refactor(cli): replace better-sqlite3 with sql.js (pure WASM)

- Remove native C++ addon dependency, no more pnpm approve-builds
- sql.js loads SQLite as WASM, zero compilation required
- WASM init is singleton (once per process)
- Add queryAsObjects() adapter for sql.js columnar → row format
- Tests migrated to sql.js (16 passing)

Implements RFC #63

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

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

docs/skill-publish.md

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

docs/skill-setup.md

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

packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uncaged/nerve-cli",
-  "version": "0.1.2",
+  "version": "0.1.8",
   "type": "module",
   "bin": {
     "nerve": "dist/cli.js"
@@ -14,17 +14,19 @@
     "access": "public"
   },
   "scripts": {
+    "prepublishOnly": "bash ../../scripts/prepublish-check.sh",
     "build": "tsup",
     "test": "vitest run"
   },
   "dependencies": {
     "@uncaged/nerve-core": "workspace:*",
-    "citty": "^0.1.6"
+    "citty": "^0.1.6",
+    "sql.js": "^1.14.1"
   },
   "devDependencies": {
-    "@uncaged/nerve-daemon": "workspace:*",
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22.0.0",
+    "@uncaged/nerve-daemon": "workspace:*",
     "vitest": "^4.1.5"
   }
 }

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

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

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

@@ -3,16 +3,24 @@
  * If the daemon package changes its public API, this file will fail to compile.
  */
 
+import type { SenseInfo } from "@uncaged/nerve-core";
 import type {
+  ArchiveLogsDayResult as DaemonArchiveLogsDayResult,
+  ArchiveLogsOptions as DaemonArchiveLogsOptions,
+  ArchiveLogsResult as DaemonArchiveLogsResult,
   LogEntry as DaemonLogEntry,
   LogQuery as DaemonLogQuery,
   LogStore as DaemonLogStore,
+  SenseInfo as DaemonSenseInfo,
   WorkflowRun as DaemonWorkflowRun,
   WorkflowRunStatus as DaemonWorkflowRunStatus,
 } from "@uncaged/nerve-daemon";
