feat(daemon): add log store archival with meta watermark + JSONL cold archive — closes #38

- Add meta table with archived_up_to watermark in logs.db
- Archive logs older than 30 days to data/archive/logs/YYYY-MM-DD.jsonl
- Idempotent: same-day re-export overwrites file
- Single transaction: DELETE + UPDATE meta
- Optional VACUUM after archive loop
- CLI: nerve store archive [--vacuum]
- 15+ new tests for archive logic

packages/cli/package.json

@@ -1,23 +1,28 @@
 {
   "name": "@uncaged/nerve-cli",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.1.4",
   "type": "module",
   "bin": {
     "nerve": "dist/cli.js"
   },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "build": "tsup",
     "test": "vitest run"
   },
   "dependencies": {
     "@uncaged/nerve-core": "workspace:*",
-    "@uncaged/nerve-daemon": "workspace:*",
     "citty": "^0.1.6"
   },
   "devDependencies": {
+    "@uncaged/nerve-daemon": "workspace:*",
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22.0.0",
     "vitest": "^4.1.5"

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

@@ -0,0 +1,73 @@
+/**
+ * Compile-time check: daemon-types.ts stays in sync with @uncaged/nerve-daemon exports.
+ * If the daemon package changes its public API, this file will fail to compile.
+ */
+
+import type {
+  ArchiveLogsDayResult as DaemonArchiveLogsDayResult,
+  ArchiveLogsOptions as DaemonArchiveLogsOptions,
+  ArchiveLogsResult as DaemonArchiveLogsResult,
+  LogEntry as DaemonLogEntry,
+  LogQuery as DaemonLogQuery,
+  LogStore as DaemonLogStore,
+  WorkflowRun as DaemonWorkflowRun,
+  WorkflowRunStatus as DaemonWorkflowRunStatus,
+} from "@uncaged/nerve-daemon";
+import { describe, expectTypeOf, it } from "vitest";
+
+import type {
+  ArchiveLogsDayResult,
+  ArchiveLogsOptions,
+  ArchiveLogsResult,
+  LogEntry,
+  LogQuery,
+  LogStore,
+  WorkflowRun,
+  WorkflowRunStatus,
+} from "../daemon-types.js";
+
+describe("daemon-types drift guard", () => {
+  it("WorkflowRunStatus is assignable both ways", () => {
+    expectTypeOf<WorkflowRunStatus>().toMatchTypeOf<DaemonWorkflowRunStatus>();
+    expectTypeOf<DaemonWorkflowRunStatus>().toMatchTypeOf<WorkflowRunStatus>();
+  });
+
+  it("WorkflowRun is assignable both ways", () => {
+    expectTypeOf<WorkflowRun>().toMatchTypeOf<DaemonWorkflowRun>();
+    expectTypeOf<DaemonWorkflowRun>().toMatchTypeOf<WorkflowRun>();
+  });
+
+  it("LogEntry is assignable both ways", () => {
+    expectTypeOf<LogEntry>().toMatchTypeOf<DaemonLogEntry>();
+    expectTypeOf<DaemonLogEntry>().toMatchTypeOf<LogEntry>();
+  });
+
+  it("LogQuery is assignable both ways", () => {
+    expectTypeOf<LogQuery>().toMatchTypeOf<DaemonLogQuery>();
+    expectTypeOf<DaemonLogQuery>().toMatchTypeOf<LogQuery>();
+  });
+
+  it("LogStore has all required methods", () => {
+    expectTypeOf<LogStore>().toMatchTypeOf<
+      Pick<
+        DaemonLogStore,
+        | "query"
+        | "getWorkflowRun"
+        | "getActiveWorkflowRuns"
+        | "getAllWorkflowRuns"
+        | "upsertWorkflowRun"
+        | "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,295 @@
+/**
+ * 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 { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import { listSensesViaDaemon } from "../daemon-client.js";
+import type { SenseInfo } from "../daemon-client.js";
+import { formatDuration, formatSenseList, sensesFromConfig } from "../commands/sense.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.test.ts

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

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

@@ -13,7 +13,6 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 
 import { createLogStore } from "@uncaged/nerve-daemon";
-import type { LogStore, WorkflowRun } from "@uncaged/nerve-daemon";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
 
 import {
@@ -25,6 +24,7 @@ import {
   statusIcon,
 } from "../commands/workflow.js";
 import { triggerWorkflowViaDaemon } from "../daemon-client.js";
+import type { LogStore, WorkflowRun } from "../daemon-types.js";
 
 // ---------------------------------------------------------------------------
 // Test helpers

packages/cli/src/cli.ts

@@ -1,12 +1,12 @@
-#!/usr/bin/env node
-
 import { defineCommand, runMain } from "citty";
 
 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 { 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";
 
@@ -22,6 +22,8 @@ const main = defineCommand({
     status: statusCommand,
     logs: logsCommand,
     validate: validateCommand,
+    sense: senseCommand,
+    store: storeCommand,
     workflow: workflowCommand,
   },
 });

packages/cli/src/commands/init.ts

@@ -26,10 +26,14 @@ const PACKAGE_JSON = `{
   "type": "module",
   "dependencies": {
     "@uncaged/nerve-core": "latest",
+    "@uncaged/nerve-daemon": "latest",
     "drizzle-orm": "latest"
   },
   "devDependencies": {
     "drizzle-kit": "latest"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": ["better-sqlite3", "esbuild"]
   }
 }
 `;
@@ -97,7 +101,7 @@ async function runCommand(cmd: string, args: string[], cwd: string): Promise<voi
   });
 }
 
-async function detectPackageManager(): Promise<{ cmd: string; args: string[] }> {
+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);
@@ -105,13 +109,13 @@ async function detectPackageManager(): Promise<{ cmd: string; args: string[] }>
   for (const pm of ["pnpm", "yarn", "npm"]) {
     try {
       await execFileAsync(pm, ["--version"]);
-      const args = pm === "pnpm" ? ["install", "--no-cache"] : ["install"];
-      return { cmd: pm, args };
+      const installArgs = pm === "pnpm" ? ["install", "--no-cache"] : ["install"];
+      return { cmd: pm, installArgs };
     } catch {
       // not available, try next
     }
   }
-  return { cmd: "npm", args: ["install"] };
+  return { cmd: "npm", installArgs: ["install"] };
 }
 
 export const WORKFLOW_NAME_RE = /^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/;
@@ -239,8 +243,17 @@ async function runInitWorkspace(force: boolean): Promise<void> {
 
   process.stdout.write("Installing dependencies…\n");
   try {
-    const { cmd, args } = await detectPackageManager();
-    await runCommand(cmd, args, nerveRoot);
+    const { cmd, installArgs } = await detectPackageManager();
+    await runCommand(cmd, installArgs, nerveRoot);
+
+    process.stdout.write("Rebuilding native module better-sqlite3…\n");
+    try {
+      await runCommand(cmd, ["rebuild", "better-sqlite3"], nerveRoot);
+    } catch {
+      process.stdout.write(
+        "⚠️ rebuild better-sqlite3 failed — if the daemon fails to start, reinstall from the workspace directory.\n",
+      );
+    }
   } catch {
     process.stdout.write("⚠️ Install failed — you may need to install dependencies manually.\n");
   }

packages/cli/src/commands/sense.ts

@@ -0,0 +1,157 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { parseNerveConfig } from "@uncaged/nerve-core";
+import { defineCommand } from "citty";
+
+import { listSensesViaDaemon, triggerSenseViaDaemon } from "../daemon-client.js";
+import type { SenseInfo } from "../daemon-client.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>
+// ---------------------------------------------------------------------------
+
+const senseTriggerCommand = defineCommand({
+  meta: {
+    name: "trigger",
+    description: "Manually trigger a sense compute by sending an IPC message to the running daemon",
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "The sense name to trigger",
+    },
+  },
+  async run({ args }) {
+    if (!isRunning()) {
+      process.stderr.write("❌ Nerve daemon is not running. Start it with `nerve start`.\n");
+      process.exit(1);
+    }
+
+    const socketPath = getSocketPath();
+    let response: { ok: true } | { ok: false; error: string };
+    try {
+      response = await triggerSenseViaDaemon(socketPath, args.name);
+    } 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 rejected trigger: ${response.error}\n`);
+      process.exit(1);
+    }
+
+    process.stdout.write(`✅ Triggered sense "${args.name}" via daemon.\n`);
+  },
+});
+
+// ---------------------------------------------------------------------------
+// nerve sense (parent command)
+// ---------------------------------------------------------------------------
+
+export const senseCommand = defineCommand({
+  meta: {
+    name: "sense",
+    description: "Interact with sense computes",
+  },
+  subCommands: {
+    list: senseListCommand,
+    trigger: senseTriggerCommand,
+  },
+});

packages/cli/src/commands/start.ts

@@ -1,99 +1,42 @@
-import { createWriteStream, existsSync, readFileSync } from "node:fs";
+import { createWriteStream, existsSync } from "node:fs";
 import { mkdir } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
-import { parseNerveConfig } from "@uncaged/nerve-core";
-import { createKernel } from "@uncaged/nerve-daemon";
 import { defineCommand } from "citty";
 
+import { runForegroundKernelSession } from "../run-foreground-kernel.js";
+import { loadDaemonModule } from "../workspace-daemon.js";
 import {
   getLogPath,
   getNerveRoot,
-  getSocketPath,
   isRunning,
   readPidFile,
+  removePidFile,
   writePidFile,
 } from "../workspace.js";
 
-function readConfig(nerveRoot: string): ReturnType<typeof parseNerveConfig> {
-  const configPath = join(nerveRoot, "nerve.yaml");
-  let raw: string;
-  try {
-    raw = readFileSync(configPath, "utf8");
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : String(e);
-    return { ok: false, error: new Error(`❌ Cannot read ${configPath}: ${msg}`) };
-  }
-  return parseNerveConfig(raw);
+function waitForSocket(socketPath: string, timeoutMs = 5000, intervalMs = 200): Promise<boolean> {
+  return new Promise((resolve) => {
+    const deadline = Date.now() + timeoutMs;
+    const check = (): void => {
+      if (existsSync(socketPath)) {
+        resolve(true);
+      } else if (Date.now() >= deadline) {
+        resolve(false);
+      } else {
+        setTimeout(check, intervalMs);
+      }
+    };
+    check();
+  });
 }
 
-async function runForeground(nerveRoot: string): Promise<void> {
-  const configResult = readConfig(nerveRoot);
-  if (!configResult.ok) {
-    process.stderr.write(`${configResult.error.message}\n`);
-    process.exit(1);
-  }
-
-  const config = configResult.value;
-  const kernel = createKernel(config, nerveRoot, {
-    enableFileWatcher: true,
-    ipcSocketPath: getSocketPath(),
-  });
-
-  const senseNames = Object.keys(config.senses);
-  const groups = [...kernel.groups];
-
-  process.stdout.write(
-    `✅ Nerve starting — ${senseNames.length} sense(s), ${groups.length} group(s)\n`,
-  );
-  for (const group of groups) {
-    const groupSenses = Object.entries(config.senses)
-      .filter(([, sc]) => sc.group === group)
-      .map(([name]) => name);
-    process.stdout.write(`   group "${group}": ${groupSenses.join(", ")}\n`);
-  }
-  process.stdout.write("   Press Ctrl+C to stop.\n");
-
-  let shuttingDown = false;
-
-  async function shutdown(): Promise<void> {
-    if (shuttingDown) return;
-    shuttingDown = true;
-    process.stdout.write("\n[nerve] Shutting down…\n");
-    await kernel.stop();
-    process.exit(0);
-  }
-
-  process.on("SIGINT", () => {
-    shutdown().catch((e: unknown) => {
-      const msg = e instanceof Error ? e.message : String(e);
-      process.stderr.write(`[nerve] Shutdown error: ${msg}\n`);
-      process.exit(1);
-    });
-  });
-
-  process.on("SIGTERM", () => {
-    shutdown().catch((e: unknown) => {
-      const msg = e instanceof Error ? e.message : String(e);
-      process.stderr.write(`[nerve] Shutdown error: ${msg}\n`);
-      process.exit(1);
-    });
-  });
-
-  await kernel.ready;
-}
-
-/** Path to the CLI entry script (for spawning `start` without `-d`). */
+/** Path to the CLI entry script (used to locate dist/ next to bundled assets). */
 function cliEntryScript(): string {
   const here = fileURLToPath(import.meta.url);
   const ext = here.endsWith(".ts") ? ".ts" : ".js";
-  // When bundled, `here` is already the CLI entry (e.g. dist/cli.js).
-  // When running from source, `here` is src/commands/start.ts → go up to src/cli.ts.
-  const candidates = [
-    join(dirname(here), `cli${ext}`),        // bundled: dist/cli.js
-    join(dirname(here), "..", `cli${ext}`),   // source: src/commands/start.ts → src/cli.ts
-  ];
+  const candidates = [join(dirname(here), `cli${ext}`), join(dirname(here), "..", `cli${ext}`)];
   const cliPath = candidates.find((p) => existsSync(p));
   if (!cliPath) {
     throw new Error(`CLI entry not found (searched: ${candidates.join(", ")})`);
@@ -101,6 +44,23 @@ function cliEntryScript(): string {
   return cliPath;
 }
 
+function daemonBootstrapScript(): string {
+  const cliPath = cliEntryScript();
+  const dir = dirname(cliPath);
+  const bootstrapJs = join(dir, "daemon-bootstrap.js");
+  if (existsSync(bootstrapJs)) {
+    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\`).`,
+  );
+}
+
+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();
@@ -108,12 +68,6 @@ async function runDaemon(nerveRoot: string): Promise<void> {
     process.exit(1);
   }
 
-  const configResult = readConfig(nerveRoot);
-  if (!configResult.ok) {
-    process.stderr.write(`${configResult.error.message}\n`);
-    process.exit(1);
-  }
-
   const logPath = getLogPath();
   await mkdir(join(nerveRoot, "logs"), { recursive: true });
 
@@ -124,12 +78,13 @@ async function runDaemon(nerveRoot: string): Promise<void> {
     else resolve();
   });
 
-  const cliPath = cliEntryScript();
+  const bootstrapPath = daemonBootstrapScript();
 
-  const child = spawn(process.execPath, [cliPath, "start"], {
+  const child = spawn(process.execPath, [bootstrapPath], {
     detached: true,
     stdio: ["ignore", logStream.fd, logStream.fd],
-    env: { ...process.env, NERVE_DAEMON_MODE: "1" },
+    env: { ...process.env, NERVE_ROOT: nerveRoot },
+    cwd: nerveRoot,
   });
 
   child.unref();
@@ -141,6 +96,18 @@ async function runDaemon(nerveRoot: string): Promise<void> {
   }
 
   writePidFile(pid);
+
+  const { getSocketPath } = await import("../workspace.js");
+  const ready = await waitForSocket(getSocketPath(), 5000);
+
+  if (!ready || !isRunning()) {
+    removePidFile();
+    process.stderr.write(
+      `❌ Daemon process exited shortly after start. Check logs at:\n   ${logPath}\n`,
+    );
+    process.exit(1);
+  }
+
   process.stdout.write(`✅ Nerve daemon started (pid ${pid}).\n`);
   process.stdout.write(`   Logs: ${logPath}\n`);
   process.stdout.write("   Run `nerve stop` to stop.\n");

packages/cli/src/commands/store.ts

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

packages/cli/src/commands/workflow.ts

@@ -1,11 +1,11 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 
-import { createLogStore } from "@uncaged/nerve-daemon";
-import type { LogStore, WorkflowRun } from "@uncaged/nerve-daemon";
 import { defineCommand } from "citty";
 
 import { triggerWorkflowViaDaemon } from "../daemon-client.js";
+import type { LogStore, WorkflowRun } from "../daemon-types.js";
+import { loadDaemonModule } from "../workspace-daemon.js";
 import { getNerveRoot, getSocketPath, isRunning } from "../workspace.js";
 
 export const DEFAULT_PAGE_SIZE = 20;
@@ -23,12 +23,14 @@ export function formatTs(ts: number): string {
   return new Date(ts).toISOString();
 }
 
-function openStore(): LogStore {
+async function openStore(): Promise<LogStore> {
+  const nerveRoot = getNerveRoot();
   const dbPath = getDbPath();
   if (!existsSync(dbPath)) {
     process.stderr.write("❌ No logs.db found — has the daemon run yet?\n");
     process.exit(1);
   }
+  const { createLogStore } = await loadDaemonModule(nerveRoot);
   return createLogStore(dbPath);
 }
 
@@ -202,7 +204,7 @@ const workflowListCommand = defineCommand({
     },
   },
   async run({ args }) {
-    const store = openStore();
+    const store = await openStore();
 
     try {
       const limit = Math.max(1, parseIntArg(args.limit, DEFAULT_PAGE_SIZE));
@@ -259,7 +261,7 @@ const workflowInspectCommand = defineCommand({
     },
   },
   async run({ args }) {
-    const store = openStore();
+    const store = await openStore();
 
     try {
       const limit = Math.max(1, parseIntArg(args.limit, DEFAULT_PAGE_SIZE));

packages/cli/src/daemon-bootstrap.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+import { runForegroundKernelSession } from "./run-foreground-kernel.js";
+import { loadDaemonModule } from "./workspace-daemon.js";
+
+const nerveRoot = process.env.NERVE_ROOT;
+if (nerveRoot === undefined || nerveRoot.length === 0) {
+  process.stderr.write("[nerve] NERVE_ROOT environment variable is required.\n");
+  process.exit(1);
+}
+
+const { createKernel } = await loadDaemonModule(nerveRoot);
+await runForegroundKernelSession(nerveRoot, createKernel);

packages/cli/src/daemon-client.ts

@@ -1,6 +1,6 @@
 /**
  * Daemon IPC client — connects to the daemon's Unix socket and sends
- * a trigger-workflow request.
+ * trigger-workflow or trigger-sense requests.
  *
  * Protocol: newline-delimited JSON (same as daemon-ipc.ts server side).
  */
@@ -13,6 +13,16 @@ const RESPONSE_TIMEOUT_MS = 5_000;
 
 type TriggerResponse = { ok: true } | { ok: false; error: string };
 
+export type SenseInfo = {
+  name: string;
+  group: string;
+  throttle: number | null;
+  timeout: number | null;
+  lastSignalTs: number | null;
+};
+
+type ListSensesResponse = { ok: true; senses: SenseInfo[] } | { ok: false; error: string };
+
 function parseDaemonResponse(line: string): TriggerResponse {
   try {
     const obj = JSON.parse(line) as unknown;
@@ -27,15 +37,7 @@ function parseDaemonResponse(line: string): TriggerResponse {
   return { ok: false, error: `Unexpected daemon response: ${line}` };
 }
 
-/**
- * Send a trigger-workflow message to the running daemon via its Unix socket.
- * Resolves with the daemon's response or rejects on connection/timeout errors.
- */
-export function triggerWorkflowViaDaemon(
-  socketPath: string,
-  workflow: string,
-  payload: unknown,
-): Promise<TriggerResponse> {
+function sendAndReceive(socketPath: string, message: object): Promise<TriggerResponse> {
   return new Promise((resolve, reject) => {
     let socket: Socket | null = null;
     let settled = false;
@@ -79,7 +81,7 @@ export function triggerWorkflowViaDaemon(
         }
       });
 
-      const msg = `${JSON.stringify({ type: "trigger-workflow", workflow, payload })}\n`;
+      const msg = `${JSON.stringify(message)}\n`;
       socket?.write(msg);
     });
 
@@ -89,3 +91,100 @@ export function triggerWorkflowViaDaemon(
     });
   });
 }
+
+/**
+ * Send a trigger-workflow message to the running daemon via its Unix socket.
+ * Resolves with the daemon's response or rejects on connection/timeout errors.
+ */
+export function triggerWorkflowViaDaemon(
+  socketPath: string,
+  workflow: string,
+  payload: unknown,
+): Promise<TriggerResponse> {
+  return sendAndReceive(socketPath, { type: "trigger-workflow", workflow, payload });
+}
+
+/**
+ * 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 });
+}
+
+/**
+ * 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 new Promise((resolve, reject) => {
+    let socket: Socket | null = null;
+    let settled = false;
+
+    function settle(result: ListSensesResponse | Error): void {
+      if (settled) return;
+      settled = true;
+      if (socket !== null) {
+        socket.destroy();
+        socket = null;
+      }
+      if (result instanceof Error) {
+        reject(result);
+      } else {
+        resolve(result);
+      }
+    }
+
+    const connectTimer = setTimeout(() => {
+      settle(new Error(`Timed out connecting to daemon socket: ${socketPath}`));
+    }, CONNECT_TIMEOUT_MS);
+
+    socket = connect(socketPath, () => {
+      clearTimeout(connectTimer);
+
+      const responseTimer = setTimeout(() => {
+        settle(new Error("Timed out waiting for daemon response"));
+      }, RESPONSE_TIMEOUT_MS);
+
+      let buf = "";
+      socket?.on("data", (chunk: Buffer) => {
+        buf += chunk.toString("utf8");
+        const lines = buf.split("\n");
+        buf = lines.pop() ?? "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (trimmed.length === 0) continue;
+          clearTimeout(responseTimer);
+          try {
+            const obj = JSON.parse(trimmed) as unknown;
+            if (obj !== null && typeof obj === "object") {
+              const r = obj as Record<string, unknown>;
+              if (r.ok === false && typeof r.error === "string") {
+                settle({ ok: false, error: r.error });
+                return;
+              }
+              if (r.ok === true && Array.isArray(r.senses)) {
+                settle({ ok: true, senses: r.senses as SenseInfo[] });
+                return;
+              }
+            }
+          } catch {
+            // fall through
+          }
+          settle({ ok: false, error: `Unexpected daemon response: ${trimmed}` });
+          return;
+        }
+      });
+
+      socket?.write(`${JSON.stringify({ type: "list-senses" })}\n`);
+    });
+
+    socket.on("error", (err) => {
+      clearTimeout(connectTimer);
+      settle(new Error(`Cannot connect to daemon: ${err.message}`));
+    });
+  });
+}

packages/cli/src/daemon-types.ts

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

@@ -8,5 +8,8 @@ export {
   isRunning,
 } from "./workspace.js";
 
-export { createKernel } from "@uncaged/nerve-daemon";
-export type { Kernel } from "@uncaged/nerve-daemon";
+export {
+  assertWorkspaceDaemonInstalled,
+  getDaemonEntryPath,
+  loadDaemonModule,
+} from "./workspace-daemon.js";

packages/cli/src/run-foreground-kernel.ts

@@ -0,0 +1,88 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { NerveConfig } from "@uncaged/nerve-core";
+import { parseNerveConfig } from "@uncaged/nerve-core";
+
+import { getSocketPath } from "./workspace.js";
+
+export type CreateKernelFn = (
+  config: NerveConfig,
+  nerveRoot: string,
+  opts: { enableFileWatcher: boolean; ipcSocketPath: string },
+) => {
+  groups: Set<string>;
+  ready: Promise<void>;
+  stop: () => Promise<void>;
+};
+
+function readConfig(nerveRoot: string): ReturnType<typeof parseNerveConfig> {
+  const configPath = join(nerveRoot, "nerve.yaml");
+  let raw: string;
+  try {
+    raw = readFileSync(configPath, "utf8");
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return { ok: false, error: new Error(`❌ Cannot read ${configPath}: ${msg}`) };
+  }
+  return parseNerveConfig(raw);
+}
+
+export async function runForegroundKernelSession(
+  nerveRoot: string,
+  createKernel: CreateKernelFn,
+): Promise<void> {
+  const configResult = readConfig(nerveRoot);
+  if (!configResult.ok) {
+    process.stderr.write(`${configResult.error.message}\n`);
+    process.exit(1);
+  }
+
+  const config = configResult.value;
+  const kernel = createKernel(config, nerveRoot, {
+    enableFileWatcher: true,
+    ipcSocketPath: getSocketPath(),
+  });
+
+  const senseNames = Object.keys(config.senses);
+  const groups = [...kernel.groups];
+
+  process.stdout.write(
+    `✅ Nerve starting — ${senseNames.length} sense(s), ${groups.length} group(s)\n`,
+  );
+  for (const group of groups) {
+    const groupSenses = Object.entries(config.senses)
+      .filter(([, sc]) => sc.group === group)
+      .map(([name]) => name);
+    process.stdout.write(`   group "${group}": ${groupSenses.join(", ")}\n`);
+  }
+  process.stdout.write("   Press Ctrl+C to stop.\n");
+
+  let shuttingDown = false;
+
+  async function shutdown(): Promise<void> {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    process.stdout.write("\n[nerve] Shutting down…\n");
+    await kernel.stop();
+    process.exit(0);
+  }
+
+  process.on("SIGINT", () => {
+    shutdown().catch((e: unknown) => {
+      const msg = e instanceof Error ? e.message : String(e);
+      process.stderr.write(`[nerve] Shutdown error: ${msg}\n`);
+      process.exit(1);
+    });
+  });
+
+  process.on("SIGTERM", () => {
+    shutdown().catch((e: unknown) => {
+      const msg = e instanceof Error ? e.message : String(e);
+      process.stderr.write(`[nerve] Shutdown error: ${msg}\n`);
+      process.exit(1);
+    });
+  });
+
+  await kernel.ready;
+}

packages/cli/src/workspace-daemon.ts

@@ -0,0 +1,50 @@
+import { existsSync } from "node:fs";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+import type { NerveConfig } from "@uncaged/nerve-core";
+
+import type { LogStore } from "./daemon-types.js";
+
+export function getDaemonEntryPath(nerveRoot: string): string | undefined {
+  const pkgPath = join(nerveRoot, "node_modules", "@uncaged", "nerve-daemon", "package.json");
+  if (!existsSync(pkgPath)) return undefined;
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as { main?: string };
+    const main = pkg.main ?? "dist/index.js";
+    return join(nerveRoot, "node_modules", "@uncaged", "nerve-daemon", main);
+  } catch {
+    return join(nerveRoot, "node_modules", "@uncaged", "nerve-daemon", "dist", "index.js");
+  }
+}
+
+export function assertWorkspaceDaemonInstalled(nerveRoot: string): string {
+  const entry = getDaemonEntryPath(nerveRoot);
+  if (!entry || !existsSync(entry)) {
+    throw new Error(
+      `@uncaged/nerve-daemon is not installed under ${nerveRoot}/node_modules/. Run \`nerve init\` (or \`nerve init --force\`) to install workspace dependencies.`,
+    );
+  }
+  return entry;
+}
+
+/** Loaded from ~/.uncaged-nerve/node_modules at runtime — keep types structural only. */
+export type DaemonModule = {
+  createKernel: (
+    config: NerveConfig,
+    nerveRoot: string,
+    options: { enableFileWatcher: boolean; ipcSocketPath: string },
+  ) => {
+    groups: Set<string>;
+    ready: Promise<void>;
+    stop: () => Promise<void>;
+  };
+  createLogStore: (dbPath: string) => LogStore;
+};
+
+export async function loadDaemonModule(nerveRoot: string): Promise<DaemonModule> {
+  const entry = assertWorkspaceDaemonInstalled(nerveRoot);
+  const url = pathToFileURL(entry).href;
+  return import(url) as Promise<DaemonModule>;
+}

packages/cli/tsup.config.ts

@@ -1,8 +1,13 @@
 import { defineConfig } from "tsup";
 
 export default defineConfig({
-  entry: ["src/index.ts", "src/cli.ts"],
+  entry: ["src/index.ts", "src/cli.ts", "src/daemon-bootstrap.ts"],
   format: ["esm"],
   dts: true,
   clean: true,
+  banner: {
+    js: "#!/usr/bin/env node",
+  },
+  /** Daemon is loaded from workspace node_modules at runtime — never bundle it. */
+  external: ["@uncaged/nerve-daemon"],
 });

packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uncaged/nerve-core",
-  "version": "0.0.1",
+  "version": "0.1.2",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

packages/daemon/package.json

@@ -1,10 +1,15 @@
 {
   "name": "@uncaged/nerve-daemon",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.1.3",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "build": "tsup",
     "test": "vitest run"

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__/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__/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/daemon-ipc.ts

@@ -1,10 +1,13 @@
 /**
  * Daemon IPC server — listens on a Unix domain socket so that the CLI
- * can send commands (e.g. trigger-workflow) to the running daemon process.
+ * can send commands (e.g. trigger-workflow, trigger-sense) to the running daemon process.
  *
  * 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";
@@ -19,9 +22,32 @@ export type TriggerWorkflowRequest = {
   payload: unknown;
 };
 
-type DaemonRequest = TriggerWorkflowRequest;
+/** JSON message sent by the CLI to trigger a sense compute on-demand. */
+export type TriggerSenseRequest = {
+  type: "trigger-sense";
+  sense: string;
+};
 
-type DaemonResponse = { ok: true } | { ok: false; error: string };
+/** JSON message sent by the CLI to list registered senses. */
+export type ListSensesRequest = {
+  type: "list-senses";
+};
+
+/** Runtime info about a single sense returned by list-senses. */
+export type SenseInfo = {
+  name: string;
+  group: string;
+  throttle: number | null;
+  timeout: number | null;
+  lastSignalTs: number | null;
+};
+
+type DaemonRequest = TriggerWorkflowRequest | TriggerSenseRequest | ListSensesRequest;
+
+type DaemonResponse =
+  | { ok: true }
+  | { ok: false; error: string }
+  | { ok: true; senses: SenseInfo[] };
 
 export type DaemonIpcServer = {
   close: () => Promise<void>;
@@ -36,15 +62,30 @@ function parseRequest(line: string): DaemonRequest | null {
       if (typeof req.workflow !== "string" || req.workflow.length === 0) return null;
       return { type: "trigger-workflow", workflow: req.workflow, payload: req.payload ?? {} };
     }
+    if (req.type === "trigger-sense") {
+      if (typeof req.sense !== "string" || req.sense.length === 0) return null;
+      return { type: "trigger-sense", sense: req.sense };
+    }
+    if (req.type === "list-senses") {
+      return { type: "list-senses" };
+    }
     return null;
   } catch {
     return null;
   }
 }
 
+export type DaemonIpcServerOptions = {
+  /** Called when a trigger-sense request arrives. Should throw if the sense is unknown. */
+  triggerSense: (senseName: string) => void;
+  /** Called when a list-senses request arrives. Returns sense info for all registered senses. */
+  listSenses: () => SenseInfo[];
+};
+
 export function createDaemonIpcServer(
   socketPath: string,
   workflowManager: WorkflowManager,
+  opts: DaemonIpcServerOptions,
 ): DaemonIpcServer {
   // Remove stale socket file if it exists
   try {
@@ -65,9 +106,19 @@ export function createDaemonIpcServer(
     }
 
     try {
-      workflowManager.startWorkflow(req.workflow, req.payload);
-      const resp: DaemonResponse = { ok: true };
-      socket.write(`${JSON.stringify(resp)}\n`);
+      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`);
+      }
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       const resp: DaemonResponse = { ok: false, error: msg };

packages/daemon/src/index.ts

@@ -32,13 +32,16 @@ export type { Kernel, KernelOptions, KernelHealth } from "./kernel.js";
 export { createFileWatcher } from "./file-watcher.js";
 export type { FileWatcher, FileChange, FileChangeHandler } from "./file-watcher.js";
 
-export { createLogStore } from "./log-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

@@ -22,7 +22,7 @@ import type { NerveConfig, Signal } from "@uncaged/nerve-core";
 import { parseNerveConfig } from "@uncaged/nerve-core";
 
 import { createDaemonIpcServer } from "./daemon-ipc.js";
-import type { DaemonIpcServer } from "./daemon-ipc.js";
+import type { DaemonIpcServer, SenseInfo } from "./daemon-ipc.js";
 import { createFileWatcher } from "./file-watcher.js";
 import type { FileWatcher } from "./file-watcher.js";
 import type { ComputeMessage, ShutdownMessage } from "./ipc.js";
@@ -58,6 +58,11 @@ export type Kernel = {
   getWorkerPid: (group: string) => number | null;
   /** Sends a compute message to the worker responsible for the given sense. */
   triggerCompute: (senseName: string) => void;
+  /**
+   * On-demand sense trigger — looks up the group for `senseName`, finds its worker,
+   * and sends a compute message. Throws if the sense is unknown.
+   */
+  triggerSense: (senseName: string) => void;
   /** Gracefully restart a group worker (wait for exit, then respawn). */
   restartGroup: (group: string) => Promise<void>;
   /** Reload config from a new NerveConfig, incrementally updating scheduler and workers.
@@ -80,9 +85,12 @@ function resolveWorkerScript(): string {
 }
 
 function spawnWorker(nerveRoot: string, group: string, workerScript: string): ChildProcess {
-  return fork(workerScript, ["--group", group, "--root", nerveRoot], {
+  const child = fork(workerScript, ["--group", group, "--root", nerveRoot], {
     stdio: ["ignore", "inherit", "inherit", "ipc"],
   });
+  // Prevent unhandled EPIPE when writing to a child whose IPC channel closed
+  child.on("error", () => {});
+  return child;
 }
 
 function sendCompute(worker: ChildProcess, senseName: string): void {
@@ -280,6 +288,18 @@ export function createKernel(
     sendCompute(entry.process, senseName);
   }
 
+  function triggerSense(senseName: string): void {
+    const group = groupForSense(config, senseName);
+    if (group === null) {
+      throw new Error(`Unknown sense: "${senseName}"`);
+    }
+    const entry = workers.get(group);
+    if (entry === undefined) {
+      throw new Error(`No worker running for group "${group}" (sense: "${senseName}")`);
+    }
+    sendCompute(entry.process, senseName);
+  }
+
   scheduler = createReflexScheduler(config, bus, triggerFn, {
     logStore,
     workflowTriggerFn: (workflowName, payload) => {
@@ -499,7 +519,26 @@ export function createKernel(
 
   let ipcServer: DaemonIpcServer | null = null;
   if (options.ipcSocketPath != null) {
-    ipcServer = createDaemonIpcServer(options.ipcSocketPath, workflowManager);
+    ipcServer = createDaemonIpcServer(options.ipcSocketPath, workflowManager, {
+      triggerSense,
+      listSenses(): SenseInfo[] {
+        return Object.entries(config.senses).map(([name, senseConfig]) => {
+          const entries = logStore.query({
+            source: "reflex",
+            type: "run_complete",
+            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,
+          };
+        });
+      },
+    });
   }
 
   async function stop(): Promise<void> {
@@ -546,6 +585,7 @@ export function createKernel(
     ready,
     getWorkerPid,
     triggerCompute: triggerFn,
+    triggerSense,
     restartGroup,
     reloadConfig,
     getHealth,

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/workflow-manager.ts

@@ -86,9 +86,12 @@ function spawnWorkflowWorker(
   workflowName: string,
   workerScript: string,
 ): ChildProcess {
-  return fork(workerScript, ["--workflow", workflowName, "--root", nerveRoot], {
+  const child = fork(workerScript, ["--workflow", workflowName, "--root", nerveRoot], {
     stdio: ["ignore", "inherit", "inherit", "ipc"],
   });
+  // Prevent unhandled EPIPE when writing to a child whose IPC channel closed
+  child.on("error", () => {});
+  return child;
 }
 
 function sendStartThread(worker: ChildProcess, msg: StartThreadMessage): void {

pnpm-lock.yaml

@@ -23,9 +23,6 @@ importers:
       '@uncaged/nerve-core':
         specifier: workspace:*
         version: link:../core
-      '@uncaged/nerve-daemon':
-        specifier: workspace:*
-        version: link:../daemon
       citty:
         specifier: ^0.1.6
         version: 0.1.6
@@ -36,6 +33,9 @@ importers:
       '@types/node':
         specifier: ^22.0.0
         version: 22.19.17
+      '@uncaged/nerve-daemon':
+        specifier: workspace:*
+        version: link:../daemon
       vitest:
         specifier: ^4.1.5
         version: 4.1.5(@types/node@22.19.17)(vite@8.0.9(@types/node@22.19.17)(esbuild@0.27.7)(yaml@2.8.3))