refactor(daemon): split kernel.ts into focused modules (#86)

- Extract worker-pool.ts (211 LOC): sense worker fork/shutdown/restart/crash recovery
- Extract kernel-file-watch.ts (92 LOC): file change handlers for hot reload
- Extract kernel-sense-groups.ts (29 LOC): group lookup utilities
- kernel.ts reduced from 617 → 380 LOC (thin orchestrator)
- Add worker-pool.test.ts with 8 test cases
- No behavior changes, all existing tests unchanged

.cursor/rules/global.mdc

@@ -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 | ...
+```

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

@@ -0,0 +1,34 @@
+---
+description: Ban dynamic import() in production code — use static imports instead
+globs: packages/*/src/**/*.ts
+alwaysApply: true
+---
+
+# No Dynamic Import in Production Code
+
+## Rule
+
+Do NOT use `await import()` or dynamic `import()` expressions in production source code.
+Always use static top-level `import` statements.
+
+## Why
+
+- Static imports enable tree-shaking and bundler optimizations
+- They make dependencies explicit and discoverable at a glance
+- Dynamic imports of Node built-ins or project modules add unnecessary async overhead
+
+## Exceptions (must include a comment explaining why)
+
+1. **`sense-runtime.ts`** — loads user-authored sense modules whose paths are only known at runtime
+2. **`workflow-worker.ts`** — loads user-authored workflow modules whose paths are only known at runtime
+
+When suppressing, add a comment directly above:
+
+```ts
+// Dynamic import required: user module path resolved at runtime
+const mod = await import(senseIndexPath);
+```
+
+## Test Files
+
+Test files (`__tests__/**`) are exempt — dynamic import after `vi.mock()` is standard vitest practice.

.github/copilot-instructions.md

@@ -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 | ...
+```

.gitignore

@@ -2,3 +2,4 @@ node_modules
 dist
 .turbo
 *.tsbuildinfo
+*.tgz

CLAUDE.md

@@ -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 | ...
+```

README.md

@@ -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

docs/skill-publish.md

@@ -0,0 +1,80 @@
+# Skill: Publish @uncaged/nerve packages to npm
+
+## When to use
+
+When releasing a new version of any `@uncaged/nerve-*` package to npm.
+
+## Prerequisites
+
+- npm login with an account that has **owner** access to the `@uncaged` org
+- All tests pass: `pnpm -r run test`
+- Clean working tree (no uncommitted changes)
+
+## Packages
+
+| Package | Path | npm |
+|---------|------|-----|
+| `@uncaged/nerve-core` | `packages/core` | [link](https://www.npmjs.com/package/@uncaged/nerve-core) |
+| `@uncaged/nerve-daemon` | `packages/daemon` | [link](https://www.npmjs.com/package/@uncaged/nerve-daemon) |
+| `@uncaged/nerve-cli` | `packages/cli` | [link](https://www.npmjs.com/package/@uncaged/nerve-cli) |
+
+## Dependency order
+
+`core` → `daemon` → `cli`
+
+Always publish in this order. If `core` has changes, bump and publish it first, then update dependents.
+
+## Steps
+
+### 1. Ensure clean state
+
+```bash
+git checkout main && git pull origin main
+pnpm install
+pnpm -r run build
+pnpm -r run test
+```
+
+### 2. Bump versions
+
+Manually update `version` in each changed package's `package.json`.
+
+Follow semver:
+- **patch** (0.1.x): bug fixes, refactors
+- **minor** (0.x.0): new features, non-breaking API additions
+- **major** (x.0.0): breaking changes
+
+If bumping `core`, also update the `@uncaged/nerve-core` dependency version in `daemon` and `cli` package.json. Same for `daemon` → `cli`.
+
+### 3. Build
+
+```bash
+pnpm -r run build
+```
+
+### 4. Publish (in order)
+
+```bash
+# Only publish packages that have version bumps
+# MUST use pnpm publish (not npm) — pnpm converts workspace:* to real versions
+cd packages/core && pnpm publish --access public --no-git-checks
+cd packages/daemon && pnpm publish --access public --no-git-checks
+cd packages/cli && pnpm publish --access public --no-git-checks
+```
+
+### 5. Commit & tag
+
+```bash
+git add -A
+git commit -m "release: @uncaged/nerve-core@X.Y.Z, @uncaged/nerve-daemon@X.Y.Z, @uncaged/nerve-cli@X.Y.Z"
+git tag -a vX.Y.Z -m "Release vX.Y.Z"
+git push origin main --tags
+```
+
+## Pitfalls
+
+- **Don't publish without building first** — `tsup` output in `dist/` is what npm ships
+- **Dependency order matters** — if you publish `daemon` before `core`, npm may resolve the old `core` version
+- **`--access public`** is required for scoped packages on first publish; safe to always include
+- **Check `npm whoami`** to confirm you're logged in as the right account
+- **No changeset tool** — this project uses manual version bumps (no changesets/lerna)

docs/skill-setup.md

@@ -0,0 +1,101 @@
+# Skill: Setup nerve from scratch
+
+## When to use
+
+Setting up the nerve project for local development from a fresh clone.
+
+## Prerequisites
+
+- **Node.js** ≥ 18
+- **pnpm** ≥ 9 (`npm install -g pnpm`)
+- **Git** access to `git.shazhou.work`
+
+## Steps
+
+### 1. Clone
+
+```bash
+git clone https://git.shazhou.work/uncaged/nerve.git
+cd nerve
+```
+
+### 2. Install dependencies
+
+```bash
+pnpm install
+```
+
+This installs all workspace packages and links internal dependencies (`core` → `daemon` → `cli`).
+
+### 3. Build all packages
+
+```bash
+pnpm -r run build
+```
+
+Build order is handled automatically by pnpm workspace — `core` builds first, then `daemon`, then `cli`.
+
+### 4. Run tests
+
+```bash
+pnpm -r run test
+```
+
+Or test individual packages:
+
+```bash
+pnpm --filter @uncaged/nerve-core test
+pnpm --filter @uncaged/nerve-daemon test
+pnpm --filter @uncaged/nerve-cli test
+```
+
+### 5. Try the CLI
+
+```bash
+# Link the CLI globally
+cd packages/cli && npm link
+
+# Initialize a workspace
+mkdir ~/my-nerve-workspace && cd ~/my-nerve-workspace
+nerve init
+
+# Edit senses in nerve.yaml, then:
+nerve start      # start the daemon
+nerve sense list  # list registered senses
+nerve stop       # stop the daemon
+```
+
+### 6. Lint & format
+
+```bash
+pnpm run check    # biome lint check
+pnpm run format   # biome auto-format
+```
+
+## Project structure
+
+```
+nerve/
+├── packages/
+│   ├── core/       # @uncaged/nerve-core — shared types, log store, blob store
+│   ├── daemon/     # @uncaged/nerve-daemon — kernel, sense runtime, workflow manager
+│   └── cli/        # @uncaged/nerve-cli — CLI commands (init, start, stop, sense, etc.)
+├── docs/           # RFCs, conventions, skills
+├── pnpm-workspace.yaml
+└── biome.json      # linter/formatter config
+```
+
+## Key conventions
+
+- **Monorepo** with pnpm workspaces
+- **ESM only** — all packages output ESM (`"type": "module"`)
+- **tsup** for builds, **vitest** for tests, **biome** for lint/format
+- **SQLite** (better-sqlite3) for log store and blob store
+- See `docs/coding-conventions.md` for code style rules
+
+## Pitfalls
+
+- **Must build before test** — daemon and cli import compiled output from core
+- **better-sqlite3** requires native compilation — if `pnpm install` fails, ensure you have build tools (`build-essential` on Linux, Xcode CLI tools on macOS)
+- **Node 18+** required — uses native `fetch`, `crypto.randomUUID`, etc.
+- **pnpm only** — don't use npm/yarn, workspace links won't resolve correctly

package.json

@@ -1,6 +1,9 @@
 {
   "name": "nerve",
   "private": true,
+  "engines": {
+    "node": ">=22.5.0"
+  },
   "scripts": {
     "build": "pnpm -r run build",
     "check": "biome check .",
@@ -8,7 +11,7 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^1.9.0",
-    "tsup": "^8.0.0",
+    "@rslib/core": "^0.21.3",
     "typescript": "^5.5.0"
   }
 }

packages/cli/README.md

@@ -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

packages/cli/package.json

@@ -1,29 +1,32 @@
 {
   "name": "@uncaged/nerve-cli",
-  "version": "0.1.2",
+  "engines": {
+    "node": ">=22.5.0"
+  },
+  "version": "0.3.0",
   "type": "module",
   "bin": {
     "nerve": "dist/cli.js"
   },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": [
+  "files": ["dist"],
-    "dist"
-  ],
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "tsup",
+    "prepublishOnly": "bash ../../scripts/prepublish-check.sh",
+    "build": "rslib build",
     "test": "vitest run"
   },
   "dependencies": {
     "@uncaged/nerve-core": "workspace:*",
-    "citty": "^0.1.6"
+    "@uncaged/nerve-store": "workspace:*",
+    "citty": "^0.1.6",
+    "yaml": "^2.8.3"
   },
   "devDependencies": {
-    "@uncaged/nerve-daemon": "workspace:*",
+    "@rslib/core": "^0.21.3",
-    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22.0.0",
     "vitest": "^4.1.5"
   }

packages/cli/rslib.config.ts

@@ -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", "@uncaged/nerve-store"],
+  },
+});

packages/cli/src/__tests__/daemon-cli.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from "vitest";
+
+import { daemonCommand } from "../commands/daemon.js";
+import { devCommand } from "../commands/dev.js";
+import { daemonStartCommand } from "../commands/start.js";
+
+describe("nerve daemon command group", () => {
+  it("exposes start, stop, status, restart, and logs subcommands", () => {
+    const subs = daemonCommand.subCommands;
+    expect(subs).toBeDefined();
+    if (!subs) {
+      throw new Error("expected daemonCommand.subCommands");
+    }
+    expect(Object.keys(subs).sort()).toEqual(["logs", "restart", "start", "status", "stop"]);
+  });
+
+  it("shares the same start command object as top-level nerve start alias", () => {
+    const subs = daemonCommand.subCommands;
+    expect(subs?.start).toBe(daemonStartCommand);
+  });
+});
+
+describe("nerve dev", () => {
+  it("is a foreground dev command", () => {
+    expect(devCommand.meta?.name).toBe("dev");
+    expect(devCommand.meta?.description).toMatch(/foreground/i);
+  });
+});

packages/cli/src/__tests__/daemon-types.test.ts

@@ -1,47 +0,0 @@
-/**
- * Compile-time check: daemon-types.ts stays in sync with @uncaged/nerve-daemon exports.
- * If the daemon package changes its public API, this file will fail to compile.
- */
-
-import type {
-  LogEntry as DaemonLogEntry,
-  LogQuery as DaemonLogQuery,
-  LogStore as DaemonLogStore,
-  WorkflowRun as DaemonWorkflowRun,
-  WorkflowRunStatus as DaemonWorkflowRunStatus,
-} from "@uncaged/nerve-daemon";
-import { describe, it, expectTypeOf } from "vitest";
-
-import type {
-  LogEntry,
-  LogQuery,
-  LogStore,
-  WorkflowRun,
-  WorkflowRunStatus,
-} from "../daemon-types.js";
-
-describe("daemon-types drift guard", () => {
-  it("WorkflowRunStatus is assignable both ways", () => {
-    expectTypeOf<WorkflowRunStatus>().toMatchTypeOf<DaemonWorkflowRunStatus>();
-    expectTypeOf<DaemonWorkflowRunStatus>().toMatchTypeOf<WorkflowRunStatus>();
-  });
-
-  it("WorkflowRun is assignable both ways", () => {
-    expectTypeOf<WorkflowRun>().toMatchTypeOf<DaemonWorkflowRun>();
-    expectTypeOf<DaemonWorkflowRun>().toMatchTypeOf<WorkflowRun>();
-  });
-
-  it("LogEntry is assignable both ways", () => {
-    expectTypeOf<LogEntry>().toMatchTypeOf<DaemonLogEntry>();
-    expectTypeOf<DaemonLogEntry>().toMatchTypeOf<LogEntry>();
-  });
-
-  it("LogQuery is assignable both ways", () => {
-    expectTypeOf<LogQuery>().toMatchTypeOf<DaemonLogQuery>();
-    expectTypeOf<DaemonLogQuery>().toMatchTypeOf<LogQuery>();
-  });
-
-  it("LogStore has all required methods", () => {
-    expectTypeOf<LogStore>().toMatchTypeOf<Pick<DaemonLogStore, "query" | "getWorkflowRun" | "getActiveWorkflowRuns" | "getAllWorkflowRuns" | "upsertWorkflowRun" | "close">>();
-  });
-});

packages/cli/src/__tests__/logs.test.ts

@@ -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);
   });

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