-import { describe, it, expectTypeOf } from "vitest";
+import { describe, expectTypeOf, it } from "vitest";
 
 import type {
+  ArchiveLogsDayResult,
+  ArchiveLogsOptions,
+  ArchiveLogsResult,
   LogEntry,
   LogQuery,
   LogStore,
@@ -21,6 +29,11 @@ import type {
 } from "../daemon-types.js";
 
 describe("daemon-types drift guard", () => {
+  it("SenseInfo matches daemon package export (list-senses IPC)", () => {
+    expectTypeOf<SenseInfo>().toMatchTypeOf<DaemonSenseInfo>();
+    expectTypeOf<DaemonSenseInfo>().toMatchTypeOf<SenseInfo>();
+  });
+
   it("WorkflowRunStatus is assignable both ways", () => {
     expectTypeOf<WorkflowRunStatus>().toMatchTypeOf<DaemonWorkflowRunStatus>();
     expectTypeOf<DaemonWorkflowRunStatus>().toMatchTypeOf<WorkflowRunStatus>();
@@ -42,6 +55,26 @@ describe("daemon-types drift guard", () => {
   });
 
   it("LogStore has all required methods", () => {
-    expectTypeOf<LogStore>().toMatchTypeOf<Pick<DaemonLogStore, "query" | "getWorkflowRun" | "getActiveWorkflowRuns" | "getAllWorkflowRuns" | "upsertWorkflowRun" | "close">>();
+    expectTypeOf<LogStore>().toMatchTypeOf<
+      Pick<
+        DaemonLogStore,
+        | "query"
+        | "getWorkflowRun"
+        | "getActiveWorkflowRuns"
+        | "getAllWorkflowRuns"
+        | "upsertWorkflowRun"
+        | "archiveLogs"
+        | "close"
+      >
+    >();
+  });
+
+  it("ArchiveLogs types match daemon", () => {
+    expectTypeOf<ArchiveLogsOptions>().toMatchTypeOf<DaemonArchiveLogsOptions>();
+    expectTypeOf<DaemonArchiveLogsOptions>().toMatchTypeOf<ArchiveLogsOptions>();
+    expectTypeOf<ArchiveLogsResult>().toMatchTypeOf<DaemonArchiveLogsResult>();
+    expectTypeOf<DaemonArchiveLogsResult>().toMatchTypeOf<ArchiveLogsResult>();
+    expectTypeOf<ArchiveLogsDayResult>().toMatchTypeOf<DaemonArchiveLogsDayResult>();
+    expectTypeOf<DaemonArchiveLogsDayResult>().toMatchTypeOf<ArchiveLogsDayResult>();
   });
 });

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

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

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

@@ -0,0 +1,182 @@
+/**
+ * Tests for sense SQLite helpers used by `nerve sense schema` / `nerve sense query`.
+ */
+
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import initSqlJs, { type Database } from "sql.js";
+import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+
+import {
+  assertSenseDbExists,
+  collectColumnKeys,
+  defaultPreviewSql,
+  formatRowsAsAlignedTable,
+  listTableSqlStatements,
+  parseSenseQueryArgs,
+  pickDefaultPreviewTable,
+  queryAsObjects,
+  senseDbPath,
+} from "../sense-sqlite.js";
+
+let SQL: Awaited<ReturnType<typeof initSqlJs>>;
+let tmpDir: string;
+
+beforeAll(async () => {
+  SQL = await initSqlJs();
+});
+
+beforeEach(() => {
+  tmpDir = join(
+    tmpdir(),
+    `nerve-sense-sqlite-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+  );
+  mkdirSync(join(tmpDir, "data", "senses"), { recursive: true });
+});
+
+afterEach(() => {
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+/** Helper: create a SQLite db file with the given setup SQL. */
+function createDb(name: string, setupSql: string): void {
+  const db = new SQL.Database();
+  db.run(setupSql);
+  const data = db.export();
+  db.close();
+  writeFileSync(join(tmpDir, "data", "senses", `${name}.db`), Buffer.from(data));
+}
+
+/** Helper: open an in-memory db with setup SQL for unit tests. */
+function memDb(setupSql?: string): Database {
+  const db = new SQL.Database();
+  if (setupSql) db.run(setupSql);
+  return db;
+}
+
+describe("senseDbPath", () => {
+  it("points at data/senses/<name>.db under the given root", () => {
+    expect(senseDbPath("/root", "cpu-usage")).toBe(join("/root", "data", "senses", "cpu-usage.db"));
+  });
+});
+
+describe("assertSenseDbExists", () => {
+  it("throws when the file is missing", () => {
+    expect(() => assertSenseDbExists(tmpDir, "nope")).toThrow(/No database at/);
+  });
+
+  it("returns the path when the file exists", () => {
+    createDb("x", "SELECT 1");
+    expect(assertSenseDbExists(tmpDir, "x")).toBe(join(tmpDir, "data", "senses", "x.db"));
+  });
+});
+
+describe("listTableSqlStatements", () => {
+  it("returns CREATE statements ordered by tbl_name", () => {
+    const db = memDb("CREATE TABLE zebra (id INTEGER); CREATE TABLE alpha (id INTEGER);");
+    const stmts = listTableSqlStatements(db);
+    db.close();
+    expect(stmts).toHaveLength(2);
+    expect(stmts[0]).toMatch(/^CREATE TABLE alpha/i);
+    expect(stmts[1]).toMatch(/^CREATE TABLE zebra/i);
+  });
+});
+
+describe("pickDefaultPreviewTable", () => {
+  it("prefers non-_migrations tables when both exist", () => {
+    const db = memDb(
+      `CREATE TABLE _migrations (name TEXT PRIMARY KEY);
+       CREATE TABLE readings (id INTEGER);`,
+    );
+    expect(pickDefaultPreviewTable(db)).toBe("readings");
+    db.close();
+  });
+
+  it("uses _migrations when it is the only table", () => {
+    const db = memDb("CREATE TABLE _migrations (name TEXT PRIMARY KEY);");
+    expect(pickDefaultPreviewTable(db)).toBe("_migrations");
+    db.close();
+  });
+});
+
+describe("defaultPreviewSql", () => {
+  it("quotes identifiers for SQL safety", () => {
+    expect(defaultPreviewSql(`weird"name`)).toContain(`weird""name`);
+  });
+});
+
+describe("parseSenseQueryArgs", () => {
+  it("parses sense name only", () => {
+    expect(parseSenseQueryArgs(["cpu"])).toEqual({ name: "cpu", sql: undefined });
+  });
+
+  it("strips --json", () => {
+    expect(parseSenseQueryArgs(["cpu", "--json"])).toEqual({ name: "cpu", sql: undefined });
+    expect(parseSenseQueryArgs(["--json", "cpu"])).toEqual({ name: "cpu", sql: undefined });
+  });
+
+  it("joins remaining tokens into SQL", () => {
+    expect(parseSenseQueryArgs(["cpu", "SELECT", "1"])).toEqual({ name: "cpu", sql: "SELECT 1" });
+  });
+
+  it("throws when name is missing", () => {
+    expect(() => parseSenseQueryArgs(["--json"])).toThrow(/Missing sense name/);
+  });
+});
+
+describe("formatRowsAsAlignedTable", () => {
+  it("shows empty marker for no rows", () => {
+    expect(formatRowsAsAlignedTable([])).toContain("(0 rows)");
+  });
+
+  it("aligns columns from row data", () => {
+    const out = formatRowsAsAlignedTable([
+      { a: 1, b: "x" },
+      { a: 22, b: "yy" },
+    ]);
+    expect(out).toContain("a");
+    expect(out).toContain("b");
+    expect(out).toContain("22");
+  });
+});
+
+describe("collectColumnKeys", () => {
+  it("preserves key order from first row then appends new keys", () => {
+    expect(
+      collectColumnKeys([
+        { z: 1, a: 2 },
+        { a: 3, b: 4 },
+      ]),
+    ).toEqual(["z", "a", "b"]);
+  });
+});
+
+describe("queryAsObjects", () => {
+  it("converts columnar sql.js results to row objects", () => {
+    const db = memDb("CREATE TABLE t (x INTEGER, y TEXT); INSERT INTO t VALUES (1, 'a'), (2, 'b');");
+    const rows = queryAsObjects(db, "SELECT * FROM t ORDER BY x");
+    db.close();
+    expect(rows).toEqual([
+      { x: 1, y: "a" },
+      { x: 2, y: "b" },
+    ]);
+  });
+});
+
+describe("readonly query integration", () => {
+  it("runs default preview SQL on a real db file", () => {
+    createDb("demo", "CREATE TABLE items (id INTEGER PRIMARY KEY, v TEXT); INSERT INTO items (v) VALUES ('a'), ('b');");
+
+    const buffer = require("node:fs").readFileSync(join(tmpDir, "data", "senses", "demo.db"));
+    const db = new SQL.Database(buffer);
+    const table = pickDefaultPreviewTable(db);
+    expect(table).toBe("items");
+    if (table === null) throw new Error("expected items table");
+    const sql = defaultPreviewSql(table);
+    const rows = queryAsObjects(db, sql);
+    db.close();
+    expect(rows.length).toBeGreaterThanOrEqual(1);
+  });
+});

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

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

packages/cli/src/cli.ts

@@ -1,11 +1,14 @@
 import { defineCommand, runMain } from "citty";
 
+import { daemonCommand } from "./commands/daemon.js";
+import { devCommand } from "./commands/dev.js";
 import { initCommand } from "./commands/init.js";
 import { logsCommand } from "./commands/logs.js";
 import { senseCommand } from "./commands/sense.js";
-import { startCommand } from "./commands/start.js";
+import { daemonStartCommand } from "./commands/start.js";
 import { statusCommand } from "./commands/status.js";
 import { stopCommand } from "./commands/stop.js";
+import { storeCommand } from "./commands/store.js";
 import { validateCommand } from "./commands/validate.js";
 import { workflowCommand } from "./commands/workflow.js";
 
@@ -16,12 +19,15 @@ const main = defineCommand({
   },
   subCommands: {
     init: initCommand,
-    start: startCommand,
+    daemon: daemonCommand,
+    dev: devCommand,
+    start: daemonStartCommand,
     stop: stopCommand,
     status: statusCommand,
     logs: logsCommand,
     validate: validateCommand,
     sense: senseCommand,
+    store: storeCommand,
     workflow: workflowCommand,
   },
 });

packages/cli/src/commands/daemon.ts

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

packages/cli/src/commands/dev.ts

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

packages/cli/src/commands/init.ts

@@ -1,5 +1,7 @@
+import { spawn, execFile } from "node:child_process";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { promisify } from "node:util";
 
 import { defineCommand } from "citty";
 
@@ -42,6 +44,8 @@ const GITIGNORE = `data/
 node_modules/
 `;
 
+const execFileAsync = promisify(execFile);
+
 const CPU_SCHEMA_TS = `import { integer, real, sqliteTable, text } from "drizzle-orm/sqlite-core";
 
 export const cpuUsage = sqliteTable("cpu_usage", {
@@ -90,7 +94,6 @@ function writeFile(filePath: string, content: string): void {
 }
 
 async function runCommand(cmd: string, args: string[], cwd: string): Promise<void> {
-  const { spawn } = await import("node:child_process");
   await new Promise<void>((resolve, reject) => {
     const child = spawn(cmd, args, { cwd, stdio: "inherit" });
     child.on("close", (code) => {
@@ -102,10 +105,6 @@ async function runCommand(cmd: string, args: string[], cwd: string): Promise<voi
 }
 
 async function detectPackageManager(): Promise<{ cmd: string; installArgs: string[] }> {
-  const { execFile } = await import("node:child_process");
-  const { promisify } = await import("node:util");
-  const execFileAsync = promisify(execFile);
-
   for (const pm of ["pnpm", "yarn", "npm"]) {
     try {
       await execFileAsync(pm, ["--version"]);
@@ -219,6 +218,20 @@ const initWorkspaceCommand = defineCommand({
   },
 });
 
+async function tryRequireSqlite(nerveRoot: string): Promise<boolean> {
+  try {
+    const modulePath = join(nerveRoot, "node_modules", "better-sqlite3");
+    // Use a child process to test if the native module loads
+    await execFileAsync("node", ["-e", `require(${JSON.stringify(modulePath)})`], {
+      cwd: nerveRoot,
+      timeout: 10_000,
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 async function runInitWorkspace(force: boolean): Promise<void> {
   const nerveRoot = getNerveRoot();
 
@@ -242,20 +255,36 @@ async function runInitWorkspace(force: boolean): Promise<void> {
   );
 
   process.stdout.write("Installing dependencies…\n");
+  const { cmd, installArgs } = await detectPackageManager();
   try {
-    const { cmd, installArgs } = await detectPackageManager();
     await runCommand(cmd, installArgs, nerveRoot);
+  } catch {
+    process.stdout.write(
+      `⚠️ Install failed. Try manually:\n   cd ${nerveRoot} && ${cmd} ${installArgs.join(" ")}\n`,
+    );
+  }
 
-    process.stdout.write("Rebuilding native module better-sqlite3…\n");
-    try {
-      await runCommand(cmd, ["rebuild", "better-sqlite3"], nerveRoot);
-    } catch {
+  // Verify better-sqlite3 native module — rebuild up to 2 times if broken
+  const sqlitePath = join(nerveRoot, "node_modules", "better-sqlite3");
+  if (existsSync(sqlitePath)) {
+    for (let attempt = 1; attempt <= 2; attempt++) {
+      if (await tryRequireSqlite(nerveRoot)) break;
       process.stdout.write(
-        "⚠️ rebuild better-sqlite3 failed — if the daemon fails to start, reinstall from the workspace directory.\n",
+        `${attempt === 1 ? "Building" : "Retrying build of"} native module better-sqlite3 (attempt ${attempt}/2)…\n`,
+      );
+      try {
+        await runCommand(cmd, ["rebuild", "better-sqlite3"], nerveRoot);
+      } catch {
+        // will be caught by the verify below
+      }
+    }
+    if (!(await tryRequireSqlite(nerveRoot))) {
+      process.stdout.write(
+        `⚠️ better-sqlite3 native module is not working. The daemon will fail to start.\n` +
+          `   Fix: cd ${nerveRoot} && ${cmd} rebuild better-sqlite3\n` +
+          `   Or:  npm install --build-from-source better-sqlite3\n`,
       );
     }
-  } catch {
-    process.stdout.write("⚠️ Install failed — you may need to install dependencies manually.\n");
   }
 
   if (!existsSync(join(nerveRoot, ".git"))) {

packages/cli/src/commands/sense.ts

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

packages/cli/src/commands/start.ts

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

packages/cli/src/commands/stop.ts

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

packages/cli/src/commands/store.ts

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

packages/cli/src/daemon-bootstrap.ts

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

packages/cli/src/daemon-client.ts

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

packages/cli/src/daemon-types.ts

@@ -40,6 +40,24 @@ export type LogQuery = {
   limit?: number;
 };
 
+export type ArchiveLogsOptions = {
+  now?: number;
+  vacuum?: boolean;
+  maxDays?: number;
+  retentionMs?: number;
+};
+
+export type ArchiveLogsDayResult = {
+  day: string;
+  rowCount: number;
+  filePath: string;
+};
+
+export type ArchiveLogsResult = {
+  days: ArchiveLogsDayResult[];
+  vacuumed: boolean;
+};
+
 /** Subset of daemon LogStore used by the CLI workflow commands. */
 export type LogStore = {
   query: (filter?: LogQuery) => LogEntry[];
@@ -47,5 +65,6 @@ export type LogStore = {
   getActiveWorkflowRuns: (workflowName?: string) => WorkflowRun[];
   getAllWorkflowRuns: (workflowName: string | null) => WorkflowRun[];
   upsertWorkflowRun: (entry: Omit<LogEntry, "id">, run: WorkflowRun) => LogEntry;
+  archiveLogs: (options?: ArchiveLogsOptions) => ArchiveLogsResult;
   close: () => void;
 };

packages/cli/src/sense-sqlite.ts

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

packages/cli/tsup.config.ts

@@ -9,5 +9,5 @@ export default defineConfig({
     js: "#!/usr/bin/env node",
   },
   /** Daemon is loaded from workspace node_modules at runtime — never bundle it. */
-  external: ["@uncaged/nerve-daemon"],
+  external: ["@uncaged/nerve-daemon", "sql.js"],
 });

packages/core/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@uncaged/nerve-core",
-  "version": "0.1.1",
+  "version": "0.1.4",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
+    "prepublishOnly": "bash ../../scripts/prepublish-check.sh",
     "build": "tsup",
     "test": "vitest run"
   },

packages/core/src/index.ts

@@ -1,6 +1,7 @@
 export type {
   Signal,
   SenseConfig,
+  SenseInfo,
   SenseReflexConfig,
   WorkflowReflexConfig,
   ReflexConfig,

packages/core/src/types.ts

@@ -12,6 +12,15 @@ export type SenseConfig = {
   gracePeriod: number | null;
 };
 
+/** Runtime metadata for a sense (e.g. daemon list-senses IPC). */
+export type SenseInfo = {
+  name: string;
+  group: string;
+  throttle: number | null;
+  timeout: number | null;
+  lastSignalTs: number | null;
+};
+
 export type SenseReflexConfig = {
   kind: "sense";
   sense: string;

packages/daemon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uncaged/nerve-daemon",
-  "version": "0.1.1",
+  "version": "0.1.5",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,6 +11,7 @@
     "access": "public"
   },
   "scripts": {
+    "prepublishOnly": "bash ../../scripts/prepublish-check.sh",
     "build": "tsup",
     "test": "vitest run"
   },

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

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

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

@@ -91,6 +91,7 @@ function makeLogStore(
     }),
     getTriggerPayload: vi.fn(() => ({ value: 42 })),
     getThreadEvents: vi.fn(() => [{ type: "thread_start", triggerPayload: {} }]),
+    archiveLogs: vi.fn(() => ({ days: [], vacuumed: false })),
     close: vi.fn(),
   };
   return store;

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

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

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

@@ -77,6 +77,7 @@ function makeLogStore() {
     getActiveWorkflowRuns: vi.fn(() => []),
     getTriggerPayload: vi.fn(() => null),
     getThreadEvents: vi.fn(() => []),
+    archiveLogs: vi.fn(() => ({ days: [], vacuumed: false })),
     close: vi.fn(),
   };
 }

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

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

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

@@ -80,6 +80,7 @@ function makeLogStore() {
     getActiveWorkflowRuns: vi.fn(() => []),
     getTriggerPayload: vi.fn(() => null),
     getThreadEvents: vi.fn(() => []),
+    archiveLogs: vi.fn(() => ({ days: [], vacuumed: false })),
     close: vi.fn(),
   };
 }

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

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

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

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

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

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

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

@@ -7,6 +7,7 @@ import { drizzle } from "drizzle-orm/better-sqlite3";
 import { integer, real, sqliteTable } from "drizzle-orm/sqlite-core";
 import { describe, expect, it } from "vitest";
 
+import { createBlobStore } from "../blob-store.js";
 import { parseParentMessage } from "../ipc.js";
 import { executeCompute, openPeerDb, openSenseDb, runMigrations } from "../sense-runtime.js";
 import type { DrizzleDB, PeerMap, SenseRuntime } from "../sense-runtime.js";
@@ -340,6 +341,20 @@ describe("executeCompute", () => {
     expect(capturedSignal).toBeInstanceOf(AbortSignal);
     sqlite.close();
   });
+
+  it("passes BlobStore as options.blobs when blobStore argument is provided", async () => {
+    const blobsRoot = mkdtempSync(join(tmpdir(), "nerve-blobs-"));
+    const blobStore = createBlobStore(blobsRoot);
+    let seen: ReturnType<typeof createBlobStore> | undefined;
+    const { runtime, sqlite } = makeRuntime(async (_db, _peers, options) => {
+      seen = options?.blobs;
+      return null;
+    });
+
+    await executeCompute(runtime, emptyPeers, undefined, blobStore);
+    expect(seen).toBe(blobStore);
+    sqlite.close();
+  });
 });
 
 // ---------------------------------------------------------------------------

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

@@ -74,6 +74,7 @@ function makeLogStore() {
     getActiveWorkflowRuns: vi.fn(() => []),
     getTriggerPayload: vi.fn(() => null),
     getThreadEvents: vi.fn(() => []),
+    archiveLogs: vi.fn(() => ({ days: [], vacuumed: false })),
     close: vi.fn(),
   };
 }

packages/daemon/src/blob-store.ts

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

packages/daemon/src/daemon-ipc.ts

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

packages/daemon/src/index.ts

@@ -29,16 +29,24 @@ export {
 export { createKernel } from "./kernel.js";
 export type { Kernel, KernelOptions, KernelHealth } from "./kernel.js";
 
+export type { SenseInfo } from "./daemon-ipc.js";
+
 export { createFileWatcher } from "./file-watcher.js";
 export type { FileWatcher, FileChange, FileChangeHandler } from "./file-watcher.js";
 
-export { createLogStore } from "./log-store.js";
+export { createBlobStore, normalizeBlobHash } from "./blob-store.js";
+export type { BlobStore } from "./blob-store.js";
+
+export { createLogStore, LOG_ARCHIVE_META_KEY } from "./log-store.js";
 export type {
   LogStore,
   LogEntry,
   LogQuery,
   WorkflowRun,
   WorkflowRunStatus,
+  ArchiveLogsDayResult,
+  ArchiveLogsOptions,
+  ArchiveLogsResult,
 } from "./log-store.js";
 
 export { createWorkflowManager } from "./workflow-manager.js";

packages/daemon/src/kernel.ts

@@ -18,7 +18,7 @@ import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
-import type { NerveConfig, Signal } from "@uncaged/nerve-core";
+import type { NerveConfig, SenseInfo, Signal } from "@uncaged/nerve-core";
 import { parseNerveConfig } from "@uncaged/nerve-core";
 
 import { createDaemonIpcServer } from "./daemon-ipc.js";
@@ -33,6 +33,11 @@ import { createReflexScheduler } from "./reflex-scheduler.js";
 import type { ReflexScheduler } from "./reflex-scheduler.js";
 import { createSignalBus } from "./signal-bus.js";
 import type { SignalBus } from "./signal-bus.js";
+import {
+  formatCapturedStderrTail,
+  formatChildExitSummary,
+  teeCapturedStderr,
+} from "./worker-fork-support.js";
 import { createWorkflowManager } from "./workflow-manager.js";
 import type { WorkflowManager } from "./workflow-manager.js";
 
@@ -84,10 +89,23 @@ function resolveWorkerScript(): string {
   return join(__dir, "sense-worker.js");
 }
 
-function spawnWorker(nerveRoot: string, group: string, workerScript: string): ChildProcess {
-  return fork(workerScript, ["--group", group, "--root", nerveRoot], {
-    stdio: ["ignore", "inherit", "inherit", "ipc"],
+function spawnWorker(
+  nerveRoot: string,
+  group: string,
+  workerScript: string,
+  stderrTail: { value: string },
+): ChildProcess {
+  const child = fork(workerScript, ["--group", group, "--root", nerveRoot], {
+    stdio: ["ignore", "inherit", "pipe", "ipc"],
   });
+  teeCapturedStderr(child, stderrTail);
+  // Prevent unhandled EPIPE when writing to a child whose IPC channel closed
+  child.on("error", (err) => {
+    if ((err as NodeJS.ErrnoException).code !== "EPIPE") {
+      console.error("[worker] error:", err.message);
+    }
+  });
+  return child;
 }
 
 function sendCompute(worker: ChildProcess, senseName: string): void {
@@ -219,8 +237,8 @@ export function createKernel(
         ts: Date.now(),
       };
       logStore.append({
-        source: "reflex",
-        type: "run_complete",
+        source: "sense",
+        type: "signal",
         refId: msg.sense,
         payload: JSON.stringify(msg.payload),
         ts: signal.ts,
@@ -233,7 +251,8 @@ export function createKernel(
   }
 
   function startWorker(group: string): Promise<void> {
-    const child = spawnWorker(nerveRoot, group, workerScript);
+    const stderrTail = { value: "" };
+    const child = spawnWorker(nerveRoot, group, workerScript, stderrTail);
 
     let workerReadyResolve: (() => void) | undefined;
     const workerReady = new Promise<void>((resolve) => {
@@ -248,9 +267,10 @@ export function createKernel(
       handleWorkerMessage(raw);
     });
 
-    child.on("exit", (code) => {
+    child.on("exit", (code, signal) => {
+      const summary = formatChildExitSummary(code, signal ?? null);
       process.stderr.write(
-        `[kernel] worker for group "${group}" exited with code ${code ?? "null"}\n`,
+        `[kernel] worker for group "${group}" exited (${summary})${formatCapturedStderrTail(stderrTail.value)}\n`,
       );
       // Resolve ready in case the worker exits before sending ready (prevents hangs)
       workerReadyResolve?.();
@@ -518,6 +538,23 @@ export function createKernel(
   if (options.ipcSocketPath != null) {
     ipcServer = createDaemonIpcServer(options.ipcSocketPath, workflowManager, {
       triggerSense,
+      listSenses(): SenseInfo[] {
+        return Object.entries(config.senses).map(([name, senseConfig]) => {
+          const entries = logStore.query({
+            source: "sense",
+            type: "signal",
+            refId: name,
+          });
+          const lastEntry = entries.length > 0 ? entries[entries.length - 1] : null;
+          return {
+            name,
+            group: senseConfig.group,
+            throttle: senseConfig.throttle,
+            timeout: senseConfig.timeout,
+            lastSignalTs: lastEntry !== null ? lastEntry.ts : null,
+          };
+        });
+      },
     });
   }
 

packages/daemon/src/log-archive.ts

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

packages/daemon/src/log-store.ts

@@ -7,11 +7,27 @@
  * Also provides a `meta` key-value table for bookkeeping (e.g. archive watermarks).
  */
 
-import { mkdirSync } from "node:fs";
-import { dirname } from "node:path";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 import Database from "better-sqlite3";
 import type BetterSqlite3 from "better-sqlite3";
 
+import {
+  DEFAULT_LOG_RETENTION_MS,
+  LOG_ARCHIVE_META_KEY,
+  assertValidUtcDay,
+  compareIsoDays,
+  lastArchivableUtcDay,
+  nextUtcDay,
+  utcDateStringFromMs,
+  utcDayEndExclusiveMs,
+  utcDayStartMs,
+} from "./log-archive.js";
+import type { ArchiveLogsDayResult, ArchiveLogsOptions, ArchiveLogsResult } from "./log-archive.js";
+
+export { LOG_ARCHIVE_META_KEY } from "./log-archive.js";
+export type { ArchiveLogsDayResult, ArchiveLogsOptions, ArchiveLogsResult } from "./log-archive.js";
+
 export type LogEntry = {
   id?: number;
   source: string;
@@ -105,6 +121,12 @@ export type LogStore = {
    * Used for crash recovery to rebuild ThreadState.
    */
   getThreadEvents: (runId: string) => Array<{ type: string; [key: string]: unknown }>;
+  /**
+   * Export logs older than the retention window to `data/archive/logs/YYYY-MM-DD.jsonl`,
+   * then delete those rows and advance `meta.archived_up_to` in one transaction per day
+   * (RFC-001 §5.4).
+   */
+  archiveLogs: (options?: ArchiveLogsOptions) => ArchiveLogsResult;
   close: () => void;
 };
 
@@ -138,6 +160,78 @@ CREATE INDEX IF NOT EXISTS idx_workflow_runs_status ON workflow_runs(status);
 CREATE INDEX IF NOT EXISTS idx_workflow_runs_workflow ON workflow_runs(workflow);
 `;
 
+type SqlLogRow = {
+  id: number;
+  source: string;
+  type: string;
+  ref_id: string | null;
+  payload: string | null;
+  ts: number;
+};
+
+function buildJsonlBody(rows: SqlLogRow[]): string {
+  if (rows.length === 0) return "";
+  const lines = rows.map((r) =>
+    JSON.stringify({
+      id: r.id,
+      source: r.source,
+      type: r.type,
+      refId: r.ref_id,
+      payload: r.payload,
+      ts: r.ts,
+    }),
+  );
+  return `${lines.join("\n")}\n`;
+}
+
+function runOptionalVacuum(sqlite: BetterSqlite3.Database, vacuum?: boolean): boolean {
+  if (vacuum !== true) return false;
+  sqlite.exec("VACUUM");
+  return true;
+}
+
+function resolveArchiveStartDay(watermark: string | null, minDay: string): string {
+  if (watermark === null) return minDay;
+  const afterWatermark = nextUtcDay(watermark);
+  return compareIsoDays(minDay, afterWatermark) < 0 ? minDay : afterWatermark;
+}
+
+function runArchiveDayLoop(
+  dbPath: string,
+  options: ArchiveLogsOptions,
+  selectLogsForDayStmt: BetterSqlite3.Statement,
+  archiveDayTx: (day: string, start: number, endExclusive: number) => void,
+  startDay: string,
+  lastDay: string,
+): ArchiveLogsDayResult[] {
+  const archiveDir = join(dirname(dbPath), "archive", "logs");
+  mkdirSync(archiveDir, { recursive: true });
+
+  const days: ArchiveLogsDayResult[] = [];
+  let d = startDay;
+  let processed = 0;
+
+  while (compareIsoDays(d, lastDay) <= 0) {
+    if (options.maxDays !== undefined && processed >= options.maxDays) {
+      break;
+    }
+
+    const start = utcDayStartMs(d);
+    const endExclusive = utcDayEndExclusiveMs(d);
+    const rows = selectLogsForDayStmt.all({ start, endExclusive }) as SqlLogRow[];
+
+    const filePath = join(archiveDir, `${d}.jsonl`);
+    writeFileSync(filePath, buildJsonlBody(rows), "utf8");
+    archiveDayTx(d, start, endExclusive);
+
+    days.push({ day: d, rowCount: rows.length, filePath });
+    processed += 1;
+    d = nextUtcDay(d);
+  }
+
+  return days;
+}
+
 export function createLogStore(dbPath: string): LogStore {
   mkdirSync(dirname(dbPath), { recursive: true });
 
@@ -186,6 +280,14 @@ export function createLogStore(dbPath: string): LogStore {
     "SELECT run_id, workflow, status, ts FROM workflow_runs WHERE workflow = ? ORDER BY ts DESC",
   );
 
+  const minLogTsStmt = sqlite.prepare("SELECT MIN(ts) AS m FROM logs");
+  const selectLogsForDayStmt = sqlite.prepare(
+    "SELECT id, source, type, ref_id, payload, ts FROM logs WHERE ts >= @start AND ts < @endExclusive ORDER BY id ASC",
+  );
+  const deleteLogsForDayStmt = sqlite.prepare(
+    "DELETE FROM logs WHERE ts >= @start AND ts < @endExclusive",
+  );
+
   const upsertWorkflowRunTx = sqlite.transaction(
     (entry: Omit<LogEntry, "id">, run: WorkflowRun) => {
       const info = insertStmt.run({
@@ -358,6 +460,52 @@ export function createLogStore(dbPath: string): LogStore {
     return result;
   }
 
+  const archiveDayTx = sqlite.transaction((day: string, start: number, endExclusive: number) => {
+    deleteLogsForDayStmt.run({ start, endExclusive });
+    setMetaStmt.run({ key: LOG_ARCHIVE_META_KEY, value: day });
+  });
+
+  function readWatermark(): string | null {
+    const raw = getMeta(LOG_ARCHIVE_META_KEY);
+    if (raw === null) return null;
+    assertValidUtcDay(raw);
+    return raw;
+  }
+
+  function firstLogUtcDay(): string | null {
+    const row = minLogTsStmt.get() as { m: number | null } | undefined;
+    const m = row?.m;
+    if (m === null || m === undefined) return null;
+    return utcDateStringFromMs(m);
+  }
+
+  function archiveLogs(options: ArchiveLogsOptions = {}): ArchiveLogsResult {
+    const now = options.now ?? Date.now();
+    const retentionMs = options.retentionMs ?? DEFAULT_LOG_RETENTION_MS;
+    const lastDay = lastArchivableUtcDay(now - retentionMs);
+
+    const watermark = readWatermark();
+    const minDay = firstLogUtcDay();
+    if (minDay === null) {
+      return { days: [], vacuumed: runOptionalVacuum(sqlite, options.vacuum) };
+    }
+
+    const startDay = resolveArchiveStartDay(watermark, minDay);
+    if (compareIsoDays(startDay, lastDay) > 0) {
+      return { days: [], vacuumed: runOptionalVacuum(sqlite, options.vacuum) };
+    }
+
+    const days = runArchiveDayLoop(
+      dbPath,
+      options,
+      selectLogsForDayStmt,
+      archiveDayTx,
+      startDay,
+      lastDay,
+    );
+    return { days, vacuumed: runOptionalVacuum(sqlite, options.vacuum) };
+  }
+
   function close(): void {
     sqlite.close();
   }
@@ -374,6 +522,7 @@ export function createLogStore(dbPath: string): LogStore {
     getAllWorkflowRuns,
     getTriggerPayload,
     getThreadEvents,
+    archiveLogs,
     close,
   };
 }

packages/daemon/src/sense-runtime.ts

@@ -8,6 +8,8 @@ import type { BetterSQLite3Database } from "drizzle-orm/better-sqlite3";
 import type { Result } from "@uncaged/nerve-core";
 import { err, ok } from "@uncaged/nerve-core";
 
+import type { BlobStore } from "./blob-store.js";
+
 /** A Drizzle DB instance (schema-generic) */
 export type DrizzleDB = BetterSQLite3Database<Record<string, never>>;
 
@@ -17,11 +19,14 @@ export type PeerMap = Readonly<Record<string, DrizzleDB>>;
 /** Options passed to a compute function */
 export type ComputeOptions = {
   signal: AbortSignal;
+  /** CAS under `data/blobs/`; injected by the sense worker when available. */
+  blobs?: BlobStore;
 };
 
 /**
  * The shape every sense's index.ts must export.
- * Engine injects `db` (read-write), `peers` (read-only), and `options`.
+ * Engine injects `db` (read-write), `peers` (read-only), and `options`
+ * (`signal`, and `blobs` when running in the sense worker — RFC-001 §8 CAS).
  * Returns T when a signal should be emitted, null for silence.
  */
 export type ComputeFn<T = unknown> = (
@@ -168,6 +173,7 @@ export async function loadComputeFn(senseIndexPath: string): Promise<Result<Comp
   let mod: unknown;
 
   try {
+    // Dynamic import required: user-authored sense module, path resolved at runtime
     mod = await import(senseIndexPath);
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
@@ -192,14 +198,19 @@ export async function loadComputeFn(senseIndexPath: string): Promise<Result<Comp
  * Execute a sense's compute function with an optional soft timeout.
  * If timeoutMs is provided and compute takes longer, the AbortSignal is
  * triggered and an error Result is returned.
+ * When `blobStore` is set, it is exposed as `options.blobs` (see RFC-001 §8).
  */
 export async function executeCompute(
   runtime: SenseRuntime,
   peers: PeerMap,
   timeoutMs?: number,
+  blobStore?: BlobStore,
 ): Promise<Result<unknown | null>> {
   const controller = new AbortController();
-  const options: ComputeOptions = { signal: controller.signal };
+  const options: ComputeOptions =
+    blobStore !== undefined
+      ? { signal: controller.signal, blobs: blobStore }
+      : { signal: controller.signal };
 
   let timer: ReturnType<typeof setTimeout> | undefined;
   const timeoutPromise =

packages/daemon/src/sense-worker.ts

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

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

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

packages/daemon/src/workflow-manager.ts

@@ -22,6 +22,11 @@ import type {
 import { parseWorkerMessage } from "./ipc.js";
 import type { LogStore } from "./log-store.js";
 import type { WorkflowRunStatus } from "./log-store.js";
+import {
+  formatCapturedStderrTail,
+  formatChildExitSummary,
+  teeCapturedStderr,
+} from "./worker-fork-support.js";
 
 export type WorkflowManager = {
   /** Trigger a new workflow thread (called by Reflex scheduler). */
@@ -60,6 +65,7 @@ type WorkerEntry = {
   stopping: boolean;
   /** When set, the worker is draining before a hot-reload respawn. */
   draining: boolean;
+  stderrTail: { value: string };
 };
 
 // Crash respawn backoff: track crash timestamps per workflow.
@@ -85,10 +91,19 @@ function spawnWorkflowWorker(
   nerveRoot: string,
   workflowName: string,
   workerScript: string,
+  stderrTail: { value: string },
 ): ChildProcess {
-  return fork(workerScript, ["--workflow", workflowName, "--root", nerveRoot], {
-    stdio: ["ignore", "inherit", "inherit", "ipc"],
+  const child = fork(workerScript, ["--workflow", workflowName, "--root", nerveRoot], {
+    stdio: ["ignore", "inherit", "pipe", "ipc"],
   });
+  teeCapturedStderr(child, stderrTail);
+  // Prevent unhandled EPIPE when writing to a child whose IPC channel closed
+  child.on("error", (err) => {
+    if ((err as NodeJS.ErrnoException).code !== "EPIPE") {
+      console.error("[worker] error:", err.message);
+    }
+  });
+  return child;
 }
 
 function sendStartThread(worker: ChildProcess, msg: StartThreadMessage): void {
@@ -388,7 +403,11 @@ export function createWorkflowManager(
     state.active.clear();
   }
 
-  function handleWorkerExit(workflowName: string, code: number | null): void {
+  function handleWorkerExit(
+    workflowName: string,
+    code: number | null,
+    signal: NodeJS.Signals | null,
+  ): void {
     const entry = workers.get(workflowName);
     if (entry?.draining) {
       workers.delete(workflowName);
@@ -409,8 +428,10 @@ export function createWorkflowManager(
       }
       return;
     }
+    const summary = formatChildExitSummary(code, signal);
+    const stderrExtra = entry !== undefined ? formatCapturedStderrTail(entry.stderrTail.value) : "";
     process.stderr.write(
-      `[workflow-manager] worker for "${workflowName}" exited with code ${code ?? "null"}\n`,
+      `[workflow-manager] worker for "${workflowName}" exited (${summary})${stderrExtra}\n`,
     );
     handleWorkerCrash(workflowName);
   }
@@ -421,17 +442,24 @@ export function createWorkflowManager(
       return existing;
     }
 
-    const child = spawnWorkflowWorker(nerveRoot, workflowName, workerScript);
+    const stderrTail = { value: "" };
+    const child = spawnWorkflowWorker(nerveRoot, workflowName, workerScript, stderrTail);
 
     child.on("message", (raw: unknown) => {
       handleWorkerMessage(workflowName, raw);
     });
 
-    child.on("exit", (code) => {
-      handleWorkerExit(workflowName, code);
+    child.on("exit", (code, signal) => {
+      handleWorkerExit(workflowName, code, signal ?? null);
     });
 
-    const entry: WorkerEntry = { workflowName, process: child, stopping: false, draining: false };
+    const entry: WorkerEntry = {
+      workflowName,
+      process: child,
+      stopping: false,
+      draining: false,
+      stderrTail,
+    };
     workers.set(workflowName, entry);
     return entry;
   }

packages/daemon/src/workflow-worker.ts

@@ -21,6 +21,7 @@ import type {
 
 import type { ThreadCommandEventMessage, ThreadEventType, WorkerToParentMessage } from "./ipc.js";
 import { parseParentMessage } from "./ipc.js";
+import { ignoreSessionBroadcastSignals } from "./worker-fork-support.js";
 
 // ---------------------------------------------------------------------------
 // IPC helpers
@@ -197,6 +198,7 @@ async function loadWorkflowDefinition(
     );
   }
 
+  // Dynamic import required: user-authored workflow module, path resolved at runtime
   const mod = await import(indexPath);
   const def: unknown = mod.default ?? mod;
 
@@ -334,6 +336,10 @@ if (!parsed) {
   process.exit(1);
 }
 
+if (typeof process.send === "function") {
+  ignoreSessionBroadcastSignals();
+}
+
 bootstrap(parsed.nerveRoot, parsed.workflow).catch((e) => {
   const msg = e instanceof Error ? e.message : String(e);
   process.stderr.write(`[workflow-worker] Unhandled bootstrap error: ${msg}\n`);

pnpm-lock.yaml

@@ -26,6 +26,9 @@ importers:
       citty:
         specifier: ^0.1.6
         version: 0.1.6
+      sql.js:
+        specifier: ^1.14.1
+        version: 1.14.1
     devDependencies:
       '@types/better-sqlite3':
         specifier: ^7.6.13
@@ -60,7 +63,7 @@ importers:
         version: 11.10.0
       drizzle-orm:
         specifier: ^0.43.1
-        version: 0.43.1(@types/better-sqlite3@7.6.13)(better-sqlite3@11.10.0)
+        version: 0.43.1(@types/better-sqlite3@7.6.13)(better-sqlite3@11.10.0)(sql.js@1.14.1)
       yaml:
         specifier: ^2.8.3
         version: 2.8.3
@@ -1071,6 +1074,9 @@ packages:
     resolution: {integrity: sha512-i5uvt8C3ikiWeNZSVZNWcfZPItFQOsYTUAOkcUPGd8DqDy1uOUikjt5dG+uRlwyvR108Fb9DOd4GvXfT0N2/uQ==}
     engines: {node: '>= 12'}
 
+  sql.js@1.14.1:
+    resolution: {integrity: sha512-gcj8zBWU5cFsi9WUP+4bFNXAyF1iRpA3LLyS/DP5xlrNzGmPIizUeBggKa8DbDwdqaKwUcTEnChtd2grWo/x/A==}
+
   stackback@0.0.2:
     resolution: {integrity: sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==}
 
@@ -1692,10 +1698,11 @@ snapshots:
 
   detect-libc@2.1.2: {}
 
-  drizzle-orm@0.43.1(@types/better-sqlite3@7.6.13)(better-sqlite3@11.10.0):
+  drizzle-orm@0.43.1(@types/better-sqlite3@7.6.13)(better-sqlite3@11.10.0)(sql.js@1.14.1):
     optionalDependencies:
       '@types/better-sqlite3': 7.6.13
       better-sqlite3: 11.10.0
+      sql.js: 1.14.1
 
   end-of-stream@1.4.5:
     dependencies:
@@ -1997,6 +2004,8 @@ snapshots:
 
   source-map@0.7.6: {}
 
+  sql.js@1.14.1: {}
+
   stackback@0.0.2: {}
 
   std-env@4.1.0: {}

scripts/prepublish-check.sh

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