fix: address review issues #46-#49

#46 — EPIPE handler: only silence EPIPE, log other child errors
#47 — lastSignalTs: query sense/signal instead of reflex/run_complete
#48 — SenseInfo: deduplicate to @uncaged/nerve-core, add expectTypeOf test
#49 — IPC client: extract sendAndReceive<T> to eliminate duplication

小橘 <xiaoju@shazhou.work>

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

@@ -3,6 +3,7 @@
  * 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,
@@ -10,6 +11,7 @@ import type {
   LogEntry as DaemonLogEntry,
   LogQuery as DaemonLogQuery,
   LogStore as DaemonLogStore,
+  SenseInfo as DaemonSenseInfo,
   WorkflowRun as DaemonWorkflowRun,
   WorkflowRunStatus as DaemonWorkflowRunStatus,
 } from "@uncaged/nerve-daemon";
@@ -27,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>();

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

@@ -13,18 +13,24 @@ 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 { listSensesViaDaemon } from "../daemon-client.js";
-import type { SenseInfo } from "../daemon-client.js";
 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: "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 },
 ];

packages/cli/src/commands/init.ts

@@ -219,6 +219,23 @@ 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
+    const { execFile } = await import("node:child_process");
+    const { promisify } = await import("node:util");
+    const execFileAsync = promisify(execFile);
+    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 +259,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,11 +1,10 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 
-import { parseNerveConfig } from "@uncaged/nerve-core";
+import { type SenseInfo, 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";
 
 // ---------------------------------------------------------------------------
@@ -35,8 +34,7 @@ export function formatSenseList(senses: SenseInfo[]): string {
     lines.push(`    group:    ${s.group}\n`);
     lines.push(`    throttle: ${formatDuration(s.throttle)}\n`);
     lines.push(`    timeout:  ${formatDuration(s.timeout)}\n`);
-    const lastSignal =
-      s.lastSignalTs !== null ? new Date(s.lastSignalTs).toISOString() : "(never)";
+    const lastSignal = s.lastSignalTs !== null ? new Date(s.lastSignalTs).toISOString() : "(never)";
     lines.push(`    last signal: ${lastSignal}\n`);
   }
   return lines.join("");

packages/cli/src/daemon-client.ts

@@ -8,18 +8,14 @@
 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;
 
-type TriggerResponse = { ok: true } | { ok: false; error: string };
+export type { SenseInfo };
 
-export type SenseInfo = {
-  name: string;
-  group: string;
-  throttle: number | null;
-  timeout: number | null;
-  lastSignalTs: number | null;
-};
+type TriggerResponse = { ok: true } | { ok: false; error: string };
 
 type ListSensesResponse = { ok: true; senses: SenseInfo[] } | { ok: false; error: string };
 
@@ -37,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) {
@@ -65,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) => {
@@ -76,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;
         }
       });
@@ -101,18 +121,19 @@ 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);
 }
 
 /**
@@ -120,71 +141,5 @@ export function triggerSenseViaDaemon(
  * 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}`));
-    });
-  });
+  return sendAndReceive(socketPath, { type: "list-senses" }, parseListSensesResponse);
 }

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/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__/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__/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/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

@@ -13,8 +13,12 @@
 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";
@@ -33,15 +37,6 @@ 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 =

packages/daemon/src/index.ts

@@ -29,9 +29,14 @@ 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 { 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,

packages/daemon/src/kernel.ts

@@ -18,11 +18,11 @@ 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";
-import type { DaemonIpcServer, SenseInfo } from "./daemon-ipc.js";
+import type { DaemonIpcServer } from "./daemon-ipc.js";
 import { createFileWatcher } from "./file-watcher.js";
 import type { FileWatcher } from "./file-watcher.js";
 import type { ComputeMessage, ShutdownMessage } from "./ipc.js";
@@ -89,7 +89,11 @@ function spawnWorker(nerveRoot: string, group: string, workerScript: string): Ch
     stdio: ["ignore", "inherit", "inherit", "ipc"],
   });
   // Prevent unhandled EPIPE when writing to a child whose IPC channel closed
-  child.on("error", () => {});
+  child.on("error", (err) => {
+    if ((err as NodeJS.ErrnoException).code !== "EPIPE") {
+      console.error("[worker] error:", err.message);
+    }
+  });
   return child;
 }
 
@@ -222,8 +226,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,
@@ -524,8 +528,8 @@ export function createKernel(
       listSenses(): SenseInfo[] {
         return Object.entries(config.senses).map(([name, senseConfig]) => {
           const entries = logStore.query({
-            source: "reflex",
-            type: "run_complete",
+            source: "sense",
+            type: "signal",
             refId: name,
           });
           const lastEntry = entries.length > 0 ? entries[entries.length - 1] : null;

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> = (
@@ -192,14 +197,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,6 +20,7 @@ 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";
@@ -162,9 +164,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 +196,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 +234,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 +298,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);
   });
 }
 

packages/daemon/src/workflow-manager.ts

@@ -90,7 +90,11 @@ function spawnWorkflowWorker(
     stdio: ["ignore", "inherit", "inherit", "ipc"],
   });
   // Prevent unhandled EPIPE when writing to a child whose IPC channel closed
-  child.on("error", () => {});
+  child.on("error", (err) => {
+    if ((err as NodeJS.ErrnoException).code !== "EPIPE") {
+      console.error("[worker] error:", err.message);
+    }
+  });
   return child;
 }