fix: resolve 2 failing tests after WorkerRuntime migration

- Add trySendSync() for synchronous send when worker is ready+connected
- sendCompute uses sync path first, async fallback for cold start
- Add forwardStderr, allowRespawn, hasDisconnectedChild, onReady(key,msg)
- Tests: add connected:true to mocks, flush async fork microtasks
- All 167 daemon tests pass

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

@@ -70,6 +70,14 @@ const { createKernel } = await import("../kernel.js");
 // Helpers
 // ---------------------------------------------------------------------------
 
+/** Sense worker `fork` runs on the next microtask per scheduled `start`. */
+async function flushSenseWorkerForkMicrotasks(kernel: { groups: Set<string> }): Promise<void> {
+  const n = kernel.groups.size;
+  for (let i = 0; i < n; i++) {
+    await Promise.resolve();
+  }
+}
+
 function makeConfig(overrides: Partial<NerveConfig> = {}): NerveConfig {
   return {
     senses: {
@@ -142,6 +150,8 @@ describe("kernel — getHealth", () => {
       },
     });
     const kernel = createKernel(config, nerveRoot);
+    await flushSenseWorkerForkMicrotasks(kernel);
+    await vi.runAllTimersAsync();
 
     const health = kernel.getHealth();
     expect(health.activeSenses).toBe(3);
@@ -171,6 +181,8 @@ describe("kernel — restartGroup", () => {
   it("sends shutdown to old worker and spawns new one", async () => {
     const config = makeConfig();
     const kernel = createKernel(config, nerveRoot);
+    await flushSenseWorkerForkMicrotasks(kernel);
+    await vi.runAllTimersAsync();
 
     expect(mockChildren.length).toBe(1);
     const oldChild = mockChildren[0];
@@ -178,6 +190,7 @@ describe("kernel — restartGroup", () => {
     const restartPromise = kernel.restartGroup("system");
     // The shutdown message triggers exit in the mock
     await restartPromise;
+    await vi.runAllTimersAsync();
 
     // A new child should have been spawned
     expect(mockChildren.length).toBe(2);
@@ -191,6 +204,8 @@ describe("kernel — restartGroup", () => {
   it("restartGroup on unknown group does nothing", async () => {
     const config = makeConfig();
     const kernel = createKernel(config, nerveRoot);
+    await flushSenseWorkerForkMicrotasks(kernel);
+    await vi.runAllTimersAsync();
 
     expect(mockChildren.length).toBe(1);
     await kernel.restartGroup("nonexistent");
@@ -218,6 +233,8 @@ describe("kernel — reloadConfig", () => {
   it("adds new group worker when new sense group appears", async () => {
     const config = makeConfig();
     const kernel = createKernel(config, nerveRoot);
+    await flushSenseWorkerForkMicrotasks(kernel);
+    await vi.runAllTimersAsync();
 
     expect(mockChildren.length).toBe(1); // only system group
     expect(kernel.groups.has("network")).toBe(false);
@@ -249,6 +266,9 @@ describe("kernel — reloadConfig", () => {
       api: { port: null, token: null, host: "127.0.0.1" },
     });
 
+    await Promise.resolve();
+    await vi.runAllTimersAsync();
+
     expect(kernel.groups.has("network")).toBe(true);
     expect(mockChildren.length).toBe(2); // system + network
 
@@ -283,6 +303,8 @@ describe("kernel — reloadConfig", () => {
       api: { port: null, token: null, host: "127.0.0.1" },
     };
     const kernel = createKernel(config, nerveRoot);
+    await flushSenseWorkerForkMicrotasks(kernel);
+    await vi.runAllTimersAsync();
 
     expect(mockChildren.length).toBe(2);
     expect(kernel.groups.has("network")).toBe(true);
@@ -308,6 +330,7 @@ describe("kernel — reloadConfig", () => {
     });
 
     expect(kernel.groups.has("network")).toBe(false);
+    await vi.runAllTimersAsync();
     // Network child should have received shutdown
     expect(networkChild.send).toHaveBeenCalledWith(expect.objectContaining({ type: "shutdown" }));
 
@@ -317,6 +340,8 @@ describe("kernel — reloadConfig", () => {
   it("health reflects updated sense count after reloadConfig", async () => {
     const config = makeConfig();
     const kernel = createKernel(config, nerveRoot);
+    await flushSenseWorkerForkMicrotasks(kernel);
+    await vi.runAllTimersAsync();
 
     expect(kernel.getHealth().activeSenses).toBe(1);
 

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

@@ -29,6 +29,9 @@ type MockChild = EventEmitter & {
 function makeMockChild(pid = 1): MockChild {
   const child = new EventEmitter() as MockChild;
   child.connected = true;
+  setImmediate(() => {
+    child.emit("message", { type: "ready" });
+  });
   child.send = vi.fn((msg: unknown) => {
     if (
       msg !== null &&
@@ -136,6 +139,7 @@ describe("kernel.triggerSense()", () => {
       logStore: makeMockLogStore() as never,
     });
 
+    await vi.runAllTimersAsync();
     expect(() => kernel.triggerSense("no-such-sense")).toThrow(/Unknown sense/);
 
     await kernel.stop();
@@ -169,6 +173,7 @@ describe("kernel.triggerSense()", () => {
       logStore: makeMockLogStore() as never,
     });
 
+    await vi.runAllTimersAsync();
     // Two groups → two workers
     expect(mockChildren.length).toBe(2);
 
@@ -214,6 +219,7 @@ describe("kernel.triggerSense()", () => {
       logStore: makeMockLogStore() as never,
     });
 
+    await vi.runAllTimersAsync();
     // Both senses share the "system" group → one worker only
     expect(mockChildren.length).toBe(1);
     const worker = mockChildren[0];
@@ -237,6 +243,7 @@ describe("kernel.triggerSense()", () => {
       logStore: makeMockLogStore() as never,
     });
 
+    await new Promise<void>((resolve) => setImmediate(resolve));
     const worker = mockChildren[0];
     worker.connected = false;
 

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

@@ -102,6 +102,13 @@ function makeLogStore() {
   };
 }
 
+async function flushSenseWorkerForkMicrotasks(kernel: { groups: Set<string> }): Promise<void> {
+  const n = kernel.groups.size;
+  for (let i = 0; i < n; i++) {
+    await Promise.resolve();
+  }
+}
+
 function makeConfig(overrides: Partial<NerveConfig> = {}): NerveConfig {
   return {
     senses: {
@@ -164,6 +171,8 @@ describe("kernel + workflowManager integration", () => {
         workerScript: "fake-worker.js",
         logStore,
       });
+      await flushSenseWorkerForkMicrotasks(kernel);
+      await vi.runAllTimersAsync();
 
       // Simulate a sense worker sending a signal with workflow launch payload
       // The kernel's handleWorkerMessage processes "signal" type messages
@@ -222,6 +231,8 @@ describe("kernel + workflowManager integration", () => {
         workerScript: "fake-worker.js",
         logStore,
       });
+      await flushSenseWorkerForkMicrotasks(kernel);
+      await vi.runAllTimersAsync();
 
       // Simulate sense worker returning a signal plus workflow launch
       const workerPool = mockChildren[0];
@@ -275,6 +286,8 @@ describe("kernel + workflowManager integration", () => {
         workerScript: "fake-worker.js",
         logStore,
       });
+      await flushSenseWorkerForkMicrotasks(kernel);
+      await vi.runAllTimersAsync();
 
       const workerPool = mockChildren[0];
       if (workerPool) {
@@ -337,6 +350,8 @@ describe("kernel + workflowManager integration", () => {
         workerScript: "fake-worker.js",
         logStore,
       });
+      await flushSenseWorkerForkMicrotasks(kernel);
+      await vi.runAllTimersAsync();
 
       // Emit a regular signal (shorthand payload) — should NOT trigger any workflow
       const workerPool = mockChildren[0];
@@ -387,6 +402,8 @@ describe("kernel + workflowManager integration", () => {
         workerScript: "fake-worker.js",
         logStore,
       });
+      await flushSenseWorkerForkMicrotasks(kernel);
+      await vi.runAllTimersAsync();
 
       // Simulate sense compute returning a signal plus workflow launch
       const workerPool = mockChildren[0];
@@ -440,6 +457,8 @@ describe("kernel + workflowManager integration", () => {
         workerScript: "fake-worker.js",
         logStore,
       });
+      await flushSenseWorkerForkMicrotasks(kernel);
+      await vi.runAllTimersAsync();
 
       // Reload with a workflow added
       const newConfig: NerveConfig = {
@@ -517,6 +536,8 @@ describe("kernel + workflowManager integration", () => {
         workerScript: "fake-worker.js",
         logStore,
       });
+      await flushSenseWorkerForkMicrotasks(kernel);
+      await vi.runAllTimersAsync();
 
       // Reload with the workflow removed
       const newConfig: NerveConfig = {
@@ -600,6 +621,8 @@ describe("kernel + workflowManager integration", () => {
         workerScript: "fake-worker.js",
         logStore,
       });
+      await flushSenseWorkerForkMicrotasks(kernel);
+      await vi.runAllTimersAsync();
 
       // Trigger a workflow via sense compute return value
       const workerPool = mockChildren[0];
@@ -664,6 +687,8 @@ describe("kernel + workflowManager integration", () => {
         workerScript: "fake-worker.js",
         logStore,
       });
+      await flushSenseWorkerForkMicrotasks(kernel);
+      await vi.runAllTimersAsync();
 
       const health = kernel.getHealth();
       expect(health).toHaveProperty("activeWorkflows");

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

@@ -16,10 +16,12 @@ type MockChild = EventEmitter & {
   send: ReturnType<typeof vi.fn>;
   kill: ReturnType<typeof vi.fn>;
   pid: number;
+  connected: boolean;
 };
 
 function makeMockChild(pid = 1): MockChild {
   const child = new EventEmitter() as MockChild;
+  child.connected = true;
   setImmediate(() => {
     child.emit("message", { type: "ready" });
   });
@@ -27,7 +29,10 @@ function makeMockChild(pid = 1): MockChild {
     if (msg === null || typeof msg !== "object") return;
     const m = msg as Record<string, unknown>;
     if (m.type === "shutdown") {
-      setImmediate(() => child.emit("exit", 0, null));
+      setImmediate(() => {
+        child.connected = false;
+        child.emit("exit", 0, null);
+      });
       return;
     }
     if (m.type === "compute" && typeof m.sense === "string") {
@@ -37,6 +42,7 @@ function makeMockChild(pid = 1): MockChild {
     }
   });
   child.kill = vi.fn((_signal?: string) => {
+    child.connected = false;
     child.emit("exit", null, _signal ?? "SIGKILL");
   });
   child.pid = pid;
@@ -59,6 +65,14 @@ const { createLogStore } = await import("@uncaged/nerve-store");
 // Helpers
 // ---------------------------------------------------------------------------
 
+/** `WorkerRuntime.start` schedules `fork` on the next microtask — flush one tick per initial group. */
+async function flushSenseWorkerForkMicrotasks(kernel: { groups: Set<string> }): Promise<void> {
+  const n = kernel.groups.size;
+  for (let i = 0; i < n; i++) {
+    await Promise.resolve();
+  }
+}
+
 function makeConfig(overrides: Partial<NerveConfig> = {}): NerveConfig {
   return {
     senses: {
@@ -173,6 +187,7 @@ describe("kernel — message routing", () => {
       },
     });
     const kernel = createKernel(config, nerveRoot);
+    await flushSenseWorkerForkMicrotasks(kernel);
 
     const child = mockChildren[0];
     child.emit("message", { type: "error", sense: "cpu-usage", error: "compute failed" });
@@ -201,6 +216,7 @@ describe("kernel — message routing", () => {
       },
     });
     const kernel = createKernel(config, nerveRoot);
+    await flushSenseWorkerForkMicrotasks(kernel);
 
     const child = mockChildren[0];
     const callsBefore = stderrSpy.mock.calls.length;
@@ -228,6 +244,7 @@ describe("kernel — message routing", () => {
       },
     });
     const kernel = createKernel(config, nerveRoot);
+    await flushSenseWorkerForkMicrotasks(kernel);
 
     const child = mockChildren[0];
     expect(() => child.emit("message", { type: "unknown-type" })).not.toThrow();
@@ -290,6 +307,7 @@ describe("kernel — groupForSense mapping", () => {
       api: { port: null, token: null, host: "127.0.0.1" },
     };
     const kernel = createKernel(config, nerveRoot);
+    await flushSenseWorkerForkMicrotasks(kernel);
 
     // system and network = 2 unique groups
     expect(mockChildren.length).toBe(2);
@@ -311,8 +329,10 @@ describe("kernel — groupForSense mapping", () => {
       },
     });
     const kernel = createKernel(config, nerveRoot);
-
+    await flushSenseWorkerForkMicrotasks(kernel);
     const child = mockChildren[0];
+    child.emit("message", { type: "ready" });
+
     vi.advanceTimersByTime(500);
 
     expect(child.send).toHaveBeenCalledWith(

packages/daemon/src/__tests__/worker-pool.test.ts

@@ -50,6 +50,7 @@ async function startWorkerWithReady(
   group: string,
 ): Promise<void> {
   const pr = pool.startWorker(group);
+  await Promise.resolve();
   const child = mockChildren[mockChildren.length - 1];
   child.emit("message", { type: "ready" });
   await pr;
@@ -137,6 +138,7 @@ describe("createSenseWorkerPool", () => {
     expect(pool.activeGroupCount()).toBe(1);
     pool.evictGroup("x");
     expect(pool.hasWorkerForGroup("x")).toBe(false);
+    await Promise.resolve();
     expect(mockChildren[0].send).toHaveBeenCalledWith(
       expect.objectContaining({ type: "shutdown" }),
     );
@@ -159,6 +161,7 @@ describe("createSenseWorkerPool", () => {
 
     const p = pool.restartGroup("g");
     expect(onBeforeGroupRestart).toHaveBeenCalledWith("g");
+    await Promise.resolve();
     expect(mockChildren[0].send).toHaveBeenCalledWith(
       expect.objectContaining({ type: "shutdown" }),
     );
@@ -171,7 +174,7 @@ describe("createSenseWorkerPool", () => {
   });
 
   it("onWorkerCrashed runs and schedules respawn after non-zero exit", async () => {
-    vi.useFakeTimers({ shouldAdvanceTime: true });
+    vi.useFakeTimers();
     const onWorkerCrashed = vi.fn();
     const pool = createSenseWorkerPool({
       nerveRoot: "/tmp/n",

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

@@ -12,6 +12,7 @@ function baseConfig(script: string) {
   return {
     script,
     argsForKey: () => [],
+    forwardStderr: true,
     onMessage: vi.fn(),
     onReady: vi.fn(),
     onExit: vi.fn(),
@@ -20,6 +21,7 @@ function baseConfig(script: string) {
       maxCrashes: 6,
       windowMs: 60_000,
       delayMs: 80,
+      allowRespawn: null,
     },
     shutdownTimeoutMs: 5000,
   };
@@ -135,6 +137,7 @@ describe("createWorkerRuntime", () => {
           maxCrashes: 2,
           windowMs: 60_000,
           delayMs: 50,
+          allowRespawn: null,
         },
       }),
     );

packages/daemon/src/worker-pool.ts

@@ -1,19 +1,13 @@
 /**
- * Sense worker pool — forked child processes per sense group (IPC lifecycle).
+ * Sense worker pool — thin wrapper around WorkerRuntime (RFC-006): one fork per sense group.
  */
 
-import { fork } from "node:child_process";
-import type { ChildProcess } from "node:child_process";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
-import type { ComputeMessage, ShutdownMessage } from "./ipc.js";
-import { parseWorkerMessage } from "./ipc.js";
-import {
-  formatCapturedStderrTail,
-  formatChildExitSummary,
-  teeCapturedStderr,
-} from "./worker-fork-support.js";
+import type { ComputeMessage } from "./ipc.js";
+import { formatCapturedStderrTail, formatChildExitSummary } from "./worker-fork-support.js";
+import { createWorkerRuntime } from "./worker-runtime.js";
 
 export function resolveWorkerScript(): string {
   const __filename = fileURLToPath(import.meta.url);
@@ -21,17 +15,12 @@ export function resolveWorkerScript(): string {
   return join(__dir, "sense-worker.js");
 }
 
-type WorkerEntry = {
-  group: string;
-  process: ChildProcess;
-};
-
 export type SenseWorkerPoolOptions = {
   nerveRoot: string;
   workerScript: string;
   /** Invoked for every IPC message from a worker (including ready / signal / error). */
   onWorkerMessage: (raw: unknown) => void;
-  /** Sense names in a group — used when clearing scheduler state on crash or restart. */
+  /** Sense names in a group — reserved for scheduler-aligned cleanup (kernel passes current config). */
   sensesForGroup: (group: string) => string[];
   /**
    * Called when a worker exits with non-zero code before scheduling a respawn
@@ -58,144 +47,106 @@ export type SenseWorkerPool = {
   activeGroupCount: () => number;
 };
 
-function spawnWorker(
-  nerveRoot: string,
-  group: string,
-  workerScript: string,
-  stderrTail: { value: string },
-): ChildProcess {
-  const child = fork(workerScript, ["--group", group, "--root", nerveRoot], {
-    stdio: ["ignore", "inherit", "pipe", "ipc"],
-  });
-  teeCapturedStderr(child, stderrTail);
-  child.on("error", (err) => {
-    if ((err as NodeJS.ErrnoException).code !== "EPIPE") {
-      console.error("[worker] error:", err.message);
-    }
-  });
-  return child;
-}
-
-function sendComputeToProcess(worker: ChildProcess, senseName: string): void {
-  if (worker.connected === false) return;
-  const msg: ComputeMessage = { type: "compute", sense: senseName };
-  try {
-    worker.send(msg);
-  } catch {
-    // IPC channel closed between connected check and send
-  }
-}
-
-function sendShutdownToProcess(worker: ChildProcess): void {
-  if (worker.connected === false) return;
-  const msg: ShutdownMessage = { type: "shutdown" };
-  try {
-    worker.send(msg);
-  } catch {
-    // IPC channel closed between connected check and send
-  }
-}
-
-function waitForExit(child: ChildProcess, timeoutMs: number): Promise<void> {
-  return new Promise((resolve) => {
-    const timer = setTimeout(() => {
-      child.kill("SIGKILL");
-      resolve();
-    }, timeoutMs);
-    child.once("exit", () => {
-      clearTimeout(timer);
-      resolve();
-    });
-  });
-}
+/** Matches legacy pool: long crash window, 1s respawn delay, practical unlimited respawns. */
+const SENSE_WORKER_RESPAWN = {
+  enabled: true,
+  maxCrashes: 100_000,
+  windowMs: 86_400_000,
+  delayMs: 1000,
+} as const;
 
 export function createSenseWorkerPool(options: SenseWorkerPoolOptions): SenseWorkerPool {
-  const workers = new Map<string, WorkerEntry>();
-
-  function startWorker(group: string): Promise<void> {
-    const stderrTail = { value: "" };
-    const child = spawnWorker(options.nerveRoot, group, options.workerScript, stderrTail);
-
-    let workerReadyResolve: (() => void) | undefined;
-    const workerReady = new Promise<void>((resolve) => {
-      workerReadyResolve = resolve;
-    });
-
-    child.on("message", (raw: unknown) => {
-      const result = parseWorkerMessage(raw);
-      if (result.ok && result.value.type === "ready") {
-        workerReadyResolve?.();
-      }
+  const runtime = createWorkerRuntime<string>({
+    script: options.workerScript,
+    argsForKey: (group) => ["--group", group, "--root", options.nerveRoot],
+    forwardStderr: true,
+    onMessage: (_key, raw) => {
       options.onWorkerMessage(raw);
-    });
-
-    child.on("exit", (code, signal) => {
-      const summary = formatChildExitSummary(code, signal ?? null);
+    },
+    onReady: (_key, msg) => {
+      options.onWorkerMessage(msg);
+    },
+    onExit: (group, code, signal) => {
+      const sig =
+        signal === null || signal === undefined || signal === ""
+          ? null
+          : (signal as NodeJS.Signals);
+      const summary = formatChildExitSummary(code, sig);
       process.stderr.write(
-        `[kernel] worker for group "${group}" exited (${summary})${formatCapturedStderrTail(stderrTail.value)}\n`,
+        `[kernel] worker for group "${group}" exited (${summary})${formatCapturedStderrTail(runtime.stderrTail(group))}\n`,
       );
-      workerReadyResolve?.();
       if (!options.isStopped() && code !== 0) {
         process.stderr.write(`[kernel] respawning worker for group "${group}" in 1s\n`);
         options.onWorkerCrashed(group);
-        setTimeout(() => {
-          if (!options.isStopped()) {
-            startWorker(group);
-          }
-        }, 1000);
       }
-    });
+    },
+    respawn: {
+      ...SENSE_WORKER_RESPAWN,
+      allowRespawn: (_group) => !options.isStopped(),
+    },
+    shutdownTimeoutMs: 5000,
+  });
 
-    workers.set(group, { group, process: child });
-    return workerReady;
+  /** Groups we have ever started — mirrors legacy Map presence for `restartGroup` no-op when unknown. */
+  const trackedGroups = new Set<string>();
+  /** Marks groups mid-evict so `hasWorkerForGroup` drops immediately (legacy synchronous eviction). */
+  const evicting = new Set<string>();
+
+  async function startWorker(group: string): Promise<void> {
+    trackedGroups.add(group);
+    await runtime.start(group);
   }
 
   async function restartGroup(group: string): Promise<void> {
-    const entry = workers.get(group);
-    if (entry === undefined) return;
-
-    options.onBeforeGroupRestart(group);
-
-    sendShutdownToProcess(entry.process);
-    await waitForExit(entry.process, 5000);
-
-    if (!options.isStopped()) {
-      await startWorker(group);
+    if (!trackedGroups.has(group)) {
+      return;
     }
+    options.onBeforeGroupRestart(group);
+    await runtime.drain(group);
   }
 
   function evictGroup(group: string): void {
-    const entry = workers.get(group);
-    if (entry === undefined) return;
-    sendShutdownToProcess(entry.process);
-    workers.delete(group);
+    trackedGroups.delete(group);
+    evicting.add(group);
+    void runtime.evict(group).finally(() => {
+      evicting.delete(group);
+    });
   }
 
   async function shutdownAll(): Promise<void> {
-    const exitPromises: Promise<void>[] = [];
-    for (const entry of workers.values()) {
-      sendShutdownToProcess(entry.process);
-      exitPromises.push(waitForExit(entry.process, 5000));
-    }
-    await Promise.all(exitPromises);
+    await runtime.shutdown();
+    trackedGroups.clear();
+    evicting.clear();
   }
 
   function sendCompute(group: string, senseName: string): void {
-    const entry = workers.get(group);
-    if (entry === undefined) return;
-    sendComputeToProcess(entry.process, senseName);
+    if (!trackedGroups.has(group) || evicting.has(group)) {
+      return;
+    }
+    // Legacy pool: `child.send` no-op when IPC is closed (still allow cold start: child === null).
+    if (runtime.hasDisconnectedChild(group)) {
+      return;
+    }
+    const msg: ComputeMessage = { type: "compute", sense: senseName };
+    if (!runtime.trySendSync(group, msg)) {
+      void runtime.send(group, msg).catch(() => {
+        // IPC channel may close between scheduling and send — same as legacy try/catch on child.send
+      });
+    }
   }
 
   function getWorkerPid(group: string): number | null {
-    return workers.get(group)?.process.pid ?? null;
+    return runtime.pid(group);
   }
 
+  /** True once `startWorker` has been called for the group and it is not mid-evict (matches legacy Map key). */
   function hasWorkerForGroup(group: string): boolean {
-    return workers.has(group);
+    return trackedGroups.has(group) && !evicting.has(group);
   }
 
+  /** Count of sense groups with a worker slot (includes not-yet-ready), excluding evicted keys. */
   function activeGroupCount(): number {
-    return workers.size;
+    return trackedGroups.size;
   }
 
   return {

packages/daemon/src/worker-runtime.ts

@@ -11,25 +11,33 @@ const STDERR_TAIL_MAX_CHARS = 2048;
 export type WorkerRuntimeConfig<K extends string> = {
   script: string;
   argsForKey: (key: K) => string[];
+  /** When false, stderr is not captured into `stderrTail` (e.g. tests without a pipe). */
+  forwardStderr: boolean;
   onMessage: (key: K, msg: unknown) => void;
-  onReady: (key: K) => void;
+  onReady: (key: K, msg: unknown) => void;
   onExit: (key: K, code: number | null, signal: string | null) => void;
   respawn: {
     enabled: boolean;
     maxCrashes: number;
     windowMs: number;
     delayMs: number;
+    /** When non-null, return false to skip automatic respawn after an unexpected exit. */
+    allowRespawn: ((key: K) => boolean) | null;
   };
   shutdownTimeoutMs: number;
 };
 
 export type WorkerRuntime<K extends string> = {
   send: (key: K, msg: unknown) => Promise<void>;
+  /** When the worker is already ready and IPC-connected, sends synchronously (returns true). Otherwise false — caller may fall back to `send`. */
+  trySendSync: (key: K, msg: unknown) => boolean;
   start: (key: K) => Promise<void>;
   evict: (key: K) => Promise<void>;
   drain: (key: K) => Promise<void>;
   shutdown: () => Promise<void>;
   has: (key: K) => boolean;
+  /** True when a child exists but IPC is disconnected (legacy pool skipped sends in this case). */
+  hasDisconnectedChild: (key: K) => boolean;
   pid: (key: K) => number | null;
   keys: () => K[];
   stderrTail: (key: K) => string;
@@ -68,7 +76,7 @@ function signalToString(signal: NodeJS.Signals | null): string | null {
 
 function attachStderrTail<K extends string>(child: ChildProcess, slot: WorkerSlot<K>): void {
   const stream = child.stderr;
-  if (stream === null) {
+  if (stream == null) {
     return;
   }
   stream.setEncoding("utf8");
@@ -180,7 +188,7 @@ export function createWorkerRuntime<K extends string>(
       if (slot.state === "starting") {
         slot.state = "ready";
         slot.crashTimestamps = [];
-        config.onReady(slot.key);
+        config.onReady(slot.key, msg);
         resolveReadyWaiters(slot);
       }
       return;
@@ -222,7 +230,9 @@ export function createWorkerRuntime<K extends string>(
   function registerChild(slot: WorkerSlot<K>, child: ChildProcess): void {
     slot.child = child;
     slot.pid = child.pid ?? null;
-    attachStderrTail(child, slot);
+    if (config.forwardStderr) {
+      attachStderrTail(child, slot);
+    }
     child.on("message", (msg: unknown) => {
       handleWorkerMessage(slot, msg);
     });
@@ -270,6 +280,9 @@ export function createWorkerRuntime<K extends string>(
     if (!config.respawn.enabled) {
       return;
     }
+    if (config.respawn.allowRespawn !== null && !config.respawn.allowRespawn(slot.key)) {
+      return;
+    }
 
     const now = Date.now();
     slot.crashTimestamps.push(now);
@@ -308,6 +321,19 @@ export function createWorkerRuntime<K extends string>(
       });
     },
 
+    trySendSync: (key: K, msg: unknown): boolean => {
+      const slot = workers.get(key);
+      if (slot === undefined || !isActive(slot)) {
+        return false;
+      }
+      const child = slot.child;
+      if (child === null || !child.connected) {
+        return false;
+      }
+      child.send(msg as Serializable);
+      return true;
+    },
+
     start: async (key: K) => {
       const slot = getOrCreateSlot(key);
       await enqueueOp(slot, async () => {
@@ -345,6 +371,14 @@ export function createWorkerRuntime<K extends string>(
       return slot !== undefined && isActive(slot);
     },
 
+    hasDisconnectedChild: (key: K): boolean => {
+      const slot = workers.get(key);
+      if (slot === undefined || slot.child === null) {
+        return false;
+      }
+      return !slot.child.connected;
+    },
+
     pid: (key: K) => {
       const slot = workers.get(key);
       if (slot === undefined || !isActive(slot) || slot.pid === null) {