fix: comprehensive cli.md — all subcommands and flags

Major additions:
- thread: list/show/inspect/kill with all flags
- remote: add/list/show/set-url/set-token/remove/default
- init: --from, --force
- dev/start: --port
- daemon: restart subcommands
- sense/workflow: all flags
- logs: --offset
- store archive: --vacuum
- workspace layout: updated with workflow structure

.cursor/rules/global.mdc

@@ -9,7 +9,7 @@ alwaysApply: true
 ## Core Concepts
 
 ```
-External World → Sense(state) → { newState, workflow? } → Workflow → Log
+External World → Sense → Signal → Reflex → Workflow → Log
                   ↑                                     ↑
               "what to observe"                  "what to do"
 ```
@@ -20,17 +20,19 @@ External World → Sense(state) → { newState, workflow? } → Workflow → Log
 
 | Concept | What it is |
 |---------|-----------|
-| **Sense** | A stateful `compute(state)` function. Returns new state and an optional workflow trigger. State persisted as JSON. Scheduling (`interval`, `on`) is configured per sense in nerve.yaml. |
+| **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 senses or workflows** — prevents feedback loops. |
-| **Engine** | The kernel orchestrating everything. Holds Process Manager, Workflow Manager, Sense Scheduler. Never loads user code directly — all user code runs in isolated Workers. |
+| **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
 
-- **Two orthogonal extension points**: Sense (what to observe + when), Workflow (what to do)
+- **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(state) → Workflow (when triggered) + Log. Logs are the end of the chain.
+- **Causality is one-directional**: External world → Sense → Signal → Reflex → Action + Log. Logs are the end of the chain.
 
 
 
@@ -42,18 +44,18 @@ Use `function` + `type`, not `class` + `interface`.
 
 ```typescript
 // ✅ Good
-type WorkflowLaunch = {
-  senseName: string;
-  workflowName: string;
+type Signal = {
+  senseId: string;
+  value: unknown;
   ts: number;
 };
 
-function recordWorkflowLaunch(senseName: string, workflowName: string): WorkflowLaunch {
-  return { senseName, workflowName, ts: Date.now() };
+function createSignal(senseId: string, value: unknown): Signal {
+  return { senseId, value, ts: Date.now() };
 }
 
 // ❌ Bad — no class, no interface
-class WorkflowLaunch implements IWorkflowLaunch { ... }
+class Signal implements ISignal { ... }
 ```
 
 ### Rules
@@ -98,9 +100,9 @@ For mutually exclusive fields, use discriminated unions:
 
 ```typescript
 // ✅ Good
-type WorkflowConfig =
-  | { concurrency: number; overflow: "drop" }
-  | { concurrency: number; overflow: "queue"; maxQueue: number };
+type ReflexConfig =
+  | { kind: "sense"; sense: string; interval: string | null; on: string[] | null }
+  | { kind: "workflow"; workflow: string; on: string[] | null };
 ```
 
 ## Modules & Exports
@@ -121,9 +123,9 @@ export default function startEngine() { ... }
 
 | Type | Style | Example |
 |------|-------|---------|
-| Files | kebab-case | `sense-scheduler.ts` |
-| Types | PascalCase | `SenseScheduler` |
-| Functions/variables | camelCase | `createSenseScheduler` |
+| 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` |
 

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

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

.github/copilot-instructions.md

@@ -3,7 +3,7 @@
 ## Core Concepts
 
 ```
-External World → Sense(state) → { newState, workflow? } → Workflow → Log
+External World → Sense → Signal → Reflex → Workflow → Log
                   ↑                                     ↑
               "what to observe"                  "what to do"
 ```
@@ -14,17 +14,19 @@ External World → Sense(state) → { newState, workflow? } → Workflow → Log
 
 | Concept | What it is |
 |---------|-----------|
-| **Sense** | A stateful `compute(state)` function. Returns new state and an optional workflow trigger. State persisted as JSON. Scheduling (`interval`, `on`) is configured per sense in nerve.yaml. |
+| **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 senses or workflows** — prevents feedback loops. |
-| **Engine** | The kernel orchestrating everything. Holds Process Manager, Workflow Manager, Sense Scheduler. Never loads user code directly — all user code runs in isolated Workers. |
+| **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
 
-- **Two orthogonal extension points**: Sense (what to observe + when), Workflow (what to do)
+- **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(state) → Workflow (when triggered) + Log. Logs are the end of the chain.
+- **Causality is one-directional**: External world → Sense → Signal → Reflex → Action + Log. Logs are the end of the chain.
 
 
 
@@ -36,18 +38,18 @@ Use `function` + `type`, not `class` + `interface`.
 
 ```typescript
 // ✅ Good