@@ -0,0 +1,301 @@
+/**
+ * Tests for `nerve sense list` — formatting helpers and IPC round-trip.
+ *
+ * Covers:
+ *   - formatDuration helper
+ *   - formatSenseList output
+ *   - sensesFromConfig (static fallback from nerve.yaml)
+ *   - listSensesViaDaemon IPC round-trip via real Unix socket
+ */
+
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { createServer } from "node:net";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import type { SenseInfo } from "@uncaged/nerve-core";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import { formatDuration, formatSenseList, sensesFromConfig } from "../commands/sense.js";
+import { listSensesViaDaemon } from "../daemon-client.js";
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+const SAMPLE_SENSES: SenseInfo[] = [
+  {
+    name: "cpu-usage",
+    group: "system",
+    throttle: 5000,
+    timeout: 3000,
+    lastSignalTs: 1_700_000_000_000,
+  },
+  { name: "disk-usage", group: "system", throttle: 30000, timeout: null, lastSignalTs: null },
+  { name: "active-tasks", group: "tasks", throttle: 10000, timeout: 30000, lastSignalTs: null },
+];
+
+// ---------------------------------------------------------------------------
+// formatDuration
+// ---------------------------------------------------------------------------
+
+describe("formatDuration", () => {
+  it("returns '—' for null", () => {
+    expect(formatDuration(null)).toBe("—");
+  });
+
+  it("formats sub-minute durations as seconds", () => {
+    expect(formatDuration(0)).toBe("0s");
+    expect(formatDuration(1000)).toBe("1s");
+    expect(formatDuration(59000)).toBe("59s");
+  });
+
+  it("formats minute-range durations as Xm Ys", () => {
+    expect(formatDuration(60000)).toBe("1m 0s");
+    expect(formatDuration(90000)).toBe("1m 30s");
+    expect(formatDuration(3599000)).toBe("59m 59s");
+  });
+
+  it("formats hour-range durations as Xh Ym", () => {
+    expect(formatDuration(3600000)).toBe("1h 0m");
+    expect(formatDuration(3660000)).toBe("1h 1m");
+    expect(formatDuration(7200000)).toBe("2h 0m");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// formatSenseList
+// ---------------------------------------------------------------------------
+
+describe("formatSenseList", () => {
+  it("returns empty message when no senses", () => {
+    const output = formatSenseList([]);
+    expect(output).toContain("No senses registered");
+  });
+
+  it("shows sense count in header", () => {
+    const output = formatSenseList(SAMPLE_SENSES);
+    expect(output).toContain("3");
+  });
+
+  it("shows each sense name", () => {
+    const output = formatSenseList(SAMPLE_SENSES);
+    expect(output).toContain("cpu-usage");
+    expect(output).toContain("disk-usage");
+    expect(output).toContain("active-tasks");
+  });
+
+  it("shows group for each sense", () => {
+    const output = formatSenseList(SAMPLE_SENSES);
+    expect(output).toContain("system");
+    expect(output).toContain("tasks");
+  });
+
+  it("shows throttle and timeout durations", () => {
+    const output = formatSenseList(SAMPLE_SENSES);
+    // cpu-usage: throttle=5s, timeout=3s
+    expect(output).toContain("5s");
+    expect(output).toContain("3s");
+    // disk-usage: timeout=null → '—'
+    expect(output).toContain("—");
+  });
+
+  it("shows '(never)' when lastSignalTs is null", () => {
+    const output = formatSenseList(SAMPLE_SENSES);
+    expect(output).toContain("(never)");
+  });
+
+  it("shows ISO timestamp when lastSignalTs is set", () => {
+    const output = formatSenseList(SAMPLE_SENSES);
+    // cpu-usage has lastSignalTs = 1_700_000_000_000
+    expect(output).toContain(new Date(1_700_000_000_000).toISOString());
+  });
+});
+
+// ---------------------------------------------------------------------------
+// sensesFromConfig — static fallback from nerve.yaml
+// ---------------------------------------------------------------------------
+
+describe("sensesFromConfig", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), "nerve-sense-list-test-"));
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("returns empty array when file does not exist", () => {
+    const result = sensesFromConfig(join(tmpDir, "nonexistent.yaml"));
+    expect(result).toEqual([]);
+  });
+
+  it("returns empty array when file has invalid YAML", () => {
+    const path = join(tmpDir, "nerve.yaml");
+    writeFileSync(path, "not: valid: yaml: :::");
+    const result = sensesFromConfig(path);
+    expect(result).toEqual([]);
+  });
+
+  it("parses senses from valid nerve.yaml", () => {
+    const path = join(tmpDir, "nerve.yaml");
+    writeFileSync(
+      path,
+      `
+senses:
+  cpu-usage:
+    group: system
+    throttle: 5s
+    timeout: 3s
+  disk-usage:
+    group: system
+    throttle: 30s
+reflexes: []
+`.trim(),
+    );
+    const result = sensesFromConfig(path);
+    expect(result).toHaveLength(2);
+    expect(result[0]).toMatchObject({ name: "cpu-usage", group: "system", lastSignalTs: null });
+    expect(result[1]).toMatchObject({ name: "disk-usage", group: "system", lastSignalTs: null });
+  });
+
+  it("always sets lastSignalTs to null (static fallback)", () => {
+    const path = join(tmpDir, "nerve.yaml");
+    writeFileSync(
+      path,
+      `
+senses:
+  my-sense:
+    group: default
+reflexes: []
+`.trim(),
+    );
+    const result = sensesFromConfig(path);
+    expect(result[0].lastSignalTs).toBeNull();
+  });
+
+  it("populates throttle and timeout from config", () => {
+    const path = join(tmpDir, "nerve.yaml");
+    writeFileSync(
+      path,
+      `
+senses:
+  my-sense:
+    group: default
+    throttle: 10s
+    timeout: 5s
+reflexes: []
+`.trim(),
+    );
+    const result = sensesFromConfig(path);
+    expect(result[0].throttle).toBe(10000);
+    expect(result[0].timeout).toBe(5000);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// listSensesViaDaemon — IPC round-trip via real Unix socket
+// ---------------------------------------------------------------------------
+
+describe("listSensesViaDaemon", () => {
+  let sockDir: string;
+  let sockPath: string;
+
+  beforeEach(() => {
+    sockDir = mkdtempSync(join(tmpdir(), "nerve-sense-list-ipc-"));
+    sockPath = join(sockDir, "nerve.sock");
+  });
+
+  afterEach(() => {
+    rmSync(sockDir, { recursive: true, force: true });
+  });
+
+  it("resolves with { ok: true, senses: [] } when daemon returns empty list", async () => {
+    const server = createServer((s) => {
+      s.on("data", (chunk: Buffer) => {
+        const line = chunk.toString("utf8").trim();
+        try {
+          const req = JSON.parse(line) as { type: string };
+          if (req.type === "list-senses") {
+            s.write(`${JSON.stringify({ ok: true, senses: [] })}\n`);
+          }
+        } catch {
+          // ignore
+        }
+      });
+    });
+    await new Promise<void>((r) => server.listen(sockPath, r));
+
+    try {
+      const result = await listSensesViaDaemon(sockPath);
+      expect(result).toEqual({ ok: true, senses: [] });
+    } finally {
+      await new Promise<void>((r) => server.close(() => r()));
+    }
+  });
+
+  it("resolves with populated senses array", async () => {
+    const senses: SenseInfo[] = [
+      { name: "cpu-usage", group: "system", throttle: 5000, timeout: 3000, lastSignalTs: 12345 },
+    ];
+    const server = createServer((s) => {
+      s.on("data", () => {
+        s.write(`${JSON.stringify({ ok: true, senses })}\n`);
+      });
+    });
+    await new Promise<void>((r) => server.listen(sockPath, r));
+
+    try {
+      const result = await listSensesViaDaemon(sockPath);
+      expect(result).toEqual({ ok: true, senses });
+    } finally {
+      await new Promise<void>((r) => server.close(() => r()));
+    }
+  });
+
+  it("resolves with { ok: false, error } when daemon returns an error", async () => {
+    const server = createServer((s) => {
+      s.on("data", () => {
+        s.write(`${JSON.stringify({ ok: false, error: "something went wrong" })}\n`);
+      });
+    });
+    await new Promise<void>((r) => server.listen(sockPath, r));
+
+    try {
+      const result = await listSensesViaDaemon(sockPath);
+      expect(result).toEqual({ ok: false, error: "something went wrong" });
+    } finally {
+      await new Promise<void>((r) => server.close(() => r()));
+    }
+  });
+
+  it("rejects when no daemon is listening on the socket", async () => {
+    await expect(listSensesViaDaemon(sockPath)).rejects.toThrow(/Cannot connect to daemon/);
+  });
+
+  it("sends a list-senses IPC message to the daemon", async () => {
+    const received: unknown[] = [];
+    const server = createServer((s) => {
+      s.on("data", (chunk: Buffer) => {
+        const line = chunk.toString("utf8").trim();
+        try {
+          received.push(JSON.parse(line));
+        } catch {
+          // ignore
+        }
+        s.write(`${JSON.stringify({ ok: true, senses: [] })}\n`);
+      });
+    });
+    await new Promise<void>((r) => server.listen(sockPath, r));
+
+    try {
+      await listSensesViaDaemon(sockPath);
+      expect(received).toHaveLength(1);
+      expect(received[0]).toMatchObject({ type: "list-senses" });
+    } finally {
+      await new Promise<void>((r) => server.close(() => r()));
+    }
+  });
+});

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

@@ -0,0 +1,159 @@
+/**
+ * Tests for sense SQLite helpers used by `nerve sense schema` / `nerve sense query`.
+ */
+
+import { mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import {
+  assertSenseDbExists,
+  collectColumnKeys,
+  defaultPreviewSql,
+  formatRowsAsAlignedTable,
+  listTableSqlStatements,
+  parseSenseQueryArgs,
+  pickDefaultPreviewTable,
+  senseDbPath,
+} from "../sense-sqlite.js";
+
+let tmpDir: string;
+
+beforeEach(() => {
+  tmpDir = join(
+    tmpdir(),
+    `nerve-sense-sqlite-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+  );
+  mkdirSync(join(tmpDir, "data", "senses"), { recursive: true });
+});
+
+afterEach(() => {
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe("senseDbPath", () => {
+  it("points at data/senses/<name>.db under the given root", () => {
+    expect(senseDbPath("/root", "cpu-usage")).toBe(join("/root", "data", "senses", "cpu-usage.db"));
+  });
+});
+
+describe("assertSenseDbExists", () => {
+  it("throws when the file is missing", () => {
+    expect(() => assertSenseDbExists(tmpDir, "nope")).toThrow(/No database at/);
+  });
+
+  it("returns the path when the file exists", () => {
+    const p = join(tmpDir, "data", "senses", "x.db");
+    new DatabaseSync(p).close();
+    expect(assertSenseDbExists(tmpDir, "x")).toBe(p);
+  });
+});
+
+describe("listTableSqlStatements", () => {
+  it("returns CREATE statements ordered by tbl_name", () => {
+    const p = join(tmpDir, "data", "senses", "t.db");
+    const db = new DatabaseSync(p);
+    db.exec("CREATE TABLE zebra (id INTEGER)");
+    db.exec("CREATE TABLE alpha (id INTEGER)");
+    const stmts = listTableSqlStatements(db);
+    db.close();
+    expect(stmts).toHaveLength(2);
+    expect(stmts[0]).toMatch(/^CREATE TABLE alpha/i);
+    expect(stmts[1]).toMatch(/^CREATE TABLE zebra/i);
+  });
+});
+
+describe("pickDefaultPreviewTable", () => {
+  it("prefers non-_migrations tables when both exist", () => {
+    const p = join(tmpDir, "data", "senses", "t.db");
+    const db = new DatabaseSync(p);
+    db.exec("CREATE TABLE _migrations (name TEXT PRIMARY KEY)");
+    db.exec("CREATE TABLE readings (id INTEGER)");
+    expect(pickDefaultPreviewTable(db)).toBe("readings");
+    db.close();
+  });
+
+  it("uses _migrations when it is the only table", () => {
+    const p = join(tmpDir, "data", "senses", "t.db");
+    const db = new DatabaseSync(p);
+    db.exec("CREATE TABLE _migrations (name TEXT PRIMARY KEY)");
+    expect(pickDefaultPreviewTable(db)).toBe("_migrations");
+    db.close();
+  });
+});
+
+describe("defaultPreviewSql", () => {
+  it("quotes identifiers for SQL safety", () => {
+    expect(defaultPreviewSql(`weird"name`)).toContain(`weird""name`);
+  });
+});
+
+describe("parseSenseQueryArgs", () => {
+  it("parses sense name only", () => {
+    expect(parseSenseQueryArgs(["cpu"])).toEqual({ name: "cpu", sql: undefined });
+  });
+
+  it("strips --json", () => {
+    expect(parseSenseQueryArgs(["cpu", "--json"])).toEqual({ name: "cpu", sql: undefined });
+    expect(parseSenseQueryArgs(["--json", "cpu"])).toEqual({ name: "cpu", sql: undefined });
+  });
+
+  it("joins remaining tokens into SQL", () => {
+    expect(parseSenseQueryArgs(["cpu", "SELECT", "1"])).toEqual({ name: "cpu", sql: "SELECT 1" });
+  });
+
+  it("throws when name is missing", () => {
+    expect(() => parseSenseQueryArgs(["--json"])).toThrow(/Missing sense name/);
+  });
+});
+
+describe("formatRowsAsAlignedTable", () => {
+  it("shows empty marker for no rows", () => {
+    expect(formatRowsAsAlignedTable([])).toContain("(0 rows)");
+  });
+
+  it("aligns columns from row data", () => {
+    const out = formatRowsAsAlignedTable([
+      { a: 1, b: "x" },
+      { a: 22, b: "yy" },
+    ]);
+    expect(out).toContain("a");
+    expect(out).toContain("b");
+    expect(out).toContain("22");
+  });
+});
+
+describe("collectColumnKeys", () => {
+  it("preserves key order from first row then appends new keys", () => {
+    expect(
+      collectColumnKeys([
+        { z: 1, a: 2 },
+        { a: 3, b: 4 },
+      ]),
+    ).toEqual(["z", "a", "b"]);
+  });
+});
+
+describe("readonly query integration", () => {
+  it("runs default preview SQL on a real db", () => {
+    const p = join(tmpDir, "data", "senses", "demo.db");
+    const rw = new DatabaseSync(p);
+    rw.exec("CREATE TABLE items (id INTEGER PRIMARY KEY, v TEXT)");
+    rw.exec("INSERT INTO items (v) VALUES ('a'), ('b')");
+    rw.close();
+
+    const db = new DatabaseSync(p, { readOnly: true });
+    const table = pickDefaultPreviewTable(db);
+    expect(table).toBe("items");
+    if (table === null) {
+      throw new Error("expected items table");
+    }
+    const sql = defaultPreviewSql(table);
+    const rows = db.prepare(sql).all() as Record<string, unknown>[];
+    db.close();
+    expect(rows.length).toBeGreaterThanOrEqual(1);
+  });
+});

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

@@ -0,0 +1,110 @@
+/**
+ * Tests for the sense CLI helper — triggerSenseViaDaemon IPC round-trip.
+ *
+ * Uses a real Unix socket server to validate the full client/server
+ * protocol without requiring a running daemon process.
+ */
+
+import { mkdtempSync, rmSync } from "node:fs";
+import { createServer } from "node:net";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import { triggerSenseViaDaemon } from "../daemon-client.js";
+
+// ---------------------------------------------------------------------------
+// Test setup
+// ---------------------------------------------------------------------------
+
+let sockDir: string;
+let sockPath: string;
+
+beforeEach(() => {
+  sockDir = mkdtempSync(join(tmpdir(), "nerve-sense-test-"));
+  sockPath = join(sockDir, "nerve.sock");
+});
+
+afterEach(() => {
+  rmSync(sockDir, { recursive: true, force: true });
+});
+
+// ---------------------------------------------------------------------------
+// triggerSenseViaDaemon — IPC round-trip via real Unix socket
+// ---------------------------------------------------------------------------
+
+describe("triggerSenseViaDaemon", () => {
+  it("resolves { ok: true } when daemon responds ok", async () => {
+    const received: unknown[] = [];
+
+    const server = createServer((s) => {
+      s.on("data", (chunk: Buffer) => {
+        const line = chunk.toString("utf8").trim();
+        try {
+          received.push(JSON.parse(line));
+        } catch {
+          // ignore
+        }
+        s.write(`${JSON.stringify({ ok: true })}\n`);
+      });
+    });
+    await new Promise<void>((r) => server.listen(sockPath, r));
+
+    try {
+      const result = await triggerSenseViaDaemon(sockPath, "cpu-usage");
+      expect(result).toEqual({ ok: true });
+      // Verify the correct IPC message was sent
+      expect(received).toHaveLength(1);
+      expect(received[0]).toMatchObject({ type: "trigger-sense", sense: "cpu-usage" });
+    } finally {
+      await new Promise<void>((r) => server.close(() => r()));
+    }
+  });
+
+  it("resolves { ok: false, error } when daemon rejects the sense", async () => {
+    const server = createServer((s) => {
+      s.on("data", () => {
+        s.write(`${JSON.stringify({ ok: false, error: 'Unknown sense: "no-such-sense"' })}\n`);
+      });
+    });
+    await new Promise<void>((r) => server.listen(sockPath, r));
+
+    try {
+      const result = await triggerSenseViaDaemon(sockPath, "no-such-sense");
+      expect(result).toEqual({ ok: false, error: 'Unknown sense: "no-such-sense"' });
+    } finally {
+      await new Promise<void>((r) => server.close(() => r()));
+    }
+  });
+
+  it("rejects when no daemon is listening on the socket", async () => {
+    await expect(triggerSenseViaDaemon(sockPath, "cpu-usage")).rejects.toThrow(
+      /Cannot connect to daemon/,
+    );
+  });
+
+  it("sends the sense name exactly as provided", async () => {
+    const received: unknown[] = [];
+
+    const server = createServer((s) => {
+      s.on("data", (chunk: Buffer) => {
+        const line = chunk.toString("utf8").trim();
+        try {
+          received.push(JSON.parse(line));
+        } catch {
+          // ignore
+        }
+        s.write(`${JSON.stringify({ ok: true })}\n`);
+      });
+    });
+    await new Promise<void>((r) => server.listen(sockPath, r));
+
+    try {
+      await triggerSenseViaDaemon(sockPath, "my-custom-sense");
+      expect(received[0]).toMatchObject({ sense: "my-custom-sense" });
+    } finally {
+      await new Promise<void>((r) => server.close(() => r()));
+    }
+  });
+});

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

@@ -12,19 +12,23 @@ import { createServer } from "node:net";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-import { createLogStore } from "@uncaged/nerve-daemon";
+import { createLogStore } from "@uncaged/nerve-store";
 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 "@uncaged/nerve-store";
 
 // ---------------------------------------------------------------------------
 // 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
 // ---------------------------------------------------------------------------

packages/cli/src/cli.ts

@@ -1,14 +1,37 @@
 import { defineCommand, runMain } from "citty";
 
+import { daemonCommand } from "./commands/daemon.js";
+import { devCommand } from "./commands/dev.js";
 import { initCommand } from "./commands/init.js";
 import { logsCommand } from "./commands/logs.js";
 import { senseCommand } from "./commands/sense.js";
-import { startCommand } from "./commands/start.js";
+import { daemonStartCommand } from "./commands/start.js";
 import { statusCommand } from "./commands/status.js";
 import { stopCommand } from "./commands/stop.js";
+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",
@@ -16,14 +39,17 @@ const main = defineCommand({
   },
   subCommands: {
     init: initCommand,
-    start: startCommand,
+    daemon: daemonCommand,
+    dev: devCommand,
+    start: daemonStartCommand,
     stop: stopCommand,
     status: statusCommand,
     logs: logsCommand,
     validate: validateCommand,
     sense: senseCommand,
+    store: storeCommand,
     workflow: workflowCommand,
   },
 });
 
-runMain(main);
+runMain(main, { rawArgs: normalizeNerveArgv(process.argv.slice(2)) });

packages/cli/src/commands/daemon.ts

@@ -0,0 +1,31 @@
+import { defineCommand } from "citty";
+
+import { logsCommand } from "./logs.js";
+import { daemonStartCommand, runDaemonStartCommand } from "./start.js";
+import { statusCommand } from "./status.js";
+import { runStopCommand, stopCommand } from "./stop.js";
+
+const daemonRestartCommand = defineCommand({
+  meta: {
+    name: "restart",
+    description: "Stop then start the nerve daemon",
+  },
+  async run() {
+    await runStopCommand();
+    await runDaemonStartCommand();
+  },
+});
+
+export const daemonCommand = defineCommand({
+  meta: {
+    name: "daemon",
+    description: "Manage the nerve background daemon",
+  },
+  subCommands: {
+    start: daemonStartCommand,
+    stop: stopCommand,
+    status: statusCommand,
+    restart: daemonRestartCommand,
+    logs: logsCommand,
+  },
+});

packages/cli/src/commands/dev.ts

@@ -0,0 +1,17 @@
+import { defineCommand } from "citty";
+
+import { runForegroundKernelSession } from "../run-foreground-kernel.js";
+import { loadDaemonModule } from "../workspace-daemon.js";
+import { getNerveRoot } from "../workspace.js";
+
+export const devCommand = defineCommand({
+  meta: {
+    name: "dev",
+    description: "Run the nerve kernel in the foreground (development mode)",
+  },
+  async run() {
+    const nerveRoot = getNerveRoot();
+    const { createKernel } = await loadDaemonModule(nerveRoot);
+    await runForegroundKernelSession(nerveRoot, createKernel);
+  },
+});

packages/cli/src/commands/init.ts

@@ -1,5 +1,7 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { execFile, spawn } from "node:child_process";
+import { existsSync, mkdirSync, readdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { promisify } from "node:util";
 
 import { defineCommand } from "citty";
 
@@ -33,7 +35,7 @@ const PACKAGE_JSON = `{
     "drizzle-kit": "latest"
   },
   "pnpm": {
-    "onlyBuiltDependencies": ["better-sqlite3", "esbuild"]
+    "onlyBuiltDependencies": ["esbuild"]
   }
 }
 `;
@@ -42,6 +44,8 @@ const GITIGNORE = `data/
 node_modules/
 `;
 
+const execFileAsync = promisify(execFile);
+
 const CPU_SCHEMA_TS = `import { integer, real, sqliteTable, text } from "drizzle-orm/sqlite-core";
 
 export const cpuUsage = sqliteTable("cpu_usage", {
@@ -90,7 +94,6 @@ function writeFile(filePath: string, content: string): void {
 }
 
 async function runCommand(cmd: string, args: string[], cwd: string): Promise<void> {
-  const { spawn } = await import("node:child_process");
   await new Promise<void>((resolve, reject) => {
     const child = spawn(cmd, args, { cwd, stdio: "inherit" });
     child.on("close", (code) => {
@@ -102,10 +105,6 @@ async function runCommand(cmd: string, args: string[], cwd: string): Promise<voi
 }
 
 async function detectPackageManager(): Promise<{ cmd: string; installArgs: string[] }> {
-  const { execFile } = await import("node:child_process");
-  const { promisify } = await import("node:util");
-  const execFileAsync = promisify(execFile);
-
   for (const pm of ["pnpm", "yarn", "npm"]) {
     try {
       await execFileAsync(pm, ["--version"]);
@@ -219,23 +218,94 @@ const initWorkspaceCommand = defineCommand({
   },
 });
 
-async function tryRequireSqlite(nerveRoot: string): Promise<boolean> {
+/** Verify built-in `node:sqlite` (Node.js ≥22.5) loads in a child process. */
+async function verifyNodeSqlite(): Promise<boolean> {
   try {
-    const modulePath = join(nerveRoot, "node_modules", "better-sqlite3");
+    await execFileAsync(
-    // Use a child process to test if the native module loads
+      "node",
-    const { execFile } = await import("node:child_process");
+      [
-    const { promisify } = await import("node:util");
+        "--input-type=module",
-    const execFileAsync = promisify(execFile);
+        "-e",
-    await execFileAsync("node", ["-e", `require(${JSON.stringify(modulePath)})`], {
+        "import { DatabaseSync } from 'node:sqlite'; new DatabaseSync(':memory:').exec('SELECT 1');",
-      cwd: nerveRoot,
+      ],
-      timeout: 10_000,
+      { timeout: 10_000 },
-    });
+    );
     return true;
   } catch {
     return false;
   }
 }
 
+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();
 
@@ -268,27 +338,11 @@ async function runInitWorkspace(force: boolean): Promise<void> {
     );
   }
 
-  // Verify better-sqlite3 native module — rebuild up to 2 times if broken
+  if (!(await verifyNodeSqlite())) {
-  const sqlitePath = join(nerveRoot, "node_modules", "better-sqlite3");
+    process.stdout.write(
-  if (existsSync(sqlitePath)) {
+      "⚠️ Built-in SQLite (node:sqlite) is not available in this Node.js build. " +
-    for (let attempt = 1; attempt <= 2; attempt++) {
+        "The daemon requires Node.js 22.5 or newer with SQLite enabled.\n",
-      if (await tryRequireSqlite(nerveRoot)) break;
+    );
-      process.stdout.write(
-        `${attempt === 1 ? "Building" : "Retrying build of"} native module better-sqlite3 (attempt ${attempt}/2)…\n`,
-      );
-      try {
-        await runCommand(cmd, ["rebuild", "better-sqlite3"], nerveRoot);
-      } catch {
-        // will be caught by the verify below
-      }
-    }
-    if (!(await tryRequireSqlite(nerveRoot))) {
-      process.stdout.write(
-        `⚠️ better-sqlite3 native module is not working. The daemon will fail to start.\n` +
-          `   Fix: cd ${nerveRoot} && ${cmd} rebuild better-sqlite3\n` +
-          `   Or:  npm install --build-from-source better-sqlite3\n`,
-      );
-    }
   }
 
   if (!existsSync(join(nerveRoot, ".git"))) {
@@ -310,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: {
@@ -318,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);
   },
 });

packages/cli/src/commands/sense.ts

@@ -1,7 +1,112 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+
+import { type SenseInfo, parseNerveConfig } from "@uncaged/nerve-core";
 import { defineCommand } from "citty";
 
-import { triggerSenseViaDaemon } from "../daemon-client.js";
+import { listSensesViaDaemon, triggerSenseViaDaemon } from "../daemon-client.js";
-import { getSocketPath, isRunning } from "../workspace.js";
+import {
+  assertSenseDbExists,
+  defaultPreviewSql,
+  formatRowsAsAlignedTable,
+  listTableSqlStatements,
+  openSenseDb,
+  parseSenseQueryArgs,
+  pickDefaultPreviewTable,
+} from "../sense-sqlite.js";
+import { getNerveRoot, getSocketPath, isRunning } from "../workspace.js";
+
+// ---------------------------------------------------------------------------
+// Formatting helpers (exported for tests)
+// ---------------------------------------------------------------------------
+
+export function formatDuration(ms: number | null): string {
+  if (ms === null) return "—";
+  const totalSeconds = Math.floor(ms / 1000);
+  if (totalSeconds < 60) return `${totalSeconds}s`;
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (minutes < 60) return `${minutes}m ${seconds}s`;
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  return `${hours}h ${remainingMinutes}m`;
+}
+
+export function formatSenseList(senses: SenseInfo[]): string {
+  if (senses.length === 0) {
+    return "📭 No senses registered in nerve.yaml.\n";
+  }
+
+  const lines: string[] = [`📡 Registered senses (${senses.length}):\n`];
+  for (const s of senses) {
+    lines.push(`\n  ${s.name}\n`);
+    lines.push(`    group:    ${s.group}\n`);
+    lines.push(`    throttle: ${formatDuration(s.throttle)}\n`);
+    lines.push(`    timeout:  ${formatDuration(s.timeout)}\n`);
+    const lastSignal = s.lastSignalTs !== null ? new Date(s.lastSignalTs).toISOString() : "(never)";
+    lines.push(`    last signal: ${lastSignal}\n`);
+  }
+  return lines.join("");
+}
+
+/** Build a SenseInfo list from nerve.yaml when daemon is not running. */
+export function sensesFromConfig(configPath: string): SenseInfo[] {
+  let raw: string;
+  try {
+    raw = readFileSync(configPath, "utf8");
+  } catch {
+    return [];
+  }
+  const result = parseNerveConfig(raw);
+  if (!result.ok) return [];
+  return Object.entries(result.value.senses).map(([name, cfg]) => ({
+    name,
+    group: cfg.group,
+    throttle: cfg.throttle,
+    timeout: cfg.timeout,
+    lastSignalTs: null,
+  }));
+}
+
+// ---------------------------------------------------------------------------
+// nerve sense list
+// ---------------------------------------------------------------------------
+
+const senseListCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "List all registered senses and their status",
+  },
+  async run() {
+    if (!isRunning()) {
+      process.stderr.write(
+        "⚠️  Daemon is not running — showing static config only (no last signal time).\n\n",
+      );
+      const configPath = join(getNerveRoot(), "nerve.yaml");
+      const senses = sensesFromConfig(configPath);
+      process.stdout.write(formatSenseList(senses));
+      return;
+    }
+
+    const socketPath = getSocketPath();
+    let response: { ok: true; senses: SenseInfo[] } | { ok: false; error: string };
+    try {
+      response = await listSensesViaDaemon(socketPath);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      process.stderr.write(`❌ Failed to contact daemon: ${msg}\n`);
+      process.exit(1);
+    }
+
+    if (!response.ok) {
+      process.stderr.write(`❌ Daemon error: ${response.error}\n`);
+      process.exit(1);
+    }
+
+    process.stdout.write(formatSenseList(response.senses));
+  },
+});
 
 // ---------------------------------------------------------------------------
 // nerve sense trigger <name>
@@ -43,6 +148,115 @@ const senseTriggerCommand = defineCommand({
   },
 });
 
+// ---------------------------------------------------------------------------
+// nerve sense schema <name>
+// ---------------------------------------------------------------------------
+
+const senseSchemaCommand = defineCommand({
+  meta: {
+    name: "schema",
+    description: "Print CREATE TABLE statements from a sense SQLite database",
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Sense name (data/senses/<name>.db under the nerve workspace)",
+    },
+    json: {
+      type: "boolean",
+      description: "Print JSON array of CREATE TABLE SQL strings",
+      default: false,
+    },
+  },
+  async run({ args }) {
+    const nerveRoot = getNerveRoot();
+    let db: DatabaseSync | undefined;
+    try {
+      db = openSenseDb(nerveRoot, args.name);
+      const statements = listTableSqlStatements(db);
+      if (args.json) {
+        process.stdout.write(`${JSON.stringify(statements, null, 2)}\n`);
+      } else if (statements.length === 0) {
+        process.stdout.write("(no tables)\n");
+      } else {
+        for (const sql of statements) {
+          process.stdout.write(`${sql};\n\n`);
+        }
+      }
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      process.stderr.write(`❌ ${msg}\n`);
+      process.exit(1);
+    } finally {
+      db?.close();
+    }
+  },
+});
+
+// ---------------------------------------------------------------------------
+// nerve sense query <name> [sql...]
+// ---------------------------------------------------------------------------
+
+const senseQueryCommand = defineCommand({
+  meta: {
+    name: "query",
+    description:
+      "Run a read-only SQL query against a sense database (default: last 10 rows of the first data table). Pass optional SQL after the sense name; multiple words are joined.",
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Sense name (data/senses/<name>.db under the nerve workspace)",
+    },
+    json: {
+      type: "boolean",
+      description: "Print result rows as JSON",
+      default: false,
+    },
+  },
+  async run({ args, rawArgs }) {
+    const nerveRoot = getNerveRoot();
+    let db: DatabaseSync | undefined;
+    try {
+      let parsed: { name: string; sql: string | undefined };
+      try {
+        parsed = parseSenseQueryArgs(rawArgs);
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        process.stderr.write(`❌ ${msg}\n`);
+        process.exit(1);
+      }
+
+      db = openSenseDb(nerveRoot, args.name);
+
+      let sql = parsed.sql?.trim();
+      if (!sql) {
+        const table = pickDefaultPreviewTable(db);
+        if (table === null) {
+          process.stderr.write("❌ No tables found in database.\n");
+          process.exit(1);
+        } else {
+          sql = defaultPreviewSql(table);
+        }
+      }
+
+      const rows = db.prepare(sql).all() as Record<string, unknown>[];
+
+      if (args.json) {
+        process.stdout.write(`${JSON.stringify(rows, null, 2)}\n`);
+      } else {
+        process.stdout.write(formatRowsAsAlignedTable(rows));
+      }
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      process.stderr.write(`❌ ${msg}\n`);
+      process.exit(1);
+    } finally {
+      db?.close();
+    }
+  },
+});
+
 // ---------------------------------------------------------------------------
 // nerve sense (parent command)
 // ---------------------------------------------------------------------------
@@ -53,6 +267,9 @@ export const senseCommand = defineCommand({
     description: "Interact with sense computes",
   },
   subCommands: {
+    list: senseListCommand,
     trigger: senseTriggerCommand,
+    schema: senseSchemaCommand,
+    query: senseQueryCommand,
   },
 });

packages/cli/src/commands/start.ts

@@ -1,3 +1,4 @@
+import { spawn } from "node:child_process";
 import { createWriteStream, existsSync } from "node:fs";
 import { mkdir } from "node:fs/promises";
 import { dirname, join } from "node:path";
@@ -5,11 +6,10 @@ import { fileURLToPath } from "node:url";
 
 import { defineCommand } from "citty";
 
-import { runForegroundKernelSession } from "../run-foreground-kernel.js";
-import { loadDaemonModule } from "../workspace-daemon.js";
 import {
   getLogPath,
   getNerveRoot,
+  getSocketPath,
   isRunning,
   readPidFile,
   removePidFile,
@@ -52,15 +52,10 @@ function daemonBootstrapScript(): string {
     return bootstrapJs;
   }
   throw new Error(
-    `daemon-bootstrap.js not found next to CLI at ${bootstrapJs}. Build the CLI package (e.g. \`pnpm --filter @uncaged/nerve-cli build\`) before using background mode (\`nerve start -d\`).`,
+    `daemon-bootstrap.js not found next to CLI at ${bootstrapJs}. Build the CLI package (e.g. \`pnpm --filter @uncaged/nerve-cli build\`) before using \`nerve daemon start\`.`,
   );
 }
 
-async function runForeground(nerveRoot: string): Promise<void> {
-  const { createKernel } = await loadDaemonModule(nerveRoot);
-  await runForegroundKernelSession(nerveRoot, createKernel);
-}
-
 async function runDaemon(nerveRoot: string): Promise<void> {
   if (isRunning()) {
     const pid = readPidFile();
@@ -71,7 +66,6 @@ async function runDaemon(nerveRoot: string): Promise<void> {
   const logPath = getLogPath();
   await mkdir(join(nerveRoot, "logs"), { recursive: true });
 
-  const { spawn } = await import("node:child_process");
   const logStream = createWriteStream(logPath, { flags: "a" });
   await new Promise<void>((resolve) => {
     if (logStream.pending) logStream.once("open", () => resolve());
@@ -82,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,
   });
@@ -97,7 +91,6 @@ async function runDaemon(nerveRoot: string): Promise<void> {
 
   writePidFile(pid);
 
-  const { getSocketPath } = await import("../workspace.js");
   const ready = await waitForSocket(getSocketPath(), 5000);
 
   if (!ready || !isRunning()) {
@@ -110,29 +103,20 @@ async function runDaemon(nerveRoot: string): Promise<void> {
 
   process.stdout.write(`✅ Nerve daemon started (pid ${pid}).\n`);
   process.stdout.write(`   Logs: ${logPath}\n`);
-  process.stdout.write("   Run `nerve stop` to stop.\n");
+  process.stdout.write("   Run `nerve daemon stop` (or `nerve stop`) to stop.\n");
 }
 
-export const startCommand = defineCommand({
+/** Background daemon only — use `nerve dev` for foreground mode. */
+export async function runDaemonStartCommand(): Promise<void> {
+  await runDaemon(getNerveRoot());
+}
+
+export const daemonStartCommand = defineCommand({
   meta: {
     name: "start",
-    description: "Start the nerve daemon",
+    description: "Start the nerve daemon in the background",
   },
-  args: {
+  async run() {
-    daemon: {
+    await runDaemonStartCommand();
-      type: "boolean",
-      alias: "d",
-      description: "Run as background daemon",
-      default: false,
-    },
-  },
-  async run({ args }) {
-    const nerveRoot = getNerveRoot();
-
-    if (args.daemon) {
-      await runDaemon(nerveRoot);
-    } else {
-      await runForeground(nerveRoot);
-    }
   },
 });

packages/cli/src/commands/stop.ts

@@ -15,44 +15,49 @@ async function waitForExit(pid: number, timeoutMs: number): Promise<boolean> {
   return false;
 }
 
+/** Core stop logic — also used by `nerve daemon restart`. */
+export async function runStopCommand(): Promise<void> {
+  const pid = readPidFile();
+  if (pid === null) {
+    process.stdout.write("⚠️ No PID file found — daemon may not be running.\n");
+    return;
+  }
+
+  if (!isRunning()) {
+    process.stdout.write("⚠️ Daemon is not running (stale PID file). Cleaning up.\n");
+    removePidFile();
+    return;
+  }
+
+  process.stdout.write(`Stopping nerve daemon (pid ${pid})…\n`);
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    process.stderr.write(`❌ Failed to send SIGTERM: ${msg}\n`);
+    process.exit(1);
+  }
+
+  const graceful = await waitForExit(pid, 10_000);
+  if (!graceful) {
+    process.stdout.write("⚠️ Daemon did not exit in 10s — sending SIGKILL.\n");
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+      // already dead
+    }
+  }
+
+  removePidFile();
+  process.stdout.write("✅ Daemon stopped.\n");
+}
+
 export const stopCommand = defineCommand({
   meta: {
     name: "stop",
     description: "Stop the nerve daemon",
   },
   async run() {
-    const pid = readPidFile();
+    await runStopCommand();
-    if (pid === null) {
-      process.stdout.write("⚠️ No PID file found — daemon may not be running.\n");
-      return;
-    }
-
-    if (!isRunning()) {
-      process.stdout.write("⚠️ Daemon is not running (stale PID file). Cleaning up.\n");
-      removePidFile();
-      return;
-    }
-
-    process.stdout.write(`Stopping nerve daemon (pid ${pid})…\n`);
-    try {
-      process.kill(pid, "SIGTERM");
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      process.stderr.write(`❌ Failed to send SIGTERM: ${msg}\n`);
-      process.exit(1);
-    }
-
-    const graceful = await waitForExit(pid, 10_000);
-    if (!graceful) {
-      process.stdout.write("⚠️ Daemon did not exit in 10s — sending SIGKILL.\n");
-      try {
-        process.kill(pid, "SIGKILL");
-      } catch {
-        // already dead
-      }
-    }
-
-    removePidFile();
-    process.stdout.write("✅ Daemon stopped.\n");
   },
 });

packages/cli/src/commands/store.ts

@@ -0,0 +1,70 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+import { defineCommand } from "citty";
+
+import { loadDaemonModule } from "../workspace-daemon.js";
+import { getNerveRoot } from "../workspace.js";
+
+// ---------------------------------------------------------------------------
+// nerve store archive
+// ---------------------------------------------------------------------------
+
+const storeArchiveCommand = defineCommand({
+  meta: {
+    name: "archive",
+    description:
+      "Export logs older than 30 days from logs.db to data/archive/logs/YYYY-MM-DD.jsonl and delete those rows (RFC-001 §5.4)",
+  },
+  args: {
+    vacuum: {
+      type: "boolean",
+      description: "Run SQLite VACUUM after archiving",
+      default: false,
+    },
+  },
+  async run({ args }) {
+    const nerveRoot = getNerveRoot();
+    const dbPath = join(nerveRoot, "data", "logs.db");
+    if (!existsSync(dbPath)) {
+      process.stderr.write("❌ No data/logs.db found — start the daemon at least once.\n");
+      process.exit(1);
+    }
+
+    const { createLogStore } = await loadDaemonModule(nerveRoot);
+    const store = createLogStore(dbPath);
+
+    try {
+      const result = store.archiveLogs({ vacuum: args.vacuum });
+      if (result.days.length === 0) {
+        process.stdout.write(
+          "✅ Nothing to archive (no eligible UTC days beyond the 30-day window).\n",
+        );
+      } else {
+        process.stdout.write(`✅ Archived ${result.days.length} day(s):\n`);
+        for (const d of result.days) {
+          process.stdout.write(`   ${d.day}  rows=${d.rowCount}  ${d.filePath}\n`);
+        }
+      }
+      if (result.vacuumed) {
+        process.stdout.write("   VACUUM completed.\n");
+      }
+    } finally {
+      store.close();
+    }
+  },
+});
+
+// ---------------------------------------------------------------------------
+// nerve store
+// ---------------------------------------------------------------------------
+
+export const storeCommand = defineCommand({
+  meta: {
+    name: "store",
+    description: "Maintain local Nerve SQLite stores (log cold-archive, …)",
+  },
+  subCommands: {
+    archive: storeArchiveCommand,
+  },
+});

packages/cli/src/commands/workflow.ts

@@ -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 "@uncaged/nerve-store";
 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,
   },
 });

packages/cli/src/daemon-bootstrap.ts

@@ -1,5 +1,3 @@
-#!/usr/bin/env node
-
 import { runForegroundKernelSession } from "./run-foreground-kernel.js";
 import { loadDaemonModule } from "./workspace-daemon.js";
 

packages/cli/src/daemon-client.ts

@@ -8,11 +8,17 @@
 import { connect } from "node:net";
 import type { Socket } from "node:net";
 
+import type { SenseInfo } from "@uncaged/nerve-core";
+
 const CONNECT_TIMEOUT_MS = 3_000;
 const RESPONSE_TIMEOUT_MS = 5_000;
 
+export type { SenseInfo };
+
 type TriggerResponse = { ok: true } | { ok: false; error: string };
 
+type ListSensesResponse = { ok: true; senses: SenseInfo[] } | { ok: false; error: string };
+
 function parseDaemonResponse(line: string): TriggerResponse {
   try {
     const obj = JSON.parse(line) as unknown;
@@ -27,12 +33,36 @@ function parseDaemonResponse(line: string): TriggerResponse {
   return { ok: false, error: `Unexpected daemon response: ${line}` };
 }
 
-function sendAndReceive(socketPath: string, message: object): Promise<TriggerResponse> {
+function parseListSensesResponse(line: string): ListSensesResponse {
+  try {
+    const obj = JSON.parse(line) as unknown;
+    if (obj !== null && typeof obj === "object") {
+      const r = obj as Record<string, unknown>;
+      if (r.ok === false && typeof r.error === "string") return { ok: false, error: r.error };
+      if (r.ok === true && Array.isArray(r.senses))
+        return { ok: true, senses: r.senses as SenseInfo[] };
+    }
+  } catch {
+    // fall through
+  }
+  return { ok: false, error: `Unexpected daemon response: ${line}` };
+}
+
+/**
+ * Connect to the daemon socket, send one JSON request (newline-terminated),
+ * and resolve with the first non-empty line parsed by `parseFirstLine`.
+ */
+function sendAndReceive<T>(
+  socketPath: string,
+  message: object,
+  parseFirstLine: (trimmed: string) => T,
+  responseTimeoutMs: number = RESPONSE_TIMEOUT_MS,
+): Promise<T> {
   return new Promise((resolve, reject) => {
     let socket: Socket | null = null;
     let settled = false;
 
-    function settle(result: TriggerResponse | Error): void {
+    function settle(result: T | Error): void {
       if (settled) return;
       settled = true;
       if (socket !== null) {
@@ -55,7 +85,7 @@ function sendAndReceive(socketPath: string, message: object): Promise<TriggerRes
 
       const responseTimer = setTimeout(() => {
         settle(new Error("Timed out waiting for daemon response"));
-      }, RESPONSE_TIMEOUT_MS);
+      }, responseTimeoutMs);
 
       let buf = "";
       socket?.on("data", (chunk: Buffer) => {
@@ -66,7 +96,7 @@ function sendAndReceive(socketPath: string, message: object): Promise<TriggerRes
           const trimmed = line.trim();
           if (trimmed.length === 0) continue;
           clearTimeout(responseTimer);
-          settle(parseDaemonResponse(trimmed));
+          settle(parseFirstLine(trimmed));
           return;
         }
       });
@@ -91,16 +121,25 @@ export function triggerWorkflowViaDaemon(
   workflow: string,
   payload: unknown,
 ): Promise<TriggerResponse> {
-  return sendAndReceive(socketPath, { type: "trigger-workflow", workflow, payload });
+  return sendAndReceive(
+    socketPath,
+    { type: "trigger-workflow", workflow, payload },
+    parseDaemonResponse,
+  );
 }
 
 /**
  * Send a trigger-sense message to the running daemon via its Unix socket.
  * Resolves with the daemon's response or rejects on connection/timeout errors.
  */
-export function triggerSenseViaDaemon(
+export function triggerSenseViaDaemon(socketPath: string, sense: string): Promise<TriggerResponse> {
-  socketPath: string,
+  return sendAndReceive(socketPath, { type: "trigger-sense", sense }, parseDaemonResponse);
-  sense: string,
+}
-): Promise<TriggerResponse> {
+
-  return sendAndReceive(socketPath, { type: "trigger-sense", sense });
+/**
+ * Send a list-senses message to the running daemon via its Unix socket.
+ * Resolves with the list of registered senses or rejects on connection/timeout errors.
+ */
+export function listSensesViaDaemon(socketPath: string): Promise<ListSensesResponse> {
+  return sendAndReceive(socketPath, { type: "list-senses" }, parseListSensesResponse);
 }

packages/cli/src/daemon-types.ts

@@ -1,51 +0,0 @@
-/**
- * Structural types for workflow CLI — mirrors @uncaged/nerve-daemon log-store
- * public API so the CLI runtime does not statically depend on the daemon package.
- *
- * ⚠️  Keep in sync with @uncaged/nerve-daemon exports.
- *     Run `pnpm --filter @uncaged/nerve-cli test` to catch drift via satisfies assertions.
- */
-
-export type WorkflowRunStatus =
-  | "queued"
-  | "started"
-  | "completed"
-  | "failed"
-  | "crashed"
-  | "dropped"
-  | "interrupted";
-
-export type WorkflowRun = {
-  runId: string;
-  workflow: string;
-  status: WorkflowRunStatus;
-  ts: number;
-};
-
-export type LogEntry = {
-  id?: number;
-  source: string;
-  type: string;
-  refId: string | null;
-  payload: string | null;
-  ts: number;
-};
-
-export type LogQuery = {
-  source?: string;
-  type?: string;
-  refId?: string;
-  since?: number;
-  until?: number;
-  limit?: number;
-};
-
-/** Subset of daemon LogStore used by the CLI workflow commands. */
-export type LogStore = {
-  query: (filter?: LogQuery) => LogEntry[];
-  getWorkflowRun: (runId: string) => WorkflowRun | null;
-  getActiveWorkflowRuns: (workflowName?: string) => WorkflowRun[];
-  getAllWorkflowRuns: (workflowName: string | null) => WorkflowRun[];
-  upsertWorkflowRun: (entry: Omit<LogEntry, "id">, run: WorkflowRun) => LogEntry;
-  close: () => void;
-};

packages/cli/src/sense-sqlite.ts

@@ -0,0 +1,127 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+
+/** SQLite path for a sense under the nerve workspace root. */
+export function senseDbPath(nerveRoot: string, senseName: string): string {
+  return join(nerveRoot, "data", "senses", `${senseName}.db`);
+}
+
+export function assertSenseDbExists(nerveRoot: string, senseName: string): string {
+  const path = senseDbPath(nerveRoot, senseName);
+  if (!existsSync(path)) {
+    throw new Error(`No database at ${path}`);
+  }
+  return path;
+}
+
+/** Open a sense SQLite database in readonly mode using node:sqlite. */
+export function openSenseDb(nerveRoot: string, senseName: string): DatabaseSync {
+  const path = assertSenseDbExists(nerveRoot, senseName);
+  return new DatabaseSync(path, { readOnly: true });
+}
+
+/** `SELECT sql FROM sqlite_master WHERE type='table'` (non-null sql only). */
+export function listTableSqlStatements(db: DatabaseSync): string[] {
+  const rows = db
+    .prepare(
+      `SELECT sql FROM sqlite_master WHERE type = 'table' AND sql IS NOT NULL ORDER BY tbl_name`,
+    )
+    .all() as { sql: string }[];
+  return rows.map((r) => r.sql);
+}
+
+/**
+ * Table used for `nerve sense query <name>` with no SQL.
+ * Prefers real data tables over `_migrations`, then lexicographic by name.
+ */
+export function pickDefaultPreviewTable(db: DatabaseSync): string | null {
+  const row = db
+    .prepare(
+      `SELECT name FROM sqlite_master
+       WHERE type = 'table' AND sql IS NOT NULL
+         AND name NOT LIKE 'sqlite\\_%' ESCAPE '\\'
+       ORDER BY
+         CASE WHEN name = '_migrations' THEN 1 ELSE 0 END,
+         name
+       LIMIT 1`,
+    )
+    .get() as { name: string } | undefined;
+  return row?.name ?? null;
+}
+
+export function defaultPreviewSql(table: string): string {
+  return `SELECT * FROM "${table.replace(/"/g, '""')}" ORDER BY rowid DESC LIMIT 10`;
+}
+
+/** Parse sense name and optional SQL from subcommand raw argv (flags stripped). */
+export function parseSenseQueryArgs(rawArgs: string[]): { name: string; sql: string | undefined } {
+  const pos: string[] = [];
+  for (let i = 0; i < rawArgs.length; i++) {
+    const a = rawArgs[i];
+    if (a === "--json" || a === "--no-json") continue;
+    if (a.startsWith("-")) {
+      const eq = a.indexOf("=");
+      if (eq === -1 && i + 1 < rawArgs.length && !rawArgs[i + 1].startsWith("-")) {
+        i += 1;
+      }
+      continue;
+    }
+    pos.push(a);
+  }
+  if (pos.length < 1) {
+    throw new Error("Missing sense name");
+  }
+  const name = pos[0];
+  const sql = pos.length > 1 ? pos.slice(1).join(" ") : undefined;
+  return { name, sql };
+}
+
+function stringifyCell(value: unknown): string {
+  if (value === null || value === undefined) return "";
+  if (typeof value === "bigint") return value.toString();
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (typeof value === "string") return value;
+  if (Buffer.isBuffer(value)) return value.toString("hex");
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
+/** Collect column keys in stable order (first row keys, then any extras). */
+export function collectColumnKeys(rows: Record<string, unknown>[]): string[] {
+  const keys: string[] = [];
+  const seen = new Set<string>();
+  for (const row of rows) {
+    for (const k of Object.keys(row)) {
+      if (!seen.has(k)) {
+        seen.add(k);
+        keys.push(k);
+      }
+    }
+  }
+  return keys;
+}
+
+const MAX_CELL = 64;
+
+function truncate(s: string): string {
+  if (s.length <= MAX_CELL) return s;
+  return `${s.slice(0, MAX_CELL - 1)}…`;
+}
+
+/** Plain aligned table for terminal output. */
+export function formatRowsAsAlignedTable(rows: Record<string, unknown>[]): string {
+  if (rows.length === 0) {
+    return "(0 rows)\n";
+  }
+  const cols = collectColumnKeys(rows);
+  const cells = rows.map((row) => cols.map((c) => truncate(stringifyCell(row[c]))));
+  const widths = cols.map((c, j) => Math.max(c.length, ...cells.map((r) => r[j].length)));
+  const sep = widths.map((w) => "-".repeat(w)).join("-+-");
+  const header = cols.map((c, j) => c.padEnd(widths[j])).join(" | ");
+  const body = cells.map((r) => r.map((cell, j) => cell.padEnd(widths[j])).join(" | ")).join("\n");
+  return `${header}\n${sep}\n${body}\n`;
+}

packages/cli/src/workspace-daemon.ts

@@ -5,7 +5,7 @@ import { pathToFileURL } from "node:url";
 
 import type { NerveConfig } from "@uncaged/nerve-core";
 
-import type { LogStore } from "./daemon-types.js";
+import type { LogStore } from "@uncaged/nerve-store";
 
 export function getDaemonEntryPath(nerveRoot: string): string | undefined {
   const pkgPath = join(nerveRoot, "node_modules", "@uncaged", "nerve-daemon", "package.json");
@@ -29,7 +29,7 @@ export function assertWorkspaceDaemonInstalled(nerveRoot: string): string {
   return entry;
 }
 
-/** Loaded from ~/.uncaged-nerve/node_modules at runtime — keep types structural only. */
+/** Loaded from ~/.uncaged-nerve/node_modules at runtime. */
 export type DaemonModule = {
   createKernel: (
     config: NerveConfig,

packages/cli/tsconfig.json

@@ -6,5 +6,6 @@
     "composite": false,
     "types": ["node"]
   },
-  "include": ["src"]
+  "include": ["src"],
+  "exclude": ["src/__tests__"]
 }

packages/cli/tsup.config.ts

@@ -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"],
-});

packages/core/README.md

@@ -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

packages/core/package.json

@@ -1,17 +1,23 @@
 {
   "name": "@uncaged/nerve-core",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "type": "module",
   "main": "dist/index.js",
+  "files": ["dist"],
+  "publishConfig": {
+    "access": "public"
+  },
   "types": "dist/index.d.ts",
   "scripts": {
-    "build": "tsup",
+    "prepublishOnly": "bash ../../scripts/prepublish-check.sh",
+    "build": "rslib build",
     "test": "vitest run"
   },
   "dependencies": {
     "yaml": "^2.8.3"
   },
   "devDependencies": {
+    "@rslib/core": "^0.21.3",
     "vitest": "^4.1.5"
   }
 }

packages/core/rslib.config.ts

@@ -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,
+  },
+});

packages/core/src/__tests__/config.test.ts

@@ -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",

packages/core/src/config.ts

@@ -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) {
+  if (hasWorkflowKey) {
-    return err(new Error(`reflexes[${index}]: cannot have both "sense" and "workflow"`));
+    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) {
+  if (!hasSense) {
-    return err(new Error(`reflexes[${index}]: must have either "sense" or "workflow"`));
+    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 maxRoundsResult = parseEngineMaxRounds(obj);
-  const workflowNames = new Set(workflowsResult.value ? Object.keys(workflowsResult.value) : []);
+  if (!maxRoundsResult.ok) return maxRoundsResult;
-  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`));
-    }
-  }
 
   return ok({
+    maxRounds: maxRoundsResult.value,
     senses,
     reflexes: reflexesResult.value,
     workflows: workflowsResult.value,

packages/core/src/index.ts

@@ -1,22 +1,27 @@
 export type {
   Signal,
   SenseConfig,
+  SenseInfo,
   SenseReflexConfig,
-  WorkflowReflexConfig,
   ReflexConfig,
   DropOverflowConfig,
   QueueOverflowConfig,
   WorkflowConfig,
   NerveConfig,
-  CommandEvent,
+  WorkflowMessage,
-  ThreadState,
+  RoleResult,
-  ModerateResult,
-  WorkflowContext,
-  RoleExecuteFn,
   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";

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

@@ -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 };
+}

packages/core/src/types.ts

@@ -12,6 +12,15 @@ export type SenseConfig = {
   gracePeriod: number | null;
 };
 
+/** Runtime metadata for a sense (e.g. daemon list-senses IPC). */
+export type SenseInfo = {
+  name: string;
+  group: string;
+  throttle: number | null;
+  timeout: number | null;
+  lastSignalTs: number | null;
+};
+
 export type SenseReflexConfig = {
   kind: "sense";
   sense: string;
@@ -19,13 +28,8 @@ export type SenseReflexConfig = {
   on: string[] | null;
 };
 
-export type WorkflowReflexConfig = {
+/** Reflexes only schedule Senses; workflow launches come from Sense return values. */
-  kind: "workflow";
+export type ReflexConfig = SenseReflexConfig;
-  workflow: string;
-  on: string[] | null;
-};
-
-export type ReflexConfig = SenseReflexConfig | WorkflowReflexConfig;
 
 export type DropOverflowConfig = {
   concurrency: number;
@@ -41,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 const START = "__start__" as const;
-export type CommandEvent = {
+export const END = "__end__" as const;
-  type: string;
+export type START = typeof START;
-  [key: string]: unknown;
+export type END = typeof END;
-};
 
-/** Accumulated state of a running thread — the event history for moderate(). */
+/** Engine-wide fallback for max moderator rounds when not specified in config. */
-export type ThreadState = {
+export const DEFAULT_ENGINE_MAX_ROUNDS = 100;
-  runId: string;
-  /** All events so far, including the initial thread_start event. */
-  events: CommandEvent[];
-};
 
-/** The result of moderate() — which role to hand to next, and what prompt to pass. */
+/** A single message in the workflow conversation chain (runtime, type-erased). */
-export type ModerateResult = {
+export type WorkflowMessage = {
   role: string;
-  prompt: unknown;
+  content: string;
+  meta: unknown;
+  timestamp: number;
 };
 
-/** Context injected into every role execute() call. */
+/** The typed output of a Role execution. */
-export type WorkflowContext = {
+export type RoleResult<Meta> = { content: string; meta: Meta };
-  runId: string;
-  workflowName: string;
-  /** Emit a log message back to the parent process. */
-  log: (message: string) => void;
-};
 
 /**
- * A role's execute function. Has side effects (API calls, file I/O, etc.).
+ * A Role is a pure async function: receives the full message chain,
- * Returns a CommandEvent that is fed back into moderate().
+ * 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. */
+/** Maps role names to their meta types — the single generic that drives all inference. */
-export type Role = {
+export type RoleMeta = Record<string, Record<string, unknown>>;
-  execute: RoleExecuteFn;
+
+/** 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.
+ * The moderator — a pure routing function. Receives the last signal,
- * Decides which role to pass control to next.
+ * current round, and maxRounds. Returns the next role name or END.
- * Returns null to signal thread completion.
  */
-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 = {
+export type WorkflowDefinition<M extends RoleMeta> = {
-  roles: Record<string, Role>;
+  name: string;
-  moderate: ModerateFn;
+  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;
 };

packages/core/tsup.config.ts

@@ -1,8 +0,0 @@
-import { defineConfig } from "tsup";
-
-export default defineConfig({
-  entry: ["src/index.ts"],
-  format: ["esm"],
-  dts: true,
-  clean: true,
-});

packages/daemon/README.md

@@ -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

packages/daemon/package.json

@@ -1,27 +1,27 @@
 {
   "name": "@uncaged/nerve-daemon",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": [
+  "files": ["dist"],
-    "dist"
-  ],
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "tsup",
+    "prepublishOnly": "bash ../../scripts/prepublish-check.sh",
+    "build": "rslib build",
     "test": "vitest run"
   },
   "dependencies": {
     "@uncaged/nerve-core": "workspace:*",
-    "better-sqlite3": "^11.10.0",
+    "@uncaged/nerve-store": "workspace:*",
-    "drizzle-orm": "^0.43.1",
+    "drizzle-orm": "1.0.0-beta.23-c10d10c",
     "yaml": "^2.8.3"
   },
   "devDependencies": {
-    "@types/better-sqlite3": "^7.6.13",
+    "@rslib/core": "^0.21.3",
+    "@types/node": "^22.0.0",
     "vitest": "^4.1.5"
   }
 }

packages/daemon/rslib.config.ts

@@ -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,
+  },
+});

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

@@ -64,6 +64,7 @@ function makeConfig(workflows: Record<string, WorkflowConfig> = {}): NerveConfig
     senses: {},
     reflexes: [],
     workflows,
+    maxRounds: 10,
   };
 }
 
@@ -89,9 +90,20 @@ function makeLogStore(
       }
       return activeRuns;
     }),
-    getTriggerPayload: vi.fn(() => ({ value: 42 })),
+    getTriggerPayload: vi.fn((): unknown => ({ value: 42 })),
-    getThreadEvents: vi.fn(() => [{ 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(() => []),
   };
   return store;
 }
@@ -115,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", { prompt: "test 1", maxRounds: 10 });
-      mgr.startWorkflow("my-wf", { n: 2 });
+      mgr.startWorkflow("my-wf", { prompt: "test 2", maxRounds: 10 });
       expect(mgr.activeCount("my-wf")).toBe(2);
 
       // Simulate unexpected exit (not shutdown)
@@ -126,7 +138,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       child.emit("exit", 1, null);
 
       const crashedCalls = logStore.upsertWorkflowRun.mock.calls.filter(
-        ([entry]: [{ type: string }]) => entry.type === "crashed",
+        (args: any[]) => (args[0] as { type: string }).type === "crashed",
       );
       expect(crashedCalls).toHaveLength(2);
 
@@ -142,8 +154,8 @@ 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 });
-      mgr.startWorkflow("my-wf", {});
+      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
       expect(mgr.activeCount("my-wf")).toBe(2);
 
       const child = mockChildren[0];
@@ -167,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];
@@ -190,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([
+      logStore.getThreadMessages.mockReturnValue([
-        { type: "thread_start", triggerPayload: {} },
+        { role: "scanner", content: "done", meta: { items: ["a"] }, timestamp: 1000 },
-        { type: "scan_complete", items: ["a"] },
       ]);
       logStore.getTriggerPayload.mockReturnValue({ trigger: "initial" });
 
@@ -201,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;
@@ -215,10 +226,10 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
 
       // resume-thread should have been sent
       const resumeCalls = (secondChild.send as ReturnType<typeof vi.fn>).mock.calls.filter(
-        ([msg]: [unknown]) =>
+        (args: any[]) =>
-          msg !== null &&
+          args[0] !== null &&
-          typeof msg === "object" &&
+          typeof args[0] === "object" &&
-          (msg as Record<string, unknown>).type === "resume-thread",
+          (args[0] as Record<string, unknown>).type === "resume-thread",
       );
       expect(resumeCalls).toHaveLength(1);
       expect(resumeCalls[0][0]).toMatchObject({
@@ -226,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();
@@ -246,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;
@@ -263,34 +274,33 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
     });
   });
 
-  describe("command events are persisted (for crash recovery replay)", () => {
+  describe("workflow messages are persisted (for crash recovery replay)", () => {
-    it("persists thread_command_event when worker sends thread-command-event IPC", async () => {
+    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(
-        ([entry]: [{ type: string }]) => entry.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,
       });
 
@@ -308,11 +318,11 @@ 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(
-        ([entry]: [{ type: string }]) => entry.type === "started",
+        (args: any[]) => (args[0] as { type: string }).type === "started",
       );
       expect(startedCall).toBeDefined();
       const logEntry = startedCall?.[0] as { payload: string | null };
@@ -340,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
@@ -368,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({
@@ -376,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;
@@ -406,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++) {

packages/daemon/src/__tests__/daemon-ipc.test.ts

@@ -0,0 +1,237 @@
+/**
+ * Unit + integration tests for daemon-ipc.ts — trigger-sense request type.
+ *
+ * Tests cover:
+ *   - parseRequest correctly accepts/rejects trigger-sense messages
+ *   - createDaemonIpcServer routes trigger-sense to opts.triggerSense
+ *   - Error response when triggerSense throws (unknown sense)
+ *   - Success response on valid sense trigger
+ */
+
+import { rmSync } from "node:fs";
+import { connect } from "node:net";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { createDaemonIpcServer } from "../daemon-ipc.js";
+import type { DaemonIpcServer } from "../daemon-ipc.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+let sockPath: string;
+let server: DaemonIpcServer | null = null;
+
+function makeMockWorkflowManager() {
+  return {
+    startWorkflow: vi.fn(),
+    stop: vi.fn(async () => {}),
+    totalActiveCount: vi.fn(() => 0),
+    drainAndRespawn: vi.fn(async () => {}),
+    updateConfig: vi.fn(),
+    getActiveWorkflowRuns: vi.fn(() => []),
+  };
+}
+
+function sendRaw(path: string, message: object): Promise<object> {
+  return new Promise((resolve, reject) => {
+    const sock = connect(path, () => {
+      let buf = "";
+      sock.on("data", (chunk: Buffer) => {
+        buf += chunk.toString("utf8");
+        const lines = buf.split("\n");
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (trimmed.length === 0) continue;
+          try {
+            resolve(JSON.parse(trimmed) as object);
+          } catch {
+            reject(new Error(`Invalid JSON response: ${trimmed}`));
+          }
+          sock.destroy();
+          return;
+        }
+        buf = lines[lines.length - 1] ?? "";
+      });
+      sock.write(`${JSON.stringify(message)}\n`);
+    });
+    sock.on("error", reject);
+  });
+}
+
+beforeEach(() => {
+  sockPath = join(
+    tmpdir(),
+    `nerve-ipc-test-${Date.now()}-${Math.random().toString(36).slice(2)}.sock`,
+  );
+});
+
+afterEach(async () => {
+  if (server !== null) {
+    await server.close();
+    server = null;
+  }
+  try {
+    rmSync(sockPath);
+  } catch {
+    // already removed
+  }
+});
+
+// ---------------------------------------------------------------------------
+// trigger-sense: valid request → ok: true
+// ---------------------------------------------------------------------------
+
+describe("daemon-ipc — trigger-sense", () => {
+  it("responds ok:true when triggerSense succeeds", async () => {
+    const triggerSense = vi.fn();
+    server = createDaemonIpcServer(sockPath, makeMockWorkflowManager() as never, {
+      triggerSense,
+      listSenses: vi.fn(() => []),
+    });
+
+    const resp = await sendRaw(sockPath, { type: "trigger-sense", sense: "cpu-usage" });
+
+    expect(resp).toEqual({ ok: true });
+    expect(triggerSense).toHaveBeenCalledOnce();
+    expect(triggerSense).toHaveBeenCalledWith("cpu-usage");
+  });
+
+  it("responds ok:false with error message when triggerSense throws", async () => {
+    const triggerSense = vi.fn(() => {
+      throw new Error('Unknown sense: "no-such-sense"');
+    });
+    server = createDaemonIpcServer(sockPath, makeMockWorkflowManager() as never, {
+      triggerSense,
+      listSenses: vi.fn(() => []),
+    });
+
+    const resp = await sendRaw(sockPath, { type: "trigger-sense", sense: "no-such-sense" });
+
+    expect(resp).toEqual({ ok: false, error: 'Unknown sense: "no-such-sense"' });
+    expect(triggerSense).toHaveBeenCalledWith("no-such-sense");
+  });
+
+  it("responds ok:false for trigger-sense with empty sense name", async () => {
+    const triggerSense = vi.fn();
+    server = createDaemonIpcServer(sockPath, makeMockWorkflowManager() as never, {
+      triggerSense,
+      listSenses: vi.fn(() => []),
+    });
+
+    const resp = await sendRaw(sockPath, { type: "trigger-sense", sense: "" });
+
+    expect(resp).toEqual({ ok: false, error: "Invalid request" });
+    expect(triggerSense).not.toHaveBeenCalled();
+  });
+
+  it("responds ok:false for trigger-sense missing sense field", async () => {
+    const triggerSense = vi.fn();
+    server = createDaemonIpcServer(sockPath, makeMockWorkflowManager() as never, {
+      triggerSense,
+      listSenses: vi.fn(() => []),
+    });
+
+    const resp = await sendRaw(sockPath, { type: "trigger-sense" });
+
+    expect(resp).toEqual({ ok: false, error: "Invalid request" });
+    expect(triggerSense).not.toHaveBeenCalled();
+  });
+
+  it("does NOT call triggerSense for trigger-workflow requests", async () => {
+    const triggerSense = vi.fn();
+    const wfManager = makeMockWorkflowManager();
+    server = createDaemonIpcServer(sockPath, wfManager as never, {
+      triggerSense,
+      listSenses: vi.fn(() => []),
+    });
+
+    const resp = await sendRaw(sockPath, {
+      type: "trigger-workflow",
+      workflow: "my-workflow",
+      payload: {},
+    });
+
+    expect(resp).toEqual({ ok: true });
+    expect(triggerSense).not.toHaveBeenCalled();
+    expect(wfManager.startWorkflow).toHaveBeenCalledWith("my-workflow", {});
+  });
+
+  it("responds ok:false for completely unknown request type", async () => {
+    const triggerSense = vi.fn();
+    server = createDaemonIpcServer(sockPath, makeMockWorkflowManager() as never, {
+      triggerSense,
+      listSenses: vi.fn(() => []),
+    });
+
+    const resp = await sendRaw(sockPath, { type: "unknown-type", data: "x" });
+
+    expect(resp).toEqual({ ok: false, error: "Invalid request" });
+    expect(triggerSense).not.toHaveBeenCalled();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// list-senses: valid request → ok: true with senses array
+// ---------------------------------------------------------------------------
+
+describe("daemon-ipc — list-senses", () => {
+  it("responds ok:true with empty senses array when listSenses returns []", async () => {
+    const listSenses = vi.fn(() => []);
+    server = createDaemonIpcServer(sockPath, makeMockWorkflowManager() as never, {
+      triggerSense: vi.fn(),
+      listSenses,
+    });
+
+    const resp = await sendRaw(sockPath, { type: "list-senses" });
+
+    expect(resp).toEqual({ ok: true, senses: [] });
+    expect(listSenses).toHaveBeenCalledOnce();
+  });
+
+  it("responds ok:true with senses populated from listSenses", async () => {
+    const sensesData = [
+      { name: "cpu-usage", group: "system", throttle: 5000, timeout: 3000, lastSignalTs: 1000 },
+      { name: "disk-usage", group: "system", throttle: 30000, timeout: null, lastSignalTs: null },
+    ];
+    const listSenses = vi.fn(() => sensesData);
+    server = createDaemonIpcServer(sockPath, makeMockWorkflowManager() as never, {
+      triggerSense: vi.fn(),
+      listSenses,
+    });
+
+    const resp = await sendRaw(sockPath, { type: "list-senses" });
+
+    expect(resp).toEqual({ ok: true, senses: sensesData });
+    expect(listSenses).toHaveBeenCalledOnce();
+  });
+
+  it("responds ok:false when listSenses throws", async () => {
+    const listSenses = vi.fn(() => {
+      throw new Error("internal error");
+    });
+    server = createDaemonIpcServer(sockPath, makeMockWorkflowManager() as never, {
+      triggerSense: vi.fn(),
+      listSenses,
+    });
+
+    const resp = await sendRaw(sockPath, { type: "list-senses" });
+
+    expect(resp).toEqual({ ok: false, error: "internal error" });
+  });
+
+  it("does NOT call listSenses for trigger-sense requests", async () => {
+    const listSenses = vi.fn(() => []);
+    server = createDaemonIpcServer(sockPath, makeMockWorkflowManager() as never, {
+      triggerSense: vi.fn(),
+      listSenses,
+    });
+
+    await sendRaw(sockPath, { type: "trigger-sense", sense: "cpu-usage" });
+
+    expect(listSenses).not.toHaveBeenCalled();
+  });
+});

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

@@ -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,7 +77,12 @@ 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(() => []),
   };
 }
 
@@ -97,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
@@ -116,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", { prompt: "test", maxRounds: 10 });
-    mgr.startWorkflow("my-wf", { n: 2 });
+    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
     expect(mgr.activeCount("my-wf")).toBe(2);
 
     const drainPromise = mgr.drainAndRespawn("my-wf", 5000);
@@ -125,7 +130,7 @@ describe("WorkflowManager — drainAndRespawn (Phase 3 hot reload)", () => {
     await drainPromise;
 
     const interruptedCalls = logStore.upsertWorkflowRun.mock.calls.filter(
-      ([entry]: [{ type: string }]) => entry.type === "interrupted",
+      (args: any[]) => (args[0] as { type: string }).type === "interrupted",
     );
     expect(interruptedCalls).toHaveLength(2);
 
@@ -148,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);
@@ -164,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);
@@ -181,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();
@@ -189,10 +194,10 @@ describe("WorkflowManager — drainAndRespawn (Phase 3 hot reload)", () => {
 
     const newChild = mockChildren[1];
     const resumeCalls = (newChild.send as ReturnType<typeof vi.fn>).mock.calls.filter(
-      ([msg]: [unknown]) =>
+      (args: any[]) =>
-        msg !== null &&
+        args[0] !== null &&
-        typeof msg === "object" &&
+        typeof args[0] === "object" &&
-        (msg as Record<string, unknown>).type === "resume-thread",
+        (args[0] as Record<string, unknown>).type === "resume-thread",
     );
     expect(resumeCalls).toHaveLength(0);
 
@@ -206,21 +211,21 @@ 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(
-      ([msg]: [unknown]) =>
+      (args: any[]) =>
-        msg !== null &&
+        args[0] !== null &&
-        typeof msg === "object" &&
+        typeof args[0] === "object" &&
-        (msg as Record<string, unknown>).type === "start-thread",
+        (args[0] as Record<string, unknown>).type === "start-thread",
     );
     expect(startCalls).toHaveLength(1);
 
@@ -245,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", {
@@ -255,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);
@@ -265,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(([e]: [{ type: string }]) => e.type === "start");
+    const startCall = appendCalls.find(
+      (args: any[]) => (args[0] as { type: string }).type === "start",
+    );
     expect(startCall).toBeDefined();
 
     const stopPromise = kernel.stop();
@@ -277,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", {
@@ -287,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
@@ -295,6 +304,7 @@ describe("Kernel — workflow hot reload via file-watcher (Phase 3)", () => {
       senses: {},
       reflexes: [],
       workflows: null,
+    maxRounds: 10,
     };
     kernel.reloadConfig(newConfig);
 
@@ -314,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", {
@@ -323,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);
 
@@ -342,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", { prompt: "test", maxRounds: 10 });
-    kernel.workflowManager.startWorkflow("my-wf", { n: 3 });
+    kernel.workflowManager.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
     expect(kernel.workflowManager.activeCount("my-wf")).toBe(3);
 
     const stopPromise = kernel.stop();

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

@@ -27,6 +27,7 @@ function makeConfig(overrides: Partial<NerveConfig> = {}): NerveConfig {
     },
     reflexes: [],
     workflows: null,
+    maxRounds: 10,
     ...overrides,
   };
 }

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

@@ -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);

packages/daemon/src/__tests__/kernel-trigger-sense.test.ts

@@ -0,0 +1,202 @@
+/**
+ * Unit tests for kernel.triggerSense() — IPC issue #36.
+ *
+ * These tests use a mock child_process and a mock LogStore so they do NOT
+ * require a real LogStore (node:sqlite) in integration tests.
+ */
+
+import { EventEmitter } from "node:events";
+
+import type { NerveConfig } from "@uncaged/nerve-core";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+// ---------------------------------------------------------------------------
+// Mock child_process.fork before importing kernel
+// ---------------------------------------------------------------------------
+
+const mockChildren: MockChild[] = [];
+
+type MockChild = EventEmitter & {
+  send: ReturnType<typeof vi.fn>;
+  kill: ReturnType<typeof vi.fn>;
+  connected: boolean;
+  pid: number;
+};
+
+function makeMockChild(pid = 1): MockChild {
+  const child = new EventEmitter() as MockChild;
+  child.connected = true;
+  child.send = vi.fn((msg: unknown) => {
+    if (
+      msg !== null &&
+      typeof msg === "object" &&
+      (msg as Record<string, unknown>).type === "shutdown"
+    ) {
+      setImmediate(() => {
+        child.connected = false;
+        child.emit("exit", 0, null);
+      });
+    }
+  });
+  child.kill = vi.fn((_signal?: string) => {
+    child.connected = false;
+    child.emit("exit", null, _signal ?? "SIGKILL");
+  });
+  child.pid = pid;
+  return child;
+}
+
+vi.mock("node:child_process", () => ({
+  fork: vi.fn((_script: string, _args: string[], _opts: unknown) => {
+    const child = makeMockChild(mockChildren.length + 1);
+    mockChildren.push(child);
+    return child;
+  }),
+}));
+
+// Import after mock is set up
+const { createKernel } = await import("../kernel.js");
+
+// ---------------------------------------------------------------------------
+// Mock LogStore factory (avoids SQLite I/O in this unit test)
+// ---------------------------------------------------------------------------
+
+function makeMockLogStore() {
+  return {
+    append: vi.fn(),
+    query: vi.fn(() => []),
+    getMeta: vi.fn(() => null),
+    setMeta: vi.fn(),
+    upsertWorkflowRun: vi.fn(),
+    appendWithWorkflowUpdate: vi.fn(),
+    getWorkflowRun: vi.fn(() => null),
+    getActiveWorkflowRuns: vi.fn(() => []),
+    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(),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Config helpers
+// ---------------------------------------------------------------------------
+
+function makeConfig(overrides: Partial<NerveConfig> = {}): NerveConfig {
+  return {
+    senses: {
+      "cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
+    },
+    reflexes: [],
+    workflows: null,
+    maxRounds: 10,
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("kernel.triggerSense()", () => {
+  beforeEach(() => {
+    mockChildren.length = 0;
+    vi.useFakeTimers({ shouldAdvanceTime: true });
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("throws for an unknown sense name", async () => {
+    const config = makeConfig();
+    const kernel = createKernel(config, "/tmp/nerve-test", {
+      workerScript: null,
+      logStore: makeMockLogStore() as never,
+    });
+
+    expect(() => kernel.triggerSense("no-such-sense")).toThrow(/Unknown sense/);
+
+    await kernel.stop();
+  });
+
+  it("sends a compute message to the worker for the correct group", async () => {
+    const config = makeConfig({
+      senses: {
+        "cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
+        "net-io": { group: "network", throttle: null, timeout: null, gracePeriod: null },
+      },
+      reflexes: [],
+    });
+    const kernel = createKernel(config, "/tmp/nerve-test", {
+      workerScript: null,
+      logStore: makeMockLogStore() as never,
+    });
+
+    // Two groups → two workers
+    expect(mockChildren.length).toBe(2);
+
+    // Workers are keyed by group: groups iteration order matches the insertion
+    // order from Object.values(config.senses).  Find the worker for "system".
+    const systemWorkerIdx = Array.from(kernel.groups).indexOf("system");
+    const systemWorker = mockChildren[systemWorkerIdx];
+
+    kernel.triggerSense("cpu-usage");
+
+    expect(systemWorker.send).toHaveBeenCalledWith(
+      expect.objectContaining({ type: "compute", sense: "cpu-usage" }),
+    );
+
+    await kernel.stop();
+  });
+
+  it("sends a compute message to the correct worker when multiple senses share a group", async () => {
+    const config = makeConfig({
+      senses: {
+        "cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
+        "disk-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
+      },
+      reflexes: [],
+    });
+    const kernel = createKernel(config, "/tmp/nerve-test", {
+      workerScript: null,
+      logStore: makeMockLogStore() as never,
+    });
+
+    // Both senses share the "system" group → one worker only
+    expect(mockChildren.length).toBe(1);
+    const worker = mockChildren[0];
+
+    kernel.triggerSense("disk-usage");
+
+    expect(worker.send).toHaveBeenCalledWith(
+      expect.objectContaining({ type: "compute", sense: "disk-usage" }),
+    );
+
+    await kernel.stop();
+  });
+
+  it("does not send to a disconnected worker (does not throw)", async () => {
+    // Use real timers so kernel.stop() waitForExit can rely on SIGKILL timeout
+    vi.useRealTimers();
+
+    const config = makeConfig();
+    const kernel = createKernel(config, "/tmp/nerve-test", {
+      workerScript: null,
+      logStore: makeMockLogStore() as never,
+    });
+
+    const worker = mockChildren[0];
+    worker.connected = false;
+
+    // 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" }));
+
+    await kernel.stop();
+  }, 10_000);
+});

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

@@ -78,8 +78,13 @@ function makeLogStore() {
     appendWithWorkflowUpdate: vi.fn(),
     getWorkflowRun: vi.fn(() => null),
     getActiveWorkflowRuns: vi.fn(() => []),
+    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(),
   };
 }
@@ -91,6 +96,7 @@ function makeConfig(overrides: Partial<NerveConfig> = {}): NerveConfig {
     },
     reflexes: [],
     workflows: null,
+    maxRounds: 10,
     ...overrides,
   };
 }
@@ -117,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" } },
       });
 
@@ -136,10 +142,10 @@ describe("kernel + workflowManager integration", () => {
       // We need to check that a start-thread message was sent to the workflow worker
       const workflowWorker = mockChildren.find((c) =>
         (c.send as ReturnType<typeof vi.fn>).mock.calls.some(
-          ([msg]: [unknown]) =>
+          (args: unknown[]) =>
-            msg !== null &&
+            args[0] !== null &&
-            typeof msg === "object" &&
+            typeof args[0] === "object" &&
-            (msg as Record<string, unknown>).type === "start-thread",
+            (args[0] as Record<string, unknown>).type === "start-thread",
         ),
       );
       expect(workflowWorker).toBeDefined();
@@ -155,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" } },
       });
 
@@ -196,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" } },
       });
 
@@ -211,10 +217,10 @@ describe("kernel + workflowManager integration", () => {
       // No workflow worker should have been spawned (only the sense group worker)
       const workflowWorkerSpawned = mockChildren.some((c) =>
         (c.send as ReturnType<typeof vi.fn>).mock.calls.some(
-          ([msg]: [unknown]) =>
+          (args: unknown[]) =>
-            msg !== null &&
+            args[0] !== null &&
-            typeof msg === "object" &&
+            typeof args[0] === "object" &&
-            (msg as Record<string, unknown>).type === "start-thread",
+            (args[0] as Record<string, unknown>).type === "start-thread",
         ),
       );
       expect(workflowWorkerSpawned).toBe(false);
@@ -232,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" } },
       });
 
@@ -263,6 +269,7 @@ describe("kernel + workflowManager integration", () => {
         },
         reflexes: [],
         workflows: null,
+    maxRounds: 10,
       });
 
       const kernel = createKernel(initialConfig, "/tmp/nerve-test", {
@@ -275,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);
 
@@ -306,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" } },
       });
 
@@ -322,6 +330,7 @@ describe("kernel + workflowManager integration", () => {
         },
         reflexes: [],
         workflows: null,
+    maxRounds: 10,
       };
       kernel.reloadConfig(newConfig);
 
@@ -357,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" } },
       });
 
@@ -399,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" } },
       });
 

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

@@ -1,4 +1,7 @@
 import { EventEmitter } from "node:events";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
 import type { NerveConfig } from "@uncaged/nerve-core";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
@@ -44,6 +47,7 @@ vi.mock("node:child_process", () => ({
 
 // Import after mock is set up
 const { createKernel } = await import("../kernel.js");
+const { createLogStore } = await import("@uncaged/nerve-store");
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -56,6 +60,7 @@ function makeConfig(overrides: Partial<NerveConfig> = {}): NerveConfig {
     },
     reflexes: [],
     workflows: null,
+    maxRounds: 10,
     ...overrides,
   };
 }
@@ -93,6 +98,29 @@ describe("kernel — message routing", () => {
     await kernel.stop();
   });
 
+  it("persists emitted signals as sense/signal log entries", async () => {
+    const tmpDir = mkdtempSync(join(tmpdir(), "nerve-kernel-sig-"));
+    const logStore = createLogStore(join(tmpDir, "logs.db"));
+    try {
+      const config = makeConfig({
+        senses: {
+          "cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
+        },
+        reflexes: [],
+      });
+      const kernel = createKernel(config, tmpDir, { logStore });
+      const child = mockChildren[0];
+      child.emit("message", { type: "ready" });
+      child.emit("message", { type: "signal", sense: "cpu-usage", payload: 123 });
+      const rows = logStore.query({ source: "sense", type: "signal", refId: "cpu-usage" });
+      expect(rows).toHaveLength(1);
+      expect(rows[0].payload).toBe(JSON.stringify(123));
+      await kernel.stop();
+    } finally {
+      rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
   it("routes error message to stderr", async () => {
     const stderrSpy = vi.spyOn(process.stderr, "write").mockImplementation(() => true);
     const config = makeConfig({
@@ -173,6 +201,7 @@ describe("kernel — groupForSense mapping", () => {
       },
       reflexes: [],
       workflows: null,
+    maxRounds: 10,
     };
     const kernel = createKernel(config, "/tmp/nerve-test");
 

packages/daemon/src/__tests__/log-store-integration.test.ts

@@ -4,8 +4,8 @@ import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 import type { NerveConfig, Signal } from "@uncaged/nerve-core";
-import { createLogStore } from "../log-store.js";
+import { createLogStore } from "@uncaged/nerve-store";
-import type { LogStore } from "../log-store.js";
+import type { LogStore } from "@uncaged/nerve-store";
 import { createReflexScheduler } from "../reflex-scheduler.js";
 import { createSignalBus } from "../signal-bus.js";
 
@@ -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[] = [];

packages/daemon/src/__tests__/phase6-integration.test.ts

@@ -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);
 

packages/daemon/src/__tests__/reflex-scheduler-throttle-pending.test.ts

@@ -11,6 +11,7 @@ function makeConfig(overrides: Partial<NerveConfig> = {}): NerveConfig {
     },
     reflexes: [],
     workflows: null,
+    maxRounds: 10,
     ...overrides,
   };
 }

packages/daemon/src/__tests__/reflex-scheduler.test.ts

@@ -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" },
       },

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

@@ -2,14 +2,15 @@ import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-import Database from "better-sqlite3";
+import { DatabaseSync } from "node:sqlite";
-import { drizzle } from "drizzle-orm/better-sqlite3";
+import { drizzle } from "drizzle-orm/node-sqlite";
 import { integer, real, sqliteTable } from "drizzle-orm/sqlite-core";
 import { describe, expect, it } from "vitest";
 
+import { createBlobStore } from "@uncaged/nerve-store";
 import { parseParentMessage } from "../ipc.js";
 import { executeCompute, openPeerDb, openSenseDb, runMigrations } from "../sense-runtime.js";
-import type { DrizzleDB, PeerMap, SenseRuntime } from "../sense-runtime.js";
+import type { ComputeFn, DrizzleDB, PeerMap, SenseRuntime } from "../sense-runtime.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -48,7 +49,7 @@ const samples = sqliteTable("samples", {
 
 describe("runMigrations", () => {
   it("creates table via SQL migration file", () => {
-    const sqlite = new Database(":memory:");
+    const sqlite = new DatabaseSync(":memory:");
     const migrationsDir = makeTempMigrationsDir(INIT_SQL);
     const result = runMigrations(sqlite, migrationsDir);
 
@@ -63,7 +64,7 @@ describe("runMigrations", () => {
   });
 
   it("runs multiple migrations in lexicographic order", () => {
-    const sqlite = new Database(":memory:");
+    const sqlite = new DatabaseSync(":memory:");
     const dir = mkdtempSync(join(tmpdir(), "nerve-multi-"));
 
     writeFileSync(join(dir, "0001_init.sql"), INIT_SQL);
@@ -80,7 +81,7 @@ describe("runMigrations", () => {
   });
 
   it("returns ok when migrations directory is empty", () => {
-    const sqlite = new Database(":memory:");
+    const sqlite = new DatabaseSync(":memory:");
     const dir = makeTempMigrationsDirEmpty();
     const result = runMigrations(sqlite, dir);
     expect(result.ok).toBe(true);
@@ -88,14 +89,14 @@ describe("runMigrations", () => {
   });
 
   it("returns err when migrations directory does not exist", () => {
-    const sqlite = new Database(":memory:");
+    const sqlite = new DatabaseSync(":memory:");
     const result = runMigrations(sqlite, "/nonexistent/path/migrations");
     expect(result.ok).toBe(false);
     sqlite.close();
   });
 
   it("returns err when a migration SQL is invalid", () => {
-    const sqlite = new Database(":memory:");
+    const sqlite = new DatabaseSync(":memory:");
     const dir = mkdtempSync(join(tmpdir(), "nerve-bad-sql-"));
     writeFileSync(join(dir, "0001_bad.sql"), "NOT VALID SQL !!!;");
     const result = runMigrations(sqlite, dir);
@@ -140,7 +141,7 @@ describe("openPeerDb", () => {
   it("opens an existing db in read-only mode", () => {
     // Create a writable db first
     const dbPath = makeTempDbPath();
-    const sqlite = new Database(dbPath);
+    const sqlite = new DatabaseSync(dbPath);
     sqlite.exec(INIT_SQL);
     sqlite.prepare("INSERT INTO samples (ts, value) VALUES (1, 42.0)").run();
     sqlite.close();
@@ -167,13 +168,13 @@ describe("openPeerDb", () => {
 // ---------------------------------------------------------------------------
 
 describe("executeCompute", () => {
-  function makeRuntime(computeFn: (db: DrizzleDB, peers: PeerMap) => Promise<unknown | null>): {
+  function makeRuntime(computeFn: ComputeFn): {
     runtime: SenseRuntime;
-    sqlite: Database.Database;
+    sqlite: DatabaseSync;
   } {
-    const sqlite = new Database(":memory:");
+    const sqlite = new DatabaseSync(":memory:");
     sqlite.exec(INIT_SQL);
-    const db = drizzle(sqlite) as DrizzleDB;
+    const db = drizzle({ client: sqlite }) as DrizzleDB;
     return {
       runtime: { name: "test-sense", db, compute: computeFn },
       sqlite,
@@ -225,10 +226,10 @@ describe("executeCompute", () => {
 
   it("compute can read from peers", async () => {
     // Set up a peer db with data
-    const peerSqlite = new Database(":memory:");
+    const peerSqlite = new DatabaseSync(":memory:");
     peerSqlite.exec(INIT_SQL);
     peerSqlite.prepare("INSERT INTO samples (ts, value) VALUES (100, 3.14)").run();
-    const peerDb = drizzle(peerSqlite) as DrizzleDB;
+    const peerDb = drizzle({ client: peerSqlite }) as DrizzleDB;
 
     const peers: PeerMap = { "other-sense": peerDb };
 
@@ -247,9 +248,9 @@ describe("executeCompute", () => {
   });
 
   it("write to own db does not affect peer db (isolation)", async () => {
-    const peerSqlite = new Database(":memory:");
+    const peerSqlite = new DatabaseSync(":memory:");
     peerSqlite.exec(INIT_SQL);
-    const peerDb = drizzle(peerSqlite) as DrizzleDB;
+    const peerDb = drizzle({ client: peerSqlite }) as DrizzleDB;
     const peers: PeerMap = { "peer-sense": peerDb };
 
     const { runtime, sqlite } = makeRuntime(async (db) => {
@@ -340,6 +341,20 @@ describe("executeCompute", () => {
     expect(capturedSignal).toBeInstanceOf(AbortSignal);
     sqlite.close();
   });
+
+  it("passes BlobStore as options.blobs when blobStore argument is provided", async () => {
+    const blobsRoot = mkdtempSync(join(tmpdir(), "nerve-blobs-"));
+    const blobStore = createBlobStore(blobsRoot);
+    let seen: ReturnType<typeof createBlobStore> | undefined;
+    const { runtime, sqlite } = makeRuntime(async (_db, _peers, options) => {
+      seen = options?.blobs;
+      return null;
+    });
+
+    await executeCompute(runtime, emptyPeers, undefined, blobStore);
+    expect(seen).toBe(blobStore);
+    sqlite.close();
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -388,7 +403,7 @@ describe("parseParentMessage", () => {
 
 describe("runMigrations journal", () => {
   it("does not re-run an already-applied migration", () => {
-    const sqlite = new Database(":memory:");
+    const sqlite = new DatabaseSync(":memory:");
     const dir = mkdtempSync(join(tmpdir(), "nerve-journal-"));
     writeFileSync(join(dir, "0001_init.sql"), INIT_SQL);
 
@@ -415,7 +430,7 @@ describe("runMigrations journal", () => {
   });
 
   it("tracks migrations in _migrations table", () => {
-    const sqlite = new Database(":memory:");
+    const sqlite = new DatabaseSync(":memory:");
     const dir = mkdtempSync(join(tmpdir(), "nerve-journal2-"));
     writeFileSync(join(dir, "0001_init.sql"), INIT_SQL);
 

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

@@ -0,0 +1,235 @@
+import { EventEmitter } from "node:events";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const mockChildren: MockChild[] = [];
+
+type MockChild = EventEmitter & {
+  send: ReturnType<typeof vi.fn>;
+  kill: ReturnType<typeof vi.fn>;
+  pid: number;
+  connected: boolean;
+};
+
+function makeMockChild(pid = 1): MockChild {
+  const child = new EventEmitter() as MockChild;
+  child.connected = true;
+  child.send = vi.fn((msg: unknown) => {
+    if (
+      msg !== null &&
+      typeof msg === "object" &&
+      (msg as Record<string, unknown>).type === "shutdown"
+    ) {
+      child.connected = false;
+      setImmediate(() => child.emit("exit", 0, null));
+    }
+  });
+  child.kill = vi.fn((_signal?: string) => {
+    child.connected = false;
+    child.emit("exit", null, _signal ?? "SIGKILL");
+  });
+  child.pid = pid;
+  return child;
+}
+
+vi.mock("node:child_process", () => ({
+  fork: vi.fn((_script: string, _args: string[], _opts: unknown) => {
+    const child = makeMockChild(mockChildren.length + 1);
+    mockChildren.push(child);
+    return child;
+  }),
+}));
+
+const { createSenseWorkerPool } = await import("../worker-pool.js");
+
+async function flushSetImmediate(): Promise<void> {
+  await new Promise<void>((resolve) => setImmediate(resolve));
+}
+
+async function startWorkerWithReady(
+  pool: ReturnType<typeof createSenseWorkerPool>,
+  group: string,
+): Promise<void> {
+  const pr = pool.startWorker(group);
+  const child = mockChildren[mockChildren.length - 1];
+  child.emit("message", { type: "ready" });
+  await pr;
+}
+
+describe("createSenseWorkerPool", () => {
+  beforeEach(() => {
+    mockChildren.length = 0;
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("forks one child per startWorker and routes IPC to onWorkerMessage", async () => {
+    const onWorkerMessage = vi.fn();
+    const pool = createSenseWorkerPool({
+      nerveRoot: "/tmp/n",
+      workerScript: "/fake/sense-worker.js",
+      onWorkerMessage,
+      sensesForGroup: () => [],
+      onWorkerCrashed: vi.fn(),
+      onBeforeGroupRestart: vi.fn(),
+      isStopped: () => false,
+    });
+
+    await startWorkerWithReady(pool, "g1");
+    expect(mockChildren).toHaveLength(1);
+    const child = mockChildren[0];
+    child.emit("message", { type: "signal", sense: "s", payload: 1 });
+    expect(onWorkerMessage).toHaveBeenCalledWith({ type: "signal", sense: "s", payload: 1 });
+  });
+
+  it("sendCompute delivers to the worker for that group", async () => {
+    const pool = createSenseWorkerPool({
+      nerveRoot: "/tmp/n",
+      workerScript: "/fake/sense-worker.js",
+      onWorkerMessage: vi.fn(),
+      sensesForGroup: () => [],
+      onWorkerCrashed: vi.fn(),
+      onBeforeGroupRestart: vi.fn(),
+      isStopped: () => false,
+    });
+
+    await startWorkerWithReady(pool, "sys");
+    const child = mockChildren[0];
+    pool.sendCompute("sys", "cpu");
+    expect(child.send).toHaveBeenCalledWith(
+      expect.objectContaining({ type: "compute", sense: "cpu" }),
+    );
+  });
+
+  it("hasWorkerForGroup and getWorkerPid reflect running workers", async () => {
+    const pool = createSenseWorkerPool({
+      nerveRoot: "/tmp/n",
+      workerScript: "/fake/sense-worker.js",
+      onWorkerMessage: vi.fn(),
+      sensesForGroup: () => [],
+      onWorkerCrashed: vi.fn(),
+      onBeforeGroupRestart: vi.fn(),
+      isStopped: () => false,
+    });
+
+    expect(pool.hasWorkerForGroup("a")).toBe(false);
+    expect(pool.getWorkerPid("a")).toBeNull();
+
+    await startWorkerWithReady(pool, "a");
+    expect(pool.hasWorkerForGroup("a")).toBe(true);
+    expect(pool.getWorkerPid("a")).toBe(1);
+    expect(pool.activeGroupCount()).toBe(1);
+  });
+
+  it("evictGroup sends shutdown and removes the entry without waiting", async () => {
+    const pool = createSenseWorkerPool({
+      nerveRoot: "/tmp/n",
+      workerScript: "/fake/sense-worker.js",
+      onWorkerMessage: vi.fn(),
+      sensesForGroup: () => [],
+      onWorkerCrashed: vi.fn(),
+      onBeforeGroupRestart: vi.fn(),
+      isStopped: () => false,
+    });
+
+    await startWorkerWithReady(pool, "x");
+    expect(pool.activeGroupCount()).toBe(1);
+    pool.evictGroup("x");
+    expect(pool.hasWorkerForGroup("x")).toBe(false);
+    expect(mockChildren[0].send).toHaveBeenCalledWith(
+      expect.objectContaining({ type: "shutdown" }),
+    );
+  });
+
+  it("restartGroup invokes onBeforeGroupRestart then respawns", async () => {
+    const onBeforeGroupRestart = vi.fn();
+    const pool = createSenseWorkerPool({
+      nerveRoot: "/tmp/n",
+      workerScript: "/fake/sense-worker.js",
+      onWorkerMessage: vi.fn(),
+      sensesForGroup: () => ["s1"],
+      onWorkerCrashed: vi.fn(),
+      onBeforeGroupRestart,
+      isStopped: () => false,
+    });
+
+    await startWorkerWithReady(pool, "g");
+    expect(mockChildren).toHaveLength(1);
+
+    const p = pool.restartGroup("g");
+    expect(onBeforeGroupRestart).toHaveBeenCalledWith("g");
+    expect(mockChildren[0].send).toHaveBeenCalledWith(
+      expect.objectContaining({ type: "shutdown" }),
+    );
+
+    await flushSetImmediate();
+    expect(mockChildren).toHaveLength(2);
+    mockChildren[1].emit("message", { type: "ready" });
+    await p;
+    expect(pool.hasWorkerForGroup("g")).toBe(true);
+  });
+
+  it("onWorkerCrashed runs and schedules respawn after non-zero exit", async () => {
+    vi.useFakeTimers({ shouldAdvanceTime: true });
+    const onWorkerCrashed = vi.fn();
+    const pool = createSenseWorkerPool({
+      nerveRoot: "/tmp/n",
+      workerScript: "/fake/sense-worker.js",
+      onWorkerMessage: vi.fn(),
+      sensesForGroup: (g) => (g === "g" ? ["a", "b"] : []),
+      onWorkerCrashed,
+      onBeforeGroupRestart: vi.fn(),
+      isStopped: () => false,
+    });
+
+    await startWorkerWithReady(pool, "g");
+    expect(mockChildren).toHaveLength(1);
+    mockChildren[0].emit("exit", 1, null);
+    expect(onWorkerCrashed).toHaveBeenCalledWith("g");
+
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(mockChildren).toHaveLength(2);
+  });
+
+  it("shutdownAll sends shutdown to every worker", async () => {
+    const pool = createSenseWorkerPool({
+      nerveRoot: "/tmp/n",
+      workerScript: "/fake/sense-worker.js",
+      onWorkerMessage: vi.fn(),
+      sensesForGroup: () => [],
+      onWorkerCrashed: vi.fn(),
+      onBeforeGroupRestart: vi.fn(),
+      isStopped: () => false,
+    });
+
+    await startWorkerWithReady(pool, "a");
+    await startWorkerWithReady(pool, "b");
+    await pool.shutdownAll();
+    expect(mockChildren[0].send).toHaveBeenCalledWith(
+      expect.objectContaining({ type: "shutdown" }),
+    );
+    expect(mockChildren[1].send).toHaveBeenCalledWith(
+      expect.objectContaining({ type: "shutdown" }),
+    );
+  });
+
+  it("does not respawn after crash when isStopped is true", async () => {
+    vi.useFakeTimers({ shouldAdvanceTime: true });
+    const pool = createSenseWorkerPool({
+      nerveRoot: "/tmp/n",
+      workerScript: "/fake/sense-worker.js",
+      onWorkerMessage: vi.fn(),
+      sensesForGroup: () => [],
+      onWorkerCrashed: vi.fn(),
+      onBeforeGroupRestart: vi.fn(),
+      isStopped: () => true,
+    });
+
+    await startWorkerWithReady(pool, "g");
+    const n = mockChildren.length;
+    mockChildren[0].emit("exit", 1, null);
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(mockChildren.length).toBe(n);
+  });
+});

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

@@ -74,12 +74,18 @@ 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(() => []),
   };
 }
 
 function makeConfig(overrides: Partial<NerveConfig["workflows"]> = {}): NerveConfig {
   return {
+    maxRounds: 10,
     senses: {},
     reflexes: [],
     workflows: overrides as NerveConfig["workflows"],
@@ -109,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(
@@ -125,8 +131,8 @@ describe("WorkflowManager", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("my-workflow", { n: 1 });
+      mgr.startWorkflow("my-workflow", { prompt: "test 1", maxRounds: 10 });
-      mgr.startWorkflow("my-workflow", { n: 2 });
+      mgr.startWorkflow("my-workflow", { prompt: "test 2", maxRounds: 10 });
 
       // Only one forked child — worker is reused
       expect(mockChildren).toHaveLength(1);
@@ -141,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" }),
@@ -158,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);
@@ -175,8 +181,8 @@ describe("WorkflowManager", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("drop-wf", {});
+      mgr.startWorkflow("drop-wf", { prompt: "test", maxRounds: 10 });
-      mgr.startWorkflow("drop-wf", {});
+      mgr.startWorkflow("drop-wf", { prompt: "test", maxRounds: 10 });
 
       const droppedCall = logStore.upsertWorkflowRun.mock.calls.find(
         ([entry]) => entry.type === "dropped",
@@ -193,8 +199,8 @@ describe("WorkflowManager", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("queue-wf", { first: true });
+      mgr.startWorkflow("queue-wf", { prompt: "first", maxRounds: 10 });
-      mgr.startWorkflow("queue-wf", { second: true });
+      mgr.startWorkflow("queue-wf", { prompt: "second", maxRounds: 10 });
 
       expect(mgr.activeCount("queue-wf")).toBe(1);
       expect(mgr.queueLength("queue-wf")).toBe(1);
@@ -207,8 +213,8 @@ describe("WorkflowManager", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("queue-wf", {});
+      mgr.startWorkflow("queue-wf", { prompt: "test", maxRounds: 10 });
-      mgr.startWorkflow("queue-wf", {});
+      mgr.startWorkflow("queue-wf", { prompt: "test", maxRounds: 10 });
 
       const queuedCall = logStore.upsertWorkflowRun.mock.calls.find(
         ([entry]) => entry.type === "queued",
@@ -227,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", { prompt: "test 1", maxRounds: 10 });
-      mgr.startWorkflow("queue-wf", { n: 2 });
+      mgr.startWorkflow("queue-wf", { prompt: "test 2", maxRounds: 10 });
-      // This one should push out { n: 1 }
+      // This one should push out the oldest
-      mgr.startWorkflow("queue-wf", { n: 3 });
+      mgr.startWorkflow("queue-wf", { prompt: "test 3", maxRounds: 10 });
 
       // Queue should still be at maxQueue (2)
       expect(mgr.queueLength("queue-wf")).toBe(2);
@@ -253,8 +259,8 @@ describe("WorkflowManager", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("queue-wf", { first: true });
+      mgr.startWorkflow("queue-wf", { prompt: "first", maxRounds: 10 });
-      mgr.startWorkflow("queue-wf", { second: true });
+      mgr.startWorkflow("queue-wf", { prompt: "second", maxRounds: 10 });
 
       expect(mgr.activeCount("queue-wf")).toBe(1);
       expect(mgr.queueLength("queue-wf")).toBe(1);
@@ -288,8 +294,8 @@ describe("WorkflowManager", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("queue-wf", { first: true });
+      mgr.startWorkflow("queue-wf", { prompt: "first", maxRounds: 10 });
-      mgr.startWorkflow("queue-wf", { second: true });
+      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;
@@ -315,8 +321,8 @@ describe("WorkflowManager", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("wf-a", {});
+      mgr.startWorkflow("wf-a", { prompt: "test", maxRounds: 10 });
-      mgr.startWorkflow("wf-b", {});
+      mgr.startWorkflow("wf-b", { prompt: "test", maxRounds: 10 });
 
       // Two distinct workers should have been forked
       expect(mockChildren).toHaveLength(2);
@@ -342,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);
@@ -355,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();

packages/daemon/src/daemon-ipc.ts

@@ -5,19 +5,26 @@
  * Protocol: newline-delimited JSON messages.
  * Each request: { type: "trigger-workflow"; workflow: string; payload: unknown }
  *             | { type: "trigger-sense"; sense: string }
+ *             | { type: "list-senses" }
  * Each response: { ok: true } | { ok: false; error: string }
+ *              | { ok: true; senses: SenseInfo[] }  (for list-senses)
  */
 
 import { rmSync } from "node:fs";
 import { type Server, type Socket, createServer } from "node:net";
 
+import type { SenseInfo } from "@uncaged/nerve-core";
+
 import type { WorkflowManager } from "./workflow-manager.js";
 
+export type { SenseInfo };
+
 /** JSON message sent by the CLI to trigger a workflow. */
 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. */
@@ -26,9 +33,17 @@ export type TriggerSenseRequest = {
   sense: string;
 };
 
-type DaemonRequest = TriggerWorkflowRequest | TriggerSenseRequest;
+/** JSON message sent by the CLI to list registered senses. */
+export type ListSensesRequest = {
+  type: "list-senses";
+};
 
-type DaemonResponse = { ok: true } | { ok: false; error: string };
+type DaemonRequest = TriggerWorkflowRequest | TriggerSenseRequest | ListSensesRequest;
+
+type DaemonResponse =
+  | { ok: true }
+  | { ok: false; error: string }
+  | { ok: true; senses: SenseInfo[] };
 
 export type DaemonIpcServer = {
   close: () => Promise<void>;
@@ -41,12 +56,17 @@ 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;
       return { type: "trigger-sense", sense: req.sense };
     }
+    if (req.type === "list-senses") {
+      return { type: "list-senses" };
+    }
     return null;
   } catch {
     return null;
@@ -56,6 +76,8 @@ function parseRequest(line: string): DaemonRequest | null {
 export type DaemonIpcServerOptions = {
   /** Called when a trigger-sense request arrives. Should throw if the sense is unknown. */
   triggerSense: (senseName: string) => void;
+  /** Called when a list-senses request arrives. Returns sense info for all registered senses. */
+  listSenses: () => SenseInfo[];
 };
 
 export function createDaemonIpcServer(
@@ -83,12 +105,18 @@ 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") {
         opts.triggerSense(req.sense);
+        const resp: DaemonResponse = { ok: true };
+        socket.write(`${JSON.stringify(resp)}\n`);
+      } else if (req.type === "list-senses") {
+        const senses = opts.listSenses();
+        const resp: DaemonResponse = { ok: true, senses };
+        socket.write(`${JSON.stringify(resp)}\n`);
       }
-      const resp: DaemonResponse = { ok: true };
-      socket.write(`${JSON.stringify(resp)}\n`);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       const resp: DaemonResponse = { ok: false, error: msg };

packages/daemon/src/index.ts

@@ -12,6 +12,7 @@ export type {
   ResumeThreadMessage,
   ThreadEventMessage,
   WorkflowErrorMessage,
+  ThreadWorkflowMessageMessage,
 } from "./ipc.js";
 
 export type { SignalBus, SignalHandler, Unsubscribe } from "./signal-bus.js";
@@ -29,17 +30,30 @@ export {
 export { createKernel } from "./kernel.js";
 export type { Kernel, KernelOptions, KernelHealth } from "./kernel.js";
 
+export type { SenseInfo } from "./daemon-ipc.js";
+
 export { createFileWatcher } from "./file-watcher.js";
 export type { FileWatcher, FileChange, FileChangeHandler } from "./file-watcher.js";
 
-export { createLogStore } from "./log-store.js";
+export {
+  createBlobStore,
+  createLogStore,
+  LOG_ARCHIVE_META_KEY,
+  normalizeBlobHash,
+} from "@uncaged/nerve-store";
 export type {
-  LogStore,
+  ArchiveLogsDayResult,
+  ArchiveLogsOptions,
+  ArchiveLogsResult,
+  BlobStore,
+  GetThreadRoundsParams,
   LogEntry,
   LogQuery,
+  LogStore,
+  ThreadRoundRow,
   WorkflowRun,
   WorkflowRunStatus,
-} from "./log-store.js";
+} from "@uncaged/nerve-store";
 
 export { createWorkflowManager } from "./workflow-manager.js";
 export type { WorkflowManager } from "./workflow-manager.js";

packages/daemon/src/ipc.ts

@@ -31,18 +31,19 @@ export type StartThreadMessage = {
   type: "start-thread";
   runId: string;
   workflow: string;
-  /** The trigger payload from the Reflex that initiated this thread. */
+  prompt: string;
-  triggerPayload: unknown;
+  /** 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. */
+  /** Serialised WorkflowMessage history to rebuild chain (must begin with `__start__`). */
-  events: Array<{ type: string; [key: string]: unknown }>;
+  messages: Array<{ role: string; content: string; meta: unknown; timestamp: number }>;
-  /** Serialised trigger payload (the same value as in the original start-thread). */
+  /** Safety-valve: max moderator rounds for this thread. */
-  triggerPayload: unknown;
+  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). */
+/** Workflow Worker → Parent: a WorkflowMessage produced by a role (for crash recovery). */
-export type ThreadCommandEventMessage = {
+export type ThreadWorkflowMessageMessage = {
-  type: "thread-command-event";
+  type: "thread-workflow-message";
   runId: string;
-  /** The CommandEvent returned by role.execute() — will be persisted for crash recovery. */
+  /** The WorkflowMessage produced by the role — persisted for crash recovery. */
-  event: { type: string; [key: string]: unknown };
+  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 (!Array.isArray(obj.messages)) return "'resume-thread' message missing 'messages' array";
-  if (!("triggerPayload" in obj)) return "'resume-thread' message missing 'triggerPayload'";
+  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") {
+  if (obj.message === null || typeof obj.message !== "object") {
-    return err(new Error("Worker 'thread-command-event' message missing object 'event' field"));
+    return err(new Error("Worker 'thread-workflow-message' missing object 'message' field"));
   }
-  const event = obj.event as Record<string, unknown>;
+  const msg = obj.message as Record<string, unknown>;
-  if (typeof event.type !== "string") {
+  if (typeof msg.role !== "string") {
-    return err(new Error("Worker 'thread-command-event' event missing string 'type' field"));
+    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" });
 }

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

@@ -0,0 +1,92 @@
+/**
+ * File-watcher callbacks for nerve.yaml / sense / workflow sources (hot reload wiring).
+ */
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { NerveConfig } from "@uncaged/nerve-core";
+import { parseNerveConfig } from "@uncaged/nerve-core";
+
+import type { LogStore } from "@uncaged/nerve-store";
+import type { WorkflowManager } from "./workflow-manager.js";
+
+export type KernelFileWatchDeps = {
+  nerveRoot: string;
+  getConfig: () => NerveConfig;
+  logStore: LogStore;
+  workflowManager: WorkflowManager;
+  restartGroup: (group: string) => Promise<void>;
+  reloadConfig: (newConfig: NerveConfig) => void;
+};
+
+export type KernelFileWatchHandlers = {
+  onSenseFileChange: (senseName: string) => void;
+  onWorkflowFileChange: (workflowName: string) => void;
+  onConfigFileChange: () => void;
+};
+
+export function createKernelFileWatchHandlers(deps: KernelFileWatchDeps): KernelFileWatchHandlers {
+  function onSenseFileChange(senseName: string): void {
+    const sc = deps.getConfig().senses[senseName];
+    if (sc === undefined) return;
+    process.stderr.write(
+      `[kernel] sense file changed: "${senseName}", restarting group "${sc.group}"\n`,
+    );
+    deps.logStore.append({
+      source: "system",
+      type: "sense_reload",
+      refId: senseName,
+      payload: null,
+      ts: Date.now(),
+    });
+    deps.restartGroup(sc.group).catch((e) => {
+      const msg = e instanceof Error ? e.message : String(e);
+      process.stderr.write(`[kernel] restartGroup error: ${msg}\n`);
+    });
+  }
+
+  function onWorkflowFileChange(workflowName: string): void {
+    process.stderr.write(
+      `[kernel] workflow file changed: "${workflowName}", draining and respawning worker\n`,
+    );
+    deps.logStore.append({
+      source: "system",
+      type: "workflow_reload",
+      refId: workflowName,
+      payload: null,
+      ts: Date.now(),
+    });
+    deps.workflowManager.drainAndRespawn(workflowName).catch((e) => {
+      const msg = e instanceof Error ? e.message : String(e);
+      process.stderr.write(`[kernel] drainAndRespawn error for "${workflowName}": ${msg}\n`);
+    });
+  }
+
+  function onConfigFileChange(): void {
+    process.stderr.write("[kernel] nerve.yaml changed, reloading config\n");
+    deps.logStore.append({
+      source: "system",
+      type: "config_reload",
+      refId: null,
+      payload: null,
+      ts: Date.now(),
+    });
+    try {
+      const raw = readFileSync(join(deps.nerveRoot, "nerve.yaml"), "utf8");
+      const parseResult = parseNerveConfig(raw);
+      if (!parseResult.ok) {
+        process.stderr.write(
+          `[kernel] config parse error, keeping current config: ${parseResult.error.message}\n`,
+        );
+        return;
+      }
+      deps.reloadConfig(parseResult.value);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      process.stderr.write(`[kernel] failed to read nerve.yaml, keeping current config: ${msg}\n`);
+    }
+  }
+
+  return { onSenseFileChange, onWorkflowFileChange, onConfigFileChange };
+}

packages/daemon/src/kernel-sense-groups.ts

@@ -0,0 +1,29 @@
+import type { NerveConfig } from "@uncaged/nerve-core";
+
+export function groupForSense(config: NerveConfig, senseName: string): string | null {
+  const senseConfig = config.senses[senseName];
+  if (senseConfig === undefined) return null;
+  return senseConfig.group;
+}
+
+export function senseNamesInGroup(config: NerveConfig, group: string): string[] {
+  return Object.entries(config.senses)
+    .filter(([, sc]) => sc.group === group)
+    .map(([name]) => name);
+}
+
+export function collectSenseGroups(cfg: NerveConfig): Set<string> {
+  const result = new Set<string>();
+  for (const sc of Object.values(cfg.senses)) {
+    result.add(sc.group);
+  }
+  return result;
+}
+
+export function senseNamesInGroupAsSet(cfg: NerveConfig, group: string): Set<string> {
+  const result = new Set<string>();
+  for (const [name, sc] of Object.entries(cfg.senses)) {
+    if (sc.group === group) result.add(name);
+  }
+  return result;
+}

packages/daemon/src/kernel.ts

@@ -1,38 +1,32 @@
 /**
- * Kernel — the main orchestrator that ties sense workers, signal bus, and
+ * Kernel — ties sense workers, signal bus, reflex scheduler, workflow manager,
- * reflex scheduler together.
+ * optional file watcher, and daemon IPC.
- *
- * Responsibilities:
- *   - Spawn one child process per sense group (via fork)
- *   - Route SignalMessage from workers → SignalBus
- *   - Route ErrorMessage from workers → stderr log
- *   - Drive compute triggers via ReflexScheduler
- *   - Graceful shutdown: stop scheduler, send shutdown to all workers
- *   - Hot reload: restartGroup, reloadConfig, file watcher integration
- *   - Health reporting: getHealth
  */
 
-import { fork } from "node:child_process";
+import { join } from "node:path";
-import type { ChildProcess } from "node:child_process";
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
 
-import type { NerveConfig, Signal } from "@uncaged/nerve-core";
+import type { NerveConfig, SenseInfo, Signal } from "@uncaged/nerve-core";
-import { parseNerveConfig } from "@uncaged/nerve-core";
+import { routeSenseComputeOutput } from "@uncaged/nerve-core";
 
+import { createLogStore } from "@uncaged/nerve-store";
+import type { LogStore } from "@uncaged/nerve-store";
 import { createDaemonIpcServer } from "./daemon-ipc.js";
 import type { DaemonIpcServer } from "./daemon-ipc.js";
 import { createFileWatcher } from "./file-watcher.js";
 import type { FileWatcher } from "./file-watcher.js";
-import type { ComputeMessage, ShutdownMessage } from "./ipc.js";
 import { parseWorkerMessage } from "./ipc.js";
-import { createLogStore } from "./log-store.js";
+import { createKernelFileWatchHandlers } from "./kernel-file-watch.js";
-import type { LogStore } from "./log-store.js";
+import {
+  collectSenseGroups,
+  groupForSense,
+  senseNamesInGroup,
+  senseNamesInGroupAsSet,
+} from "./kernel-sense-groups.js";
 import { createReflexScheduler } from "./reflex-scheduler.js";
 import type { ReflexScheduler } from "./reflex-scheduler.js";
 import { createSignalBus } from "./signal-bus.js";
 import type { SignalBus } from "./signal-bus.js";
+import { createSenseWorkerPool, resolveWorkerScript } from "./worker-pool.js";
 import { createWorkflowManager } from "./workflow-manager.js";
 import type { WorkflowManager } from "./workflow-manager.js";
 
@@ -52,80 +46,19 @@ export type Kernel = {
   bus: SignalBus;
   logStore: LogStore;
   workflowManager: WorkflowManager;
-  /** Resolves when all workers have sent their initial "ready" message. */
   ready: Promise<void>;
-  /** Returns the PID of the worker process for a given group, or null if not found. */
   getWorkerPid: (group: string) => number | null;
-  /** Sends a compute message to the worker responsible for the given sense. */
   triggerCompute: (senseName: string) => void;
-  /**
-   * On-demand sense trigger — looks up the group for `senseName`, finds its worker,
-   * and sends a compute message. Throws if the sense is unknown.
-   */
   triggerSense: (senseName: string) => void;
-  /** Gracefully restart a group worker (wait for exit, then respawn). */
   restartGroup: (group: string) => Promise<void>;
-  /** Reload config from a new NerveConfig, incrementally updating scheduler and workers.
-   * Note: any pending/throttled computes in the old scheduler are silently dropped on reload.
-   * In-flight state is not preserved across reloadConfig. */
   reloadConfig: (newConfig: NerveConfig) => void;
-  /** Return daemon health info. */
   getHealth: () => KernelHealth;
 };
 
-type WorkerEntry = {
-  group: string;
-  process: ChildProcess;
-};
-
-function resolveWorkerScript(): string {
-  const __filename = fileURLToPath(import.meta.url);
-  const __dir = dirname(__filename);
-  return join(__dir, "sense-worker.js");
-}
-
-function spawnWorker(nerveRoot: string, group: string, workerScript: string): ChildProcess {
-  return fork(workerScript, ["--group", group, "--root", nerveRoot], {
-    stdio: ["ignore", "inherit", "inherit", "ipc"],
-  });
-}
-
-function sendCompute(worker: ChildProcess, senseName: string): void {
-  // worker.connected is false when the IPC channel has been closed (e.g. worker crashed)
-  if (worker.connected === false) return;
-  const msg: ComputeMessage = { type: "compute", sense: senseName };
-  try {
-    worker.send(msg);
-  } catch {
-    // IPC channel closed between connected check and send
-  }
-}
-
-function sendShutdown(worker: ChildProcess): void {
-  if (worker.connected === false) return;
-  const msg: ShutdownMessage = { type: "shutdown" };
-  try {
-    worker.send(msg);
-  } catch {
-    // IPC channel closed between connected check and send
-  }
-}
-
-function groupForSense(config: NerveConfig, senseName: string): string | null {
-  const senseConfig = config.senses[senseName];
-  if (senseConfig === undefined) return null;
-  return senseConfig.group;
-}
-
 export type KernelOptions = {
   workerScript?: string | null;
   enableFileWatcher?: boolean;
-  /** Override the LogStore instance (useful for testing). */
   logStore?: LogStore;
-  /**
-   * Unix socket path for the daemon IPC server (used by CLI to send trigger-workflow).
-   * When null, the IPC server is not started (e.g. during tests).
-   */
   ipcSocketPath?: string | null;
 };
 
@@ -166,7 +99,6 @@ export function createKernel(
     groups.add(senseConfig.group);
   }
 
-  const workers = new Map<string, WorkerEntry>();
   let stopped = false;
   let scheduler: ReflexScheduler = null as unknown as ReflexScheduler;
 
@@ -176,10 +108,10 @@ export function createKernel(
   });
   let pendingReadyCount = groups.size > 0 ? groups.size : 0;
 
-  function sensesForGroup(group: string): string[] {
+  function clearSchedulerForGroup(group: string): void {
-    return Object.entries(config.senses)
+    for (const senseName of senseNamesInGroup(config, group)) {
-      .filter(([, sc]) => sc.group === group)
+      scheduler.onComputeComplete(senseName);
-      .map(([name]) => name);
+    }
   }
 
   function handleWorkerMessage(raw: unknown): void {
@@ -212,64 +144,46 @@ export function createKernel(
     }
 
     if (msg.type === "signal") {
-      const signal: Signal = {
+      const route = routeSenseComputeOutput(msg.payload);
-        id: nextSignalId(),
+      if (route.kind === "launch") {
-        senseId: msg.sense,
+        const { workflowName, maxRounds, prompt } = route.launch;
-        payload: msg.payload,
+        workflowManager.startWorkflow(workflowName, { prompt, maxRounds });
-        ts: Date.now(),
+        logStore.append({
-      };
+          source: "sense",
-      logStore.append({
+          type: "workflow-launch",
-        source: "reflex",
+          refId: msg.sense,
-        type: "run_complete",
+          payload: JSON.stringify(route.launch),
-        refId: msg.sense,
+          ts: Date.now(),
-        payload: JSON.stringify(msg.payload),
+        });
-        ts: signal.ts,
+      } else {
-      });
+        const signal: Signal = {
-      bus.emit(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);
     }
-
-    // health-response is handled externally by the caller; no action needed here
   }
 
-  function startWorker(group: string): Promise<void> {
+  const senseWorkerPool = createSenseWorkerPool({
-    const child = spawnWorker(nerveRoot, group, workerScript);
+    nerveRoot,
-
+    workerScript,
-    let workerReadyResolve: (() => void) | undefined;
+    onWorkerMessage: handleWorkerMessage,
-    const workerReady = new Promise<void>((resolve) => {
+    sensesForGroup: (group) => senseNamesInGroup(config, group),
-      workerReadyResolve = resolve;
+    onWorkerCrashed: clearSchedulerForGroup,
-    });
+    onBeforeGroupRestart: clearSchedulerForGroup,
-
+    isStopped: () => stopped,
-    child.on("message", (raw: unknown) => {
+  });
-      const result = parseWorkerMessage(raw);
-      if (result.ok && result.value.type === "ready") {
-        workerReadyResolve?.();
-      }
-      handleWorkerMessage(raw);
-    });
-
-    child.on("exit", (code) => {
-      process.stderr.write(
-        `[kernel] worker for group "${group}" exited with code ${code ?? "null"}\n`,
-      );
-      // Resolve ready in case the worker exits before sending ready (prevents hangs)
-      workerReadyResolve?.();
-      if (!stopped && code !== 0) {
-        process.stderr.write(`[kernel] respawning worker for group "${group}" in 1s\n`);
-        for (const senseName of sensesForGroup(group)) {
-          scheduler.onComputeComplete(senseName);
-        }
-        setTimeout(() => {
-          if (!stopped) {
-            startWorker(group);
-          }
-        }, 1000);
-      }
-    });
-
-    workers.set(group, { group, process: child });
-    return workerReady;
-  }
 
   function triggerFn(senseName: string): void {
     const group = groupForSense(config, senseName);
@@ -277,12 +191,7 @@ export function createKernel(
       process.stderr.write(`[kernel] triggerFn: unknown sense "${senseName}"\n`);
       return;
     }
-    const entry = workers.get(group);
+    senseWorkerPool.sendCompute(group, senseName);
-    if (entry === undefined) {
-      process.stderr.write(`[kernel] triggerFn: no worker for group "${group}"\n`);
-      return;
-    }
-    sendCompute(entry.process, senseName);
   }
 
   function triggerSense(senseName: string): void {
@@ -290,18 +199,14 @@ export function createKernel(
     if (group === null) {
       throw new Error(`Unknown sense: "${senseName}"`);
     }
-    const entry = workers.get(group);
+    if (!senseWorkerPool.hasWorkerForGroup(group)) {
-    if (entry === undefined) {
       throw new Error(`No worker running for group "${group}" (sense: "${senseName}")`);
     }
-    sendCompute(entry.process, senseName);
+    senseWorkerPool.sendCompute(group, senseName);
   }
 
   scheduler = createReflexScheduler(config, bus, triggerFn, {
     logStore,
-    workflowTriggerFn: (workflowName, payload) => {
-      workflowManager.startWorkflow(workflowName, payload);
-    },
   });
 
   if (groups.size === 0) {
@@ -309,63 +214,13 @@ export function createKernel(
   }
 
   for (const group of groups) {
-    startWorker(group);
+    senseWorkerPool.startWorker(group);
-  }
-
-  function waitForExit(child: ChildProcess, timeoutMs: number): Promise<void> {
-    return new Promise((resolve) => {
-      const timer = setTimeout(() => {
-        child.kill("SIGKILL");
-        resolve();
-      }, timeoutMs);
-      child.once("exit", () => {
-        clearTimeout(timer);
-        resolve();
-      });
-    });
-  }
-
-  // --- restartGroup: gracefully stop worker, then respawn and await ready ---
-  async function restartGroup(group: string): Promise<void> {
-    const entry = workers.get(group);
-    if (entry === undefined) return;
-
-    for (const senseName of sensesForGroup(group)) {
-      scheduler.onComputeComplete(senseName);
-    }
-
-    sendShutdown(entry.process);
-    await waitForExit(entry.process, 5000);
-
-    if (!stopped) {
-      await startWorker(group);
-    }
-  }
-
-  function collectGroups(cfg: NerveConfig): Set<string> {
-    const result = new Set<string>();
-    for (const sc of Object.values(cfg.senses)) {
-      result.add(sc.group);
-    }
-    return result;
-  }
-
-  function sensesForGroupInConfig(cfg: NerveConfig, group: string): Set<string> {
-    const result = new Set<string>();
-    for (const [name, sc] of Object.entries(cfg.senses)) {
-      if (sc.group === group) result.add(name);
-    }
-    return result;
   }
 
   function removeStaleGroups(oldGroups: Set<string>, newGroups: Set<string>): void {
     for (const g of oldGroups) {
       if (newGroups.has(g)) continue;
-      const entry = workers.get(g);
+      senseWorkerPool.evictGroup(g);
-      if (entry !== undefined) {
-        sendShutdown(entry.process);
-        workers.delete(g);
-      }
       groups.delete(g);
     }
   }
@@ -374,30 +229,25 @@ export function createKernel(
     for (const g of newGroups) {
       if (oldGroups.has(g)) continue;
       groups.add(g);
-      if (!stopped) startWorker(g);
+      if (!stopped) {
+        senseWorkerPool.startWorker(g);
+      }
     }
   }
 
   function reloadConfig(newConfig: NerveConfig): void {
-    const oldGroups = collectGroups(config);
+    const oldGroups = collectSenseGroups(config);
     const oldConfig = config;
     const oldWorkflows = config.workflows ?? {};
     config = newConfig;
-    // Note: pending/throttled computes in the old scheduler are silently dropped here.
-    // In-flight state is not preserved across reloadConfig.
     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);
 
     const newWorkflows = newConfig.workflows ?? {};
 
-    // Drain + remove workers for deleted workflows
     for (const workflowName of Object.keys(oldWorkflows)) {
       if (!(workflowName in newWorkflows)) {
         process.stderr.write(
@@ -412,20 +262,17 @@ export function createKernel(
       }
     }
 
-    const newGroups = collectGroups(newConfig);
+    const newGroups = collectSenseGroups(newConfig);
     removeStaleGroups(oldGroups, newGroups);
     addNewGroups(oldGroups, newGroups);
 
-    // Restart existing groups that gained new senses — the running worker process
-    // was spawned with the old config and will report "Unknown sense" for any newly
-    // added sense until it is restarted.
     for (const g of newGroups) {
-      if (!oldGroups.has(g)) continue; // already handled by addNewGroups
+      if (!oldGroups.has(g)) continue;
-      const oldSenses = sensesForGroupInConfig(oldConfig, g);
+      const oldSenses = senseNamesInGroupAsSet(oldConfig, g);
-      const newSenses = sensesForGroupInConfig(newConfig, g);
+      const newSenses = senseNamesInGroupAsSet(newConfig, g);
       const gained = [...newSenses].some((s) => !oldSenses.has(s));
       if (gained) {
-        restartGroup(g).catch((e) => {
+        senseWorkerPool.restartGroup(g).catch((e) => {
           const msg = e instanceof Error ? e.message : String(e);
           process.stderr.write(`[kernel] reloadConfig restartGroup error for "${g}": ${msg}\n`);
         });
@@ -437,80 +284,28 @@ export function createKernel(
     return {
       uptime: Date.now() - startTime,
       activeSenses: Object.keys(config.senses).length,
-      activeGroups: workers.size,
+      activeGroups: senseWorkerPool.activeGroupCount(),
       pendingComputes: 0,
       activeWorkflows: workflowManager.totalActiveCount(),
       memoryUsage: process.memoryUsage(),
     };
   }
 
-  function handleSenseFileChange(senseName: string): void {
+  const fileWatchHandlers = createKernelFileWatchHandlers({
-    const sc = config.senses[senseName];
+    nerveRoot,
-    if (sc === undefined) return;
+    getConfig: () => config,
-    process.stderr.write(
+    logStore,
-      `[kernel] sense file changed: "${senseName}", restarting group "${sc.group}"\n`,
+    workflowManager,
-    );
+    restartGroup: (group) => senseWorkerPool.restartGroup(group),
-    logStore.append({
+    reloadConfig,
-      source: "system",
+  });
-      type: "sense_reload",
-      refId: senseName,
-      payload: null,
-      ts: Date.now(),
-    });
-    restartGroup(sc.group).catch((e) => {
-      const msg = e instanceof Error ? e.message : String(e);
-      process.stderr.write(`[kernel] restartGroup error: ${msg}\n`);
-    });
-  }
-
-  function handleWorkflowFileChange(workflowName: string): void {
-    process.stderr.write(
-      `[kernel] workflow file changed: "${workflowName}", draining and respawning worker\n`,
-    );
-    logStore.append({
-      source: "system",
-      type: "workflow_reload",
-      refId: workflowName,
-      payload: null,
-      ts: Date.now(),
-    });
-    workflowManager.drainAndRespawn(workflowName).catch((e) => {
-      const msg = e instanceof Error ? e.message : String(e);
-      process.stderr.write(`[kernel] drainAndRespawn error for "${workflowName}": ${msg}\n`);
-    });
-  }
-
-  function handleConfigFileChange(): void {
-    process.stderr.write("[kernel] nerve.yaml changed, reloading config\n");
-    logStore.append({
-      source: "system",
-      type: "config_reload",
-      refId: null,
-      payload: null,
-      ts: Date.now(),
-    });
-    try {
-      const raw = readFileSync(join(nerveRoot, "nerve.yaml"), "utf8");
-      const parseResult = parseNerveConfig(raw);
-      if (!parseResult.ok) {
-        process.stderr.write(
-          `[kernel] config parse error, keeping current config: ${parseResult.error.message}\n`,
-        );
-        return;
-      }
-      reloadConfig(parseResult.value);
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      process.stderr.write(`[kernel] failed to read nerve.yaml, keeping current config: ${msg}\n`);
-    }
-  }
 
   let fileWatcher: FileWatcher | null = null;
   if (options.enableFileWatcher) {
     fileWatcher = createFileWatcher(nerveRoot, (change) => {
-      if (change.kind === "sense") handleSenseFileChange(change.senseName);
+      if (change.kind === "sense") fileWatchHandlers.onSenseFileChange(change.senseName);
-      if (change.kind === "config") handleConfigFileChange();
+      if (change.kind === "config") fileWatchHandlers.onConfigFileChange();
-      if (change.kind === "workflow") handleWorkflowFileChange(change.workflowName);
+      if (change.kind === "workflow") fileWatchHandlers.onWorkflowFileChange(change.workflowName);
     });
   }
 
@@ -518,6 +313,23 @@ export function createKernel(
   if (options.ipcSocketPath != null) {
     ipcServer = createDaemonIpcServer(options.ipcSocketPath, workflowManager, {
       triggerSense,
+      listSenses(): SenseInfo[] {
+        return Object.entries(config.senses).map(([name, senseConfig]) => {
+          const entries = logStore.query({
+            source: "sense",
+            type: "signal",
+            refId: name,
+          });
+          const lastEntry = entries.length > 0 ? entries[entries.length - 1] : null;
+          return {
+            name,
+            group: senseConfig.group,
+            throttle: senseConfig.throttle,
+            timeout: senseConfig.timeout,
+            lastSignalTs: lastEntry !== null ? lastEntry.ts : null,
+          };
+        });
+      },
     });
   }
 
@@ -533,12 +345,7 @@ export function createKernel(
     }
     scheduler.stop();
     await workflowManager.stop();
-    const exitPromises: Promise<void>[] = [];
+    await senseWorkerPool.shutdownAll();
-    for (const entry of workers.values()) {
-      sendShutdown(entry.process);
-      exitPromises.push(waitForExit(entry.process, 5000));
-    }
-    await Promise.all(exitPromises);
     logStore.append({
       source: "system",
       type: "stop",
@@ -550,7 +357,7 @@ export function createKernel(
   }
 
   function getWorkerPid(group: string): number | null {
-    return workers.get(group)?.process.pid ?? null;
+    return senseWorkerPool.getWorkerPid(group);
   }
 
   const senseCount = Object.keys(config.senses).length;
@@ -566,7 +373,7 @@ export function createKernel(
     getWorkerPid,
     triggerCompute: triggerFn,
     triggerSense,
-    restartGroup,
+    restartGroup: (group) => senseWorkerPool.restartGroup(group),
     reloadConfig,
     getHealth,
   };

packages/daemon/src/log-store.ts

@@ -1,379 +0,0 @@
-/**
- * Log Store — append-only structured log storage backed by SQLite.
- *
- * Stores system, reflex, and workflow log entries in a single table.
- * Logs are data assets for audit/analysis — they MUST NOT trigger reflexes.
- *
- * Also provides a `meta` key-value table for bookkeeping (e.g. archive watermarks).
- */
-
-import { mkdirSync } from "node:fs";
-import { dirname } from "node:path";
-import Database from "better-sqlite3";
-import type BetterSqlite3 from "better-sqlite3";
-
-export type LogEntry = {
-  id?: number;
-  source: string;
-  type: string;
-  refId: string | null;
-  payload: string | null;
-  ts: number;
-};
-
-export type LogQuery = {
-  source?: string;
-  type?: string;
-  refId?: string;
-  since?: number;
-  until?: number;
-  limit?: number;
-};
-
-// ---------------------------------------------------------------------------
-// Workflow runs materialized view (RFC-002 §6.2)
-// ---------------------------------------------------------------------------
-
-export type WorkflowRunStatus =
-  | "queued"
-  | "started"
-  | "completed"
-  | "failed"
-  | "crashed"
-  | "dropped"
-  | "interrupted";
-
-const VALID_WORKFLOW_STATUSES = new Set<string>([
-  "queued",
-  "started",
-  "completed",
-  "failed",
-  "crashed",
-  "dropped",
-  "interrupted",
-]);
-
-function validateWorkflowRunStatus(status: string): WorkflowRunStatus {
-  if (!VALID_WORKFLOW_STATUSES.has(status)) {
-    throw new Error(`Invalid workflow run status from DB: "${status}"`);
-  }
-  return status as WorkflowRunStatus;
-}
-
-/** One row in the workflow_runs materialized table. */
-export type WorkflowRun = {
-  runId: string;
-  workflow: string;
-  status: WorkflowRunStatus;
-  ts: number;
-};
-
-export type LogStore = {
-  append: (entry: Omit<LogEntry, "id">) => LogEntry;
-  query: (filter?: LogQuery) => LogEntry[];
-  getMeta: (key: string) => string | null;
-  setMeta: (key: string, value: string) => void;
-  /**
-   * Append a workflow log event and atomically upsert the workflow_runs
-   * materialized table — both in a single SQLite transaction (RFC-002 §6.2).
-   */
-  upsertWorkflowRun: (entry: Omit<LogEntry, "id">, run: WorkflowRun) => LogEntry;
-  /**
-   * Alias for upsertWorkflowRun — append a log entry and update workflow_runs
-   * in one atomic transaction.
-   */
-  appendWithWorkflowUpdate: (entry: Omit<LogEntry, "id">, run: WorkflowRun) => LogEntry;
-  /** Get the current materialized state of a specific workflow run. */
-  getWorkflowRun: (runId: string) => WorkflowRun | null;
-  /**
-   * Get all workflow runs with status 'queued' or 'started'.
-   * Optionally filter by workflow name.
-   */
-  getActiveWorkflowRuns: (workflowName?: string) => WorkflowRun[];
-  /**
-   * Get all workflow runs regardless of status, sorted by ts descending.
-   * Optionally filter by workflow name.
-   */
-  getAllWorkflowRuns: (workflowName: string | null) => WorkflowRun[];
-  /**
-   * Get the trigger payload for a workflow run (stored in the 'started' log entry).
-   * Returns null if not found.
-   */
-  getTriggerPayload: (runId: string) => unknown;
-  /**
-   * Get all workflow CommandEvents for a specific run, ordered by id ASC.
-   * Used for crash recovery to rebuild ThreadState.
-   */
-  getThreadEvents: (runId: string) => Array<{ type: string; [key: string]: unknown }>;
-  close: () => void;
-};
-
-const SCHEMA_SQL = `
-CREATE TABLE IF NOT EXISTS logs (
-  id      INTEGER PRIMARY KEY AUTOINCREMENT,
-  source  TEXT NOT NULL,
-  type    TEXT NOT NULL,
-  ref_id  TEXT,
-  payload TEXT,
-  ts      INTEGER NOT NULL
-);
-
-CREATE INDEX IF NOT EXISTS idx_logs_source_type ON logs(source, type);
-CREATE INDEX IF NOT EXISTS idx_logs_ts ON logs(ts);
-CREATE INDEX IF NOT EXISTS idx_logs_ref_id ON logs(ref_id);
-
-CREATE TABLE IF NOT EXISTS meta (
-  key   TEXT PRIMARY KEY,
-  value TEXT NOT NULL
-);
-
-CREATE TABLE IF NOT EXISTS workflow_runs (
-  run_id   TEXT PRIMARY KEY,
-  workflow TEXT NOT NULL,
-  status   TEXT NOT NULL,
-  ts       INTEGER NOT NULL
-);
-
-CREATE INDEX IF NOT EXISTS idx_workflow_runs_status ON workflow_runs(status);
-CREATE INDEX IF NOT EXISTS idx_workflow_runs_workflow ON workflow_runs(workflow);
-`;
-
-export function createLogStore(dbPath: string): LogStore {
-  mkdirSync(dirname(dbPath), { recursive: true });
-
-  const sqlite: BetterSqlite3.Database = new Database(dbPath);
-  sqlite.pragma("journal_mode = WAL");
-  sqlite.exec(SCHEMA_SQL);
-
-  const insertStmt = sqlite.prepare(
-    "INSERT INTO logs (source, type, ref_id, payload, ts) VALUES (@source, @type, @refId, @payload, @ts)",
-  );
-
-  const getMetaStmt = sqlite.prepare("SELECT value FROM meta WHERE key = ?");
-  const setMetaStmt = sqlite.prepare(
-    "INSERT INTO meta (key, value) VALUES (@key, @value) ON CONFLICT(key) DO UPDATE SET value = @value",
-  );
-
-  const upsertWorkflowRunStmt = sqlite.prepare(
-    "INSERT OR REPLACE INTO workflow_runs (run_id, workflow, status, ts) VALUES (@runId, @workflow, @status, @ts)",
-  );
-
-  const getWorkflowRunStmt = sqlite.prepare(
-    "SELECT run_id, workflow, status, ts FROM workflow_runs WHERE run_id = ?",
-  );
-
-  const getTriggerPayloadStmt = sqlite.prepare(
-    "SELECT payload FROM logs WHERE source = 'workflow' AND type = 'started' AND ref_id = ? ORDER BY id ASC LIMIT 1",
-  );
-
-  const getThreadEventsStmt = sqlite.prepare(
-    "SELECT payload FROM logs WHERE source = 'workflow' AND type = 'thread_command_event' AND ref_id = ? ORDER BY id ASC",
-  );
-
-  const getActiveWorkflowRunsStmt = sqlite.prepare(
-    "SELECT run_id, workflow, status, ts FROM workflow_runs WHERE status IN ('queued', 'started') ORDER BY ts ASC",
-  );
-
-  const getActiveWorkflowRunsByNameStmt = sqlite.prepare(
-    "SELECT run_id, workflow, status, ts FROM workflow_runs WHERE status IN ('queued', 'started') AND workflow = ? ORDER BY ts ASC",
-  );
-
-  const getAllWorkflowRunsStmt = sqlite.prepare(
-    "SELECT run_id, workflow, status, ts FROM workflow_runs ORDER BY ts DESC",
-  );
-
-  const getAllWorkflowRunsByNameStmt = sqlite.prepare(
-    "SELECT run_id, workflow, status, ts FROM workflow_runs WHERE workflow = ? ORDER BY ts DESC",
-  );
-
-  const upsertWorkflowRunTx = sqlite.transaction(
-    (entry: Omit<LogEntry, "id">, run: WorkflowRun) => {
-      const info = insertStmt.run({
-        source: entry.source,
-        type: entry.type,
-        refId: entry.refId,
-        payload: entry.payload,
-        ts: entry.ts,
-      });
-      upsertWorkflowRunStmt.run({
-        runId: run.runId,
-        workflow: run.workflow,
-        status: run.status,
-        ts: run.ts,
-      });
-      return { ...entry, id: Number(info.lastInsertRowid) };
-    },
-  );
-
-  function append(entry: Omit<LogEntry, "id">): LogEntry {
-    const info = insertStmt.run({
-      source: entry.source,
-      type: entry.type,
-      refId: entry.refId,
-      payload: entry.payload,
-      ts: entry.ts,
-    });
-    return { ...entry, id: Number(info.lastInsertRowid) };
-  }
-
-  function query(filter: LogQuery = {}): LogEntry[] {
-    const conditions: string[] = [];
-    const params: Record<string, unknown> = {};
-
-    if (filter.source !== undefined) {
-      conditions.push("source = @source");
-      params.source = filter.source;
-    }
-    if (filter.type !== undefined) {
-      conditions.push("type = @type");
-      params.type = filter.type;
-    }
-    if (filter.refId !== undefined) {
-      conditions.push("ref_id = @refId");
-      params.refId = filter.refId;
-    }
-    if (filter.since !== undefined) {
-      conditions.push("ts >= @since");
-      params.since = filter.since;
-    }
-    if (filter.until !== undefined) {
-      conditions.push("ts <= @until");
-      params.until = filter.until;
-    }
-
-    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-    const limit = filter.limit !== undefined ? `LIMIT ${filter.limit}` : "";
-    const sql = `SELECT id, source, type, ref_id, payload, ts FROM logs ${where} ORDER BY id ASC ${limit}`;
-
-    const rows = sqlite.prepare(sql).all(params) as Array<{
-      id: number;
-      source: string;
-      type: string;
-      ref_id: string | null;
-      payload: string | null;
-      ts: number;
-    }>;
-
-    return rows.map((r) => ({
-      id: r.id,
-      source: r.source,
-      type: r.type,
-      refId: r.ref_id,
-      payload: r.payload,
-      ts: r.ts,
-    }));
-  }
-
-  function getMeta(key: string): string | null {
-    const row = getMetaStmt.get(key) as { value: string } | undefined;
-    return row?.value ?? null;
-  }
-
-  function setMeta(key: string, value: string): void {
-    setMetaStmt.run({ key, value });
-  }
-
-  function upsertWorkflowRun(entry: Omit<LogEntry, "id">, run: WorkflowRun): LogEntry {
-    return upsertWorkflowRunTx(entry, run) as LogEntry;
-  }
-
-  function appendWithWorkflowUpdate(entry: Omit<LogEntry, "id">, run: WorkflowRun): LogEntry {
-    return upsertWorkflowRunTx(entry, run) as LogEntry;
-  }
-
-  function getWorkflowRun(runId: string): WorkflowRun | null {
-    const row = getWorkflowRunStmt.get(runId) as
-      | { run_id: string; workflow: string; status: string; ts: number }
-      | undefined;
-    if (row === undefined) return null;
-    return {
-      runId: row.run_id,
-      workflow: row.workflow,
-      status: validateWorkflowRunStatus(row.status),
-      ts: row.ts,
-    };
-  }
-
-  function getActiveWorkflowRuns(workflowName?: string): WorkflowRun[] {
-    const rows = (
-      workflowName !== undefined
-        ? getActiveWorkflowRunsByNameStmt.all(workflowName)
-        : getActiveWorkflowRunsStmt.all()
-    ) as Array<{ run_id: string; workflow: string; status: string; ts: number }>;
-    return rows.map((r) => ({
-      runId: r.run_id,
-      workflow: r.workflow,
-      status: validateWorkflowRunStatus(r.status),
-      ts: r.ts,
-    }));
-  }
-
-  function getAllWorkflowRuns(workflowName: string | null): WorkflowRun[] {
-    const rows = (
-      workflowName !== null
-        ? getAllWorkflowRunsByNameStmt.all(workflowName)
-        : getAllWorkflowRunsStmt.all()
-    ) as Array<{ run_id: string; workflow: string; status: string; ts: number }>;
-    return rows.map((r) => ({
-      runId: r.run_id,
-      workflow: r.workflow,
-      status: validateWorkflowRunStatus(r.status),
-      ts: r.ts,
-    }));
-  }
-
-  function getTriggerPayload(runId: string): unknown {
-    const row = getTriggerPayloadStmt.get(runId) as { payload: string | null } | undefined;
-    if (row === undefined || row.payload === null) return null;
-    try {
-      const parsed = JSON.parse(row.payload) as unknown;
-      if (parsed !== null && typeof parsed === "object") {
-        const obj = parsed as Record<string, unknown>;
-        return obj.triggerPayload ?? null;
-      }
-    } catch {
-      // malformed
-    }
-    return null;
-  }
-
-  function getThreadEvents(runId: string): Array<{ type: string; [key: string]: unknown }> {
-    const rows = getThreadEventsStmt.all(runId) as Array<{ payload: string | null }>;
-    const result: Array<{ type: string; [key: string]: unknown }> = [];
-    for (const row of rows) {
-      if (row.payload === null) continue;
-      try {
-        const parsed = JSON.parse(row.payload) as unknown;
-        if (
-          parsed !== null &&
-          typeof parsed === "object" &&
-          typeof (parsed as Record<string, unknown>).type === "string"
-        ) {
-          result.push(parsed as { type: string; [key: string]: unknown });
-        }
-      } catch {
-        // skip malformed payloads
-      }
-    }
-    return result;
-  }
-
-  function close(): void {
-    sqlite.close();
-  }
-
-  return {
-    append,
-    query,
-    getMeta,
-    setMeta,
-    upsertWorkflowRun,
-    appendWithWorkflowUpdate,
-    getWorkflowRun,
-    getActiveWorkflowRuns,
-    getAllWorkflowRuns,
-    getTriggerPayload,
-    getThreadEvents,
-    close,
-  };
-}

packages/daemon/src/reflex-scheduler.ts

@@ -10,15 +10,12 @@
  */
 
 import type { NerveConfig } from "@uncaged/nerve-core";
-import type { LogStore } from "./log-store.js";
+import type { LogStore } from "@uncaged/nerve-store";
 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;

packages/daemon/src/sense-runtime.ts

@@ -1,15 +1,17 @@
 import { mkdirSync, readFileSync, readdirSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
 
-import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/node-sqlite";
-import { drizzle } from "drizzle-orm/better-sqlite3";
+import type { NodeSQLiteDatabase } from "drizzle-orm/node-sqlite";
-import type { BetterSQLite3Database } from "drizzle-orm/better-sqlite3";
 
 import type { Result } from "@uncaged/nerve-core";
 import { err, ok } from "@uncaged/nerve-core";
 
+import type { BlobStore } from "@uncaged/nerve-store";
+
 /** A Drizzle DB instance (schema-generic) */
-export type DrizzleDB = BetterSQLite3Database<Record<string, never>>;
+export type DrizzleDB = NodeSQLiteDatabase<Record<string, never>>;
 
 /** Read-only map of peer sense name → their Drizzle DB */
 export type PeerMap = Readonly<Record<string, DrizzleDB>>;
@@ -17,11 +19,14 @@ export type PeerMap = Readonly<Record<string, DrizzleDB>>;
 /** Options passed to a compute function */
 export type ComputeOptions = {
   signal: AbortSignal;
+  /** CAS under `data/blobs/`; injected by the sense worker when available. */
+  blobs?: BlobStore;
 };
 
 /**
  * The shape every sense's index.ts must export.
- * Engine injects `db` (read-write), `peers` (read-only), and `options`.
+ * Engine injects `db` (read-write), `peers` (read-only), and `options`
+ * (`signal`, and `blobs` when running in the sense worker — RFC-001 §8 CAS).
  * Returns T when a signal should be emitted, null for silence.
  */
 export type ComputeFn<T = unknown> = (
@@ -37,7 +42,7 @@ export type SenseRuntime = {
   compute: ComputeFn;
 };
 
-function ensureMigrationsTable(sqlite: Database.Database): Result<void> {
+function ensureMigrationsTable(sqlite: DatabaseSync): Result<void> {
   try {
     sqlite.exec(
       `CREATE TABLE IF NOT EXISTS _migrations (
@@ -64,11 +69,7 @@ function listMigrationFiles(migrationsDir: string): Result<string[]> {
   }
 }
 
-function applyMigrationFile(
+function applyMigrationFile(sqlite: DatabaseSync, file: string, filePath: string): Result<void> {
-  sqlite: Database.Database,
-  file: string,
-  filePath: string,
-): Result<void> {
   let sql: string;
   try {
     sql = readFileSync(filePath, "utf8");
@@ -78,13 +79,18 @@ function applyMigrationFile(
   }
 
   const insertJournal = sqlite.prepare("INSERT INTO _migrations (name, applied_at) VALUES (?, ?)");
+  sqlite.exec("BEGIN IMMEDIATE");
   try {
-    sqlite.transaction(() => {
+    sqlite.exec(sql);
-      sqlite.exec(sql);
+    insertJournal.run(file, Date.now());
-      insertJournal.run(file, Date.now());
+    sqlite.exec("COMMIT");
-    })();
     return ok(undefined);
   } catch (e) {
+    try {
+      sqlite.exec("ROLLBACK");
+    } catch {
+      // ignore secondary errors during rollback
+    }
     const msg = e instanceof Error ? e.message : String(e);
     return err(new Error(`Migration "${file}" failed: ${msg}`));
   }
@@ -92,10 +98,10 @@ function applyMigrationFile(
 
 /**
  * Run all *.sql migration files in the given directory against a
- * better-sqlite3 Database, in lexicographic order.
+ * `node:sqlite` DatabaseSync, in lexicographic order.
  * Tracks applied migrations in _migrations table to avoid re-running.
  */
-export function runMigrations(sqlite: Database.Database, migrationsDir: string): Result<void> {
+export function runMigrations(sqlite: DatabaseSync, migrationsDir: string): Result<void> {
   const tableResult = ensureMigrationsTable(sqlite);
   if (!tableResult.ok) return tableResult;
 
@@ -124,14 +130,13 @@ export function runMigrations(sqlite: Database.Database, migrationsDir: string):
 export function openSenseDb(
   dbPath: string,
   migrationsDir: string,
-): Result<{ sqlite: Database.Database; db: DrizzleDB }> {
+): Result<{ sqlite: DatabaseSync; db: DrizzleDB }> {
-  let sqlite: Database.Database;
+  let sqlite: DatabaseSync;
 
   try {
     mkdirSync(dirname(dbPath), { recursive: true });
-    sqlite = new Database(dbPath);
+    sqlite = new DatabaseSync(dbPath);
-    // WAL mode for better concurrent read performance
+    sqlite.exec("PRAGMA journal_mode=WAL");
-    sqlite.pragma("journal_mode = WAL");
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
     return err(new Error(`Failed to open database "${dbPath}": ${msg}`));
@@ -140,7 +145,7 @@ export function openSenseDb(
   const migResult = runMigrations(sqlite, migrationsDir);
   if (!migResult.ok) return migResult;
 
-  const db = drizzle(sqlite) as DrizzleDB;
+  const db = drizzle({ client: sqlite }) as DrizzleDB;
   return ok({ sqlite, db });
 }
 
@@ -148,16 +153,16 @@ export function openSenseDb(
  * Open a peer sense DB in read-only mode (no migrations).
  */
 export function openPeerDb(dbPath: string): Result<DrizzleDB> {
-  let sqlite: Database.Database;
+  let sqlite: DatabaseSync;
 
   try {
-    sqlite = new Database(dbPath, { readonly: true });
+    sqlite = new DatabaseSync(dbPath, { readOnly: true });
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
     return err(new Error(`Failed to open peer database "${dbPath}" (readonly): ${msg}`));
   }
 
-  return ok(drizzle(sqlite) as DrizzleDB);
+  return ok(drizzle({ client: sqlite }) as DrizzleDB);
 }
 
 /**
@@ -168,6 +173,7 @@ export async function loadComputeFn(senseIndexPath: string): Promise<Result<Comp
   let mod: unknown;
 
   try {
+    // Dynamic import required: user-authored sense module, path resolved at runtime
     mod = await import(senseIndexPath);
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
@@ -192,14 +198,19 @@ export async function loadComputeFn(senseIndexPath: string): Promise<Result<Comp
  * Execute a sense's compute function with an optional soft timeout.
  * If timeoutMs is provided and compute takes longer, the AbortSignal is
  * triggered and an error Result is returned.
+ * When `blobStore` is set, it is exposed as `options.blobs` (see RFC-001 §8).
  */
 export async function executeCompute(
   runtime: SenseRuntime,
   peers: PeerMap,
   timeoutMs?: number,
+  blobStore?: BlobStore,
 ): Promise<Result<unknown | null>> {
   const controller = new AbortController();
-  const options: ComputeOptions = { signal: controller.signal };
+  const options: ComputeOptions =
+    blobStore !== undefined
+      ? { signal: controller.signal, blobs: blobStore }
+      : { signal: controller.signal };
 
   let timer: ReturnType<typeof setTimeout> | undefined;
   const timeoutPromise =

packages/daemon/src/sense-worker.ts

@@ -10,6 +10,7 @@
  *   senses/<name>/index.js        ← compiled compute
  *   senses/<name>/migrations/     ← SQL migration files
  *   data/senses/<name>.db         ← SQLite data file
+ *   data/blobs/<aa>/<hashrest>    ← CAS (sha256), via options.blobs in compute
  *   nerve.yaml                    ← config
  */
 
@@ -19,10 +20,12 @@ import { join, resolve } from "node:path";
 import { parseNerveConfig } from "@uncaged/nerve-core";
 import type { NerveConfig } from "@uncaged/nerve-core";
 
+import { createBlobStore } from "@uncaged/nerve-store";
 import type { WorkerToParentMessage } from "./ipc.js";
 import { parseParentMessage } from "./ipc.js";
 import { executeCompute, loadComputeFn, openPeerDb, openSenseDb } from "./sense-runtime.js";
 import type { DrizzleDB, PeerMap, SenseRuntime } from "./sense-runtime.js";
+import { ignoreSessionBroadcastSignals } from "./worker-fork-support.js";
 
 // ---------------------------------------------------------------------------
 // IPC helpers
@@ -162,9 +165,10 @@ async function runCompute(
   peers: PeerMap,
   timeoutMs: number,
   gracePeriodMs: number | null,
+  blobStore: ReturnType<typeof createBlobStore>,
 ): Promise<void> {
   try {
-    const result = await executeCompute(runtime, peers, timeoutMs);
+    const result = await executeCompute(runtime, peers, timeoutMs, blobStore);
     if (!result.ok) {
       sendError(senseName, result.error.message);
       if (gracePeriodMs !== null && result.error.message.includes("timed out")) {
@@ -193,6 +197,7 @@ function handleMessage(
   group: string,
   senseConfigs: Map<string, { timeout: number | null; gracePeriod: number | null }>,
   inFlight: Map<string, Promise<void>>,
+  blobStore: ReturnType<typeof createBlobStore>,
 ): void {
   const parseResult = parseParentMessage(raw);
   if (!parseResult.ok) {
@@ -230,7 +235,7 @@ function handleMessage(
 
   const previous = inFlight.get(msg.sense) ?? Promise.resolve();
   const next = previous
-    .then(() => runCompute(msg.sense, runtime, peers, timeoutMs, gracePeriodMs))
+    .then(() => runCompute(msg.sense, runtime, peers, timeoutMs, gracePeriodMs, blobStore))
     .catch((e: unknown) => {
       const errMsg = e instanceof Error ? e.message : String(e);
       sendError(msg.sense, errMsg);
@@ -294,11 +299,12 @@ async function bootstrap(nerveRoot: string, group: string): Promise<void> {
   }
 
   const inFlight = new Map<string, Promise<void>>();
+  const blobStore = createBlobStore(join(nerveRoot, "data", "blobs"));
 
   sendReady();
 
   process.on("message", (raw: unknown) => {
-    handleMessage(raw, runtimes, peers, group, senseConfigs, inFlight);
+    handleMessage(raw, runtimes, peers, group, senseConfigs, inFlight, blobStore);
   });
 }
 
@@ -331,6 +337,10 @@ if (!parsed) {
   process.exit(1);
 }
 
+if (typeof process.send === "function") {
+  ignoreSessionBroadcastSignals();
+}
+
 bootstrap(parsed.nerveRoot, parsed.group).catch((e) => {
   const msg = e instanceof Error ? e.message : String(e);
   process.stderr.write(`[sense-worker] Unhandled bootstrap error: ${msg}\n`);

packages/daemon/src/worker-fork-support.ts

@@ -0,0 +1,45 @@
+import type { ChildProcess } from "node:child_process";
+
+const STDERR_TAIL_MAX_CHARS = 16_384;
+
+/**
+ * Forked workers inherit the parent's process group. In foreground `nerve dev`,
+ * terminal-driven SIGINT/SIGTERM is delivered to the whole group, so workers can exit
+ * on the default handler before the kernel sends `{ type: "shutdown" }` over IPC.
+ * Swallow these in worker processes so the parent coordinates shutdown (issue #55).
+ * Only call when `process.send` is defined (fork IPC); standalone `node …-worker.js` keeps default Ctrl+C behaviour.
+ */
+export function ignoreSessionBroadcastSignals(): void {
+  const swallow = (): void => {};
+  process.on("SIGINT", swallow);
+  process.on("SIGTERM", swallow);
+}
+
+export function teeCapturedStderr(child: ChildProcess, tail: { value: string }): void {
+  const stream = child.stderr;
+  if (stream === null || stream === undefined) return;
+  stream.setEncoding("utf8");
+  stream.on("data", (chunk: string | Buffer) => {
+    const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    process.stderr.write(text);
+    tail.value = (tail.value + text).slice(-STDERR_TAIL_MAX_CHARS);
+  });
+}
+
+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}`;
+  }
+  return `code=${codeStr}`;
+}
+
+export function formatCapturedStderrTail(tail: string, maxChars = 800): string {
+  const trimmed = tail.trim();
+  if (trimmed.length === 0) return "";
+  const normalized = trimmed.replace(/\r?\n/g, "\\n");
+  if (normalized.length <= maxChars) {
+    return ` worker_stderr=${normalized}`;
+  }
+  return ` worker_stderr=…${normalized.slice(-maxChars)}`;
+}

packages/daemon/src/worker-pool.ts

@@ -0,0 +1,211 @@
+/**
+ * Sense worker pool — forked child processes per sense group (IPC lifecycle).
+ */
+
+import { fork } from "node:child_process";
+import type { ChildProcess } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import type { ComputeMessage, ShutdownMessage } from "./ipc.js";
+import { parseWorkerMessage } from "./ipc.js";
+import {
+  formatCapturedStderrTail,
+  formatChildExitSummary,
+  teeCapturedStderr,
+} from "./worker-fork-support.js";
+
+export function resolveWorkerScript(): string {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dir = dirname(__filename);
+  return join(__dir, "sense-worker.js");
+}
+
+type WorkerEntry = {
+  group: string;
+  process: ChildProcess;
+};
+
+export type SenseWorkerPoolOptions = {
+  nerveRoot: string;
+  workerScript: string;
+  /** Invoked for every IPC message from a worker (including ready / signal / error). */
+  onWorkerMessage: (raw: unknown) => void;
+  /** Sense names in a group — used when clearing scheduler state on crash or restart. */
+  sensesForGroup: (group: string) => string[];
+  /**
+   * Called when a worker exits with non-zero code before scheduling a respawn
+   * (scheduler should release pending computes for senses in that group).
+   */
+  onWorkerCrashed: (group: string) => void;
+  /**
+   * Called at the beginning of `restartGroup` before shutdown
+   * (same scheduler cleanup as crash path).
+   */
+  onBeforeGroupRestart: (group: string) => void;
+  isStopped: () => boolean;
+};
+
+export type SenseWorkerPool = {
+  startWorker: (group: string) => Promise<void>;
+  restartGroup: (group: string) => Promise<void>;
+  /** Send shutdown and drop the entry without waiting (matches reloadConfig stale-group removal). */
+  evictGroup: (group: string) => void;
+  shutdownAll: () => Promise<void>;
+  sendCompute: (group: string, senseName: string) => void;
+  getWorkerPid: (group: string) => number | null;
+  hasWorkerForGroup: (group: string) => boolean;
+  activeGroupCount: () => number;
+};
+
+function spawnWorker(
+  nerveRoot: string,
+  group: string,
+  workerScript: string,
+  stderrTail: { value: string },
+): ChildProcess {
+  const child = fork(workerScript, ["--group", group, "--root", nerveRoot], {
+    stdio: ["ignore", "inherit", "pipe", "ipc"],
+  });
+  teeCapturedStderr(child, stderrTail);
+  child.on("error", (err) => {
+    if ((err as NodeJS.ErrnoException).code !== "EPIPE") {
+      console.error("[worker] error:", err.message);
+    }
+  });
+  return child;
+}
+
+function sendComputeToProcess(worker: ChildProcess, senseName: string): void {
+  if (worker.connected === false) return;
+  const msg: ComputeMessage = { type: "compute", sense: senseName };
+  try {
+    worker.send(msg);
+  } catch {
+    // IPC channel closed between connected check and send
+  }
+}
+
+function sendShutdownToProcess(worker: ChildProcess): void {
+  if (worker.connected === false) return;
+  const msg: ShutdownMessage = { type: "shutdown" };
+  try {
+    worker.send(msg);
+  } catch {
+    // IPC channel closed between connected check and send
+  }
+}
+
+function waitForExit(child: ChildProcess, timeoutMs: number): Promise<void> {
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      resolve();
+    }, timeoutMs);
+    child.once("exit", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+  });
+}
+
+export function createSenseWorkerPool(options: SenseWorkerPoolOptions): SenseWorkerPool {
+  const workers = new Map<string, WorkerEntry>();
+
+  function startWorker(group: string): Promise<void> {
+    const stderrTail = { value: "" };
+    const child = spawnWorker(options.nerveRoot, group, options.workerScript, stderrTail);
+
+    let workerReadyResolve: (() => void) | undefined;
+    const workerReady = new Promise<void>((resolve) => {
+      workerReadyResolve = resolve;
+    });
+
+    child.on("message", (raw: unknown) => {
+      const result = parseWorkerMessage(raw);
+      if (result.ok && result.value.type === "ready") {
+        workerReadyResolve?.();
+      }
+      options.onWorkerMessage(raw);
+    });
+
+    child.on("exit", (code, signal) => {
+      const summary = formatChildExitSummary(code, signal ?? null);
+      process.stderr.write(
+        `[kernel] worker for group "${group}" exited (${summary})${formatCapturedStderrTail(stderrTail.value)}\n`,
+      );
+      workerReadyResolve?.();
+      if (!options.isStopped() && code !== 0) {
+        process.stderr.write(`[kernel] respawning worker for group "${group}" in 1s\n`);
+        options.onWorkerCrashed(group);
+        setTimeout(() => {
+          if (!options.isStopped()) {
+            startWorker(group);
+          }
+        }, 1000);
+      }
+    });
+
+    workers.set(group, { group, process: child });
+    return workerReady;
+  }
+
+  async function restartGroup(group: string): Promise<void> {
+    const entry = workers.get(group);
+    if (entry === undefined) return;
+
+    options.onBeforeGroupRestart(group);
+
+    sendShutdownToProcess(entry.process);
+    await waitForExit(entry.process, 5000);
+
+    if (!options.isStopped()) {
+      await startWorker(group);
+    }
+  }
+
+  function evictGroup(group: string): void {
+    const entry = workers.get(group);
+    if (entry === undefined) return;
+    sendShutdownToProcess(entry.process);
+    workers.delete(group);
+  }
+
+  async function shutdownAll(): Promise<void> {
+    const exitPromises: Promise<void>[] = [];
+    for (const entry of workers.values()) {
+      sendShutdownToProcess(entry.process);
+      exitPromises.push(waitForExit(entry.process, 5000));
+    }
+    await Promise.all(exitPromises);
+  }
+
+  function sendCompute(group: string, senseName: string): void {
+    const entry = workers.get(group);
+    if (entry === undefined) return;
+    sendComputeToProcess(entry.process, senseName);
+  }
+
+  function getWorkerPid(group: string): number | null {
+    return workers.get(group)?.process.pid ?? null;
+  }
+
+  function hasWorkerForGroup(group: string): boolean {
+    return workers.has(group);
+  }
+
+  function activeGroupCount(): number {
+    return workers.size;
+  }
+
+  return {
+    startWorker,
+    restartGroup,
+    evictGroup,
+    shutdownAll,
+    sendCompute,
+    getWorkerPid,
+    hasWorkerForGroup,
+    activeGroupCount,
+  };
+}

packages/daemon/src/workflow-manager.ts

@@ -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,
@@ -20,12 +21,21 @@ import type {
   ThreadEventMessage,
 } from "./ipc.js";
 import { parseWorkerMessage } from "./ipc.js";
-import type { LogStore } from "./log-store.js";
+import type { LogStore, WorkflowRunStatus } from "@uncaged/nerve-store";
-import type { WorkflowRunStatus } from "./log-store.js";
+import {
+  formatCapturedStderrTail,
+  formatChildExitSummary,
+  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). */
+  /** Trigger a new workflow thread (Sense-driven launch or CLI / IPC). */
-  startWorkflow: (workflowName: string, payload: unknown) => void;
+  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. */
@@ -46,7 +56,8 @@ export type WorkflowManager = {
 
 type PendingThread = {
   runId: string;
-  payload: unknown;
+  prompt: string;
+  maxRounds: number;
 };
 
 type WorkflowState = {
@@ -60,6 +71,7 @@ type WorkerEntry = {
   stopping: boolean;
   /** When set, the worker is draining before a hot-reload respawn. */
   draining: boolean;
+  stderrTail: { value: string };
 };
 
 // Crash respawn backoff: track crash timestamps per workflow.
@@ -75,6 +87,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);
@@ -85,10 +133,19 @@ function spawnWorkflowWorker(
   nerveRoot: string,
   workflowName: string,
   workerScript: string,
+  stderrTail: { value: string },
 ): ChildProcess {
-  return fork(workerScript, ["--workflow", workflowName, "--root", nerveRoot], {
+  const child = fork(workerScript, ["--workflow", workflowName, "--root", nerveRoot], {
-    stdio: ["ignore", "inherit", "inherit", "ipc"],
+    stdio: ["ignore", "inherit", "pipe", "ipc"],
   });
+  teeCapturedStderr(child, stderrTail);
+  // Prevent unhandled EPIPE when writing to a child whose IPC channel closed
+  child.on("error", (err) => {
+    if ((err as NodeJS.ErrnoException).code !== "EPIPE") {
+      console.error("[worker] error:", err.message);
+    }
+  });
+  return child;
 }
 
 function sendStartThread(worker: ChildProcess, msg: StartThreadMessage): void {
@@ -198,7 +255,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);
 
@@ -207,11 +269,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", { prompt, maxRounds });
-    logWorkflowEvent(workflowName, runId, "started", { triggerPayload: payload });
   }
 
   function dequeueNext(workflowName: string): void {
@@ -224,7 +286,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);
       }
     }
   }
@@ -245,8 +307,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);
+    const launch = readLaunchFromTriggerPayload(logStore.getTriggerPayload(runId), config.maxRounds);
-    state.queue.push({ runId, payload: triggerPayload });
+    state.queue.push({ runId, prompt: launch.prompt, maxRounds: launch.maxRounds });
     process.stderr.write(
       `[workflow-manager] crash-recovery: re-queued thread "${runId}" for "${workflowName}"\n`,
     );
@@ -259,18 +321,19 @@ export function createWorkflowManager(
     worker: WorkerEntry,
   ): void {
     if (state.active.has(runId)) return;
-    const events = logStore.getThreadEvents(runId);
+    const rawMessages = logStore.getThreadMessages(runId);
-    const triggerPayload = logStore.getTriggerPayload(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,
+      messages,
-      triggerPayload,
+      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`,
     );
   }
 
@@ -348,12 +411,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;
@@ -388,7 +451,11 @@ export function createWorkflowManager(
     state.active.clear();
   }
 
-  function handleWorkerExit(workflowName: string, code: number | null): void {
+  function handleWorkerExit(
+    workflowName: string,
+    code: number | null,
+    signal: NodeJS.Signals | null,
+  ): void {
     const entry = workers.get(workflowName);
     if (entry?.draining) {
       workers.delete(workflowName);
@@ -409,8 +476,10 @@ export function createWorkflowManager(
       }
       return;
     }
+    const summary = formatChildExitSummary(code, signal);
+    const stderrExtra = entry !== undefined ? formatCapturedStderrTail(entry.stderrTail.value) : "";
     process.stderr.write(
-      `[workflow-manager] worker for "${workflowName}" exited with code ${code ?? "null"}\n`,
+      `[workflow-manager] worker for "${workflowName}" exited (${summary})${stderrExtra}\n`,
     );
     handleWorkerCrash(workflowName);
   }
@@ -421,22 +490,29 @@ export function createWorkflowManager(
       return existing;
     }
 
-    const child = spawnWorkflowWorker(nerveRoot, workflowName, workerScript);
+    const stderrTail = { value: "" };
+    const child = spawnWorkflowWorker(nerveRoot, workflowName, workerScript, stderrTail);
 
     child.on("message", (raw: unknown) => {
       handleWorkerMessage(workflowName, raw);
     });
 
-    child.on("exit", (code) => {
+    child.on("exit", (code, signal) => {
-      handleWorkerExit(workflowName, code);
+      handleWorkerExit(workflowName, code, signal ?? null);
     });
 
-    const entry: WorkerEntry = { workflowName, process: child, stopping: false, draining: false };
+    const entry: WorkerEntry = {
+      workflowName,
+      process: child,
+      stopping: false,
+      draining: false,
+      stderrTail,
+    };
     workers.set(workflowName, entry);
     return entry;
   }
 
-  function startWorkflow(workflowName: string, payload: unknown): void {
+  function startWorkflow(workflowName: string, launch: WorkflowLaunchParams): void {
     if (stopped) return;
 
     const wfConfig = workflowConfig(workflowName);
@@ -449,9 +525,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;
     }
 
@@ -476,7 +553,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`,

packages/daemon/src/workflow-worker.ts

@@ -12,15 +12,16 @@
 import { existsSync } from "node:fs";
 import { join, resolve } from "node:path";
 
-import type {
+import type { RoleMeta, WorkflowDefinition, WorkflowMessage } from "@uncaged/nerve-core";
-  CommandEvent,
+import { END, START } from "@uncaged/nerve-core";
-  ThreadState,
-  WorkflowContext,
-  WorkflowDefinition,
-} 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";
 
 // ---------------------------------------------------------------------------
 // IPC helpers
@@ -44,137 +45,121 @@ function sendWorkflowError(runId: string, error: string): void {
   send({ type: "workflow-error", runId, error });
 }
 
-function sendCommandEvent(runId: string, event: CommandEvent): void {
+function sendWorkflowMessage(runId: string, message: WorkflowMessage): void {
-  const msg: ThreadCommandEventMessage = {
+  const msg: ThreadWorkflowMessageMessage = {
-    type: "thread-command-event",
+    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,
+  def: WorkflowDefinition<RoleMeta>,
-  workflowName: string,
   runId: string,
-  triggerPayload: unknown,
+  maxRounds: number,
-  /** Pre-existing event history for crash-recovery resume. Empty for a fresh thread. */
+  resumeMessages: WorkflowMessage[] = [],
-  resumeEvents: CommandEvent[] = [],
+  freshPrompt: string | null = null,
 ): Promise<void> {
-  const state: ThreadState = { runId, events: [] };
+  let chain: WorkflowMessage[];
-  const ctx: WorkflowContext = {
-    runId,
-    workflowName,
-    log: (msg) => sendThreadEvent(runId, "step_complete", { message: msg }),
-  };
 
-  const initialEvent: CommandEvent = {
+  if (resumeMessages.length > 0) {
-    type: "thread_start",
+    chain = [...resumeMessages];
-    triggerPayload:
+  } else {
-      triggerPayload != null && typeof triggerPayload === "object" ? triggerPayload : {},
+    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.
+  let roleRound = chain.filter((m) => m.role !== START).length;
-  if (resumeEvents.length > 0) {
+  const lastMsg = chain[chain.length - 1];
-    const nextEvent = await replayAndResume(def, runId, ctx, state, resumeEvents);
+  if (lastMsg === undefined) {
-    if (nextEvent === null) return;
+    sendWorkflowError(runId, "empty workflow message chain");
-    await continueThread(def, runId, ctx, state, nextEvent);
     return;
   }
 
-  // Fresh thread — send the initial command event and enter the loop.
+  const lastSignal =
-  sendCommandEvent(runId, initialEvent);
+    lastMsg.role === START
-  await continueThread(def, runId, ctx, state, initialEvent);
+      ? {
-}
+          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(
+  let nextRole = def.moderator(
-  def: WorkflowDefinition,
+    lastSignal as Parameters<typeof def.moderator>[0],
-  runId: string,
+    roleRound,
-  ctx: WorkflowContext,
+    maxRounds,
-  state: ThreadState,
+  );
-  firstEvent: CommandEvent,
-): Promise<void> {
-  let event = firstEvent;
 
-  const MAX_STEPS = 1000;
+  if (nextRole === END) {
-  let step = 0;
+    sendThreadEvent(runId, "completed", null);
-  while (step < MAX_STEPS) {
+    return;
-    step++;
+  }
-    state.events.push(event);
-    const next = def.moderate(state, event);
 
-    if (next === null) {
+  while (roleRound < maxRounds) {
-      sendThreadEvent(runId, "completed", null);
+    const role = def.roles[nextRole];
-      return;
-    }
-
-    const role = def.roles[next.role];
     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 (typeof result.content !== "string") {
-  if (step >= MAX_STEPS) {
+      sendWorkflowError(runId, `Role "${nextRole}" returned non-string content`);
-    sendWorkflowError(runId, `Thread exceeded maximum steps (${MAX_STEPS})`);
+      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})`);
 }
 
 // ---------------------------------------------------------------------------
@@ -184,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")),
@@ -197,21 +182,23 @@ async function loadWorkflowDefinition(
     );
   }
 
+  // Dynamic import required: user-authored workflow module, path resolved at runtime
   const mod = await import(indexPath);
   const def: unknown = mod.default ?? mod;
 
   if (
     def === null ||
     typeof def !== "object" ||
-    typeof (def as WorkflowDefinition).moderate !== "function" ||
+    typeof (def as WorkflowDefinition<RoleMeta>).moderator !== "function" ||
-    typeof (def as WorkflowDefinition).roles !== "object"
+    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>;
 }
 
 // ---------------------------------------------------------------------------
@@ -220,8 +207,7 @@ async function loadWorkflowDefinition(
 
 function handleMessage(
   raw: unknown,
-  def: WorkflowDefinition,
+  def: WorkflowDefinition<RoleMeta>,
-  workflowName: string,
   inFlight: Map<string, Promise<void>>,
   shuttingDown: { value: boolean },
 ): void {
@@ -244,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);
@@ -263,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);
@@ -286,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) {
@@ -301,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);
   });
 }
 
@@ -334,6 +320,10 @@ if (!parsed) {
   process.exit(1);
 }
 
+if (typeof process.send === "function") {
+  ignoreSessionBroadcastSignals();
+}
+
 bootstrap(parsed.nerveRoot, parsed.workflow).catch((e) => {
   const msg = e instanceof Error ? e.message : String(e);
   process.stderr.write(`[workflow-worker] Unhandled bootstrap error: ${msg}\n`);

packages/daemon/tsup.config.ts

@@ -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,
-});

packages/store/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@uncaged/nerve-store",
+  "version": "0.3.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "prepublishOnly": "bash ../../scripts/prepublish-check.sh",
+    "build": "rslib build",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@uncaged/nerve-core": "workspace:*"
+  },
+  "devDependencies": {
+    "@rslib/core": "^0.21.3",
+    "@types/node": "^22.0.0",
+    "vitest": "^4.1.5"
+  }
+}

packages/store/rslib.config.ts

@@ -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,
+  },
+});

packages/store/src/__tests__/blob-store.test.ts

@@ -0,0 +1,105 @@
+import { createHash } from "node:crypto";
+import { existsSync, readdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { describe, expect, it } from "vitest";
+
+import { createBlobStore, normalizeBlobHash } from "../blob-store.js";
+
+function makeRoot(): string {
+  return join(tmpdir(), `nerve-blob-${Date.now()}-${Math.random().toString(16).slice(2)}`);
+}
+
+describe("normalizeBlobHash", () => {
+  it("accepts 64-char lowercase hex", () => {
+    const h = "a".repeat(64);
+    expect(normalizeBlobHash(h)).toBe(h);
+  });
+
+  it("normalizes uppercase to lowercase", () => {
+    const h = "A".repeat(64);
+    expect(normalizeBlobHash(h)).toBe("a".repeat(64));
+  });
+
+  it("rejects wrong length and non-hex", () => {
+    expect(normalizeBlobHash("ab")).toBeNull();
+    expect(normalizeBlobHash("g".repeat(64))).toBeNull();
+  });
+});
+
+describe("createBlobStore", () => {
+  it("write returns sha256 hex and stores under 2-char shard", () => {
+    const root = makeRoot();
+    const store = createBlobStore(root);
+    const content = "hello cas";
+    const hash = store.write(content);
+
+    expect(hash).toMatch(/^[0-9a-f]{64}$/);
+    expect(createHash("sha256").update(content, "utf8").digest("hex")).toBe(hash);
+
+    const shard = hash.slice(0, 2);
+    const rel = hash.slice(2);
+    const filePath = join(root, shard, rel);
+    expect(existsSync(filePath)).toBe(true);
+  });
+
+  it("read returns stored bytes and exists is true", () => {
+    const root = makeRoot();
+    const store = createBlobStore(root);
+    const buf = Buffer.from([0, 255, 128]);
+    const hash = store.write(buf);
+
+    expect(store.exists(hash)).toBe(true);
+    const got = store.read(hash);
+    expect(got).not.toBeNull();
+    expect(Buffer.compare(got as Buffer, buf)).toBe(0);
+  });
+
+  it("write is idempotent for same content", () => {
+    const root = makeRoot();
+    const store = createBlobStore(root);
+    const h1 = store.write("same");
+    const h2 = store.write("same");
+    expect(h1).toBe(h2);
+
+    const shard = h1.slice(0, 2);
+    const names = readdirSync(join(root, shard));
+    expect(names.filter((n: string) => !n.startsWith("."))).toHaveLength(1);
+  });
+
+  it("read returns null for missing blob", () => {
+    const root = makeRoot();
+    const store = createBlobStore(root);
+    const missing = "0".repeat(64);
+    expect(store.read(missing)).toBeNull();
+    expect(store.exists(missing)).toBe(false);
+  });
+
+  it("read and exists return null/false for invalid hash", () => {
+    const root = makeRoot();
+    const store = createBlobStore(root);
+    expect(store.read("not-a-hash")).toBeNull();
+    expect(store.exists("not-a-hash")).toBe(false);
+  });
+
+  it("throws when on-disk content does not match path hash", () => {
+    const root = makeRoot();
+    const store = createBlobStore(root);
+    const hash = store.write("ok");
+    const filePath = join(root, hash.slice(0, 2), hash.slice(2));
+    writeFileSync(filePath, "tampered");
+
+    expect(() => store.read(hash)).toThrow(/CAS mismatch/i);
+  });
+
+  it("write throws when an existing file at the digest path has wrong content", () => {
+    const root = makeRoot();
+    const store = createBlobStore(root);
+    const hash = store.write("truth");
+    const filePath = join(root, hash.slice(0, 2), hash.slice(2));
+    writeFileSync(filePath, "lies");
+
+    expect(() => store.write("truth")).toThrow(/CAS mismatch/i);
+  });
+});

packages/store/src/__tests__/log-archive.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  assertValidUtcDay,
+  compareIsoDays,
+  lastArchivableUtcDay,
+  nextUtcDay,
+  prevUtcDay,
+  utcDateStringFromMs,
+  utcDayEndExclusiveMs,
+  utcDayStartMs,
+} from "../log-archive.js";
+
+describe("log-archive UTC helpers", () => {
+  it("lastArchivableUtcDay matches RFC-style boundary (exclusive end of day ≤ boundary)", () => {
+    const boundary = Date.UTC(2026, 1, 2, 12, 0, 0); // 2026-02-02 12:00 UTC
+    expect(lastArchivableUtcDay(boundary)).toBe("2026-02-01");
+  });
+
+  it("round-trips UTC day bounds", () => {
+    expect(utcDayStartMs("2026-02-01")).toBe(Date.UTC(2026, 1, 1));
+    expect(utcDayEndExclusiveMs("2026-02-01")).toBe(Date.UTC(2026, 1, 2));
+    expect(utcDateStringFromMs(Date.UTC(2026, 1, 1, 23, 59))).toBe("2026-02-01");
+  });
+
+  it("nextUtcDay / prevUtcDay", () => {
+    expect(nextUtcDay("2026-02-01")).toBe("2026-02-02");
+    expect(prevUtcDay("2026-02-01")).toBe("2026-01-31");
+  });
+
+  it("compareIsoDays sorts lexicographically for YYYY-MM-DD", () => {
+    expect(compareIsoDays("2026-01-01", "2026-02-01")).toBeLessThan(0);
+    expect(compareIsoDays("2026-02-01", "2026-02-01")).toBe(0);
+  });
+
+  it("assertValidUtcDay rejects invalid calendars", () => {
+    expect(() => assertValidUtcDay("2026-02-31")).toThrow();
+    expect(() => assertValidUtcDay("bad")).toThrow();
+  });
+});

packages/store/src/__tests__/log-store-archive.test.ts

@@ -0,0 +1,139 @@
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import { LOG_ARCHIVE_META_KEY, createLogStore } from "../log-store.js";
+import type { LogStore } from "../log-store.js";
+
+const DAY_MS = 86_400_000;
+
+/** `now` such that 2026-02-01 is the last archivable UTC day under a 30-day window. */
+function nowForLastArchivableFeb1(): number {
+  const boundary = Date.UTC(2026, 1, 2, 12, 0, 0);
+  return boundary + 30 * DAY_MS;
+}
+
+describe("LogStore — cold archive (RFC-001 §5.4)", () => {
+  let tmpDir: string;
+  let store: LogStore;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), "nerve-archive-"));
+    store = createLogStore(join(tmpDir, "data", "logs.db"));
+  });
+
+  afterEach(() => {
+    store.close();
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("exports one UTC day to JSONL, deletes rows, advances archived_up_to", () => {
+    const ts = Date.UTC(2026, 1, 1, 10, 0, 0);
+    store.append({ source: "system", type: "x", refId: null, payload: '{"a":1}', ts });
+    store.append({ source: "reflex", type: "y", refId: "z", payload: null, ts: ts + 1 });
+
+    const now = nowForLastArchivableFeb1();
+    const result = store.archiveLogs({ now, retentionMs: 30 * DAY_MS });
+    expect(result.days).toHaveLength(1);
+    expect(result.days[0].day).toBe("2026-02-01");
+    expect(result.days[0].rowCount).toBe(2);
+
+    const jsonlPath = join(tmpDir, "data", "archive", "logs", "2026-02-01.jsonl");
+    expect(result.days[0].filePath).toBe(jsonlPath);
+
+    const lines = readFileSync(jsonlPath, "utf8").trim().split("\n");
+    expect(lines).toHaveLength(2);
+    const o = JSON.parse(lines[0] ?? "{}") as Record<string, unknown>;
+    expect(o.source).toBe("system");
+    expect(o.refId).toBeNull();
+
+    expect(store.query()).toHaveLength(0);
+    expect(store.getMeta(LOG_ARCHIVE_META_KEY)).toBe("2026-02-01");
+  });
+
+  it("returns nothing for an empty logs table", () => {
+    const r = store.archiveLogs({ now: nowForLastArchivableFeb1(), retentionMs: 30 * DAY_MS });
+    expect(r.days).toHaveLength(0);
+    expect(store.getMeta(LOG_ARCHIVE_META_KEY)).toBeNull();
+  });
+
+  it("does nothing when all logs are inside the hot window", () => {
+    const now = Date.UTC(2026, 3, 23, 12, 0, 0);
+    const ts = now - 5 * DAY_MS;
+    store.append({ source: "system", type: "warm", refId: null, payload: null, ts });
+    const r = store.archiveLogs({ now, retentionMs: 30 * DAY_MS });
+    expect(r.days).toHaveLength(0);
+    expect(store.query()).toHaveLength(1);
+  });
+
+  it("second archive with same clock is a no-op (watermark already caught up)", () => {
+    const ts = Date.UTC(2026, 1, 1, 10, 0, 0);
+    store.append({ source: "system", type: "x", refId: null, payload: null, ts });
+    const now = nowForLastArchivableFeb1();
+    store.archiveLogs({ now, retentionMs: 30 * DAY_MS });
+    const path = join(tmpDir, "data", "archive", "logs", "2026-02-01.jsonl");
+    const first = readFileSync(path, "utf8");
+
+    const second = store.archiveLogs({ now, retentionMs: 30 * DAY_MS });
+    expect(second.days).toHaveLength(0);
+    expect(readFileSync(path, "utf8")).toBe(first);
+  });
+
+  it("overwrites JSONL when the same UTC day is archived again after watermark rewind", () => {
+    const ts = Date.UTC(2026, 1, 1, 10, 0, 0);
+    store.append({ source: "a", type: "1", refId: null, payload: null, ts });
+    const now = nowForLastArchivableFeb1();
+    store.archiveLogs({ now, retentionMs: 30 * DAY_MS });
+    store.setMeta(LOG_ARCHIVE_META_KEY, "2026-01-31");
+    store.append({ source: "b", type: "2", refId: null, payload: null, ts: ts + 100 });
+    store.archiveLogs({ now, retentionMs: 30 * DAY_MS });
+
+    const path = join(tmpDir, "data", "archive", "logs", "2026-02-01.jsonl");
+    const lines = readFileSync(path, "utf8").trim().split("\n");
+    expect(lines).toHaveLength(1);
+    expect(JSON.parse(lines[0] ?? "{}").source).toBe("b");
+  });
+
+  it("respects maxDays across invocations", () => {
+    const t1 = Date.UTC(2026, 1, 1, 10, 0, 0);
+    const t2 = Date.UTC(2026, 1, 2, 10, 0, 0);
+    store.append({ source: "system", type: "a", refId: null, payload: null, ts: t1 });
+    store.append({ source: "system", type: "b", refId: null, payload: null, ts: t2 });
+
+    const now = Date.UTC(2027, 0, 1, 12, 0, 0);
+    const r1 = store.archiveLogs({ now, retentionMs: 30 * DAY_MS, maxDays: 1 });
+    expect(r1.days).toHaveLength(1);
+    expect(r1.days[0].day).toBe("2026-02-01");
+
+    const r2 = store.archiveLogs({ now, retentionMs: 30 * DAY_MS, maxDays: 1 });
+    expect(r2.days).toHaveLength(1);
+    expect(r2.days[0].day).toBe("2026-02-02");
+    expect(store.getMeta(LOG_ARCHIVE_META_KEY)).toBe("2026-02-02");
+    expect(store.query()).toHaveLength(0);
+  });
+
+  it("starts from earliest log day when it is before watermark+1", () => {
+    store.setMeta(LOG_ARCHIVE_META_KEY, "2026-01-10");
+    const ts = Date.UTC(2026, 1, 1, 10, 0, 0);
+    store.append({ source: "x", type: "p", refId: null, payload: null, ts });
+    const result = store.archiveLogs({ now: nowForLastArchivableFeb1(), retentionMs: 30 * DAY_MS });
+    expect(result.days.map((d) => d.day)).toContain("2026-02-01");
+  });
+
+  it("throws on invalid archived_up_to watermark", () => {
+    store.setMeta(LOG_ARCHIVE_META_KEY, "not-a-date");
+    expect(() => store.archiveLogs({ now: Date.now() })).toThrow();
+  });
+
+  it("runs VACUUM when vacuum: true", () => {
+    const ts = Date.UTC(2026, 1, 1, 10, 0, 0);
+    store.append({ source: "system", type: "x", refId: null, payload: null, ts });
+    const r = store.archiveLogs({
+      now: nowForLastArchivableFeb1(),
+      retentionMs: 30 * DAY_MS,
+      vacuum: true,
+    });
+    expect(r.vacuumed).toBe(true);
+  });
+});

packages/store/src/__tests__/log-store-crash-recovery.test.ts

@@ -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);
+    });
+  });
 });

packages/store/src/blob-store.ts

@@ -0,0 +1,106 @@
+/**
+ * CAS blob store — sha256 content-addressable files under `data/blobs/`.
+ *
+ * Layout: `<root>/<2-hex-shard>/<62-hex-rest>` (RFC-001 §8).
+ */
+
+import { createHash, randomBytes } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+
+const SHA256_HEX_LEN = 64;
+const HEX_RE = /^[0-9a-f]+$/;
+
+export type BlobStore = {
+  /** Persist UTF-8 or raw bytes; returns lowercase hex sha256. Idempotent for identical content. */
+  write: (content: string | Uint8Array | Buffer) => string;
+  /** Returns bytes or null if the hash is invalid or no blob exists. Verifies digest matches path. */
+  read: (hash: string) => Buffer | null;
+  /** True when hash is well-formed and the blob file is present. */
+  exists: (hash: string) => boolean;
+};
+
+function toBuffer(content: string | Uint8Array | Buffer): Buffer {
+  if (typeof content === "string") return Buffer.from(content, "utf8");
+  if (Buffer.isBuffer(content)) return content;
+  return Buffer.from(content);
+}
+
+function digestHex(buf: Buffer): string {
+  return createHash("sha256").update(buf).digest("hex");
+}
+
+/** @returns normalized lowercase hex or null if not a valid sha256 hex string */
+export function normalizeBlobHash(hash: string): string | null {
+  const h = hash.trim().toLowerCase();
+  if (h.length !== SHA256_HEX_LEN) return null;
+  if (!HEX_RE.test(h)) return null;
+  return h;
+}
+
+function pathForHash(blobsRoot: string, hashLower: string): string {
+  return join(blobsRoot, hashLower.slice(0, 2), hashLower.slice(2));
+}
+
+function verifyPathMatchesContent(filePath: string, expectedHash: string): Buffer {
+  const data = readFileSync(filePath);
+  const actual = digestHex(data);
+  if (actual !== expectedHash) {
+    throw new Error(
+      `Blob CAS mismatch at "${filePath}": file digests to ${actual}, path expects ${expectedHash}`,
+    );
+  }
+  return data;
+}
+
+export function createBlobStore(blobsRoot: string): BlobStore {
+  function write(content: string | Uint8Array | Buffer): string {
+    const buf = toBuffer(content);
+    const hash = digestHex(buf);
+    const filePath = pathForHash(blobsRoot, hash);
+
+    if (existsSync(filePath)) {
+      verifyPathMatchesContent(filePath, hash);
+      return hash;
+    }
+
+    mkdirSync(dirname(filePath), { recursive: true });
+    const tmp = join(dirname(filePath), `.tmp.${randomBytes(16).toString("hex")}`);
+    try {
+      writeFileSync(tmp, buf);
+      renameSync(tmp, filePath);
+    } catch (e) {
+      try {
+        unlinkSync(tmp);
+      } catch {
+        // ignore cleanup errors
+      }
+      throw e;
+    }
+
+    return hash;
+  }
+
+  function read(hash: string): Buffer | null {
+    const h = normalizeBlobHash(hash);
+    if (h === null) return null;
+    const filePath = pathForHash(blobsRoot, h);
+    if (!existsSync(filePath)) return null;
+    return verifyPathMatchesContent(filePath, h);
+  }
+
+  function exists(hash: string): boolean {
+    const h = normalizeBlobHash(hash);
+    if (h === null) return false;
+    return existsSync(pathForHash(blobsRoot, h));
+  }
+
+  return { write, read, exists };
+}

packages/store/src/index.ts

@@ -0,0 +1,16 @@
+/**
+ * @uncaged/nerve-store — append-only log storage, cold-archive helpers, CAS blob store.
+ */
+
+export * from "./blob-store.js";
+export * from "./log-archive.js";
+export { createLogStore } from "./log-store.js";
+export type {
+  GetThreadRoundsParams,
+  LogEntry,
+  LogQuery,
+  LogStore,
+  ThreadRoundRow,
+  WorkflowRun,
+  WorkflowRunStatus,
+} from "./log-store.js";

packages/store/src/log-archive.ts

@@ -0,0 +1,78 @@
+/** Log cold-archive helpers (RFC-001 §5.4) — UTC calendar days, JSONL export. */
+
+export const LOG_ARCHIVE_META_KEY = "archived_up_to";
+
+export const DEFAULT_LOG_RETENTION_MS = 30 * 86_400_000;
+
+export type ArchiveLogsOptions = {
+  /** Wall clock for retention boundary (default: `Date.now()`). */
+  now?: number;
+  /** Run `VACUUM` after archiving (outside the per-day transaction). */
+  vacuum?: boolean;
+  /** Max UTC days to process in one call (default: unlimited). */
+  maxDays?: number;
+  /** Override default 30-day retention (tests). */
+  retentionMs?: number;
+};
+
+export type ArchiveLogsDayResult = {
+  day: string;
+  rowCount: number;
+  filePath: string;
+};
+
+export type ArchiveLogsResult = {
+  days: ArchiveLogsDayResult[];
+  vacuumed: boolean;
+};
+
+export function utcDateStringFromMs(ms: number): string {
+  return new Date(ms).toISOString().slice(0, 10);
+}
+
+function parseUtcDayParts(day: string): [number, number, number] {
+  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(day);
+  if (m === null) {
+    throw new Error(`Invalid UTC day (expected YYYY-MM-DD): ${day}`);
+  }
+  const y = Number(m[1]);
+  const mo = Number(m[2]);
+  const d = Number(m[3]);
+  const t = Date.UTC(y, mo - 1, d);
+  if (utcDateStringFromMs(t) !== day) {
+    throw new Error(`Invalid UTC calendar day: ${day}`);
+  }
+  return [y, mo, d];
+}
+
+export function assertValidUtcDay(day: string): void {
+  parseUtcDayParts(day);
+}
+
+export function utcDayStartMs(day: string): number {
+  const [y, mo, d] = parseUtcDayParts(day);
+  return Date.UTC(y, mo - 1, d);
+}
+
+export function utcDayEndExclusiveMs(day: string): number {
+  return utcDayStartMs(day) + 86_400_000;
+}
+
+export function prevUtcDay(day: string): string {
+  return utcDateStringFromMs(utcDayStartMs(day) - 86_400_000);
+}
+
+export function nextUtcDay(day: string): string {
+  return utcDateStringFromMs(utcDayEndExclusiveMs(day));
+}
+
+/** Last UTC calendar day D such that the exclusive end of D is ≤ boundaryMs. */
+export function lastArchivableUtcDay(boundaryMs: number): string {
+  return prevUtcDay(utcDateStringFromMs(boundaryMs));
+}
+
+export function compareIsoDays(a: string, b: string): number {
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
+}

packages/store/src/log-store.ts

@@ -0,0 +1,702 @@
+/**
+ * Log Store — append-only structured log storage backed by SQLite.
+ *
+ * Stores system, reflex, and workflow log entries in a single table.
+ * Logs are data assets for audit/analysis — they MUST NOT trigger reflexes.
+ *
+ * Also provides a `meta` key-value table for bookkeeping (e.g. archive watermarks).
+ */
+
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { DatabaseSync, type StatementSync } from "node:sqlite";
+
+import {
+  DEFAULT_LOG_RETENTION_MS,
+  LOG_ARCHIVE_META_KEY,
+  assertValidUtcDay,
+  compareIsoDays,
+  lastArchivableUtcDay,
+  nextUtcDay,
+  utcDateStringFromMs,
+  utcDayEndExclusiveMs,
+  utcDayStartMs,
+} from "./log-archive.js";
+import type { ArchiveLogsDayResult, ArchiveLogsOptions, ArchiveLogsResult } from "./log-archive.js";
+
+export { LOG_ARCHIVE_META_KEY } from "./log-archive.js";
+export type { ArchiveLogsDayResult, ArchiveLogsOptions, ArchiveLogsResult } from "./log-archive.js";
+
+export type LogEntry = {
+  id?: number;
+  source: string;
+  type: string;
+  refId: string | null;
+  payload: string | null;
+  ts: number;
+};
+
+export type LogQuery = {
+  source?: string;
+  type?: string;
+  refId?: string;
+  since?: number;
+  until?: number;
+  limit?: number;
+};
+
+// ---------------------------------------------------------------------------
+// Workflow runs materialized view (RFC-002 §6.2)
+// ---------------------------------------------------------------------------
+
+export type WorkflowRunStatus =
+  | "queued"
+  | "started"
+  | "completed"
+  | "failed"
+  | "crashed"
+  | "dropped"
+  | "interrupted";
+
+const VALID_WORKFLOW_STATUSES = new Set<string>([
+  "queued",
+  "started",
+  "completed",
+  "failed",
+  "crashed",
+  "dropped",
+  "interrupted",
+]);
+
+function validateWorkflowRunStatus(status: string): WorkflowRunStatus {
+  if (!VALID_WORKFLOW_STATUSES.has(status)) {
+    throw new Error(`Invalid workflow run status from DB: "${status}"`);
+  }
+  return status as WorkflowRunStatus;
+}
+
+/** One row in the workflow_runs materialized table. */
+export type WorkflowRun = {
+  runId: string;
+  workflow: string;
+  status: WorkflowRunStatus;
+  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[];
+  getMeta: (key: string) => string | null;
+  setMeta: (key: string, value: string) => void;
+  /**
+   * Append a workflow log event and atomically upsert the workflow_runs
+   * materialized table — both in a single SQLite transaction (RFC-002 §6.2).
+   */
+  upsertWorkflowRun: (entry: Omit<LogEntry, "id">, run: WorkflowRun) => LogEntry;
+  /**
+   * Alias for upsertWorkflowRun — append a log entry and update workflow_runs
+   * in one atomic transaction.
+   */
+  appendWithWorkflowUpdate: (entry: Omit<LogEntry, "id">, run: WorkflowRun) => LogEntry;
+  /** Get the current materialized state of a specific workflow run. */
+  getWorkflowRun: (runId: string) => WorkflowRun | null;
+  /**
+   * Get all workflow runs with status 'queued' or 'started'.
+   * Optionally filter by workflow name.
+   */
+  getActiveWorkflowRuns: (workflowName?: string) => WorkflowRun[];
+  /**
+   * Get all workflow runs regardless of status, sorted by ts descending.
+   * Optionally filter by workflow name.
+   */
+  getAllWorkflowRuns: (workflowName: string | null) => WorkflowRun[];
+  /**
+   * Get the trigger payload for a workflow run (stored in the 'started' log entry).
+   * Returns null if not found.
+   */
+  getTriggerPayload: (runId: string) => unknown;
+  /**
+   * Get all workflow CommandEvents for a specific run, ordered by id ASC.
+   * @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
+   * (RFC-001 §5.4).
+   */
+  archiveLogs: (options?: ArchiveLogsOptions) => ArchiveLogsResult;
+  close: () => void;
+};
+
+const SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS logs (
+  id      INTEGER PRIMARY KEY AUTOINCREMENT,
+  source  TEXT NOT NULL,
+  type    TEXT NOT NULL,
+  ref_id  TEXT,
+  payload TEXT,
+  ts      INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_logs_source_type ON logs(source, type);
+CREATE INDEX IF NOT EXISTS idx_logs_ts ON logs(ts);
+CREATE INDEX IF NOT EXISTS idx_logs_ref_id ON logs(ref_id);
+
+CREATE TABLE IF NOT EXISTS meta (
+  key   TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS workflow_runs (
+  run_id   TEXT PRIMARY KEY,
+  workflow TEXT NOT NULL,
+  status   TEXT NOT NULL,
+  ts       INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_workflow_runs_status ON workflow_runs(status);
+CREATE INDEX IF NOT EXISTS idx_workflow_runs_workflow ON workflow_runs(workflow);
+`;
+
+type SqlLogRow = {
+  id: number;
+  source: string;
+  type: string;
+  ref_id: string | null;
+  payload: string | null;
+  ts: number;
+};
+
+function buildJsonlBody(rows: SqlLogRow[]): string {
+  if (rows.length === 0) return "";
+  const lines = rows.map((r) =>
+    JSON.stringify({
+      id: r.id,
+      source: r.source,
+      type: r.type,
+      refId: r.ref_id,
+      payload: r.payload,
+      ts: r.ts,
+    }),
+  );
+  return `${lines.join("\n")}\n`;
+}
+
+function runInTransaction<T>(db: DatabaseSync, fn: () => T): T {
+  db.exec("BEGIN IMMEDIATE");
+  try {
+    const out = fn();
+    db.exec("COMMIT");
+    return out;
+  } catch (e) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {
+      // ignore rollback errors
+    }
+    throw e;
+  }
+}
+
+function runOptionalVacuum(sqlite: DatabaseSync, vacuum?: boolean): boolean {
+  if (vacuum !== true) return false;
+  sqlite.exec("VACUUM");
+  return true;
+}
+
+function resolveArchiveStartDay(watermark: string | null, minDay: string): string {
+  if (watermark === null) return minDay;
+  const afterWatermark = nextUtcDay(watermark);
+  return compareIsoDays(minDay, afterWatermark) < 0 ? minDay : afterWatermark;
+}
+
+function runArchiveDayLoop(
+  dbPath: string,
+  options: ArchiveLogsOptions,
+  selectLogsForDayStmt: StatementSync,
+  archiveDayTx: (day: string, start: number, endExclusive: number) => void,
+  startDay: string,
+  lastDay: string,
+): ArchiveLogsDayResult[] {
+  const archiveDir = join(dirname(dbPath), "archive", "logs");
+  mkdirSync(archiveDir, { recursive: true });
+
+  const days: ArchiveLogsDayResult[] = [];
+  let d = startDay;
+  let processed = 0;
+
+  while (compareIsoDays(d, lastDay) <= 0) {
+    if (options.maxDays !== undefined && processed >= options.maxDays) {
+      break;
+    }
+
+    const start = utcDayStartMs(d);
+    const endExclusive = utcDayEndExclusiveMs(d);
+    const rows = selectLogsForDayStmt.all({ start, endExclusive }) as SqlLogRow[];
+
+    const filePath = join(archiveDir, `${d}.jsonl`);
+    writeFileSync(filePath, buildJsonlBody(rows), "utf8");
+    archiveDayTx(d, start, endExclusive);
+
+    days.push({ day: d, rowCount: rows.length, filePath });
+    processed += 1;
+    d = nextUtcDay(d);
+  }
+
+  return days;
+}
+
+export function createLogStore(dbPath: string): LogStore {
+  mkdirSync(dirname(dbPath), { recursive: true });
+
+  const sqlite = new DatabaseSync(dbPath);
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec(SCHEMA_SQL);
+
+  const insertStmt = sqlite.prepare(
+    "INSERT INTO logs (source, type, ref_id, payload, ts) VALUES (@source, @type, @refId, @payload, @ts)",
+  );
+
+  const getMetaStmt = sqlite.prepare("SELECT value FROM meta WHERE key = ?");
+  const setMetaStmt = sqlite.prepare(
+    "INSERT INTO meta (key, value) VALUES (@key, @value) ON CONFLICT(key) DO UPDATE SET value = @value",
+  );
+
+  const upsertWorkflowRunStmt = sqlite.prepare(
+    "INSERT OR REPLACE INTO workflow_runs (run_id, workflow, status, ts) VALUES (@runId, @workflow, @status, @ts)",
+  );
+
+  const getWorkflowRunStmt = sqlite.prepare(
+    "SELECT run_id, workflow, status, ts FROM workflow_runs WHERE run_id = ?",
+  );
+
+  const getTriggerPayloadStmt = sqlite.prepare(
+    "SELECT payload FROM logs WHERE source = 'workflow' AND type = 'started' AND ref_id = ? ORDER BY id ASC LIMIT 1",
+  );
+
+  const getThreadEventsStmt = sqlite.prepare(
+    "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",
+  );
+
+  const getActiveWorkflowRunsByNameStmt = sqlite.prepare(
+    "SELECT run_id, workflow, status, ts FROM workflow_runs WHERE status IN ('queued', 'started') AND workflow = ? ORDER BY ts ASC",
+  );
+
+  const getAllWorkflowRunsStmt = sqlite.prepare(
+    "SELECT run_id, workflow, status, ts FROM workflow_runs ORDER BY ts DESC",
+  );
+
+  const getAllWorkflowRunsByNameStmt = sqlite.prepare(
+    "SELECT run_id, workflow, status, ts FROM workflow_runs WHERE workflow = ? ORDER BY ts DESC",
+  );
+
+  const minLogTsStmt = sqlite.prepare("SELECT MIN(ts) AS m FROM logs");
+  const selectLogsForDayStmt = sqlite.prepare(
+    "SELECT id, source, type, ref_id, payload, ts FROM logs WHERE ts >= @start AND ts < @endExclusive ORDER BY id ASC",
+  );
+  const deleteLogsForDayStmt = sqlite.prepare(
+    "DELETE FROM logs WHERE ts >= @start AND ts < @endExclusive",
+  );
+
+  function upsertWorkflowRunTx(entry: Omit<LogEntry, "id">, run: WorkflowRun): LogEntry {
+    return runInTransaction(sqlite, () => {
+      const info = insertStmt.run({
+        source: entry.source,
+        type: entry.type,
+        refId: entry.refId,
+        payload: entry.payload,
+        ts: entry.ts,
+      });
+      upsertWorkflowRunStmt.run({
+        runId: run.runId,
+        workflow: run.workflow,
+        status: run.status,
+        ts: run.ts,
+      });
+      return { ...entry, id: Number(info.lastInsertRowid) };
+    });
+  }
+
+  function append(entry: Omit<LogEntry, "id">): LogEntry {
+    const info = insertStmt.run({
+      source: entry.source,
+      type: entry.type,
+      refId: entry.refId,
+      payload: entry.payload,
+      ts: entry.ts,
+    });
+    return { ...entry, id: Number(info.lastInsertRowid) };
+  }
+
+  function query(filter: LogQuery = {}): LogEntry[] {
+    const conditions: string[] = [];
+    const params: Record<string, string | number> = {};
+
+    if (filter.source !== undefined) {
+      conditions.push("source = @source");
+      params.source = filter.source;
+    }
+    if (filter.type !== undefined) {
+      conditions.push("type = @type");
+      params.type = filter.type;
+    }
+    if (filter.refId !== undefined) {
+      conditions.push("ref_id = @refId");
+      params.refId = filter.refId;
+    }
+    if (filter.since !== undefined) {
+      conditions.push("ts >= @since");
+      params.since = filter.since;
+    }
+    if (filter.until !== undefined) {
+      conditions.push("ts <= @until");
+      params.until = filter.until;
+    }
+
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const limit = filter.limit !== undefined ? `LIMIT ${filter.limit}` : "";
+    const sql = `SELECT id, source, type, ref_id, payload, ts FROM logs ${where} ORDER BY id ASC ${limit}`;
+
+    const rows = sqlite.prepare(sql).all(params) as Array<{
+      id: number;
+      source: string;
+      type: string;
+      ref_id: string | null;
+      payload: string | null;
+      ts: number;
+    }>;
+
+    return rows.map((r) => ({
+      id: r.id,
+      source: r.source,
+      type: r.type,
+      refId: r.ref_id,
+      payload: r.payload,
+      ts: r.ts,
+    }));
+  }
+
+  function getMeta(key: string): string | null {
+    const row = getMetaStmt.get(key) as { value: string } | undefined;
+    return row?.value ?? null;
+  }
+
+  function setMeta(key: string, value: string): void {
+    setMetaStmt.run({ key, value });
+  }
+
+  function upsertWorkflowRun(entry: Omit<LogEntry, "id">, run: WorkflowRun): LogEntry {
+    return upsertWorkflowRunTx(entry, run);
+  }
+
+  function appendWithWorkflowUpdate(entry: Omit<LogEntry, "id">, run: WorkflowRun): LogEntry {
+    return upsertWorkflowRunTx(entry, run);
+  }
+
+  function getWorkflowRun(runId: string): WorkflowRun | null {
+    const row = getWorkflowRunStmt.get(runId) as
+      | { run_id: string; workflow: string; status: string; ts: number }
+      | undefined;
+    if (row === undefined) return null;
+    return {
+      runId: row.run_id,
+      workflow: row.workflow,
+      status: validateWorkflowRunStatus(row.status),
+      ts: row.ts,
+    };
+  }
+
+  function getActiveWorkflowRuns(workflowName?: string): WorkflowRun[] {
+    const rows = (
+      workflowName !== undefined
+        ? getActiveWorkflowRunsByNameStmt.all(workflowName)
+        : getActiveWorkflowRunsStmt.all()
+    ) as Array<{ run_id: string; workflow: string; status: string; ts: number }>;
+    return rows.map((r) => ({
+      runId: r.run_id,
+      workflow: r.workflow,
+      status: validateWorkflowRunStatus(r.status),
+      ts: r.ts,
+    }));
+  }
+
+  function getAllWorkflowRuns(workflowName: string | null): WorkflowRun[] {
+    const rows = (
+      workflowName !== null
+        ? getAllWorkflowRunsByNameStmt.all(workflowName)
+        : getAllWorkflowRunsStmt.all()
+    ) as Array<{ run_id: string; workflow: string; status: string; ts: number }>;
+    return rows.map((r) => ({
+      runId: r.run_id,
+      workflow: r.workflow,
+      status: validateWorkflowRunStatus(r.status),
+      ts: r.ts,
+    }));
+  }
+
+  function getTriggerPayload(runId: string): unknown {
+    const row = getTriggerPayloadStmt.get(runId) as { payload: string | null } | undefined;
+    if (row === undefined || row.payload === null) return null;
+    try {
+      const parsed = JSON.parse(row.payload) as unknown;
+      if (parsed !== null && typeof parsed === "object") {
+        const obj = parsed as Record<string, unknown>;
+        return obj.triggerPayload ?? null;
+      }
+    } catch {
+      // malformed
+    }
+    return null;
+  }
+
+  function getThreadEvents(runId: string): Array<{ type: string; [key: string]: unknown }> {
+    const rows = getThreadEventsStmt.all(runId) as Array<{ payload: string | null }>;
+    const result: Array<{ type: string; [key: string]: unknown }> = [];
+    for (const row of rows) {
+      if (row.payload === null) continue;
+      try {
+        const parsed = JSON.parse(row.payload) as unknown;
+        if (
+          parsed !== null &&
+          typeof parsed === "object" &&
+          typeof (parsed as Record<string, unknown>).type === "string"
+        ) {
+          result.push(parsed as { type: string; [key: string]: unknown });
+        }
+      } catch {
+        // skip malformed payloads
+      }
+    }
+    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 });
+      setMetaStmt.run({ key: LOG_ARCHIVE_META_KEY, value: day });
+    });
+  }
+
+  function readWatermark(): string | null {
+    const raw = getMeta(LOG_ARCHIVE_META_KEY);
+    if (raw === null) return null;
+    assertValidUtcDay(raw);
+    return raw;
+  }
+
+  function firstLogUtcDay(): string | null {
+    const row = minLogTsStmt.get() as { m: number | null } | undefined;
+    const m = row?.m;
+    if (m === null || m === undefined) return null;
+    return utcDateStringFromMs(m);
+  }
+
+  function archiveLogs(options: ArchiveLogsOptions = {}): ArchiveLogsResult {
+    const now = options.now ?? Date.now();
+    const retentionMs = options.retentionMs ?? DEFAULT_LOG_RETENTION_MS;
+    const lastDay = lastArchivableUtcDay(now - retentionMs);
+
+    const watermark = readWatermark();
+    const minDay = firstLogUtcDay();
+    if (minDay === null) {
+      return { days: [], vacuumed: runOptionalVacuum(sqlite, options.vacuum) };
+    }
+
+    const startDay = resolveArchiveStartDay(watermark, minDay);
+    if (compareIsoDays(startDay, lastDay) > 0) {
+      return { days: [], vacuumed: runOptionalVacuum(sqlite, options.vacuum) };
+    }
+
+    const days = runArchiveDayLoop(
+      dbPath,
+      options,
+      selectLogsForDayStmt,
+      archiveDayTx,
+      startDay,
+      lastDay,
+    );
+    return { days, vacuumed: runOptionalVacuum(sqlite, options.vacuum) };
+  }
+
+  function close(): void {
+    sqlite.close();
+  }
+
+  return {
+    append,
+    query,
+    getMeta,
+    setMeta,
+    upsertWorkflowRun,
+    appendWithWorkflowUpdate,
+    getWorkflowRun,
+    getActiveWorkflowRuns,
+    getAllWorkflowRuns,
+    getTriggerPayload,
+    getThreadEvents,
+    getThreadMessages,
+    getThreadRoundCount,
+    getThreadRounds,
+    archiveLogs,
+    close,
+  };
+}

packages/store/tsconfig.json

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

pnpm-workspace.yaml

@@ -3,5 +3,4 @@ packages:
 
 onlyBuiltDependencies:
   - "@biomejs/biome"
-  - better-sqlite3
   - esbuild

scripts/prepublish-check.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+# All packages must use pnpm publish. Block npm publish unconditionally.
+
+if [ -z "$npm_execpath" ] || [[ "$npm_execpath" != *pnpm* ]]; then
+  echo "❌ Use 'pnpm publish' instead of 'npm publish'."
+  echo "   pnpm auto-converts workspace:* dependencies to real versions."
+  exit 1
+fi

tsconfig.json

@@ -17,6 +17,7 @@
   },
   "references": [
     { "path": "packages/core" },
+    { "path": "packages/store" },
     { "path": "packages/cli" },
     { "path": "packages/daemon" }
   ]