chore: walkthrough cleanup — engines, types, mock fixes

- Add engines >= 22.5.0 to root and cli package.json (node:sqlite requirement)
- Remove unused @types/better-sqlite3 from cli devDeps (leftover from sql.js migration)
- Add files/publishConfig to core package.json (parity with other packages)
- Fix daemon test type errors: add getAllWorkflowRuns to mock LogStore,
  fix array destructuring on mock.calls, fix sense-runtime callback signatures

All 356 tests pass across all packages.

小橘 🍊（NEKO Team）

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

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

package.json

@@ -1,6 +1,9 @@
 {
   "name": "nerve",
   "private": true,
+  "engines": {
+    "node": ">=22.5.0"
+  },
   "scripts": {
     "build": "pnpm -r run build",
     "check": "biome check .",

packages/cli/package.json

@@ -1,6 +1,9 @@
 {
   "name": "@uncaged/nerve-cli",
-  "version": "0.1.7",
+  "engines": {
+    "node": ">=22.5.0"
+  },
+  "version": "0.1.8",
   "type": "module",
   "bin": {
     "nerve": "dist/cli.js"
@@ -23,9 +26,8 @@
     "citty": "^0.1.6"
   },
   "devDependencies": {
-    "@uncaged/nerve-daemon": "workspace:*",
-    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22.0.0",
+    "@uncaged/nerve-daemon": "workspace:*",
     "vitest": "^4.1.5"
   }
 }

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

@@ -0,0 +1,159 @@
+/**
+ * Tests for sense SQLite helpers used by `nerve sense schema` / `nerve sense query`.
+ */
+
+import { mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import {
+  assertSenseDbExists,
+  collectColumnKeys,
+  defaultPreviewSql,
+  formatRowsAsAlignedTable,
+  listTableSqlStatements,
+  parseSenseQueryArgs,
+  pickDefaultPreviewTable,
+  senseDbPath,
+} from "../sense-sqlite.js";
+
+let tmpDir: string;
+
+beforeEach(() => {
+  tmpDir = join(
+    tmpdir(),
+    `nerve-sense-sqlite-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+  );
+  mkdirSync(join(tmpDir, "data", "senses"), { recursive: true });
+});
+
+afterEach(() => {
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe("senseDbPath", () => {
+  it("points at data/senses/<name>.db under the given root", () => {
+    expect(senseDbPath("/root", "cpu-usage")).toBe(join("/root", "data", "senses", "cpu-usage.db"));
+  });
+});
+
+describe("assertSenseDbExists", () => {
+  it("throws when the file is missing", () => {
+    expect(() => assertSenseDbExists(tmpDir, "nope")).toThrow(/No database at/);
+  });
+
+  it("returns the path when the file exists", () => {
+    const p = join(tmpDir, "data", "senses", "x.db");
+    new DatabaseSync(p).close();
+    expect(assertSenseDbExists(tmpDir, "x")).toBe(p);
+  });
+});
+
+describe("listTableSqlStatements", () => {
+  it("returns CREATE statements ordered by tbl_name", () => {
+    const p = join(tmpDir, "data", "senses", "t.db");
+    const db = new DatabaseSync(p);
+    db.exec("CREATE TABLE zebra (id INTEGER)");
+    db.exec("CREATE TABLE alpha (id INTEGER)");
+    const stmts = listTableSqlStatements(db);
+    db.close();
+    expect(stmts).toHaveLength(2);
+    expect(stmts[0]).toMatch(/^CREATE TABLE alpha/i);
+    expect(stmts[1]).toMatch(/^CREATE TABLE zebra/i);
+  });
+});
+
+describe("pickDefaultPreviewTable", () => {
+  it("prefers non-_migrations tables when both exist", () => {
+    const p = join(tmpDir, "data", "senses", "t.db");
+    const db = new DatabaseSync(p);
+    db.exec("CREATE TABLE _migrations (name TEXT PRIMARY KEY)");
+    db.exec("CREATE TABLE readings (id INTEGER)");
+    expect(pickDefaultPreviewTable(db)).toBe("readings");
+    db.close();
+  });
+
+  it("uses _migrations when it is the only table", () => {
+    const p = join(tmpDir, "data", "senses", "t.db");
+    const db = new DatabaseSync(p);
+    db.exec("CREATE TABLE _migrations (name TEXT PRIMARY KEY)");
+    expect(pickDefaultPreviewTable(db)).toBe("_migrations");
+    db.close();
+  });
+});
+
+describe("defaultPreviewSql", () => {
+  it("quotes identifiers for SQL safety", () => {
+    expect(defaultPreviewSql(`weird"name`)).toContain(`weird""name`);
+  });
+});
+
+describe("parseSenseQueryArgs", () => {
+  it("parses sense name only", () => {
+    expect(parseSenseQueryArgs(["cpu"])).toEqual({ name: "cpu", sql: undefined });
+  });
+
+  it("strips --json", () => {
+    expect(parseSenseQueryArgs(["cpu", "--json"])).toEqual({ name: "cpu", sql: undefined });
+    expect(parseSenseQueryArgs(["--json", "cpu"])).toEqual({ name: "cpu", sql: undefined });
+  });
+
+  it("joins remaining tokens into SQL", () => {
+    expect(parseSenseQueryArgs(["cpu", "SELECT", "1"])).toEqual({ name: "cpu", sql: "SELECT 1" });
+  });
+
+  it("throws when name is missing", () => {
+    expect(() => parseSenseQueryArgs(["--json"])).toThrow(/Missing sense name/);
+  });
+});
+
+describe("formatRowsAsAlignedTable", () => {
+  it("shows empty marker for no rows", () => {
+    expect(formatRowsAsAlignedTable([])).toContain("(0 rows)");
+  });
+
+  it("aligns columns from row data", () => {
+    const out = formatRowsAsAlignedTable([
+      { a: 1, b: "x" },
+      { a: 22, b: "yy" },
+    ]);
+    expect(out).toContain("a");
+    expect(out).toContain("b");
+    expect(out).toContain("22");
+  });
+});
+
+describe("collectColumnKeys", () => {
+  it("preserves key order from first row then appends new keys", () => {
+    expect(
+      collectColumnKeys([
+        { z: 1, a: 2 },
+        { a: 3, b: 4 },
+      ]),
+    ).toEqual(["z", "a", "b"]);
+  });
+});
+
+describe("readonly query integration", () => {
+  it("runs default preview SQL on a real db", () => {
+    const p = join(tmpDir, "data", "senses", "demo.db");
+    const rw = new DatabaseSync(p);
+    rw.exec("CREATE TABLE items (id INTEGER PRIMARY KEY, v TEXT)");
+    rw.exec("INSERT INTO items (v) VALUES ('a'), ('b')");
+    rw.close();
+
+    const db = new DatabaseSync(p, { readOnly: true });
+    const table = pickDefaultPreviewTable(db);
+    expect(table).toBe("items");
+    if (table === null) {
+      throw new Error("expected items table");
+    }
+    const sql = defaultPreviewSql(table);
+    const rows = db.prepare(sql).all() as Record<string, unknown>[];
+    db.close();
+    expect(rows.length).toBeGreaterThanOrEqual(1);
+  });
+});

packages/cli/src/commands/init.ts

@@ -1,5 +1,7 @@
+import { spawn, execFile } from "node:child_process";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { promisify } from "node:util";
 
 import { defineCommand } from "citty";
 
@@ -42,6 +44,8 @@ const GITIGNORE = `data/
 node_modules/
 `;
 
+const execFileAsync = promisify(execFile);
+
 const CPU_SCHEMA_TS = `import { integer, real, sqliteTable, text } from "drizzle-orm/sqlite-core";
 
 export const cpuUsage = sqliteTable("cpu_usage", {
@@ -90,7 +94,6 @@ function writeFile(filePath: string, content: string): void {
 }
 
 async function runCommand(cmd: string, args: string[], cwd: string): Promise<void> {
-  const { spawn } = await import("node:child_process");
   await new Promise<void>((resolve, reject) => {
     const child = spawn(cmd, args, { cwd, stdio: "inherit" });
     child.on("close", (code) => {
@@ -102,10 +105,6 @@ async function runCommand(cmd: string, args: string[], cwd: string): Promise<voi
 }
 
 async function detectPackageManager(): Promise<{ cmd: string; installArgs: string[] }> {
-  const { execFile } = await import("node:child_process");
-  const { promisify } = await import("node:util");
-  const execFileAsync = promisify(execFile);
-
   for (const pm of ["pnpm", "yarn", "npm"]) {
     try {
       await execFileAsync(pm, ["--version"]);
@@ -223,9 +222,6 @@ 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,

packages/cli/src/commands/sense.ts

@@ -1,10 +1,20 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
 
 import { type SenseInfo, parseNerveConfig } from "@uncaged/nerve-core";
 import { defineCommand } from "citty";
 
 import { listSensesViaDaemon, triggerSenseViaDaemon } from "../daemon-client.js";
+import {
+  assertSenseDbExists,
+  defaultPreviewSql,
+  formatRowsAsAlignedTable,
+  listTableSqlStatements,
+  openSenseDb,
+  parseSenseQueryArgs,
+  pickDefaultPreviewTable,
+} from "../sense-sqlite.js";
 import { getNerveRoot, getSocketPath, isRunning } from "../workspace.js";
 
 // ---------------------------------------------------------------------------
@@ -70,7 +80,6 @@ const senseListCommand = defineCommand({
   },
   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",
       );
@@ -139,6 +148,115 @@ const senseTriggerCommand = defineCommand({
   },
 });
 
+// ---------------------------------------------------------------------------
+// nerve sense schema <name>
+// ---------------------------------------------------------------------------
+
+const senseSchemaCommand = defineCommand({
+  meta: {
+    name: "schema",
+    description: "Print CREATE TABLE statements from a sense SQLite database",
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Sense name (data/senses/<name>.db under the nerve workspace)",
+    },
+    json: {
+      type: "boolean",
+      description: "Print JSON array of CREATE TABLE SQL strings",
+      default: false,
+    },
+  },
+  async run({ args }) {
+    const nerveRoot = getNerveRoot();
+    let db: DatabaseSync | undefined;
+    try {
+      db = openSenseDb(nerveRoot, args.name);
+      const statements = listTableSqlStatements(db);
+      if (args.json) {
+        process.stdout.write(`${JSON.stringify(statements, null, 2)}\n`);
+      } else if (statements.length === 0) {
+        process.stdout.write("(no tables)\n");
+      } else {
+        for (const sql of statements) {
+          process.stdout.write(`${sql};\n\n`);
+        }
+      }
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      process.stderr.write(`❌ ${msg}\n`);
+      process.exit(1);
+    } finally {
+      db?.close();
+    }
+  },
+});
+
+// ---------------------------------------------------------------------------
+// nerve sense query <name> [sql...]
+// ---------------------------------------------------------------------------
+
+const senseQueryCommand = defineCommand({
+  meta: {
+    name: "query",
+    description:
+      "Run a read-only SQL query against a sense database (default: last 10 rows of the first data table). Pass optional SQL after the sense name; multiple words are joined.",
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Sense name (data/senses/<name>.db under the nerve workspace)",
+    },
+    json: {
+      type: "boolean",
+      description: "Print result rows as JSON",
+      default: false,
+    },
+  },
+  async run({ args, rawArgs }) {
+    const nerveRoot = getNerveRoot();
+    let db: DatabaseSync | undefined;
+    try {
+      let parsed: { name: string; sql: string | undefined };
+      try {
+        parsed = parseSenseQueryArgs(rawArgs);
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        process.stderr.write(`❌ ${msg}\n`);
+        process.exit(1);
+      }
+
+      db = openSenseDb(nerveRoot, args.name);
+
+      let sql = parsed.sql?.trim();
+      if (!sql) {
+        const table = pickDefaultPreviewTable(db);
+        if (table === null) {
+          process.stderr.write("❌ No tables found in database.\n");
+          process.exit(1);
+        } else {
+          sql = defaultPreviewSql(table);
+        }
+      }
+
+      const rows = db.prepare(sql).all() as Record<string, unknown>[];
+
+      if (args.json) {
+        process.stdout.write(`${JSON.stringify(rows, null, 2)}\n`);
+      } else {
+        process.stdout.write(formatRowsAsAlignedTable(rows));
+      }
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      process.stderr.write(`❌ ${msg}\n`);
+      process.exit(1);
+    } finally {
+      db?.close();
+    }
+  },
+});
+
 // ---------------------------------------------------------------------------
 // nerve sense (parent command)
 // ---------------------------------------------------------------------------
@@ -151,5 +269,7 @@ export const senseCommand = defineCommand({
   subCommands: {
     list: senseListCommand,
     trigger: senseTriggerCommand,
+    schema: senseSchemaCommand,
+    query: senseQueryCommand,
   },
 });

packages/cli/src/commands/start.ts

@@ -1,3 +1,4 @@
+import { spawn } from "node:child_process";
 import { createWriteStream, existsSync } from "node:fs";
 import { mkdir } from "node:fs/promises";
 import { dirname, join } from "node:path";
@@ -8,6 +9,7 @@ import { defineCommand } from "citty";
 import {
   getLogPath,
   getNerveRoot,
+  getSocketPath,
   isRunning,
   readPidFile,
   removePidFile,
@@ -64,7 +66,6 @@ async function runDaemon(nerveRoot: string): Promise<void> {
   const logPath = getLogPath();
   await mkdir(join(nerveRoot, "logs"), { recursive: true });
 
-  const { spawn } = await import("node:child_process");
   const logStream = createWriteStream(logPath, { flags: "a" });
   await new Promise<void>((resolve) => {
     if (logStream.pending) logStream.once("open", () => resolve());
@@ -90,7 +91,6 @@ async function runDaemon(nerveRoot: string): Promise<void> {
 
   writePidFile(pid);
 
-  const { getSocketPath } = await import("../workspace.js");
   const ready = await waitForSocket(getSocketPath(), 5000);
 
   if (!ready || !isRunning()) {

packages/cli/src/sense-sqlite.ts

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

packages/core/package.json

@@ -3,6 +3,10 @@
   "version": "0.1.4",
   "type": "module",
   "main": "dist/index.js",
+  "files": ["dist"],
+  "publishConfig": {
+    "access": "public"
+  },
   "types": "dist/index.d.ts",
   "scripts": {
     "prepublishOnly": "bash ../../scripts/prepublish-check.sh",

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

@@ -89,10 +89,11 @@ function makeLogStore(
       }
       return activeRuns;
     }),
-    getTriggerPayload: vi.fn(() => ({ value: 42 })),
-    getThreadEvents: vi.fn(() => [{ type: "thread_start", triggerPayload: {} }]),
+    getTriggerPayload: vi.fn((): unknown => ({ value: 42 })),
+    getThreadEvents: vi.fn((): Array<{ type: string; [key: string]: unknown }> => [{ type: "thread_start", triggerPayload: {} }]),
     archiveLogs: vi.fn(() => ({ days: [], vacuumed: false })),
     close: vi.fn(),
+    getAllWorkflowRuns: vi.fn(() => []),
   };
   return store;
 }
@@ -127,7 +128,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       child.emit("exit", 1, null);
 
       const crashedCalls = logStore.upsertWorkflowRun.mock.calls.filter(
-        ([entry]: [{ type: string }]) => entry.type === "crashed",
+        (args: any[]) => (args[0] as { type: string }).type === "crashed",
       );
       expect(crashedCalls).toHaveLength(2);
 
@@ -216,10 +217,10 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
 
       // resume-thread should have been sent
       const resumeCalls = (secondChild.send as ReturnType<typeof vi.fn>).mock.calls.filter(
-        ([msg]: [unknown]) =>
-          msg !== null &&
-          typeof msg === "object" &&
-          (msg as Record<string, unknown>).type === "resume-thread",
+        (args: any[]) =>
+          args[0] !== null &&
+          typeof args[0] === "object" &&
+          (args[0] as Record<string, unknown>).type === "resume-thread",
       );
       expect(resumeCalls).toHaveLength(1);
       expect(resumeCalls[0][0]).toMatchObject({
@@ -286,7 +287,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       });
 
       const appendCalls = logStore.append.mock.calls.filter(
-        ([entry]: [{ type: string }]) => entry.type === "thread_command_event",
+        (args: any[]) => (args[0] as { type: string }).type === "thread_command_event",
       );
       expect(appendCalls).toHaveLength(1);
       expect(appendCalls[0][0]).toMatchObject({
@@ -313,7 +314,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       mgr.startWorkflow("my-wf", payload);
 
       const startedCall = logStore.upsertWorkflowRun.mock.calls.find(
-        ([entry]: [{ type: string }]) => entry.type === "started",
+        (args: any[]) => (args[0] as { type: string }).type === "started",
       );
       expect(startedCall).toBeDefined();
       const logEntry = startedCall?.[0] as { payload: string | null };

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

@@ -79,6 +79,7 @@ function makeLogStore() {
     getThreadEvents: vi.fn(() => []),
     archiveLogs: vi.fn(() => ({ days: [], vacuumed: false })),
     close: vi.fn(),
+    getAllWorkflowRuns: vi.fn(() => []),
   };
 }
 
@@ -126,7 +127,7 @@ describe("WorkflowManager — drainAndRespawn (Phase 3 hot reload)", () => {
     await drainPromise;
 
     const interruptedCalls = logStore.upsertWorkflowRun.mock.calls.filter(
-      ([entry]: [{ type: string }]) => entry.type === "interrupted",
+      (args: any[]) => (args[0] as { type: string }).type === "interrupted",
     );
     expect(interruptedCalls).toHaveLength(2);
 
@@ -190,10 +191,10 @@ describe("WorkflowManager — drainAndRespawn (Phase 3 hot reload)", () => {
 
     const newChild = mockChildren[1];
     const resumeCalls = (newChild.send as ReturnType<typeof vi.fn>).mock.calls.filter(
-      ([msg]: [unknown]) =>
-        msg !== null &&
-        typeof msg === "object" &&
-        (msg as Record<string, unknown>).type === "resume-thread",
+      (args: any[]) =>
+        args[0] !== null &&
+        typeof args[0] === "object" &&
+        (args[0] as Record<string, unknown>).type === "resume-thread",
     );
     expect(resumeCalls).toHaveLength(0);
 
@@ -218,10 +219,10 @@ describe("WorkflowManager — drainAndRespawn (Phase 3 hot reload)", () => {
 
     const newChild = mockChildren[1];
     const startCalls = (newChild.send as ReturnType<typeof vi.fn>).mock.calls.filter(
-      ([msg]: [unknown]) =>
-        msg !== null &&
-        typeof msg === "object" &&
-        (msg as Record<string, unknown>).type === "start-thread",
+      (args: any[]) =>
+        args[0] !== null &&
+        typeof args[0] === "object" &&
+        (args[0] as Record<string, unknown>).type === "start-thread",
     );
     expect(startCalls).toHaveLength(1);
 
@@ -266,7 +267,7 @@ describe("Kernel — workflow hot reload via file-watcher (Phase 3)", () => {
     // Kernel's handleWorkflowFileChange should log a workflow_reload event
     // We test this via the kernel itself
     const appendCalls = logStore.append.mock.calls;
-    const startCall = appendCalls.find(([e]: [{ type: string }]) => e.type === "start");
+    const startCall = appendCalls.find((args: any[]) => (args[0] as { type: string }).type === "start");
     expect(startCall).toBeDefined();
 
     const stopPromise = kernel.stop();

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

@@ -78,6 +78,7 @@ function makeLogStore() {
     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 })),
@@ -137,10 +138,10 @@ describe("kernel + workflowManager integration", () => {
       // We need to check that a start-thread message was sent to the workflow worker
       const workflowWorker = mockChildren.find((c) =>
         (c.send as ReturnType<typeof vi.fn>).mock.calls.some(
-          ([msg]: [unknown]) =>
-            msg !== null &&
-            typeof msg === "object" &&
-            (msg as Record<string, unknown>).type === "start-thread",
+          (args: unknown[]) =>
+            args[0] !== null &&
+            typeof args[0] === "object" &&
+            (args[0] as Record<string, unknown>).type === "start-thread",
         ),
       );
       expect(workflowWorker).toBeDefined();
@@ -212,10 +213,10 @@ describe("kernel + workflowManager integration", () => {
       // No workflow worker should have been spawned (only the sense group worker)
       const workflowWorkerSpawned = mockChildren.some((c) =>
         (c.send as ReturnType<typeof vi.fn>).mock.calls.some(
-          ([msg]: [unknown]) =>
-            msg !== null &&
-            typeof msg === "object" &&
-            (msg as Record<string, unknown>).type === "start-thread",
+          (args: unknown[]) =>
+            args[0] !== null &&
+            typeof args[0] === "object" &&
+            (args[0] as Record<string, unknown>).type === "start-thread",
         ),
       );
       expect(workflowWorkerSpawned).toBe(false);

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

@@ -10,7 +10,7 @@ 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";
+import type { ComputeFn, DrizzleDB, PeerMap, SenseRuntime } from "../sense-runtime.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -168,7 +168,7 @@ describe("openPeerDb", () => {
 // ---------------------------------------------------------------------------
 
 describe("executeCompute", () => {
-  function makeRuntime(computeFn: (db: DrizzleDB, peers: PeerMap) => Promise<unknown | null>): {
+  function makeRuntime(computeFn: ComputeFn): {
     runtime: SenseRuntime;
     sqlite: Database.Database;
   } {

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

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

packages/daemon/src/kernel.ts

@@ -33,6 +33,11 @@ import { createReflexScheduler } from "./reflex-scheduler.js";
 import type { ReflexScheduler } from "./reflex-scheduler.js";
 import { createSignalBus } from "./signal-bus.js";
 import type { SignalBus } from "./signal-bus.js";
+import {
+  formatCapturedStderrTail,
+  formatChildExitSummary,
+  teeCapturedStderr,
+} from "./worker-fork-support.js";
 import { createWorkflowManager } from "./workflow-manager.js";
 import type { WorkflowManager } from "./workflow-manager.js";
 
@@ -84,10 +89,16 @@ function resolveWorkerScript(): string {
   return join(__dir, "sense-worker.js");
 }
 
-function spawnWorker(nerveRoot: string, group: string, workerScript: string): ChildProcess {
+function spawnWorker(
+  nerveRoot: string,
+  group: string,
+  workerScript: string,
+  stderrTail: { value: string },
+): ChildProcess {
   const child = fork(workerScript, ["--group", group, "--root", nerveRoot], {
-    stdio: ["ignore", "inherit", "inherit", "ipc"],
+    stdio: ["ignore", "inherit", "pipe", "ipc"],
   });
+  teeCapturedStderr(child, stderrTail);
   // Prevent unhandled EPIPE when writing to a child whose IPC channel closed
   child.on("error", (err) => {
     if ((err as NodeJS.ErrnoException).code !== "EPIPE") {
@@ -240,7 +251,8 @@ export function createKernel(
   }
 
   function startWorker(group: string): Promise<void> {
-    const child = spawnWorker(nerveRoot, group, workerScript);
+    const stderrTail = { value: "" };
+    const child = spawnWorker(nerveRoot, group, workerScript, stderrTail);
 
     let workerReadyResolve: (() => void) | undefined;
     const workerReady = new Promise<void>((resolve) => {
@@ -255,9 +267,10 @@ export function createKernel(
       handleWorkerMessage(raw);
     });
 
-    child.on("exit", (code) => {
+    child.on("exit", (code, signal) => {
+      const summary = formatChildExitSummary(code, signal ?? null);
       process.stderr.write(
-        `[kernel] worker for group "${group}" exited with code ${code ?? "null"}\n`,
+        `[kernel] worker for group "${group}" exited (${summary})${formatCapturedStderrTail(stderrTail.value)}\n`,
       );
       // Resolve ready in case the worker exits before sending ready (prevents hangs)
       workerReadyResolve?.();

packages/daemon/src/sense-runtime.ts

@@ -173,6 +173,7 @@ export async function loadComputeFn(senseIndexPath: string): Promise<Result<Comp
   let mod: unknown;
 
   try {
+    // Dynamic import required: user-authored sense module, path resolved at runtime
     mod = await import(senseIndexPath);
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);

packages/daemon/src/sense-worker.ts

@@ -25,6 +25,7 @@ import type { WorkerToParentMessage } from "./ipc.js";
 import { parseParentMessage } from "./ipc.js";
 import { executeCompute, loadComputeFn, openPeerDb, openSenseDb } from "./sense-runtime.js";
 import type { DrizzleDB, PeerMap, SenseRuntime } from "./sense-runtime.js";
+import { ignoreSessionBroadcastSignals } from "./worker-fork-support.js";
 
 // ---------------------------------------------------------------------------
 // IPC helpers
@@ -336,6 +337,10 @@ if (!parsed) {
   process.exit(1);
 }
 
+if (typeof process.send === "function") {
+  ignoreSessionBroadcastSignals();
+}
+
 bootstrap(parsed.nerveRoot, parsed.group).catch((e) => {
   const msg = e instanceof Error ? e.message : String(e);
   process.stderr.write(`[sense-worker] Unhandled bootstrap error: ${msg}\n`);

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

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

packages/daemon/src/workflow-manager.ts

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

packages/daemon/src/workflow-worker.ts

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

pnpm-lock.yaml

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