-type WorkflowLaunch = {
-  senseName: string;
-  workflowName: string;
+type Signal = {
+  senseId: string;
+  value: unknown;
   ts: number;
 };
 
-function recordWorkflowLaunch(senseName: string, workflowName: string): WorkflowLaunch {
-  return { senseName, workflowName, ts: Date.now() };
+function createSignal(senseId: string, value: unknown): Signal {
+  return { senseId, value, ts: Date.now() };
 }
 
 // ❌ Bad — no class, no interface
-class WorkflowLaunch implements IWorkflowLaunch { ... }
+class Signal implements ISignal { ... }
 ```
 
 ### Rules
@@ -92,9 +94,9 @@ For mutually exclusive fields, use discriminated unions:
 
 ```typescript
 // ✅ Good
-type WorkflowConfig =
-  | { concurrency: number; overflow: "drop" }
-  | { concurrency: number; overflow: "queue"; maxQueue: number };
+type ReflexConfig =
+  | { kind: "sense"; sense: string; interval: string | null; on: string[] | null }
+  | { kind: "workflow"; workflow: string; on: string[] | null };
 ```
 
 ## Modules & Exports
@@ -106,9 +108,9 @@ type WorkflowConfig =
 
 | Type | Style | Example |
 |------|-------|---------|
-| Files | kebab-case | `sense-scheduler.ts` |
-| Types | PascalCase | `SenseScheduler` |
-| Functions/variables | camelCase | `createSenseScheduler` |
+| 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` |
 

.gitignore

@@ -3,4 +3,3 @@ dist
 .turbo
 *.tsbuildinfo
 *.tgz
-knowledge.db

.knowledge/adapter-isolation.md

@@ -1,171 +0,0 @@
-# Adapter Process Isolation
-
-Describes sandboxing, process isolation, resource limits, and timeout enforcement for adapter invocations in the Nerve workflow system.
-
-## Process Isolation Model
-
-Adapters run in a **two-tier isolation** model:
-
-1. **Workflow Worker Process** — Each workflow runs in a dedicated Node.js worker process (`workflow-worker.ts`) forked from the main daemon
-2. **Adapter Child Process** — Each adapter spawns CLI tools as child processes via `spawnSafe()` with `shell: false`
-
-## Resource Limits & Timeouts
-
-### Adapter-Level Timeouts
-
-- **Default timeout**: 300 seconds (300,000ms) for both cursor and hermes adapters
-- **Configurable** via `AgentConfig.timeout` in adapter factory functions
-- **Wall-clock enforcement** using `setTimeout()` — kills child process with `SIGTERM` on timeout
-- **AbortSignal support** — external cancellation triggers immediate `SIGTERM`
-
-### Timeout Behavior
-
-```ts
-// Timeout resolution priority (packages/core/src/spawn-safe.ts):
-// 1. Explicit timeoutMs value
-// 2. AbortSignal presence → no internal timer (relies on external abort)
-// 3. DEFAULT_TIMEOUT_MS (300_000) fallback
-```
-
-- Child process terminated with `SIGTERM` on timeout/abort
-- Returns `{ kind: "timeout", stdout, stderr }` error result
-- **No grace period** — immediate kill
-- **No SIGKILL escalation** — relies entirely on `SIGTERM` effectiveness
-
-#### SIGTERM Limitations
-
-If a child process **ignores or blocks `SIGTERM`** (e.g., signal handlers, blocked delivery):
-
-- **No fallback to `SIGKILL`** — process may remain alive indefinitely
-- **No escalation timer** — spawnSafe() does not implement progressive signal escalation
-- **Potential zombie/orphan risk** — unresponsive processes continue consuming resources
-- **OS-level cleanup only** — relies on parent process death or OS reaping mechanisms
-
-## Sandboxing Characteristics
-
-### What's Isolated
-
-- **File system**: Child process runs in specified `cwd` (workflow working directory)
-- **Environment**: Controlled env vars via `nerveCommandEnv()` + optional overrides
-- **Network**: No explicit restrictions (inherits parent process network access)
-- **Process tree**: Child processes are direct children, not containerized
-
-### What's NOT Sandboxed
-
-- **No resource quotas** (CPU, memory, disk I/O limits)
-- **No filesystem chroot/containers** — full filesystem access within user permissions
-- **No network isolation** — can make arbitrary network calls
-- **No syscall filtering** — no seccomp or similar restrictions
-
-#### Runtime Resource Enforcement
-
-**No active resource monitoring or constraints**:
-
-- **No cgroups** (Linux) — no CPU, memory, or I/O limits enforced
-- **No job objects** (Windows) — no resource quotas or process tree limits
-- **No worker_threads resource tracking** — Node.js worker processes run unrestricted
-- **Pure timeout-based enforcement** — only wall-clock time limits via `setTimeout()`
-- **OS-scheduled resource sharing** — relies entirely on operating system process scheduling
-
-Adapters can consume unlimited:
-- **CPU time** (until timeout)
-- **Memory** (until OOM)
-- **Disk I/O** (no quotas)
-- **Network bandwidth** (no throttling)
-- **File descriptors** (until ulimit)
-
-#### Environment Variable Security
-
-The `nerveCommandEnv()` function provides **minimal sanitization**:
-
-```ts
-// spawn-safe.ts lines 47-55
-export function nerveCommandEnv(): SpawnEnv {
-  const home = homedir();
-  const pnpmHome = join(home, ".local/share/pnpm");
-  return {
-    ...process.env,           // ← Full parent environment inherited
-    PNPM_HOME: pnpmHome,
-    PATH: `${pnpmHome}:${process.env.PATH ?? ""}`,
-  };
-}
-```
-
-- **No filtering of sensitive keys** — `NODE_OPTIONS`, `LD_PRELOAD`, `PYTHONPATH` passed through unchanged
-- **Full environment inheritance** — all parent process environment variables copied
-- **Injection risk** — malicious env vars (e.g., `NODE_OPTIONS=--require=evil.js`) affect Node.js child processes
-- **Path manipulation** — sensitive PATH entries remain accessible to adapters
-
-## Security Model
-
-### Execution Context
-
-- Uses `shell: false` to prevent shell injection attacks
-- Arguments passed as separate array elements (not shell-parsed)
-- PATH includes `~/.local/share/pnpm` for tool discovery
-- Inherits parent process user/group permissions
-
-#### File Descriptor Management
-
-```ts
-// spawn-safe.ts line 122
-stdio: ["ignore", "pipe", "pipe"]
-```
-
-- **stdin closed**: Child receives no input (`stdio[0]: "ignore"`)
-- **stdout/stderr captured**: Piped to parent for collection (`stdio[1,2]: "pipe"`)
-- **No explicit fd closing**: Node.js default behavior — inherits other file descriptors
-- **Parent sockets/pipes accessible**: Child can access parent's open network connections, database handles, etc.
-- **Security risk**: Adapter processes may access unintended parent file descriptors
-
-### Attack Surface
-
-- CLI tools have **full user-level filesystem access**
-- Can spawn additional processes (not tracked/limited)
-- Network requests unrestricted
-- Resource consumption relies on OS-level limits
-
-## Worker Process Management
-
-### Workflow Isolation
-
-- Each workflow type gets dedicated worker process
-- Worker processes handle multiple concurrent threads (runIds)
-- Kill flags enable per-thread cancellation without killing worker
-- Graceful shutdown waits up to 10 seconds for in-flight operations
-
-#### Cross-RunId Contamination Risks
-
-**Shared mutable state** poses contamination risks between concurrent runIds:
-
-- **`process.env` mutations**: Environment changes affect all subsequent runIds in same worker
-- **`require.cache` pollution**: Module cache shared across all runIds — side effects persist
-- **Global variables**: Any global state mutations from one runId visible to others
-- **`process.cwd()` changes**: Working directory changes affect entire worker process
-- **File descriptors**: Open files/sockets shared between runId executions
-
-**No runId-specific scoping** implemented:
-- Worker reuses single Node.js process for efficiency
-- Each role execution sees cumulative environment from previous runIds
-- **Mitigation relies on adapter discipline** — clean implementations avoid global mutations
-
-### Error Handling
-
-- Adapter failures don't crash the worker process
-- Timeout/abort errors are isolated to specific role execution
-- Worker process survives adapter failures and continues serving other threads
-
-## Configuration
-
-```yaml
-# Example nerve.yaml configuration for timeout overrides
-workflows:
-  my-workflow:
-    roles:
-      coder:
-        adapter:
-          type: cursor
-          timeout: 600000  # 10 minutes in milliseconds
-```
-
-Timeout configuration happens at the adapter creation level, not as a system-wide sandbox policy.

.knowledge/adapter.md

@@ -5,52 +5,21 @@ Adapter = capability. Role = scenario. Workflows declare adapters directly via i
 ## AgentFn Protocol
 
 ```ts
-type AgentFn = (ctx: ThreadContext, systemPrompt: string) => Promise<string>
+type AgentFn = (prompt: string, context: WorkflowContext) => Promise<string>
 ```
 
-- Input: thread context (`{ threadId, start, steps }`) + system prompt (role identity)
-- Output: **single-shot `Promise<string>`** — no streaming support
+- Input: prompt + context (start frame, messages, workdir, AbortSignal)
+- Output: raw string — structured extraction is separate
 - Adapter handles tool-specific details internally
 
-### Streaming Limitations
-
-The `AgentFn` protocol does **not** support streaming responses (`AsyncIterable<string>` or `ReadableStream`). It's strictly limited to single-shot `Promise<string>` returns.
-
-For long-running or incremental agent outputs:
-- CLI tools buffer full output until completion
-- Timeout enforcement via `timeoutMs` (default 300s)
-- No intermediate results exposed to workflow logic
-- Progress indication happens at the CLI tool level only
-
 ## Available Adapters
 
 | Package | Adapter | Tool |
 |---------|---------|------|
 | `@uncaged/nerve-adapter-cursor` | `cursorAdapter` / `createCursorAdapter()` | cursor-agent CLI |
 | `@uncaged/nerve-adapter-hermes` | `hermesAdapter` / `createHermesAdapter()` | hermes chat CLI |
-| `@uncaged/nerve-workflow-utils` | `createLlmAdapter(provider)` | OpenAI-compatible HTTP chat (single-turn) |
 
-The Cursor and Hermes adapter packages each export a **default instance** (sensible defaults) and a **factory** for custom config. `createLlmAdapter` is a factory on `@uncaged/nerve-workflow-utils` only.
-
-## createLlmAdapter
-
-`createLlmAdapter` builds an `AgentFn` from an `LlmProvider` (`baseUrl`, `apiKey`, `model`). One chat completion per role step: **system** = the string passed by `createRole` (your prompt); **user** = `ctx.start.content` (the thread’s start frame). On failure it throws with a formatted LLM error.
-
-```ts
-import { createLlmAdapter, createRole } from "@uncaged/nerve-workflow-utils";
-import { z } from "zod";
-
-const metaSchema = z.object({ ok: z.boolean() });
-
-const planner = createRole(
-  createLlmAdapter({ baseUrl: "https://api.example.com/v1", apiKey: "…", model: "gpt-4o-mini" }),
-  "You are a planner…",
-  metaSchema,
-  extractConfig,
-);
-```
-
-Use this when you want a role backed by an HTTP LLM instead of a subprocess CLI adapter.
+Each exports a **default instance** (sensible defaults) and a **factory** for custom config.
 
 ## Usage in Workflows
 
@@ -76,14 +45,3 @@ extract:
 ```
 
 Two-level merge: global → role override. Retry once on parse failure (feeds error back to LLM), then throw `ExtractError`.
-
-## Error Handling
-
-When adapters' underlying CLI tools (e.g., `cursor-agent` or `hermes`) fail, errors are surfaced **synchronously via rejection** with no fallback/retry logic:
-
-- **Missing/unavailable tool**: `spawn_failed` error when CLI binary not found in `$PATH`
-- **Non-zero exit code**: `non_zero_exit` error with captured stdout/stderr
-- **Timeout**: `timeout` error when execution exceeds configured `timeoutMs`
-- **Abort signal**: `aborted` error when `AbortSignal` triggers cancellation
-
-All errors are immediately thrown as `Error` instances with descriptive messages (e.g., `"cursor-agent: exitCode=7 stdout=... stderr=..."`). No automatic retries or fallback adapters.

.knowledge/architecture.md

@@ -5,22 +5,20 @@ Observation engine for autonomous agents — sense the world, react to changes,
 ## Core Pipeline
 
 ```
-External World → Sense → Signal → Workflow → Log
-                           ↑
-                     compute() returns
-                     { signal, workflow }
+External World → Sense → Signal → Reflex → Workflow → Log
 ```
 
-Causality is **one-directional**. Logs are the end of the chain — they cannot trigger further Senses (prevents feedback loops).
+Causality is **one-directional**. Logs are the end of the chain — they cannot trigger Reflexes (prevents feedback loops).
 
-## Two Extension Points
+## Three Orthogonal Extension Points
 
 | Extension | Question | Nature |
 |-----------|----------|--------|
-| **Sense** | What to observe & when to react | `compute()` pure function + YAML config (interval / on) |
+| **Sense** | What to compute | `compute()` function |
+| **Reflex** | When to compute | Declarative YAML (interval / on) |
 | **Workflow** | What to do | Roles + Moderator |
 
-Senses own both the "what" (compute logic) and the "when" (config-driven scheduling). A Sense can trigger a Workflow directly by returning `{ signal, workflow: { name, prompt } }`.
+Each is independent. Reflex doesn't know compute internals, Sense doesn't know when it's triggered, Workflow doesn't know why it was started.
 
 ## Two Event Types
 
@@ -33,15 +31,3 @@ Senses own both the "what" (compute logic) and the "when" (config-driven schedul
 - One worker per Workflow type (on-demand)
 - Workers never talk to each other
 - All user code runs in isolated Workers; kernel never loads user code directly
-- **`WorkerRuntime`** (`packages/daemon/src/worker-runtime.ts`) centralizes fork lifecycle for both sense groups (`worker-pool.ts`) and workflow types (`workflow-manager.ts`); see `.knowledge/worker-isolation.md`
-
-## Storage Systems
-
-- **Log Store** — SQLite with WAL mode for audit trails and workflow state
-- **Sense Databases** — Isolated SQLite per sense group for private data
-- **Knowledge Store** — Vector search index for project context
-- **Blob Store** — Content-addressable storage for large artifacts
-
-## Signal Flow
-
-Sense compute outputs are routed through signal routing logic that determines whether to emit a signal or trigger a workflow—never both simultaneously.

.knowledge/cli.md

@@ -5,43 +5,54 @@
 ## Workspace Lifecycle
 
 ```bash
-nerve init                    # scaffold a new workspace (nerve.yaml, senses/, workflows/)
-nerve init --force            # reinitialize workspace even if ~/.uncaged-nerve/ exists (preserves data/)
-nerve init --from <git-url>   # clone existing workspace from git repository
+nerve init                    # scaffold workspace (nerve.yaml, senses/, workflows/)
+nerve init --from <git-url>   # clone existing workspace from git
+nerve init --force            # reinitialize (preserves data/)
 nerve validate                # validate nerve.yaml config
 nerve dev                     # run kernel foreground (development, Ctrl+C to stop)
+nerve dev --port 3000         # with HTTP API on specific port
 nerve start                   # start daemon (background)
+nerve start --port 3000       # with HTTP API port
 nerve stop                    # stop daemon
 nerve status                  # check daemon health (uptime, senses, workflows)
-nerve daemon                  # restart daemon (stop + start)
+nerve daemon restart           # stop + start
+nerve daemon logs             # alias for nerve logs
 ```
 
-### Init Behavior
-
-**Default `nerve init`**: Creates workspace at `~/.uncaged-nerve/`. If this directory already exists and is non-empty, **exits with error** requiring `--force` flag. No merge/overwrite logic — prevents accidental workspace destruction.
-
-**Force mode `nerve init --force`**: Reinitializes workspace even if `~/.uncaged-nerve/` exists. **Preserves `data/` directory** (containing sense SQLite databases and logs) but overwrites all config files (`nerve.yaml`, `package.json`, etc.) and example senses.
-
-**Git clone `nerve init --from <url>`**: Clones existing repository to `~/.uncaged-nerve/`. Requires empty target directory — fails if workspace already exists and is non-empty.
-
 ## Sense Management
 
 ```bash
 nerve create sense <name>     # scaffold a new sense (compute.ts + schema.ts)
-nerve sense list              # list configured senses
+nerve create sense <name> --force  # overwrite existing
+nerve sense list              # list configured senses and status
 nerve sense trigger <name>    # manually trigger a sense compute
-nerve sense schema <name>     # show sense Drizzle schema
-nerve sense query <name>      # inspect sense SQLite database
-nerve sense query <name> --sql "SELECT * FROM samples LIMIT 5"
+nerve sense schema <name>     # print CREATE TABLE statements from sense SQLite
+nerve sense schema <name> --json   # as JSON array
+nerve sense query <name>      # inspect sense SQLite database (preview rows)
+nerve sense query <name> --json    # rows as JSON
 ```
 
 ## Workflow Management
 
 ```bash
 nerve create workflow <name>  # scaffold a new workflow
+nerve create workflow <name> --force  # overwrite existing
+nerve workflow list           # list workflow definitions from nerve.yaml
+nerve workflow status         # show live status (concurrency, active, queued)
 nerve workflow trigger <name> --prompt "..." [--max-rounds N] [--dry-run]
-nerve workflow list           # list configured workflows
-nerve thread                  # list active (queued/started) workflow threads
+```
+
+## Thread Management
+
+```bash
+nerve thread list             # list active (queued/started) workflow runs
+nerve thread list --all       # include completed/failed/crashed
+nerve thread list --workflow <name>  # filter by workflow name
+nerve thread show <runId>     # print role rounds for a run (agent-oriented)
+nerve thread show <runId> --before N  # limit rounds (pagination)
+nerve thread inspect <runId>  # show details and thread events
+nerve thread inspect <runId> --offset N --limit N  # paginate events
+nerve thread kill <runId>     # kill a running or queued thread
 ```
 
 ## Knowledge
@@ -51,21 +62,30 @@ nerve knowledge sync          # chunk files per knowledge.yaml, compute embeddin
 nerve knowledge query "text"  # search indexed knowledge (cosine similarity)
 nerve knowledge query -g "text"           # global search across all indexed repos
 nerve knowledge query --repo /path "text" # search specific repo
+nerve knowledge query "text" --limit 20   # max hits (default 10)
 ```
 
 ## Logs & Store
 
 ```bash
-nerve logs                    # view daemon logs (last 50 lines)
-nerve logs -f                 # follow logs (tail -f style)
+nerve logs                    # show daemon log output (last 50 lines)
 nerve logs -n 200             # last N lines
-nerve store archive           # archive old log entries to JSONL
+nerve logs --offset 100       # start from line N (pagination)
+nerve logs -f                 # follow logs (tail -f style)
+nerve store archive           # archive logs older than 30 days to JSONL
+nerve store archive --vacuum  # also run SQLite VACUUM after archiving
 ```
 
-## Remote
+## Remote Management
 
 ```bash
-nerve remote add <name> <url> # add a remote daemon endpoint
+nerve remote add <name> <host:port> [--token <token>]  # add remote daemon
+nerve remote list             # list all remotes
+nerve remote show <name>      # show remote details
+nerve remote set-url <name> <host:port>   # update remote host
+nerve remote set-token <name> <token>     # update remote token
+nerve remote remove <name>    # remove a remote
+nerve remote default [<name>] # set or show default remote
 nerve status --remote <name>  # check remote daemon health
 ```
 
@@ -77,12 +97,22 @@ my-agent/
   knowledge.yaml              # knowledge index config (optional)
   senses/
     cpu-usage/
-      compute.ts              # sense implementation
-      schema.ts               # Drizzle schema
-      migrations/             # auto-generated
+      src/
+        index.ts              # sense compute implementation
+        schema.ts             # Drizzle schema (single source of truth)
+      migrations/             # auto-generated by drizzle-kit
+      package.json            # with esbuild build script
+      index.js                # bundled output (generated by pnpm build)
   workflows/
     cleanup/
       src/index.ts            # workflow definition
+      build.ts                # factory function
+      moderator.ts            # moderator + meta types
+      roles/                  # one file per role
+      package.json
+  data/
+    senses/                   # per-sense SQLite databases
+    archive/                  # archived logs (JSONL)
   knowledge.db                # generated by nerve knowledge sync
   .knowledge/                 # curated knowledge cards
 ```

.knowledge/coding-conventions.md

@@ -24,21 +24,6 @@ type Config = { throttle?: string }
 - `throw` only for programmer errors (bugs)
 - No try-catch for flow control
 
-### Result<T, E> Type
-
-Defined in `@uncaged/nerve-core` (`packages/core/src/result.ts`):
-
-```ts
-export type Result<T, E = Error> = { ok: true; value: T } | { ok: false; error: E };
-```
-
-**Discriminated union** with tagged `ok` field. Helper functions:
-- `ok(value)` → `{ ok: true, value }`
-- `err(error)` → `{ ok: false, error }`
-
-**Exhaustive handling**: Pattern is `if (!result.ok) { handle error }` then access `result.value`. 
-No compiler enforcement - relies on manual discipline and TypeScript's flow control analysis.
-
 ## Naming
 
 | Type | Style |
@@ -53,25 +38,9 @@ No compiler enforcement - relies on manual discipline and TypeScript's flow cont
 - Always named exports, never default
 - One module = one responsibility
 
-### Module Naming Conventions
-
-**Primary exports** use descriptive, unambiguous names:
-- Functions: `createXxx()`, `parseXxx()`, `xxxAgent()` (e.g., `createCursorAdapter`, `cursorAgent`)
-- Types: Domain-specific prefixes (e.g., `CursorAgentOptions`, `SenseComputeFn`, `ThreadContext`)
-- Constants: `UPPER_SNAKE_CASE` with context (e.g., `DEFAULT_SENSE_SIGNAL_RETENTION`, `CURSOR_ADAPTER_DEFAULT_MS`)
-
-**Avoiding ambiguity**:
-- Package-scoped naming: `@uncaged/nerve-adapter-cursor` exports `cursorAgent`, `createCursorAdapter`
-- Factory pattern: `createXxxAdapter()` for configurable instances, `xxxAdapter` for defaults
-- Descriptive type prefixes prevent collision (e.g., `CursorAgentOptions` vs `HermesAgentOptions`)
-
 ## Async
 
 - Always `async/await`, never `.then()` chains
-- Use `AbortSignal` for cancellation: `AbortController` to create signals, pass to long-running operations
-- `spawn-safe.ts` and adapter functions accept `abortSignal: AbortSignal | null` parameter
-- On abort: child processes receive `SIGTERM`, async operations should check `signal.aborted`
-- No enforced Biome/Vitest rules for AbortSignal usage (manual discipline required)
 
 ## No Dynamic Import
 

.knowledge/knowledge-layer.md

@@ -19,20 +19,10 @@ nerve knowledge query --repo /path "query"  # search specific repo
 
 ## Embedding
 
-- **Default model**: Dashscope text-embedding-v3 (1024 dimensions)
-- **Remote service**: configured via `EMBED_SERVICE_URL` env var (self-hosted Cloudflare Worker + KV cache)
-- **Model configuration**: No mechanism to specify alternate models — hardcoded to text-embedding-v3 in remote service
-- **Vector dimensions**: Fixed at 1024 (Float32Array, stored as 4096-byte Buffer blobs in SQLite)
-- **Cache**: content-addressable (sha256 of model+text), never expires
-- **Fallback**: word-overlap scoring when embed service not configured
-
-### Configuration
-
-The embedding model is **not configurable** through `knowledge.yaml` or other config files. The remote service at `embed.shazhou.workers.dev` uses Dashscope text-embedding-v3 exclusively. To use different models, you would need to:
-
-1. Deploy your own embedding service compatible with the same API
-2. Point `EMBED_SERVICE_URL` to your service
-3. Ensure vector dimensions match (1024) or modify knowledge database schema
+- Remote service: configured via `EMBED_SERVICE_URL` env var (self-hosted Cloudflare Worker + KV cache)
+- Model: Dashscope text-embedding-v3 (1024 dims)
+- Cache: content-addressable (sha256 of model+text), never expires
+- Fallback: word-overlap scoring when embed service not configured
 
 ## Chunking
 

.knowledge/monorepo.md

@@ -5,7 +5,7 @@ nerve/
   packages/
     core/              # @uncaged/nerve-core — shared types, config parser, Result, spawn-safe
     cli/               # @uncaged/nerve-cli — CLI (init, validate, dev, daemon, knowledge)
-    daemon/            # @uncaged/nerve-daemon — kernel, workers, sense scheduler, workflow manager
+    daemon/            # @uncaged/nerve-daemon — kernel, workers, signal bus, scheduler
     store/             # @uncaged/nerve-store — append-only log, SQLite, CAS blob store
     workflow-utils/    # @uncaged/nerve-workflow-utils — role factories, extract, LLM helpers
     adapter-cursor/    # @uncaged/nerve-adapter-cursor — cursor-agent CLI adapter

.knowledge/sense.md

@@ -2,38 +2,18 @@
 
 A `compute()` function that samples or derives external data. The only first-class citizen in nerve.
 
-## Contract
+## Behavior
 
-Each sense module (`src/index.ts`) must export:
+- Returns `T | null` — non-null emits a Signal, null is silent (no storage write, no signal, no downstream trigger)
+- Each Sense has its own **independent SQLite database**
+- Cross-sense reads are read-only via `peers` parameter
+- Schema defined with Drizzle ORM (`schema.ts` is single source of truth)
 
-```ts
-export { snapshots as table } from "./schema.ts";  // drizzle table for runtime to insert into
+## Sense → Workflow
 
-export async function compute(): Promise<ComputeResult<T>> { ... }  // pure, no args
-```
+If `compute()` returns an object with `workflow: "name|maxRounds|prompt"`, the engine starts that workflow and does **not** emit a Signal. `workflow: null` or `""` means emit signal normally.
 
-**Function Signature & Input Schema:**
-- `compute()` is **parameterless** — no direct inputs, environment variables available
-- No database access within compute — runtime provides isolated execution context 
-- Must be pure function (no side effects, no external API calls)
-
-**Return Value Contract (current engine):**
-- `compute(state)` returns `Promise<{ state: S; trigger: SenseTrigger | null }>` where `SenseTrigger = { command: string }`.
-  - `trigger: null` → persist state only; no shell command
-  - `trigger: { command }` → persist state; worker runs the command with `shell: true` after a successful compute
-- Workflows are **not** started from `trigger`; use CLI / daemon IPC (`nerve workflow trigger`, etc.).
-
-**Error Handling & Serialization:**
-- Exceptions caught by worker, logged as errors (state unchanged)
-- State must be JSON-serializable (persisted to `data/senses/<name>.json`)
-- Invalid `trigger` shapes fail IPC validation when the worker sends `compute-result`
-
-**Timeout & Scheduling Semantics:**
-- Timeout priority: explicit config → AbortSignal → DEFAULT_TIMEOUT_MS (30s)
-- Enforced via `Promise.race()` with timeout promise
-- Grace period can trigger `process.exit(1)` after timeout (kills worker group)
-- Interval translation: YAML config values used directly as milliseconds in `setInterval()`
-- Jitter control: throttle mechanism prevents rapid-fire, single deferred trigger per throttle window
+See `routeSenseComputeOutput` / `parseSenseWorkflowDirective` in `@uncaged/nerve-core`.
 
 ## Config (nerve.yaml)
 
@@ -47,14 +27,3 @@ senses:
     interval: 30s        # periodic trigger (optional)
     on: [disk-pressure]  # trigger on signals from other senses (optional)
 ```
-
-## Manual Trigger Context
-
-**`nerve sense trigger <name>`** sends IPC message to running daemon. The compute context is initialized as follows:
-
-- **SQLite Database**: Opened in **read-write mode** at `data/senses/<name>.db`
-- **Migrations**: All `*.sql` files in `senses/<name>/migrations/` applied in lexicographic order
-- **Environment**: Inherits daemon process environment (no special secrets injection)
-- **Arguments**: No runtime arguments or mock inputs supported — `compute()` is always pure function with no parameters
-- **Isolation**: Runs in forked child process (worker) with full filesystem access within user permissions
-- **Persistence**: Runtime automatically calls `db.insert(table).values(result.signal)` if compute returns non-null signal

.knowledge/signal-routing.md

@@ -1,32 +0,0 @@
-# Sense compute → shell + scheduler (issue #318)
-
-Stateful senses run `compute(state)` and return `{ state, trigger }`. The worker persists state JSON and sends `compute-result` to the kernel. Optional side effects are **shell commands only**, executed in the sense worker. Workflows are not started from sense return values.
-
-## Flow
-
-```
-Sense worker: compute(state) → { state, trigger }
-                    ↓
-          persist state JSON (data/senses/<name>.json)
-                    ↓
-     trigger !== null → spawn shell command (cwd = nerve root)
-                    ↓
-          IPC compute-result → kernel (audit: shell-launch log)
-                    ↓
-          scheduler.onSenseCompleted(senseName) → dependents with `on: [senseName]`
-```
-
-Workflow runs: **`workflowManager.startWorkflow`** from CLI / daemon IPC only (`nerve workflow trigger`, HTTP when enabled).
-
-## Sense trigger shape
-
-When `trigger` is non-null it must be a plain object validated by `parseSenseTrigger()` in `packages/core/src/sense.ts`:
-
-- Exactly one property: `command` (non-empty string after trim)
-- No `kind` field; no workflow fields
-
-Invalid triggers are rejected when parsing the worker message.
-
-## Scheduling
-
-Other senses list this sense under `on` in `nerve.yaml` to be scheduled when this sense completes a successful compute (see sense scheduler reverse-index in the daemon).

.knowledge/storage-layer.md

@@ -1,132 +0,0 @@
-# Storage Layer
-
-Nerve uses multiple storage systems designed for different data types and access patterns.
-
-## Core Storage Components
-
-### 1. Log Store (`logs.db`)
-Append-only audit trail implemented in SQLite with WAL mode.
-
-**Schema:**
-- `logs` — all system events (signals, workflow transitions, sense outputs)
-- `meta` — key-value store for system metadata
-- `workflow_runs` — materialized view of workflow execution state
-
-**Key Features:**
-- Atomic workflow state updates via transactions
-- Thread message persistence for crash recovery
-- Configurable log archival to JSONL files
-- Full-text search across log entries
-
-### 2. Sense Databases
-Each sense group gets its own SQLite database for private state.
-
-**Characteristics:**
-- Isolated per sense group (e.g., `system-senses.db`)
-- Managed by individual sense compute functions
-- Drizzle ORM integration for schema management
-- No cross-sense data sharing
-
-### 3. Knowledge Store (`knowledge.db`)
-Vector-enabled search index for project context.
-
-**Contents:**
-- Chunked source files with embeddings
-- Curated knowledge cards from `.knowledge/`
-- Semantic search capabilities
-- Global vs. repo-scoped search modes
-
-### 4. Blob Store (CAS)
-Content-addressable storage for large artifacts.
-
-**Design:**
-- SHA-256 based file naming
-- Automatic deduplication
-- Used for workflow artifacts and large payloads
-
-## Consistency & Isolation Mechanisms
-
-### SQLite WAL Mode
-All SQLite databases use `PRAGMA journal_mode=WAL` for:
-- **Writer-reader concurrency** — readers don't block writers
-- **Atomic writes** — each transaction is fully applied or rolled back
-- **Crash recovery** — WAL provides consistent state after crashes
-
-### Transaction Management
-
-#### Log Store Transactions
-Uses `BEGIN IMMEDIATE` transactions (`packages/store/src/log-store.ts`):
-```typescript
-function runInTransaction<T>(db: DatabaseSync, fn: () => T): T {
-  db.exec("BEGIN IMMEDIATE");  // Exclusive write lock
-  try {
-    const result = fn();
-    db.exec("COMMIT");
-    return result;
-  } catch (e) {
-    db.exec("ROLLBACK");
-    throw e;
-  }
-}
-```
-
-**Key Operations:**
-- `upsertWorkflowRun()` — atomically writes log entry + workflow state
-- `archiveLogs()` — transactional export + delete + watermark update
-
-#### Sense Database Isolation
-- Each sense group has its own SQLite file (e.g., `system-senses.db`)
-- No cross-sense transactions or coordination required
-- Independent schema migrations per sense
-- Private `_signals` table for signal history retention
-
-### Process-Level Isolation
-
-#### Worker Process Architecture
-- **One worker per sense group** — prevents data races within group
-- **One worker per workflow type** — isolated execution contexts  
-- **No shared memory** — all communication via IPC messages
-
-#### Concurrency Control
-Workflow manager enforces limits per workflow:
-```yaml
-workflows:
-  my-workflow:
-    concurrency: 2        # Max parallel threads
-    overflow: "queue"     # or "drop" 
-    maxQueue: 10         # Queue depth limit
-```
-
-### Consistency Guarantees & Failure Modes
-
-**Strong Consistency (Single Database)**:
-1. **Within Log Store** — ACID transactions with immediate consistency
-2. **Within Sense DB** — WAL mode ensures atomic commits per database
-3. **Workflow State** — `upsertWorkflowRun()` atomically updates log + materialized view
-
-**No Cross-Database Consistency**:
-- No distributed transactions across multiple SQLite files
-- Log Store and Sense Databases can temporarily diverge during failures
-- Signal emission and workflow triggering are separate, non-atomic operations
-
-**Failure Recovery Mechanisms**:
-- **Sense worker crash**: State rebuilt from sense SQLite database on respawn
-- **Workflow worker crash**: Thread state recovered from log store message history
-- **Kernel crash**: All workers respawned, state recovered from persistent stores
-- **Log Store corruption**: WAL recovery on database open
-- **Sense DB corruption**: Migrations re-run, `_signals` table rebuilt if needed
-
-**Rollback Scenarios**:
-- **Log write failure**: Transaction rolled back, no state changes persisted
-- **Sense compute failure**: Error logged, no signal/workflow emitted
-- **Workflow failure**: Thread marked as failed in materialized view
-- **IPC failure**: Worker respawned, pending operations lost (not rolled back)
-
-## Archive Strategy
-
-Logs older than retention window (default 30 days) are:
-1. Exported to `data/archive/logs/YYYY-MM-DD.jsonl`
-2. Deleted from active database
-3. Watermark updated to prevent re-processing
-
-This keeps the active database size bounded while preserving audit trails.

.knowledge/worker-isolation.md

@@ -1,158 +0,0 @@
-# Worker Isolation
-
-Nerve's worker architecture ensures complete isolation between different types of user code while maintaining system stability.
-
-## Process Architecture
-
-```
-Kernel (Main Process)
-├── Sense Worker (Group A) ── sense-1, sense-2
-├── Sense Worker (Group B) ── sense-3, sense-4
-├── Workflow Worker (cleanup) ── cleanup workflow instances
-└── Workflow Worker (review) ── review workflow instances
-```
-
-### WorkerRuntime (RFC-006)
-
-Forked worker processes are managed by **`WorkerRuntime`** (`worker-runtime.ts`): one Node child per logical key, cold start, optional respawn after crash, drain/evict, and coordinated shutdown over IPC. **`worker-pool.ts`** (sense groups) and **`workflow-manager.ts`** (workflow types) both configure and delegate to `createWorkerRuntime` instead of owning ad-hoc fork logic.
-
-Worker **entrypoints** (`sense-worker.ts`, `workflow-worker.ts`) import lightweight helpers only — e.g. `worker-signals.ts` for session broadcast signal handling — so they do not pull in the parent-side runtime module.
-
-## Isolation Boundaries
-
-### 1. Sense Workers
-- **One worker per sense group** (configured in `nerve.yaml`)
-- Groups share a child process but have isolated execution contexts
-- Crash in one sense doesn't affect other groups
-- Each group has its own SQLite database
-
-### 2. Workflow Workers  
-- **One worker per workflow type** (spawned on-demand)
-- Multiple threads of the same workflow share a worker process
-- Concurrency limits enforced at the workflow level
-- Workers terminate when no active threads remain
-
-### 3. Kernel Protection
-- **User code never runs in kernel process**
-- All `compute()` and workflow role functions run in workers
-- Kernel only handles IPC, scheduling, and coordination
-- System remains stable even with infinite loops or crashes in user code
-
-## Worker Lifecycle
-
-### Sense Workers
-```
-nerve daemon start → spawn worker per group → long-lived process
-                   → hot reload on file changes
-                   → respawn on crash
-```
-
-### Workflow Workers
-```
-workflow trigger → check existing worker → reuse or spawn
-                                       → execute thread
-                                       → terminate when idle
-```
-
-## Communication Patterns
-
-### Kernel ↔ Sense Worker
-- IPC via child process stdio
-- JSON-formatted messages
-- Worker reports signals back to kernel
-- Bidirectional: kernel can request immediate computes
-
-### Kernel ↔ Workflow Worker  
-- Similar IPC protocol
-- Workflow definition loaded in worker
-- Role execution results streamed back
-- Thread state managed in kernel
-
-## Resource Limits & Control
-
-### Timeout Enforcement
-Configurable timeouts per sense (in `nerve.yaml`):
-```yaml
-senses:
-  my-sense:
-    timeout: 30000      # Execution timeout (ms)
-    gracePeriod: 5000   # Grace period before hard kill
-```
-
-**Timeout Implementation:**
-- `AbortController` for async operations 
-- `Promise.race()` between compute and timeout
-- Grace period triggers `process.exit(1)` to kill entire worker group
-
-### Memory & CPU Limits
-**No Application-Level Resource Quotas**:
-- No memory caps, CPU throttling, or disk I/O limits enforced by Nerve
-- Workers can consume arbitrary system resources until OS limits
-- No cgroup/container isolation — full filesystem access within user permissions
-- No syscall filtering (no seccomp restrictions)
-
-**OS-Level Constraints Only**:
-- Process memory limited by system `ulimit -m` 
-- CPU usage bounded by scheduler only
-- Network requests unrestricted
-- Can spawn additional processes (not tracked by Nerve)
-
-### Concurrency Control
-
-#### Sense Workers
-- One active compute per sense at a time (serialized via promise chains)
-- No memory sharing between sense groups
-- Crash isolation: one sense crash doesn't affect other groups
-
-#### Workflow Workers
-Per-workflow limits configured in `nerve.yaml`:
-```yaml
-workflows:
-  my-workflow:
-    concurrency: 2        # Max parallel threads
-    overflow: "drop"      # or "queue"
-    maxQueue: 10         # Queue size limit
-```
-
-### Process Management
-
-#### Signal Handling
-Workers ignore session broadcast signals (SIGINT/SIGTERM) via `ignoreSessionBroadcastSignals()` in `worker-signals.ts`:
-```typescript
-// Workers ignore terminal signals; kernel coordinates shutdown
-process.on("SIGINT", () => {});
-process.on("SIGTERM", () => {});
-```
-
-#### Graceful Shutdown & State Handoff
-**Sense Workers**:
-- IPC `shutdown` message → `process.exit(0)` (immediate)
-- No graceful termination period for senses
-- State rebuilt from SQLite on respawn (no handoff needed)
-
-**Workflow Workers**:
-- IPC `shutdown` → wait for in-flight threads to complete
-- Drain timeout: `WORKER_SHUTDOWN_TIMEOUT_MS` (10s)
-- If threads don't complete → `SIGKILL` force termination
-- Thread state preserved in log store for crash recovery
-
-**State Handoff Mechanism**:
-- No explicit state transfer between old/new workers
-- Sense workers: SQLite database contains full state
-- Workflow workers: Log store contains thread message history
-- Kernel coordinates recovery via `recoverThreadsForWorker()`
-
-## Failure Handling
-
-### Worker Crashes
-- **Sense workers**: Automatic respawn after 1s delay, state rebuilt from DB
-- **Workflow workers**: Crash recovery from log store thread messages  
-- **Kernel protection**: Main process continues, marks affected runs as crashed
-- **Crash limits**: Max 5 crashes per workflow in 60s window (prevents infinite respawn)
-
-### Resource Exhaustion
-- **Memory**: Worker process killed by OS, kernel respawns automatically
-- **Compute timeout**: Grace period → hard kill → respawn
-- **Infinite loops**: Timeout enforcement prevents hanging indefinitely
-
-This architecture allows Nerve to run untrusted or experimental code safely while maintaining system availability.

.knowledge/workflow.md

@@ -2,26 +2,12 @@
 
 Stateful multi-step execution driven by Roles and a Moderator.
 
-## Workspace Layout (authoring)
-
-User Nerve workspaces use a **flat** build: one root `package.json`, one root bundle script (typically `scripts/build.mjs` wired from `scripts.build`), and **no** per-workflow `package.json` or `tsconfig.json`.
-
-| Location | Purpose |
-|----------|---------|
-| `workflows/<name>/index.ts` | Default export: `WorkflowDefinition` (moderator + role map). |
-| `workflows/<name>/roles/<role>.ts` | One module per role — schemas, prompts, `createRole` factories, or hand-written async role functions. |
-| `dist/workflows/<name>/index.js` | Emit of the root build; this is what the daemon loads. |
-
-**Naming:** Workflow ids should be **verb-first** kebab-case phrases (e.g. `deploy-staging`, `scan-dependencies`), not opaque nouns alone.
-
-Senses follow the same flat pattern: `senses/<name>/src/*.ts`, `migrations/`, root build → `dist/senses/<name>/index.js`. See `.knowledge/sense.md`.
-
 ## Core Concepts
 
 - **Workflow** — definition with concurrency strategy
 - **Thread** — one execution instance, unique `runId`
-- **Role** — executes actions (has side effects). `(ctx: ThreadContext) → Promise<RoleResult<M>>`
-- **Moderator** — pure routing function. `(ctx: ThreadContext) → next role | END`
+- **Role** — executes actions (has side effects). `(start, messages) → { content, meta }`
+- **Moderator** — pure routing function. `(context) → next role | END`
 
 ## Thread Lifecycle
 
@@ -68,69 +54,6 @@ const workflow: WorkflowDefinition<MyMeta> = {
 ```
 
 - `adapter: AgentFn` — direct function reference
-- `prompt: string | ((ctx: ThreadContext) => Promise<string>)` — static or dynamic
+- `prompt: string | ((start, messages) => Promise<string>)` — static or dynamic
 - `meta: z.ZodType<M>` — Zod schema, directly (no wrapper needed)
 - `extract: LlmExtractorConfig` — provider for structured extraction
-
-## Runtime Enforcement Mechanisms
-
-### Role Authority & Validation
-
-**Role Function Lookup**:
-- Roles accessed via `def.roles[nextRole]` dictionary lookup
-- Unknown roles trigger immediate workflow error (`Unknown role: ${nextRole}`)
-- No dynamic role registration during execution
-
-**Result Validation** (`validateRoleResult()`):
-```typescript
-// Required return shape from every role function
-{ content: string, meta: Record<string, unknown> }
-```
-- `content` must be string (non-string → workflow error)
-- `meta` must be plain object (array/null/primitive → workflow error)
-- Validation failure terminates thread immediately
-
-### Moderator Authority & Routing Control
-
-**Next Role Selection**:
-- Moderator must return role name from `roles` keys OR `END` symbol
-- Called after every role completion (receives full context)
-- No validation of role name until execution attempt
-- Pure function constraint: cannot perform side effects
-
-**Causal Chain Integrity**:
-- Moderator receives immutable **ThreadContext**: `{ threadId, start, steps }`
-- Steps array contains ALL role outputs in chronological order
-- No role can modify prior steps or start metadata
-- Thread context built from log store on crash recovery
-
-### Unauthorized Command Event Prevention
-
-**Message Flow Control**:
-- Role functions have NO direct access to kernel IPC
-- All outputs flow through `sendWorkflowMessage()` wrapper
-- Worker process validates messages before kernel transmission
-- No direct log store database access from roles
-
-**Process Isolation**:
-- Roles execute in forked worker processes (not kernel)
-- File system access limited to user permissions
-- No network isolation (roles can make arbitrary HTTP calls)
-- Worker has read/write access to workflow workspace only
-
-### Concurrent Thread Management
-
-**Kill Flag Implementation**:
-```typescript
-type KillFlag = { value: boolean };
-// Checked before role execution and after completion
-if (killFlag.value) {
-  sendThreadEvent(runId, "killed", { exitCode: 137 });
-  return;
-}
-```
-
-**Concurrency Enforcement**:
-- Workflow manager enforces per-workflow limits in kernel
-- Excess threads queued/dropped per overflow policy
-- No role can spawn additional threads (no access to workflow manager)

CLAUDE.md

@@ -3,7 +3,7 @@
 ## Core Concepts
 
 ```
-External World → Sense(state) → { newState, workflow? } → Workflow → Log
+External World → Sense → Signal → Reflex → Workflow → Log
                   ↑                                     ↑
               "what to observe"                  "what to do"
 ```
@@ -14,33 +14,22 @@ External World → Sense(state) → { newState, workflow? } → Workflow → Log
 
 | Concept | What it is |
 |---------|-----------|
-| **Sense** | A stateful `compute(state)` function. Returns new state and an optional workflow trigger. State persisted as JSON. Scheduling configured in nerve.yaml. |
+| **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 Senses — prevents feedback loops. |
-| **Engine** | The kernel orchestrating everything. Holds Process Manager, Workflow Manager, Sense Scheduler. Never loads user code directly — all user code runs in isolated Workers. |
+| **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
 
-- **Two extension points**: Sense (what to observe + when), Workflow (what to do)
+- **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(state) → Workflow (when triggered) + Log. Logs are the end of the chain.
+- **Causality is one-directional**: External world → Sense → Signal → Reflex → Action + Log. Logs are the end of the chain.
 
 
 
-### Sense State Persistence
-
-Each sense's state is persisted as a JSON file at `data/senses/<name>.json` (relative to the nerve root, typically `~/.uncaged-nerve/`).
-
-| Event | Behavior |
-|-------|----------|
-| **Worker start** | Read `state.json`; if missing or corrupt, use `initialState` from the sense module |
-| **Compute success** | Write new state atomically (write-temp + rename), then update in-memory state |
-| **Compute failure** | State unchanged (both disk and memory) |
-| **Daemon restart** | State restored from last successful write |
-
-State files are written atomically (temp file + rename) to prevent corruption on crash.
-
 ## Language & Paradigm
 
 ### Functional-first
@@ -49,18 +38,18 @@ Use `function` + `type`, not `class` + `interface`.
 
 ```typescript
 // ✅ Good
-type WorkflowLaunch = {
-  senseName: string;
-  workflowName: string;
+type Signal = {
+  senseId: string;
+  value: unknown;
   ts: number;
 };
 
-function recordWorkflowLaunch(senseName: string, workflowName: string): WorkflowLaunch {
-  return { senseName, workflowName, ts: Date.now() };
+function createSignal(senseId: string, value: unknown): Signal {
+  return { senseId, value, ts: Date.now() };
 }
 
 // ❌ Bad — no class, no interface
-class WorkflowLaunch implements IWorkflowLaunch { ... }
+class Signal implements ISignal { ... }
 ```
 
 ### Rules
@@ -104,45 +93,10 @@ type SenseConfig = {
 For mutually exclusive fields, use discriminated unions:
 
 ```typescript
-import type { SenseTrigger } from "@uncaged/nerve-core";
-
-// ✅ Good — sense modules return explicit next state + optional shell trigger only
-type SenseComputeReturn<S> = {
-  state: S;
-  trigger: SenseTrigger | null;
-};
-```
-
-### Workflow Naming
-
-Workflow identifiers — `WorkflowDefinition.name`, the directory under `workflows/`, and keys under `workflows:` in `nerve.yaml` — must use **verb-first** kebab-case phrases so the name reads as an action.
-
-- ✅ `solve-issue`, `extract-knowledge`, `develop-sense`
-- ❌ `knowledge-extraction`, `issue-solver`
-
-### Workflow authoring (user modules)
-
-Roles and moderators take **ThreadContext** (`threadId`, `start`, `steps`) — not separate `StartStep` / message arrays.
-
-```typescript
-import type { RoleResult, ThreadContext, WorkflowDefinition } from "@uncaged/nerve-core";
-import { END } from "@uncaged/nerve-core";
-
-type MyMeta = { round: number };
-
-async function planner(ctx: ThreadContext): Promise<RoleResult<MyMeta>> {
-  void ctx.start;
-  void ctx.steps;
-  return { content: "plan", meta: { round: ctx.steps.length } };
-}
-
-const workflow: WorkflowDefinition<Record<"planner", MyMeta>> = {
-  name: "example",
-  roles: { planner },
-  moderator(ctx: ThreadContext<Record<"planner", MyMeta>>) {
-    return ctx.steps.length === 0 ? "planner" : END;
-  },
-};
+// ✅ Good
+type ReflexConfig =
+  | { kind: "sense"; sense: string; interval: string | null; on: string[] | null }
+  | { kind: "workflow"; workflow: string; on: string[] | null };
 ```
 
 ## Modules & Exports
@@ -154,9 +108,9 @@ const workflow: WorkflowDefinition<Record<"planner", MyMeta>> = {
 
 | Type | Style | Example |
 |------|-------|---------|
-| Files | kebab-case | `sense-scheduler.ts` |
-| Types | PascalCase | `SenseScheduler` |
-| Functions/variables | camelCase | `createSenseScheduler` |
+| 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` |
 

README.md

@@ -2,36 +2,35 @@
 
 **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** (stateful `compute(state)` + JSON persistence), schedules them via **`interval` / `on`** in `nerve.yaml`, and orchestrates multi-step **Workflows**. Built for the [Uncaged](https://github.com/uncaged) agent framework.
+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(state) → { state, trigger? } → (shell in worker) / Log
-                                      │
-                              Workflow → Log   (CLI / daemon IPC only)
-                  ↑
-          scheduling: interval / on (per sense in nerve.yaml)
+External World → Sense ─┬→ Signal → Reflex → Sense (scheduled compute)
+                        │
+                        └→ Workflow (Sense return with workflow directive) → Log
 ```
 
 | Concept | Metaphor | Role |
 |---------|----------|------|
-| **Sense** | 👁️ Perception | Stateful `compute(state)` returning `{ state, trigger }`. State lives in `data/senses/<name>.json`. |
-| **Schedule** | ⏱️ When | Each sense entry sets optional `interval` (periodic) and `on: [other senses]` (run after those senses complete a compute). |
-| **Workflow** | 🔧 Action | Stateful multi-step execution with Roles and a Moderator. Started via CLI / daemon IPC (`nerve workflow trigger`, transport). Not started from sense `compute()` results. |
-| **Log** | 📝 Record | Immutable audit trail. **Cannot** schedule senses or workflows (prevents feedback loops). |
+| **Sense** | 👁️ Perception | A `compute()` function that samples or derives data. Each sense has its own SQLite database. |
+| **Reflex** | ⚡ Reaction | Declarative rules that **only schedule Sense computes** (interval and/or `on` signal names). Reflex YAML cannot reference workflows. |
+| **Signal** | 📡 Notification | Emitted when a sense returns a non-null value that is routed as a normal signal (see Sense → Workflow below). Other reflexes can listen via `on`. |
+| **Workflow** | 🔧 Action | Stateful multi-step execution with Roles and a Moderator. Started from a Sense return value or from CLI/daemon IPC—not from reflex YAML. |
+| **Log** | 📝 Record | Immutable audit trail. Queryable by senses, but **cannot** trigger reflexes (prevents feedback loops). |
 
-**Sense → shell:** when `trigger` is non-null it must be `{ command: string }`. The sense worker runs it with `shell: true` (cwd = nerve root). Use `trigger: null` when no command should run. To start a workflow, invoke it from that shell command (for example calling the CLI) or trigger workflows separately via IPC.
+**Sense → Workflow:** if `compute()` returns a plain object with a string field `workflow` in the form `name|maxRounds|prompt` (only the first two `|` delimit name and rounds; the rest is the prompt), the engine starts that workflow and **does not** emit a Signal for that return. `workflow: null` or `""` means “emit a signal” and strip the key from the payload. Invalid `workflow` strings are treated like a normal signal (directive stripped). See `@uncaged/nerve-core` `routeSenseComputeOutput` / `parseSenseWorkflowDirective`.
 
-Two extension points for **what to observe (+ when)** vs **multi-step action** — scheduling is declarative config on each sense, not a separate YAML section.
+Three extension points for **what / when / multi-step action** — reflexes never replace Sense-driven workflow launches.
 
 ## Packages
 
 | Package | Description |
 |---------|-------------|
-| [`@uncaged/nerve-core`](./packages/core) | Shared types, config parser, sense trigger validation (`parseSenseTrigger`), daemon IPC protocol |
+| [`@uncaged/nerve-core`](./packages/core) | Shared types, config parser, Sense→workflow routing, daemon IPC protocol |
 | [`@uncaged/nerve-store`](./packages/store) | Append-only log SQLite, JSONL archive, CAS blob store, workflow run rows |
-| [`@uncaged/nerve-daemon`](./packages/daemon) | Kernel, sense workers, sense scheduler, workflow manager, file watcher, IPC |
+| [`@uncaged/nerve-daemon`](./packages/daemon) | Kernel, workers, signal bus, sense scheduler, workflow manager, file watcher, IPC |
 | [`@uncaged/nerve-cli`](./packages/cli) | CLI (`nerve`) — init, validate, daemon, dev, logs, sense, store, workflow |
 
 ## Quick Start
@@ -44,28 +43,24 @@ pnpm add -g @uncaged/nerve-cli
 mkdir my-agent && cd my-agent
 nerve init
 
-# Write a sense (see `nerve init` for the full template)
-mkdir -p senses/cpu-usage/src
-cat > senses/cpu-usage/src/index.ts << 'EOF'
-import { loadavg } from "node:os";
-
-type CpuState = { lastLoad: number };
-
-export const initialState: CpuState = { lastLoad: 0 };
-
-export async function compute(state: CpuState) {
-  const [oneMin] = loadavg();
-  const lastLoad = typeof oneMin === "number" && !Number.isNaN(oneMin) ? oneMin : 0;
-  return { state: { lastLoad }, workflow: null };
+# 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 scheduling on each sense in nerve.yaml
+# 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
 
@@ -78,7 +73,7 @@ nerve logs         # view logs
 
 ## Configuration
 
-`nerve.yaml` declares senses (each with optional `interval` / `on`), optional workflows (concurrency), and optional engine `max_rounds`. Top-level `reflexes` is **not** supported — use `interval` and `on` on each sense.
+`nerve.yaml` declares senses, reflexes (sense-only), optional workflows (concurrency), and optional engine `max_rounds`:
 
 ```yaml
 max_rounds: 100              # default moderator cap (e.g. CLI workflow trigger)
@@ -89,15 +84,12 @@ senses:
     throttle: 10s          # min interval between computes
     timeout: 30s           # max compute duration
     grace_period: 5s       # wait before first compute after startup
-    interval: 30s          # periodic trigger
 
-  derived-example:
-    group: system
-    throttle: null
-    timeout: 30s
-    grace_period: null
-    on:
-      - cpu-usage          # run after cpu-usage completes a compute
+reflexes:
+  - kind: sense
+    sense: cpu-usage
+    interval: 30s          # periodic trigger
+    on: [disk-pressure]    # also trigger on signals from other senses
 
 workflows:
   cleanup:
@@ -109,24 +101,17 @@ workflows:
     max_queue: 20
 ```
 
-Declare workflows under `workflows:` and start them from Sense `compute()` (non-null `workflow`) or `nerve workflow trigger`.
+YAML must **not** include `workflow:` under `reflexes` — the parser rejects it. Declare workflows under `workflows:` and start them from Sense `compute()` or `nerve workflow trigger`.
 
-**Example — Sense starts a workflow** (`senses/disk-pressure/src/index.ts`):
+**Example — Sense starts a workflow** (`senses/disk-pressure/compute.ts`):
 
 ```typescript
-export const initialState = { checked: false };
-
-export async function compute(state: typeof initialState) {
+export async function compute() {
   const full = await diskNearlyFull();
-  if (!full) return { state: { ...state, checked: true }, workflow: null };
+  if (!full) return null;
   return {
-    state: { ...state, checked: true },
-    workflow: {
-      name: "cleanup",
-      maxRounds: 10,
-      prompt: "Disk partition nearly full",
-      dryRun: false,
-    },
+    path: "/data",
+    workflow: "cleanup|10|Disk partition nearly full", // name|maxRounds|prompt
   };
 }
 ```
@@ -153,9 +138,12 @@ export async function compute(state: typeof initialState) {
 │         │                 └──────────────┼──────────────┘            │
 │         │                                ▼                            │
 │         │                        ┌──────────────┐                     │
-│         │                        │Sense Scheduler                     │
-│         │                        │(interval + on)                     │
+│         │                        │  Signal Bus  │                     │
 │         │                        └──────┬───────┘                     │
+│         │                               ▼                             │
+│         │                     ┌──────────────────┐                      │
+│         │                     │ Reflex Scheduler│                      │
+│         │                     └────────┬─────────┘                     │
 │         │                              ▼                              │
 │         │                    ┌───────────────────┐                    │
 │         └───────────────────►│ Workflow Manager  │──→ @uncaged/nerve-store │
@@ -164,7 +152,8 @@ export async function compute(state: typeof initialState) {
 ```
 
 - **Worker pool** — one child process per sense group; isolation between groups.
-- **Sense scheduler** — interval timers + `on` reverse-index (upstream sense → dependents), with throttle/coalesce.
+- **Signal Bus** — in-memory pub/sub for signal distribution.
+- **Reflex Scheduler** — interval timers + signal subscriptions, with throttle/coalesce.
 - **Workflow Manager** — concurrency (drop/queue), per-workflow workers, crash recovery.
 - **File watcher** — hot reload for config, sense modules, and workflow modules.
 - **Daemon IPC** — Unix domain socket; used by the CLI when the daemon is running.
@@ -172,8 +161,8 @@ export async function compute(state: typeof initialState) {
 
 ## Tech Stack
 
-- **Zero native addons** — uses Node.js built-in `node:sqlite` (DatabaseSync) for logs / workflow persistence via `@uncaged/nerve-store`
-- **Sense state as JSON** — files under `data/senses/` written by sense workers
+- **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
@@ -191,7 +180,7 @@ pnpm -r test     # run all tests
 
 ## Design Documents
 
-- [RFC-001: Observation Engine](./docs/rfc-001-observation-engine.md) — historical sense / scheduling model (superseded in places by stateful senses — see `CLAUDE.md`)
+- [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)
 

docs/coding-conventions.md

@@ -8,29 +8,25 @@
 
 ```typescript
 // ✅ Good
-type WorkflowLaunch = {
-  senseName: string
-  workflowName: string
+type Signal = {
+  senseId: string
+  value: unknown
   ts: number
 }
 
-function recordWorkflowLaunch(senseName: string, workflowName: string): WorkflowLaunch {
-  return { senseName, workflowName, ts: Date.now() }
+function createSignal(senseId: string, value: unknown): Signal {
+  return { senseId, value, ts: Date.now() }
 }
 
 // ❌ Bad
-interface IWorkflowLaunch {
-  senseName: string
-  workflowName: string
+interface ISignal {
+  senseId: string
+  value: unknown
   ts: number
 }
 
-class WorkflowLaunch implements IWorkflowLaunch {
-  constructor(
-    public senseName: string,
-    public workflowName: string,
-    public ts: number,
-  ) {}
+class Signal implements ISignal {
+  constructor(public senseId: string, public value: unknown, public ts: number) {}
 }
 ```
 
@@ -69,16 +65,17 @@ type SenseConfig = {
 当多个字段互斥时，用 discriminated union 代替一堆 optional：
 
 ```typescript
-// ✅ Good — 编译器保证两种 overflow 形态互斥且字段完整
-type WorkflowConfig =
-  | { concurrency: number; overflow: "drop" }
-  | { concurrency: number; overflow: "queue"; maxQueue: number }
+// ✅ Good — 编译器保证 sense 和 workflow 不会同时出现
+type ReflexConfig =
+  | { kind: "sense"; sense: string; interval: string | null; on: string[] | null }
+  | { kind: "workflow"; workflow: string; on: string[] | null }
 
-// ❌ Bad — 字段一堆 optional，运行时才知道到底填了哪种并发策略
-type WorkflowConfig = {
-  concurrency?: number;
-  overflow?: string;
-  maxQueue?: number;
+// ❌ Bad — sense 和 workflow 都 optional，运行时才知道到底填了哪个
+type ReflexConfig = {
+  sense?: string;
+  workflow?: string;
+  interval?: string;
+  on?: string[];
 }
 ```
 
@@ -106,9 +103,9 @@ export default function startEngine() { ... }
 
 | 类型 | 风格 | 示例 |
 |------|------|------|
-| 文件 | kebab-case | `sense-scheduler.ts` |
-| 类型 | PascalCase | `SenseScheduler` |
-| 函数/变量 | camelCase | `createSenseScheduler` |
+| 文件 | kebab-case | `signal-bus.ts` |
+| 类型 | PascalCase | `SignalBus` |
+| 函数/变量 | camelCase | `createSignalBus` |
 | 常量 | UPPER_SNAKE | `MAX_RETRY_COUNT` |
 | 泛型参数 | 单字母或描述性 | `T`, `TValue` |
 

docs/dead-code-analysis.md

@@ -1,146 +0,0 @@
-# Nerve 单仓死代码分析报告
-
-**分析日期**: 2026-04-30  
-**范围**: `packages/core`, `daemon`, `store`, `cli`, `khala`, `workflow-utils`, `workflow-meta`, `adapter-cursor`, `adapter-hermes` 的 TypeScript 源码与 `package.json` 依赖。  
-**方法**: 全仓 `ripgrep` 交叉验证 `import` / `export` 路径；未运行 Knip/TS 死代码专项工具。  
-**说明**: 未包含 `role-reviewer` / `role-committer` / `skills` 等包（你列出的范围外），但 `workflow-meta` 对其中部分有依赖，相关结论已注明。
-
----
-
-## 方法限制（读前必读）
-
-| 限制 | 影响 |
-|------|------|
-| **动态 `import(url)`** | `cli` 的 `loadDaemonModule` 在运行时加载 `@uncaged/nerve-daemon`，静态分析无法把 `createKernel` 等映射到具体导出。 |
-| **已发布包的公共 API** | 大量导出仅被仓外消费者使用；本报告中的「仓内未引用」≠「应删除」。 |
-| **构建入口** | Rslib 多入口（如 `sense-worker`、`workflow-worker`、`daemon-bootstrap`）视为存活入口，不作为孤儿文件。 |
-| **内部未导出函数** | 未做逐函数调用图；「死函数」仅列出高置信个例。 |
-
----
-
-## 1. 未使用导出（仓内无 `import`）
-
-以下符号在 **monorepo 内** 没有任何文件从 `@uncaged/nerve-core` / `@uncaged/nerve-workflow-utils` / `@uncaged/nerve-daemon` 等包根导出处引用（测试与定义自身除外）。
-
-### 1.1 `@uncaged/nerve-core`
-
-| 路径 | 未使用项 | 置信度 | 建议 |
-|------|----------|--------|------|
-| `packages/core/src/index.ts` → `agent.js` | `KNOWN_AGENT_ADAPTER_IDS` | **高** | **调查**：若 CLI/校验应约束 adapter id，可接入；否则可从公共 API 移除或保留作文档性常量并注明。 |
-| `packages/core/src/index.ts` → `sense.js` | `labelSenseTrigger`（`senseTriggerLabels` 在 `cli`/`daemon` 有使用） | **高（相对仓内）** | **保留或收敛导出**：仅 `senseTriggerLabels` 对外即可；`labelSenseTrigger` 可作为内部函数若不需要单独暴露。 |
-| `packages/core/src/index.ts` → `util.js` | `parseDurationStringToMs`（仅 `config.ts` 内部使用） | **高** | **调查**：无需在 `index` 再导出则改为非导出或移除 re-export，减少 API 面。 |
-| `packages/core/src/index.ts` → `sense.js` | 类型 `SenseModule` | **中** | **保留**：用户文档/外部 Sense 模块常用；仓内未按名引用属正常。 |
-| `packages/core/src/index.ts` → `config.js` | 单独导出的类型 `NerveApiConfig`（仅 `config.ts` 与 `index` 出现） | **低** | **保留**：通常随 `NerveConfig` 一并使用；单独 export 多为 TS 公共类型便利。 |
-
-### 1.2 `@uncaged/nerve-workflow-utils`
-
-下列项在 **`packages/*/src/**/*.ts` 中无人从包入口导入**（`workflow-meta`、`role-committer` 等主要只用 `createRole`、`decorateRole`、`onFail`、`withDryRun`、`LlmExtractorConfig`）。
-
-| 路径 | 未使用项 | 置信度 | 建议 |
-|------|----------|--------|------|
-| `packages/workflow-utils/src/index.ts` | `createLlmAdapter` | **高** | **保留（对外 API）** 或标注文档；仓内无调用。 |
-| 同上 | `llmExtract`、`llmExtractWithRetry` | **高** | **保留**：高级用法 / 文档示例；内部与测试使用。 |
-| 同上 | `mergeExtractConfig`、`ExtractConfigLayer` | **高** | **调查**：若 RFC 分层配置仍在推进则保留；否则评估移除导出。 |
-| 同上 | `assertZodMetaSchemas`、`createLlmExtractFn`、`extractMetaOrThrow`、`zodMeta`、`ZodMetaSchema` | **高** | **保留（对外 API）**；当前仅 `workflow-utils` 测试与内部 `create-role` 链路使用 `extractMetaOrThrow`。 |
-| 同上 | `readNerveYaml`、`nerveAgentContext` 及相关类型 | **高** | **调查**：若已无 YAML 上下文注入场景可删导出；否则保留给 Agent 工具链。 |
-| 同上 | `spawnSafe`、`nerveCommandEnv` 及 `Spawn*` 类型（从 core 再导出） | **高** | **删除再导出或改为文档链接**：仓内均直接从 `@uncaged/nerve-core` 引用 spawn。 |
-| 同上 | `isDryRun` | **高** | **删除或实现**：见 §3「死函数」。 |
-| 同上 | `LlmMessage`、`MetaExtractConfig`、`LlmChatError`、`LlmError`、`LlmProvider` 等类型再导出 | **中** | **保留**：供外部精细类型标注；仓内未单独 import。 |
-
-### 1.3 `@uncaged/nerve-daemon`
-
-| 路径 | 未使用项 | 置信度 | 建议 |
-|------|----------|--------|------|
-| `packages/daemon/src/index.ts` → `agent-adapters/echo.js` | `createEchoAgent` | **高** | **调查**：无任何测试或运行时引用；若设计保留 `type: "echo"` 适配器，应在 workflow/agent 装载路径接线或删除导出与文件。 |
-| `packages/daemon/src/index.ts`（及其它导出） | 多数 IPC / runtime 符号 | **低** | **保留**：动态加载与外部集成无法静态判定；仅 `createEchoAgent` 可确定为当前静态图下的死角。 |
-
-### 1.4 `@uncaged/nerve-adapter-cursor` / `@uncaged/nerve-adapter-hermes`
-
-| 路径 | 未使用项 | 置信度 | 建议 |
-|------|----------|--------|------|
-| `packages/adapter-cursor/src/index.ts` | `cursorAdapter`、`createCursorAdapter`（以及 `cursorAgent` 仅被 `workflow-utils/src/role-cursor.ts` 使用） | **中** | **保留**：默认实例与工厂供下游与工作流仓使用；仓内业务包未直接 import `cursorAdapter` 属预期。 |
-| `packages/adapter-hermes/src/index.ts` | `hermesAdapter`、`createHermesAdapter`（`hermesAgent` 经 `workflow-utils` 间接使用） | **中** | 同上。 |
-
-### 1.5 `@uncaged/nerve-cli`
-
-| 路径 | 未使用项 | 置信度 | 建议 |
-|------|----------|--------|------|
-| `packages/cli/src/index.ts` | `getNerveRoot`、`loadDaemonModule` 等程序化导出 | **高（仓内）** | **保留**：无任何 workspace 包引用 `@uncaged/nerve-cli`；面向 CLI 二次开发者。 |
-
----
-
-## 2. 孤儿文件（非入口、未被其它源码引用）
-
-在当前 Rslib / `cli` 入口定义下，**未发现**「零 import、且非 entry / 非测试」的 `.ts` 业务文件：
-
-- `workflow-utils` 下的 `role-cursor.ts`、`role-hermes.ts`、`role-llm.ts`、`role-react.ts` 虽**未出现在包 `index.ts`**，但被 `packages/workflow-utils/src/__tests__/role-factories.test.ts` 直接引用，**不是孤儿文件**。
-- `daemon` 的 `sense-worker.ts`、`workflow-worker.ts` 等为 **显式构建入口**。
-
-**置信度**: 对全表扫描为 **中**（未跑依赖图工具；动态路径可能掩盖极少数脚本引用）。
-
----
-
-## 3. 死函数（内部未导出且未被调用）
-
-| 路径 | 说明 | 置信度 | 建议 |
-|------|------|--------|------|
-| `packages/workflow-utils/src/role-types.ts` | `isDryRun(_start: StartStep)`：导出在 `index.ts`，但全仓无调用（函数体恒返回 `false` 且标注 deprecated） | **高** | **删除**或改为内部常量；若需向后兼容则保留并文档标注「保留占位」。 |
-
-其它内部函数未系统逐文件枚举。
-
----
-
-## 4. 未使用的 npm 依赖（package.json）
-
-在声明范围内通过源码 `import` 抽查：**未发现明显「完全未使用」的生产依赖**。
-
-| 包 | 依赖 | 结论 |
-|----|------|------|
-| `cli` | `citty`、`yaml`、`picomatch` | 均有对应源码引用。 |
-| `khala` | `hono`、`jsonata`、`ulidx`、`@uncaged/nerve-core` | 均有引用。 |
-| `core` / `daemon` | `yaml`、`drizzle-orm` | 均有引用。 |
-| `workflow-utils` / `workflow-meta` | `zod`、workspace 包 | 均有引用。 |
-
-**置信度**: **中**（未对 peer、可选路径、CLI `bin` 专用依赖做自动化扫描）。
-
----
-
-## 5. 陈旧测试夹具 / 未引用辅助文件
-
-未发现独立的「fixture 目录」明显失联；`cli` 下 `e2e-harness`、`__tests__` 内 helper 均有对应测试引用。
-
-**置信度**: **低**（未枚举每个 `__tests__` 资源文件）。
-
----
-
-## 6. 重构遗留 / 文档漂移
-
-| 项目 | 位置 | 说明 | 置信度 | 建议 |
-|------|------|------|--------|------|
-| ~~已更名 API 仍出现在 README~~ | `packages/core/README.md` | （已修正）文档与 stateful sense、`parseSenseTrigger`（shell-only）对齐 | — | 关闭 |
-| Hermes 选项合并注释 | `packages/workflow-utils/src/shared/hermes-agent.ts` | 注释称 absorbed from `hermes-options.ts`，该文件已不存在 | **中** | **清理注释**，避免误导。 |
-| `KNOWN_AGENT_ADAPTER_IDS` 含 `codex` | `packages/core/src/agent.ts` | 仓内无 `codex` 适配器包；与常量未被引用叠加 | **中** | **对齐产品**：实现适配器或从列表移除。 |
-
-未发现用户提到的 `worker-fork-support` 等字符串副本（全仓无匹配）。
-
----
-
-## 7. 汇总建议优先级
-
-1. **高优先级调查**: `createEchoAgent` 与 `KNOWN_AGENT_ADAPTER_IDS` — 要么接入运行时，要么删减以免维护假象。  
-2. **API 面收敛**: `parseDurationStringToMs`、`labelSenseTrigger` 若无意对外，可从 `core` 公共导出移除。  
-3. **`workflow-utils`**: 评估 `isDryRun` 删除；`spawnSafe` 等从 `workflow-utils` 再导出是否仍有必要。  
-4. ~~**文档**: 修正 `packages/core/README.md` 中 Sense→Workflow 路由 API 名称。~~（已完成）  
-
----
-
-## 8. 重新验证命令示例
-
-后续可在本地采用工具增强置信度（非本次执行）：
-
-```bash
-pnpm add -D -w knip
-pnpm exec knip
-```
-
-或在各包对 `@uncaged/nerve-*` 的导出做面向消费者的契约测试，避免误删对外 API。

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

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

docs/rfc-004-package-architecture.md

@@ -1,187 +0,0 @@
-# RFC-004: Package Architecture — Shareable Workflows, Roles & Senses
-
-**Author:** 小橘 🍊（NEKO Team）
-**Status:** Draft
-**Created:** 2026-04-29
-
-## Summary
-
-Make workflows, roles, and senses publishable as lightweight npm packages. Workspaces become pure configuration — selecting packages, wiring adapters, and providing credentials. No builtin workflows in the nerve core.
-
-## Motivation
-
-Currently, workflows like `develop-sense` and `develop-workflow` live inside the workspace (`~/.uncaged-nerve/workflows/`). This creates problems:
-
-1. **No sharing** — every workspace duplicates the same workflow code
-2. **No versioning** — upgrading a workflow means manual file edits
-3. **Builtin is a trap** — if we bake workflows into nerve core, they require adapters and LLM providers that may not be installed. A fresh `nerve` install on a bare machine would fail to load builtins.
-4. **Roles are already shared** — `_shared/workspace-committer.ts` proves the pattern works; we just need to formalize it as packages
-
-The adapter pattern (`@uncaged/nerve-adapter-hermes`, `@uncaged/nerve-adapter-cursor`) already established the precedent: infrastructure as packages, workspace as wiring.
-
-## Design
-
-### Package Taxonomy
-
-```
-@uncaged/nerve-core              # types, engine
-@uncaged/nerve-daemon            # runtime
-@uncaged/nerve-workflow-utils    # createRole, decorateRole, withDryRun, onFail, etc.
-
-# Adapters (existing)
-@uncaged/nerve-adapter-hermes
-@uncaged/nerve-adapter-cursor
-
-# Workflows (new)
-@uncaged/nerve-workflow-solve-issue
-@uncaged/nerve-workflow-develop-sense
-@uncaged/nerve-workflow-develop-workflow
-
-# Shared Roles (new)
-@uncaged/nerve-role-committer    # workspace committer (branch, commit, push)
-@uncaged/nerve-role-reviewer     # code review role
-@uncaged/nerve-role-publisher    # PR creation role
-
-# Senses (existing pattern, formalized)
-@uncaged/nerve-sense-cpu-usage
-@uncaged/nerve-sense-disk-usage
-```
-
-### Package Contract
-
-Each package type exports a factory function:
-
-#### Workflow Package
-
-```ts
-// @uncaged/nerve-workflow-develop-sense
-import type { AgentFn, WorkflowDefinition } from "@uncaged/nerve-core";
-import type { LlmExtractorConfig } from "@uncaged/nerve-workflow-utils";
-
-export type SenseMeta = { /* ... */ };
-
-export type CreateDevelopSenseDeps = {
-  defaultAdapter: AgentFn;
-  adapters?: Partial<Record<keyof SenseMeta, AgentFn>>;
-  extract: LlmExtractorConfig;
-  cwd: string;
-};
-
-export function createDevelopSenseWorkflow(deps: CreateDevelopSenseDeps): WorkflowDefinition<SenseMeta>;
-```
-
-Key design decisions:
-- `defaultAdapter` + optional `adapters` override per role — via `Partial<Record<keyof Meta, AgentFn>>`
-- Adapter keys are derived from `Meta` type — adding/removing a role automatically updates the adapter map
-- Roles that don't need an agent simply don't appear in `adapters` (the `Partial` allows this)
-
-#### Role Package
-
-```ts
-// @uncaged/nerve-role-committer
-import type { AgentFn, Role } from "@uncaged/nerve-core";
-import type { LlmExtractorConfig } from "@uncaged/nerve-workflow-utils";
-import { createRole, decorateRole, withDryRun, onFail } from "@uncaged/nerve-workflow-utils";
-
-export type CommitterMeta = { committed: boolean };
-
-export function createCommitterRole(adapter: AgentFn, extract: LlmExtractorConfig): Role<CommitterMeta> {
-  const inner = createRole(adapter, prompt, committerMetaSchema, extract);
-  return decorateRole(inner, [
-    withDryRun({ label: "committer", meta: { committed: true } }),
-    onFail({ label: "committer", meta: { committed: false } }),
-  ]);
-}
-```
-
-Roles compose with the decorator chain from `workflow-utils`:
-- `withDryRun` — skip execution in dry-run mode
-- `onFail` — catch errors into structured failure results
-- `decorateRole(role, [...])` — apply decorators left-to-right
-- Custom `RoleDecorator<M>` can be created for project-specific needs
-
-#### Sense Package
-
-```ts
-// @uncaged/nerve-sense-cpu-usage
-export const senseName = "cpu-usage";
-export const schema = { /* drizzle schema */ };
-export async function compute(ctx: SenseContext): Promise<SenseResult>;
-```
-
-### Workspace as Configuration
-
-The workspace becomes a thin wiring layer:
-
-```
-~/.uncaged-nerve/
-  nerve.yaml           # senses, extract config
-  package.json         # depends on workflow/role/adapter packages
-  workflows/
-    develop-sense/
-      index.ts         # ~10 lines: import package, wire adapters, export
-    solve-issue/
-      index.ts         # same pattern
-```
-
-A typical `index.ts`:
-
-```ts
-import { createDevelopSenseWorkflow } from "@uncaged/nerve-workflow-develop-sense";
-import { hermesAdapter } from "@uncaged/nerve-adapter-hermes";
-import { cursorAdapter } from "@uncaged/nerve-adapter-cursor";
-
-export default createDevelopSenseWorkflow({
-  defaultAdapter: hermesAdapter,
-  adapters: { planner: cursorAdapter, coder: cursorAdapter },
-  extract: { provider: { apiKey, baseUrl, model } },
-  cwd: nerveRoot,
-});
-```
-
-### What Stays in Workspace
-
-- **Custom workflows** — project-specific workflows that aren't general enough to share
-- **Custom senses** — project-specific metrics
-- **Configuration** — adapter selection, credentials, `nerve.yaml`
-- **Overrides** — a workspace can always write its own role/workflow instead of using a package
-
-### Dependency Rules
-
-```
-nerve-core           ← no deps on other nerve packages
-nerve-workflow-utils ← depends on nerve-core
-nerve-adapter-*      ← depends on nerve-core
-nerve-role-*         ← depends on nerve-core, nerve-workflow-utils
-nerve-workflow-*     ← depends on nerve-core, nerve-workflow-utils, may depend on nerve-role-*
-nerve-sense-*        ← depends on nerve-core
-nerve-daemon         ← depends on nerve-core, nerve-store
-```
-
-Workflow packages depend on role packages (not adapters). Adapters are injected at the workspace level.
-
-### Migration Path
-
-1. **Phase 1: Extract role packages** — Start with `@uncaged/nerve-role-committer` (already `_shared/workspace-committer.ts`). Publish, update workspace to import from package.
-2. **Phase 2: Extract workflow packages** — Move `develop-sense` and `develop-workflow` to packages. Workspace `index.ts` becomes pure wiring.
-3. **Phase 3: Sense packages** — Formalize sense packaging (lower priority, senses are already self-contained directories).
-4. **Phase 4: Community** — Document the package contract so others can publish workflows/roles/senses.
-
-### Not in Scope
-
-- **No builtin workflows** — nerve core ships zero workflows. All workflows are packages installed by the workspace.
-- **No workflow marketplace/registry** — just npm packages. `pnpm add @uncaged/nerve-workflow-solve-issue`.
-- **No nerve.yaml workflow declaration** — workflows are still TypeScript entry points. The daemon discovers them the same way it does today.
-
-## Open Questions
-
-1. **Monorepo vs separate repos?** — Should workflow/role packages live in the nerve monorepo or separate repos? Monorepo is easier for coordinated releases; separate repos allow independent versioning.
-2. **Sense package format** — Senses currently bundle with esbuild. Should sense packages ship pre-bundled or as TypeScript source?
-3. **Version coupling** — How tightly should workflow packages pin `nerve-core`? Peer deps with semver range?
-
-## Prior Art
-
-- Adapter packages (`@uncaged/nerve-adapter-*`) — established the factory + injection pattern
-- `_shared/workspace-committer.ts` — proved roles can be shared across workflows
-- `createRole` / `decorateRole` / `withDryRun` / `onFail` in `workflow-utils` — building blocks that role packages compose
-- `defaultAdapter` + `Partial<Record<keyof Meta, AgentFn>>` pattern — adapter injection without coupling

examples/cpu-usage/index.ts

@@ -1,17 +1,22 @@
 import { loadavg } from "node:os";
 
-type CpuState = {
-  samples: Array<{ ts: number; value: number }>;
-};
+import type { DrizzleDB, PeerMap } from "@uncaged/nerve-daemon";
 
-export const initialState: CpuState = { samples: [] };
+import { samples } from "./schema.js";
 
-export async function compute(state: CpuState): Promise<{
-  state: CpuState;
-  workflow: null;
-}> {
+/**
+ * Read the 1-minute CPU load average, persist it, and emit a Signal.
+ *
+ * Returns `null` only if `loadavg` is unavailable (non-POSIX platforms).
+ * On every successful read a row is inserted and a Signal is emitted with the load value.
+ */
+export async function compute(db: DrizzleDB, _peers: PeerMap) {
   const [oneMin] = loadavg();
-  const value = typeof oneMin === "number" && !Number.isNaN(oneMin) ? oneMin : 0;
-  const newSamples = [...state.samples.slice(-99), { ts: Date.now(), value }];
-  return { state: { samples: newSamples }, workflow: null };
+
+  if (typeof oneMin !== "number" || Number.isNaN(oneMin)) {
+    return null;
+  }
+
+  await db.insert(samples).values({ ts: Date.now(), value: oneMin });
+  return { signal: oneMin, workflow: null };
 }

examples/cpu-usage/migrations/0001_init.sql

@@ -0,0 +1,7 @@
+-- Migration: 0001_init
+-- Creates the samples table for the cpu-usage sense.
+
+CREATE TABLE IF NOT EXISTS samples (
+  ts    INTEGER PRIMARY KEY,
+  value REAL    NOT NULL
+);

examples/cpu-usage/schema.ts

@@ -0,0 +1,11 @@
+import { integer, real, sqliteTable } from "drizzle-orm/sqlite-core";
+
+/**
+ * Each row records one CPU load sample.
+ * `ts` is the Unix timestamp in milliseconds (primary key, append-only).
+ * `value` is the 1-minute load average from os.loadavg()[0].
+ */
+export const samples = sqliteTable("samples", {
+  ts: integer("ts").primaryKey(),
+  value: real("value").notNull(),
+});

examples/nerve.yaml

@@ -1,9 +1,9 @@
-# Example nerve.yaml demonstrating per-sense scheduling (interval + on)
+# Example nerve.yaml demonstrating Signal Bus & Reflex Scheduler (Phase 3)
 #
 # Layout:
 #   - cpu-usage: periodic every 10s, throttled to 5s minimum between computes
 #   - disk-usage: periodic every 30s
-#   - system-health: derived sense, scheduled when cpu-usage OR disk-usage completes a compute
+#   - system-health: derived sense, triggered whenever cpu-usage OR disk-usage emits
 
 senses:
   cpu-usage:

examples/senses/nerve-health.ts

@@ -2,7 +2,8 @@
  * nerve-health — built-in sense that reports daemon health via IPC.
  *
  * When running inside a sense worker, this compute function sends a
- * "health-request" to the parent kernel process and merges the response into state.
+ * "health-request" to the parent kernel process and returns the
+ * health-response payload as its signal.
  *
  * Usage in nerve.yaml:
  *   senses:
@@ -21,23 +22,9 @@ export type NerveHealth = {
   workerUptime: number;
 };
 
-type HealthState = {
-  lastCheck: number | null;
-  lastHealth: NerveHealth | null;
-};
-
-export const initialState: HealthState = { lastCheck: null, lastHealth: null };
-
-export async function compute(_state: HealthState): Promise<{
-  state: HealthState;
-  workflow: null;
-}> {
-  void _state;
+export async function compute() {
   const health = await requestHealthFromKernel();
-  return {
-    state: { lastCheck: Date.now(), lastHealth: health },
-    workflow: null,
-  };
+  return { signal: health, workflow: null };
 }
 
 function requestHealthFromKernel(): Promise<NerveHealth> {

package.json

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

packages/adapter-cursor/package.json

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

packages/adapter-cursor/src/index.ts

@@ -1,6 +1,5 @@
-import type { AgentConfig } from "@uncaged/nerve-core";
+import type { AgentConfig, AgentFn, WorkflowContext } from "@uncaged/nerve-core";
 import { type Result, type SpawnEnv, type SpawnError, ok, spawnSafe } from "@uncaged/nerve-core";
-import type { AgentFn, ThreadContext } from "@uncaged/workflow";
 
 export type CursorAgentMode = "plan" | "ask" | "default";
 
@@ -85,28 +84,22 @@ function throwCursorSpawnError(error: SpawnError): never {
 /** Default adapter config: model auto-selection and 300s wall-clock cap (milliseconds). */
 const CURSOR_ADAPTER_DEFAULT_MS = 300_000;
 
-export type CursorAdapterConfig = AgentConfig & {
-  /** When set, passes `--mode=ask` or `--mode=plan` to `cursor-agent` (default runs without extra mode). */
-  mode?: CursorAgentMode;
-};
-
 /**
  * Builds a Cursor CLI `AgentFn` from adapter config (model, timeout).
  */
-export function createCursorAdapter(config: CursorAdapterConfig): AgentFn {
+export function createCursorAdapter(config: AgentConfig): AgentFn {
   const timeoutMs = config.timeout;
-  const mode = config.mode ?? "default";
 
-  return async (_ctx: ThreadContext, prompt: string): Promise<string> => {
+  return async (prompt: string, context: WorkflowContext): Promise<string> => {
     const run = await cursorAgent({
       prompt,
-      mode,
+      mode: "default",
       model: config.model,
-      cwd: process.cwd(),
+      cwd: context.workdir,
       env: null,
       timeoutMs,
-      dryRun: false,
-      abortSignal: null,
+      dryRun: context.start.meta.dryRun,
+      abortSignal: context.signal,
     });
     if (!run.ok) {
       throwCursorSpawnError(run.error);

packages/adapter-hermes/package.json

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

packages/adapter-hermes/src/index.ts

@@ -1,6 +1,5 @@
-import type { AgentConfig } from "@uncaged/nerve-core";
+import type { AgentConfig, AgentFn, WorkflowContext } from "@uncaged/nerve-core";
 import { type Result, type SpawnEnv, type SpawnError, ok, spawnSafe } from "@uncaged/nerve-core";
-import type { AgentFn, ThreadContext } from "@uncaged/workflow";
 
 /**
  * Spawns a non-interactive `hermes chat` invocation with YOLO enabled, argv-only
@@ -97,7 +96,7 @@ export function createHermesAdapter(config: AgentConfig): AgentFn {
   const modelFromConfig = config.model === "auto" ? null : config.model;
   const timeoutMs = config.timeout;
 
-  return async (_ctx: ThreadContext, prompt: string): Promise<string> => {
+  return async (prompt: string, context: WorkflowContext): Promise<string> => {
     const run = await hermesAgent({
       prompt,
       model: modelFromConfig,
@@ -107,8 +106,8 @@ export function createHermesAdapter(config: AgentConfig): AgentFn {
       maxTurns: HERMES_ADAPTER_DEFAULT_MAX_TURNS,
       env: null,
       timeoutMs,
-      dryRun: false,
-      abortSignal: null,
+      dryRun: context.start.meta.dryRun,
+      abortSignal: context.signal,
     });
     if (!run.ok) {
       throwHermesSpawnError(run.error);

packages/cli/README.md

@@ -51,10 +51,10 @@ Structured rows in `data/logs.db` are surfaced via **`nerve workflow inspect`**
 ```bash
 nerve sense list            # List senses (live fields from daemon IPC when running)
 nerve sense trigger <name>  # IPC trigger-sense — queue a compute for that sense
+nerve sense query <name>    # Read-only SQL on data/senses/<name>.db (optional SQL args)
+nerve sense schema <name>   # Print CREATE TABLE statements for that sense DB
 ```
 
-Sense state is persisted as JSON under `data/senses/<name>.json` by the sense worker after each successful compute.
-
 ### Store maintenance
 
 ```bash

packages/cli/package.json

@@ -10,20 +10,18 @@
   },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": ["dist", "skills"],
+  "files": ["dist"],
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
     "prepublishOnly": "bash ../../scripts/prepublish-check.sh",
     "build": "rslib build",
-    "pretest": "pnpm --filter @uncaged/workflow run build:public-types && pnpm --filter @uncaged/nerve-core run build && pnpm --filter @uncaged/nerve-store run build && pnpm --filter @uncaged/workflow run build && pnpm --filter @uncaged/nerve-daemon run build",
     "test": "vitest run"
   },
   "dependencies": {
     "@uncaged/nerve-core": "workspace:*",
     "@uncaged/nerve-store": "workspace:*",
-    "@uncaged/workflow": "workspace:*",
     "citty": "^0.1.6",
     "picomatch": "^4.0.2",
     "yaml": "^2.8.3"

packages/cli/skills/claude/CLAUDE.md

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

packages/cli/skills/cursor/.cursorrules

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

packages/cli/skills/hermes/SKILL.md

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

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

@@ -4,7 +4,13 @@
 
 import { describe, expect, it } from "vitest";
 
-import { buildSenseIndexTs, validateResourceName } from "../commands/create.js";
+import {
+  buildSenseIndexTs,
+  buildSenseMigrationSql,
+  buildSensePackageJson,
+  buildSenseSchemaTs,
+  validateResourceName,
+} from "../commands/create.js";
 
 describe("validateSenseName", () => {
   it("accepts valid ids", () => {
@@ -20,13 +26,48 @@ describe("validateSenseName", () => {
   });
 });
 
-describe("buildSenseIndexTs", () => {
-  it("generates a stateful sense stub with TypeScript types", () => {
-    const ts = buildSenseIndexTs("my-sense");
-    expect(ts).toContain("type SenseState");
-    expect(ts).toContain("export const initialState");
-    expect(ts).toContain("export async function compute");
-    expect(ts).toContain("trigger: null");
-    expect(ts).toContain("lastRun");
+describe("buildSenseSchemaTs", () => {
+  it("maps kebab-case id to snake table and camel export", () => {
+    const src = buildSenseSchemaTs("my-sense");
+    expect(src).toContain('sqliteTable("my_sense"');
+    expect(src).toContain("export const mySense = ");
+  });
+
+  it("handles single-segment id", () => {
+    const src = buildSenseSchemaTs("metrics");
+    expect(src).toContain('sqliteTable("metrics"');
+    expect(src).toContain("export const metrics = ");
+  });
+});
+
+describe("buildSenseMigrationSql", () => {
+  it("uses snake_case table name", () => {
+    expect(buildSenseMigrationSql("disk-io")).toContain("CREATE TABLE IF NOT EXISTS disk_io");
+  });
+});
+
+describe("buildSensePackageJson", () => {
+  it("includes esbuild script and sense name", () => {
+    const pkg = JSON.parse(buildSensePackageJson("my-sense"));
+    expect(pkg.name).toBe("nerve-sense-my-sense");
+    expect(pkg.scripts.build).toContain("esbuild");
+    expect(pkg.scripts.build).toContain("src/index.ts");
+    expect(pkg.devDependencies.esbuild).toBeTruthy();
+  });
+});
+
+describe("buildSenseIndexTs", () => {
+  it("embeds sense id in stub with TypeScript types", () => {
+    const ts = buildSenseIndexTs("my-sense");
+    expect(ts).toContain("my-sense");
+    expect(ts).toContain("export async function compute");
+    expect(ts).toContain("LibSQLDatabase");
+    expect(ts).toContain("Promise<SenseResult>");
+    expect(ts).toContain('from "./schema.js"');
+  });
+
+  it("imports the correct schema export", () => {
+    const ts = buildSenseIndexTs("cpu-usage");
+    expect(ts).toContain("cpuUsage");
   });
 });

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

@@ -9,7 +9,7 @@ import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "nod
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { buildWorkflowScaffold } from "../commands/create.js";
+import { buildWorkflowPackageJson, buildWorkflowScaffold } from "../commands/create.js";
 
 let tmpDir: string;
 
@@ -27,17 +27,15 @@ describe("buildWorkflowScaffold", () => {
     expect(roleMainIndexTs).toContain("my-workflow started");
   });
 
-  it("root index contains WorkflowDefinition import from @uncaged/workflow", () => {
+  it("root index contains WorkflowDefinition import from nerve-core", () => {
     const { indexTs } = buildWorkflowScaffold("test");
     expect(indexTs).toContain("WorkflowDefinition");
-    expect(indexTs).toContain("@uncaged/workflow");
+    expect(indexTs).toContain("@uncaged/nerve-core");
   });
 
-  it("root index wires moderator with ThreadContext and END", () => {
+  it("root index wires moderator and END", () => {
     const { indexTs } = buildWorkflowScaffold("test");
     expect(indexTs).toContain("moderator");
-    expect(indexTs).toContain("ThreadContext");
-    expect(indexTs).toContain("ctx.steps.length");
     expect(indexTs).toContain("END");
   });
 
@@ -48,13 +46,9 @@ describe("buildWorkflowScaffold", () => {
     expect(indexTs).toContain("./roles/main/index.js");
   });
 
-  it("main role module exports mainRole with ThreadContext", () => {
+  it("main role module exports mainRole function", () => {
     const { roleMainIndexTs } = buildWorkflowScaffold("test");
     expect(roleMainIndexTs).toContain("export async function mainRole");
-    expect(roleMainIndexTs).toContain("ThreadContext");
-    expect(roleMainIndexTs).toContain("RoleResult");
-    expect(roleMainIndexTs).not.toContain("StartStep");
-    expect(roleMainIndexTs).not.toContain("WorkflowMessage");
   });
 
   it("uses different names per call", () => {
@@ -81,6 +75,21 @@ describe("buildWorkflowScaffold", () => {
     const { roleMainPromptMd } = buildWorkflowScaffold("my-flow");
     expect(roleMainPromptMd).toContain("# my-flow — main role");
   });
+
+  it("package.json defines esbuild bundling to dist/", () => {
+    const pkg = JSON.parse(buildWorkflowPackageJson("my-flow")) as {
+      scripts: { build: string };
+      devDependencies: { esbuild: string };
+    };
+    expect(pkg.scripts.build).toContain("esbuild");
+    expect(pkg.scripts.build).toContain("--outdir=dist");
+    expect(pkg.devDependencies.esbuild).toBeTruthy();
+  });
+
+  it("buildWorkflowScaffold includes package.json body", () => {
+    const { packageJson } = buildWorkflowScaffold("wf");
+    expect(JSON.parse(packageJson).scripts.build).toContain("esbuild");
+  });
 });
 
 describe("workflow scaffold file writing (simulated)", () => {

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

@@ -2,12 +2,9 @@
  * E2E-style tests for `nerve create workflow` and `nerve create sense`.
  */
 
-import { execFile } from "node:child_process";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { createRequire } from "node:module";
 import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import { promisify } from "node:util";
+import { join } from "node:path";
 
 import { defineCommand, runCommand } from "citty";
 import { afterEach, describe, expect, it } from "vitest";
@@ -15,23 +12,6 @@ import { afterEach, describe, expect, it } from "vitest";
 import { createCommand } from "../commands/create.js";
 import { initCommand } from "../commands/init.js";
 
-const execFileAsync = promisify(execFile);
-const requireFromHere = createRequire(import.meta.url);
-
-/**
- * Default init pins `@uncaged/workflow` to npm `latest`, but that package is not published yet.
- * Install from the monorepo workspace so `pnpm run build` can resolve workflow types.
- */
-async function installWorkspaceWithLocalWorkflow(nerveRoot: string): Promise<void> {
-  const pkgPath = join(nerveRoot, "package.json");
-  const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as { dependencies: Record<string, string> };
-  const wfRoot = dirname(requireFromHere.resolve("@uncaged/workflow/package.json"));
-  pkg.dependencies["@uncaged/workflow"] = `file:${wfRoot}`;
-  writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`, "utf8");
-  await execFileAsync("pnpm", ["install", "--no-frozen-lockfile"], { cwd: nerveRoot });
-  await execFileAsync("pnpm", ["run", "build"], { cwd: nerveRoot });
-}
-
 const testRootCommand = defineCommand({
   meta: { name: "nerve", description: "e2e-create" },
   subCommands: {
@@ -142,49 +122,54 @@ describe("e2e create", () => {
   });
 
   it(
-    "create workflow scaffolds sources and root build emits dist/workflows/<name>/index.js",
-    { timeout: 120_000 },
+    "create workflow scaffolds sources and package.json with esbuild build",
+    { timeout: 10_000 },
     async () => {
       fakeHome = mkdtempSync(join(tmpdir(), "nerve-create-e2e-"));
       const nerveRoot = join(fakeHome, ".uncaged-nerve");
 
       await runTestCli(fakeHome, ["init", "--force", "--skip-install"]);
-      await installWorkspaceWithLocalWorkflow(nerveRoot);
 
       const wf = await runTestCli(fakeHome, ["create", "workflow", "e2e-flow"]);
       expect(wf.exitCode).toBe(0);
       expect(wf.stdout).toContain("✅");
 
-      const wfDir = join(nerveRoot, "workflows", "e2e-flow");
-      const indexPath = join(wfDir, "index.ts");
-      const mainRolePath = join(wfDir, "roles", "main", "index.ts");
-      expect(existsSync(join(wfDir, "package.json"))).toBe(false);
+      const pkgPath = join(nerveRoot, "workflows", "e2e-flow", "package.json");
+      const indexPath = join(nerveRoot, "workflows", "e2e-flow", "index.ts");
+      const mainRolePath = join(nerveRoot, "workflows", "e2e-flow", "roles", "main", "index.ts");
+      expect(existsSync(pkgPath)).toBe(true);
+      expect(JSON.parse(readFileSync(pkgPath, "utf8")).scripts.build).toContain("esbuild");
       expect(existsSync(indexPath)).toBe(true);
       expect(existsSync(mainRolePath)).toBe(true);
       expect(readFileSync(indexPath, "utf8")).toContain('name: "e2e-flow"');
       expect(readFileSync(mainRolePath, "utf8")).toContain("e2e-flow started");
-      expect(existsSync(join(nerveRoot, "dist", "workflows", "e2e-flow", "index.js"))).toBe(true);
     },
   );
 
   it(
-    "create sense scaffolds src/ and root build emits dist/senses/<name>/index.js",
-    { timeout: 120_000 },
+    "create sense scaffolds src/index.ts, src/schema.ts, package.json and migration",
+    { timeout: 60_000 },
     async () => {
       fakeHome = mkdtempSync(join(tmpdir(), "nerve-create-e2e-"));
       const nerveRoot = join(fakeHome, ".uncaged-nerve");
 
       await runTestCli(fakeHome, ["init", "--force", "--skip-install"]);
-      await installWorkspaceWithLocalWorkflow(nerveRoot);
 
       const sense = await runTestCli(fakeHome, ["create", "sense", "e2e-sense"]);
       expect(sense.exitCode).toBe(0);
       expect(sense.stdout).toContain("✅");
 
       const base = join(nerveRoot, "senses", "e2e-sense");
-      expect(existsSync(join(base, "package.json"))).toBe(false);
+      expect(existsSync(join(base, "package.json"))).toBe(true);
       expect(existsSync(join(base, "src", "index.ts"))).toBe(true);
-      expect(existsSync(join(nerveRoot, "dist", "senses", "e2e-sense", "index.js"))).toBe(true);
+      expect(existsSync(join(base, "src", "schema.ts"))).toBe(true);
+      expect(existsSync(join(base, "migrations", "0001_init.sql"))).toBe(true);
+
+      const pkg = JSON.parse(readFileSync(join(base, "package.json"), "utf8"));
+      expect(pkg.scripts.build).toContain("esbuild");
+
+      // pnpm install + build should produce index.js
+      expect(existsSync(join(base, "index.js"))).toBe(true);
     },
   );
 

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

@@ -2,7 +2,14 @@
  * Shared E2E harness: temp HOME layout (`.uncaged-nerve`), real kernel + sense worker,
  * IPC socket for CLI, and `runCommand` helpers with captured stdio.
  *
- * Stateful senses persist JSON under `data/senses/<name>.json` (see sense-worker).
+ * ## Signal persistence (CLI `nerve sense list`)
+ *
+ * The kernel appends a `source: "sense", type: "signal"` row to `data/logs.db` when a
+ * worker emits a signal (see `packages/daemon/src/kernel.ts`). The daemon also
+ * auto-persists each signal into a `_signals` table in the per-sense SQLite DB
+ * (see `runtime.persistSignal` in `packages/daemon/src/sense-runtime.ts`).
+ * `listSenses()` reads `lastSignalTimestamp` from the kernel's in-memory state,
+ * while `sense query` reads from the `_signals` table (or a user-defined preview table).
  *
  * ## Timeout guard (vitest)
  *
@@ -51,9 +58,8 @@ import { workflowCommand } from "../commands/workflow.js";
 
 const require = createRequire(import.meta.url);
 const nerveDaemonRoot = dirname(require.resolve("@uncaged/nerve-daemon/package.json"));
-const nerveWorkflowRoot = dirname(require.resolve("@uncaged/workflow/package.json"));
 const senseWorkerScript = join(nerveDaemonRoot, "dist", "sense-worker.js");
-const workflowWorkerScript = join(nerveWorkflowRoot, "dist", "worker.js");
+const workflowWorkerScript = join(nerveDaemonRoot, "dist", "workflow-worker.js");
 
 const nerveYamlTemplate = `senses:
   counter:
@@ -82,9 +88,9 @@ const echoWorkflowIndexJs = `const END = "__end__";
 export default {
   name: "echo",
   roles: {
-    echo: async (ctx) => {
+    echo: async (start, _messages) => {
       await new Promise((r) => setTimeout(r, 350));
-      const p = typeof ctx.start.content === "string" ? ctx.start.content : "";
+      const p = typeof start.content === "string" ? start.content : "";
       return {
         content: p.length > 0 ? "echo:" + p : "echo:empty",
         meta: {},
@@ -115,14 +121,39 @@ api:
   host: 127.0.0.1
 `;
 
-/** Minimal counter sense — each compute increments \`count\` in persisted state. */
-const counterIndexJs = `export const initialState = { count: 0 };
+/** Empty migration — counter sense uses only `_signals` (auto-created by daemon). */
+const counterMigration = `-- no-op migration for e2e counter sense
+SELECT 1;
+`;
 
-export async function compute(state) {
-  return {
-    state: { count: state.count + 1 },
-    trigger: null,
-  };
+/**
+ * Minimal counter sense — each compute returns an incrementing count.
+ * Does NOT touch the DB directly; signal persistence is handled by the daemon
+ * (`runtime.persistSignal`) which writes to `_signals` automatically.
+ */
+const counterIndexJs = `let _count = 0;
+export async function compute(_db, _peers, _options) {
+  _count += 1;
+  return { signal: { count: _count }, workflow: null };
+}
+`;
+
+/** First trigger launches local noop workflow; later triggers emit a plain signal. */
+const counterIndexJsWithNoopWorkflow = `let _launched = false;
+export async function compute(_db, _peers, _options) {
+  if (!_launched) {
+    _launched = true;
+    return {
+      signal: { launched: true },
+      workflow: {
+        name: "noop",
+        maxRounds: 3,
+        prompt: "e2e-archive",
+        dryRun: false,
+      },
+    };
+  }
+  return { signal: { idle: true }, workflow: null };
 }
 `;
 
@@ -159,6 +190,7 @@ function defaultTestConfig(withNoopWorkflow: boolean): NerveConfig {
         throttle: null,
         timeout: null,
         gracePeriod: null,
+        retention: 10_000,
         interval: null,
         on: [],
       },
@@ -176,23 +208,33 @@ function defaultTestConfig(withNoopWorkflow: boolean): NerveConfig {
 function writeWorkspaceLayout(nerveRoot: string, withNoopWorkflow: boolean): void {
   mkdirSync(join(nerveRoot, "data", "senses"), { recursive: true });
   mkdirSync(join(nerveRoot, "data", "blobs"), { recursive: true });
-  mkdirSync(join(nerveRoot, "dist", "senses", "counter"), { recursive: true });
-  mkdirSync(join(nerveRoot, "dist", "workflows", "echo"), { recursive: true });
+  mkdirSync(join(nerveRoot, "senses", "counter", "migrations"), { recursive: true });
+  mkdirSync(join(nerveRoot, "workflows", "echo", "dist"), { recursive: true });
   writeFileSync(
     join(nerveRoot, "nerve.yaml"),
     withNoopWorkflow ? nerveYamlWithNoopWorkflow : nerveYamlTemplate,
     "utf8",
   );
-  writeFileSync(join(nerveRoot, "dist", "senses", "counter", "index.js"), counterIndexJs, "utf8");
   writeFileSync(
-    join(nerveRoot, "dist", "workflows", "echo", "index.js"),
+    join(nerveRoot, "senses", "counter", "migrations", "001.sql"),
+    counterMigration,
+    "utf8",
+  );
+  writeFileSync(
+    join(nerveRoot, "senses", "counter", "index.js"),
+    withNoopWorkflow ? counterIndexJsWithNoopWorkflow : counterIndexJs,
+    "utf8",
+  );
+  writeFileSync(
+    join(nerveRoot, "workflows", "echo", "dist", "index.js"),
     echoWorkflowIndexJs,
     "utf8",
   );
   if (withNoopWorkflow) {
-    mkdirSync(join(nerveRoot, "dist", "workflows", "noop"), { recursive: true });
+    mkdirSync(join(nerveRoot, "workflows", "noop", "dist"), { recursive: true });
+    mkdirSync(join(nerveRoot, "workflows", "noop", "migrations"), { recursive: true });
     writeFileSync(
-      join(nerveRoot, "dist", "workflows", "noop", "index.js"),
+      join(nerveRoot, "workflows", "noop", "dist", "index.js"),
       noopWorkflowIndexJs,
       "utf8",
     );
@@ -209,8 +251,8 @@ export type TestDaemonHandle = {
 
 export type StartTestDaemonOpts = {
   /**
-   * When true, bundles a local `noop` workflow under `dist/workflows/noop` for tests that
-   * start runs via `nerve workflow trigger` (real workflow-worker child).
+   * When true, counter sense's first compute launches a local `noop` workflow (real
+   * workflow-worker child). Requires built `workflow-worker.js` next to `sense-worker.js`.
    */
   withNoopWorkflow: boolean;
 } | null;
@@ -225,13 +267,11 @@ function useNoopWorkflow(opts: StartTestDaemonOpts): boolean {
  */
 export function linkWorkspaceDaemonIntoNerveRoot(nerveRoot: string): void {
   const daemonPkgRoot = dirname(require.resolve("@uncaged/nerve-daemon/package.json"));
-  const nm = join(nerveRoot, "node_modules");
-  mkdirSync(nm, { recursive: true });
-
-  const linkDir = join(nm, "@uncaged");
-  mkdirSync(linkDir, { recursive: true });
+  const linkDir = join(nerveRoot, "node_modules", "@uncaged");
   const linkPath = join(linkDir, "nerve-daemon");
-  if (!existsSync(linkPath)) symlinkSync(daemonPkgRoot, linkPath);
+  mkdirSync(linkDir, { recursive: true });
+  if (existsSync(linkPath)) return;
+  symlinkSync(daemonPkgRoot, linkPath);
 }
 
 /**
@@ -275,7 +315,7 @@ export async function startTestDaemon(
   }
   if (!existsSync(workflowWorkerScript)) {
     throw new Error(
-      `Missing "${workflowWorkerScript}". Run \`pnpm --filter @uncaged/workflow build\`.`,
+      `Missing "${workflowWorkerScript}". Run \`pnpm --filter @uncaged/nerve-daemon build\`.`,
     );
   }
 

packages/cli/src/__tests__/e2e-sense-query.test.ts

@@ -0,0 +1,121 @@
+/**
+ * E2E: `nerve sense query` against a real daemon + persisted `_signals` (issue #156).
+ */
+
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+import {
+  type TestDaemonHandle,
+  pollUntil,
+  runCli,
+  startTestDaemon,
+  stopTestDaemon,
+} from "./e2e-harness.js";
+
+describe("e2e sense query", () => {
+  let daemon: TestDaemonHandle | null = null;
+
+  afterEach(async () => {
+    const h = daemon;
+    daemon = null;
+    if (h === null) return;
+    await Promise.race([
+      stopTestDaemon(h),
+      new Promise<never>((_, reject) =>
+        setTimeout(() => reject(new Error("stopTestDaemon timed out after 10s")), 10_000),
+      ),
+    ]);
+  });
+
+  async function waitForSignalsPersisted(handle: TestDaemonHandle): Promise<void> {
+    const dbPath = join(handle.nerveRoot, "data", "senses", "counter.db");
+    await pollUntil(() => {
+      if (!existsSync(dbPath)) return false;
+      try {
+        const db = new DatabaseSync(dbPath, { readOnly: true });
+        const row = db.prepare("SELECT COUNT(*) as cnt FROM _signals").get() as
+          | { cnt: number }
+          | undefined;
+        db.close();
+        return row !== undefined && row.cnt > 0;
+      } catch {
+        return false;
+      }
+    }, 10_000);
+  }
+
+  /** Start daemon, trigger counter, wait until `_signals` has a row. */
+  async function startDaemonWithPersistedSignal(): Promise<TestDaemonHandle> {
+    const handle = await startTestDaemon();
+    const triggerResult = await runCli(handle, ["sense", "trigger", "counter"]);
+    expect(triggerResult.exitCode).toBe(0);
+    expect(triggerResult.stdout).toContain("Triggered");
+    await waitForSignalsPersisted(handle);
+    return handle;
+  }
+
+  it(
+    "after trigger, persisted _signals and sense query counter returns at least one row",
+    { timeout: 30_000 },
+    async () => {
+      daemon = await startDaemonWithPersistedSignal();
+
+      const queryResult = await runCli(daemon, ["sense", "query", "counter"]);
+      expect(queryResult.exitCode).toBe(0);
+      expect(queryResult.stdout).not.toContain("(0 rows)");
+    },
+  );
+
+  it(
+    "default sense query output lists payload column and counter count in payload",
+    { timeout: 30_000 },
+    async () => {
+      daemon = await startDaemonWithPersistedSignal();
+
+      const queryResult = await runCli(daemon, ["sense", "query", "counter"]);
+      expect(queryResult.exitCode).toBe(0);
+      expect(queryResult.stdout).toContain("payload");
+      expect(queryResult.stdout).toMatch(/count/);
+    },
+  );
+
+  it(
+    "nerve sense query counter --json prints a JSON array with payload on each row",
+    { timeout: 30_000 },
+    async () => {
+      daemon = await startDaemonWithPersistedSignal();
+
+      const jsonResult = await runCli(daemon, ["sense", "query", "counter", "--json"]);
+      expect(jsonResult.exitCode).toBe(0);
+      const rows = JSON.parse(jsonResult.stdout.trim()) as unknown;
+      expect(Array.isArray(rows)).toBe(true);
+      expect(rows.length).toBeGreaterThanOrEqual(1);
+      for (const row of rows as Record<string, unknown>[]) {
+        expect(Object.keys(row)).toContain("payload");
+      }
+    },
+  );
+
+  it(
+    "nerve sense query counter --sql runs custom read-only SQL and prints total column",
+    { timeout: 30_000 },
+    async () => {
+      daemon = await startDaemonWithPersistedSignal();
+
+      const sqlResult = await runCli(daemon, [
+        "sense",
+        "query",
+        "counter",
+        "--sql",
+        "SELECT count(*) as total FROM _signals",
+      ]);
+      expect(sqlResult.exitCode).toBe(0);
+      expect(sqlResult.stdout).toContain("total");
+      expect(sqlResult.stdout).not.toContain("(0 rows)");
+    },
+  );
+});

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

@@ -1,11 +1,8 @@
 /**
  * Smoke test: start a real daemon with a counter sense, trigger it,
- * then verify CLI lists the sense and state file is written.
+ * then verify CLI commands can list and query the persisted signal.
  */
 
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
 import { afterEach, describe, expect, it } from "vitest";
 
 import {
@@ -31,27 +28,46 @@ describe("e2e smoke", () => {
     ]);
   });
 
-  it("sense list after trigger and persisted counter state", { timeout: 30_000 }, async () => {
+  it("sense list + sense query after trigger", { timeout: 30_000 }, async () => {
     daemon = await startTestDaemon();
 
+    // Trigger counter sense via IPC
     const triggerResult = await runCli(daemon, ["sense", "trigger", "counter"]);
     expect(triggerResult.exitCode).toBe(0);
     expect(triggerResult.stdout).toContain("Triggered");
 
-    const statePath = join(daemon.nerveRoot, "data", "senses", "counter.json");
+    // Wait for signal to be persisted (_signals table in the sense DB)
+    const { existsSync } = await import("node:fs");
+    const { join } = await import("node:path");
+    const { DatabaseSync } = await import("node:sqlite");
+
+    const dbPath = join(daemon.nerveRoot, "data", "senses", "counter.db");
     await pollUntil(() => {
+      if (!existsSync(dbPath)) return false;
       try {
-        const raw = readFileSync(statePath, "utf8");
-        const parsed = JSON.parse(raw) as { count?: number };
-        return typeof parsed.count === "number" && parsed.count >= 1;
+        const db = new DatabaseSync(dbPath, { readOnly: true });
+        const row = db.prepare("SELECT COUNT(*) as cnt FROM _signals").get() as
+          | { cnt: number }
+          | undefined;
+        db.close();
+        return row !== undefined && row.cnt > 0;
       } catch {
         return false;
       }
     }, 10_000);
 
+    // nerve sense list — should show counter with a last signal timestamp
     const listResult = await runCli(daemon, ["sense", "list"]);
     expect(listResult.exitCode).toBe(0);
     expect(listResult.stdout).toContain("counter");
-    expect(listResult.stdout).not.toContain("last signal");
+    expect(listResult.stdout).toContain("last signal:");
+    // Should NOT say "(never)" since we triggered and persisted
+    expect(listResult.stdout).not.toContain("(never)");
+
+    // nerve sense query counter — should return rows from _signals
+    const queryResult = await runCli(daemon, ["sense", "query", "counter"]);
+    expect(queryResult.exitCode).toBe(0);
+    // Should have actual data rows (not "(0 rows)")
+    expect(queryResult.stdout).not.toContain("(0 rows)");
   });
 });

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

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

packages/cli/src/__tests__/e2e-validate-init.test.ts

@@ -202,25 +202,31 @@ describe("e2e init", () => {
     // Verify key files exist
     expect(existsSync(join(nerveRoot, "nerve.yaml"))).toBe(true);
     expect(existsSync(join(nerveRoot, "package.json"))).toBe(true);
-    expect(existsSync(join(nerveRoot, "scripts", "build.mjs"))).toBe(true);
+    expect(existsSync(join(nerveRoot, "pnpm-workspace.yaml"))).toBe(true);
     expect(existsSync(join(nerveRoot, "biome.json"))).toBe(true);
     expect(existsSync(join(nerveRoot, ".gitignore"))).toBe(true);
-    expect(existsSync(join(nerveRoot, "AGENT.md"))).toBe(true);
-    const agentMd = readFileSync(join(nerveRoot, "AGENT.md"), "utf8");
-    expect(agentMd).toContain("verb-first");
-    expect(agentMd).toContain("createRole");
+    expect(existsSync(join(nerveRoot, "senses", "cpu-usage", "package.json"))).toBe(true);
     expect(existsSync(join(nerveRoot, "senses", "cpu-usage", "src", "index.ts"))).toBe(true);
+    expect(existsSync(join(nerveRoot, "senses", "cpu-usage", "src", "schema.ts"))).toBe(true);
+    expect(existsSync(join(nerveRoot, "senses", "cpu-usage", "migrations", "0001_init.sql"))).toBe(
+      true,
+    );
     expect(existsSync(join(nerveRoot, ".cursor", "rules", "nerve-skills.mdc"))).toBe(true);
 
     const pkgJson = readFileSync(join(nerveRoot, "package.json"), "utf8");
-    expect(pkgJson).not.toContain("nerve-skills");
-    expect(pkgJson).toContain('"build": "node scripts/build.mjs"');
-    expect(pkgJson).toContain('"esbuild": "^0.27.0"');
+    expect(pkgJson).toContain('"@uncaged/nerve-skills": "latest"');
+    expect(pkgJson).toContain('"build": "pnpm -r build"');
 
-    const buildScript = readFileSync(join(nerveRoot, "scripts", "build.mjs"), "utf8");
-    expect(buildScript).toContain('path.join(root, "senses")');
-    expect(buildScript).toContain('path.join(root, "workflows")');
-    expect(buildScript).toContain("dist");
+    const workspaceYaml = readFileSync(join(nerveRoot, "pnpm-workspace.yaml"), "utf8");
+    expect(workspaceYaml).toContain("workflows/*");
+    expect(workspaceYaml).toContain("senses/*");
+
+    const sensePkgJson = readFileSync(
+      join(nerveRoot, "senses", "cpu-usage", "package.json"),
+      "utf8",
+    );
+    expect(sensePkgJson).toContain("nerve-sense-cpu-usage");
+    expect(sensePkgJson).toContain("esbuild");
   });
 
   it("generated nerve.yaml passes validate", { timeout: 10_000 }, async () => {

packages/cli/src/__tests__/e2e/sense.md

@@ -2,7 +2,7 @@
 
 ## sense list
 
-- ✅ prints sense list with name, group, throttle, triggers
+- ✅ prints sense list with name, group, throttle, triggers, and last signal time
 - 🔲 empty state — no senses registered, prints empty message
 - 🔲 `--json` — outputs valid JSON array
 
@@ -11,3 +11,19 @@
 - ✅ trigger known sense exits 0, stdout contains "Triggered"
 - ✅ trigger non-existent sense writes error to stderr and exits 1
 - ✅ sends correct IPC message `{ type: trigger-sense, sense: <name> }` to daemon
+
+## sense query
+
+- ✅ after trigger, persisted `_signals` table has at least one row
+- ✅ default output lists payload column and counter count
+- ✅ `--json` prints valid JSON array with payload on each row
+- ✅ `--sql` runs custom read-only SQL and prints result
+- 🔲 query non-existent sense — error message
+- 🔲 `--limit` / `--offset` pagination
+
+## sense schema
+
+- ✅ prints CREATE TABLE statements for the sense database
+- ✅ includes `_signals` table in output
+- ✅ `--json` prints valid JSON array of SQL strings
+- 🔲 schema for non-existent sense — error message

packages/cli/src/__tests__/e2e/smoke.md

@@ -2,5 +2,5 @@
 
 Full round-trip integration tests that exercise multiple subcommands together.
 
-- ✅ sense list after trigger — daemon lists configured senses; trigger queues a compute (state persisted under `data/senses/` by the worker)
+- ✅ sense list + sense query after trigger — registers sense, triggers, verifies persisted signal and query output
 - 🔲 init → dev → trigger workflow → thread inspect round-trip

packages/cli/src/__tests__/knowledge-query.test.ts

@@ -72,8 +72,8 @@ describe("queryKnowledgeRepo (word overlap fallback)", () => {
           path: "a.md",
           slug: "a.md#0",
           chunkIndex: 0,
-          text: "the sense scheduler triggers computes",
-          contentHash: contentHash("the sense scheduler triggers computes"),
+          text: "the signal bus emits notifications",
+          contentHash: contentHash("the signal bus emits notifications"),
           embedding: fakeEmbeddingBytes("a"),
         },
         {
@@ -89,7 +89,7 @@ describe("queryKnowledgeRepo (word overlap fallback)", () => {
       db.close();
     }
 
-    const ranked = await queryKnowledgeRepo(root, dbPath, "sense scheduler", 10);
+    const ranked = await queryKnowledgeRepo(root, dbPath, "signal bus", 10);
     expect(ranked.length).toBe(2);
     expect(ranked[0]?.path).toBe("a.md");
     expect(ranked[1]?.path).toBe("b.md");

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

@@ -27,12 +27,15 @@ describe("nerve sense list CLI (runCommand + temp HOME + mock IPC socket)", () =
   let stdoutSpy: ReturnType<typeof vi.spyOn<typeof process.stdout, "write">> | null;
   let listSensesRequests: unknown[];
 
+  const LAST_SIGNAL_TS = 1_714_521_600_000; // fixed wall time for stable ISO in assertions
+
   const daemonSenseRow: SenseInfo = {
     name: "cpu-usage",
     group: "system",
     throttle: 5000,
     timeout: 3000,
     triggers: ["every 5s"],
+    lastSignalTimestamp: LAST_SIGNAL_TS,
   };
 
   function nerveYamlFixture(): string {
@@ -116,7 +119,9 @@ senses:
     rmSync(sockDir, { recursive: true, force: true });
   });
 
-  it("prints sense list from daemon path with name, group, throttle, and trigger schedule", async () => {
+  it("prints sense list from daemon path with name, group, throttle, trigger schedule, and last signal time", async () => {
+    // With a real daemon, we would wait for a compute cycle; the mock server
+    // returns SenseInfo as if one already produced lastSignalTimestamp.
     await runCommand(senseCommand, { rawArgs: ["list"] });
 
     expect(listSensesRequests).toHaveLength(1);
@@ -128,6 +133,7 @@ senses:
     expect(out).toContain("throttle: 5s");
     expect(out).toContain("timeout:  3s");
     expect(out).toContain("trigger schedule: every 5s");
-    expect(out).not.toContain("last signal");
+    expect(out).not.toContain("(never)");
+    expect(out).toContain(new Date(LAST_SIGNAL_TS).toISOString());
   });
 });

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

@@ -30,6 +30,7 @@ const SAMPLE_SENSES: SenseInfo[] = [
     throttle: 5000,
     timeout: 3000,
     triggers: ["every 30s", "on: cpu-threshold"],
+    lastSignalTimestamp: 1_700_000_000_000,
   },
   {
     name: "disk-usage",
@@ -37,6 +38,7 @@ const SAMPLE_SENSES: SenseInfo[] = [
     throttle: 30000,
     timeout: null,
     triggers: [],
+    lastSignalTimestamp: null,
   },
   {
     name: "active-tasks",
@@ -44,6 +46,7 @@ const SAMPLE_SENSES: SenseInfo[] = [
     throttle: 10000,
     timeout: 30000,
     triggers: ["every 1m"],
+    lastSignalTimestamp: null,
   },
 ];
 
@@ -119,9 +122,15 @@ describe("formatSenseList", () => {
     expect(output).toContain("(none)");
   });
 
-  it("does not include last signal line", () => {
+  it("shows '(never)' when lastSignalTimestamp is null", () => {
     const output = formatSenseList(SAMPLE_SENSES);
-    expect(output).not.toContain("last signal");
+    expect(output).toContain("(never)");
+  });
+
+  it("shows ISO timestamp when lastSignalTimestamp is set", () => {
+    const output = formatSenseList(SAMPLE_SENSES);
+    // cpu-usage has lastSignalTimestamp = 1_700_000_000_000
+    expect(output).toContain(new Date(1_700_000_000_000).toISOString());
   });
 });
 
@@ -172,13 +181,29 @@ senses:
     expect(result[0]).toMatchObject({
       name: "cpu-usage",
       group: "system",
+      lastSignalTimestamp: null,
     });
     expect(result[1]).toMatchObject({
       name: "disk-usage",
       group: "system",
+      lastSignalTimestamp: null,
     });
   });
 
+  it("always sets lastSignalTimestamp to null (static fallback)", () => {
+    const path = join(tmpDir, "nerve.yaml");
+    writeFileSync(
+      path,
+      `
+senses:
+  my-sense:
+    group: default
+`.trim(),
+    );
+    const result = sensesFromConfig(path);
+    expect(result[0].lastSignalTimestamp).toBeNull();
+  });
+
   it("populates throttle and timeout from config", () => {
     const path = join(tmpDir, "nerve.yaml");
     writeFileSync(
@@ -267,6 +292,7 @@ describe("listSensesViaDaemon", () => {
         throttle: 5000,
         timeout: 3000,
         triggers: [],
+        lastSignalTimestamp: 12345,
       },
     ];
     const server = createServer((s) => {

packages/cli/src/__tests__/sense-schema-e2e.test.ts

@@ -0,0 +1,97 @@
+/**
+ * E2E-style tests for `nerve sense schema` with a temp HOME and a real sense SQLite file.
+ * `getNerveRoot()` uses `os.homedir()`, which respects `process.env.HOME` on POSIX.
+ */
+
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+
+import { runCommand } from "citty";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { senseCommand } from "../commands/sense.js";
+
+const SENSE_NAME = "e2e-schema-sense";
+
+function createFakeSenseDb(nerveRoot: string): void {
+  const sensesDir = join(nerveRoot, "data", "senses");
+  mkdirSync(sensesDir, { recursive: true });
+  const dbPath = join(sensesDir, `${SENSE_NAME}.db`);
+  const db = new DatabaseSync(dbPath);
+  db.exec(
+    "CREATE TABLE _signals(id INTEGER PRIMARY KEY, sense TEXT, timestamp INTEGER, payload TEXT)",
+  );
+  db.exec("CREATE TABLE _migrations (name TEXT PRIMARY KEY)");
+  db.close();
+}
+
+describe("nerve sense schema CLI (runCommand + temp HOME)", () => {
+  let prevHome: string | undefined;
+  let fakeHome: string;
+  let stdoutSpy: ReturnType<typeof vi.spyOn> | null;
+  let capturedStdout: string;
+
+  beforeEach(() => {
+    capturedStdout = "";
+    stdoutSpy = vi
+      .spyOn(process.stdout, "write")
+      .mockImplementation(
+        (chunk: string | Uint8Array, enc?: BufferEncoding, cb?: (err?: Error | null) => void) => {
+          if (typeof chunk === "string") {
+            capturedStdout += chunk;
+          } else {
+            capturedStdout += Buffer.from(chunk).toString(typeof enc === "string" ? enc : "utf8");
+          }
+          if (typeof cb === "function") {
+            cb();
+          }
+          return true;
+        },
+      );
+
+    prevHome = process.env.HOME;
+    fakeHome = mkdtempSync(join(tmpdir(), "nerve-sense-schema-e2e-"));
+    process.env.HOME = fakeHome;
+
+    const nerveRoot = join(fakeHome, ".uncaged-nerve");
+    createFakeSenseDb(nerveRoot);
+  });
+
+  afterEach(() => {
+    stdoutSpy?.mockRestore();
+    stdoutSpy = null;
+    if (prevHome === undefined) {
+      // biome-ignore lint/performance/noDelete: semantically correct for env cleanup
+      delete process.env.HOME;
+    } else {
+      process.env.HOME = prevHome;
+    }
+    rmSync(fakeHome, { recursive: true, force: true });
+  });
+
+  it("prints CREATE TABLE statements for the sense database", async () => {
+    await runCommand(senseCommand, { rawArgs: ["schema", SENSE_NAME] });
+    expect(capturedStdout).toMatch(/CREATE TABLE/i);
+  });
+
+  it("includes the _signals table in output", async () => {
+    await runCommand(senseCommand, { rawArgs: ["schema", SENSE_NAME] });
+    expect(capturedStdout).toContain("_signals");
+  });
+
+  it("with --json prints a valid JSON array of SQL strings", async () => {
+    await runCommand(senseCommand, { rawArgs: ["schema", SENSE_NAME, "--json"] });
+    const parsed: unknown = JSON.parse(capturedStdout.trim());
+    expect(Array.isArray(parsed)).toBe(true);
+    const arr = parsed as unknown[];
+    expect(arr.length).toBeGreaterThanOrEqual(1);
+    for (const item of arr) {
+      expect(typeof item).toBe("string");
+      expect(item).toMatch(/CREATE TABLE/i);
+    }
+    const joined = arr.join("\n");
+    expect(joined).toContain("_signals");
+  });
+});

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

@@ -0,0 +1,181 @@
+/**
+ * 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("uses --sql value instead of positional SQL", () => {
+    expect(parseSenseQueryArgs(["cpu", "--sql", "SELECT 2"])).toEqual({
+      name: "cpu",
+      sql: "SELECT 2",
+    });
+    expect(parseSenseQueryArgs(["cpu", "--sql=SELECT 3"])).toEqual({
+      name: "cpu",
+      sql: "SELECT 3",
+    });
+  });
+
+  it("prefers --sql over trailing positional SQL", () => {
+    expect(parseSenseQueryArgs(["cpu", "--sql", "SELECT a", "SELECT b"])).toEqual({
+      name: "cpu",
+      sql: "SELECT a",
+    });
+  });
+
+  it("throws when --sql has no value", () => {
+    expect(() => parseSenseQueryArgs(["cpu", "--sql"])).toThrow(/Missing value for --sql/);
+  });
+
+  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__/validate-workflow-agents.test.ts

@@ -1,5 +1,5 @@
 /**
- * RFC-003 Phase 5: nerve validate — workflow adapter usage and extract.
+ * RFC-003 Phase 5: nerve validate — WorkflowSpec adapter usage and extract.
  */
 
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
@@ -38,8 +38,9 @@ describe("validateAgentConfigurationLayer", () => {
     writeFileSync(
       join(nerveRoot, "workflows", "demo", "src", "index.ts"),
       `
+import type { WorkflowSpec } from "@uncaged/nerve-core";
 const adapter = async () => "";
-const spec = {
+const spec: WorkflowSpec<{ r: { x: number } }> = {
   name: "demo",
   roles: {
     r: { adapter: adapter, prompt: "p", meta: {} as never },

packages/cli/src/cli.ts

@@ -3,7 +3,6 @@ import "@uncaged/nerve-daemon/experimental-warning-suppression.js";
 import { defineCommand, runMain } from "citty";
 
 import { consumeGlobalDaemonCliFlags } from "./cli-global.js";
-import { agentCommand } from "./commands/agent.js";
 import { createCommand } from "./commands/create.js";
 import { daemonCommand } from "./commands/daemon.js";
 import { devCommand } from "./commands/dev.js";
@@ -43,7 +42,6 @@ const main = defineCommand({
       "Nerve — an AI agent kernel. Global options: --host <host:port> (remote HTTP), --api-token <secret> (Bearer auth).",
   },
   subCommands: {
-    agent: agentCommand,
     init: initCommand,
     create: createCommand,
     daemon: daemonCommand,

packages/cli/src/commands/agent.ts

@@ -1,477 +0,0 @@
-import {
-  cpSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  readdirSync,
-  rmSync,
-  statSync,
-  writeFileSync,
-} from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join, resolve as resolvePath } from "node:path";
-import { fileURLToPath } from "node:url";
-
-import { defineCommand } from "citty";
-
-function getPackageRootDir(): string {
-  const thisFile = fileURLToPath(import.meta.url);
-  let dir = dirname(thisFile);
-  for (let i = 0; i < 5; i++) {
-    if (existsSync(join(dir, "package.json"))) return dir;
-    dir = dirname(dir);
-  }
-  throw new Error("Cannot locate package root. Is the CLI package intact?");
-}
-
-function getCliVersion(): string {
-  const pkgPath = join(getPackageRootDir(), "package.json");
-  const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as { version: string };
-  return pkg.version;
-}
-
-let _cachedVersion: string | null = null;
-function cliVersion(): string {
-  if (_cachedVersion === null) _cachedVersion = getCliVersion();
-  return _cachedVersion;
-}
-
-function getSkillSourceDir(): string {
-  const root = getPackageRootDir();
-  const skillsDir = join(root, "skills");
-  if (!existsSync(skillsDir)) {
-    throw new Error("Cannot locate skills directory. Is the CLI package intact?");
-  }
-  return skillsDir;
-}
-
-function getHermesSkillDir(profile: string | null): string {
-  const hermesHome = join(homedir(), ".hermes");
-  if (profile !== null) {
-    return join(hermesHome, "profiles", profile, "skills", "nerve");
-  }
-  return join(hermesHome, "skills", "nerve");
-}
-
-function readVersionFile(skillDir: string): string | null {
-  const versionPath = join(skillDir, ".nerve-version");
-  if (!existsSync(versionPath)) return null;
-  return readFileSync(versionPath, "utf8").trim();
-}
-
-function writeVersionFile(skillDir: string, version: string): void {
-  writeFileSync(join(skillDir, ".nerve-version"), `${version}\n`, "utf8");
-}
-
-const CURSOR_VERSION_MARKER_RE = /<!--\s*nerve-cli-version:\s*([^>]+?)\s*-->/;
-
-const CLAUDE_BLOCK_START_RE = /<!--\s*nerve-cli:start\s+v([^\s>]+)\s*-->/;
-const CLAUDE_BLOCK_END = "<!-- nerve-cli:end -->";
-const CLAUDE_BLOCK_RE = /<!--\s*nerve-cli:start\s+v[^\s>]+\s*-->[\s\S]*?<!--\s*nerve-cli:end\s*-->/;
-
-function resolveCursorProjectDir(pathArg: string | null): string {
-  const raw = pathArg !== null && pathArg !== "" ? pathArg : process.cwd();
-  return resolvePath(raw);
-}
-
-function assertDirectory(projectDir: string, label: string): void {
-  if (!existsSync(projectDir)) {
-    process.stderr.write(`❌ ${label} does not exist: ${projectDir}\n`);
-    process.exit(1);
-  }
-  if (!statSync(projectDir).isDirectory()) {
-    process.stderr.write(`❌ ${label} is not a directory: ${projectDir}\n`);
-    process.exit(1);
-  }
-}
-
-function readCursorInjectVersion(projectDir: string): string | null {
-  const versionPath = join(projectDir, ".nerve-version");
-  if (existsSync(versionPath)) {
-    return readFileSync(versionPath, "utf8").trim();
-  }
-  const rulesPath = join(projectDir, ".cursorrules");
-  if (!existsSync(rulesPath)) return null;
-  const content = readFileSync(rulesPath, "utf8");
-  const match = content.match(CURSOR_VERSION_MARKER_RE);
-  return match !== null ? match[1].trim() : null;
-}
-
-function injectCursor(projectDir: string): void {
-  assertDirectory(projectDir, "Project directory");
-  const rulesPath = join(projectDir, ".cursorrules");
-  const existingVer = readCursorInjectVersion(projectDir);
-  if (existingVer === cliVersion() && existsSync(rulesPath)) {
-    process.stdout.write(
-      `✅ Cursor .cursorrules is already up to date (v${cliVersion()}) at ${projectDir}\n`,
-    );
-    return;
-  }
-
-  const templatePath = join(getSkillSourceDir(), "cursor", ".cursorrules");
-  if (!existsSync(templatePath)) {
-    throw new Error("Cannot locate cursor/.cursorrules template. Is the CLI package intact?");
-  }
-  let body = readFileSync(templatePath, "utf8");
-  body = body.replaceAll("__NERVE_CLI_VERSION__", cliVersion());
-  writeFileSync(rulesPath, body, "utf8");
-  writeVersionFile(projectDir, cliVersion());
-
-  const action = existingVer !== null ? "Updated" : "Installed";
-  process.stdout.write(`✅ ${action} Cursor .cursorrules v${cliVersion()} at ${projectDir}\n`);
-}
-
-function removeCursor(projectDir: string): void {
-  assertDirectory(projectDir, "Project directory");
-  const rulesPath = join(projectDir, ".cursorrules");
-  const versionPath = join(projectDir, ".nerve-version");
-  if (!existsSync(rulesPath)) {
-    process.stdout.write(`ℹ️ Cursor .cursorrules is not present at ${projectDir}\n`);
-    return;
-  }
-  rmSync(rulesPath, { force: true });
-  if (existsSync(versionPath)) {
-    rmSync(versionPath, { force: true });
-  }
-  process.stdout.write(`✅ Removed Cursor .cursorrules from ${projectDir}\n`);
-}
-
-function injectHermes(profile: string | null): void {
-  const sourceDir = join(getSkillSourceDir(), "hermes");
-  const targetDir = getHermesSkillDir(profile);
-  const existing = readVersionFile(targetDir);
-
-  if (existing === cliVersion()) {
-    const loc = profile !== null ? ` (profile: ${profile})` : "";
-    process.stdout.write(`✅ Hermes nerve skill is already up to date (v${cliVersion()})${loc}\n`);
-    return;
-  }
-
-  mkdirSync(targetDir, { recursive: true });
-  cpSync(sourceDir, targetDir, { recursive: true });
-  writeVersionFile(targetDir, cliVersion());
-
-  const action = existing !== null ? "Updated" : "Installed";
-  const loc = profile !== null ? ` (profile: ${profile})` : "";
-  process.stdout.write(`✅ ${action} Hermes nerve skill v${cliVersion()}${loc}\n`);
-  process.stdout.write(`   → ${targetDir}/SKILL.md\n`);
-}
-
-function removeHermes(profile: string | null): void {
-  const targetDir = getHermesSkillDir(profile);
-  if (!existsSync(targetDir)) {
-    process.stdout.write("ℹ️ Hermes nerve skill is not installed.\n");
-    return;
-  }
-  rmSync(targetDir, { recursive: true, force: true });
-  const loc = profile !== null ? ` (profile: ${profile})` : "";
-  process.stdout.write(`✅ Removed Hermes nerve skill${loc}\n`);
-}
-
-// --- Claude Code ---
-
-function getClaudeGlobalFile(): string {
-  return join(homedir(), ".claude", "CLAUDE.md");
-}
-
-function readClaudeBlockVersion(): string | null {
-  const filePath = getClaudeGlobalFile();
-  if (!existsSync(filePath)) return null;
-  const content = readFileSync(filePath, "utf8");
-  const match = content.match(CLAUDE_BLOCK_START_RE);
-  return match !== null ? match[1].trim() : null;
-}
-
-function injectClaude(): void {
-  const templatePath = join(getSkillSourceDir(), "claude", "CLAUDE.md");
-  if (!existsSync(templatePath)) {
-    throw new Error("Cannot locate claude/CLAUDE.md template. Is the CLI package intact?");
-  }
-  const version = cliVersion();
-  const existingVer = readClaudeBlockVersion();
-
-  if (existingVer === version) {
-    process.stdout.write(`✅ Claude Code nerve skill is already up to date (v${version})\n`);
-    return;
-  }
-
-  const body = readFileSync(templatePath, "utf8");
-  const block = `<!-- nerve-cli:start v${version} -->\n${body.trim()}\n${CLAUDE_BLOCK_END}`;
-
-  const filePath = getClaudeGlobalFile();
-  mkdirSync(dirname(filePath), { recursive: true });
-
-  if (existsSync(filePath)) {
-    const existing = readFileSync(filePath, "utf8");
-    if (CLAUDE_BLOCK_RE.test(existing)) {
-      // Replace existing block
-      const updated = existing.replace(CLAUDE_BLOCK_RE, block);
-      writeFileSync(filePath, updated, "utf8");
-    } else {
-      // Append
-      const sep = existing.endsWith("\n") ? "\n" : "\n\n";
-      writeFileSync(filePath, `${existing}${sep}${block}\n`, "utf8");
-    }
-  } else {
-    writeFileSync(filePath, `${block}\n`, "utf8");
-  }
-
-  const action = existingVer !== null ? "Updated" : "Installed";
-  process.stdout.write(`✅ ${action} Claude Code nerve skill v${version}\n`);
-  process.stdout.write(`   → ${filePath}\n`);
-}
-
-function removeClaude(): void {
-  const filePath = getClaudeGlobalFile();
-  if (!existsSync(filePath)) {
-    process.stdout.write("ℹ️ Claude Code nerve skill is not installed.\n");
-    return;
-  }
-  const content = readFileSync(filePath, "utf8");
-  if (!CLAUDE_BLOCK_RE.test(content)) {
-    process.stdout.write("ℹ️ Claude Code nerve skill is not installed.\n");
-    return;
-  }
-  const cleaned = content
-    .replace(CLAUDE_BLOCK_RE, "")
-    .replace(/\n{3,}/g, "\n\n")
-    .trim();
-  if (cleaned.length === 0) {
-    rmSync(filePath, { force: true });
-  } else {
-    writeFileSync(filePath, `${cleaned}\n`, "utf8");
-  }
-  process.stdout.write("✅ Removed Claude Code nerve skill\n");
-}
-
-function printCursorStatusLine(projectDir: string): void {
-  const rulesPath = join(projectDir, ".cursorrules");
-  const label = `Cursor (${projectDir})`;
-  if (!existsSync(rulesPath)) {
-    process.stdout.write(`  ${label}: ❌ not installed\n`);
-    return;
-  }
-  const ver = readCursorInjectVersion(projectDir);
-  if (ver === null) {
-    process.stdout.write(
-      `  ${label}: ⚠️ installed (unknown version; run \`nerve agent inject cursor\`)\n`,
-    );
-    return;
-  }
-  if (ver === cliVersion()) {
-    process.stdout.write(`  ${label}: ✅ v${ver}\n`);
-  } else {
-    process.stdout.write(
-      `  ${label}: ⚠️ v${ver} → v${cliVersion()} available (run \`nerve agent inject cursor\`)\n`,
-    );
-  }
-}
-
-function printStatus(): void {
-  process.stdout.write(`nerve agent skills (CLI v${cliVersion()})\n\n`);
-
-  printCursorStatusLine(process.cwd());
-  process.stdout.write("\n");
-
-  // Claude Code
-  const claudeVer = readClaudeBlockVersion();
-  printAgentLine("Claude Code", claudeVer);
-  process.stdout.write("\n");
-
-  // Default profile
-  const defaultDir = getHermesSkillDir(null);
-  const defaultVer = readVersionFile(defaultDir);
-  printAgentLine("Hermes (default)", defaultVer);
-
-  // Named profiles
-  const profilesDir = join(homedir(), ".hermes", "profiles");
-  if (existsSync(profilesDir)) {
-    const profiles = readdirSync(profilesDir, { withFileTypes: true })
-      .filter((d) => d.isDirectory())
-      .map((d) => d.name);
-
-    for (const profile of profiles) {
-      const dir = getHermesSkillDir(profile);
-      const ver = readVersionFile(dir);
-      if (ver !== null) {
-        printAgentLine(`Hermes (${profile})`, ver);
-      }
-    }
-  }
-
-  process.stdout.write("\n");
-}
-
-function printAgentLine(label: string, version: string | null): void {
-  if (version === null) {
-    process.stdout.write(`  ${label}: ❌ not installed\n`);
-  } else if (version === cliVersion()) {
-    process.stdout.write(`  ${label}: ✅ v${version}\n`);
-  } else {
-    process.stdout.write(
-      `  ${label}: ⚠️ v${version} → v${cliVersion()} available (run \`nerve agent update\`)\n`,
-    );
-  }
-}
-
-const injectCommand = defineCommand({
-  meta: {
-    name: "inject",
-    description: "Inject nerve skill into an AI agent",
-  },
-  args: {
-    target: {
-      type: "positional",
-      description: "Agent target: hermes | cursor | claude",
-    },
-    profile: {
-      type: "string",
-      description: "Hermes profile name (default: main profile)",
-    },
-    path: {
-      type: "string",
-      description: "Project directory for Cursor rules (default: cwd); only used with cursor",
-    },
-  },
-  run({ args }) {
-    const target = args.target;
-    if (target === "hermes") {
-      if (args.path != null && args.path !== "") {
-        process.stderr.write("❌ --path applies only to the cursor target\n");
-        process.exit(1);
-      }
-      injectHermes(args.profile ?? null);
-      return;
-    }
-    if (target === "cursor") {
-      if (args.profile != null && args.profile !== "") {
-        process.stderr.write("❌ --profile applies only to the hermes target\n");
-        process.exit(1);
-      }
-      const pathArg = args.path != null && args.path !== "" ? args.path : null;
-      injectCursor(resolveCursorProjectDir(pathArg));
-      return;
-    }
-    if (target === "claude") {
-      injectClaude();
-      return;
-    }
-    process.stderr.write(`❌ Unknown agent target: ${target}\n`);
-    process.stderr.write("   Supported targets: hermes, cursor, claude\n");
-    process.exit(1);
-  },
-});
-
-const updateCommand = defineCommand({
-  meta: {
-    name: "update",
-    description: "Update all injected nerve skills to current CLI version",
-  },
-  run() {
-    let updated = 0;
-
-    // Default profile
-    const defaultDir = getHermesSkillDir(null);
-    if (existsSync(defaultDir)) {
-      injectHermes(null);
-      updated++;
-    }
-
-    // Named profiles
-    const profilesDir = join(homedir(), ".hermes", "profiles");
-    if (existsSync(profilesDir)) {
-      const profiles = readdirSync(profilesDir, { withFileTypes: true })
-        .filter((d) => d.isDirectory())
-        .map((d) => d.name);
-
-      for (const profile of profiles) {
-        const dir = getHermesSkillDir(profile);
-        if (existsSync(dir)) {
-          injectHermes(profile);
-          updated++;
-        }
-      }
-    }
-
-    if (updated === 0) {
-      process.stdout.write("ℹ️ No injected skills found. Run `nerve agent inject hermes` first.\n");
-    }
-
-    // Claude Code (always check, no profiles)
-    const claudeVer = readClaudeBlockVersion();
-    if (claudeVer !== null) {
-      injectClaude();
-    }
-  },
-});
-
-const removeCommand = defineCommand({
-  meta: {
-    name: "remove",
-    description: "Remove injected nerve skill from an AI agent",
-  },
-  args: {
-    target: {
-      type: "positional",
-      description: "Agent target: hermes | cursor",
-    },
-    profile: {
-      type: "string",
-      description: "Hermes profile name (default: main profile)",
-    },
-    path: {
-      type: "string",
-      description: "Project directory for Cursor rules (default: cwd); only used with cursor",
-    },
-  },
-  run({ args }) {
-    const target = args.target;
-    if (target === "hermes") {
-      if (args.path != null && args.path !== "") {
-        process.stderr.write("❌ --path applies only to the cursor target\n");
-        process.exit(1);
-      }
-      removeHermes(args.profile ?? null);
-      return;
-    }
-    if (target === "cursor") {
-      if (args.profile != null && args.profile !== "") {
-        process.stderr.write("❌ --profile applies only to the hermes target\n");
-        process.exit(1);
-      }
-      const pathArg = args.path != null && args.path !== "" ? args.path : null;
-      removeCursor(resolveCursorProjectDir(pathArg));
-      return;
-    }
-    if (target === "claude") {
-      removeClaude();
-      return;
-    }
-    process.stderr.write(`❌ Unknown agent target: ${target}\n`);
-    process.stderr.write("   Supported targets: hermes, cursor, claude\n");
-    process.exit(1);
-  },
-});
-
-const statusCommand = defineCommand({
-  meta: {
-    name: "status",
-    description: "Show injection status of nerve skills across agents",
-  },
-  run() {
-    printStatus();
-  },
-});
-
-export const agentCommand = defineCommand({
-  meta: {
-    name: "agent",
-    description: "Manage nerve skill injection for AI agents",
-  },
-  subCommands: {
-    inject: injectCommand,
-    update: updateCommand,
-    remove: removeCommand,
-    status: statusCommand,
-  },
-});

packages/cli/src/commands/create.ts

@@ -20,19 +20,40 @@ export type WorkflowScaffoldFiles = {
   indexTs: string;
   roleMainIndexTs: string;
   roleMainPromptMd: string;
+  packageJson: string;
 };
 
+export function buildWorkflowPackageJson(name: string): string {
+  return `${JSON.stringify(
+    {
+      name: `nerve-workflow-${name}`,
+      private: true,
+      type: "module",
+      scripts: {
+        build:
+          "esbuild index.ts --bundle --platform=node --format=esm --outdir=dist --packages=external",
+      },
+      devDependencies: {
+        esbuild: "^0.27.0",
+      },
+    },
+    null,
+    2,
+  )}\n`;
+}
+
 export function buildWorkflowScaffold(name: string): WorkflowScaffoldFiles {
   return {
     indexTs: buildWorkflowIndexTs(name),
     roleMainIndexTs: buildWorkflowMainRoleIndexTs(name),
     roleMainPromptMd: buildWorkflowMainRolePromptMd(name),
+    packageJson: buildWorkflowPackageJson(name),
   };
 }
 
 function buildWorkflowIndexTs(name: string): string {
-  return `import type { ThreadContext, WorkflowDefinition } from "@uncaged/workflow";
-import { END } from "@uncaged/workflow";
+  return `import type { WorkflowDefinition } from "@uncaged/nerve-core";
+import { END } from "@uncaged/nerve-core";
 
 import { mainRole } from "./roles/main/index.js";
 
@@ -43,8 +64,8 @@ const workflow: WorkflowDefinition<Record<"main", MainMeta>> = {
   roles: {
     main: mainRole,
   },
-  moderator(ctx: ThreadContext<Record<"main", MainMeta>>) {
-    if (ctx.steps.length === 0) {
+  moderator({ steps }) {
+    if (steps.length === 0) {
       return "main";
     }
     return END;
@@ -56,16 +77,18 @@ export default workflow;
 }
 
 function buildWorkflowMainRoleIndexTs(name: string): string {
-  return `import type { RoleResult, ThreadContext } from "@uncaged/workflow";
+  return `import type { RoleResult, StartStep, WorkflowMessage } from "@uncaged/nerve-core";
 
 /**
  * Main role — implement LLM calls, scripts, HTTP, etc.
  * Optional: align behavior with \`prompt.md\` in this directory.
  */
 export async function mainRole(
-  ctx: ThreadContext,
+  start: StartStep,
+  messages: WorkflowMessage[],
 ): Promise<RoleResult<Record<string, unknown>>> {
-  void ctx;
+  void start;
+  void messages;
   // TODO: implement your role logic here
   return {
     content: "${name} started",
@@ -85,26 +108,94 @@ and optionally load this file at runtime if you keep prompts outside code.
 `;
 }
 
-export function buildSenseIndexTs(_senseId: string): string {
-  return `type SenseState = {
-  lastRun: number | null;
-};
+function senseIdToSqlTableName(id: string): string {
+  return id.replaceAll("-", "_");
+}
 
-export const initialState: SenseState = { lastRun: null };
+function senseIdToSchemaExportName(id: string): string {
+  const parts = id.split("-");
+  return parts
+    .map((part, index) =>
+      index === 0 ? part : part.length === 0 ? "" : part.charAt(0).toUpperCase() + part.slice(1),
+    )
+    .join("");
+}
 
-export async function compute(state: SenseState): Promise<{
-  state: SenseState;
-  trigger: null;
-}> {
-  // TODO: implement sense logic
+export function buildSenseSchemaTs(senseId: string): string {
+  const table = senseIdToSqlTableName(senseId);
+  const exportName = senseIdToSchemaExportName(senseId);
+  return `import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+export const ${exportName} = sqliteTable("${table}", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  ts: integer("ts").notNull(),
+  label: text("label").notNull(),
+});
+`;
+}
+
+export function buildSensePackageJson(name: string): string {
+  return `${JSON.stringify(
+    {
+      name: `nerve-sense-${name}`,
+      private: true,
+      type: "module",
+      scripts: {
+        build:
+          "esbuild src/index.ts --bundle --platform=node --format=esm --outdir=. --out-extension:.js=.js --packages=external",
+      },
+      devDependencies: {
+        esbuild: "^0.27.0",
+        "drizzle-orm": "*",
+      },
+    },
+    null,
+    2,
+  )}\n`;
+}
+
+export function buildSenseIndexTs(senseId: string): string {
+  const exportName = senseIdToSchemaExportName(senseId);
+  return `import type { LibSQLDatabase } from "drizzle-orm/libsql";
+
+import { ${exportName} } from "./schema.js";
+
+type SenseResult = {
+  signal: { label: string; ts: number };
+  workflow: null;
+} | null;
+
+/**
+ * ${senseId} — replace this stub with your sampling logic.
+ * Returns non-null to emit a signal, null to stay silent.
+ */
+export async function compute(
+  db: LibSQLDatabase,
+  _peers: Record<string, LibSQLDatabase>,
+  _options: { signal: AbortSignal },
+): Promise<SenseResult> {
+  void ${exportName};
   return {
-    state: { lastRun: Date.now() },
-    trigger: null,
+    signal: {
+      label: "${senseId}",
+      ts: Date.now(),
+    },
+    workflow: null,
   };
 }
 `;
 }
 
+export function buildSenseMigrationSql(senseId: string): string {
+  const table = senseIdToSqlTableName(senseId);
+  return `CREATE TABLE IF NOT EXISTS ${table} (
+  id    INTEGER PRIMARY KEY AUTOINCREMENT,
+  ts    INTEGER NOT NULL,
+  label TEXT    NOT NULL
+);
+`;
+}
+
 function writeFile(filePath: string, content: string): void {
   mkdirSync(dirname(filePath), { recursive: true });
   writeFileSync(filePath, content, "utf8");
@@ -156,39 +247,30 @@ const createWorkflowCommand = defineCommand({
 
     mkdirSync(workflowDir, { recursive: true });
     const scaffold = buildWorkflowScaffold(args.name);
+    writeFile(join(workflowDir, "package.json"), scaffold.packageJson);
     writeFile(join(workflowDir, "index.ts"), scaffold.indexTs);
     writeFile(join(workflowDir, "roles", "main", "index.ts"), scaffold.roleMainIndexTs);
     writeFile(join(workflowDir, "roles", "main", "prompt.md"), scaffold.roleMainPromptMd);
 
     process.stdout.write("✅ Workflow scaffolded:\n");
+    process.stdout.write(`   ${join(workflowDir, "package.json")}\n`);
     process.stdout.write(`   ${join(workflowDir, "index.ts")}\n`);
     process.stdout.write(`   ${join(workflowDir, "roles", "main", "index.ts")}\n`);
     process.stdout.write(`   ${join(workflowDir, "roles", "main", "prompt.md")}\n`);
-
-    process.stdout.write("\nBuilding workspace (workflows + senses)…\n");
-    try {
-      await spawnAsync("pnpm", ["run", "build"], nerveRoot);
-      process.stdout.write(
-        `✅ Build complete — ${join("dist", "workflows", args.name, "index.js")} ready.\n`,
-      );
-    } catch {
-      process.stdout.write(`⚠️ Build failed. Run manually:\n   cd ${nerveRoot} && pnpm run build\n`);
-    }
-
     process.stdout.write("\n💡 Next steps:\n");
-    process.stdout.write("   1. Add to nerve.yaml:\n");
+    process.stdout.write(
+      `   1. In ${workflowDir}, run \`npm install\` then \`npm run build\` (bundles to dist/index.js).\n`,
+    );
+    process.stdout.write("   2. Add to nerve.yaml:\n");
     process.stdout.write("         workflows:\n");
     process.stdout.write(`           ${args.name}:\n`);
     process.stdout.write("             concurrency: 1\n");
     process.stdout.write("             overflow: drop\n");
     process.stdout.write(
-      `   2. Edit ${join(workflowDir, "roles", "main", "index.ts")} (and optional prompt.md).\n`,
+      `   3. Edit ${join(workflowDir, "roles", "main", "index.ts")} (and optional prompt.md).\n`,
     );
     process.stdout.write(
-      `   3. Adjust moderator routing in ${join(workflowDir, "index.ts")} if you add roles.\n`,
-    );
-    process.stdout.write(
-      `   4. After edits, run \`pnpm run build\` from the workspace root (${nerveRoot}); output is dist/workflows/<name>/index.js.\n`,
+      `   4. Adjust moderator routing in ${join(workflowDir, "index.ts")} if you add roles.\n`,
     );
     process.stdout.write("   5. Run `nerve start` to launch the daemon.\n");
   },
@@ -228,19 +310,27 @@ const createSenseCommand = defineCommand({
     }
 
     mkdirSync(join(senseDir, "src"), { recursive: true });
+    mkdirSync(join(senseDir, "migrations"), { recursive: true });
+    writeFile(join(senseDir, "package.json"), buildSensePackageJson(args.name));
     writeFile(join(senseDir, "src", "index.ts"), buildSenseIndexTs(args.name));
+    writeFile(join(senseDir, "src", "schema.ts"), buildSenseSchemaTs(args.name));
+    writeFile(join(senseDir, "migrations", "0001_init.sql"), buildSenseMigrationSql(args.name));
 
     process.stdout.write("✅ Sense scaffolded:\n");
+    process.stdout.write(`   ${join(senseDir, "package.json")}\n`);
     process.stdout.write(`   ${join(senseDir, "src", "index.ts")}\n`);
+    process.stdout.write(`   ${join(senseDir, "src", "schema.ts")}\n`);
+    process.stdout.write(`   ${join(senseDir, "migrations", "0001_init.sql")}\n`);
 
-    process.stdout.write("\nBuilding workspace (senses + workflows)…\n");
+    process.stdout.write("\nInstalling sense dependencies and building…\n");
     try {
-      await spawnAsync("pnpm", ["run", "build"], nerveRoot);
-      process.stdout.write(
-        `✅ Build complete — ${join("dist", "senses", args.name, "index.js")} ready.\n`,
-      );
+      await spawnAsync("pnpm", ["install", "--no-cache", "--ignore-workspace"], senseDir);
+      await spawnAsync("pnpm", ["run", "build"], senseDir);
+      process.stdout.write("✅ Build complete — index.js ready.\n");
     } catch {
-      process.stdout.write(`⚠️ Build failed. Run manually:\n   cd ${nerveRoot} && pnpm run build\n`);
+      process.stdout.write(
+        `⚠️ Build failed. Run manually:\n   cd ${senseDir} && pnpm install --no-cache --ignore-workspace && pnpm run build\n`,
+      );
     }
 
     process.stdout.write("\n💡 Next steps:\n");
@@ -253,9 +343,7 @@ const createSenseCommand = defineCommand({
     process.stdout.write(
       `   2. Edit ${join(senseDir, "src", "index.ts")} to implement ${args.name}.\n`,
     );
-    process.stdout.write(
-      `   3. Re-run \`pnpm run build\` from the workspace root (${nerveRoot}) after edits.\n`,
-    );
+    process.stdout.write(`   3. Re-run \`pnpm run build\` in ${senseDir} after edits.\n`);
     process.stdout.write("   4. Run `nerve start` to launch the daemon.\n");
   },
 });

packages/cli/src/commands/init.ts

@@ -17,6 +17,11 @@ senses:
     interval: 10s
 `;
 
+const PNPM_WORKSPACE_YAML = `packages:
+  - 'workflows/*'
+  - 'senses/*'
+`;
+
 const BIOME_JSON = `{
   "$schema": "https://biomejs.dev/schemas/1.9.0/schema.json",
   "formatter": {
@@ -49,19 +54,17 @@ const PACKAGE_JSON = `${JSON.stringify(
     private: true,
     type: "module",
     scripts: {
-      build: "node scripts/build.mjs",
+      build: "pnpm -r build",
     },
     dependencies: {
       "@uncaged/nerve-core": "latest",
       "@uncaged/nerve-daemon": "latest",
-      "@uncaged/workflow": "latest",
-      zod: "^4.3.6",
+      "@uncaged/nerve-skills": "latest",
+      "drizzle-orm": "latest",
     },
     devDependencies: {
       "@biomejs/biome": "latest",
-      "@types/node": "^22.0.0",
-      esbuild: "^0.27.0",
-      typescript: "^5.7.0",
+      "drizzle-kit": "latest",
     },
     pnpm: {
       onlyBuiltDependencies: ["esbuild"],
@@ -71,54 +74,6 @@ const PACKAGE_JSON = `${JSON.stringify(
   2,
 )}\n`;
 
-const BUILD_MJS = `import * as esbuild from "esbuild";
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const root = path.join(path.dirname(fileURLToPath(import.meta.url)), "..");
-const dist = path.join(root, "dist");
-
-const opts = {
-  bundle: true,
-  platform: "node",
-  format: "esm",
-  packages: "external",
-};
-
-function listDirs(dir) {
-  if (!fs.existsSync(dir)) return [];
-  return fs
-    .readdirSync(dir)
-    .filter((name) => !name.startsWith(".") && !name.startsWith("_"))
-    .map((name) => ({ name, full: path.join(dir, name) }))
-    .filter(({ full }) => fs.statSync(full).isDirectory());
-}
-
-async function main() {
-  // Clean dist/
-  fs.rmSync(dist, { recursive: true, force: true });
-
-  for (const { name, full } of listDirs(path.join(root, "senses"))) {
-    const entry = path.join(full, "src", "index.ts");
-    if (!fs.existsSync(entry)) continue;
-    const outfile = path.join(dist, "senses", name, "index.js");
-    fs.mkdirSync(path.dirname(outfile), { recursive: true });
-    await esbuild.build({ ...opts, entryPoints: [entry], outfile });
-  }
-
-  for (const { name, full } of listDirs(path.join(root, "workflows"))) {
-    const entry = path.join(full, "index.ts");
-    if (!fs.existsSync(entry)) continue;
-    const outfile = path.join(dist, "workflows", name, "index.js");
-    fs.mkdirSync(path.dirname(outfile), { recursive: true });
-    await esbuild.build({ ...opts, entryPoints: [entry], outfile });
-  }
-}
-
-await main();
-`;
-
 const GITIGNORE = `data/
 logs/
 nerve.pid
@@ -126,114 +81,105 @@ node_modules/
 knowledge.db
 `;
 
-/** Generated at workspace root so agents can \`cat AGENT.md\` instead of npm skill paths. */
-const AGENT_MD = `# Nerve workspace — agent guide
-
-This file is created by \`nerve init\`. Read it before implementing senses or workflows.
-
-## Directory layout
-
-| Path | Purpose |
-|------|---------|
-| \`nerve.yaml\` | Senses, workflows, intervals, groups |
-| \`package.json\` | Single root package — no per-sense/per-workflow packages |
-| \`scripts/build.mjs\` | Root esbuild step; output under \`dist/\` |
-| \`senses/<name>/src/index.ts\` | Sense \`compute()\` + \`initialState\` |
-| \`data/senses/<name>.json\` | Persisted sense state (written by the daemon) |
-| \`workflows/<name>/index.ts\` | Default export: \`WorkflowDefinition\` |
-| \`workflows/<name>/roles/<role>.ts\` | One TypeScript file per role |
-| \`dist/senses/<name>/index.js\` | Bundled sense (after build) |
-| \`dist/workflows/<name>/index.js\` | Bundled workflow (after build) |
-
-There is **no** \`package.json\` or \`tsconfig.json\` inside individual senses or workflows.
-
-## Naming
-
-- **Workflows:** verb-first kebab-case (e.g. \`review-pull-request\`, \`deploy-staging\`). Avoid bare nouns like \`notifications\`.
-- **Senses:** kebab-case descriptive nouns (e.g. \`cpu-usage\`).
-
-## Workflow roles — four-tuple pattern
-
-Wire each role with \`createRole\` from \`@uncaged/nerve-workflow-utils\`:
-
-1. **Adapter** — \`AgentFn\` (LLM call)
-2. **Prompt builder** — \`async (ctx: ThreadContext) => string\`
-3. **Meta schema** — Zod object (routing / structured output from the model)
-4. **Extractor config** — how JSON meta is parsed from replies
-
-Keep meta small (often one boolean per role). The **moderator** in \`WorkflowDefinition\` routes between role names.
-
-## Build commands
-
-Always run from the **workspace root**:
-
-\`\`\`bash
-pnpm run build
-# or: npm run build
-\`\`\`
-
-Fix errors until this succeeds. New workflows must appear under \`workflows/<name>/\` and be registered in \`nerve.yaml\`; new senses under \`senses/<name>/\` with matching \`nerve.yaml\` entries.
-
-## Coding style (Nerve conventions)
-
-- Use \`type\`, not \`interface\`; prefer \`function\` over classes (except errors / library requirements).
-- **Named exports only** — no \`export default\` (exception: \`workflows/<name>/index.ts\` uses default export for the daemon loader).
-- Nullable fields: \`T | null\`, not TypeScript optional \`?:\`.
-- No dynamic \`import()\` in workspace code (bundling and tooling assume static imports).
-- Use \`async\`/\`await\`; use a \`Result\` type for expected failures instead of control-flow try/catch.
-
-## Extra references (optional)
-
-- \`CONVENTIONS.md\` — project-specific overrides at repo root.
-- \`.knowledge/*.md\` — deeper docs when working inside the Nerve monorepo.
-- \`.cursor/skills/\` — Cursor Agent Skills (\`SKILL.md\` per skill).
-`;
-
 const NERVE_SKILLS_MDC = `---
 description: >-
-  Where Agent Skills live in this Nerve workspace and how to use them with Cursor
+  Nerve skills package — where bundled Agent Skills live in this workspace and how to use them
 alwaysApply: true
 ---
 
-# Nerve Agent Skills
+# Nerve skills (\`@uncaged/nerve-skills\`)
 
-**Agent Skills** are directories that contain a \`SKILL.md\` (with YAML frontmatter). Cursor loads them from **Project Skills** paths (for example \`.cursor/skills/\` or your global skills directory).
+This workspace lists **@uncaged/nerve-skills** in \`package.json\`. It ships **Agent Skills** (one directory per skill, each with a \`SKILL.md\`) for Nerve development and related tasks.
 
-## Getting Nerve-oriented skills
+## After install
 
-There is no separate npm package for skills in the default workspace. To align with Nerve CLI, daemon, and monorepo conventions:
+Run your package manager in this workspace (e.g. \`pnpm install\`, \`npm install\` — whatever \`nerve init\` used). Then skills are on disk at:
 
-1. Copy or symlink skill folders from the **Nerve** repository (e.g. \`packages/skills/*/\`) into \`.cursor/skills/\`, **or**
-2. Follow project documentation and \`CLAUDE.md\` / \`.cursor/rules/\` in this repo.
+- \`node_modules/@uncaged/nerve-skills/<skill-id>/SKILL.md\`
+
+Example (current catalog):
+
+- **nerve-dev** — Nerve architecture, CLI, sense/workflow patterns, \`nerve.yaml\`, and conventions: read \`node_modules/@uncaged/nerve-skills/nerve-dev/SKILL.md\`.
 
 ## How to use in an agent
 
-1. When a task matches a skill’s **description** (in \`SKILL.md\` frontmatter), open that file and follow its steps.
-2. Prefer those conventions for sense/workflow layout, \`nerve.yaml\`, and tooling over generic guesses.
-3. Keep skills versioned with your dotfiles or project; update them when you upgrade Nerve.
+1. For tasks that match a skill’s **description** (in the \`SKILL.md\` frontmatter), open that \`SKILL.md\` and follow its structure and checklists.
+2. Prefer the skill as the **source of truth** for Nerve-specific conventions over generic assumptions.
+3. If the catalog grows, new skills appear as new sibling directories under \`node_modules/@uncaged/nerve-skills/\`.
+
+Do not commit \`node_modules\`; the dependency is the supported way to get and update skills to match \`@uncaged/nerve-skills\` on npm.
 `;
 
 const execFileAsync = promisify(execFile);
 
-const CPU_INDEX_TS = `import { loadavg } from "node:os";
+const CPU_SCHEMA_TS = `import { integer, real, sqliteTable, text } from "drizzle-orm/sqlite-core";
 
-type CpuState = {
-  samples: Array<{ ts: number; value: number }>;
+export const cpuUsage = sqliteTable("cpu_usage", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  ts: integer("ts").notNull(),
+  model: text("model").notNull(),
+  loadPercent: real("load_percent").notNull(),
+});
+`;
+
+const CPU_INDEX_TS = `import { cpus } from "node:os";
+
+type SenseResult = {
+  signal: { model: string; loadPercent: number; ts: number };
+  workflow: null;
 };
 
-export const initialState: CpuState = { samples: [] };
+export async function compute(): Promise<SenseResult> {
+  const cpuList = cpus();
 
-export async function compute(state: CpuState): Promise<{
-  state: CpuState;
-  trigger: null;
-}> {
-  const [oneMin] = loadavg();
-  const value = typeof oneMin === "number" && !Number.isNaN(oneMin) ? oneMin : 0;
-  const newSamples = [...state.samples.slice(-99), { ts: Date.now(), value }];
-  return { state: { samples: newSamples }, trigger: null };
+  let totalIdle = 0;
+  let totalTick = 0;
+  for (const cpu of cpuList) {
+    for (const [, time] of Object.entries(cpu.times)) {
+      totalTick += time;
+    }
+    totalIdle += cpu.times.idle;
+  }
+
+  const loadPercent = totalTick === 0 ? 0 : ((totalTick - totalIdle) / totalTick) * 100;
+
+  return {
+    signal: {
+      model: cpuList[0]?.model ?? "unknown",
+      loadPercent: Math.round(loadPercent * 100) / 100,
+      ts: Date.now(),
+    },
+    workflow: null,
+  };
 }
 `;
 
+const CPU_SENSE_PACKAGE_JSON = `${JSON.stringify(
+  {
+    name: "nerve-sense-cpu-usage",
+    private: true,
+    type: "module",
+    scripts: {
+      build:
+        "esbuild src/index.ts --bundle --platform=node --format=esm --outdir=. --out-extension:.js=.js --packages=external",
+    },
+    devDependencies: {
+      esbuild: "^0.27.0",
+      "drizzle-orm": "*",
+    },
+  },
+  null,
+  2,
+)}\n`;
+
+const CPU_MIGRATION_SQL = `CREATE TABLE IF NOT EXISTS cpu_usage (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  ts          INTEGER NOT NULL,
+  model       TEXT    NOT NULL,
+  load_percent REAL   NOT NULL
+);
+`;
+
 function writeFile(filePath: string, content: string): void {
   mkdirSync(dirname(filePath), { recursive: true });
   writeFileSync(filePath, content, "utf8");
@@ -384,14 +330,20 @@ async function runInitWorkspace(force: boolean, skipInstall = false): Promise<vo
   mkdirSync(join(nerveRoot, "data"), { recursive: true });
   mkdirSync(join(nerveRoot, "data", "senses"), { recursive: true });
   mkdirSync(join(nerveRoot, "senses", "cpu-usage", "src"), { recursive: true });
+  mkdirSync(join(nerveRoot, "senses", "cpu-usage", "migrations"), { recursive: true });
 
   writeFile(join(nerveRoot, "nerve.yaml"), NERVE_YAML);
   writeFile(join(nerveRoot, "package.json"), PACKAGE_JSON);
-  writeFile(join(nerveRoot, "scripts", "build.mjs"), BUILD_MJS);
+  writeFile(join(nerveRoot, "pnpm-workspace.yaml"), PNPM_WORKSPACE_YAML);
   writeFile(join(nerveRoot, "biome.json"), BIOME_JSON);
   writeFile(join(nerveRoot, ".gitignore"), GITIGNORE);
-  writeFile(join(nerveRoot, "AGENT.md"), AGENT_MD);
+  writeFile(join(nerveRoot, "senses", "cpu-usage", "package.json"), CPU_SENSE_PACKAGE_JSON);
   writeFile(join(nerveRoot, "senses", "cpu-usage", "src", "index.ts"), CPU_INDEX_TS);
+  writeFile(join(nerveRoot, "senses", "cpu-usage", "src", "schema.ts"), CPU_SCHEMA_TS);
+  writeFile(
+    join(nerveRoot, "senses", "cpu-usage", "migrations", "0001_init.sql"),
+    CPU_MIGRATION_SQL,
+  );
   writeFile(join(nerveRoot, ".cursor", "rules", "nerve-skills.mdc"), NERVE_SKILLS_MDC);
 
   if (!skipInstall) {

packages/cli/src/commands/sense.ts

@@ -1,11 +1,25 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
+import type { DatabaseSync } from "node:sqlite";
 
-import { type SenseInfo, parseNerveConfig, senseTriggerLabels } from "@uncaged/nerve-core";
+import {
+  type SenseInfo,
+  isPlainRecord,
+  parseNerveConfig,
+  senseTriggerLabels,
+} from "@uncaged/nerve-core";
 import { defineCommand } from "citty";
 
 import { isRemoteDaemonCli } from "../cli-global.js";
 import { resolveDaemonTransport } from "../daemon-client.js";
+import {
+  defaultPreviewSql,
+  formatRowsAsAlignedTable,
+  listTableSqlStatements,
+  openSenseDb,
+  parseSenseQueryArgs,
+  pickDefaultPreviewTable,
+} from "../sense-sqlite.js";
 import { getNerveRoot, isRunning } from "../workspace.js";
 
 // ---------------------------------------------------------------------------
@@ -38,6 +52,9 @@ export function formatSenseList(senses: SenseInfo[]): string {
     lines.push(
       `    trigger schedule: ${s.triggers.length > 0 ? s.triggers.join("; ") : "(none)"}\n`,
     );
+    const lastSignal =
+      s.lastSignalTimestamp !== null ? new Date(s.lastSignalTimestamp).toISOString() : "(never)";
+    lines.push(`    last signal: ${lastSignal}\n`);
   }
   return lines.join("");
 }
@@ -59,6 +76,7 @@ export function sensesFromConfig(configPath: string): SenseInfo[] {
     throttle: cfg.throttle,
     timeout: cfg.timeout,
     triggers: senseTriggerLabels(name, senses),
+    lastSignalTimestamp: null,
   }));
 }
 
@@ -74,7 +92,7 @@ const senseListCommand = defineCommand({
   async run() {
     if (!isRemoteDaemonCli() && !isRunning()) {
       process.stderr.write(
-        "⚠️  Daemon is not running — showing static config from nerve.yaml only.\n\n",
+        "⚠️  Daemon is not running — showing static config only (no last signal time).\n\n",
       );
       const configPath = join(getNerveRoot(), "nerve.yaml");
       const senses = sensesFromConfig(configPath);
@@ -136,6 +154,116 @@ 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, or use --sql "…".',
+  },
+  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 rawRows: unknown[] = db.prepare(sql).all();
+      const rows: Record<string, unknown>[] = rawRows.filter(isPlainRecord);
+
+      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)
 // ---------------------------------------------------------------------------
@@ -148,5 +276,7 @@ export const senseCommand = defineCommand({
   subCommands: {
     list: senseListCommand,
     trigger: senseTriggerCommand,
+    schema: senseSchemaCommand,
+    query: senseQueryCommand,
   },
 });

packages/cli/src/commands/status.ts

@@ -97,5 +97,6 @@ export const statusCommand = defineCommand({
     process.stdout.write(
       `   workers: ${workerGroups.length > 0 ? workerGroups.join(", ") : "(none)"}\n`,
     );
+    process.stdout.write("   signals: (pending SignalBus persistence)\n");
   },
 });

packages/cli/src/commands/workflow.ts

@@ -1,15 +1,14 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 
-import { isPlainRecord, parseNerveConfig } from "@uncaged/nerve-core";
-import { DEFAULT_ENGINE_MAX_ROUNDS } from "@uncaged/workflow";
+import { DEFAULT_ENGINE_MAX_ROUNDS, isPlainRecord, parseNerveConfig } from "@uncaged/nerve-core";
 import { defineCommand } from "citty";
 import { stringify } from "yaml";
 
 import type { LogStore, ThreadRoundRow, WorkflowRun } from "@uncaged/nerve-store";
 import { isRemoteDaemonCli } from "../cli-global.js";
 import { resolveDaemonTransport } from "../daemon-client.js";
-import { formatRowsAsAlignedTable } from "../table-format.js";
+import { formatRowsAsAlignedTable } from "../sense-sqlite.js";
 import { loadDaemonModule } from "../workspace-daemon.js";
 import { getNerveRoot, isRunning } from "../workspace.js";
 

packages/cli/src/daemon-client.ts

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

packages/cli/src/http-transport.ts

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

packages/cli/src/sense-sqlite.ts

@@ -0,0 +1,170 @@
+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 = '_signals' THEN 0
+              WHEN name = '_migrations' THEN 2
+              ELSE 1 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`;
+}
+
+function endIndexAfterGenericDashArg(rawArgs: string[], i: number): number {
+  const a = rawArgs[i];
+  const eq = a.indexOf("=");
+  if (eq === -1 && i + 1 < rawArgs.length && !rawArgs[i + 1].startsWith("-")) {
+    return i + 1;
+  }
+  return i;
+}
+
+type SenseQueryArgStep = {
+  nextIndex: number;
+  flagSql: string | undefined;
+  positionalToken: string | null;
+};
+
+function nextSenseQueryArgStep(rawArgs: string[], i: number): SenseQueryArgStep {
+  const a = rawArgs[i];
+  if (a === "--json" || a === "--no-json") {
+    return { nextIndex: i, flagSql: undefined, positionalToken: null };
+  }
+  if (a.startsWith("--sql=")) {
+    return { nextIndex: i, flagSql: a.slice("--sql=".length), positionalToken: null };
+  }
+  if (a === "--sql") {
+    if (i + 1 >= rawArgs.length || rawArgs[i + 1].startsWith("-")) {
+      throw new Error("Missing value for --sql");
+    }
+    return { nextIndex: i + 1, flagSql: rawArgs[i + 1], positionalToken: null };
+  }
+  if (a.startsWith("-")) {
+    return {
+      nextIndex: endIndexAfterGenericDashArg(rawArgs, i),
+      flagSql: undefined,
+      positionalToken: null,
+    };
+  }
+  return { nextIndex: i, flagSql: undefined, positionalToken: a };
+}
+
+/** Parse sense name and optional SQL from subcommand raw argv (flags stripped). */
+export function parseSenseQueryArgs(rawArgs: string[]): { name: string; sql: string | undefined } {
+  let flagSql: string | undefined;
+  const pos: string[] = [];
+  let i = 0;
+  while (i < rawArgs.length) {
+    const step = nextSenseQueryArgStep(rawArgs, i);
+    if (step.flagSql !== undefined) {
+      flagSql = step.flagSql;
+    }
+    if (step.positionalToken !== null) {
+      pos.push(step.positionalToken);
+    }
+    i = step.nextIndex + 1;
+  }
+  if (pos.length < 1) {
+    throw new Error("Missing sense name");
+  }
+  const name = pos[0];
+  const positionalSql = pos.length > 1 ? pos.slice(1).join(" ") : undefined;
+  const trimmedFlag = flagSql?.trim();
+  const sql = trimmedFlag !== undefined && trimmedFlag.length > 0 ? trimmedFlag : positionalSql;
+  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/table-format.ts

@@ -1,48 +0,0 @@
-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/workflow-agent-validation.ts

@@ -8,7 +8,7 @@ import { join } from "node:path";
 import type { NerveConfig } from "@uncaged/nerve-core";
 
 /**
- * Detects `adapter:` usage in workflow TypeScript sources (e.g. createRole wiring).
+ * Detects RoleSpec `adapter:` usage in workflow TypeScript sources.
  * NOTE: This regex can match occurrences inside comments.
  */
 const WORKFLOW_SPEC_ADAPTER_PATTERN = /adapter:\s*[a-zA-Z_$]/;
@@ -26,7 +26,7 @@ function collectTsSourceFiles(dir: string, acc: string[]): void {
 }
 
 /**
- * Returns true when any workflow `src` tree appears to use roles with adapters.
+ * Returns true when any workflow `src` tree appears to use WorkflowSpec roles with adapters.
  */
 export function workflowSourcesDeclareAdapterRoles(nerveRoot: string): boolean {
   const workflowsRoot = join(nerveRoot, "workflows");
@@ -66,7 +66,7 @@ export function validateAgentConfigurationLayer(
     return {
       ok: false,
       message:
-        "extract: required when workflow roles use adapters (configure extract.provider and extract.model)",
+        "extract: required when WorkflowSpec roles use adapters (configure extract.provider and extract.model)",
     };
   }
 

packages/core/README.md

@@ -4,18 +4,18 @@ Shared types and configuration parser for the [nerve](../../README.md) observati
 
 ## What's Inside
 
-- **Type definitions** — `SenseConfig`, `SenseInfo`, `SenseComputeFn`, `SenseModule`, `SenseTrigger`, `WorkflowConfig`, `NerveConfig`, and related types
-- **Config parser** — `parseNerveConfig(yaml)` validates and parses `nerve.yaml` into `NerveConfig` (top-level `reflexes` is rejected; use `interval` / `on` on each sense)
-- **Sense triggers** — `parseSenseTrigger` validates `{ command: string }` from sense compute results or worker IPC (`trigger` field on `compute-result`)
+- **Type definitions** — `Signal`, `SenseConfig`, `SenseInfo`, `SenseReflexConfig`, `ReflexConfig` (sense-only), `WorkflowConfig`, `NerveConfig`, and related types
+- **Config parser** — `parseNerveConfig(yaml)` validates and parses `nerve.yaml` into `NerveConfig` (rejects reflex entries that declare a `workflow` key; reflexes only schedule senses)
+- **Sense → workflow routing** — `parseSenseWorkflowDirective`, `routeSenseComputeOutput`, and types `ParsedSenseWorkflowDirective`, `SenseComputeRoute`
 - **Daemon IPC protocol** — request/response types (`DaemonIpcRequest`, `DaemonIpcResponse`, …) and `parseDaemonIpcRequest` for newline-delimited JSON on the CLI ↔ daemon socket
-- **Workflow automaton types** — `START` / `END` sentinel constants, `WorkflowMessage`, `StartStep`, `RoleStep`, `ModeratorContext` (`start` + `steps`; empty `steps` on first moderator call), `Moderator` (single `context` argument), `WorkflowDefinition`, `Role`, `RoleResult`, plus `DEFAULT_ENGINE_MAX_ROUNDS`
+- **Workflow automaton types** — `START` / `END` sentinel constants, `WorkflowMessage`, `StartStep`, `RoleStep`, `ModeratorContext` (`start` + `steps`; empty `steps` on first moderator call), `Moderator` (single `context` argument), `WorkflowDefinition`, `Role`, `SenseResult`, plus `DEFAULT_ENGINE_MAX_ROUNDS`
 - **Result type** — `Result<T>` with `ok()` / `err()` helpers for explicit error handling (no thrown exceptions for parse paths)
 
 ## Usage
 
 ```typescript
 import { parseNerveConfig, ok, err } from "@uncaged/nerve-core";
-import type { NerveConfig, Result } from "@uncaged/nerve-core";
+import type { NerveConfig, Signal, Result } from "@uncaged/nerve-core";
 
 const result: Result<NerveConfig> = parseNerveConfig(yamlString);
 if (result.ok) {
@@ -23,19 +23,29 @@ if (result.ok) {
 }
 ```
 
-### Sense trigger validation
+### Sense return → signal vs workflow
 
 ```typescript
-import { parseSenseTrigger } from "@uncaged/nerve-core";
+import { parseSenseWorkflowDirective, routeSenseComputeOutput } from "@uncaged/nerve-core";
 
-const parsed = parseSenseTrigger({ command: "echo hello" });
-if (parsed.ok) {
-  console.log(parsed.value.command);
+const directive = parseSenseWorkflowDirective("my-workflow|8|Hello from sense");
+if (directive.ok) {
+  console.log(directive.value.workflowName, directive.value.maxRounds, directive.value.prompt);
+}
+
+const route = routeSenseComputeOutput({
+  metric: 42,
+  workflow: "my-workflow|8|Run now",
+});
+if (route.kind === "launch") {
+  // engine starts workflow; no Signal to the bus for this return
+  console.log(route.launch);
+} else {
+  // normal signal with payload
+  console.log(route.payload);
 }
 ```
 
-Sense modules return `{ state, trigger }` from `compute(state)`; when `trigger` is non-null it must be exactly `{ command: string }` (non-empty after trim). The daemon validates worker IPC with `parseSenseTrigger`. Workflows are started only via CLI / daemon IPC, not from this field.
-
 ## Duration Format
 
 Config fields like `throttle`, `timeout`, and `interval` accept human-readable durations:

packages/core/package.json

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

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

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 
-import { parseNerveConfig } from "../config.js";
+import { parseNerveConfig } from "../parse-nerve-config.js";
 
 const VALID_CONFIG = `
 senses:
@@ -34,6 +34,7 @@ describe("parseNerveConfig", () => {
         throttle: 5000,
         timeout: null,
         gracePeriod: null,
+        retention: 10_000,
         interval: 30_000,
         on: [],
       });
@@ -42,6 +43,7 @@ describe("parseNerveConfig", () => {
         throttle: null,
         timeout: 10_000,
         gracePeriod: 3000,
+        retention: 10_000,
         interval: null,
         on: ["high_usage"],
       });
@@ -81,11 +83,25 @@ senses:
         throttle: null,
         timeout: null,
         gracePeriod: null,
+        retention: 10_000,
         interval: null,
         on: [],
       });
     });
 
+    it("parses optional retention as a positive integer", () => {
+      const yaml = `
+senses:
+  cpu:
+    group: system
+    retention: 5000
+`;
+      const result = parseNerveConfig(yaml);
+      expect(result.ok).toBe(true);
+      if (!result.ok) return;
+      expect(result.value.senses.cpu.retention).toBe(5000);
+    });
+
     it("accepts all valid duration suffixes (s, m, h)", () => {
       const yaml = `
 senses:
@@ -327,6 +343,45 @@ api:
       expect(result.error.message).toMatch(/senses/);
     });
 
+    it("returns error when retention is zero", () => {
+      const yaml = `
+senses:
+  cpu:
+    group: system
+    retention: 0
+`;
+      const result = parseNerveConfig(yaml);
+      expect(result.ok).toBe(false);
+      if (result.ok) return;
+      expect(result.error.message).toMatch(/retention.*positive integer/);
+    });
+
+    it("returns error when retention is not an integer", () => {
+      const yaml = `
+senses:
+  cpu:
+    group: system
+    retention: 1.5
+`;
+      const result = parseNerveConfig(yaml);
+      expect(result.ok).toBe(false);
+      if (result.ok) return;
+      expect(result.error.message).toMatch(/retention.*positive integer/);
+    });
+
+    it("returns error when retention is not a number", () => {
+      const yaml = `
+senses:
+  cpu:
+    group: system
+    retention: "5000"
+`;
+      const result = parseNerveConfig(yaml);
+      expect(result.ok).toBe(false);
+      if (result.ok) return;
+      expect(result.error.message).toMatch(/retention.*positive integer/);
+    });
+
     it("returns error for invalid throttle format", () => {
       const yaml = `
 senses:

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

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 
-import { parseDaemonIpcRequest } from "../daemon.js";
+import { parseDaemonIpcRequest } from "../daemon-ipc-protocol.js";
 
 describe("parseDaemonIpcRequest", () => {
   it("parses trigger-workflow", () => {

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

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 
-import { parseKnowledgeYaml } from "../config.js";
+import { parseKnowledgeYaml } from "../knowledge-config.js";
 
 describe("parseKnowledgeYaml", () => {
   it("parses include and exclude glob lists", () => {

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

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

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

@@ -0,0 +1,116 @@
+import { describe, expect, it } from "vitest";
+
+import { parseWorkflowTrigger, routeSenseComputeOutput } from "../sense-workflow-directive.js";
+
+describe("parseWorkflowTrigger", () => {
+  it("accepts a valid trigger object", () => {
+    const r = parseWorkflowTrigger({
+      name: "my-wf",
+      maxRounds: 3,
+      prompt: "go",
+      dryRun: true,
+    });
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+    expect(r.value).toEqual({ name: "my-wf", maxRounds: 3, prompt: "go", dryRun: true });
+  });
+
+  it("trims workflow name", () => {
+    const r = parseWorkflowTrigger({
+      name: "  spaced  ",
+      maxRounds: 1,
+      prompt: "",
+      dryRun: false,
+    });
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+    expect(r.value.name).toBe("spaced");
+  });
+
+  it("rejects empty name", () => {
+    const r = parseWorkflowTrigger({ name: "", maxRounds: 1, prompt: "x", dryRun: false });
+    expect(r.ok).toBe(false);
+  });
+
+  it("rejects non-integer maxRounds", () => {
+    const r = parseWorkflowTrigger({
+      name: "w",
+      maxRounds: 1.5,
+      prompt: "",
+      dryRun: false,
+    });
+    expect(r.ok).toBe(false);
+  });
+
+  it("rejects maxRounds < 1", () => {
+    const r = parseWorkflowTrigger({ name: "w", maxRounds: 0, prompt: "", dryRun: false });
+    expect(r.ok).toBe(false);
+  });
+
+  it("rejects non-boolean dryRun", () => {
+    const r = parseWorkflowTrigger({
+      name: "w",
+      maxRounds: 1,
+      prompt: "",
+      dryRun: "no" as unknown as boolean,
+    });
+    expect(r.ok).toBe(false);
+  });
+});
+
+describe("routeSenseComputeOutput", () => {
+  it("wraps non-record values as signal-only", () => {
+    const r = routeSenseComputeOutput(99);
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+    expect(r.value).toEqual({ signal: 99, workflow: null });
+  });
+
+  it("wraps plain objects without signal key as signal-only", () => {
+    const r = routeSenseComputeOutput({ count: 2 });
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+    expect(r.value).toEqual({ signal: { count: 2 }, workflow: null });
+  });
+
+  it("parses explicit signal with null workflow", () => {
+    const r = routeSenseComputeOutput({ signal: { a: 1 }, workflow: null });
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+    expect(r.value).toEqual({ signal: { a: 1 }, workflow: null });
+  });
+
+  it("parses explicit signal with workflow trigger", () => {
+    const r = routeSenseComputeOutput({
+      signal: { x: true },
+      workflow: { name: "wf", maxRounds: 2, prompt: "p", dryRun: false },
+    });
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+    expect(r.value.signal).toEqual({ x: true });
+    expect(r.value.workflow).toEqual({
+      name: "wf",
+      maxRounds: 2,
+      prompt: "p",
+      dryRun: false,
+    });
+  });
+
+  it("defaults missing workflow key to null", () => {
+    const r = routeSenseComputeOutput({ signal: 7 });
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+    expect(r.value).toEqual({ signal: 7, workflow: null });
+  });
+
+  it("degrades to signal-only when workflow object is invalid", () => {
+    const r = routeSenseComputeOutput({
+      signal: { v: 1 },
+      workflow: { name: "w", maxRounds: 0, prompt: "", dryRun: false },
+    });
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+    expect(r.value.signal).toEqual({ v: 1 });
+    expect(r.value.workflow).toBeNull();
+  });
+});

packages/core/src/__tests__/spawn-safe.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 
-import { spawnSafe } from "../util.js";
+import { spawnSafe } from "../spawn-safe.js";
 
 describe("spawnSafe", () => {
   it("passes argv literally without shell interpretation (injection-safe)", async () => {

packages/core/src/agent-adapter-ids.ts

@@ -0,0 +1,5 @@
+/**
+ * Agent adapter ids referenced by tooling / docs (RFC-003).
+ * Workflows import adapter packages directly; echo may be used in tests via a small factory.
+ */
+export const KNOWN_AGENT_ADAPTER_IDS = ["echo", "cursor", "hermes", "codex"] as const;

packages/core/src/config.ts

@@ -1,24 +1,32 @@
-import { parse } from "yaml";
-
-import type { DropOverflowConfig, QueueOverflowConfig, WorkflowConfig } from "@uncaged/workflow";
-import { type Result, err, isPlainRecord, ok, parseDurationStringToMs } from "./util.js";
-
-export type { DropOverflowConfig, QueueOverflowConfig, WorkflowConfig };
-
-/** Engine-wide fallback when nerve.yaml omits max_rounds (keep in sync with workflow package default). */
-export const DEFAULT_ENGINE_MAX_ROUNDS = 100;
+/** Default max rows kept in each sense's `_signals` SQLite table (see `retention` on `SenseConfig`). */
+export const DEFAULT_SENSE_SIGNAL_RETENTION = 10_000;
 
 export type SenseConfig = {
   group: string;
   throttle: number | null;
   timeout: number | null;
   gracePeriod: number | null;
+  /** Max rows to retain in `_signals`; older rows are pruned periodically after inserts. */
+  retention: number;
   /** Polling interval (ms). When set, the sense is triggered periodically. */
   interval: number | null;
-  /** Other sense names whose successful computes schedule this sense (kernel reverse-index). */
+  /** Other sense names whose signals trigger this sense. */
   on: string[];
 };
 
+export type DropOverflowConfig = {
+  concurrency: number;
+  overflow: "drop";
+};
+
+export type QueueOverflowConfig = {
+  concurrency: number;
+  overflow: "queue";
+  maxQueue: number;
+};
+
+export type WorkflowConfig = DropOverflowConfig | QueueOverflowConfig;
+
 /** Optional HTTP control plane. When `port` is null, the HTTP server is not started. */
 export type NerveApiConfig = {
   port: number | null;
@@ -44,15 +52,20 @@ export type ExtractConfig = {
   model: string;
 };
 
-/**
- * Optional shell side effect after a successful sense `compute()`.
- * Executed in the sense worker (`spawn` with `shell: true`, cwd = nerve root).
- * Workflows are started only via CLI / daemon IPC, not from sense compute results.
- */
-export type SenseTrigger = {
-  command: string;
+/** Parameters for starting a workflow from a Sense compute result (or CLI trigger). */
+export type WorkflowTrigger = {
+  name: string;
+  maxRounds: number;
+  prompt: string;
+  dryRun: boolean;
 };
 
+/**
+ * Sense `compute()` return: silence, or a signal payload with an optional workflow to start.
+ * `workflow: null` means signal only; signal is always emitted first when non-null.
+ */
+export type ComputeResult<T> = null | { signal: T; workflow: WorkflowTrigger | null };
+
 export type NerveConfig = {
   /** Engine-wide default max moderator rounds (e.g. CLI workflow trigger when omitted). */
   maxRounds: number;
@@ -62,381 +75,3 @@ export type NerveConfig = {
   /** Global extract defaults; `null` when the section is omitted. */
   extract: ExtractConfig | null;
 };
-
-export type KnowledgeConfig = {
-  include: ReadonlyArray<string>;
-  exclude: ReadonlyArray<string>;
-};
-
-function isValidGroupName(value: string): boolean {
-  return /^[a-zA-Z0-9_-]+$/.test(value);
-}
-
-function parseDurationField(field: unknown, label: string): Result<number | null> {
-  if (field === undefined || field === null) return ok(null);
-  if (typeof field !== "string") {
-    return err(
-      new Error(`${label}: invalid duration "${field}" (expected e.g. "5s", "10m", "1h")`),
-    );
-  }
-  const msResult = parseDurationStringToMs(field);
-  if (!msResult.ok) {
-    return err(new Error(`${label}: ${msResult.error.message}`));
-  }
-  return ok(msResult.value);
-}
-
-function validateSenseConfig(name: string, raw: unknown): Result<SenseConfig> {
-  if (!isPlainRecord(raw)) {
-    return err(new Error(`senses.${name}: must be an object`));
-  }
-
-  const obj = raw;
-
-  if (typeof obj.group !== "string" || obj.group.trim() === "") {
-    return err(new Error(`senses.${name}.group: required string`));
-  }
-
-  if (!isValidGroupName(obj.group)) {
-    return err(
-      new Error(
-        `senses.${name}.group: invalid name "${obj.group}" (only alphanumeric, underscore, hyphen allowed)`,
-      ),
-    );
-  }
-
-  const throttleResult = parseDurationField(obj.throttle, `senses.${name}.throttle`);
-  if (!throttleResult.ok) return throttleResult;
-
-  const timeoutResult = parseDurationField(obj.timeout, `senses.${name}.timeout`);
-  if (!timeoutResult.ok) return timeoutResult;
-
-  const graceResult = parseDurationField(obj.grace_period, `senses.${name}.grace_period`);
-  if (!graceResult.ok) return graceResult;
-
-  const intervalResult = parseDurationField(obj.interval, `senses.${name}.interval`);
-  if (!intervalResult.ok) return intervalResult;
-
-  let on: string[] = [];
-  if (obj.on !== undefined && obj.on !== null) {
-    if (
-      !Array.isArray(obj.on) ||
-      !obj.on.every((item: unknown): item is string => typeof item === "string")
-    ) {
-      return err(new Error(`senses.${name}.on: must be an array of strings`));
-    }
-    on = obj.on;
-  }
-
-  return ok({
-    group: obj.group,
-    throttle: throttleResult.value,
-    timeout: timeoutResult.value,
-    gracePeriod: graceResult.value,
-    interval: intervalResult.value,
-    on,
-  });
-}
-
-function parseEngineMaxRounds(obj: Record<string, unknown>): Result<number> {
-  if (obj.max_rounds === undefined || obj.max_rounds === null) {
-    return ok(DEFAULT_ENGINE_MAX_ROUNDS);
-  }
-  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> {
-  if (!isPlainRecord(raw)) {
-    return err(new Error(`workflows.${name}: must be an object`));
-  }
-
-  const obj = raw;
-
-  if (
-    typeof obj.concurrency !== "number" ||
-    !Number.isInteger(obj.concurrency) ||
-    obj.concurrency < 1
-  ) {
-    return err(new Error(`workflows.${name}.concurrency: must be a positive integer`));
-  }
-
-  if (obj.overflow !== "drop" && obj.overflow !== "queue") {
-    return err(new Error(`workflows.${name}.overflow: must be "drop" or "queue"`));
-  }
-
-  if (obj.overflow === "drop") {
-    if (obj.max_queue !== undefined && obj.max_queue !== null) {
-      return err(new Error(`workflows.${name}: max_queue is not allowed with overflow "drop"`));
-    }
-    return ok({
-      concurrency: obj.concurrency,
-      overflow: "drop" as const,
-    });
-  }
-
-  // overflow: "queue"
-  let maxQueue = 100; // default
-  if (obj.max_queue !== undefined && obj.max_queue !== null) {
-    if (
-      typeof obj.max_queue !== "number" ||
-      !Number.isInteger(obj.max_queue) ||
-      obj.max_queue < 1
-    ) {
-      return err(new Error(`workflows.${name}.max_queue: must be a positive integer`));
-    }
-    maxQueue = obj.max_queue;
-  }
-
-  return ok({
-    concurrency: obj.concurrency,
-    overflow: "queue" as const,
-    maxQueue,
-  });
-}
-
-function parseSenses(
-  obj: Record<string, unknown>,
-): Result<{ senses: Record<string, SenseConfig> }> {
-  if (!isPlainRecord(obj.senses)) {
-    return err(new Error("senses: required object"));
-  }
-
-  const sensesRaw = obj.senses;
-  const senses: Record<string, SenseConfig> = {};
-
-  for (const [name, senseRaw] of Object.entries(sensesRaw)) {
-    const result = validateSenseConfig(name, senseRaw);
-    if (!result.ok) return result;
-    senses[name] = result.value;
-  }
-
-  return ok({ senses });
-}
-
-const DEFAULT_API_BIND_HOST = "127.0.0.1";
-
-/** Hosts that may bind the HTTP API without `api.token` (loopback-only). */
-function isLoopbackOnlyApiHost(host: string): boolean {
-  const h = host.trim();
-  return h === "127.0.0.1" || h.toLowerCase() === "localhost";
-}
-
-function parseApiTokenField(api: Record<string, unknown>): Result<string | null> {
-  if (api.token === undefined || api.token === null) {
-    return ok(null);
-  }
-  if (typeof api.token !== "string") {
-    return err(new Error("api.token: must be a string when provided"));
-  }
-  if (api.token.length === 0) {
-    return err(new Error("api.token: must not be empty when provided"));
-  }
-  return ok(api.token);
-}
-
-function parseApiHostField(api: Record<string, unknown>): Result<string> {
-  if (api.host === undefined || api.host === null) {
-    return ok(DEFAULT_API_BIND_HOST);
-  }
-  if (typeof api.host !== "string") {
-    return err(new Error("api.host: must be a string when provided"));
-  }
-  if (api.host.length === 0) {
-    return err(new Error("api.host: must not be empty when provided"));
-  }
-  return ok(api.host);
-}
-
-function parseApiConfig(obj: Record<string, unknown>): Result<NerveApiConfig> {
-  if (obj.api === undefined || obj.api === null) {
-    return ok({ port: null, token: null, host: DEFAULT_API_BIND_HOST });
-  }
-  if (!isPlainRecord(obj.api)) {
-    return err(new Error("api: must be an object if provided"));
-  }
-  const api = obj.api;
-  if (api.port === undefined || api.port === null) {
-    return ok({ port: null, token: null, host: DEFAULT_API_BIND_HOST });
-  }
-  if (
-    typeof api.port !== "number" ||
-    !Number.isInteger(api.port) ||
-    api.port < 1 ||
-    api.port > 65_535
-  ) {
-    return err(new Error("api.port: must be an integer between 1 and 65535 if provided"));
-  }
-
-  const tokenResult = parseApiTokenField(api);
-  if (!tokenResult.ok) return tokenResult;
-  const hostResult = parseApiHostField(api);
-  if (!hostResult.ok) return hostResult;
-
-  if (!isLoopbackOnlyApiHost(hostResult.value) && tokenResult.value === null) {
-    return err(
-      new Error("api.host binds to non-loopback address, api.token is required for security"),
-    );
-  }
-
-  return ok({ port: api.port, token: tokenResult.value, host: hostResult.value });
-}
-
-function parseWorkflows(obj: Record<string, unknown>): Result<Record<string, WorkflowConfig>> {
-  if (obj.workflows === undefined || obj.workflows === null) return ok({});
-
-  if (!isPlainRecord(obj.workflows)) {
-    return err(new Error("workflows: must be an object if provided"));
-  }
-
-  const workflowsRaw = obj.workflows;
-  const workflows: Record<string, WorkflowConfig> = {};
-
-  for (const [name, wfRaw] of Object.entries(workflowsRaw)) {
-    const result = validateWorkflowConfig(name, wfRaw);
-    if (!result.ok) return result;
-    workflows[name] = result.value;
-  }
-
-  return ok(workflows);
-}
-
-function parseExtract(obj: Record<string, unknown>): Result<ExtractConfig | null> {
-  if (obj.extract === undefined || obj.extract === null) {
-    return ok(null);
-  }
-
-  if (!isPlainRecord(obj.extract)) {
-    return err(new Error("extract: must be an object if provided"));
-  }
-
-  const ext = obj.extract;
-
-  if (typeof ext.provider !== "string" || ext.provider.trim() === "") {
-    return err(new Error("extract.provider: required non-empty string"));
-  }
-
-  if (typeof ext.model !== "string" || ext.model.trim() === "") {
-    return err(new Error("extract.model: required non-empty string"));
-  }
-
-  return ok({ provider: ext.provider, model: ext.model });
-}
-
-export function parseNerveConfig(raw: string): Result<NerveConfig> {
-  let parsed: unknown;
-
-  try {
-    parsed = parse(raw);
-  } catch (e) {
-    const message = e instanceof Error ? e.message : String(e);
-    return err(new Error(`YAML parse error: ${message}`));
-  }
-
-  if (!isPlainRecord(parsed)) {
-    return err(new Error("Config must be a YAML object"));
-  }
-
-  const obj = parsed;
-
-  const sensesResult = parseSenses(obj);
-  if (!sensesResult.ok) return sensesResult;
-  const { senses } = sensesResult.value;
-
-  // Legacy top-level `reflexes` is rejected; each sense carries `interval` / `on` for the sense scheduler.
-  if (Object.hasOwn(obj, "reflexes")) {
-    return err(
-      new Error(
-        "reflexes: top-level key is no longer supported; set `interval` and `on` on each sense under `senses.<name>`",
-      ),
-    );
-  }
-
-  const workflowsResult = parseWorkflows(obj);
-  if (!workflowsResult.ok) return workflowsResult;
-
-  const maxRoundsResult = parseEngineMaxRounds(obj);
-  if (!maxRoundsResult.ok) return maxRoundsResult;
-
-  const apiResult = parseApiConfig(obj);
-  if (!apiResult.ok) return apiResult;
-
-  if (Object.hasOwn(obj, "agents")) {
-    return err(
-      new Error(
-        "agents: key is no longer supported — declare adapters on workflow roles (RFC-003)",
-      ),
-    );
-  }
-
-  const extractResult = parseExtract(obj);
-  if (!extractResult.ok) return extractResult;
-
-  return ok({
-    maxRounds: maxRoundsResult.value,
-    senses,
-    workflows: workflowsResult.value,
-    api: apiResult.value,
-    extract: extractResult.value,
-  });
-}
-
-function parseStringList(field: unknown, label: string): Result<ReadonlyArray<string>> {
-  if (field === undefined || field === null) {
-    return ok([]);
-  }
-  if (!Array.isArray(field)) {
-    return err(new Error(`${label}: must be an array of strings`));
-  }
-  const out: string[] = [];
-  for (let i = 0; i < field.length; i++) {
-    const item = field[i];
-    if (typeof item !== "string" || item.length === 0) {
-      return err(new Error(`${label}[${String(i)}]: must be a non-empty string`));
-    }
-    out.push(item);
-  }
-  return ok(out);
-}
-
-/**
- * Parse `knowledge.yaml` at the repo root (RFC-003 Knowledge Layer).
- * `include` / `exclude` entries are glob patterns resolved against the repo root.
- */
-export function parseKnowledgeYaml(raw: string): Result<KnowledgeConfig> {
-  let parsed: unknown;
-  try {
-    parsed = parse(raw);
-  } catch (e) {
-    const message = e instanceof Error ? e.message : String(e);
-    return err(new Error(`YAML parse error: ${message}`));
-  }
-
-  if (parsed === undefined || parsed === null) {
-    return ok({ include: [], exclude: [] });
-  }
-
-  if (!isPlainRecord(parsed)) {
-    return err(new Error("knowledge.yaml: root must be a mapping"));
-  }
-
-  const includeResult = parseStringList(parsed.include, "include");
-  if (!includeResult.ok) {
-    return includeResult;
-  }
-  const excludeResult = parseStringList(parsed.exclude, "exclude");
-  if (!excludeResult.ok) {
-    return excludeResult;
-  }
-
-  return ok({
-    include: includeResult.value,
-    exclude: excludeResult.value,
-  });
-}

packages/core/src/daemon-ipc-protocol.ts

@@ -4,8 +4,8 @@
  * one response object per line from the daemon.
  */
 
+import { isPlainRecord } from "./is-plain-record.js";
 import type { SenseInfo } from "./sense.js";
-import { isPlainRecord } from "./util.js";
 
 /** Runtime status of a registered workflow (for listing / observability). */
 export type WorkflowStatus = {
@@ -100,32 +100,6 @@ export type DaemonIpcResponse =
   | DaemonIpcListWorkflowsResponse
   | DaemonIpcHealthResponse;
 
-export type DaemonTransportTriggerResult = { ok: true } | { ok: false; error: string };
-
-export type DaemonTransportWorkflowLaunch = {
-  prompt: string;
-  maxRounds: number;
-  dryRun: boolean;
-};
-
-/**
- * Abstraction over daemon control plane (Unix socket IPC today, HTTP in Phase 2).
- * Implementations live in CLI / tools; the daemon kernel uses shared handler logic.
- */
-export type DaemonTransport = {
-  health(): Promise<HealthInfo>;
-  listSenses(): Promise<SenseInfo[]>;
-  listWorkflows(): Promise<WorkflowStatus[]>;
-  triggerSense(name: string): Promise<DaemonTransportTriggerResult>;
-  /** When `launch` is null, implementations use engine defaults (empty prompt, default max rounds, dryRun false). */
-  triggerWorkflow(
-    name: string,
-    launch: DaemonTransportWorkflowLaunch | null,
-  ): Promise<DaemonTransportTriggerResult>;
-  /** Kill a running or queued workflow thread by `runId` (same field as IPC `kill-workflow`). */
-  killWorkflow(runId: string): Promise<DaemonTransportTriggerResult>;
-};
-
 function parseTriggerWorkflowFields(
   req: Record<string, unknown>,
 ): DaemonIpcTriggerWorkflowRequest | null {
@@ -176,32 +150,3 @@ export function parseDaemonIpcRequest(line: string): DaemonIpcRequest | null {
     return null;
   }
 }
-
-/** Type guard for JSON {@link SenseInfo} payloads from daemon HTTP/IPC. */
-export function isSenseInfo(value: unknown): value is SenseInfo {
-  if (!isPlainRecord(value)) return false;
-  return (
-    typeof value.name === "string" &&
-    typeof value.group === "string" &&
-    (value.throttle === null || typeof value.throttle === "number") &&
-    (value.timeout === null || typeof value.timeout === "number") &&
-    Array.isArray(value.triggers) &&
-    value.triggers.every((t: unknown) => typeof t === "string")
-  );
-}
-
-/** Type guard for JSON {@link WorkflowStatus} payloads from daemon HTTP/IPC. */
-export function isWorkflowStatus(value: unknown): value is WorkflowStatus {
-  if (!isPlainRecord(value)) return false;
-  const cfg = value.config;
-  if (!isPlainRecord(cfg)) return false;
-  return (
-    typeof value.name === "string" &&
-    typeof value.activeThreads === "number" &&
-    Array.isArray(value.activeRunIds) &&
-    value.activeRunIds.every((id: unknown) => typeof id === "string") &&
-    typeof value.queuedThreads === "number" &&
-    typeof cfg.concurrency === "number" &&
-    typeof cfg.overflow === "string"
-  );
-}

packages/core/src/daemon-payload-guards.ts

@@ -0,0 +1,33 @@
+import type { WorkflowStatus } from "./daemon-ipc-protocol.js";
+import { isPlainRecord } from "./is-plain-record.js";
+import type { SenseInfo } from "./sense.js";
+
+/** Type guard for JSON {@link SenseInfo} payloads from daemon HTTP/IPC. */
+export function isSenseInfo(value: unknown): value is SenseInfo {
+  if (!isPlainRecord(value)) return false;
+  return (
+    typeof value.name === "string" &&
+    typeof value.group === "string" &&
+    (value.throttle === null || typeof value.throttle === "number") &&
+    (value.timeout === null || typeof value.timeout === "number") &&
+    Array.isArray(value.triggers) &&
+    value.triggers.every((t: unknown) => typeof t === "string") &&
+    (value.lastSignalTimestamp === null || typeof value.lastSignalTimestamp === "number")
+  );
+}
+
+/** Type guard for JSON {@link WorkflowStatus} payloads from daemon HTTP/IPC. */
+export function isWorkflowStatus(value: unknown): value is WorkflowStatus {
+  if (!isPlainRecord(value)) return false;
+  const cfg = value.config;
+  if (!isPlainRecord(cfg)) return false;
+  return (
+    typeof value.name === "string" &&
+    typeof value.activeThreads === "number" &&
+    Array.isArray(value.activeRunIds) &&
+    value.activeRunIds.every((id: unknown) => typeof id === "string") &&
+    typeof value.queuedThreads === "number" &&
+    typeof cfg.concurrency === "number" &&
+    typeof cfg.overflow === "string"
+  );
+}

packages/core/src/daemon-transport.ts

@@ -0,0 +1,28 @@
+import type { HealthInfo, WorkflowStatus } from "./daemon-ipc-protocol.js";
+import type { SenseInfo } from "./sense.js";
+
+export type DaemonTransportTriggerResult = { ok: true } | { ok: false; error: string };
+
+export type DaemonTransportWorkflowLaunch = {
+  prompt: string;
+  maxRounds: number;
+  dryRun: boolean;
+};
+
+/**
+ * Abstraction over daemon control plane (Unix socket IPC today, HTTP in Phase 2).
+ * Implementations live in CLI / tools; the daemon kernel uses shared handler logic.
+ */
+export type DaemonTransport = {
+  health(): Promise<HealthInfo>;
+  listSenses(): Promise<SenseInfo[]>;
+  listWorkflows(): Promise<WorkflowStatus[]>;
+  triggerSense(name: string): Promise<DaemonTransportTriggerResult>;
+  /** When `launch` is null, implementations use engine defaults (empty prompt, default max rounds, dryRun false). */
+  triggerWorkflow(
+    name: string,
+    launch: DaemonTransportWorkflowLaunch | null,
+  ): Promise<DaemonTransportTriggerResult>;
+  /** Kill a running or queued workflow thread by `runId` (same field as IPC `kill-workflow`). */
+  killWorkflow(runId: string): Promise<DaemonTransportTriggerResult>;
+};

packages/core/src/duration.ts

@@ -0,0 +1,22 @@
+import type { Result } from "./result.js";
+import { err, ok } from "./result.js";
+
+const DURATION_RE = /^(\d+)([smh])$/;
+
+const DURATION_MULTIPLIERS: Record<string, number> = {
+  s: 1_000,
+  m: 60_000,
+  h: 3_600_000,
+};
+
+/**
+ * Parse a duration string such as `5s`, `10m`, `1h` to milliseconds.
+ * Used by `parseNerveConfig` sense/workflow duration fields.
+ */
+export function parseDurationStringToMs(value: string): Result<number> {
+  const match = DURATION_RE.exec(value);
+  if (!match) {
+    return err(new Error(`invalid duration "${value}" (expected e.g. "5s", "10m", "1h")`));
+  }
+  return ok(Number(match[1]) * DURATION_MULTIPLIERS[match[2]]);
+}

packages/core/src/index.ts

@@ -1,18 +1,38 @@
+export { DEFAULT_SENSE_SIGNAL_RETENTION } from "./config.js";
 export type {
   SenseConfig,
+  DropOverflowConfig,
+  QueueOverflowConfig,
+  WorkflowConfig,
   NerveApiConfig,
   AgentConfig,
   ExtractConfig,
   NerveConfig,
-  SenseTrigger,
+  WorkflowTrigger,
+  ComputeResult,
 } from "./config.js";
-export type { SenseInfo } from "./sense.js";
-export type { SenseComputeFn, SenseModule } from "./sense.js";
-export { senseTriggerLabels } from "./sense.js";
-export type { Schema, ExtractFn } from "./agent.js";
-export { ExtractError } from "./agent.js";
-export type { Result } from "./util.js";
-export { ok, err } from "./util.js";
+export type { Signal, SenseInfo } from "./sense.js";
+export { labelSenseTrigger, senseTriggerLabels } from "./sense-trigger-labels.js";
+export type {
+  WorkflowMessage,
+  RoleResult,
+  Role,
+  RoleMeta,
+  StartStep,
+  WorkflowContext,
+  AgentFn,
+  RoleStep,
+  ModeratorContext,
+  Moderator,
+  WorkflowDefinition,
+} from "./workflow.js";
+export { START, END, DEFAULT_ENGINE_MAX_ROUNDS } from "./workflow.js";
+export type { PromptInput, RoleSpec, WorkflowSpec } from "./workflow-spec.js";
+export { parseDurationStringToMs } from "./duration.js";
+export type { Schema, ExtractFn } from "./extract-layer.js";
+export { ExtractError } from "./extract-layer.js";
+export type { Result } from "./result.js";
+export { ok, err } from "./result.js";
 export {
   nerveCommandEnv,
   spawnSafe,
@@ -20,15 +40,17 @@ export {
   type SpawnError,
   type SpawnResult,
   type SpawnSafeOptions,
-} from "./util.js";
-export { parseNerveConfig } from "./config.js";
-export type { KnowledgeConfig } from "./config.js";
-export { parseKnowledgeYaml } from "./config.js";
-export { isPlainRecord } from "./util.js";
+} from "./spawn-safe.js";
+export { parseNerveConfig } from "./parse-nerve-config.js";
+export type { KnowledgeConfig } from "./knowledge-config.js";
+export { parseKnowledgeYaml } from "./knowledge-config.js";
+export { isPlainRecord } from "./is-plain-record.js";
+export { KNOWN_AGENT_ADAPTER_IDS } from "./agent-adapter-ids.js";
 
-export { parseSenseTrigger } from "./sense.js";
+export type { RoutedSenseOutput } from "./sense-workflow-directive.js";
+export { parseWorkflowTrigger, routeSenseComputeOutput } from "./sense-workflow-directive.js";
 
-export { isSenseInfo, isWorkflowStatus } from "./daemon.js";
+export { isSenseInfo, isWorkflowStatus } from "./daemon-payload-guards.js";
 export type {
   WorkflowStatus,
   HealthInfo,
@@ -46,10 +68,10 @@ export type {
   DaemonIpcListWorkflowsResponse,
   DaemonIpcHealthResponse,
   DaemonIpcResponse,
-} from "./daemon.js";
-export { parseDaemonIpcRequest } from "./daemon.js";
+} from "./daemon-ipc-protocol.js";
+export { parseDaemonIpcRequest } from "./daemon-ipc-protocol.js";
 export type {
   DaemonTransport,
   DaemonTransportTriggerResult,
   DaemonTransportWorkflowLaunch,
-} from "./daemon.js";
+} from "./daemon-transport.js";

packages/core/src/is-plain-record.ts

@@ -0,0 +1,7 @@
+/**
+ * Narrows `unknown` to a plain JSON-style object (not null, not array).
+ * Use after `JSON.parse` / YAML / IPC when validating structure field-by-field.
+ */
+export function isPlainRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

packages/core/src/knowledge-config.ts

@@ -0,0 +1,64 @@
+import { parse } from "yaml";
+
+import { isPlainRecord } from "./is-plain-record.js";
+import type { Result } from "./result.js";
+import { err, ok } from "./result.js";
+
+export type KnowledgeConfig = {
+  include: ReadonlyArray<string>;
+  exclude: ReadonlyArray<string>;
+};
+
+function parseStringList(field: unknown, label: string): Result<ReadonlyArray<string>> {
+  if (field === undefined || field === null) {
+    return ok([]);
+  }
+  if (!Array.isArray(field)) {
+    return err(new Error(`${label}: must be an array of strings`));
+  }
+  const out: string[] = [];
+  for (let i = 0; i < field.length; i++) {
+    const item = field[i];
+    if (typeof item !== "string" || item.length === 0) {
+      return err(new Error(`${label}[${String(i)}]: must be a non-empty string`));
+    }
+    out.push(item);
+  }
+  return ok(out);
+}
+
+/**
+ * Parse `knowledge.yaml` at the repo root (RFC-003 Knowledge Layer).
+ * `include` / `exclude` entries are glob patterns resolved against the repo root.
+ */
+export function parseKnowledgeYaml(raw: string): Result<KnowledgeConfig> {
+  let parsed: unknown;
+  try {
+    parsed = parse(raw);
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    return err(new Error(`YAML parse error: ${message}`));
+  }
+
+  if (parsed === undefined || parsed === null) {
+    return ok({ include: [], exclude: [] });
+  }
+
+  if (!isPlainRecord(parsed)) {
+    return err(new Error("knowledge.yaml: root must be a mapping"));
+  }
+
+  const includeResult = parseStringList(parsed.include, "include");
+  if (!includeResult.ok) {
+    return includeResult;
+  }
+  const excludeResult = parseStringList(parsed.exclude, "exclude");
+  if (!excludeResult.ok) {
+    return excludeResult;
+  }
+
+  return ok({
+    include: includeResult.value,
+    exclude: excludeResult.value,
+  });
+}

packages/core/src/parse-nerve-config.ts

@@ -0,0 +1,348 @@
+import { parse } from "yaml";
+
+import {
+  DEFAULT_SENSE_SIGNAL_RETENTION,
+  type ExtractConfig,
+  type NerveApiConfig,
+  type NerveConfig,
+  type SenseConfig,
+  type WorkflowConfig,
+} from "./config.js";
+import { parseDurationStringToMs } from "./duration.js";
+import { isPlainRecord } from "./is-plain-record.js";
+import type { Result } from "./result.js";
+import { err, ok } from "./result.js";
+import { DEFAULT_ENGINE_MAX_ROUNDS } from "./workflow.js";
+
+function isValidGroupName(value: string): boolean {
+  return /^[a-zA-Z0-9_-]+$/.test(value);
+}
+
+function parseRetentionField(name: string, field: unknown): Result<number> {
+  if (field === undefined || field === null) {
+    return ok(DEFAULT_SENSE_SIGNAL_RETENTION);
+  }
+  if (typeof field !== "number" || !Number.isInteger(field) || field < 1) {
+    return err(new Error(`senses.${name}.retention: must be a positive integer`));
+  }
+  return ok(field);
+}
+
+function parseDurationField(field: unknown, label: string): Result<number | null> {
+  if (field === undefined || field === null) return ok(null);
+  if (typeof field !== "string") {
+    return err(
+      new Error(`${label}: invalid duration "${field}" (expected e.g. "5s", "10m", "1h")`),
+    );
+  }
+  const msResult = parseDurationStringToMs(field);
+  if (!msResult.ok) {
+    return err(new Error(`${label}: ${msResult.error.message}`));
+  }
+  return ok(msResult.value);
+}
+
+function validateSenseConfig(name: string, raw: unknown): Result<SenseConfig> {
+  if (!isPlainRecord(raw)) {
+    return err(new Error(`senses.${name}: must be an object`));
+  }
+
+  const obj = raw;
+
+  if (typeof obj.group !== "string" || obj.group.trim() === "") {
+    return err(new Error(`senses.${name}.group: required string`));
+  }
+
+  if (!isValidGroupName(obj.group)) {
+    return err(
+      new Error(
+        `senses.${name}.group: invalid name "${obj.group}" (only alphanumeric, underscore, hyphen allowed)`,
+      ),
+    );
+  }
+
+  const throttleResult = parseDurationField(obj.throttle, `senses.${name}.throttle`);
+  if (!throttleResult.ok) return throttleResult;
+
+  const timeoutResult = parseDurationField(obj.timeout, `senses.${name}.timeout`);
+  if (!timeoutResult.ok) return timeoutResult;
+
+  const graceResult = parseDurationField(obj.grace_period, `senses.${name}.grace_period`);
+  if (!graceResult.ok) return graceResult;
+
+  const retentionResult = parseRetentionField(name, obj.retention);
+  if (!retentionResult.ok) return retentionResult;
+
+  const intervalResult = parseDurationField(obj.interval, `senses.${name}.interval`);
+  if (!intervalResult.ok) return intervalResult;
+
+  let on: string[] = [];
+  if (obj.on !== undefined && obj.on !== null) {
+    if (
+      !Array.isArray(obj.on) ||
+      !obj.on.every((item: unknown): item is string => typeof item === "string")
+    ) {
+      return err(new Error(`senses.${name}.on: must be an array of strings`));
+    }
+    on = obj.on;
+  }
+
+  return ok({
+    group: obj.group,
+    throttle: throttleResult.value,
+    timeout: timeoutResult.value,
+    gracePeriod: graceResult.value,
+    retention: retentionResult.value,
+    interval: intervalResult.value,
+    on,
+  });
+}
+
+function parseEngineMaxRounds(obj: Record<string, unknown>): Result<number> {
+  if (obj.max_rounds === undefined || obj.max_rounds === null) {
+    return ok(DEFAULT_ENGINE_MAX_ROUNDS);
+  }
+  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> {
+  if (!isPlainRecord(raw)) {
+    return err(new Error(`workflows.${name}: must be an object`));
+  }
+
+  const obj = raw;
+
+  if (
+    typeof obj.concurrency !== "number" ||
+    !Number.isInteger(obj.concurrency) ||
+    obj.concurrency < 1
+  ) {
+    return err(new Error(`workflows.${name}.concurrency: must be a positive integer`));
+  }
+
+  if (obj.overflow !== "drop" && obj.overflow !== "queue") {
+    return err(new Error(`workflows.${name}.overflow: must be "drop" or "queue"`));
+  }
+
+  if (obj.overflow === "drop") {
+    if (obj.max_queue !== undefined && obj.max_queue !== null) {
+      return err(new Error(`workflows.${name}: max_queue is not allowed with overflow "drop"`));
+    }
+    return ok({
+      concurrency: obj.concurrency,
+      overflow: "drop" as const,
+    });
+  }
+
+  // overflow: "queue"
+  let maxQueue = 100; // default
+  if (obj.max_queue !== undefined && obj.max_queue !== null) {
+    if (
+      typeof obj.max_queue !== "number" ||
+      !Number.isInteger(obj.max_queue) ||
+      obj.max_queue < 1
+    ) {
+      return err(new Error(`workflows.${name}.max_queue: must be a positive integer`));
+    }
+    maxQueue = obj.max_queue;
+  }
+
+  return ok({
+    concurrency: obj.concurrency,
+    overflow: "queue" as const,
+    maxQueue,
+  });
+}
+
+function parseSenses(
+  obj: Record<string, unknown>,
+): Result<{ senses: Record<string, SenseConfig> }> {
+  if (!isPlainRecord(obj.senses)) {
+    return err(new Error("senses: required object"));
+  }
+
+  const sensesRaw = obj.senses;
+  const senses: Record<string, SenseConfig> = {};
+
+  for (const [name, senseRaw] of Object.entries(sensesRaw)) {
+    const result = validateSenseConfig(name, senseRaw);
+    if (!result.ok) return result;
+    senses[name] = result.value;
+  }
+
+  return ok({ senses });
+}
+
+const DEFAULT_API_BIND_HOST = "127.0.0.1";
+
+/** Hosts that may bind the HTTP API without `api.token` (loopback-only). */
+function isLoopbackOnlyApiHost(host: string): boolean {
+  const h = host.trim();
+  return h === "127.0.0.1" || h.toLowerCase() === "localhost";
+}
+
+function parseApiTokenField(api: Record<string, unknown>): Result<string | null> {
+  if (api.token === undefined || api.token === null) {
+    return ok(null);
+  }
+  if (typeof api.token !== "string") {
+    return err(new Error("api.token: must be a string when provided"));
+  }
+  if (api.token.length === 0) {
+    return err(new Error("api.token: must not be empty when provided"));
+  }
+  return ok(api.token);
+}
+
+function parseApiHostField(api: Record<string, unknown>): Result<string> {
+  if (api.host === undefined || api.host === null) {
+    return ok(DEFAULT_API_BIND_HOST);
+  }
+  if (typeof api.host !== "string") {
+    return err(new Error("api.host: must be a string when provided"));
+  }
+  if (api.host.length === 0) {
+    return err(new Error("api.host: must not be empty when provided"));
+  }
+  return ok(api.host);
+}
+
+function parseApiConfig(obj: Record<string, unknown>): Result<NerveApiConfig> {
+  if (obj.api === undefined || obj.api === null) {
+    return ok({ port: null, token: null, host: DEFAULT_API_BIND_HOST });
+  }
+  if (!isPlainRecord(obj.api)) {
+    return err(new Error("api: must be an object if provided"));
+  }
+  const api = obj.api;
+  if (api.port === undefined || api.port === null) {
+    return ok({ port: null, token: null, host: DEFAULT_API_BIND_HOST });
+  }
+  if (
+    typeof api.port !== "number" ||
+    !Number.isInteger(api.port) ||
+    api.port < 1 ||
+    api.port > 65_535
+  ) {
+    return err(new Error("api.port: must be an integer between 1 and 65535 if provided"));
+  }
+
+  const tokenResult = parseApiTokenField(api);
+  if (!tokenResult.ok) return tokenResult;
+  const hostResult = parseApiHostField(api);
+  if (!hostResult.ok) return hostResult;
+
+  if (!isLoopbackOnlyApiHost(hostResult.value) && tokenResult.value === null) {
+    return err(
+      new Error("api.host binds to non-loopback address, api.token is required for security"),
+    );
+  }
+
+  return ok({ port: api.port, token: tokenResult.value, host: hostResult.value });
+}
+
+function parseWorkflows(obj: Record<string, unknown>): Result<Record<string, WorkflowConfig>> {
+  if (obj.workflows === undefined || obj.workflows === null) return ok({});
+
+  if (!isPlainRecord(obj.workflows)) {
+    return err(new Error("workflows: must be an object if provided"));
+  }
+
+  const workflowsRaw = obj.workflows;
+  const workflows: Record<string, WorkflowConfig> = {};
+
+  for (const [name, wfRaw] of Object.entries(workflowsRaw)) {
+    const result = validateWorkflowConfig(name, wfRaw);
+    if (!result.ok) return result;
+    workflows[name] = result.value;
+  }
+
+  return ok(workflows);
+}
+
+function parseExtract(obj: Record<string, unknown>): Result<ExtractConfig | null> {
+  if (obj.extract === undefined || obj.extract === null) {
+    return ok(null);
+  }
+
+  if (!isPlainRecord(obj.extract)) {
+    return err(new Error("extract: must be an object if provided"));
+  }
+
+  const ext = obj.extract;
+
+  if (typeof ext.provider !== "string" || ext.provider.trim() === "") {
+    return err(new Error("extract.provider: required non-empty string"));
+  }
+
+  if (typeof ext.model !== "string" || ext.model.trim() === "") {
+    return err(new Error("extract.model: required non-empty string"));
+  }
+
+  return ok({ provider: ext.provider, model: ext.model });
+}
+
+export function parseNerveConfig(raw: string): Result<NerveConfig> {
+  let parsed: unknown;
+
+  try {
+    parsed = parse(raw);
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    return err(new Error(`YAML parse error: ${message}`));
+  }
+
+  if (!isPlainRecord(parsed)) {
+    return err(new Error("Config must be a YAML object"));
+  }
+
+  const obj = parsed;
+
+  const sensesResult = parseSenses(obj);
+  if (!sensesResult.ok) return sensesResult;
+  const { senses } = sensesResult.value;
+
+  // Legacy top-level `reflexes` is rejected; each sense carries `interval` / `on` for the sense scheduler.
+  if (Object.hasOwn(obj, "reflexes")) {
+    return err(
+      new Error(
+        "reflexes: top-level key is no longer supported; set `interval` and `on` on each sense under `senses.<name>`",
+      ),
+    );
+  }
+
+  const workflowsResult = parseWorkflows(obj);
+  if (!workflowsResult.ok) return workflowsResult;
+
+  const maxRoundsResult = parseEngineMaxRounds(obj);
+  if (!maxRoundsResult.ok) return maxRoundsResult;
+
+  const apiResult = parseApiConfig(obj);
+  if (!apiResult.ok) return apiResult;
+
+  if (Object.hasOwn(obj, "agents")) {
+    return err(
+      new Error(
+        "agents: key is no longer supported — declare adapters on WorkflowSpec roles (RFC-003)",
+      ),
+    );
+  }
+
+  const extractResult = parseExtract(obj);
+  if (!extractResult.ok) return extractResult;
+
+  return ok({
+    maxRounds: maxRoundsResult.value,
+    senses,
+    workflows: workflowsResult.value,
+    api: apiResult.value,
+    extract: extractResult.value,
+  });
+}

packages/core/src/result.ts

@@ -0,0 +1,9 @@
+export type Result<T, E = Error> = { ok: true; value: T } | { ok: false; error: E };
+
+export function ok<T>(value: T): Result<T, never> {
+  return { ok: true, value };
+}
+
+export function err<E = Error>(error: E): Result<never, E> {
+  return { ok: false, error };
+}

packages/core/src/sense-trigger-labels.ts

@@ -0,0 +1,40 @@
+import type { SenseConfig } from "./config.js";
+
+function formatIntervalMs(ms: number): string {
+  const totalSeconds = Math.floor(ms / 1000);
+  if (totalSeconds < 60) return `${totalSeconds}s`;
+  const minutes = Math.floor(totalSeconds / 60);
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  return `${hours}h ${remainingMinutes}m`;
+}
+
+/** Human-readable label for a sense schedule (`interval` and/or `on`). */
+export function labelSenseTrigger(slice: Pick<SenseConfig, "interval" | "on">): string {
+  const parts: string[] = [];
+  if (slice.interval !== null) {
+    parts.push(`every ${formatIntervalMs(slice.interval)}`);
+  }
+  if (slice.on.length > 0) {
+    parts.push(`on: ${slice.on.join(", ")}`);
+  }
+  if (parts.length === 0) {
+    return "trigger (no interval or on)";
+  }
+  return parts.join(" · ");
+}
+
+/**
+ * Human-readable trigger labels for a sense from its `SenseConfig.interval` / `.on`.
+ * Returns an empty array when the sense is missing or has no schedule.
+ */
+export function senseTriggerLabels(
+  senseName: string,
+  senses: Record<string, SenseConfig>,
+): string[] {
+  const sc = senses[senseName];
+  if (sc === undefined) return [];
+  if (sc.interval === null && sc.on.length === 0) return [];
+  return [labelSenseTrigger({ interval: sc.interval, on: sc.on })];
+}

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

@@ -0,0 +1,56 @@
+import type { WorkflowTrigger } from "./config.js";
+import { isPlainRecord } from "./is-plain-record.js";
+import type { Result } from "./result.js";
+import { err, ok } from "./result.js";
+
+/** Normalized non-null compute output for the kernel (unknown signal payload). */
+export type RoutedSenseOutput = {
+  signal: unknown;
+  workflow: WorkflowTrigger | null;
+};
+
+/**
+ * Validates a structured workflow trigger object from Sense compute or IPC.
+ */
+export function parseWorkflowTrigger(value: unknown): Result<WorkflowTrigger> {
+  if (!isPlainRecord(value)) {
+    return err(new Error("workflow trigger must be a plain object"));
+  }
+  const nameRaw = value.name;
+  if (typeof nameRaw !== "string" || nameRaw.trim().length === 0) {
+    return err(new Error('workflow trigger: "name" must be a non-empty string'));
+  }
+  const maxRounds = value.maxRounds;
+  if (typeof maxRounds !== "number" || !Number.isInteger(maxRounds) || maxRounds < 1) {
+    return err(new Error('workflow trigger: "maxRounds" must be an integer >= 1'));
+  }
+  const prompt = value.prompt;
+  if (typeof prompt !== "string") {
+    return err(new Error('workflow trigger: "prompt" must be a string'));
+  }
+  const dryRun = value.dryRun;
+  if (typeof dryRun !== "boolean") {
+    return err(new Error('workflow trigger: "dryRun" must be a boolean'));
+  }
+  return ok({ name: nameRaw.trim(), maxRounds, prompt, dryRun });
+}
+
+/**
+ * Interprets a Sense compute non-null return value for the engine.
+ * - Explicit `{ signal, workflow }` (workflow may be null): validates `workflow` when non-null.
+ * - Any other value: treated as `{ signal: payload, workflow: null }` (shorthand).
+ */
+export function routeSenseComputeOutput(payload: unknown): Result<RoutedSenseOutput> {
+  if (isPlainRecord(payload) && Object.hasOwn(payload, "signal")) {
+    const wfRaw = Object.hasOwn(payload, "workflow") ? payload.workflow : null;
+    if (wfRaw === null) {
+      return ok({ signal: payload.signal, workflow: null });
+    }
+    const parsed = parseWorkflowTrigger(wfRaw);
+    if (!parsed.ok) {
+      return ok({ signal: payload.signal, workflow: null });
+    }
+    return ok({ signal: payload.signal, workflow: parsed.value });
+  }
+  return ok({ signal: payload, workflow: null });
+}

packages/core/src/sense.ts

@@ -1,5 +1,9 @@
-import type { SenseConfig, SenseTrigger } from "./config.js";
-import { type Result, err, isPlainRecord, ok } from "./util.js";
+export type Signal = {
+  id: number;
+  senseId: string;
+  payload: unknown;
+  timestamp: number;
+};
 
 /** Runtime metadata for a sense (e.g. daemon list-senses IPC). */
 export type SenseInfo = {
@@ -8,80 +12,6 @@ export type SenseInfo = {
   throttle: number | null;
   timeout: number | null;
   /** Declarative schedule (`interval` / `on`) for this sense (derived from nerve.yaml). */
-  triggers: ReadonlyArray<string>;
+  triggers: string[];
+  lastSignalTimestamp: number | null;
 };
-
-/**
- * The function signature every sense `src/index.ts` must export as a named
- * `compute` export.
- *
- * Pure: no DB, no peers.
- * Returns the next sense state and an optional trigger (`trigger: null` means no side effect).
- */
-export type SenseComputeFn<S = unknown> = (
-  state: S,
-) => Promise<{ state: S; trigger: SenseTrigger | null }>;
-
-/**
- * The full shape a sense module (`src/index.ts`) must export.
- */
-export type SenseModule<S = unknown> = {
-  compute: SenseComputeFn<S>;
-  initialState: S;
-};
-
-function formatIntervalMs(ms: number): string {
-  const totalSeconds = Math.floor(ms / 1000);
-  if (totalSeconds < 60) return `${totalSeconds}s`;
-  const minutes = Math.floor(totalSeconds / 60);
-  if (minutes < 60) return `${minutes}m`;
-  const hours = Math.floor(minutes / 60);
-  const remainingMinutes = minutes % 60;
-  return `${hours}h ${remainingMinutes}m`;
-}
-
-/** Human-readable label for a sense schedule (`interval` and/or `on`). */
-export function labelSenseTrigger(slice: Pick<SenseConfig, "interval" | "on">): string {
-  const parts: string[] = [];
-  if (slice.interval !== null) {
-    parts.push(`every ${formatIntervalMs(slice.interval)}`);
-  }
-  if (slice.on.length > 0) {
-    parts.push(`on: ${slice.on.join(", ")}`);
-  }
-  if (parts.length === 0) {
-    return "trigger (no interval or on)";
-  }
-  return parts.join(" · ");
-}
-
-/**
- * Human-readable trigger labels for a sense from its `SenseConfig.interval` / `.on`.
- * Returns an empty array when the sense is missing or has no schedule.
- */
-export function senseTriggerLabels(
-  senseName: string,
-  senses: Record<string, SenseConfig>,
-): string[] {
-  const sc = senses[senseName];
-  if (sc === undefined) return [];
-  if (sc.interval === null && sc.on.length === 0) return [];
-  return [labelSenseTrigger({ interval: sc.interval, on: sc.on })];
-}
-
-/** Validates `{ command: string }` from Sense compute or IPC (`trigger` field). */
-export function parseSenseTrigger(value: unknown): Result<SenseTrigger> {
-  if (!isPlainRecord(value)) {
-    return err(new Error("sense trigger must be a plain object"));
-  }
-  for (const key of Object.keys(value)) {
-    if (key !== "command") {
-      return err(new Error(`sense trigger: unexpected property "${key}"`));
-    }
-  }
-  const command = value.command;
-  if (typeof command !== "string" || command.trim().length === 0) {
-    return err(new Error('sense trigger: "command" must be a non-empty string'));
-  }
-  return ok({ command: command.trim() });
-}

packages/core/src/spawn-safe.ts

@@ -1,8 +1,7 @@
 import { spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { join } from "node:path";
-
-export type Result<T, E = Error> = { ok: true; value: T } | { ok: false; error: E };
+import { type Result, err, ok } from "./result.js";
 
 /** Compatible with `process.env` for `child_process.spawn`. */
 export type SpawnEnv = Record<string, string | undefined>;
@@ -41,42 +40,6 @@ type SpawnSafeOptionsInput = SpawnSafeOptions | Omit<SpawnSafeOptions, "dryRun">
 
 const DEFAULT_TIMEOUT_MS = 300_000;
 
-export function ok<T>(value: T): Result<T, never> {
-  return { ok: true, value };
-}
-
-export function err<E = Error>(error: E): Result<never, E> {
-  return { ok: false, error };
-}
-
-/**
- * Narrows `unknown` to a plain JSON-style object (not null, not array).
- * Use after `JSON.parse` / YAML / IPC when validating structure field-by-field.
- */
-export function isPlainRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-const DURATION_RE = /^(\d+)([smh])$/;
-
-const DURATION_MULTIPLIERS: Record<string, number> = {
-  s: 1_000,
-  m: 60_000,
-  h: 3_600_000,
-};
-
-/**
- * Parse a duration string such as `5s`, `10m`, `1h` to milliseconds.
- * Used by `parseNerveConfig` sense/workflow duration fields.
- */
-export function parseDurationStringToMs(value: string): Result<number> {
-  const match = DURATION_RE.exec(value);
-  if (!match) {
-    return err(new Error(`invalid duration "${value}" (expected e.g. "5s", "10m", "1h")`));
-  }
-  return ok(Number(match[1]) * DURATION_MULTIPLIERS[match[2]]);
-}
-
 /**
  * PATH and PNPM_HOME for running `pnpm` and `nerve` from workflow roles.
  * Uses the pnpm store home only (no npm user bin); binaries must resolve via PATH.

packages/core/src/workflow-spec.ts

@@ -0,0 +1,24 @@
+import type { Schema } from "./extract-layer.js";
+import type { AgentFn, Moderator, RoleMeta, StartStep, WorkflowMessage } from "./workflow.js";
+
+/** Static string or async prompt built from thread context (RFC-003 dynamic prompts). */
+export type PromptInput =
+  | string
+  | ((start: StartStep, messages: WorkflowMessage[]) => Promise<string>);
+
+/**
+ * Authoring-time role: adapter function, prompt, extract schema (RFC-003).
+ * Compiles to runtime `Role<Meta>` via `compileWorkflowSpec`.
+ */
+export type RoleSpec<Meta extends Record<string, unknown>> = {
+  adapter: AgentFn;
+  prompt: PromptInput;
+  meta: Schema<Meta>;
+};
+
+/** User-facing workflow authoring shape; compiles to `WorkflowDefinition`. */
+export type WorkflowSpec<M extends RoleMeta> = {
+  name: string;
+  roles: { [K in keyof M]: RoleSpec<M[K]> };
+  moderator: Moderator<M>;
+};

packages/core/src/workflow.ts

@@ -21,41 +21,39 @@ export type WorkflowMessage = {
 /** The typed output of a Role execution. */
 export type RoleResult<Meta> = { content: string; meta: Meta };
 
+/**
+ * A Role is a pure async function: receives the engine start frame plus prior
+ * role messages only (the start frame is not included in `messages`).
+ * Returns typed content + meta. Implementation can be an agent, LLM call,
+ * script, HTTP request, etc.
+ */
+export type Role<Meta> = (
+  start: StartStep,
+  messages: WorkflowMessage[],
+) => Promise<RoleResult<Meta>>;
+
 /** Maps role names to their meta types — the single generic that drives all inference. */
 export type RoleMeta = Record<string, Record<string, unknown>>;
 
-/** Engine start frame: initial prompt, max rounds cap, and thread identity. */
+/** Engine start frame: prompt, max rounds cap, dry-run flag, and timestamps for the thread. */
 export type StartStep = {
   role: START;
   content: string;
   /** Thread identity (same as workflow `runId`); for role prompts and CLI `nerve thread` context. */
-  meta: { maxRounds: number; threadId: string };
+  meta: { maxRounds: number; dryRun: boolean; threadId: string };
   timestamp: number;
 };
 
-/**
- * Thread-scoped context for roles, moderator, and agent adapters (RFC-005).
- * `workdir` and `signal` are adapter/engine config — not part of this shape.
- */
-export type ThreadContext<M extends RoleMeta = RoleMeta> = {
-  threadId: string;
+/** Thread context passed to agent adapters (RFC-003): conversation frame, repo root, cancellation. */
+export type WorkflowContext = {
   start: StartStep;
-  steps: RoleStep<M>[];
+  messages: WorkflowMessage[];
+  workdir: string;
+  signal: AbortSignal;
 };
 
-/**
- * @deprecated Use {@link ThreadContext}.
- */
-export type WorkflowContext = ThreadContext;
-
-/**
- * A Role receives the full thread context (start frame + prior role steps) and returns
- * typed content + meta. Implementation can be an agent, LLM call, script, HTTP request, etc.
- */
-export type Role<Meta> = (ctx: ThreadContext) => Promise<RoleResult<Meta>>;
-
 /** Unified agent invocation — raw string output; structured meta uses the extract layer. */
-export type AgentFn = (ctx: ThreadContext, systemPrompt: string) => Promise<string>;
+export type AgentFn = (prompt: string, context: WorkflowContext) => Promise<string>;
 
 /** A discriminated union of role steps after each execution, aligned with `StartStep` shape. */
 export type RoleStep<M extends RoleMeta> = {
@@ -63,17 +61,23 @@ export type RoleStep<M extends RoleMeta> = {
 }[keyof M & string];
 
 /**
- * @deprecated Use {@link ThreadContext}.
+ * Moderator input: the complete workflow history.
+ * Contains the start frame and all role steps so far.
+ * On initial call, `steps` is empty — moderator can check `steps.length === 0`.
+ * Round count is `steps.length`; maxRounds is in `start.meta.maxRounds`.
  */
-export type ModeratorContext<M extends RoleMeta> = ThreadContext<M>;
+export type ModeratorContext<M extends RoleMeta> = {
+  start: StartStep;
+  steps: RoleStep<M>[];
+};
 
 /**
- * The moderator — a pure routing function. Receives the full thread context
- * (start frame + all prior steps). On initial call, `steps` is empty.
- * Round count is `steps.length`; maxRounds is in `start.meta.maxRounds`.
- * Returns the next role name or END.
+ * The moderator — a pure routing function. Receives the full workflow context
+ * (start frame + all prior steps). Returns the next role name or END.
  */
-export type Moderator<M extends RoleMeta> = (ctx: ThreadContext<M>) => (keyof M & string) | END;
+export type Moderator<M extends RoleMeta> = (
+  context: ModeratorContext<M>,
+) => (keyof M & string) | END;
 
 /** The complete definition of a workflow, as authored by users. */
 export type WorkflowDefinition<M extends RoleMeta> = {

packages/daemon/README.md

@@ -1,22 +1,23 @@
 # @uncaged/nerve-daemon
 
-The observation engine runtime for [nerve](../../README.md) — runs senses, persists JSON state, runs the sense scheduler, and manages workflows.
+The observation engine runtime for [nerve](../../README.md) — runs senses, routes signals, runs the sense scheduler, and manages workflows.
 
 ## Architecture
 
 | Module | Source (indicative) | Responsibility |
 |--------|---------------------|----------------|
-| **Kernel** | `kernel.ts` | Orchestrator — worker pool, sense scheduler, workflow manager, optional file watcher and daemon IPC, config reload hooks |
+| **Kernel** | `kernel.ts` | Orchestrator — worker pool, signal bus, sense scheduler, workflow manager, optional file watcher and daemon IPC, config reload hooks |
 | **Worker pool** | `worker-pool.ts` | Fork and supervise one child process per sense group; restart/shutdown; crash cleanup hooks for scheduler state |
 | **Kernel sense groups** | `kernel-sense-groups.ts` | Derive sense groups from config; list senses per group for scheduling |
-| **Sense runtime** | `sense-runtime.ts` + sense worker | Loads user modules (`compute`, `initialState`), reads/writes `data/senses/<name>.json` |
-| **Sense worker** | `sense-worker.ts` (fork target) | Child process entry — runs `compute(state)` per sense in a group |
-| **Sense scheduler** | `sense-scheduler.ts` | Interval + `on` subscriptions (reverse-index by upstream sense), throttle/coalesce |
+| **Sense runtime** | sense worker + Drizzle | Per-sense SQLite (`node:sqlite`), migrations, peer DB reads |
+| **Sense worker** | `sense-worker.ts` (fork target) | Child process entry — runs `compute()` per sense in a group |
+| **Signal bus** | `signal-bus.ts` | In-memory pub/sub for sense signals |
+| **Sense scheduler** | `sense-scheduler.ts` | Interval + `on` subscriptions, throttle/coalesce |
 | **Workflow manager** | `workflow-manager.ts` | One worker per workflow name, concurrency (drop/queue), queue caps |
 | **Workflow worker** | `workflow-worker.ts` | Child process — runs RFC-002 threads (`start-thread`, `resume-thread` IPC) |
 | **IPC (parent ↔ workers)** | `ipc.ts` | Typed messages for sense and workflow workers (includes `resume-thread` for recovery) |
 | **Log / workflow persistence** | via `@uncaged/nerve-store` | Structured logs, `workflow_runs`, thread messages (used for recovery) |
-| **Blob store** | `@uncaged/nerve-store` | CAS under `data/blobs/` — workflows use blob storage for artifacts as configured |
+| **Blob store** | `@uncaged/nerve-store` | CAS under `data/blobs/` — sense workers construct `createBlobStore(join(nerveRoot, "data", "blobs"))` for artifact writes |
 | **File watcher** | `file-watcher.ts` | Watches workspace paths for config / sense / workflow file changes |
 | **Kernel file watch** | `kernel-file-watch.ts` | Maps watcher events to `reloadConfig`, sense group restart, workflow `drainAndRespawn` |
 | **Daemon IPC** | `daemon-ipc.ts` | Unix socket server — parses `@uncaged/nerve-core` `DaemonIpcRequest`, dispatches trigger-workflow / trigger-sense / list-senses |
@@ -34,9 +35,9 @@ Hot reload (`drainAndRespawn`) uses a controlled drain: in-flight runs may be ma
 ## Key Design Decisions
 
 - **One worker process per sense group** — isolation between groups, shared compute within a group
-- **Sense state as JSON** — `data/senses/<name>.json`, updated after each successful compute in the worker
+- **`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 ≠ Sense trigger** — logs are queryable data assets but cannot schedule sense computes or workflows (prevents feedback loops)
+- **Log ≠ Signal** — logs are queryable data assets but cannot trigger the sense scheduler or workflows (prevents feedback loops)
 
 ## Usage
 
@@ -84,7 +85,7 @@ await kernel.stop();
 pnpm add @uncaged/nerve-daemon
 ```
 
-Requires Node.js ≥ 22.5 (for `node:sqlite` in the log store and related persistence).
+Requires Node.js ≥ 22.5 (for `node:sqlite`).
 
 ## License
 

packages/daemon/package.json

@@ -22,13 +22,13 @@
   "scripts": {
     "prepublishOnly": "bash ../../scripts/prepublish-check.sh",
     "build": "rslib build",
-    "pretest": "pnpm --filter @uncaged/workflow run build:public-types && pnpm --filter @uncaged/nerve-core run build && pnpm --filter @uncaged/nerve-store run build && pnpm --filter @uncaged/workflow run build",
+    "pretest": "pnpm --filter @uncaged/nerve-core run build",
     "test": "vitest run"
   },
   "dependencies": {
-    "@uncaged/workflow": "workspace:*",
     "@uncaged/nerve-core": "workspace:*",
     "@uncaged/nerve-store": "workspace:*",
+    "drizzle-orm": "1.0.0-beta.23-c10d10c",
     "yaml": "^2.8.3"
   },
   "devDependencies": {

packages/daemon/rslib.config.ts

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

packages/daemon/src/__tests__/compile-workflow-spec.test.ts

@@ -0,0 +1,188 @@
+import { describe, expect, it } from "vitest";
+
+import type {
+  AgentFn,
+  ModeratorContext,
+  RoleMeta,
+  Schema,
+  StartStep,
+  WorkflowContext,
+  WorkflowDefinition,
+  WorkflowMessage,
+  WorkflowSpec,
+} from "@uncaged/nerve-core";
+import { END, START } from "@uncaged/nerve-core";
+
+import { compileWorkflowSpec } from "../compile-workflow-spec.js";
+
+type DemoMeta = { n: number };
+
+function echoAdapter(): AgentFn {
+  return async (prompt: string, _ctx: WorkflowContext) => prompt;
+}
+
+function makeStart(threadId = "t1"): StartStep {
+  return {
+    role: START,
+    content: "",
+    meta: { maxRounds: 10, dryRun: false, threadId },
+    timestamp: Date.now(),
+  };
+}
+
+function makeContext(start: StartStep, messages: WorkflowMessage[]): WorkflowContext {
+  return {
+    start,
+    messages,
+    workdir: "/tmp/repo",
+    signal: new AbortController().signal,
+  };
+}
+
+describe("compileWorkflowSpec", () => {
+  it("compiles WorkflowSpec to WorkflowDefinition shape", () => {
+    const witness: DemoMeta | null = null;
+    const schema: Schema<DemoMeta> = { witness };
+
+    const spec: WorkflowSpec<{ main: DemoMeta }> = {
+      name: "demo",
+      roles: {
+        main: {
+          adapter: echoAdapter(),
+          prompt: "hello",
+          meta: schema,
+        },
+      },
+      moderator: (_ctx: ModeratorContext<{ main: DemoMeta }>) => END,
+    };
+
+    const def = compileWorkflowSpec(spec, {
+      extractFn: async <T>(raw: string, _s: Schema<T>) => ({ n: raw.length }) as T,
+      createContext: makeContext,
+    });
+
+    expect(def.name).toBe("demo");
+    expect(typeof def.roles.main).toBe("function");
+    expect(def.moderator).toBe(spec.moderator);
+  });
+
+  it("runs AgentFn then ExtractFn in order", async () => {
+    const witness: DemoMeta | null = null;
+    const schema: Schema<DemoMeta> = { witness };
+
+    const order: string[] = [];
+
+    const baseEcho = echoAdapter();
+    const spyAgent: AgentFn = async (prompt, ctx) => {
+      order.push("agent");
+      return baseEcho(prompt, ctx);
+    };
+
+    const spec: WorkflowSpec<{ main: DemoMeta }> = {
+      name: "order-test",
+      roles: {
+        main: {
+          adapter: spyAgent,
+          prompt: "ping",
+          meta: schema,
+        },
+      },
+      moderator: () => END,
+    };
+
+    const def = compileWorkflowSpec(spec, {
+      extractFn: async <T>(raw: string, _sch: Schema<T>) => {
+        order.push("extract");
+        return { n: raw.length } as T;
+      },
+      createContext: makeContext,
+    });
+
+    const start = makeStart();
+    await def.roles.main(start, []);
+
+    expect(order).toEqual(["agent", "extract"]);
+  });
+
+  it("passes WorkflowContext from createContext to AgentFn (adapter owns timeout)", async () => {
+    const witness: DemoMeta | null = null;
+    const schema: Schema<DemoMeta> = { witness };
+
+    const seenCtx: WorkflowContext[] = [];
+
+    const adapter: AgentFn = async (_prompt, ctx) => {
+      seenCtx.push(ctx);
+      return "x";
+    };
+
+    const spec: WorkflowSpec<{ main: DemoMeta }> = {
+      name: "ctx",
+      roles: {
+        main: {
+          adapter,
+          prompt: "x",
+          meta: schema,
+        },
+      },
+      moderator: () => END,
+    };
+
+    await compileWorkflowSpec(spec, {
+      extractFn: async <T>(_raw: string, _s: Schema<T>) => ({ n: 0 }) as T,
+      createContext: makeContext,
+    }).roles.main(makeStart(), []);
+
+    expect(seenCtx).toHaveLength(1);
+    expect(seenCtx[0].workdir).toBe("/tmp/repo");
+  });
+
+  it("resolves dynamic prompt functions before AgentFn", async () => {
+    const witness: DemoMeta | null = null;
+    const schema: Schema<DemoMeta> = { witness };
+
+    const spec: WorkflowSpec<{ main: DemoMeta }> = {
+      name: "dyn",
+      roles: {
+        main: {
+          adapter: echoAdapter(),
+          prompt: async (start, messages) => `tid=${start.meta.threadId} n=${messages.length}`,
+          meta: schema,
+        },
+      },
+      moderator: () => END,
+    };
+
+    const def = compileWorkflowSpec(spec, {
+      extractFn: async <T>(raw: string, _s: Schema<T>) => ({ n: raw.length }) as T,
+      createContext: makeContext,
+    });
+
+    const start = makeStart("thread-x");
+    const msgs: WorkflowMessage[] = [{ role: "a", content: "m", meta: {}, timestamp: 1 }];
+    const out = await def.roles.main(start, msgs);
+    expect(out.content).toBe("tid=thread-x n=1");
+    expect(out.meta.n).toBe(out.content.length);
+  });
+});
+
+describe("backward compatibility", () => {
+  it("hand-written Role-based WorkflowDefinition remains valid", async () => {
+    type M = RoleMeta & { legacy: { id: string } };
+
+    const manual: WorkflowDefinition<M> = {
+      name: "legacy",
+      roles: {
+        legacy: async (_start, _messages) => ({
+          content: "hi",
+          meta: { id: "a" },
+        }),
+      },
+      moderator: (_ctx: ModeratorContext<M>) => END,
+    };
+
+    const start = makeStart();
+    const out = await manual.roles.legacy(start, []);
+    expect(out.content).toBe("hi");
+    expect(out.meta.id).toBe("a");
+  });
+});

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

@@ -10,8 +10,7 @@
 
 import { EventEmitter } from "node:events";
 
-import type { NerveConfig } from "@uncaged/nerve-core";
-import type { WorkflowConfig } from "@uncaged/workflow";
+import type { NerveConfig, WorkflowConfig } from "@uncaged/nerve-core";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 type MockChild = EventEmitter & {
@@ -29,11 +28,6 @@ function makeMockChild(pid = 1): MockChild {
   child.connected = true;
   child.exitCode = null;
   child.pid = pid;
-  setImmediate(() => {
-    if (child.connected) {
-      child.emit("message", { type: "ready" });
-    }
-  });
   child.send = vi.fn((msg: unknown) => {
     if (
       msg !== null &&
@@ -63,7 +57,7 @@ vi.mock("node:child_process", () => ({
   }),
 }));
 
-const { createWorkflowManager } = await import("@uncaged/workflow");
+const { createWorkflowManager } = await import("../workflow-manager.js");
 
 function makeConfig(workflows: Record<string, WorkflowConfig> = {}): NerveConfig {
   return {
@@ -138,7 +132,6 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
 
       mgr.startWorkflow("my-wf", { prompt: "test 1", maxRounds: 10, dryRun: false });
       mgr.startWorkflow("my-wf", { prompt: "test 2", maxRounds: 10, dryRun: false });
-      await vi.runAllTimersAsync();
       expect(mgr.activeCount("my-wf")).toBe(2);
 
       // Simulate unexpected exit (not shutdown)
@@ -166,7 +159,6 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
 
       mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
       mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
-      await vi.runAllTimersAsync();
       expect(mgr.activeCount("my-wf")).toBe(2);
 
       const child = mockChildren[0];
@@ -191,7 +183,6 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
       mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
-      await vi.runAllTimersAsync();
       expect(mockChildren).toHaveLength(1);
 
       const child = mockChildren[0];
@@ -225,7 +216,6 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
       mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
-      await vi.runAllTimersAsync();
       const firstChild = mockChildren[0];
       firstChild.exitCode = 1;
       firstChild.connected = false;
@@ -270,7 +260,6 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
 
       // Start one thread to fill the concurrency slot (so queued run stays queued on respawn)
       mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
-      await vi.runAllTimersAsync();
       const firstChild = mockChildren[0];
       firstChild.exitCode = 1;
       firstChild.connected = false;
@@ -296,7 +285,6 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
       mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
-      await vi.runAllTimersAsync();
 
       const child = mockChildren[0];
       const startCall = (child.send as ReturnType<typeof vi.fn>).mock.calls[0];
@@ -334,7 +322,6 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
 
       const launch = { prompt: "build-docker for myrepo", maxRounds: 10, dryRun: false };
       mgr.startWorkflow("my-wf", launch);
-      await vi.runAllTimersAsync();
 
       const startedCall = logStore.upsertWorkflowRun.mock.calls.find(
         (args: any[]) => (args[0] as { type: string }).type === "started",
@@ -370,7 +357,6 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
 
       // Start one thread to fill the concurrency slot
       mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
-      await vi.runAllTimersAsync();
       const firstChild = mockChildren[0];
 
       // Crash once → respawn → crash again → second respawn
@@ -412,7 +398,6 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
       mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
-      await vi.runAllTimersAsync();
       const firstChild = mockChildren[0];
       firstChild.exitCode = 1;
       firstChild.connected = false;
@@ -443,7 +428,6 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
       mgr.startWorkflow("crash-wf", { prompt: "test", maxRounds: 10, dryRun: false });
-      await vi.runAllTimersAsync();
 
       // 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

@@ -241,6 +241,7 @@ describe("daemon-ipc — list-senses", () => {
         throttle: 5000,
         timeout: 3000,
         triggers: ["every 30s"],
+        lastSignalTimestamp: 1000,
       },
       {
         name: "disk-usage",
@@ -248,6 +249,7 @@ describe("daemon-ipc — list-senses", () => {
         throttle: 30000,
         timeout: null,
         triggers: [],
+        lastSignalTimestamp: null,
       },
     ];
     const listSenses = vi.fn(() => sensesData);

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

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

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

@@ -31,11 +31,6 @@ process.on("message", (msg) => {
       writeFileSync(markerFile, "crashed", "utf8");
       process.exit(1);
     }
-    process.send({
-      type: "compute-result",
-      sense: msg.sense,
-      state: 42,
-      trigger: null,
-    });
+    process.send({ type: "signal", sense: msg.sense, payload: 42 });
   }
 });

packages/daemon/src/__tests__/fixtures/crash-worker.js

@@ -1,9 +0,0 @@
-// Ready then crashes on a timer; still echoes IPC so parent tests can send after respawn
-process.on("message", (msg) => {
-  if (msg && msg.type === "shutdown") {
-    process.exit(0);
-  }
-  process.send({ type: "echo", payload: msg });
-});
-process.send({ type: "ready" });
-setTimeout(() => process.exit(1), 50);