fix(daemon): foreground worker signals and crash diagnostics

Ignore SIGINT/SIGTERM only when fork IPC is active (process.send) so terminal signals do not race the kernel shutdown in nerve dev, without breaking standalone worker CLIs (fixes #55).

Pipe worker stderr through the parent with a rolling capture buffer; log exit signal name and stderr tail on worker exit (fixes #56). Apply the same exit logging to workflow workers.

Made-with: Cursor

docs/skill-publish.md

@@ -56,9 +56,10 @@ pnpm -r run build
 
 ```bash
 # Only publish packages that have version bumps
-cd packages/core && npm publish --access public
-cd packages/daemon && npm publish --access public
-cd packages/cli && npm publish --access public
+# MUST use pnpm publish (not npm) — pnpm converts workspace:* to real versions
+cd packages/core && pnpm publish --access public --no-git-checks
+cd packages/daemon && pnpm publish --access public --no-git-checks
+cd packages/cli && pnpm publish --access public --no-git-checks
 ```
 
 ### 5. Commit & tag

packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uncaged/nerve-cli",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "type": "module",
   "bin": {
     "nerve": "dist/cli.js"
@@ -14,6 +14,7 @@
     "access": "public"
   },
   "scripts": {
+    "prepublishOnly": "bash ../../scripts/prepublish-check.sh",
     "build": "tsup",
     "test": "vitest run"
   },

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

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

packages/cli/src/cli.ts

@@ -1,9 +1,11 @@
 import { defineCommand, runMain } from "citty";
 
+import { daemonCommand } from "./commands/daemon.js";
+import { devCommand } from "./commands/dev.js";
 import { initCommand } from "./commands/init.js";
 import { logsCommand } from "./commands/logs.js";
 import { senseCommand } from "./commands/sense.js";
-import { startCommand } from "./commands/start.js";
+import { daemonStartCommand } from "./commands/start.js";
 import { statusCommand } from "./commands/status.js";
 import { stopCommand } from "./commands/stop.js";
 import { storeCommand } from "./commands/store.js";
@@ -17,7 +19,9 @@ const main = defineCommand({
   },
   subCommands: {
     init: initCommand,
-    start: startCommand,
+    daemon: daemonCommand,
+    dev: devCommand,
+    start: daemonStartCommand,
     stop: stopCommand,
     status: statusCommand,
     logs: logsCommand,

packages/cli/src/commands/daemon.ts

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

packages/cli/src/commands/dev.ts

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

packages/cli/src/commands/start.ts

@@ -5,8 +5,6 @@ import { fileURLToPath } from "node:url";
 
 import { defineCommand } from "citty";
 
-import { runForegroundKernelSession } from "../run-foreground-kernel.js";
-import { loadDaemonModule } from "../workspace-daemon.js";
 import {
   getLogPath,
   getNerveRoot,
@@ -52,15 +50,10 @@ function daemonBootstrapScript(): string {
     return bootstrapJs;
   }
   throw new Error(
-    `daemon-bootstrap.js not found next to CLI at ${bootstrapJs}. Build the CLI package (e.g. \`pnpm --filter @uncaged/nerve-cli build\`) before using background mode (\`nerve start -d\`).`,
+    `daemon-bootstrap.js not found next to CLI at ${bootstrapJs}. Build the CLI package (e.g. \`pnpm --filter @uncaged/nerve-cli build\`) before using \`nerve daemon start\`.`,
   );
 }
 
-async function runForeground(nerveRoot: string): Promise<void> {
-  const { createKernel } = await loadDaemonModule(nerveRoot);
-  await runForegroundKernelSession(nerveRoot, createKernel);
-}
-
 async function runDaemon(nerveRoot: string): Promise<void> {
   if (isRunning()) {
     const pid = readPidFile();
@@ -110,29 +103,20 @@ async function runDaemon(nerveRoot: string): Promise<void> {
 
   process.stdout.write(`✅ Nerve daemon started (pid ${pid}).\n`);
   process.stdout.write(`   Logs: ${logPath}\n`);
-  process.stdout.write("   Run `nerve stop` to stop.\n");
+  process.stdout.write("   Run `nerve daemon stop` (or `nerve stop`) to stop.\n");
 }
 
-export const startCommand = defineCommand({
+/** Background daemon only — use `nerve dev` for foreground mode. */
+export async function runDaemonStartCommand(): Promise<void> {
+  await runDaemon(getNerveRoot());
+}
+
+export const daemonStartCommand = defineCommand({
   meta: {
     name: "start",
-    description: "Start the nerve daemon",
+    description: "Start the nerve daemon in the background",
   },
-  args: {
-    daemon: {
-      type: "boolean",
-      alias: "d",
-      description: "Run as background daemon",
-      default: false,
-    },
-  },
-  async run({ args }) {
-    const nerveRoot = getNerveRoot();
-
-    if (args.daemon) {
-      await runDaemon(nerveRoot);
-    } else {
-      await runForeground(nerveRoot);
-    }
+  async run() {
+    await runDaemonStartCommand();
   },
 });

packages/cli/src/commands/stop.ts

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

packages/cli/src/daemon-bootstrap.ts

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

packages/core/package.json

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

packages/daemon/package.json

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

packages/daemon/src/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-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
@@ -334,6 +335,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`);

scripts/prepublish-check.sh

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