chore: bump version to 0.4.0

小橘 🍊（NEKO Team）

README.md

@@ -7,31 +7,28 @@ Nerve is a lightweight daemon that continuously observes external state through
 ## Core Concepts
 
 ```
-External World → Sense ─┬→ Signal → Reflex → Sense (scheduled compute)
-                        │
-                        └→ Workflow (Sense return with workflow directive) → Log
+External World → Sense → Signal → Reflex → Workflow → Log
+                  ↑                                     ↑
+              "what to observe"                  "what to do"
 ```
 
 | Concept | Metaphor | Role |
 |---------|----------|------|
 | **Sense** | 👁️ Perception | A `compute()` function that samples or derives data. Each sense has its own SQLite database. |
-| **Reflex** | ⚡ Reaction | Declarative 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. |
+| **Reflex** | ⚡ Reaction | Declarative trigger — interval-based, event-driven, or both. Connects senses to actions. |
+| **Signal** | 📡 Notification | Emitted when a sense returns non-null. Other reflexes can listen for signals. |
+| **Workflow** | 🔧 Action | Stateful multi-step execution with Roles (actors) and a Moderator (coordinator). |
 | **Log** | 📝 Record | Immutable audit trail. Queryable by senses, but **cannot** trigger reflexes (prevents feedback loops). |
 
-**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`.
-
-Three extension points for **what / when / multi-step action** — reflexes never replace Sense-driven workflow launches.
+Three extension points, fully orthogonal — a Sense doesn't know when it runs, a Reflex doesn't know what it computes, a Workflow doesn't know why it was triggered.
 
 ## Packages
 
 | Package | Description |
 |---------|-------------|
-| [`@uncaged/nerve-core`](./packages/core) | Shared types, 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, workers, signal bus, reflex scheduler, workflow manager, file watcher, IPC |
-| [`@uncaged/nerve-cli`](./packages/cli) | CLI (`nerve`) — init, validate, daemon, dev, logs, sense, store, workflow |
+| [`@uncaged/nerve-core`](./packages/core) | Shared types and config parser |
+| [`@uncaged/nerve-daemon`](./packages/daemon) | The observation engine — kernel, sense runtime, reflex scheduler, workflow manager |
+| [`@uncaged/nerve-cli`](./packages/cli) | CLI tool (`nerve`) — init, start, stop, logs, query |
 
 ## Quick Start
 
@@ -73,17 +70,15 @@ nerve logs         # view logs
 
 ## Configuration
 
-`nerve.yaml` declares senses, reflexes (sense-only), optional workflows (concurrency), and optional engine `max_rounds`:
+`nerve.yaml` declares senses, reflexes, and workflows:
 
 ```yaml
-max_rounds: 100              # default moderator cap (e.g. CLI workflow trigger)
-
 senses:
   cpu-usage:
     group: system          # senses in the same group share a worker process
     throttle: 10s          # min interval between computes
     timeout: 30s           # max compute duration
-    grace_period: 5s       # wait before first compute after startup
+    gracePeriod: 5s        # wait before first compute after startup
 
 reflexes:
   - kind: sense
@@ -91,6 +86,10 @@ reflexes:
     interval: 30s          # periodic trigger
     on: [disk-pressure]    # also trigger on signals from other senses
 
+  - kind: workflow
+    workflow: cleanup
+    on: [disk-pressure]    # start a workflow when signal fires
+
 workflows:
   cleanup:
     concurrency: 1
@@ -98,66 +97,43 @@ workflows:
   code-review:
     concurrency: 3
     overflow: queue
-    max_queue: 20
-```
-
-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/compute.ts`):
-
-```typescript
-export async function compute() {
-  const full = await diskNearlyFull();
-  if (!full) return null;
-  return {
-    path: "/data",
-    workflow: "cleanup|10|Disk partition nearly full", // name|maxRounds|prompt
-  };
-}
+    maxQueue: 20
 ```
 
 ## Architecture
 
 ```
-┌────────────────────────────────────────────────────────────────────────┐
-│  Kernel                                                                 │
-│                                                                         │
-│  ┌──────────────┐   watches nerve.yaml / senses / workflows            │
-│  │ File Watcher ├──────────────────────────────────────────┐           │
-│  └──────────────┘                                          │           │
-│  ┌──────────────┐   CLI ↔ newline JSON (trigger-workflow, │           │
-│  │ Daemon IPC   │   trigger-sense, list-senses)            │           │
-│  └──────┬───────┘                                          ▼           │
-│         │            ┌──────────┐   ┌──────────┐   ┌──────────┐        │
-│         │            │ Worker   │   │ Worker   │   │ Worker   │ (1 per│
-│         │            │ (group A)│   │ (group B)│   │ (group C)│ group) │
-│         │            │ sense-1  │   │ sense-3  │   │ sense-5  │        │
-│         │            │ sense-2  │   │ sense-4  │   │          │        │
-│         │            └────┬─────┘   └────┬─────┘   └────┬─────┘        │
-│         │                 │              │              │            │
-│         │                 └──────────────┼──────────────┘            │
-│         │                                ▼                            │
-│         │                        ┌──────────────┐                     │
-│         │                        │  Signal Bus  │                     │
-│         │                        └──────┬───────┘                     │
-│         │                               ▼                             │
-│         │                     ┌──────────────────┐                      │
-│         │                     │ Reflex Scheduler│                      │
-│         │                     └────────┬─────────┘                     │
-│         │                              ▼                              │
-│         │                    ┌───────────────────┐                    │
-│         └───────────────────►│ Workflow Manager  │──→ @uncaged/nerve-store │
-│                              └───────────────────┘    (logs.db, …)   │
-└────────────────────────────────────────────────────────────────────────┘
+┌─────────────────────────────────────────────────────────┐
+│  Kernel                                                 │
+│                                                         │
+│  ┌──────────┐   ┌──────────┐   ┌──────────┐           │
+│  │ Worker   │   │ Worker   │   │ Worker   │  (1 per   │
+│  │ (group A)│   │ (group B)│   │ (group C)│   group)  │
+│  │ sense-1  │   │ sense-3  │   │ sense-5  │           │
+│  │ sense-2  │   │ sense-4  │   │          │           │
+│  └────┬─────┘   └────┬─────┘   └────┬─────┘           │
+│       │              │              │                   │
+│       └──────────────┼──────────────┘                   │
+│                      ▼                                  │
+│              ┌──────────────┐                           │
+│              │  Signal Bus  │                           │
+│              └──────┬───────┘                           │
+│                     ▼                                   │
+│           ┌──────────────────┐                          │
+│           │ Reflex Scheduler │                          │
+│           └────────┬─────────┘                          │
+│                    ▼                                    │
+│          ┌───────────────────┐                          │
+│          │ Workflow Manager  │──→ Log Store (SQLite)    │
+│          └───────────────────┘                          │
+└─────────────────────────────────────────────────────────┘
 ```
 
-- **Worker pool** — one child process per sense group; isolation between groups.
+- **Worker processes** — one per sense group, forked by the kernel. Isolated compute execution.
 - **Signal Bus** — in-memory pub/sub for signal distribution.
 - **Reflex Scheduler** — interval timers + signal subscriptions, with throttle/coalesce.
-- **Workflow Manager** — concurrency (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.
-- **Log / blob storage** — implemented in `@uncaged/nerve-store` (WAL SQLite, JSONL archive, CAS blobs).
+- **Workflow Manager** — concurrency control (drop/queue), thread lifecycle tracking.
+- **Log Store** — WAL-mode SQLite via `node:sqlite`, with archival and retention policies.
 
 ## Tech Stack
 

packages/cli/README.md

@@ -21,59 +21,41 @@ nerve init                  # Initialize a nerve workspace (installs deps, scaff
 nerve validate              # Validate nerve.yaml configuration
 ```
 
-### Daemon management
+### Daemon Management
 
 ```bash
 nerve daemon start          # Start the daemon (background)
 nerve daemon stop           # Stop the daemon
-nerve daemon status         # Show pid, uptime, sense names from nerve.yaml (process must exist)
-nerve daemon restart        # Stop then start
-nerve daemon logs           # Tail daemon process logs (file under workspace logs/)
+nerve daemon status         # Check daemon health
+nerve daemon restart        # Restart the daemon
+nerve daemon logs           # Tail daemon logs
 ```
 
 ### Development
 
 ```bash
-nerve dev                   # Foreground kernel with file watcher + IPC (Ctrl+C stops)
+nerve dev                   # Run in foreground mode (no daemon, Ctrl+C to stop)
 ```
 
-### Querying & status
+### Querying
 
 ```bash
-nerve logs                  # Tail or page the daemon text log file (path in footer; default ~/.uncaged-nerve/logs/nerve.log)
-nerve status                # Short daemon health summary (aliases daemon status)
-```
-
-Structured rows in `data/logs.db` are surfaced via **`nerve workflow inspect`** / **`nerve workflow list`** (and `LogStore` in code), not via `nerve logs`.
-
-### Sense
-
-```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
-```
-
-### Store maintenance
-
-```bash
-nerve store archive         # Move old log rows to JSONL under data/archive/logs/… (optional --vacuum)
+nerve logs                  # View structured logs
+nerve sense query <name>    # Query a sense's SQLite database
+nerve sense schema <name>   # Show a sense's database schema
+nerve status                # Daemon health summary
 ```
 
 ### Workflows
 
 ```bash
-nerve workflow list         # Queued/started runs (add --all for terminal states; --workflow, --limit, --offset)
-nerve workflow inspect <runId>   # Run metadata + paginated workflow log lines
-nerve workflow thread <runId>    # Role rounds from persisted messages (--before, --budget)
-nerve workflow trigger <name>    # IPC trigger-workflow (daemon must be running)
-                                   # Optional JSON: --payload '{"prompt":"…","maxRounds":50}'
+nerve workflow list         # List workflow runs
+nerve workflow show <runId> # Show workflow run details
 ```
 
-`nerve workflow trigger` sends a `trigger-workflow` line on the daemon Unix socket (same protocol as `@uncaged/nerve-core` / `parseDaemonIpcRequest`). It does not read `nerve.yaml` workflow definitions beyond what the running daemon already loaded.
+### Top-level Aliases
 
-### Top-level aliases
+For convenience, these aliases are available:
 
 ```bash
 nerve start    → nerve daemon start

packages/cli/package.json

@@ -10,7 +10,9 @@
   },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "publishConfig": {
     "access": "public"
   },

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

@@ -29,22 +29,10 @@ const SAMPLE_SENSES: SenseInfo[] = [
     group: "system",
     throttle: 5000,
     timeout: 3000,
-    lastSignalTimestamp: 1_700_000_000_000,
-  },
-  {
-    name: "disk-usage",
-    group: "system",
-    throttle: 30000,
-    timeout: null,
-    lastSignalTimestamp: null,
-  },
-  {
-    name: "active-tasks",
-    group: "tasks",
-    throttle: 10000,
-    timeout: 30000,
-    lastSignalTimestamp: null,
+    lastSignalTs: 1_700_000_000_000,
   },
+  { name: "disk-usage", group: "system", throttle: 30000, timeout: null, lastSignalTs: null },
+  { name: "active-tasks", group: "tasks", throttle: 10000, timeout: 30000, lastSignalTs: null },
 ];
 
 // ---------------------------------------------------------------------------
@@ -112,14 +100,14 @@ describe("formatSenseList", () => {
     expect(output).toContain("—");
   });
 
-  it("shows '(never)' when lastSignalTimestamp is null", () => {
+  it("shows '(never)' when lastSignalTs is null", () => {
     const output = formatSenseList(SAMPLE_SENSES);
     expect(output).toContain("(never)");
   });
 
-  it("shows ISO timestamp when lastSignalTimestamp is set", () => {
+  it("shows ISO timestamp when lastSignalTs is set", () => {
     const output = formatSenseList(SAMPLE_SENSES);
-    // cpu-usage has lastSignalTimestamp = 1_700_000_000_000
+    // cpu-usage has lastSignalTs = 1_700_000_000_000
     expect(output).toContain(new Date(1_700_000_000_000).toISOString());
   });
 });
@@ -169,19 +157,11 @@ reflexes: []
     );
     const result = sensesFromConfig(path);
     expect(result).toHaveLength(2);
-    expect(result[0]).toMatchObject({
-      name: "cpu-usage",
-      group: "system",
-      lastSignalTimestamp: null,
-    });
-    expect(result[1]).toMatchObject({
-      name: "disk-usage",
-      group: "system",
-      lastSignalTimestamp: null,
-    });
+    expect(result[0]).toMatchObject({ name: "cpu-usage", group: "system", lastSignalTs: null });
+    expect(result[1]).toMatchObject({ name: "disk-usage", group: "system", lastSignalTs: null });
   });
 
-  it("always sets lastSignalTimestamp to null (static fallback)", () => {
+  it("always sets lastSignalTs to null (static fallback)", () => {
     const path = join(tmpDir, "nerve.yaml");
     writeFileSync(
       path,
@@ -193,7 +173,7 @@ reflexes: []
 `.trim(),
     );
     const result = sensesFromConfig(path);
-    expect(result[0].lastSignalTimestamp).toBeNull();
+    expect(result[0].lastSignalTs).toBeNull();
   });
 
   it("populates throttle and timeout from config", () => {
@@ -258,13 +238,7 @@ describe("listSensesViaDaemon", () => {
 
   it("resolves with populated senses array", async () => {
     const senses: SenseInfo[] = [
-      {
-        name: "cpu-usage",
-        group: "system",
-        throttle: 5000,
-        timeout: 3000,
-        lastSignalTimestamp: 12345,
-      },
+      { name: "cpu-usage", group: "system", throttle: 5000, timeout: 3000, lastSignalTs: 12345 },
     ];
     const server = createServer((s) => {
       s.on("data", () => {

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

@@ -514,7 +514,7 @@ describe("triggerWorkflowViaDaemon", () => {
     await new Promise<void>((r) => server.listen(sockPath, r));
 
     try {
-      const result = await triggerWorkflowViaDaemon(sockPath, "my-workflow", "", 100);
+      const result = await triggerWorkflowViaDaemon(sockPath, "my-workflow", {});
       expect(result).toEqual({ ok: true });
     } finally {
       await new Promise<void>((r) => server.close(() => r()));
@@ -530,7 +530,7 @@ describe("triggerWorkflowViaDaemon", () => {
     await new Promise<void>((r) => server.listen(sockPath, r));
 
     try {
-      const result = await triggerWorkflowViaDaemon(sockPath, "missing", "", 100);
+      const result = await triggerWorkflowViaDaemon(sockPath, "missing", {});
       expect(result).toEqual({ ok: false, error: "unknown workflow" });
     } finally {
       await new Promise<void>((r) => server.close(() => r()));
@@ -538,7 +538,7 @@ describe("triggerWorkflowViaDaemon", () => {
   });
 
   it("rejects when no daemon is listening on the socket", async () => {
-    await expect(triggerWorkflowViaDaemon(sockPath, "my-workflow", "", 100)).rejects.toThrow(
+    await expect(triggerWorkflowViaDaemon(sockPath, "my-workflow", {})).rejects.toThrow(
       /Cannot connect to daemon/,
     );
   });

packages/cli/src/commands/init.ts

@@ -21,31 +21,6 @@ reflexes:
     interval: 10s
 `;
 
-const BIOME_JSON = `{
-  "$schema": "https://biomejs.dev/schemas/1.9.0/schema.json",
-  "formatter": {
-    "indentStyle": "space",
-    "indentWidth": 2,
-    "lineWidth": 100
-  },
-  "javascript": {
-    "formatter": {
-      "quoteStyle": "double",
-      "semicolons": "always"
-    }
-  },
-  "linter": {
-    "enabled": true,
-    "rules": {
-      "recommended": true,
-      "suspicious": {
-        "noConsole": "error"
-      }
-    }
-  }
-}
-`;
-
 const PACKAGE_JSON = `{
   "name": "my-nerve-workspace",
   "version": "0.0.1",
@@ -57,7 +32,6 @@ const PACKAGE_JSON = `{
     "drizzle-orm": "latest"
   },
   "devDependencies": {
-    "@biomejs/biome": "latest",
     "drizzle-kit": "latest"
   },
   "pnpm": {
@@ -346,7 +320,6 @@ async function runInitWorkspace(force: boolean): Promise<void> {
 
   writeFile(join(nerveRoot, "nerve.yaml"), NERVE_YAML);
   writeFile(join(nerveRoot, "package.json"), PACKAGE_JSON);
-  writeFile(join(nerveRoot, "biome.json"), BIOME_JSON);
   writeFile(join(nerveRoot, ".gitignore"), GITIGNORE);
   writeFile(join(nerveRoot, "senses", "cpu-usage", "schema.ts"), CPU_SCHEMA_TS);
   writeFile(join(nerveRoot, "senses", "cpu-usage", "index.js"), CPU_INDEX_JS);

packages/cli/src/commands/sense.ts

@@ -43,8 +43,7 @@ export function formatSenseList(senses: SenseInfo[]): string {
     lines.push(`    group:    ${s.group}\n`);
     lines.push(`    throttle: ${formatDuration(s.throttle)}\n`);
     lines.push(`    timeout:  ${formatDuration(s.timeout)}\n`);
-    const lastSignal =
-      s.lastSignalTimestamp !== null ? new Date(s.lastSignalTimestamp).toISOString() : "(never)";
+    const lastSignal = s.lastSignalTs !== null ? new Date(s.lastSignalTs).toISOString() : "(never)";
     lines.push(`    last signal: ${lastSignal}\n`);
   }
   return lines.join("");
@@ -65,7 +64,7 @@ export function sensesFromConfig(configPath: string): SenseInfo[] {
     group: cfg.group,
     throttle: cfg.throttle,
     timeout: cfg.timeout,
-    lastSignalTimestamp: null,
+    lastSignalTs: null,
   }));
 }
 

packages/cli/src/commands/validate.ts

@@ -31,7 +31,7 @@ export const validateCommand = defineCommand({
     const config = result.value;
     const senseCount = Object.keys(config.senses).length;
     const reflexCount = config.reflexes.length;
-    const workflowCount = Object.keys(config.workflows).length;
+    const workflowCount = config.workflows ? Object.keys(config.workflows).length : 0;
 
     process.stdout.write(
       `✅ nerve.yaml is valid — ${senseCount} sense(s), ${reflexCount} reflex(es), ${workflowCount} workflow(s)\n`,

packages/cli/src/commands/workflow.ts

@@ -1,8 +1,7 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 
-import type { DaemonIpcTriggerResponse } from "@uncaged/nerve-core";
-import { DEFAULT_ENGINE_MAX_ROUNDS, isPlainRecord } from "@uncaged/nerve-core";
+import { isPlainRecord } from "@uncaged/nerve-core";
 import { defineCommand } from "citty";
 import { stringify } from "yaml";
 
@@ -514,8 +513,7 @@ const workflowTriggerCommand = defineCommand({
     },
     payload: {
       type: "string",
-      description:
-        'JSON with optional "prompt" (string), "maxRounds" (number), and "dryRun" (boolean) for the workflow run (default: {})',
+      description: "JSON payload to pass as trigger payload (default: {})",
       default: "{}",
     },
   },
@@ -528,25 +526,15 @@ const workflowTriggerCommand = defineCommand({
       process.exit(1);
     }
 
-    let prompt = "";
-    let maxRounds = DEFAULT_ENGINE_MAX_ROUNDS;
-    let dryRun = false;
-    if (isPlainRecord(triggerPayload)) {
-      const p = triggerPayload;
-      if (typeof p.prompt === "string") prompt = p.prompt;
-      if (typeof p.maxRounds === "number") maxRounds = p.maxRounds;
-      if (typeof p.dryRun === "boolean") dryRun = p.dryRun;
-    }
-
     if (!isRunning()) {
       process.stderr.write("❌ Nerve daemon is not running. Start it with `nerve start`.\n");
       process.exit(1);
     }
 
     const socketPath = getSocketPath();
-    let response: DaemonIpcTriggerResponse;
+    let response: { ok: true } | { ok: false; error: string };
     try {
-      response = await triggerWorkflowViaDaemon(socketPath, args.name, prompt, maxRounds, dryRun);
+      response = await triggerWorkflowViaDaemon(socketPath, args.name, triggerPayload);
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
       process.stderr.write(`❌ Failed to contact daemon: ${msg}\n`);

packages/cli/src/daemon-client.ts

@@ -8,12 +8,7 @@
 import { connect } from "node:net";
 import type { Socket } from "node:net";
 
-import type {
-  DaemonIpcListSensesResponse,
-  DaemonIpcRequest,
-  DaemonIpcTriggerResponse,
-  SenseInfo,
-} from "@uncaged/nerve-core";
+import type { SenseInfo } from "@uncaged/nerve-core";
 import { isPlainRecord } from "@uncaged/nerve-core";
 
 const CONNECT_TIMEOUT_MS = 3_000;
@@ -21,6 +16,10 @@ const RESPONSE_TIMEOUT_MS = 5_000;
 
 export type { SenseInfo };
 
+type TriggerResponse = { ok: true } | { ok: false; error: string };
+
+type ListSensesResponse = { ok: true; senses: SenseInfo[] } | { ok: false; error: string };
+
 function isSenseInfo(value: unknown): value is SenseInfo {
   if (!isPlainRecord(value)) return false;
   return (
@@ -28,11 +27,11 @@ function isSenseInfo(value: unknown): value is SenseInfo {
     typeof value.group === "string" &&
     (value.throttle === null || typeof value.throttle === "number") &&
     (value.timeout === null || typeof value.timeout === "number") &&
-    (value.lastSignalTimestamp === null || typeof value.lastSignalTimestamp === "number")
+    (value.lastSignalTs === null || typeof value.lastSignalTs === "number")
   );
 }
 
-function parseDaemonResponse(line: string): DaemonIpcTriggerResponse {
+function parseDaemonResponse(line: string): TriggerResponse {
   try {
     const obj: unknown = JSON.parse(line);
     if (isPlainRecord(obj)) {
@@ -46,7 +45,7 @@ function parseDaemonResponse(line: string): DaemonIpcTriggerResponse {
   return { ok: false, error: `Unexpected daemon response: ${line}` };
 }
 
-function parseListSensesResponse(line: string): DaemonIpcListSensesResponse {
+function parseListSensesResponse(line: string): ListSensesResponse {
   try {
     const obj: unknown = JSON.parse(line);
     if (isPlainRecord(obj)) {
@@ -68,7 +67,7 @@ function parseListSensesResponse(line: string): DaemonIpcListSensesResponse {
  */
 function sendAndReceive<T>(
   socketPath: string,
-  message: DaemonIpcRequest,
+  message: object,
   parseFirstLine: (trimmed: string) => T,
   responseTimeoutMs: number = RESPONSE_TIMEOUT_MS,
 ): Promise<T> {
@@ -133,37 +132,27 @@ function sendAndReceive<T>(
 export function triggerWorkflowViaDaemon(
   socketPath: string,
   workflow: string,
-  prompt: string,
-  maxRounds: number,
-  dryRun = false,
-): Promise<DaemonIpcTriggerResponse> {
-  const message: DaemonIpcRequest = {
-    type: "trigger-workflow",
-    workflow,
-    prompt,
-    maxRounds,
-    dryRun,
-  };
-  return sendAndReceive(socketPath, message, parseDaemonResponse);
+  payload: unknown,
+): Promise<TriggerResponse> {
+  return sendAndReceive(
+    socketPath,
+    { type: "trigger-workflow", workflow, payload },
+    parseDaemonResponse,
+  );
 }
 
 /**
  * Send a trigger-sense message to the running daemon via its Unix socket.
  * Resolves with the daemon's response or rejects on connection/timeout errors.
  */
-export function triggerSenseViaDaemon(
-  socketPath: string,
-  sense: string,
-): Promise<DaemonIpcTriggerResponse> {
-  const message: DaemonIpcRequest = { type: "trigger-sense", sense };
-  return sendAndReceive(socketPath, message, parseDaemonResponse);
+export function triggerSenseViaDaemon(socketPath: string, sense: string): Promise<TriggerResponse> {
+  return sendAndReceive(socketPath, { type: "trigger-sense", sense }, parseDaemonResponse);
 }
 
 /**
  * Send a list-senses message to the running daemon via its Unix socket.
  * Resolves with the list of registered senses or rejects on connection/timeout errors.
  */
-export function listSensesViaDaemon(socketPath: string): Promise<DaemonIpcListSensesResponse> {
-  const message: DaemonIpcRequest = { type: "list-senses" };
-  return sendAndReceive(socketPath, message, parseListSensesResponse);
+export function listSensesViaDaemon(socketPath: string): Promise<ListSensesResponse> {
+  return sendAndReceive(socketPath, { type: "list-senses" }, parseListSensesResponse);
 }

packages/core/README.md

@@ -4,12 +4,9 @@ Shared types and configuration parser for the [nerve](../../README.md) observati
 
 ## What's Inside
 
-- **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`, `StartSignal`, `RoleSignal`, `Moderator`, `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)
+- **Type definitions** — `Signal`, `SenseConfig`, `ReflexConfig`, `WorkflowConfig`, `NerveConfig`, and all related types
+- **Config parser** — `parseNerveConfig(yaml)` validates and parses `nerve.yaml` into a typed `NerveConfig`
+- **Result type** — `Result<T>` with `ok()` / `err()` helpers for explicit error handling (no thrown exceptions)
 
 ## Usage
 
@@ -23,29 +20,6 @@ if (result.ok) {
 }
 ```
 
-### Sense return → signal vs workflow
-
-```typescript
-import { parseSenseWorkflowDirective, routeSenseComputeOutput } from "@uncaged/nerve-core";
-
-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);
-}
-```
-
 ## Duration Format
 
 Config fields like `throttle`, `timeout`, and `interval` accept human-readable durations:

packages/core/package.json

@@ -3,7 +3,9 @@
   "version": "0.4.0",
   "type": "module",
   "main": "dist/index.js",
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "publishConfig": {
     "access": "public"
   },

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

@@ -50,7 +50,7 @@ describe("parseNerveConfig", () => {
         kind: "sense",
         sense: "cpu",
         interval: 30_000,
-        on: [],
+        on: null,
       });
       expect(result.value.reflexes[1]).toEqual({
         kind: "sense",
@@ -58,7 +58,7 @@ describe("parseNerveConfig", () => {
         interval: null,
         on: ["high_usage"],
       });
-      expect(result.value.workflows.alert).toEqual({
+      expect(result.value.workflows?.alert).toEqual({
         concurrency: 2,
         overflow: "queue",
         maxQueue: 10,
@@ -85,12 +85,11 @@ senses:
     group: system
 reflexes:
   - sense: cpu
-    interval: 1s
 `;
       const result = parseNerveConfig(yaml);
       expect(result.ok).toBe(true);
       if (!result.ok) return;
-      expect(result.value.workflows).toEqual({});
+      expect(result.value.workflows).toBeNull();
     });
 
     it("sense config has null for omitted throttle/timeout/gracePeriod", () => {
@@ -143,11 +142,11 @@ workflows:
       const result = parseNerveConfig(yaml);
       expect(result.ok).toBe(true);
       if (!result.ok) return;
-      expect(result.value.workflows.alert).toEqual({
+      expect(result.value.workflows?.alert).toEqual({
         concurrency: 1,
         overflow: "drop",
       });
-      expect("maxQueue" in result.value.workflows.alert).toBe(false);
+      expect("maxQueue" in (result.value.workflows?.alert ?? {})).toBe(false);
     });
 
     it("overflow: queue defaults maxQueue to 100", () => {
@@ -164,7 +163,7 @@ workflows:
       const result = parseNerveConfig(yaml);
       expect(result.ok).toBe(true);
       if (!result.ok) return;
-      expect(result.value.workflows.alert).toEqual({
+      expect(result.value.workflows?.alert).toEqual({
         concurrency: 1,
         overflow: "queue",
         maxQueue: 100,

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

@@ -1,72 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { parseDaemonIpcRequest } from "../daemon-ipc-protocol.js";
-
-describe("parseDaemonIpcRequest", () => {
-  it("parses trigger-workflow", () => {
-    expect(
-      parseDaemonIpcRequest(
-        JSON.stringify({
-          type: "trigger-workflow",
-          workflow: "wf",
-          prompt: "go",
-          maxRounds: 3,
-        }),
-      ),
-    ).toEqual({
-      type: "trigger-workflow",
-      workflow: "wf",
-      prompt: "go",
-      maxRounds: 3,
-      dryRun: false,
-    });
-  });
-
-  it("parses trigger-workflow with dryRun true", () => {
-    expect(
-      parseDaemonIpcRequest(
-        JSON.stringify({
-          type: "trigger-workflow",
-          workflow: "wf",
-          prompt: "go",
-          maxRounds: 3,
-          dryRun: true,
-        }),
-      ),
-    ).toEqual({
-      type: "trigger-workflow",
-      workflow: "wf",
-      prompt: "go",
-      maxRounds: 3,
-      dryRun: true,
-    });
-  });
-
-  it("rejects trigger-workflow with empty workflow", () => {
-    expect(
-      parseDaemonIpcRequest(
-        JSON.stringify({
-          type: "trigger-workflow",
-          workflow: "",
-          prompt: "",
-          maxRounds: 1,
-        }),
-      ),
-    ).toBeNull();
-  });
-
-  it("parses trigger-sense and list-senses", () => {
-    expect(parseDaemonIpcRequest(JSON.stringify({ type: "trigger-sense", sense: "x" }))).toEqual({
-      type: "trigger-sense",
-      sense: "x",
-    });
-    expect(parseDaemonIpcRequest(JSON.stringify({ type: "list-senses" }))).toEqual({
-      type: "list-senses",
-    });
-  });
-
-  it("returns null for invalid JSON or unknown type", () => {
-    expect(parseDaemonIpcRequest("not json")).toBeNull();
-    expect(parseDaemonIpcRequest(JSON.stringify({ type: "nope" }))).toBeNull();
-  });
-});

packages/core/src/config.ts

@@ -76,8 +76,8 @@ function validateSenseConfig(name: string, raw: unknown): Result<SenseConfig> {
   });
 }
 
-function parseOnField(index: number, obj: Record<string, unknown>): Result<string[]> {
-  if (obj.on === undefined || obj.on === null) return ok([]);
+function parseOnField(index: number, obj: Record<string, unknown>): Result<string[] | null> {
+  if (obj.on === undefined || obj.on === null) return ok(null);
   if (!Array.isArray(obj.on) || !obj.on.every((item): item is string => typeof item === "string")) {
     return err(new Error(`reflexes[${index}].on: must be an array of strings`));
   }
@@ -88,7 +88,7 @@ function parseSenseReflex(
   index: number,
   obj: Record<string, unknown>,
   senseNames: Set<string>,
-  on: string[],
+  on: string[] | null,
 ): Result<ReflexConfig> {
   if (typeof obj.sense !== "string") {
     return err(new Error(`reflexes[${index}].sense: must be a string`));
@@ -100,7 +100,7 @@ function parseSenseReflex(
   const intervalResult = parseDurationField(obj.interval, `reflexes[${index}].interval`);
   if (!intervalResult.ok) return intervalResult;
 
-  if (intervalResult.value === null && on.length === 0) {
+  if (intervalResult.value === null && on !== null && on.length === 0) {
     return err(
       new Error(`reflexes[${index}]: sense reflex must have at least one of "interval" or "on"`),
     );
@@ -245,8 +245,10 @@ function parseReflexes(
   return ok(reflexes);
 }
 
-function parseWorkflows(obj: Record<string, unknown>): Result<Record<string, WorkflowConfig>> {
-  if (obj.workflows === undefined || obj.workflows === null) return ok({});
+function parseWorkflows(
+  obj: Record<string, unknown>,
+): Result<Record<string, WorkflowConfig> | null> {
+  if (obj.workflows === undefined || obj.workflows === null) return ok(null);
 
   if (!isPlainRecord(obj.workflows)) {
     return err(new Error("workflows: must be an object if provided"));

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

@@ -1,94 +0,0 @@
-/**
- * Daemon Unix-socket IPC protocol (CLI → daemon).
- * Newline-delimited JSON: one request object per line from the client,
- * one response object per line from the daemon.
- */
-
-import { isPlainRecord } from "./is-plain-record.js";
-import type { SenseInfo } from "./types.js";
-
-/** Client → daemon: start a workflow run. */
-export type DaemonIpcTriggerWorkflowRequest = {
-  type: "trigger-workflow";
-  workflow: string;
-  prompt: string;
-  maxRounds: number;
-  dryRun: boolean;
-};
-
-/** Client → daemon: run a sense compute on demand. */
-export type DaemonIpcTriggerSenseRequest = {
-  type: "trigger-sense";
-  sense: string;
-};
-
-/** Client → daemon: list registered senses. */
-export type DaemonIpcListSensesRequest = {
-  type: "list-senses";
-};
-
-/** Union of all JSON requests the daemon IPC server accepts. */
-export type DaemonIpcRequest =
-  | DaemonIpcTriggerWorkflowRequest
-  | DaemonIpcTriggerSenseRequest
-  | DaemonIpcListSensesRequest;
-
-/** Successful trigger / trigger-sense reply (no body). */
-export type DaemonIpcTriggerOkResponse = { ok: true };
-
-export type DaemonIpcErrorResponse = { ok: false; error: string };
-
-/** Replies for trigger-workflow and trigger-sense. */
-export type DaemonIpcTriggerResponse = DaemonIpcTriggerOkResponse | DaemonIpcErrorResponse;
-
-/** Reply for list-senses. */
-export type DaemonIpcListSensesResponse =
-  | { ok: true; senses: SenseInfo[] }
-  | DaemonIpcErrorResponse;
-
-/** Any JSON response the daemon may write on the IPC socket. */
-export type DaemonIpcResponse =
-  | DaemonIpcTriggerOkResponse
-  | DaemonIpcErrorResponse
-  | { ok: true; senses: SenseInfo[] };
-
-function parseTriggerWorkflowFields(
-  req: Record<string, unknown>,
-): DaemonIpcTriggerWorkflowRequest | null {
-  if (typeof req.workflow !== "string" || req.workflow.length === 0) return null;
-  if (typeof req.prompt !== "string") return null;
-  if (typeof req.maxRounds !== "number") return null;
-  const dryRun = typeof req.dryRun === "boolean" ? req.dryRun : false;
-  return {
-    type: "trigger-workflow",
-    workflow: req.workflow,
-    prompt: req.prompt,
-    maxRounds: req.maxRounds,
-    dryRun,
-  };
-}
-
-/**
- * Parse a single line of JSON into a {@link DaemonIpcRequest}, or null if invalid.
- * Kept in core with the request types so CLI and daemon stay aligned at compile time.
- */
-export function parseDaemonIpcRequest(line: string): DaemonIpcRequest | null {
-  try {
-    const obj: unknown = JSON.parse(line);
-    if (!isPlainRecord(obj)) return null;
-    const req = obj;
-    if (req.type === "trigger-workflow") {
-      return parseTriggerWorkflowFields(req);
-    }
-    if (req.type === "trigger-sense") {
-      if (typeof req.sense !== "string" || req.sense.length === 0) return null;
-      return { type: "trigger-sense", sense: req.sense };
-    }
-    if (req.type === "list-senses") {
-      return { type: "list-senses" };
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}

packages/core/src/index.ts

@@ -14,7 +14,6 @@ export type {
   RoleMeta,
   StartSignal,
   RoleSignal,
-  ModeratorContext,
   Moderator,
   WorkflowDefinition,
   SenseResult,
@@ -33,16 +32,3 @@ export {
   parseSenseWorkflowDirective,
   routeSenseComputeOutput,
 } from "./sense-workflow-directive.js";
-
-export type {
-  DaemonIpcTriggerWorkflowRequest,
-  DaemonIpcTriggerSenseRequest,
-  DaemonIpcListSensesRequest,
-  DaemonIpcRequest,
-  DaemonIpcTriggerOkResponse,
-  DaemonIpcErrorResponse,
-  DaemonIpcTriggerResponse,
-  DaemonIpcListSensesResponse,
-  DaemonIpcResponse,
-} from "./daemon-ipc-protocol.js";
-export { parseDaemonIpcRequest } from "./daemon-ipc-protocol.js";

packages/core/src/types.ts

@@ -2,7 +2,7 @@ export type Signal = {
   id: number;
   senseId: string;
   payload: unknown;
-  timestamp: number;
+  ts: number;
 };
 
 export type SenseConfig = {
@@ -18,14 +18,14 @@ export type SenseInfo = {
   group: string;
   throttle: number | null;
   timeout: number | null;
-  lastSignalTimestamp: number | null;
+  lastSignalTs: number | null;
 };
 
 export type SenseReflexConfig = {
   kind: "sense";
   sense: string;
   interval: number | null;
-  on: string[];
+  on: string[] | null;
 };
 
 /** Reflexes only schedule Senses; workflow launches come from Sense return values. */
@@ -49,7 +49,7 @@ export type NerveConfig = {
   maxRounds: number;
   senses: Record<string, SenseConfig>;
   reflexes: ReflexConfig[];
-  workflows: Record<string, WorkflowConfig>;
+  workflows: Record<string, WorkflowConfig> | null;
 };
 
 // ---------------------------------------------------------------------------
@@ -76,24 +76,20 @@ export type WorkflowMessage = {
 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,
+ * A Role is a pure async function: receives the full message chain,
+ * returns typed content + meta. Implementation can be an agent, LLM call,
  * script, HTTP request, etc.
  */
-export type Role<Meta> = (
-  start: StartSignal,
-  messages: WorkflowMessage[],
-) => Promise<RoleResult<Meta>>;
+export type Role<Meta> = (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: prompt, max rounds cap, dry-run flag, and timestamps for the thread. */
+/** First message in the thread chain (`messages[0]`) — passed to the moderator on start. */
 export type StartSignal = {
   role: START;
   content: string;
-  meta: { maxRounds: number; dryRun: boolean };
+  meta: { maxRounds: number };
   timestamp: number;
 };
 
@@ -103,19 +99,11 @@ export type RoleSignal<M extends RoleMeta> = {
 }[keyof M & string];
 
 /**
- * Moderator input: either the initial start frame or a role signal after a step.
- * Lets implementations branch on `context.kind` with full typing for each arm.
- */
-export type ModeratorContext<M extends RoleMeta> =
-  | { kind: "start"; start: StartSignal }
-  | { kind: "step"; signal: RoleSignal<M> };
-
-/**
- * The moderator — a pure routing function. Receives start vs step context,
+ * The moderator — a pure routing function. Receives the last signal,
  * current round, and maxRounds. Returns the next role name or END.
  */
 export type Moderator<M extends RoleMeta> = (
-  context: ModeratorContext<M>,
+  signal: StartSignal | RoleSignal<M>,
   round: number,
   maxRounds: number,
 ) => (keyof M & string) | END;

packages/daemon/README.md

@@ -4,33 +4,18 @@ The observation engine runtime for [nerve](../../README.md) — runs senses, rou
 
 ## Architecture
 
-| Module | Source (indicative) | Responsibility |
-|--------|---------------------|----------------|
-| **Kernel** | `kernel.ts` | Orchestrator — worker pool, signal bus, reflex 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 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 |
-| **Reflex scheduler** | `reflex-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/` — 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 |
-
-## Crash recovery (workflow workers)
-
-If a workflow worker exits unexpectedly while threads are active:
-
-- In-flight runs are marked **`crashed`** in the log store; the manager respawns a fresh worker.
-- Runs still in **`started`** state can be **`resume-thread`**’d: the manager rebuilds the message chain from persisted workflow log rows and sends `resume-thread` to the new worker.
-- **Crash-loop backoff:** repeated crashes for the same workflow name are counted in a sliding window (`60s`); after **`5`** crashes in that window, the manager **stops respawning** that worker and logs the condition (avoids tight crash loops).
-
-Hot reload (`drainAndRespawn`) uses a controlled drain: in-flight runs may be marked **`interrupted`** when the old worker is torn down after a timeout — that path is distinct from unexpected crash recovery.
+| Module | Responsibility |
+|--------|---------------|
+| **Kernel** | Top-level orchestrator — spawns workers, wires up signal bus, scheduler, and workflow manager. Supports hot reload and graceful shutdown. |
+| **Sense Runtime** | Per-sense SQLite database (via `node:sqlite` + Drizzle ORM), migration runner, peer DB read access. |
+| **Sense Worker** | Forked child process — one per sense group. Runs compute functions in isolation. |
+| **Signal Bus** | In-memory pub/sub. Sense computes emit signals; reflexes and workflows subscribe. |
+| **Reflex Scheduler** | Drives compute triggers — interval timers, signal-based events, throttle/coalesce logic. |
+| **Workflow Manager** | Concurrency control (drop/queue), thread lifecycle, worker process management (RFC-002). |
+| **Log Store** | Structured log storage in WAL-mode SQLite. Supports retention policies, archival to JSONL, and workflow run tracking. |
+| **Blob Store** | Binary artifact storage for workflow outputs. |
+| **File Watcher** | Watches `nerve.yaml` and sense files for hot reload. |
+| **Daemon IPC** | Unix socket server for CLI ↔ daemon communication. |
 
 ## Key Design Decisions
 
@@ -41,44 +26,24 @@ Hot reload (`drainAndRespawn`) uses a controlled drain: in-flight runs may be ma
 
 ## Usage
 
-The daemon is typically started via the CLI (`nerve daemon start` / `nerve dev`), but you can embed the kernel:
+The daemon is typically started via the CLI (`nerve daemon start`), but can be used programmatically:
 
 ```typescript
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-import { parseNerveConfig } from "@uncaged/nerve-core";
 import { createKernel } from "@uncaged/nerve-daemon";
 
-const nerveRoot = "/path/to/workspace";
-const yamlPath = join(nerveRoot, "nerve.yaml");
-const parsed = parseNerveConfig(readFileSync(yamlPath, "utf8"));
-if (!parsed.ok) {
-  throw parsed.error;
-}
-
-const kernel = createKernel(parsed.value, nerveRoot, {
-  enableFileWatcher: true,
-  ipcSocketPath: join(nerveRoot, "nerve.sock"),
-});
-
+const kernel = await createKernel(nerveRoot);
 await kernel.ready;
 
+// Trigger a sense manually
 kernel.triggerSense("cpu-usage");
+
+// Check health
 const health = kernel.getHealth();
 
+// Graceful shutdown
 await kernel.stop();
 ```
 
-`createKernel(config, nerveRoot, options?)` — `config` is a parsed `NerveConfig`; `nerveRoot` is the workspace root (contains `nerve.yaml`, `data/`, etc.). Optional `KernelOptions`:
-
-| Field | Meaning |
-|-------|---------|
-| `workerScript` | Override path to the sense worker entry script (defaults to the package’s resolved worker) |
-| `enableFileWatcher` | Watch config / senses / workflows for hot reload |
-| `logStore` | Inject a `LogStore` instance (defaults to `createLogStore(join(nerveRoot, "data", "logs.db"))`) |
-| `ipcSocketPath` | When non-null, listen for daemon IPC on this Unix socket path |
-
 ## Install
 
 ```bash

packages/daemon/package.json

@@ -4,7 +4,9 @@
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "publishConfig": {
     "access": "public"
   },

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

@@ -127,8 +127,8 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("my-wf", { prompt: "test 1", maxRounds: 10, dryRun: false });
-      mgr.startWorkflow("my-wf", { prompt: "test 2", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("my-wf", { prompt: "test 1", maxRounds: 10 });
+      mgr.startWorkflow("my-wf", { prompt: "test 2", maxRounds: 10 });
       expect(mgr.activeCount("my-wf")).toBe(2);
 
       // Simulate unexpected exit (not shutdown)
@@ -154,8 +154,8 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
-      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
+      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
       expect(mgr.activeCount("my-wf")).toBe(2);
 
       const child = mockChildren[0];
@@ -179,7 +179,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
       expect(mockChildren).toHaveLength(1);
 
       const child = mockChildren[0];
@@ -212,7 +212,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
       const firstChild = mockChildren[0];
       firstChild.exitCode = 1;
       firstChild.connected = false;
@@ -256,7 +256,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
       // Start one thread to fill the concurrency slot (so queued run stays queued on respawn)
-      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
       const firstChild = mockChildren[0];
       firstChild.exitCode = 1;
       firstChild.connected = false;
@@ -281,7 +281,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
 
       const child = mockChildren[0];
       const startCall = (child.send as ReturnType<typeof vi.fn>).mock.calls[0];
@@ -317,7 +317,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      const launch = { prompt: "build-docker for myrepo", maxRounds: 10, dryRun: false };
+      const launch = { prompt: "build-docker for myrepo", maxRounds: 10 };
       mgr.startWorkflow("my-wf", launch);
 
       const startedCall = logStore.upsertWorkflowRun.mock.calls.find(
@@ -327,11 +327,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       const logEntry = startedCall?.[0] as { payload: string | null };
       expect(logEntry.payload).not.toBeNull();
       const parsed = JSON.parse(logEntry.payload as string) as Record<string, unknown>;
-      expect(parsed).toMatchObject({
-        prompt: "build-docker for myrepo",
-        maxRounds: 10,
-        dryRun: false,
-      });
+      expect(parsed).toMatchObject({ prompt: "build-docker for myrepo", maxRounds: 10 });
 
       const stopPromise = mgr.stop();
       await vi.runAllTimersAsync();
@@ -353,7 +349,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
       // Start one thread to fill the concurrency slot
-      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
       const firstChild = mockChildren[0];
 
       // Crash once → respawn → crash again → second respawn
@@ -389,7 +385,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
       const firstChild = mockChildren[0];
       firstChild.exitCode = 1;
       firstChild.connected = false;
@@ -419,7 +415,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("crash-wf", { prompt: "test", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("crash-wf", { prompt: "test", maxRounds: 10 });
 
       // Crash the worker 6 times in rapid succession (within CRASH_WINDOW_MS = 60s)
       for (let i = 0; i < 6; i++) {

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

@@ -2,7 +2,7 @@
  * Unit + integration tests for daemon-ipc.ts — trigger-sense request type.
  *
  * Tests cover:
- *   - parseDaemonIpcRequest (core) / server correctly accept or reject trigger-sense messages
+ *   - parseRequest correctly accepts/rejects trigger-sense messages
  *   - createDaemonIpcServer routes trigger-sense to opts.triggerSense
  *   - Error response when triggerSense throws (unknown sense)
  *   - Success response on valid sense trigger
@@ -154,7 +154,6 @@ describe("daemon-ipc — trigger-sense", () => {
       workflow: "my-workflow",
       prompt: "test prompt",
       maxRounds: 10,
-      dryRun: false,
     });
 
     expect(resp).toEqual({ ok: true });
@@ -162,7 +161,6 @@ describe("daemon-ipc — trigger-sense", () => {
     expect(wfManager.startWorkflow).toHaveBeenCalledWith("my-workflow", {
       prompt: "test prompt",
       maxRounds: 10,
-      dryRun: false,
     });
   });
 
@@ -200,20 +198,8 @@ describe("daemon-ipc — list-senses", () => {
 
   it("responds ok:true with senses populated from listSenses", async () => {
     const sensesData = [
-      {
-        name: "cpu-usage",
-        group: "system",
-        throttle: 5000,
-        timeout: 3000,
-        lastSignalTimestamp: 1000,
-      },
-      {
-        name: "disk-usage",
-        group: "system",
-        throttle: 30000,
-        timeout: null,
-        lastSignalTimestamp: null,
-      },
+      { name: "cpu-usage", group: "system", throttle: 5000, timeout: 3000, lastSignalTs: 1000 },
+      { name: "disk-usage", group: "system", throttle: 30000, timeout: null, lastSignalTs: null },
     ];
     const listSenses = vi.fn(() => sensesData);
     server = createDaemonIpcServer(sockPath, makeMockWorkflowManager() as never, {

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

@@ -102,7 +102,7 @@ describe("WorkflowManager — drainAndRespawn (Phase 3 hot reload)", () => {
     const config = makeWfConfig({ "my-wf": { concurrency: 1, overflow: "drop" } });
     const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
+    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
     expect(mockChildren).toHaveLength(1);
 
     // Remove workflow from config before drain completes
@@ -121,8 +121,8 @@ describe("WorkflowManager — drainAndRespawn (Phase 3 hot reload)", () => {
     const config = makeWfConfig({ "my-wf": { concurrency: 2, overflow: "drop" } });
     const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
-    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
+    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
+    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
     expect(mgr.activeCount("my-wf")).toBe(2);
 
     const drainPromise = mgr.drainAndRespawn("my-wf", 5000);
@@ -153,7 +153,7 @@ describe("WorkflowManager — drainAndRespawn (Phase 3 hot reload)", () => {
     const config = makeWfConfig({ "my-wf": { concurrency: 1, overflow: "drop" } });
     const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
+    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
     expect(mockChildren).toHaveLength(1);
 
     const drainPromise = mgr.drainAndRespawn("my-wf", 5000);
@@ -169,7 +169,7 @@ describe("WorkflowManager — drainAndRespawn (Phase 3 hot reload)", () => {
     const config = makeWfConfig({ "my-wf": { concurrency: 1, overflow: "drop" } });
     const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
+    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
     expect(mockChildren).toHaveLength(1);
 
     const drainPromise = mgr.drainAndRespawn("my-wf", 5000);
@@ -186,7 +186,7 @@ describe("WorkflowManager — drainAndRespawn (Phase 3 hot reload)", () => {
     const config = makeWfConfig({ "my-wf": { concurrency: 1, overflow: "drop" } });
     const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
+    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
 
     const drainPromise = mgr.drainAndRespawn("my-wf", 5000);
     await vi.runAllTimersAsync();
@@ -211,14 +211,14 @@ describe("WorkflowManager — drainAndRespawn (Phase 3 hot reload)", () => {
     const config = makeWfConfig({ "my-wf": { concurrency: 1, overflow: "drop" } });
     const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-    mgr.startWorkflow("my-wf", { prompt: "first", maxRounds: 10, dryRun: false });
+    mgr.startWorkflow("my-wf", { prompt: "first", maxRounds: 10 });
 
     const drainPromise = mgr.drainAndRespawn("my-wf", 5000);
     await vi.runAllTimersAsync();
     await drainPromise;
 
     // Start a new thread on the fresh worker
-    mgr.startWorkflow("my-wf", { prompt: "second", maxRounds: 10, dryRun: false });
+    mgr.startWorkflow("my-wf", { prompt: "second", maxRounds: 10 });
 
     const newChild = mockChildren[1];
     const startCalls = (newChild.send as ReturnType<typeof vi.fn>).mock.calls.filter(
@@ -250,7 +250,7 @@ describe("Kernel — workflow hot reload via file-watcher (Phase 3)", () => {
     const logStore = makeLogStore();
     const config: NerveConfig = {
       senses: {},
-      reflexes: [],
+      reflexes: [{ kind: "workflow", workflow: "my-wf", on: null } as any],
       workflows: { "my-wf": { concurrency: 1, overflow: "drop" } },
       maxRounds: 10,
     };
@@ -261,7 +261,7 @@ describe("Kernel — workflow hot reload via file-watcher (Phase 3)", () => {
     });
 
     // Trigger a workflow thread so a worker is spawned
-    kernel.workflowManager.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
+    kernel.workflowManager.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
 
     // Manually call drainAndRespawn (simulating what kernel does on workflow file change)
     const drainPromise = kernel.workflowManager.drainAndRespawn("my-wf", 1000);
@@ -285,7 +285,7 @@ describe("Kernel — workflow hot reload via file-watcher (Phase 3)", () => {
     const logStore = makeLogStore();
     const initialConfig: NerveConfig = {
       senses: {},
-      reflexes: [],
+      reflexes: [{ kind: "workflow", workflow: "old-wf", on: null } as any],
       workflows: { "old-wf": { concurrency: 1, overflow: "drop" } },
       maxRounds: 10,
     };
@@ -296,18 +296,14 @@ describe("Kernel — workflow hot reload via file-watcher (Phase 3)", () => {
     });
 
     // Spawn a worker for old-wf
-    kernel.workflowManager.startWorkflow("old-wf", {
-      prompt: "test",
-      maxRounds: 10,
-      dryRun: false,
-    });
+    kernel.workflowManager.startWorkflow("old-wf", { prompt: "test", maxRounds: 10 });
     expect(mockChildren).toHaveLength(1);
 
     // Reload config without old-wf
     const newConfig: NerveConfig = {
       senses: {},
       reflexes: [],
-      workflows: {},
+      workflows: null,
       maxRounds: 10,
     };
     kernel.reloadConfig(newConfig);
@@ -328,7 +324,7 @@ describe("Kernel — workflow hot reload via file-watcher (Phase 3)", () => {
     const logStore = makeLogStore();
     const initialConfig: NerveConfig = {
       senses: {},
-      reflexes: [],
+      reflexes: [{ kind: "workflow", workflow: "my-wf", on: null } as any],
       workflows: { "my-wf": { concurrency: 1, overflow: "drop" } },
       maxRounds: 10,
     };
@@ -338,13 +334,13 @@ describe("Kernel — workflow hot reload via file-watcher (Phase 3)", () => {
       logStore,
     });
 
-    kernel.workflowManager.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
+    kernel.workflowManager.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
     const workersBefore = mockChildren.length;
 
     // Reload with updated concurrency — should NOT spawn a new workflow worker
     const newConfig: NerveConfig = {
       senses: {},
-      reflexes: [],
+      reflexes: [{ kind: "workflow", workflow: "my-wf", on: null } as any],
       workflows: { "my-wf": { concurrency: 5, overflow: "queue", maxQueue: 50 } },
       maxRounds: 10,
     };
@@ -358,8 +354,8 @@ describe("Kernel — workflow hot reload via file-watcher (Phase 3)", () => {
     expect(kernel.workflowManager.activeCount("my-wf")).toBe(1);
 
     // Can now start up to 5 concurrent threads (previously only 1)
-    kernel.workflowManager.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
-    kernel.workflowManager.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
+    kernel.workflowManager.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
+    kernel.workflowManager.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
     expect(kernel.workflowManager.activeCount("my-wf")).toBe(3);
 
     const stopPromise = kernel.stop();

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

@@ -26,7 +26,7 @@ function makeConfig(overrides: Partial<NerveConfig> = {}): NerveConfig {
       "cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
     },
     reflexes: [],
-    workflows: {},
+    workflows: null,
     maxRounds: 10,
     ...overrides,
   };

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

@@ -73,7 +73,7 @@ function makeConfig(overrides: Partial<NerveConfig> = {}): NerveConfig {
       "cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
     },
     reflexes: [],
-    workflows: {},
+    workflows: null,
     maxRounds: 10,
     ...overrides,
   };
@@ -180,7 +180,7 @@ describe("kernel — reloadConfig", () => {
         "net-rx": { group: "network", throttle: null, timeout: null, gracePeriod: null },
       },
       reflexes: [],
-      workflows: {},
+      workflows: null,
       maxRounds: 10,
     });
 
@@ -197,7 +197,7 @@ describe("kernel — reloadConfig", () => {
         "net-rx": { group: "network", throttle: null, timeout: null, gracePeriod: null },
       },
       reflexes: [],
-      workflows: {},
+      workflows: null,
       maxRounds: 10,
     };
     const kernel = createKernel(config, "/tmp/nerve-test");
@@ -212,7 +212,7 @@ describe("kernel — reloadConfig", () => {
         "cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
       },
       reflexes: [],
-      workflows: {},
+      workflows: null,
       maxRounds: 10,
     });
 
@@ -235,7 +235,7 @@ describe("kernel — reloadConfig", () => {
         "disk-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
       },
       reflexes: [],
-      workflows: {},
+      workflows: null,
       maxRounds: 10,
     });
 

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

@@ -92,7 +92,7 @@ function makeConfig(overrides: Partial<NerveConfig> = {}): NerveConfig {
       "cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
     },
     reflexes: [],
-    workflows: {},
+    workflows: null,
     maxRounds: 10,
     ...overrides,
   };

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

@@ -95,7 +95,7 @@ function makeConfig(overrides: Partial<NerveConfig> = {}): NerveConfig {
       "cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
     },
     reflexes: [],
-    workflows: {},
+    workflows: null,
     maxRounds: 10,
     ...overrides,
   };
@@ -202,7 +202,6 @@ describe("kernel + workflowManager integration", () => {
         workflow: "alert-workflow",
         prompt: "handle critical alert",
         maxRounds: 5,
-        dryRun: false,
       });
 
       const stopPromise = kernel.stop();
@@ -298,7 +297,7 @@ describe("kernel + workflowManager integration", () => {
           "cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
         },
         reflexes: [],
-        workflows: {},
+        workflows: null,
         maxRounds: 10,
       });
 
@@ -366,7 +365,7 @@ describe("kernel + workflowManager integration", () => {
           "cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
         },
         reflexes: [],
-        workflows: {},
+        workflows: null,
         maxRounds: 10,
       };
       kernel.reloadConfig(newConfig);

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

@@ -59,7 +59,7 @@ function makeConfig(overrides: Partial<NerveConfig> = {}): NerveConfig {
       "cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
     },
     reflexes: [],
-    workflows: {},
+    workflows: null,
     maxRounds: 10,
     ...overrides,
   };
@@ -200,7 +200,7 @@ describe("kernel — groupForSense mapping", () => {
         "net-usage": { group: "network", throttle: null, timeout: null, gracePeriod: null },
       },
       reflexes: [],
-      workflows: {},
+      workflows: null,
       maxRounds: 10,
     };
     const kernel = createKernel(config, "/tmp/nerve-test");
@@ -215,7 +215,7 @@ describe("kernel — groupForSense mapping", () => {
       senses: {
         "cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
       },
-      reflexes: [{ kind: "sense", sense: "cpu-usage", interval: 500, on: [] }],
+      reflexes: [{ kind: "sense", sense: "cpu-usage", interval: 500, on: null }],
     });
     createKernel(config, "/tmp/nerve-test");
 

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

@@ -29,7 +29,7 @@ describe("LogStore + ReflexScheduler integration", () => {
         "cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
       },
       reflexes: [{ kind: "sense", sense: "cpu-usage", interval: null, on: ["cpu-usage"] }],
-      workflows: {},
+      workflows: null,
       maxRounds: 10,
     };
     const bus = createSignalBus();
@@ -38,7 +38,7 @@ describe("LogStore + ReflexScheduler integration", () => {
       logStore,
     });
 
-    const signal: Signal = { id: 1, senseId: "cpu-usage", payload: 42, timestamp: Date.now() };
+    const signal: Signal = { id: 1, senseId: "cpu-usage", payload: 42, ts: Date.now() };
     bus.emit(signal);
 
     const logs = logStore.query({ source: "reflex", type: "run_start" });
@@ -56,8 +56,8 @@ describe("LogStore + ReflexScheduler integration", () => {
       senses: {
         "cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
       },
-      reflexes: [{ kind: "sense", sense: "cpu-usage", interval: 1000, on: [] }],
-      workflows: {},
+      reflexes: [{ kind: "sense", sense: "cpu-usage", interval: 1000, on: null }],
+      workflows: null,
       maxRounds: 10,
     };
     const bus = createSignalBus();
@@ -88,7 +88,7 @@ describe("LogStore + ReflexScheduler integration", () => {
         "cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
       },
       reflexes: [{ kind: "sense", sense: "cpu-usage", interval: null, on: ["cpu-usage"] }],
-      workflows: {},
+      workflows: null,
       maxRounds: 10,
     };
     const bus = createSignalBus();

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

@@ -23,7 +23,7 @@ function makeConfig(overrides: Partial<NerveConfig> = {}): NerveConfig {
       "cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
     },
     reflexes: [],
-    workflows: {},
+    workflows: null,
     maxRounds: 10,
     ...overrides,
   };
@@ -136,7 +136,7 @@ describe("phase6 — reloadConfig", () => {
         "net-rx": { group: "network", throttle: null, timeout: null, gracePeriod: null },
       },
       reflexes: [],
-      workflows: {},
+      workflows: null,
       maxRounds: 10,
     };
 
@@ -156,7 +156,7 @@ describe("phase6 — reloadConfig", () => {
         "net-rx": { group: "network", throttle: null, timeout: null, gracePeriod: null },
       },
       reflexes: [],
-      workflows: {},
+      workflows: null,
       maxRounds: 10,
     };
     kernel = createKernel(config, "/tmp/nerve-phase6-test", {
@@ -171,7 +171,7 @@ describe("phase6 — reloadConfig", () => {
         "cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
       },
       reflexes: [],
-      workflows: {},
+      workflows: null,
       maxRounds: 10,
     };
 
@@ -202,7 +202,7 @@ describe("phase6 — error isolation", () => {
         "bad-sense": { group: "mixed", throttle: null, timeout: null, gracePeriod: null },
       },
       reflexes: [],
-      workflows: {},
+      workflows: null,
       maxRounds: 10,
     };
 
@@ -306,7 +306,7 @@ describe("phase6 — getHealth", () => {
         "net-rx": { group: "network", throttle: null, timeout: null, gracePeriod: null },
       },
       reflexes: [],
-      workflows: {},
+      workflows: null,
       maxRounds: 10,
     };
     kernel.reloadConfig(newConfig);

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

@@ -10,14 +10,14 @@ function makeConfig(overrides: Partial<NerveConfig> = {}): NerveConfig {
       "cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
     },
     reflexes: [],
-    workflows: {},
+    workflows: null,
     maxRounds: 10,
     ...overrides,
   };
 }
 
 function makeSignal(senseId: string, payload: unknown = 1): Signal {
-  return { id: 1, senseId, payload, timestamp: Date.now() };
+  return { id: 1, senseId, payload, ts: Date.now() };
 }
 
 describe("ReflexScheduler — throttle + pending deferred trigger", () => {

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

@@ -16,14 +16,14 @@ function makeConfig(overrides: Partial<NerveConfig> = {}): NerveConfig {
       "system-health": { group: "derived", throttle: null, timeout: null, gracePeriod: null },
     },
     reflexes: [],
-    workflows: {},
+    workflows: null,
     maxRounds: 10,
     ...overrides,
   };
 }
 
 function makeSignal(senseId: string, payload: unknown = 1): Signal {
-  return { id: 1, senseId, payload, timestamp: Date.now() };
+  return { id: 1, senseId, payload, ts: Date.now() };
 }
 
 // ---------------------------------------------------------------------------
@@ -41,7 +41,7 @@ describe("ReflexScheduler — interval reflex", () => {
   it("fires triggerFn on schedule", () => {
     const triggered: string[] = [];
     const config = makeConfig({
-      reflexes: [{ kind: "sense", sense: "cpu-usage", interval: 1000, on: [] }],
+      reflexes: [{ kind: "sense", sense: "cpu-usage", interval: 1000, on: null }],
     });
     const bus = createSignalBus();
     // Use a ref so the triggerFn can call back into the scheduler
@@ -66,7 +66,7 @@ describe("ReflexScheduler — interval reflex", () => {
   it("stops firing after stop() is called", () => {
     const triggered: string[] = [];
     const config = makeConfig({
-      reflexes: [{ kind: "sense", sense: "cpu-usage", interval: 500, on: [] }],
+      reflexes: [{ kind: "sense", sense: "cpu-usage", interval: 500, on: null }],
     });
     const bus = createSignalBus();
     const ref: { scheduler: ReturnType<typeof createReflexScheduler> | null } = {
@@ -89,7 +89,7 @@ describe("ReflexScheduler — interval reflex", () => {
   it("starts from current time — does not compensate for past intervals", () => {
     const triggered: string[] = [];
     const config = makeConfig({
-      reflexes: [{ kind: "sense", sense: "cpu-usage", interval: 1000, on: [] }],
+      reflexes: [{ kind: "sense", sense: "cpu-usage", interval: 1000, on: null }],
     });
     const bus = createSignalBus();
     const scheduler = createReflexScheduler(config, bus, (name) => triggered.push(name));

packages/daemon/src/__tests__/signal-bus.test.ts

@@ -4,7 +4,7 @@ import type { Signal } from "@uncaged/nerve-core";
 import { createSignalBus } from "../signal-bus.js";
 
 function makeSignal(senseId: string, payload: unknown = 1): Signal {
-  return { id: 1, senseId, payload, timestamp: Date.now() };
+  return { id: 1, senseId, payload, ts: Date.now() };
 }
 
 describe("createSignalBus", () => {

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

@@ -115,7 +115,7 @@ describe("WorkflowManager", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("my-workflow", { prompt: "test", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("my-workflow", { prompt: "test", maxRounds: 10 });
 
       expect(mockChildren).toHaveLength(1);
       expect(mockChildren[0].send).toHaveBeenCalledWith(
@@ -131,8 +131,8 @@ describe("WorkflowManager", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("my-workflow", { prompt: "test 1", maxRounds: 10, dryRun: false });
-      mgr.startWorkflow("my-workflow", { prompt: "test 2", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("my-workflow", { prompt: "test 1", maxRounds: 10 });
+      mgr.startWorkflow("my-workflow", { prompt: "test 2", maxRounds: 10 });
 
       // Only one forked child — worker is reused
       expect(mockChildren).toHaveLength(1);
@@ -147,7 +147,7 @@ describe("WorkflowManager", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("my-workflow", { prompt: "test", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("my-workflow", { prompt: "test", maxRounds: 10 });
 
       expect(logStore.upsertWorkflowRun).toHaveBeenCalledWith(
         expect.objectContaining({ source: "workflow", type: "started" }),
@@ -164,9 +164,9 @@ describe("WorkflowManager", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("drop-wf", { prompt: "first", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("drop-wf", { prompt: "first", maxRounds: 10 });
       // now at limit — second call should be dropped
-      mgr.startWorkflow("drop-wf", { prompt: "second", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("drop-wf", { prompt: "second", maxRounds: 10 });
 
       expect(mgr.activeCount("drop-wf")).toBe(1);
       expect(mgr.queueLength("drop-wf")).toBe(0);
@@ -181,8 +181,8 @@ describe("WorkflowManager", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("drop-wf", { prompt: "test", maxRounds: 10, dryRun: false });
-      mgr.startWorkflow("drop-wf", { prompt: "test", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("drop-wf", { prompt: "test", maxRounds: 10 });
+      mgr.startWorkflow("drop-wf", { prompt: "test", maxRounds: 10 });
 
       const droppedCall = logStore.upsertWorkflowRun.mock.calls.find(
         ([entry]) => entry.type === "dropped",
@@ -199,8 +199,8 @@ describe("WorkflowManager", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("queue-wf", { prompt: "first", maxRounds: 10, dryRun: false });
-      mgr.startWorkflow("queue-wf", { prompt: "second", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("queue-wf", { prompt: "first", maxRounds: 10 });
+      mgr.startWorkflow("queue-wf", { prompt: "second", maxRounds: 10 });
 
       expect(mgr.activeCount("queue-wf")).toBe(1);
       expect(mgr.queueLength("queue-wf")).toBe(1);
@@ -213,8 +213,8 @@ describe("WorkflowManager", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("queue-wf", { prompt: "test", maxRounds: 10, dryRun: false });
-      mgr.startWorkflow("queue-wf", { prompt: "test", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("queue-wf", { prompt: "test", maxRounds: 10 });
+      mgr.startWorkflow("queue-wf", { prompt: "test", maxRounds: 10 });
 
       const queuedCall = logStore.upsertWorkflowRun.mock.calls.find(
         ([entry]) => entry.type === "queued",
@@ -233,12 +233,12 @@ describe("WorkflowManager", () => {
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
       // Fill the concurrency slot
-      mgr.startWorkflow("queue-wf", { prompt: "test 0", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("queue-wf", { prompt: "test 0", maxRounds: 10 });
       // Fill the queue to maxQueue
-      mgr.startWorkflow("queue-wf", { prompt: "test 1", maxRounds: 10, dryRun: false });
-      mgr.startWorkflow("queue-wf", { prompt: "test 2", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("queue-wf", { prompt: "test 1", maxRounds: 10 });
+      mgr.startWorkflow("queue-wf", { prompt: "test 2", maxRounds: 10 });
       // This one should push out the oldest
-      mgr.startWorkflow("queue-wf", { prompt: "test 3", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("queue-wf", { prompt: "test 3", maxRounds: 10 });
 
       // Queue should still be at maxQueue (2)
       expect(mgr.queueLength("queue-wf")).toBe(2);
@@ -259,8 +259,8 @@ describe("WorkflowManager", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("queue-wf", { prompt: "first", maxRounds: 10, dryRun: false });
-      mgr.startWorkflow("queue-wf", { prompt: "second", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("queue-wf", { prompt: "first", maxRounds: 10 });
+      mgr.startWorkflow("queue-wf", { prompt: "second", maxRounds: 10 });
 
       expect(mgr.activeCount("queue-wf")).toBe(1);
       expect(mgr.queueLength("queue-wf")).toBe(1);
@@ -294,8 +294,8 @@ describe("WorkflowManager", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("queue-wf", { prompt: "first", maxRounds: 10, dryRun: false });
-      mgr.startWorkflow("queue-wf", { prompt: "second", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("queue-wf", { prompt: "first", maxRounds: 10 });
+      mgr.startWorkflow("queue-wf", { prompt: "second", maxRounds: 10 });
 
       const child = mockChildren[0];
       const firstRunId = (child.send as ReturnType<typeof vi.fn>).mock.calls[0][0].runId as string;
@@ -321,8 +321,8 @@ describe("WorkflowManager", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("wf-a", { prompt: "test", maxRounds: 10, dryRun: false });
-      mgr.startWorkflow("wf-b", { prompt: "test", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("wf-a", { prompt: "test", maxRounds: 10 });
+      mgr.startWorkflow("wf-b", { prompt: "test", maxRounds: 10 });
 
       // Two distinct workers should have been forked
       expect(mockChildren).toHaveLength(2);
@@ -348,7 +348,7 @@ describe("WorkflowManager", () => {
       await vi.runAllTimersAsync();
       await stopPromise;
 
-      mgr.startWorkflow("wf-a", { prompt: "test", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("wf-a", { prompt: "test", maxRounds: 10 });
 
       // No worker should have been spawned
       expect(mockChildren).toHaveLength(0);
@@ -361,7 +361,7 @@ describe("WorkflowManager", () => {
       const config = makeConfig({});
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("no-such-workflow", { prompt: "test", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("no-such-workflow", { prompt: "test", maxRounds: 10 });
 
       expect(mockChildren).toHaveLength(0);
       expect(logStore.upsertWorkflowRun).not.toHaveBeenCalled();

packages/daemon/src/daemon-ipc.ts

@@ -2,24 +2,83 @@
  * Daemon IPC server — listens on a Unix domain socket so that the CLI
  * can send commands (e.g. trigger-workflow, trigger-sense) to the running daemon process.
  *
- * Protocol: newline-delimited JSON — request/response types and
- * `parseDaemonIpcRequest` live in `@uncaged/nerve-core`.
+ * Protocol: newline-delimited JSON messages.
+ * Each request: { type: "trigger-workflow"; workflow: string; payload: unknown }
+ *             | { type: "trigger-sense"; sense: string }
+ *             | { type: "list-senses" }
+ * Each response: { ok: true } | { ok: false; error: string }
+ *              | { ok: true; senses: SenseInfo[] }  (for list-senses)
  */
 
 import { rmSync } from "node:fs";
 import { type Server, type Socket, createServer } from "node:net";
 
-import type { DaemonIpcResponse, SenseInfo } from "@uncaged/nerve-core";
-import { parseDaemonIpcRequest } from "@uncaged/nerve-core";
+import type { SenseInfo } from "@uncaged/nerve-core";
+import { isPlainRecord } from "@uncaged/nerve-core";
 
 import type { WorkflowManager } from "./workflow-manager.js";
 
 export type { SenseInfo };
 
+/** JSON message sent by the CLI to trigger a workflow. */
+export type TriggerWorkflowRequest = {
+  type: "trigger-workflow";
+  workflow: string;
+  prompt: string;
+  maxRounds: number;
+};
+
+/** JSON message sent by the CLI to trigger a sense compute on-demand. */
+export type TriggerSenseRequest = {
+  type: "trigger-sense";
+  sense: string;
+};
+
+/** JSON message sent by the CLI to list registered senses. */
+export type ListSensesRequest = {
+  type: "list-senses";
+};
+
+type DaemonRequest = TriggerWorkflowRequest | TriggerSenseRequest | ListSensesRequest;
+
+type DaemonResponse =
+  | { ok: true }
+  | { ok: false; error: string }
+  | { ok: true; senses: SenseInfo[] };
+
 export type DaemonIpcServer = {
   close: () => Promise<void>;
 };
 
+function parseRequest(line: string): DaemonRequest | null {
+  try {
+    const obj: unknown = JSON.parse(line);
+    if (!isPlainRecord(obj)) return null;
+    const req = obj;
+    if (req.type === "trigger-workflow") {
+      if (typeof req.workflow !== "string" || req.workflow.length === 0) return null;
+      if (typeof req.prompt !== "string") return null;
+      if (typeof req.maxRounds !== "number") return null;
+      return {
+        type: "trigger-workflow",
+        workflow: req.workflow,
+        prompt: req.prompt,
+        maxRounds: req.maxRounds,
+      };
+    }
+    if (req.type === "trigger-sense") {
+      if (typeof req.sense !== "string" || req.sense.length === 0) return null;
+      return { type: "trigger-sense", sense: req.sense };
+    }
+    if (req.type === "list-senses") {
+      return { type: "list-senses" };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
 export type DaemonIpcServerOptions = {
   /** Called when a trigger-sense request arrives. Should throw if the sense is unknown. */
   triggerSense: (senseName: string) => void;
@@ -43,9 +102,9 @@ export function createDaemonIpcServer(
     const trimmed = line.trim();
     if (trimmed.length === 0) return;
 
-    const req = parseDaemonIpcRequest(trimmed);
+    const req = parseRequest(trimmed);
     if (req === null) {
-      const resp: DaemonIpcResponse = { ok: false, error: "Invalid request" };
+      const resp: DaemonResponse = { ok: false, error: "Invalid request" };
       socket.write(`${JSON.stringify(resp)}\n`);
       return;
     }
@@ -55,25 +114,21 @@ export function createDaemonIpcServer(
         workflowManager.startWorkflow(req.workflow, {
           prompt: req.prompt,
           maxRounds: req.maxRounds,
-          dryRun: req.dryRun,
         });
-        const resp: DaemonIpcResponse = { ok: true };
+        const resp: DaemonResponse = { ok: true };
         socket.write(`${JSON.stringify(resp)}\n`);
       } else if (req.type === "trigger-sense") {
         opts.triggerSense(req.sense);
-        const resp: DaemonIpcResponse = { ok: true };
+        const resp: DaemonResponse = { ok: true };
         socket.write(`${JSON.stringify(resp)}\n`);
       } else if (req.type === "list-senses") {
         const senses = opts.listSenses();
-        const resp: DaemonIpcResponse = { ok: true, senses };
+        const resp: DaemonResponse = { ok: true, senses };
         socket.write(`${JSON.stringify(resp)}\n`);
-      } else {
-        const _exhaustive: never = req;
-        void _exhaustive;
       }
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      const resp: DaemonIpcResponse = { ok: false, error: msg };
+      const resp: DaemonResponse = { ok: false, error: msg };
       socket.write(`${JSON.stringify(resp)}\n`);
     }
   }

packages/daemon/src/index.ts

@@ -30,7 +30,7 @@ export {
 export { createKernel } from "./kernel.js";
 export type { Kernel, KernelOptions, KernelHealth } from "./kernel.js";
 
-export type { SenseInfo } from "@uncaged/nerve-core";
+export type { SenseInfo } from "./daemon-ipc.js";
 
 export { createFileWatcher } from "./file-watcher.js";
 export type { FileWatcher, FileChange, FileChangeHandler } from "./file-watcher.js";

packages/daemon/src/ipc.ts

@@ -34,8 +34,6 @@ export type StartThreadMessage = {
   prompt: string;
   /** Safety-valve: max moderator rounds for this thread (engine launch parameter). */
   maxRounds: number;
-  /** When true, roles may skip side effects (thread-level hint on the start frame). */
-  dryRun: boolean;
 };
 
 /** Parent → Workflow Worker: resume an existing thread after crash recovery */
@@ -46,8 +44,6 @@ export type ResumeThreadMessage = {
   messages: Array<{ role: string; content: string; meta: unknown; timestamp: number }>;
   /** Safety-valve: max moderator rounds for this thread. */
   maxRounds: number;
-  /** Thread-level dry-run hint (aligns with persisted `__start__` meta when replaying). */
-  dryRun: boolean;
 };
 
 /** Union of all messages the parent sends to a worker */
@@ -139,7 +135,6 @@ function validateStartThreadMsg(obj: Record<string, unknown>): string | null {
   if (typeof obj.workflow !== "string") return "'start-thread' message missing string 'workflow'";
   if (typeof obj.prompt !== "string") return "'start-thread' message missing string 'prompt'";
   if (typeof obj.maxRounds !== "number") return "'start-thread' message missing number 'maxRounds'";
-  if (typeof obj.dryRun !== "boolean") return "'start-thread' message missing boolean 'dryRun'";
   return null;
 }
 
@@ -148,7 +143,6 @@ function validateResumeThreadMsg(obj: Record<string, unknown>): string | null {
   if (!Array.isArray(obj.messages)) return "'resume-thread' message missing 'messages' array";
   if (typeof obj.maxRounds !== "number")
     return "'resume-thread' message missing number 'maxRounds'";
-  if (typeof obj.dryRun !== "boolean") return "'resume-thread' message missing boolean 'dryRun'";
   return null;
 }
 
@@ -186,7 +180,6 @@ export function parseParentMessage(raw: unknown): Result<ParentToWorkerMessage>
       workflow: obj.workflow,
       prompt: obj.prompt,
       maxRounds: obj.maxRounds,
-      dryRun: obj.dryRun,
     } as StartThreadMessage);
   }
   if (obj.type === "resume-thread") {
@@ -198,7 +191,6 @@ export function parseParentMessage(raw: unknown): Result<ParentToWorkerMessage>
       runId: obj.runId,
       messages: obj.messages as ResumeThreadMessage["messages"],
       maxRounds: obj.maxRounds,
-      dryRun: obj.dryRun,
     } as ResumeThreadMessage);
   }
   return err(new Error(`Unhandled IPC message type: "${obj.type}"`));

packages/daemon/src/kernel.ts

@@ -148,7 +148,7 @@ export function createKernel(
       const route = routeSenseComputeOutput(msg.payload);
       if (route.kind === "launch") {
         const { workflowName, maxRounds, prompt } = route.launch;
-        workflowManager.startWorkflow(workflowName, { prompt, maxRounds, dryRun: false });
+        workflowManager.startWorkflow(workflowName, { prompt, maxRounds });
         logStore.append({
           source: "sense",
           type: "workflow-launch",
@@ -161,14 +161,14 @@ export function createKernel(
           id: nextSignalId(),
           senseId: msg.sense,
           payload: route.payload,
-          timestamp: Date.now(),
+          ts: Date.now(),
         };
         logStore.append({
           source: "sense",
           type: "signal",
           refId: msg.sense,
           payload: JSON.stringify(route.payload),
-          ts: signal.timestamp,
+          ts: signal.ts,
         });
         bus.emit(signal);
       }
@@ -239,7 +239,7 @@ export function createKernel(
   function reloadConfig(newConfig: NerveConfig): void {
     const oldGroups = collectSenseGroups(config);
     const oldConfig = config;
-    const oldWorkflows = config.workflows;
+    const oldWorkflows = config.workflows ?? {};
     config = newConfig;
     scheduler.stop();
     scheduler = createReflexScheduler(config, bus, triggerFn, {
@@ -247,7 +247,7 @@ export function createKernel(
     });
     workflowManager.updateConfig(newConfig);
 
-    const newWorkflows = newConfig.workflows;
+    const newWorkflows = newConfig.workflows ?? {};
 
     for (const workflowName of Object.keys(oldWorkflows)) {
       if (!(workflowName in newWorkflows)) {
@@ -327,7 +327,7 @@ export function createKernel(
             group: senseConfig.group,
             throttle: senseConfig.throttle,
             timeout: senseConfig.timeout,
-            lastSignalTimestamp: lastEntry !== null ? lastEntry.ts : null,
+            lastSignalTs: lastEntry !== null ? lastEntry.ts : null,
           };
         });
       },

packages/daemon/src/reflex-scheduler.ts

@@ -164,7 +164,7 @@ export function createReflexScheduler(
       intervals.push(id);
     }
 
-    if (senseReflex.on.length > 0) {
+    if (senseReflex.on !== null && senseReflex.on.length > 0) {
       const watchedSenses = new Set(senseReflex.on);
       const unsub = bus.subscribe((signal) => {
         if (watchedSenses.has(signal.senseId)) {

packages/daemon/src/workflow-manager.ts

@@ -31,7 +31,6 @@ import {
 export type WorkflowLaunchParams = {
   prompt: string;
   maxRounds: number;
-  dryRun: boolean;
 };
 
 export type WorkflowManager = {
@@ -59,7 +58,6 @@ type PendingThread = {
   runId: string;
   prompt: string;
   maxRounds: number;
-  dryRun: boolean;
 };
 
 type WorkflowState = {
@@ -92,22 +90,20 @@ const DEFAULT_MAX_QUEUE = 100;
 function readLaunchFromTriggerPayload(
   raw: unknown,
   engineDefaultMaxRounds: number,
-): { prompt: string; maxRounds: number; dryRun: boolean } {
+): { prompt: string; maxRounds: number } {
   if (isPlainRecord(raw)) {
     const o = raw;
     if (typeof o.prompt === "string" && typeof o.maxRounds === "number") {
-      const dryRun = typeof o.dryRun === "boolean" ? o.dryRun : false;
-      return { prompt: o.prompt, maxRounds: o.maxRounds, dryRun };
+      return { prompt: o.prompt, maxRounds: o.maxRounds };
     }
   }
-  return { prompt: "", maxRounds: engineDefaultMaxRounds, dryRun: false };
+  return { prompt: "", maxRounds: engineDefaultMaxRounds };
 }
 
 function ensureThreadMessagesWithStart(
   messages: Array<{ role: string; content: string; meta: unknown; timestamp: number }>,
   fallbackPrompt: string,
   fallbackMaxRounds: number,
-  fallbackDryRun: boolean,
 ): WorkflowMessage[] {
   const mapped: WorkflowMessage[] = messages.map((m) => ({
     role: m.role,
@@ -121,7 +117,7 @@ function ensureThreadMessagesWithStart(
   const start: WorkflowMessage = {
     role: START,
     content: fallbackPrompt,
-    meta: { maxRounds: fallbackMaxRounds, dryRun: fallbackDryRun },
+    meta: { maxRounds: fallbackMaxRounds },
     timestamp: Date.now(),
   };
   return [start, ...mapped];
@@ -217,7 +213,7 @@ export function createWorkflowManager(
   }
 
   function workflowConfig(workflowName: string): WorkflowConfig | null {
-    return config.workflows[workflowName] ?? null;
+    return config.workflows?.[workflowName] ?? null;
   }
 
   function toWorkflowRunStatus(eventType: string): WorkflowRunStatus | null {
@@ -264,7 +260,6 @@ export function createWorkflowManager(
     runId: string,
     prompt: string,
     maxRounds: number,
-    dryRun: boolean,
   ): void {
     const state = getOrCreateState(workflowName);
     state.active.add(runId);
@@ -276,10 +271,9 @@ export function createWorkflowManager(
       workflow: workflowName,
       prompt,
       maxRounds,
-      dryRun,
     };
     sendStartThread(worker.process, msg);
-    logWorkflowEvent(workflowName, runId, "started", { prompt, maxRounds, dryRun });
+    logWorkflowEvent(workflowName, runId, "started", { prompt, maxRounds });
   }
 
   function dequeueNext(workflowName: string): void {
@@ -292,7 +286,7 @@ export function createWorkflowManager(
     if (state.active.size < concurrency) {
       const next = state.queue.shift();
       if (next !== undefined) {
-        dispatchThread(workflowName, next.runId, next.prompt, next.maxRounds, next.dryRun);
+        dispatchThread(workflowName, next.runId, next.prompt, next.maxRounds);
       }
     }
   }
@@ -317,12 +311,7 @@ export function createWorkflowManager(
       logStore.getTriggerPayload(runId),
       config.maxRounds,
     );
-    state.queue.push({
-      runId,
-      prompt: launch.prompt,
-      maxRounds: launch.maxRounds,
-      dryRun: launch.dryRun,
-    });
+    state.queue.push({ runId, prompt: launch.prompt, maxRounds: launch.maxRounds });
     process.stderr.write(
       `[workflow-manager] crash-recovery: re-queued thread "${runId}" for "${workflowName}"\n`,
     );
@@ -340,19 +329,13 @@ export function createWorkflowManager(
       logStore.getTriggerPayload(runId),
       config.maxRounds,
     );
-    const messages = ensureThreadMessagesWithStart(
-      rawMessages,
-      launch.prompt,
-      launch.maxRounds,
-      launch.dryRun,
-    );
+    const messages = ensureThreadMessagesWithStart(rawMessages, launch.prompt, launch.maxRounds);
     state.active.add(runId);
     const msg: ResumeThreadMessage = {
       type: "resume-thread",
       runId,
       messages,
       maxRounds: launch.maxRounds,
-      dryRun: launch.dryRun,
     };
     sendResumeThread(worker.process, msg);
     process.stderr.write(
@@ -548,10 +531,10 @@ export function createWorkflowManager(
 
     const state = getOrCreateState(workflowName);
     const runId = crypto.randomUUID();
-    const { prompt, maxRounds, dryRun } = launch;
+    const { prompt, maxRounds } = launch;
 
     if (state.active.size < wfConfig.concurrency) {
-      dispatchThread(workflowName, runId, prompt, maxRounds, dryRun);
+      dispatchThread(workflowName, runId, prompt, maxRounds);
       return;
     }
 
@@ -576,7 +559,7 @@ export function createWorkflowManager(
       }
     }
 
-    state.queue.push({ runId, prompt, maxRounds, dryRun });
+    state.queue.push({ runId, prompt, maxRounds });
     logWorkflowEvent(workflowName, runId, "queued");
     process.stderr.write(
       `[workflow-manager] queued thread for "${workflowName}" runId "${runId}" (queue length: ${state.queue.length})\n`,

packages/daemon/src/workflow-worker.ts

@@ -13,7 +13,7 @@ import { existsSync } from "node:fs";
 import { join, resolve } from "node:path";
 
 import type {
-  ModeratorContext,
+  Moderator,
   RoleMeta,
   StartSignal,
   WorkflowDefinition,
@@ -29,6 +29,8 @@ import type {
 import { parseParentMessage } from "./ipc.js";
 import { ignoreSessionBroadcastSignals } from "./worker-fork-support.js";
 
+type ModeratorInput = Parameters<Moderator<RoleMeta>>[0];
+
 // ---------------------------------------------------------------------------
 // IPC helpers
 // ---------------------------------------------------------------------------
@@ -85,95 +87,42 @@ function validateRoleResult(
   return true;
 }
 
-function isStartMeta(meta: unknown): meta is StartSignal["meta"] {
-  return (
-    isPlainRecord(meta) && typeof meta.maxRounds === "number" && typeof meta.dryRun === "boolean"
-  );
-}
-
-function normalizeStartMeta(meta: unknown, maxRoundsFallback: number): StartSignal["meta"] {
-  if (!isPlainRecord(meta)) {
-    return { maxRounds: maxRoundsFallback, dryRun: false };
-  }
-  const maxRounds = typeof meta.maxRounds === "number" ? meta.maxRounds : maxRoundsFallback;
-  const dryRun = typeof meta.dryRun === "boolean" ? meta.dryRun : false;
-  return { maxRounds, dryRun };
-}
-
-function startSignalFromWorkflowMessage(
-  msg: WorkflowMessage,
-  maxRoundsFallback: number,
-): StartSignal {
-  if (msg.role !== START) {
+function buildInitialLastSignal(lastMsg: WorkflowMessage): ModeratorInput {
+  if (lastMsg.role === START) {
     return {
       role: START,
-      content: "",
-      meta: { maxRounds: maxRoundsFallback, dryRun: false },
-      timestamp: Date.now(),
+      content: lastMsg.content,
+      meta: lastMsg.meta as StartSignal["meta"],
+      timestamp: lastMsg.timestamp,
     };
   }
-  const meta = isStartMeta(msg.meta) ? msg.meta : normalizeStartMeta(msg.meta, maxRoundsFallback);
-  return {
-    role: START,
-    content: msg.content,
-    meta,
-    timestamp: msg.timestamp,
-  };
+  return { role: lastMsg.role, meta: lastMsg.meta as Record<string, unknown> };
 }
 
-type ThreadMessagesState = {
-  start: StartSignal;
-  /** Role outputs only; never includes the `__start__` frame. */
-  messages: WorkflowMessage[];
-};
-
-function initThreadMessages(
+function initChain(
   runId: string,
   resumeMessages: WorkflowMessage[],
   freshPrompt: string | null,
   maxRounds: number,
-  dryRun: boolean,
-): ThreadMessagesState {
+): WorkflowMessage[] {
   if (resumeMessages.length > 0) {
-    const [first, ...rest] = resumeMessages;
-    if (first.role === START) {
-      return {
-        start: startSignalFromWorkflowMessage(first, maxRounds),
-        messages: [...rest],
-      };
-    }
-    const prompt = freshPrompt ?? "";
-    return {
-      start: {
-        role: START,
-        content: prompt,
-        meta: { maxRounds, dryRun },
-        timestamp: Date.now(),
-      },
-      messages: [...resumeMessages],
-    };
+    return [...resumeMessages];
   }
   const prompt = freshPrompt ?? "";
-  const start: StartSignal = {
+  const startMsg: WorkflowMessage = {
     role: START,
     content: prompt,
-    meta: { maxRounds, dryRun },
+    meta: { maxRounds },
     timestamp: Date.now(),
   };
-  sendWorkflowMessage(runId, {
-    role: start.role,
-    content: start.content,
-    meta: start.meta,
-    timestamp: start.timestamp,
-  });
-  return { start, messages: [] };
+  sendWorkflowMessage(runId, startMsg);
+  return [startMsg];
 }
 
 async function executeRole(
   def: WorkflowDefinition<RoleMeta>,
   nextRole: string,
-  start: StartSignal,
-  messages: WorkflowMessage[],
+  chain: WorkflowMessage[],
   runId: string,
 ): Promise<{ content: string; meta: Record<string, unknown> } | null> {
   const role = def.roles[nextRole];
@@ -184,7 +133,7 @@ async function executeRole(
 
   let result: { content: string; meta: Record<string, unknown> };
   try {
-    result = await role(start, messages);
+    result = await role(chain);
   } catch (e: unknown) {
     const errMsg = e instanceof Error ? e.message : String(e);
     sendThreadEvent(runId, "failed", { error: errMsg });
@@ -201,18 +150,17 @@ async function runThread(
   maxRounds: number,
   resumeMessages: WorkflowMessage[] = [],
   freshPrompt: string | null = null,
-  dryRun = false,
 ): Promise<void> {
-  const { start, messages: roleMessages } = initThreadMessages(
-    runId,
-    resumeMessages,
-    freshPrompt,
-    maxRounds,
-    dryRun,
-  );
+  const chain = initChain(runId, resumeMessages, freshPrompt, maxRounds);
 
-  let roleRound = roleMessages.length;
-  let nextRole = def.moderator({ kind: "start", start }, roleRound, maxRounds);
+  let roleRound = chain.filter((m) => m.role !== START).length;
+  const lastMsg = chain[chain.length - 1];
+  if (lastMsg === undefined) {
+    sendWorkflowError(runId, "empty workflow message chain");
+    return;
+  }
+
+  let nextRole = def.moderator(buildInitialLastSignal(lastMsg), roleRound, maxRounds);
 
   if (nextRole === END) {
     sendThreadEvent(runId, "completed", null);
@@ -220,7 +168,7 @@ async function runThread(
   }
 
   while (roleRound < maxRounds) {
-    const result = await executeRole(def, nextRole, start, roleMessages, runId);
+    const result = await executeRole(def, nextRole, chain, runId);
     if (result === null) return;
 
     const message: WorkflowMessage = {
@@ -229,16 +177,13 @@ async function runThread(
       meta: result.meta,
       timestamp: Date.now(),
     };
-    roleMessages.push(message);
+    chain.push(message);
     sendWorkflowMessage(runId, message);
 
     roleRound += 1;
 
-    const stepContext: ModeratorContext<RoleMeta> = {
-      kind: "step",
-      signal: { role: nextRole, meta: result.meta },
-    };
-    nextRole = def.moderator(stepContext, roleRound, maxRounds);
+    const signal: ModeratorInput = { role: nextRole, meta: result.meta };
+    nextRole = def.moderator(signal, roleRound, maxRounds);
 
     if (nextRole === END) {
       sendThreadEvent(runId, "completed", null);
@@ -322,11 +267,11 @@ function handleMessage(
 
   if (msg.type === "start-thread") {
     if (shuttingDown.value) return;
-    const { runId, prompt, maxRounds, dryRun } = msg;
+    const { runId, prompt, maxRounds } = msg;
 
     const previous = inFlight.get(runId) ?? Promise.resolve();
     const next = previous
-      .then(() => runThread(def, runId, maxRounds, [], prompt, dryRun))
+      .then(() => runThread(def, runId, maxRounds, [], prompt))
       .catch((e: unknown) => {
         const errMsg = e instanceof Error ? e.message : String(e);
         sendWorkflowError(runId, errMsg);
@@ -341,11 +286,11 @@ function handleMessage(
 
   if (msg.type === "resume-thread") {
     if (shuttingDown.value) return;
-    const { runId, messages, maxRounds, dryRun } = msg;
+    const { runId, messages, maxRounds } = msg;
 
     const previous = inFlight.get(runId) ?? Promise.resolve();
     const next = previous
-      .then(() => runThread(def, runId, maxRounds, messages, null, dryRun))
+      .then(() => runThread(def, runId, maxRounds, messages, null))
       .catch((e: unknown) => {
         const errMsg = e instanceof Error ? e.message : String(e);
         sendWorkflowError(runId, errMsg);

packages/store/README.md

@@ -1,48 +0,0 @@
-# @uncaged/nerve-store
-
-Persistent storage for the [nerve](../../README.md) daemon — append-only structured logs, optional JSONL cold archive, and content-addressable blobs.
-
-## LogStore (`createLogStore`, `log-store.ts`)
-
-- **Append-only log table** — rows with `source`, `type`, `refId`, `payload`, `ts` (string payloads for ad hoc fields)
-- **SQLite WAL** — `DatabaseSync` from `node:sqlite`
-- **Workflow run tracking** — materialized `workflow_runs` table plus helpers to list active runs, upsert status transitions, and read **thread messages** / **role rounds** for CLI and crash recovery
-- **Meta key-value** — small `meta` table (e.g. archive watermarks)
-
-Public exports include `LogStore`, `LogEntry`, `LogQuery`, `WorkflowRun`, `WorkflowRunStatus`, `ThreadRoundRow`, `GetThreadRoundsParams`, and archive-related types re-exported from `log-archive`.
-
-## WorkflowRunStatus
-
-Runs progress through a small state machine. Typical paths:
-
-1. **`queued`** → **`started`** when a worker picks up the thread
-2. **`started`** → **`completed`** | **`failed`** | **`crashed`** | **`interrupted`** | **`dropped`**
-
-Semantics in the daemon/store layer:
-
-- **`completed` / `failed`** — normal terminal outcomes from the workflow worker
-- **`crashed`** — worker exited unexpectedly; manager may respawn and **`resume-thread`** eligible **`started`** runs
-- **`interrupted`** — e.g. hot-reload drain killed an in-flight thread after timeout
-- **`dropped`** — concurrency **`overflow: drop`** rejected a new run, or **`overflow: queue`** evicted an queued item when the queue was full
-
-## LogArchive (`log-archive.ts`)
-
-- **`archiveLogs`** / helpers — export eligible UTC days of old rows to **`data/archive/logs/YYYY-MM-DD.jsonl`**, delete archived rows from SQLite, optional **`VACUUM`**
-- Used by **`nerve store archive`** in `@uncaged/nerve-cli`
-
-## BlobStore (`createBlobStore`, `blob-store.ts`)
-
-- **Content-addressable storage** — `write` returns lowercase **sha256** hex; files live under **`data/blobs/<2-hex>/<62-hex>`**
-- **`read` / `exists`** — path must match digest on disk (tamper detection)
-
-## Install
-
-```bash
-pnpm add @uncaged/nerve-store
-```
-
-Requires Node.js ≥ 22.5 (same as the rest of the stack).
-
-## License
-
-MIT

packages/store/package.json

@@ -4,7 +4,9 @@
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "publishConfig": {
     "access": "public"
   },

packages/store/src/log-store.ts

@@ -242,41 +242,6 @@ function runInTransaction<T>(db: DatabaseSync, fn: () => T): T {
   }
 }
 
-function launchShapeFromRecord(rec: Record<string, unknown>): {
-  prompt: string;
-  maxRounds: number;
-  dryRun: boolean;
-} | null {
-  if (typeof rec.prompt !== "string" || typeof rec.maxRounds !== "number") return null;
-  return {
-    prompt: rec.prompt,
-    maxRounds: rec.maxRounds,
-    dryRun: typeof rec.dryRun === "boolean" ? rec.dryRun : false,
-  };
-}
-
-/** Parse JSON from a workflow `started` log row into a trigger / launch payload for crash recovery. */
-function triggerPayloadFromStartedLogJson(payload: string): unknown | null {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(payload);
-  } catch {
-    return null;
-  }
-  if (!isPlainRecord(parsed)) return null;
-
-  const direct = launchShapeFromRecord(parsed);
-  if (direct !== null) return direct;
-
-  const inner = parsed.triggerPayload;
-  if (inner !== null && isPlainRecord(inner)) {
-    const fromInner = launchShapeFromRecord(inner);
-    if (fromInner !== null) return fromInner;
-    return inner;
-  }
-  return null;
-}
-
 function runOptionalVacuum(sqlite: DatabaseSync, vacuum?: boolean): boolean {
   if (vacuum !== true) return false;
   sqlite.exec("VACUUM");
@@ -548,7 +513,15 @@ export function createLogStore(dbPath: string): LogStore {
   function getTriggerPayload(runId: string): unknown {
     const row = getTriggerPayloadStmt.get(runId) as { payload: string | null } | undefined;
     if (row === undefined || row.payload === null) return null;
-    return triggerPayloadFromStartedLogJson(row.payload);
+    try {
+      const parsed: unknown = JSON.parse(row.payload);
+      if (isPlainRecord(parsed)) {
+        return parsed.triggerPayload ?? null;
+      }
+    } catch {
+      // malformed
+    }
+    return null;
   }
 
   function getThreadEvents(runId: string): Array<{ type: string; [key: string]: unknown }> {

packages/workflow-utils/package.json

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

packages/workflow-utils/rslib.config.ts

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

packages/workflow-utils/src/__tests__/llm-extract.test.ts

@@ -1,130 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { z } from "zod";
-
-import { llmExtract } from "../llm-extract.js";
-
-describe("llmExtract", () => {
-  afterEach(() => {
-    vi.unstubAllGlobals();
-    vi.restoreAllMocks();
-  });
-
-  it("parses tool call arguments and validates with the zod schema", async () => {
-    const schema = z
-      .object({
-        name: z.string(),
-        description: z.string(),
-      })
-      .describe("Extract sense metadata from plan");
-
-    const fetchMock = vi.fn().mockResolvedValue({
-      ok: true,
-      status: 200,
-      text: async () =>
-        JSON.stringify({
-          choices: [
-            {
-              message: {
-                tool_calls: [
-                  {
-                    function: {
-                      name: "extract",
-                      arguments: JSON.stringify({ name: "cpu-usage", description: "CPU load" }),
-                    },
-                  },
-                ],
-              },
-            },
-          ],
-        }),
-    });
-
-    vi.stubGlobal("fetch", fetchMock);
-
-    const result = await llmExtract({
-      text: "some plan",
-      schema,
-      provider: {
-        baseUrl: "https://example.com/v1",
-        apiKey: "k",
-        model: "m",
-      },
-    });
-
-    expect(result.ok).toBe(true);
-    if (!result.ok) {
-      return;
-    }
-    expect(result.value).toEqual({ name: "cpu-usage", description: "CPU load" });
-
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-    const [, init] = fetchMock.mock.calls[0] as [string, RequestInit];
-    expect(init.method).toBe("POST");
-    expect(init.headers).toMatchObject({
-      Authorization: "Bearer k",
-      "Content-Type": "application/json",
-    });
-    const body = JSON.parse(init.body as string) as {
-      model: string;
-      tool_choice: { function: { name: string } };
-    };
-    expect(body.model).toBe("m");
-    expect(body.tool_choice.function.name).toBeDefined();
-  });
-
-  it("returns schema_validation_failed when arguments do not match the schema", async () => {
-    const schema = z.object({ n: z.number() });
-
-    vi.stubGlobal(
-      "fetch",
-      vi.fn().mockResolvedValue({
-        ok: true,
-        status: 200,
-        text: async () =>
-          JSON.stringify({
-            choices: [
-              {
-                message: {
-                  tool_calls: [
-                    { function: { name: "extract", arguments: JSON.stringify({ n: "oops" }) } },
-                  ],
-                },
-              },
-            ],
-          }),
-      }),
-    );
-
-    const result = await llmExtract({
-      text: "x",
-      schema,
-      provider: { baseUrl: "https://example.com", apiKey: "k", model: "m" },
-    });
-
-    expect(result.ok).toBe(false);
-    if (result.ok) {
-      return;
-    }
-    expect(result.error.kind).toBe("schema_validation_failed");
-  });
-
-  it("dryRun skips fetch and returns an empty stub value", async () => {
-    const fetchMock = vi.fn();
-    vi.stubGlobal("fetch", fetchMock);
-
-    const schema = z.object({ n: z.number() });
-    const result = await llmExtract({
-      text: "ignored",
-      schema,
-      provider: { baseUrl: "https://example.com", apiKey: "k", model: "m" },
-      dryRun: true,
-    });
-
-    expect(fetchMock).not.toHaveBeenCalled();
-    expect(result.ok).toBe(true);
-    if (!result.ok) {
-      return;
-    }
-    expect(result.value).toEqual({});
-  });
-});

packages/workflow-utils/src/__tests__/spawn-safe.test.ts

@@ -1,59 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { spawnSafe } from "../spawn-safe.js";
-
-describe("spawnSafe", () => {
-  it("passes argv literally without shell interpretation (injection-safe)", async () => {
-    const injection = "$(echo BAD)";
-    const result = await spawnSafe(
-      process.execPath,
-      ["-e", "process.stdout.write(process.argv[1] ?? '')", injection],
-      { cwd: null, env: null, timeoutMs: 10_000 },
-    );
-
-    expect(result.ok).toBe(true);
-    if (!result.ok) {
-      return;
-    }
-    expect(result.value.stdout).toBe(injection);
-    expect(result.value.exitCode).toBe(0);
-  });
-
-  it("returns err on non-zero exit", async () => {
-    const result = await spawnSafe(process.execPath, ["-e", "process.exit(7)"], {
-      cwd: null,
-      env: null,
-      timeoutMs: 10_000,
-    });
-
-    expect(result.ok).toBe(false);
-    if (result.ok) {
-      return;
-    }
-    expect(result.error.kind).toBe("non_zero_exit");
-    if (result.error.kind !== "non_zero_exit") {
-      return;
-    }
-    expect(result.error.exitCode).toBe(7);
-  });
-
-  it("dryRun skips spawn and returns a zero-exit stub", async () => {
-    const result = await spawnSafe(process.execPath, ["-e", "process.exit(1)"], {
-      cwd: null,
-      env: null,
-      timeoutMs: 10_000,
-      dryRun: true,
-    });
-
-    expect(result.ok).toBe(true);
-    if (!result.ok) {
-      return;
-    }
-    expect(result.value).toEqual({
-      stdout: "[dryRun] skipped",
-      stderr: "",
-      exitCode: 0,
-      signal: null,
-    });
-  });
-});

packages/workflow-utils/src/context.ts

@@ -1,47 +0,0 @@
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { type Result, err, ok } from "@uncaged/nerve-core";
-
-export type ReadNerveYamlOptions = {
-  nerveRoot: string;
-};
-
-export type NerveYamlError = {
-  code: "PATH_TRAVERSAL" | "READ_FAILED";
-  message: string;
-};
-
-/**
- * Reads `nerve.yaml` from a Nerve data directory (typically `~/.uncaged-nerve`).
- * Returns Result to avoid throwing on expected failures (missing file, bad perms).
- * Validates that the resolved path stays within nerveRoot to prevent path traversal.
- */
-export function readNerveYaml(options: ReadNerveYamlOptions): Result<string, NerveYamlError> {
-  const root = resolve(options.nerveRoot);
-  const target = resolve(root, "nerve.yaml");
-
-  if (!target.startsWith(root)) {
-    return err({
-      code: "PATH_TRAVERSAL",
-      message: `Resolved path "${target}" escapes nerveRoot "${root}"`,
-    });
-  }
-
-  try {
-    return ok(readFileSync(target, "utf-8"));
-  } catch (e) {
-    return err({
-      code: "READ_FAILED",
-      message: e instanceof Error ? e.message : String(e),
-    });
-  }
-}
-
-/**
- * Shared context for workflow agents: how Nerve fits together and common CLI verbs.
- */
-export const nerveAgentContext = `
-Nerve observes the world through **Senses** (each has its own SQLite DB and a \`compute()\` function).
-**Reflexes** (YAML) schedule sense runs or start **Workflows** on intervals or signals.
-The \`nerve\` CLI manages config, triggers, and queries; keep paths and commands aligned with the host nerve.yaml and senses directory.
-`.trim();

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

@@ -1,61 +0,0 @@
-import { type Result, ok } from "@uncaged/nerve-core";
-
-import { type SpawnEnv, type SpawnError, spawnSafe } from "./spawn-safe.js";
-
-export type CursorAgentMode = "plan" | "ask" | "default";
-
-export type CursorAgentOptions = {
-  prompt: string;
-  mode: CursorAgentMode;
-  cwd: string;
-  env: SpawnEnv | null;
-  timeoutMs: number | null;
-  dryRun: boolean;
-};
-
-type CursorAgentOptionsInput = CursorAgentOptions | Omit<CursorAgentOptions, "dryRun">;
-
-function resolveCursorAgentDryRun(options: CursorAgentOptionsInput): boolean {
-  return "dryRun" in options ? options.dryRun : false;
-}
-
-/**
- * Invokes `cursor-agent` with the prompt passed as a single argv slot (`shell: false`).
- */
-export async function cursorAgent(
-  options: CursorAgentOptionsInput,
-): Promise<Result<string, SpawnError>> {
-  const dryRun = resolveCursorAgentDryRun(options);
-  if (dryRun) {
-    return ok("[dryRun] skipped");
-  }
-
-  const args: string[] = [
-    "-p",
-    options.prompt,
-    "--model",
-    "auto",
-    "--output-format",
-    "text",
-    "--trust",
-    "--force",
-  ];
-  if (options.mode === "plan") {
-    args.push("--mode=plan");
-  } else if (options.mode === "ask") {
-    args.push("--mode=ask");
-  }
-
-  const run = await spawnSafe("cursor-agent", args, {
-    cwd: options.cwd,
-    env: options.env,
-    timeoutMs: options.timeoutMs,
-    dryRun: false,
-  });
-
-  if (!run.ok) {
-    return run;
-  }
-
-  return ok(run.value.stdout);
-}

packages/workflow-utils/src/index.ts

@@ -1,22 +0,0 @@
-export { cursorAgent, type CursorAgentMode, type CursorAgentOptions } from "./cursor-agent.js";
-export {
-  nerveAgentContext,
-  readNerveYaml,
-  type NerveYamlError,
-  type ReadNerveYamlOptions,
-} from "./context.js";
-export {
-  llmExtract,
-  type LlmError,
-  type LlmExtractOptions,
-  type LlmProvider,
-} from "./llm-extract.js";
-export {
-  nerveCommandEnv,
-  spawnSafe,
-  type SpawnEnv,
-  type SpawnError,
-  type SpawnResult,
-  type SpawnSafeOptions,
-} from "./spawn-safe.js";
-export { isDryRun } from "./start-signal.js";

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

@@ -1,188 +0,0 @@
-import { type Result, err, ok } from "@uncaged/nerve-core";
-import { toJSONSchema, type z } from "zod";
-
-export type LlmProvider = {
-  baseUrl: string;
-  apiKey: string;
-  model: string;
-};
-
-export type LlmExtractOptions<T> = {
-  text: string;
-  schema: z.ZodType<T>;
-  provider: LlmProvider;
-  dryRun: boolean;
-};
-
-type LlmExtractOptionsInput<T> = LlmExtractOptions<T> | Omit<LlmExtractOptions<T>, "dryRun">;
-
-function resolveLlmExtractDryRun<T>(options: LlmExtractOptionsInput<T>): boolean {
-  return "dryRun" in options ? options.dryRun : false;
-}
-
-export type LlmError =
-  | { kind: "http_error"; status: number; body: string }
-  | { kind: "invalid_response_json"; message: string }
-  | { kind: "no_tool_call"; preview: string }
-  | { kind: "tool_arguments_invalid_json"; message: string }
-  | { kind: "schema_validation_failed"; message: string }
-  | { kind: "network_error"; message: string };
-
-function chatCompletionsUrl(baseUrl: string): string {
-  const trimmed = baseUrl.replace(/\/+$/, "");
-  return `${trimmed}/chat/completions`;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function stripJsonSchemaMeta(json: Record<string, unknown>): Record<string, unknown> {
-  const { $schema: _drop, ...rest } = json;
-  return rest;
-}
-
-function readToolName(parametersSchema: Record<string, unknown>): string {
-  const title = parametersSchema.title;
-  if (typeof title === "string" && title.trim().length > 0) {
-    return title.trim();
-  }
-  return "extract";
-}
-
-function readToolArgumentsJson(parsed: unknown, previewSource: string): Result<string, LlmError> {
-  if (!isRecord(parsed)) {
-    return err({ kind: "invalid_response_json", message: "Top-level JSON is not an object" });
-  }
-
-  const choices = parsed.choices;
-  if (!Array.isArray(choices) || choices.length === 0) {
-    return err({ kind: "no_tool_call", preview: previewSource.slice(0, 500) });
-  }
-
-  const first = choices[0];
-  if (!isRecord(first)) {
-    return err({ kind: "no_tool_call", preview: previewSource.slice(0, 500) });
-  }
-
-  const messageObj = first.message;
-  if (!isRecord(messageObj)) {
-    return err({ kind: "no_tool_call", preview: previewSource.slice(0, 500) });
-  }
-
-  const toolCalls = messageObj.tool_calls;
-  if (!Array.isArray(toolCalls) || toolCalls.length === 0) {
-    return err({ kind: "no_tool_call", preview: previewSource.slice(0, 500) });
-  }
-
-  const call0 = toolCalls[0];
-  if (!isRecord(call0)) {
-    return err({ kind: "no_tool_call", preview: previewSource.slice(0, 500) });
-  }
-
-  const fn = call0.function;
-  if (!isRecord(fn)) {
-    return err({ kind: "no_tool_call", preview: previewSource.slice(0, 500) });
-  }
-
-  const argsRaw = fn.arguments;
-  if (typeof argsRaw !== "string") {
-    return err({ kind: "no_tool_call", preview: previewSource.slice(0, 500) });
-  }
-
-  return ok(argsRaw);
-}
-
-/**
- * Calls an OpenAI-compatible chat completions API with `tool_choice` forced to a single function
- * derived from a Zod v4 schema (`toJSONSchema`). Uses `fetch()` only (no shell).
- */
-export async function llmExtract<T>(
-  options: LlmExtractOptionsInput<T>,
-): Promise<Result<T, LlmError>> {
-  const dryRun = resolveLlmExtractDryRun(options);
-  if (dryRun) {
-    return ok({} as T);
-  }
-
-  const rawJsonSchema = toJSONSchema(options.schema) as Record<string, unknown>;
-  const parameters = stripJsonSchemaMeta(rawJsonSchema);
-  const toolName = readToolName(parameters);
-  const toolDescription =
-    typeof options.schema.description === "string" && options.schema.description.trim().length > 0
-      ? options.schema.description.trim()
-      : "Extract structured data from the input text.";
-
-  const body = {
-    model: options.provider.model,
-    messages: [
-      {
-        role: "system" as const,
-        content: "Extract the requested information from the provided text. Be precise.",
-      },
-      { role: "user" as const, content: options.text },
-    ],
-    tools: [
-      {
-        type: "function" as const,
-        function: {
-          name: toolName,
-          description: toolDescription,
-          parameters,
-        },
-      },
-    ],
-    tool_choice: { type: "function" as const, function: { name: toolName } },
-  };
-
-  let response: Response;
-  try {
-    response = await fetch(chatCompletionsUrl(options.provider.baseUrl), {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${options.provider.apiKey}`,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(body),
-    });
-  } catch (cause) {
-    const message = cause instanceof Error ? cause.message : String(cause);
-    return err({ kind: "network_error", message });
-  }
-
-  const responseText = await response.text();
-  if (!response.ok) {
-    return err({ kind: "http_error", status: response.status, body: responseText.slice(0, 4000) });
-  }
-
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(responseText) as unknown;
-  } catch (cause) {
-    const message = cause instanceof Error ? cause.message : String(cause);
-    return err({ kind: "invalid_response_json", message });
-  }
-
-  const argsJson = readToolArgumentsJson(parsed, responseText);
-  if (!argsJson.ok) {
-    return argsJson;
-  }
-
-  let argsParsed: unknown;
-  try {
-    argsParsed = JSON.parse(argsJson.value) as unknown;
-  } catch (cause) {
-    const message = cause instanceof Error ? cause.message : String(cause);
-    return err({ kind: "tool_arguments_invalid_json", message });
-  }
-
-  const validated = options.schema.safeParse(argsParsed);
-  if (!validated.success) {
-    return err({
-      kind: "schema_validation_failed",
-      message: validated.error.message,
-    });
-  }
-
-  return ok(validated.data);
-}

packages/workflow-utils/src/spawn-safe.ts

@@ -1,159 +0,0 @@
-import { spawn } from "node:child_process";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { type Result, err, ok } from "@uncaged/nerve-core";
-
-/** Compatible with `process.env` for `child_process.spawn`. */
-export type SpawnEnv = Record<string, string | undefined>;
-
-export type SpawnResult = {
-  stdout: string;
-  stderr: string;
-  exitCode: number;
-  /** OS signal name (e.g. `"SIGTERM"`) when terminated by signal; otherwise `null`. */
-  signal: string | null;
-};
-
-export type SpawnError =
-  | {
-      kind: "non_zero_exit";
-      stdout: string;
-      stderr: string;
-      exitCode: number;
-      signal: string | null;
-    }
-  | { kind: "timeout"; stdout: string; stderr: string }
-  | { kind: "spawn_failed"; message: string };
-
-export type SpawnSafeOptions = {
-  cwd: string | null;
-  /** When null, merges {@link nerveCommandEnv} over `process.env`. When set, merges over that default. */
-  env: SpawnEnv | null;
-  timeoutMs: number | null;
-  dryRun: boolean;
-};
-
-type SpawnSafeOptionsInput = SpawnSafeOptions | Omit<SpawnSafeOptions, "dryRun">;
-
-const DEFAULT_TIMEOUT_MS = 300_000;
-
-/**
- * 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.
- */
-export function nerveCommandEnv(): SpawnEnv {
-  const home = homedir();
-  const pnpmHome = join(home, ".local/share/pnpm");
-  return {
-    ...process.env,
-    PNPM_HOME: pnpmHome,
-    PATH: `${pnpmHome}:${process.env.PATH ?? ""}`,
-  };
-}
-
-function mergeEnv(user: SpawnEnv | null): SpawnEnv {
-  const base = nerveCommandEnv();
-  if (user === null) {
-    return base;
-  }
-  return { ...base, ...user };
-}
-
-function resolveTimeout(timeoutMs: number | null): number {
-  if (timeoutMs === null) {
-    return DEFAULT_TIMEOUT_MS;
-  }
-  return timeoutMs;
-}
-
-function resolveDryRun(options: SpawnSafeOptionsInput): boolean {
-  return "dryRun" in options ? options.dryRun : false;
-}
-
-/**
- * Spawn a process with `shell: false` (argv only), default {@link nerveCommandEnv}, and optional timeout.
- * Returns `ok` only when the process exits with code 0.
- */
-export function spawnSafe(
-  command: string,
-  args: ReadonlyArray<string>,
-  options: SpawnSafeOptionsInput,
-): Promise<Result<SpawnResult, SpawnError>> {
-  const dryRun = resolveDryRun(options);
-  if (dryRun) {
-    return Promise.resolve(
-      ok({
-        stdout: "[dryRun] skipped",
-        stderr: "",
-        exitCode: 0,
-        signal: null,
-      }),
-    );
-  }
-
-  return new Promise((resolve) => {
-    const cwd = options.cwd === null ? process.cwd() : options.cwd;
-    const env = mergeEnv(options.env);
-    const timeoutMs = resolveTimeout(options.timeoutMs);
-
-    const child = spawn(command, args, {
-      cwd,
-      env,
-      shell: false,
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-
-    let stdout = "";
-    let stderr = "";
-    let settled = false;
-
-    const finish = (outcome: Result<SpawnResult, SpawnError>) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      clearTimeout(timer);
-      resolve(outcome);
-    };
-
-    const timer = setTimeout(() => {
-      child.kill("SIGTERM");
-      finish(err({ kind: "timeout", stdout, stderr }));
-    }, timeoutMs);
-
-    child.stdout?.on("data", (chunk: Buffer | string) => {
-      stdout += typeof chunk === "string" ? chunk : chunk.toString("utf-8");
-    });
-    child.stderr?.on("data", (chunk: Buffer | string) => {
-      stderr += typeof chunk === "string" ? chunk : chunk.toString("utf-8");
-    });
-
-    child.on("error", (cause: Error) => {
-      finish(err({ kind: "spawn_failed", message: cause.message }));
-    });
-
-    child.on("close", (code, signal) => {
-      const exitCode = code ?? 1;
-      const sig = signal === undefined || signal === null ? null : String(signal);
-      const result: SpawnResult = {
-        stdout: stdout.trimEnd(),
-        stderr: stderr.trimEnd(),
-        exitCode,
-        signal: sig,
-      };
-      if (exitCode !== 0) {
-        finish(
-          err({
-            kind: "non_zero_exit",
-            stdout: result.stdout,
-            stderr: result.stderr,
-            exitCode,
-            signal: sig,
-          }),
-        );
-        return;
-      }
-      finish(ok(result));
-    });
-  });
-}

packages/workflow-utils/src/start-signal.ts

@@ -1,6 +0,0 @@
-import type { StartSignal } from "@uncaged/nerve-core";
-
-/** Returns the thread-level dry-run flag from the workflow start frame. */
-export function isDryRun(start: StartSignal): boolean {
-  return start.meta.dryRun;
-}

packages/workflow-utils/tsconfig.json

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

pnpm-lock.yaml

@@ -69,7 +69,7 @@ importers:
         version: link:../store
       drizzle-orm:
         specifier: 1.0.0-beta.23-c10d10c
-        version: 1.0.0-beta.23-c10d10c(@types/better-sqlite3@7.6.13)(@types/mssql@9.1.11(@azure/core-client@1.10.1))(better-sqlite3@11.10.0)(mssql@11.0.1(@azure/core-client@1.10.1))(sql.js@1.14.1)(zod@4.3.6)
+        version: 1.0.0-beta.23-c10d10c(@types/better-sqlite3@7.6.13)(@types/mssql@9.1.11(@azure/core-client@1.10.1))(better-sqlite3@11.10.0)(mssql@11.0.1(@azure/core-client@1.10.1))(sql.js@1.14.1)
       yaml:
         specifier: ^2.8.3
         version: 2.8.3
@@ -100,25 +100,6 @@ importers:
         specifier: ^4.1.5
         version: 4.1.5(@types/node@22.19.17)(vite@8.0.9(@types/node@22.19.17)(esbuild@0.27.7)(yaml@2.8.3))
 
-  packages/workflow-utils:
-    dependencies:
-      '@uncaged/nerve-core':
-        specifier: workspace:*
-        version: link:../core
-      zod:
-        specifier: ^4.3.6
-        version: 4.3.6
-    devDependencies:
-      '@rslib/core':
-        specifier: ^0.21.3
-        version: 0.21.3(typescript@5.9.3)
-      '@types/node':
-        specifier: ^22.0.0
-        version: 22.19.17
-      vitest:
-        specifier: ^4.1.5
-        version: 4.1.5(@types/node@22.19.17)(vite@8.0.9(@types/node@22.19.17)(esbuild@0.27.7)(yaml@2.8.3))
-
 packages:
 
   '@ast-grep/napi-darwin-arm64@0.37.0':
@@ -1491,9 +1472,6 @@ packages:
     engines: {node: '>= 14.6'}
     hasBin: true
 
-  zod@4.3.6:
-    resolution: {integrity: sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==}
-
 snapshots:
 
   '@ast-grep/napi-darwin-arm64@0.37.0':
@@ -2191,14 +2169,13 @@ snapshots:
 
   detect-libc@2.1.2: {}
 
-  drizzle-orm@1.0.0-beta.23-c10d10c(@types/better-sqlite3@7.6.13)(@types/mssql@9.1.11(@azure/core-client@1.10.1))(better-sqlite3@11.10.0)(mssql@11.0.1(@azure/core-client@1.10.1))(sql.js@1.14.1)(zod@4.3.6):
+  drizzle-orm@1.0.0-beta.23-c10d10c(@types/better-sqlite3@7.6.13)(@types/mssql@9.1.11(@azure/core-client@1.10.1))(better-sqlite3@11.10.0)(mssql@11.0.1(@azure/core-client@1.10.1))(sql.js@1.14.1):
     optionalDependencies:
       '@types/better-sqlite3': 7.6.13
       '@types/mssql': 9.1.11(@azure/core-client@1.10.1)
       better-sqlite3: 11.10.0
       mssql: 11.0.1(@azure/core-client@1.10.1)
       sql.js: 1.14.1
-      zod: 4.3.6
 
   ecdsa-sig-formatter@1.0.11:
     dependencies:
@@ -2795,5 +2772,3 @@ snapshots:
     optional: true
 
   yaml@2.8.3: {}
-
-  zod@4.3.6: {}