feat(core,daemon,cli): add dryRun thread-level parameter to StartSignal

- StartSignal.meta gains dryRun: boolean (alongside maxRounds)
- DaemonIpcTriggerWorkflowRequest includes dryRun, parsed with default false
- CLI parses dryRun from --payload JSON, passes through daemon client
- workflow-worker/workflow-manager propagate dryRun through full IPC chain
- Sense-triggered workflows default to dryRun: false
- workflow-utils exports isDryRun(start) helper
- All tests updated, 376 pass

Fixes #101

packages/cli/src/commands/workflow.ts

@@ -515,7 +515,7 @@ const workflowTriggerCommand = defineCommand({
     payload: {
       type: "string",
       description:
-        'JSON with optional "prompt" (string) and "maxRounds" (number) for the workflow run (default: {})',
+        'JSON with optional "prompt" (string), "maxRounds" (number), and "dryRun" (boolean) for the workflow run (default: {})',
       default: "{}",
     },
   },
@@ -530,10 +530,12 @@ const workflowTriggerCommand = defineCommand({
 
     let prompt = "";
     let maxRounds = DEFAULT_ENGINE_MAX_ROUNDS;
+    let dryRun = false;
     if (isPlainRecord(triggerPayload)) {
       const p = triggerPayload;
       if (typeof p.prompt === "string") prompt = p.prompt;
       if (typeof p.maxRounds === "number") maxRounds = p.maxRounds;
+      if (typeof p.dryRun === "boolean") dryRun = p.dryRun;
     }
 
     if (!isRunning()) {
@@ -544,7 +546,7 @@ const workflowTriggerCommand = defineCommand({
     const socketPath = getSocketPath();
     let response: DaemonIpcTriggerResponse;
     try {
-      response = await triggerWorkflowViaDaemon(socketPath, args.name, prompt, maxRounds);
+      response = await triggerWorkflowViaDaemon(socketPath, args.name, prompt, maxRounds, dryRun);
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
       process.stderr.write(`❌ Failed to contact daemon: ${msg}\n`);

packages/cli/src/daemon-client.ts

@@ -135,12 +135,14 @@ export function triggerWorkflowViaDaemon(
   workflow: string,
   prompt: string,
   maxRounds: number,
+  dryRun = false,
 ): Promise<DaemonIpcTriggerResponse> {
   const message: DaemonIpcRequest = {
     type: "trigger-workflow",
     workflow,
     prompt,
     maxRounds,
+    dryRun,
   };
   return sendAndReceive(socketPath, message, parseDaemonResponse);
 }

packages/core/src/__tests__/daemon-ipc-protocol.test.ts

@@ -18,6 +18,27 @@ describe("parseDaemonIpcRequest", () => {
       workflow: "wf",
       prompt: "go",
       maxRounds: 3,
+      dryRun: false,
+    });
+  });
+
+  it("parses trigger-workflow with dryRun true", () => {
+    expect(
+      parseDaemonIpcRequest(
+        JSON.stringify({
+          type: "trigger-workflow",
+          workflow: "wf",
+          prompt: "go",
+          maxRounds: 3,
+          dryRun: true,
+        }),
+      ),
+    ).toEqual({
+      type: "trigger-workflow",
+      workflow: "wf",
+      prompt: "go",
+      maxRounds: 3,
+      dryRun: true,
     });
   });
 

packages/core/src/daemon-ipc-protocol.ts

@@ -13,6 +13,7 @@ export type DaemonIpcTriggerWorkflowRequest = {
   workflow: string;
   prompt: string;
   maxRounds: number;
+  dryRun: boolean;
 };
 
 /** Client → daemon: run a sense compute on demand. */
@@ -51,6 +52,22 @@ export type DaemonIpcResponse =
   | DaemonIpcErrorResponse
   | { ok: true; senses: SenseInfo[] };
 
+function parseTriggerWorkflowFields(
+  req: Record<string, unknown>,
+): DaemonIpcTriggerWorkflowRequest | null {
+  if (typeof req.workflow !== "string" || req.workflow.length === 0) return null;
+  if (typeof req.prompt !== "string") return null;
+  if (typeof req.maxRounds !== "number") return null;
+  const dryRun = typeof req.dryRun === "boolean" ? req.dryRun : false;
+  return {
+    type: "trigger-workflow",
+    workflow: req.workflow,
+    prompt: req.prompt,
+    maxRounds: req.maxRounds,
+    dryRun,
+  };
+}
+
 /**
  * Parse a single line of JSON into a {@link DaemonIpcRequest}, or null if invalid.
  * Kept in core with the request types so CLI and daemon stay aligned at compile time.
@@ -61,15 +78,7 @@ export function parseDaemonIpcRequest(line: string): DaemonIpcRequest | null {
     if (!isPlainRecord(obj)) return null;
     const req = obj;
     if (req.type === "trigger-workflow") {
-      if (typeof req.workflow !== "string" || req.workflow.length === 0) return null;
-      if (typeof req.prompt !== "string") return null;
-      if (typeof req.maxRounds !== "number") return null;
-      return {
-        type: "trigger-workflow",
-        workflow: req.workflow,
-        prompt: req.prompt,
-        maxRounds: req.maxRounds,
-      };
+      return parseTriggerWorkflowFields(req);
     }
     if (req.type === "trigger-sense") {
       if (typeof req.sense !== "string" || req.sense.length === 0) return null;

packages/core/src/index.ts

@@ -14,6 +14,7 @@ export type {
   RoleMeta,
   StartSignal,
   RoleSignal,
+  ModeratorContext,
   Moderator,
   WorkflowDefinition,
   SenseResult,

packages/core/src/types.ts

@@ -76,20 +76,24 @@ export type WorkflowMessage = {
 export type RoleResult<Meta> = { content: string; meta: Meta };
 
 /**
- * A Role is a pure async function: receives the full message chain,
- * returns typed content + meta. Implementation can be an agent, LLM call,
+ * A Role is a pure async function: receives the engine start frame plus prior
+ * role messages only (the start frame is not included in `messages`).
+ * Returns typed content + meta. Implementation can be an agent, LLM call,
  * script, HTTP request, etc.
  */
-export type Role<Meta> = (messages: WorkflowMessage[]) => Promise<RoleResult<Meta>>;
+export type Role<Meta> = (
+  start: StartSignal,
+  messages: WorkflowMessage[],
+) => Promise<RoleResult<Meta>>;
 
 /** Maps role names to their meta types — the single generic that drives all inference. */
 export type RoleMeta = Record<string, Record<string, unknown>>;
 
-/** First message in the thread chain (`messages[0]`) — passed to the moderator on start. */
+/** Engine start frame: prompt, max rounds cap, dry-run flag, and timestamps for the thread. */
 export type StartSignal = {
   role: START;
   content: string;
-  meta: { maxRounds: number };
+  meta: { maxRounds: number; dryRun: boolean };
   timestamp: number;
 };
 
@@ -99,11 +103,19 @@ export type RoleSignal<M extends RoleMeta> = {
 }[keyof M & string];
 
 /**
- * The moderator — a pure routing function. Receives the last signal,
+ * Moderator input: either the initial start frame or a role signal after a step.
+ * Lets implementations branch on `context.kind` with full typing for each arm.
+ */
+export type ModeratorContext<M extends RoleMeta> =
+  | { kind: "start"; start: StartSignal }
+  | { kind: "step"; signal: RoleSignal<M> };
+
+/**
+ * The moderator — a pure routing function. Receives start vs step context,
  * current round, and maxRounds. Returns the next role name or END.
  */
 export type Moderator<M extends RoleMeta> = (
-  signal: StartSignal | RoleSignal<M>,
+  context: ModeratorContext<M>,
   round: number,
   maxRounds: number,
 ) => (keyof M & string) | END;

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

@@ -127,8 +127,8 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("my-wf", { prompt: "test 1", maxRounds: 10 });
-      mgr.startWorkflow("my-wf", { prompt: "test 2", maxRounds: 10 });
+      mgr.startWorkflow("my-wf", { prompt: "test 1", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("my-wf", { prompt: "test 2", maxRounds: 10, dryRun: false });
       expect(mgr.activeCount("my-wf")).toBe(2);
 
       // Simulate unexpected exit (not shutdown)
@@ -154,8 +154,8 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
-      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
+      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
       expect(mgr.activeCount("my-wf")).toBe(2);
 
       const child = mockChildren[0];
@@ -179,7 +179,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
+      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
       expect(mockChildren).toHaveLength(1);
 
       const child = mockChildren[0];
@@ -212,7 +212,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
+      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
       const firstChild = mockChildren[0];
       firstChild.exitCode = 1;
       firstChild.connected = false;
@@ -256,7 +256,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
       // Start one thread to fill the concurrency slot (so queued run stays queued on respawn)
-      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
+      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
       const firstChild = mockChildren[0];
       firstChild.exitCode = 1;
       firstChild.connected = false;
@@ -281,7 +281,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
+      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
 
       const child = mockChildren[0];
       const startCall = (child.send as ReturnType<typeof vi.fn>).mock.calls[0];
@@ -317,7 +317,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      const launch = { prompt: "build-docker for myrepo", maxRounds: 10 };
+      const launch = { prompt: "build-docker for myrepo", maxRounds: 10, dryRun: false };
       mgr.startWorkflow("my-wf", launch);
 
       const startedCall = logStore.upsertWorkflowRun.mock.calls.find(
@@ -327,7 +327,11 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       const logEntry = startedCall?.[0] as { payload: string | null };
       expect(logEntry.payload).not.toBeNull();
       const parsed = JSON.parse(logEntry.payload as string) as Record<string, unknown>;
-      expect(parsed).toMatchObject({ prompt: "build-docker for myrepo", maxRounds: 10 });
+      expect(parsed).toMatchObject({
+        prompt: "build-docker for myrepo",
+        maxRounds: 10,
+        dryRun: false,
+      });
 
       const stopPromise = mgr.stop();
       await vi.runAllTimersAsync();
@@ -349,7 +353,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
       // Start one thread to fill the concurrency slot
-      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
+      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
       const firstChild = mockChildren[0];
 
       // Crash once → respawn → crash again → second respawn
@@ -385,7 +389,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
+      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
       const firstChild = mockChildren[0];
       firstChild.exitCode = 1;
       firstChild.connected = false;
@@ -415,7 +419,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("crash-wf", { prompt: "test", maxRounds: 10 });
+      mgr.startWorkflow("crash-wf", { prompt: "test", maxRounds: 10, dryRun: false });
 
       // Crash the worker 6 times in rapid succession (within CRASH_WINDOW_MS = 60s)
       for (let i = 0; i < 6; i++) {

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

@@ -154,6 +154,7 @@ describe("daemon-ipc — trigger-sense", () => {
       workflow: "my-workflow",
       prompt: "test prompt",
       maxRounds: 10,
+      dryRun: false,
     });
 
     expect(resp).toEqual({ ok: true });
@@ -161,6 +162,7 @@ describe("daemon-ipc — trigger-sense", () => {
     expect(wfManager.startWorkflow).toHaveBeenCalledWith("my-workflow", {
       prompt: "test prompt",
       maxRounds: 10,
+      dryRun: false,
     });
   });
 

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

@@ -102,7 +102,7 @@ describe("WorkflowManager — drainAndRespawn (Phase 3 hot reload)", () => {
     const config = makeWfConfig({ "my-wf": { concurrency: 1, overflow: "drop" } });
     const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
+    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
     expect(mockChildren).toHaveLength(1);
 
     // Remove workflow from config before drain completes
@@ -121,8 +121,8 @@ describe("WorkflowManager — drainAndRespawn (Phase 3 hot reload)", () => {
     const config = makeWfConfig({ "my-wf": { concurrency: 2, overflow: "drop" } });
     const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
-    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
+    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
+    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
     expect(mgr.activeCount("my-wf")).toBe(2);
 
     const drainPromise = mgr.drainAndRespawn("my-wf", 5000);
@@ -153,7 +153,7 @@ describe("WorkflowManager — drainAndRespawn (Phase 3 hot reload)", () => {
     const config = makeWfConfig({ "my-wf": { concurrency: 1, overflow: "drop" } });
     const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
+    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
     expect(mockChildren).toHaveLength(1);
 
     const drainPromise = mgr.drainAndRespawn("my-wf", 5000);
@@ -169,7 +169,7 @@ describe("WorkflowManager — drainAndRespawn (Phase 3 hot reload)", () => {
     const config = makeWfConfig({ "my-wf": { concurrency: 1, overflow: "drop" } });
     const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
+    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
     expect(mockChildren).toHaveLength(1);
 
     const drainPromise = mgr.drainAndRespawn("my-wf", 5000);
@@ -186,7 +186,7 @@ describe("WorkflowManager — drainAndRespawn (Phase 3 hot reload)", () => {
     const config = makeWfConfig({ "my-wf": { concurrency: 1, overflow: "drop" } });
     const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
+    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
 
     const drainPromise = mgr.drainAndRespawn("my-wf", 5000);
     await vi.runAllTimersAsync();
@@ -211,14 +211,14 @@ describe("WorkflowManager — drainAndRespawn (Phase 3 hot reload)", () => {
     const config = makeWfConfig({ "my-wf": { concurrency: 1, overflow: "drop" } });
     const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-    mgr.startWorkflow("my-wf", { prompt: "first", maxRounds: 10 });
+    mgr.startWorkflow("my-wf", { prompt: "first", maxRounds: 10, dryRun: false });
 
     const drainPromise = mgr.drainAndRespawn("my-wf", 5000);
     await vi.runAllTimersAsync();
     await drainPromise;
 
     // Start a new thread on the fresh worker
-    mgr.startWorkflow("my-wf", { prompt: "second", maxRounds: 10 });
+    mgr.startWorkflow("my-wf", { prompt: "second", maxRounds: 10, dryRun: false });
 
     const newChild = mockChildren[1];
     const startCalls = (newChild.send as ReturnType<typeof vi.fn>).mock.calls.filter(
@@ -261,7 +261,7 @@ describe("Kernel — workflow hot reload via file-watcher (Phase 3)", () => {
     });
 
     // Trigger a workflow thread so a worker is spawned
-    kernel.workflowManager.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
+    kernel.workflowManager.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
 
     // Manually call drainAndRespawn (simulating what kernel does on workflow file change)
     const drainPromise = kernel.workflowManager.drainAndRespawn("my-wf", 1000);
@@ -296,7 +296,11 @@ describe("Kernel — workflow hot reload via file-watcher (Phase 3)", () => {
     });
 
     // Spawn a worker for old-wf
-    kernel.workflowManager.startWorkflow("old-wf", { prompt: "test", maxRounds: 10 });
+    kernel.workflowManager.startWorkflow("old-wf", {
+      prompt: "test",
+      maxRounds: 10,
+      dryRun: false,
+    });
     expect(mockChildren).toHaveLength(1);
 
     // Reload config without old-wf
@@ -334,7 +338,7 @@ describe("Kernel — workflow hot reload via file-watcher (Phase 3)", () => {
       logStore,
     });
 
-    kernel.workflowManager.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
+    kernel.workflowManager.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
     const workersBefore = mockChildren.length;
 
     // Reload with updated concurrency — should NOT spawn a new workflow worker
@@ -354,8 +358,8 @@ describe("Kernel — workflow hot reload via file-watcher (Phase 3)", () => {
     expect(kernel.workflowManager.activeCount("my-wf")).toBe(1);
 
     // Can now start up to 5 concurrent threads (previously only 1)
-    kernel.workflowManager.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
-    kernel.workflowManager.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
+    kernel.workflowManager.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
+    kernel.workflowManager.startWorkflow("my-wf", { prompt: "test", maxRounds: 10, dryRun: false });
     expect(kernel.workflowManager.activeCount("my-wf")).toBe(3);
 
     const stopPromise = kernel.stop();

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

@@ -202,6 +202,7 @@ describe("kernel + workflowManager integration", () => {
         workflow: "alert-workflow",
         prompt: "handle critical alert",
         maxRounds: 5,
+        dryRun: false,
       });
 
       const stopPromise = kernel.stop();

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

@@ -115,7 +115,7 @@ describe("WorkflowManager", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("my-workflow", { prompt: "test", maxRounds: 10 });
+      mgr.startWorkflow("my-workflow", { prompt: "test", maxRounds: 10, dryRun: false });
 
       expect(mockChildren).toHaveLength(1);
       expect(mockChildren[0].send).toHaveBeenCalledWith(
@@ -131,8 +131,8 @@ describe("WorkflowManager", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("my-workflow", { prompt: "test 1", maxRounds: 10 });
-      mgr.startWorkflow("my-workflow", { prompt: "test 2", maxRounds: 10 });
+      mgr.startWorkflow("my-workflow", { prompt: "test 1", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("my-workflow", { prompt: "test 2", maxRounds: 10, dryRun: false });
 
       // Only one forked child — worker is reused
       expect(mockChildren).toHaveLength(1);
@@ -147,7 +147,7 @@ describe("WorkflowManager", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("my-workflow", { prompt: "test", maxRounds: 10 });
+      mgr.startWorkflow("my-workflow", { prompt: "test", maxRounds: 10, dryRun: false });
 
       expect(logStore.upsertWorkflowRun).toHaveBeenCalledWith(
         expect.objectContaining({ source: "workflow", type: "started" }),
@@ -164,9 +164,9 @@ describe("WorkflowManager", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("drop-wf", { prompt: "first", maxRounds: 10 });
+      mgr.startWorkflow("drop-wf", { prompt: "first", maxRounds: 10, dryRun: false });
       // now at limit — second call should be dropped
-      mgr.startWorkflow("drop-wf", { prompt: "second", maxRounds: 10 });
+      mgr.startWorkflow("drop-wf", { prompt: "second", maxRounds: 10, dryRun: false });
 
       expect(mgr.activeCount("drop-wf")).toBe(1);
       expect(mgr.queueLength("drop-wf")).toBe(0);
@@ -181,8 +181,8 @@ describe("WorkflowManager", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("drop-wf", { prompt: "test", maxRounds: 10 });
-      mgr.startWorkflow("drop-wf", { prompt: "test", maxRounds: 10 });
+      mgr.startWorkflow("drop-wf", { prompt: "test", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("drop-wf", { prompt: "test", maxRounds: 10, dryRun: false });
 
       const droppedCall = logStore.upsertWorkflowRun.mock.calls.find(
         ([entry]) => entry.type === "dropped",
@@ -199,8 +199,8 @@ describe("WorkflowManager", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("queue-wf", { prompt: "first", maxRounds: 10 });
-      mgr.startWorkflow("queue-wf", { prompt: "second", maxRounds: 10 });
+      mgr.startWorkflow("queue-wf", { prompt: "first", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("queue-wf", { prompt: "second", maxRounds: 10, dryRun: false });
 
       expect(mgr.activeCount("queue-wf")).toBe(1);
       expect(mgr.queueLength("queue-wf")).toBe(1);
@@ -213,8 +213,8 @@ describe("WorkflowManager", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("queue-wf", { prompt: "test", maxRounds: 10 });
-      mgr.startWorkflow("queue-wf", { prompt: "test", maxRounds: 10 });
+      mgr.startWorkflow("queue-wf", { prompt: "test", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("queue-wf", { prompt: "test", maxRounds: 10, dryRun: false });
 
       const queuedCall = logStore.upsertWorkflowRun.mock.calls.find(
         ([entry]) => entry.type === "queued",
@@ -233,12 +233,12 @@ describe("WorkflowManager", () => {
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
       // Fill the concurrency slot
-      mgr.startWorkflow("queue-wf", { prompt: "test 0", maxRounds: 10 });
+      mgr.startWorkflow("queue-wf", { prompt: "test 0", maxRounds: 10, dryRun: false });
       // Fill the queue to maxQueue
-      mgr.startWorkflow("queue-wf", { prompt: "test 1", maxRounds: 10 });
-      mgr.startWorkflow("queue-wf", { prompt: "test 2", maxRounds: 10 });
+      mgr.startWorkflow("queue-wf", { prompt: "test 1", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("queue-wf", { prompt: "test 2", maxRounds: 10, dryRun: false });
       // This one should push out the oldest
-      mgr.startWorkflow("queue-wf", { prompt: "test 3", maxRounds: 10 });
+      mgr.startWorkflow("queue-wf", { prompt: "test 3", maxRounds: 10, dryRun: false });
 
       // Queue should still be at maxQueue (2)
       expect(mgr.queueLength("queue-wf")).toBe(2);
@@ -259,8 +259,8 @@ describe("WorkflowManager", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("queue-wf", { prompt: "first", maxRounds: 10 });
-      mgr.startWorkflow("queue-wf", { prompt: "second", maxRounds: 10 });
+      mgr.startWorkflow("queue-wf", { prompt: "first", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("queue-wf", { prompt: "second", maxRounds: 10, dryRun: false });
 
       expect(mgr.activeCount("queue-wf")).toBe(1);
       expect(mgr.queueLength("queue-wf")).toBe(1);
@@ -294,8 +294,8 @@ describe("WorkflowManager", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("queue-wf", { prompt: "first", maxRounds: 10 });
-      mgr.startWorkflow("queue-wf", { prompt: "second", maxRounds: 10 });
+      mgr.startWorkflow("queue-wf", { prompt: "first", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("queue-wf", { prompt: "second", maxRounds: 10, dryRun: false });
 
       const child = mockChildren[0];
       const firstRunId = (child.send as ReturnType<typeof vi.fn>).mock.calls[0][0].runId as string;
@@ -321,8 +321,8 @@ describe("WorkflowManager", () => {
       });
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("wf-a", { prompt: "test", maxRounds: 10 });
-      mgr.startWorkflow("wf-b", { prompt: "test", maxRounds: 10 });
+      mgr.startWorkflow("wf-a", { prompt: "test", maxRounds: 10, dryRun: false });
+      mgr.startWorkflow("wf-b", { prompt: "test", maxRounds: 10, dryRun: false });
 
       // Two distinct workers should have been forked
       expect(mockChildren).toHaveLength(2);
@@ -348,7 +348,7 @@ describe("WorkflowManager", () => {
       await vi.runAllTimersAsync();
       await stopPromise;
 
-      mgr.startWorkflow("wf-a", { prompt: "test", maxRounds: 10 });
+      mgr.startWorkflow("wf-a", { prompt: "test", maxRounds: 10, dryRun: false });
 
       // No worker should have been spawned
       expect(mockChildren).toHaveLength(0);
@@ -361,7 +361,7 @@ describe("WorkflowManager", () => {
       const config = makeConfig({});
       const mgr = createWorkflowManager("/nerve-root", config, logStore);
 
-      mgr.startWorkflow("no-such-workflow", { prompt: "test", maxRounds: 10 });
+      mgr.startWorkflow("no-such-workflow", { prompt: "test", maxRounds: 10, dryRun: false });
 
       expect(mockChildren).toHaveLength(0);
       expect(logStore.upsertWorkflowRun).not.toHaveBeenCalled();

packages/daemon/src/daemon-ipc.ts

@@ -55,6 +55,7 @@ export function createDaemonIpcServer(
         workflowManager.startWorkflow(req.workflow, {
           prompt: req.prompt,
           maxRounds: req.maxRounds,
+          dryRun: req.dryRun,
         });
         const resp: DaemonIpcResponse = { ok: true };
         socket.write(`${JSON.stringify(resp)}\n`);

packages/daemon/src/ipc.ts

@@ -34,6 +34,8 @@ export type StartThreadMessage = {
   prompt: string;
   /** Safety-valve: max moderator rounds for this thread (engine launch parameter). */
   maxRounds: number;
+  /** When true, roles may skip side effects (thread-level hint on the start frame). */
+  dryRun: boolean;
 };
 
 /** Parent → Workflow Worker: resume an existing thread after crash recovery */
@@ -44,6 +46,8 @@ export type ResumeThreadMessage = {
   messages: Array<{ role: string; content: string; meta: unknown; timestamp: number }>;
   /** Safety-valve: max moderator rounds for this thread. */
   maxRounds: number;
+  /** Thread-level dry-run hint (aligns with persisted `__start__` meta when replaying). */
+  dryRun: boolean;
 };
 
 /** Union of all messages the parent sends to a worker */
@@ -135,6 +139,7 @@ function validateStartThreadMsg(obj: Record<string, unknown>): string | null {
   if (typeof obj.workflow !== "string") return "'start-thread' message missing string 'workflow'";
   if (typeof obj.prompt !== "string") return "'start-thread' message missing string 'prompt'";
   if (typeof obj.maxRounds !== "number") return "'start-thread' message missing number 'maxRounds'";
+  if (typeof obj.dryRun !== "boolean") return "'start-thread' message missing boolean 'dryRun'";
   return null;
 }
 
@@ -143,6 +148,7 @@ function validateResumeThreadMsg(obj: Record<string, unknown>): string | null {
   if (!Array.isArray(obj.messages)) return "'resume-thread' message missing 'messages' array";
   if (typeof obj.maxRounds !== "number")
     return "'resume-thread' message missing number 'maxRounds'";
+  if (typeof obj.dryRun !== "boolean") return "'resume-thread' message missing boolean 'dryRun'";
   return null;
 }
 
@@ -180,6 +186,7 @@ export function parseParentMessage(raw: unknown): Result<ParentToWorkerMessage>
       workflow: obj.workflow,
       prompt: obj.prompt,
       maxRounds: obj.maxRounds,
+      dryRun: obj.dryRun,
     } as StartThreadMessage);
   }
   if (obj.type === "resume-thread") {
@@ -191,6 +198,7 @@ export function parseParentMessage(raw: unknown): Result<ParentToWorkerMessage>
       runId: obj.runId,
       messages: obj.messages as ResumeThreadMessage["messages"],
       maxRounds: obj.maxRounds,
+      dryRun: obj.dryRun,
     } as ResumeThreadMessage);
   }
   return err(new Error(`Unhandled IPC message type: "${obj.type}"`));

packages/daemon/src/kernel.ts

@@ -148,7 +148,7 @@ export function createKernel(
       const route = routeSenseComputeOutput(msg.payload);
       if (route.kind === "launch") {
         const { workflowName, maxRounds, prompt } = route.launch;
-        workflowManager.startWorkflow(workflowName, { prompt, maxRounds });
+        workflowManager.startWorkflow(workflowName, { prompt, maxRounds, dryRun: false });
         logStore.append({
           source: "sense",
           type: "workflow-launch",

packages/daemon/src/workflow-manager.ts

@@ -31,6 +31,7 @@ import {
 export type WorkflowLaunchParams = {
   prompt: string;
   maxRounds: number;
+  dryRun: boolean;
 };
 
 export type WorkflowManager = {
@@ -58,6 +59,7 @@ type PendingThread = {
   runId: string;
   prompt: string;
   maxRounds: number;
+  dryRun: boolean;
 };
 
 type WorkflowState = {
@@ -90,20 +92,22 @@ const DEFAULT_MAX_QUEUE = 100;
 function readLaunchFromTriggerPayload(
   raw: unknown,
   engineDefaultMaxRounds: number,
-): { prompt: string; maxRounds: number } {
+): { prompt: string; maxRounds: number; dryRun: boolean } {
   if (isPlainRecord(raw)) {
     const o = raw;
     if (typeof o.prompt === "string" && typeof o.maxRounds === "number") {
-      return { prompt: o.prompt, maxRounds: o.maxRounds };
+      const dryRun = typeof o.dryRun === "boolean" ? o.dryRun : false;
+      return { prompt: o.prompt, maxRounds: o.maxRounds, dryRun };
     }
   }
-  return { prompt: "", maxRounds: engineDefaultMaxRounds };
+  return { prompt: "", maxRounds: engineDefaultMaxRounds, dryRun: false };
 }
 
 function ensureThreadMessagesWithStart(
   messages: Array<{ role: string; content: string; meta: unknown; timestamp: number }>,
   fallbackPrompt: string,
   fallbackMaxRounds: number,
+  fallbackDryRun: boolean,
 ): WorkflowMessage[] {
   const mapped: WorkflowMessage[] = messages.map((m) => ({
     role: m.role,
@@ -117,7 +121,7 @@ function ensureThreadMessagesWithStart(
   const start: WorkflowMessage = {
     role: START,
     content: fallbackPrompt,
-    meta: { maxRounds: fallbackMaxRounds },
+    meta: { maxRounds: fallbackMaxRounds, dryRun: fallbackDryRun },
     timestamp: Date.now(),
   };
   return [start, ...mapped];
@@ -260,6 +264,7 @@ export function createWorkflowManager(
     runId: string,
     prompt: string,
     maxRounds: number,
+    dryRun: boolean,
   ): void {
     const state = getOrCreateState(workflowName);
     state.active.add(runId);
@@ -271,9 +276,10 @@ export function createWorkflowManager(
       workflow: workflowName,
       prompt,
       maxRounds,
+      dryRun,
     };
     sendStartThread(worker.process, msg);
-    logWorkflowEvent(workflowName, runId, "started", { prompt, maxRounds });
+    logWorkflowEvent(workflowName, runId, "started", { prompt, maxRounds, dryRun });
   }
 
   function dequeueNext(workflowName: string): void {
@@ -286,7 +292,7 @@ export function createWorkflowManager(
     if (state.active.size < concurrency) {
       const next = state.queue.shift();
       if (next !== undefined) {
-        dispatchThread(workflowName, next.runId, next.prompt, next.maxRounds);
+        dispatchThread(workflowName, next.runId, next.prompt, next.maxRounds, next.dryRun);
       }
     }
   }
@@ -311,7 +317,12 @@ export function createWorkflowManager(
       logStore.getTriggerPayload(runId),
       config.maxRounds,
     );
-    state.queue.push({ runId, prompt: launch.prompt, maxRounds: launch.maxRounds });
+    state.queue.push({
+      runId,
+      prompt: launch.prompt,
+      maxRounds: launch.maxRounds,
+      dryRun: launch.dryRun,
+    });
     process.stderr.write(
       `[workflow-manager] crash-recovery: re-queued thread "${runId}" for "${workflowName}"\n`,
     );
@@ -329,13 +340,19 @@ export function createWorkflowManager(
       logStore.getTriggerPayload(runId),
       config.maxRounds,
     );
-    const messages = ensureThreadMessagesWithStart(rawMessages, launch.prompt, launch.maxRounds);
+    const messages = ensureThreadMessagesWithStart(
+      rawMessages,
+      launch.prompt,
+      launch.maxRounds,
+      launch.dryRun,
+    );
     state.active.add(runId);
     const msg: ResumeThreadMessage = {
       type: "resume-thread",
       runId,
       messages,
       maxRounds: launch.maxRounds,
+      dryRun: launch.dryRun,
     };
     sendResumeThread(worker.process, msg);
     process.stderr.write(
@@ -531,10 +548,10 @@ export function createWorkflowManager(
 
     const state = getOrCreateState(workflowName);
     const runId = crypto.randomUUID();
-    const { prompt, maxRounds } = launch;
+    const { prompt, maxRounds, dryRun } = launch;
 
     if (state.active.size < wfConfig.concurrency) {
-      dispatchThread(workflowName, runId, prompt, maxRounds);
+      dispatchThread(workflowName, runId, prompt, maxRounds, dryRun);
       return;
     }
 
@@ -559,7 +576,7 @@ export function createWorkflowManager(
       }
     }
 
-    state.queue.push({ runId, prompt, maxRounds });
+    state.queue.push({ runId, prompt, maxRounds, dryRun });
     logWorkflowEvent(workflowName, runId, "queued");
     process.stderr.write(
       `[workflow-manager] queued thread for "${workflowName}" runId "${runId}" (queue length: ${state.queue.length})\n`,

packages/daemon/src/workflow-worker.ts

@@ -13,7 +13,7 @@ import { existsSync } from "node:fs";
 import { join, resolve } from "node:path";
 
 import type {
-  Moderator,
+  ModeratorContext,
   RoleMeta,
   StartSignal,
   WorkflowDefinition,
@@ -29,8 +29,6 @@ import type {
 import { parseParentMessage } from "./ipc.js";
 import { ignoreSessionBroadcastSignals } from "./worker-fork-support.js";
 
-type ModeratorInput = Parameters<Moderator<RoleMeta>>[0];
-
 // ---------------------------------------------------------------------------
 // IPC helpers
 // ---------------------------------------------------------------------------
@@ -87,42 +85,95 @@ function validateRoleResult(
   return true;
 }
 
-function buildInitialLastSignal(lastMsg: WorkflowMessage): ModeratorInput {
-  if (lastMsg.role === START) {
-    return {
-      role: START,
-      content: lastMsg.content,
-      meta: lastMsg.meta as StartSignal["meta"],
-      timestamp: lastMsg.timestamp,
-    };
-  }
-  return { role: lastMsg.role, meta: lastMsg.meta as Record<string, unknown> };
+function isStartMeta(meta: unknown): meta is StartSignal["meta"] {
+  return (
+    isPlainRecord(meta) && typeof meta.maxRounds === "number" && typeof meta.dryRun === "boolean"
+  );
 }
 
-function initChain(
+function normalizeStartMeta(meta: unknown, maxRoundsFallback: number): StartSignal["meta"] {
+  if (!isPlainRecord(meta)) {
+    return { maxRounds: maxRoundsFallback, dryRun: false };
+  }
+  const maxRounds = typeof meta.maxRounds === "number" ? meta.maxRounds : maxRoundsFallback;
+  const dryRun = typeof meta.dryRun === "boolean" ? meta.dryRun : false;
+  return { maxRounds, dryRun };
+}
+
+function startSignalFromWorkflowMessage(
+  msg: WorkflowMessage,
+  maxRoundsFallback: number,
+): StartSignal {
+  if (msg.role !== START) {
+    return {
+      role: START,
+      content: "",
+      meta: { maxRounds: maxRoundsFallback, dryRun: false },
+      timestamp: Date.now(),
+    };
+  }
+  const meta = isStartMeta(msg.meta) ? msg.meta : normalizeStartMeta(msg.meta, maxRoundsFallback);
+  return {
+    role: START,
+    content: msg.content,
+    meta,
+    timestamp: msg.timestamp,
+  };
+}
+
+type ThreadMessagesState = {
+  start: StartSignal;
+  /** Role outputs only; never includes the `__start__` frame. */
+  messages: WorkflowMessage[];
+};
+
+function initThreadMessages(
   runId: string,
   resumeMessages: WorkflowMessage[],
   freshPrompt: string | null,
   maxRounds: number,
-): WorkflowMessage[] {
+  dryRun: boolean,
+): ThreadMessagesState {
   if (resumeMessages.length > 0) {
-    return [...resumeMessages];
+    const [first, ...rest] = resumeMessages;
+    if (first.role === START) {
+      return {
+        start: startSignalFromWorkflowMessage(first, maxRounds),
+        messages: [...rest],
+      };
+    }
+    const prompt = freshPrompt ?? "";
+    return {
+      start: {
+        role: START,
+        content: prompt,
+        meta: { maxRounds, dryRun },
+        timestamp: Date.now(),
+      },
+      messages: [...resumeMessages],
+    };
   }
   const prompt = freshPrompt ?? "";
-  const startMsg: WorkflowMessage = {
+  const start: StartSignal = {
     role: START,
     content: prompt,
-    meta: { maxRounds },
+    meta: { maxRounds, dryRun },
     timestamp: Date.now(),
   };
-  sendWorkflowMessage(runId, startMsg);
-  return [startMsg];
+  sendWorkflowMessage(runId, {
+    role: start.role,
+    content: start.content,
+    meta: start.meta,
+    timestamp: start.timestamp,
+  });
+  return { start, messages: [] };
 }
 
 async function executeRole(
   def: WorkflowDefinition<RoleMeta>,
   nextRole: string,
-  chain: WorkflowMessage[],
+  start: StartSignal,
+  messages: WorkflowMessage[],
   runId: string,
 ): Promise<{ content: string; meta: Record<string, unknown> } | null> {
   const role = def.roles[nextRole];
@@ -133,7 +184,7 @@ async function executeRole(
 
   let result: { content: string; meta: Record<string, unknown> };
   try {
-    result = await role(chain);
+    result = await role(start, messages);
   } catch (e: unknown) {
     const errMsg = e instanceof Error ? e.message : String(e);
     sendThreadEvent(runId, "failed", { error: errMsg });
@@ -150,17 +201,18 @@ async function runThread(
   maxRounds: number,
   resumeMessages: WorkflowMessage[] = [],
   freshPrompt: string | null = null,
+  dryRun = false,
 ): Promise<void> {
-  const chain = initChain(runId, resumeMessages, freshPrompt, maxRounds);
+  const { start, messages: roleMessages } = initThreadMessages(
+    runId,
+    resumeMessages,
+    freshPrompt,
+    maxRounds,
+    dryRun,
+  );
 
-  let roleRound = chain.filter((m) => m.role !== START).length;
-  const lastMsg = chain[chain.length - 1];
-  if (lastMsg === undefined) {
-    sendWorkflowError(runId, "empty workflow message chain");
-    return;
-  }
-
-  let nextRole = def.moderator(buildInitialLastSignal(lastMsg), roleRound, maxRounds);
+  let roleRound = roleMessages.length;
+  let nextRole = def.moderator({ kind: "start", start }, roleRound, maxRounds);
 
   if (nextRole === END) {
     sendThreadEvent(runId, "completed", null);
@@ -168,7 +220,7 @@ async function runThread(
   }
 
   while (roleRound < maxRounds) {
-    const result = await executeRole(def, nextRole, chain, runId);
+    const result = await executeRole(def, nextRole, start, roleMessages, runId);
     if (result === null) return;
 
     const message: WorkflowMessage = {
@@ -177,13 +229,16 @@ async function runThread(
       meta: result.meta,
       timestamp: Date.now(),
     };
-    chain.push(message);
+    roleMessages.push(message);
     sendWorkflowMessage(runId, message);
 
     roleRound += 1;
 
-    const signal: ModeratorInput = { role: nextRole, meta: result.meta };
-    nextRole = def.moderator(signal, roleRound, maxRounds);
+    const stepContext: ModeratorContext<RoleMeta> = {
+      kind: "step",
+      signal: { role: nextRole, meta: result.meta },
+    };
+    nextRole = def.moderator(stepContext, roleRound, maxRounds);
 
     if (nextRole === END) {
       sendThreadEvent(runId, "completed", null);
@@ -267,11 +322,11 @@ function handleMessage(
 
   if (msg.type === "start-thread") {
     if (shuttingDown.value) return;
-    const { runId, prompt, maxRounds } = msg;
+    const { runId, prompt, maxRounds, dryRun } = msg;
 
     const previous = inFlight.get(runId) ?? Promise.resolve();
     const next = previous
-      .then(() => runThread(def, runId, maxRounds, [], prompt))
+      .then(() => runThread(def, runId, maxRounds, [], prompt, dryRun))
       .catch((e: unknown) => {
         const errMsg = e instanceof Error ? e.message : String(e);
         sendWorkflowError(runId, errMsg);
@@ -286,11 +341,11 @@ function handleMessage(
 
   if (msg.type === "resume-thread") {
     if (shuttingDown.value) return;
-    const { runId, messages, maxRounds } = msg;
+    const { runId, messages, maxRounds, dryRun } = msg;
 
     const previous = inFlight.get(runId) ?? Promise.resolve();
     const next = previous
-      .then(() => runThread(def, runId, maxRounds, messages, null))
+      .then(() => runThread(def, runId, maxRounds, messages, null, dryRun))
       .catch((e: unknown) => {
         const errMsg = e instanceof Error ? e.message : String(e);
         sendWorkflowError(runId, errMsg);

packages/store/src/log-store.ts

@@ -242,6 +242,41 @@ function runInTransaction<T>(db: DatabaseSync, fn: () => T): T {
   }
 }
 
+function launchShapeFromRecord(rec: Record<string, unknown>): {
+  prompt: string;
+  maxRounds: number;
+  dryRun: boolean;
+} | null {
+  if (typeof rec.prompt !== "string" || typeof rec.maxRounds !== "number") return null;
+  return {
+    prompt: rec.prompt,
+    maxRounds: rec.maxRounds,
+    dryRun: typeof rec.dryRun === "boolean" ? rec.dryRun : false,
+  };
+}
+
+/** Parse JSON from a workflow `started` log row into a trigger / launch payload for crash recovery. */
+function triggerPayloadFromStartedLogJson(payload: string): unknown | null {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(payload);
+  } catch {
+    return null;
+  }
+  if (!isPlainRecord(parsed)) return null;
+
+  const direct = launchShapeFromRecord(parsed);
+  if (direct !== null) return direct;
+
+  const inner = parsed.triggerPayload;
+  if (inner !== null && isPlainRecord(inner)) {
+    const fromInner = launchShapeFromRecord(inner);
+    if (fromInner !== null) return fromInner;
+    return inner;
+  }
+  return null;
+}
+
 function runOptionalVacuum(sqlite: DatabaseSync, vacuum?: boolean): boolean {
   if (vacuum !== true) return false;
   sqlite.exec("VACUUM");
@@ -513,15 +548,7 @@ export function createLogStore(dbPath: string): LogStore {
   function getTriggerPayload(runId: string): unknown {
     const row = getTriggerPayloadStmt.get(runId) as { payload: string | null } | undefined;
     if (row === undefined || row.payload === null) return null;
-    try {
-      const parsed: unknown = JSON.parse(row.payload);
-      if (isPlainRecord(parsed)) {
-        return parsed.triggerPayload ?? null;
-      }
-    } catch {
-      // malformed
-    }
-    return null;
+    return triggerPayloadFromStartedLogJson(row.payload);
   }
 
   function getThreadEvents(runId: string): Array<{ type: string; [key: string]: unknown }> {

packages/workflow-utils/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@uncaged/nerve-workflow-utils",
+  "version": "0.4.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "prepublishOnly": "bash ../../scripts/prepublish-check.sh",
+    "build": "rslib build",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@uncaged/nerve-core": "workspace:*",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@rslib/core": "^0.21.3",
+    "@types/node": "^22.0.0",
+    "vitest": "^4.1.5"
+  }
+}

packages/workflow-utils/rslib.config.ts

@@ -0,0 +1,19 @@
+import { defineConfig } from "@rslib/core";
+
+export default defineConfig({
+  lib: [
+    {
+      format: "esm",
+      dts: true,
+    },
+  ],
+  source: {
+    entry: {
+      index: "src/index.ts",
+    },
+  },
+  output: {
+    target: "node",
+    cleanDistPath: true,
+  },
+});

packages/workflow-utils/src/__tests__/llm-extract.test.ts

@@ -0,0 +1,110 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { z } from "zod";
+
+import { llmExtract } from "../llm-extract.js";
+
+describe("llmExtract", () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+  });
+
+  it("parses tool call arguments and validates with the zod schema", async () => {
+    const schema = z
+      .object({
+        name: z.string(),
+        description: z.string(),
+      })
+      .describe("Extract sense metadata from plan");
+
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      text: async () =>
+        JSON.stringify({
+          choices: [
+            {
+              message: {
+                tool_calls: [
+                  {
+                    function: {
+                      name: "extract",
+                      arguments: JSON.stringify({ name: "cpu-usage", description: "CPU load" }),
+                    },
+                  },
+                ],
+              },
+            },
+          ],
+        }),
+    });
+
+    vi.stubGlobal("fetch", fetchMock);
+
+    const result = await llmExtract({
+      text: "some plan",
+      schema,
+      provider: {
+        baseUrl: "https://example.com/v1",
+        apiKey: "k",
+        model: "m",
+      },
+    });
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) {
+      return;
+    }
+    expect(result.value).toEqual({ name: "cpu-usage", description: "CPU load" });
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    const [, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+    expect(init.method).toBe("POST");
+    expect(init.headers).toMatchObject({
+      Authorization: "Bearer k",
+      "Content-Type": "application/json",
+    });
+    const body = JSON.parse(init.body as string) as {
+      model: string;
+      tool_choice: { function: { name: string } };
+    };
+    expect(body.model).toBe("m");
+    expect(body.tool_choice.function.name).toBeDefined();
+  });
+
+  it("returns schema_validation_failed when arguments do not match the schema", async () => {
+    const schema = z.object({ n: z.number() });
+
+    vi.stubGlobal(
+      "fetch",
+      vi.fn().mockResolvedValue({
+        ok: true,
+        status: 200,
+        text: async () =>
+          JSON.stringify({
+            choices: [
+              {
+                message: {
+                  tool_calls: [
+                    { function: { name: "extract", arguments: JSON.stringify({ n: "oops" }) } },
+                  ],
+                },
+              },
+            ],
+          }),
+      }),
+    );
+
+    const result = await llmExtract({
+      text: "x",
+      schema,
+      provider: { baseUrl: "https://example.com", apiKey: "k", model: "m" },
+    });
+
+    expect(result.ok).toBe(false);
+    if (result.ok) {
+      return;
+    }
+    expect(result.error.kind).toBe("schema_validation_failed");
+  });
+});

packages/workflow-utils/src/__tests__/spawn-safe.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+
+import { spawnSafe } from "../spawn-safe.js";
+
+describe("spawnSafe", () => {
+  it("passes argv literally without shell interpretation (injection-safe)", async () => {
+    const injection = "$(echo BAD)";
+    const result = await spawnSafe(
+      process.execPath,
+      ["-e", "process.stdout.write(process.argv[1] ?? '')", injection],
+      { cwd: null, env: null, timeoutMs: 10_000 },
+    );
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) {
+      return;
+    }
+    expect(result.value.stdout).toBe(injection);
+    expect(result.value.exitCode).toBe(0);
+  });
+
+  it("returns err on non-zero exit", async () => {
+    const result = await spawnSafe(process.execPath, ["-e", "process.exit(7)"], {
+      cwd: null,
+      env: null,
+      timeoutMs: 10_000,
+    });
+
+    expect(result.ok).toBe(false);
+    if (result.ok) {
+      return;
+    }
+    expect(result.error.kind).toBe("non_zero_exit");
+    if (result.error.kind !== "non_zero_exit") {
+      return;
+    }
+    expect(result.error.exitCode).toBe(7);
+  });
+});

packages/workflow-utils/src/context.ts

@@ -0,0 +1,47 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { type Result, err, ok } from "@uncaged/nerve-core";
+
+export type ReadNerveYamlOptions = {
+  nerveRoot: string;
+};
+
+export type NerveYamlError = {
+  code: "PATH_TRAVERSAL" | "READ_FAILED";
+  message: string;
+};
+
+/**
+ * Reads `nerve.yaml` from a Nerve data directory (typically `~/.uncaged-nerve`).
+ * Returns Result to avoid throwing on expected failures (missing file, bad perms).
+ * Validates that the resolved path stays within nerveRoot to prevent path traversal.
+ */
+export function readNerveYaml(options: ReadNerveYamlOptions): Result<string, NerveYamlError> {
+  const root = resolve(options.nerveRoot);
+  const target = resolve(root, "nerve.yaml");
+
+  if (!target.startsWith(root)) {
+    return err({
+      code: "PATH_TRAVERSAL",
+      message: `Resolved path "${target}" escapes nerveRoot "${root}"`,
+    });
+  }
+
+  try {
+    return ok(readFileSync(target, "utf-8"));
+  } catch (e) {
+    return err({
+      code: "READ_FAILED",
+      message: e instanceof Error ? e.message : String(e),
+    });
+  }
+}
+
+/**
+ * Shared context for workflow agents: how Nerve fits together and common CLI verbs.
+ */
+export const nerveAgentContext = `
+Nerve observes the world through **Senses** (each has its own SQLite DB and a \`compute()\` function).
+**Reflexes** (YAML) schedule sense runs or start **Workflows** on intervals or signals.
+The \`nerve\` CLI manages config, triggers, and queries; keep paths and commands aligned with the host nerve.yaml and senses directory.
+`.trim();

packages/workflow-utils/src/cursor-agent.ts

@@ -0,0 +1,48 @@
+import { type Result, ok } from "@uncaged/nerve-core";
+
+import { type SpawnEnv, type SpawnError, spawnSafe } from "./spawn-safe.js";
+
+export type CursorAgentMode = "plan" | "ask" | "default";
+
+export type CursorAgentOptions = {
+  prompt: string;
+  mode: CursorAgentMode;
+  cwd: string;
+  env: SpawnEnv | null;
+  timeoutMs: number | null;
+};
+
+/**
+ * Invokes `cursor-agent` with the prompt passed as a single argv slot (`shell: false`).
+ */
+export async function cursorAgent(
+  options: CursorAgentOptions,
+): Promise<Result<string, SpawnError>> {
+  const args: string[] = [
+    "-p",
+    options.prompt,
+    "--model",
+    "auto",
+    "--output-format",
+    "text",
+    "--trust",
+    "--force",
+  ];
+  if (options.mode === "plan") {
+    args.push("--mode=plan");
+  } else if (options.mode === "ask") {
+    args.push("--mode=ask");
+  }
+
+  const run = await spawnSafe("cursor-agent", args, {
+    cwd: options.cwd,
+    env: options.env,
+    timeoutMs: options.timeoutMs,
+  });
+
+  if (!run.ok) {
+    return run;
+  }
+
+  return ok(run.value.stdout);
+}

packages/workflow-utils/src/index.ts

@@ -0,0 +1,22 @@
+export { cursorAgent, type CursorAgentMode, type CursorAgentOptions } from "./cursor-agent.js";
+export {
+  nerveAgentContext,
+  readNerveYaml,
+  type NerveYamlError,
+  type ReadNerveYamlOptions,
+} from "./context.js";
+export {
+  llmExtract,
+  type LlmError,
+  type LlmExtractOptions,
+  type LlmProvider,
+} from "./llm-extract.js";
+export {
+  nerveCommandEnv,
+  spawnSafe,
+  type SpawnEnv,
+  type SpawnError,
+  type SpawnResult,
+  type SpawnSafeOptions,
+} from "./spawn-safe.js";
+export { isDryRun } from "./start-signal.js";

packages/workflow-utils/src/llm-extract.ts

@@ -0,0 +1,174 @@
+import { type Result, err, ok } from "@uncaged/nerve-core";
+import { toJSONSchema, type z } from "zod";
+
+export type LlmProvider = {
+  baseUrl: string;
+  apiKey: string;
+  model: string;
+};
+
+export type LlmExtractOptions<T> = {
+  text: string;
+  schema: z.ZodType<T>;
+  provider: LlmProvider;
+};
+
+export type LlmError =
+  | { kind: "http_error"; status: number; body: string }
+  | { kind: "invalid_response_json"; message: string }
+  | { kind: "no_tool_call"; preview: string }
+  | { kind: "tool_arguments_invalid_json"; message: string }
+  | { kind: "schema_validation_failed"; message: string }
+  | { kind: "network_error"; message: string };
+
+function chatCompletionsUrl(baseUrl: string): string {
+  const trimmed = baseUrl.replace(/\/+$/, "");
+  return `${trimmed}/chat/completions`;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function stripJsonSchemaMeta(json: Record<string, unknown>): Record<string, unknown> {
+  const { $schema: _drop, ...rest } = json;
+  return rest;
+}
+
+function readToolName(parametersSchema: Record<string, unknown>): string {
+  const title = parametersSchema.title;
+  if (typeof title === "string" && title.trim().length > 0) {
+    return title.trim();
+  }
+  return "extract";
+}
+
+function readToolArgumentsJson(parsed: unknown, previewSource: string): Result<string, LlmError> {
+  if (!isRecord(parsed)) {
+    return err({ kind: "invalid_response_json", message: "Top-level JSON is not an object" });
+  }
+
+  const choices = parsed.choices;
+  if (!Array.isArray(choices) || choices.length === 0) {
+    return err({ kind: "no_tool_call", preview: previewSource.slice(0, 500) });
+  }
+
+  const first = choices[0];
+  if (!isRecord(first)) {
+    return err({ kind: "no_tool_call", preview: previewSource.slice(0, 500) });
+  }
+
+  const messageObj = first.message;
+  if (!isRecord(messageObj)) {
+    return err({ kind: "no_tool_call", preview: previewSource.slice(0, 500) });
+  }
+
+  const toolCalls = messageObj.tool_calls;
+  if (!Array.isArray(toolCalls) || toolCalls.length === 0) {
+    return err({ kind: "no_tool_call", preview: previewSource.slice(0, 500) });
+  }
+
+  const call0 = toolCalls[0];
+  if (!isRecord(call0)) {
+    return err({ kind: "no_tool_call", preview: previewSource.slice(0, 500) });
+  }
+
+  const fn = call0.function;
+  if (!isRecord(fn)) {
+    return err({ kind: "no_tool_call", preview: previewSource.slice(0, 500) });
+  }
+
+  const argsRaw = fn.arguments;
+  if (typeof argsRaw !== "string") {
+    return err({ kind: "no_tool_call", preview: previewSource.slice(0, 500) });
+  }
+
+  return ok(argsRaw);
+}
+
+/**
+ * Calls an OpenAI-compatible chat completions API with `tool_choice` forced to a single function
+ * derived from a Zod v4 schema (`toJSONSchema`). Uses `fetch()` only (no shell).
+ */
+export async function llmExtract<T>(options: LlmExtractOptions<T>): Promise<Result<T, LlmError>> {
+  const rawJsonSchema = toJSONSchema(options.schema) as Record<string, unknown>;
+  const parameters = stripJsonSchemaMeta(rawJsonSchema);
+  const toolName = readToolName(parameters);
+  const toolDescription =
+    typeof options.schema.description === "string" && options.schema.description.trim().length > 0
+      ? options.schema.description.trim()
+      : "Extract structured data from the input text.";
+
+  const body = {
+    model: options.provider.model,
+    messages: [
+      {
+        role: "system" as const,
+        content: "Extract the requested information from the provided text. Be precise.",
+      },
+      { role: "user" as const, content: options.text },
+    ],
+    tools: [
+      {
+        type: "function" as const,
+        function: {
+          name: toolName,
+          description: toolDescription,
+          parameters,
+        },
+      },
+    ],
+    tool_choice: { type: "function" as const, function: { name: toolName } },
+  };
+
+  let response: Response;
+  try {
+    response = await fetch(chatCompletionsUrl(options.provider.baseUrl), {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${options.provider.apiKey}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(body),
+    });
+  } catch (cause) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    return err({ kind: "network_error", message });
+  }
+
+  const responseText = await response.text();
+  if (!response.ok) {
+    return err({ kind: "http_error", status: response.status, body: responseText.slice(0, 4000) });
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(responseText) as unknown;
+  } catch (cause) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    return err({ kind: "invalid_response_json", message });
+  }
+
+  const argsJson = readToolArgumentsJson(parsed, responseText);
+  if (!argsJson.ok) {
+    return argsJson;
+  }
+
+  let argsParsed: unknown;
+  try {
+    argsParsed = JSON.parse(argsJson.value) as unknown;
+  } catch (cause) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    return err({ kind: "tool_arguments_invalid_json", message });
+  }
+
+  const validated = options.schema.safeParse(argsParsed);
+  if (!validated.success) {
+    return err({
+      kind: "schema_validation_failed",
+      message: validated.error.message,
+    });
+  }
+
+  return ok(validated.data);
+}

packages/workflow-utils/src/spawn-safe.ts

@@ -0,0 +1,140 @@
+import { spawn } from "node:child_process";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { type Result, err, ok } from "@uncaged/nerve-core";
+
+/** Compatible with `process.env` for `child_process.spawn`. */
+export type SpawnEnv = Record<string, string | undefined>;
+
+export type SpawnResult = {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+  /** OS signal name (e.g. `"SIGTERM"`) when terminated by signal; otherwise `null`. */
+  signal: string | null;
+};
+
+export type SpawnError =
+  | {
+      kind: "non_zero_exit";
+      stdout: string;
+      stderr: string;
+      exitCode: number;
+      signal: string | null;
+    }
+  | { kind: "timeout"; stdout: string; stderr: string }
+  | { kind: "spawn_failed"; message: string };
+
+export type SpawnSafeOptions = {
+  cwd: string | null;
+  /** When null, merges {@link nerveCommandEnv} over `process.env`. When set, merges over that default. */
+  env: SpawnEnv | null;
+  timeoutMs: number | null;
+};
+
+const DEFAULT_TIMEOUT_MS = 300_000;
+
+/**
+ * PATH and PNPM_HOME for running `pnpm` and `nerve` from workflow roles.
+ * Uses the pnpm store home only (no npm user bin); binaries must resolve via PATH.
+ */
+export function nerveCommandEnv(): SpawnEnv {
+  const home = homedir();
+  const pnpmHome = join(home, ".local/share/pnpm");
+  return {
+    ...process.env,
+    PNPM_HOME: pnpmHome,
+    PATH: `${pnpmHome}:${process.env.PATH ?? ""}`,
+  };
+}
+
+function mergeEnv(user: SpawnEnv | null): SpawnEnv {
+  const base = nerveCommandEnv();
+  if (user === null) {
+    return base;
+  }
+  return { ...base, ...user };
+}
+
+function resolveTimeout(timeoutMs: number | null): number {
+  if (timeoutMs === null) {
+    return DEFAULT_TIMEOUT_MS;
+  }
+  return timeoutMs;
+}
+
+/**
+ * Spawn a process with `shell: false` (argv only), default {@link nerveCommandEnv}, and optional timeout.
+ * Returns `ok` only when the process exits with code 0.
+ */
+export function spawnSafe(
+  command: string,
+  args: ReadonlyArray<string>,
+  options: SpawnSafeOptions,
+): Promise<Result<SpawnResult, SpawnError>> {
+  return new Promise((resolve) => {
+    const cwd = options.cwd === null ? process.cwd() : options.cwd;
+    const env = mergeEnv(options.env);
+    const timeoutMs = resolveTimeout(options.timeoutMs);
+
+    const child = spawn(command, args, {
+      cwd,
+      env,
+      shell: false,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+
+    const finish = (outcome: Result<SpawnResult, SpawnError>) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      resolve(outcome);
+    };
+
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      finish(err({ kind: "timeout", stdout, stderr }));
+    }, timeoutMs);
+
+    child.stdout?.on("data", (chunk: Buffer | string) => {
+      stdout += typeof chunk === "string" ? chunk : chunk.toString("utf-8");
+    });
+    child.stderr?.on("data", (chunk: Buffer | string) => {
+      stderr += typeof chunk === "string" ? chunk : chunk.toString("utf-8");
+    });
+
+    child.on("error", (cause: Error) => {
+      finish(err({ kind: "spawn_failed", message: cause.message }));
+    });
+
+    child.on("close", (code, signal) => {
+      const exitCode = code ?? 1;
+      const sig = signal === undefined || signal === null ? null : String(signal);
+      const result: SpawnResult = {
+        stdout: stdout.trimEnd(),
+        stderr: stderr.trimEnd(),
+        exitCode,
+        signal: sig,
+      };
+      if (exitCode !== 0) {
+        finish(
+          err({
+            kind: "non_zero_exit",
+            stdout: result.stdout,
+            stderr: result.stderr,
+            exitCode,
+            signal: sig,
+          }),
+        );
+        return;
+      }
+      finish(ok(result));
+    });
+  });
+}

packages/workflow-utils/src/start-signal.ts

@@ -0,0 +1,6 @@
+import type { StartSignal } from "@uncaged/nerve-core";
+
+/** Returns the thread-level dry-run flag from the workflow start frame. */
+export function isDryRun(start: StartSignal): boolean {
+  return start.meta.dryRun;
+}

packages/workflow-utils/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "composite": false
+  },
+  "include": ["src"]
+}

pnpm-lock.yaml

@@ -69,7 +69,7 @@ importers:
         version: link:../store
       drizzle-orm:
         specifier: 1.0.0-beta.23-c10d10c
-        version: 1.0.0-beta.23-c10d10c(@types/better-sqlite3@7.6.13)(@types/mssql@9.1.11(@azure/core-client@1.10.1))(better-sqlite3@11.10.0)(mssql@11.0.1(@azure/core-client@1.10.1))(sql.js@1.14.1)
+        version: 1.0.0-beta.23-c10d10c(@types/better-sqlite3@7.6.13)(@types/mssql@9.1.11(@azure/core-client@1.10.1))(better-sqlite3@11.10.0)(mssql@11.0.1(@azure/core-client@1.10.1))(sql.js@1.14.1)(zod@4.3.6)
       yaml:
         specifier: ^2.8.3
         version: 2.8.3
@@ -100,6 +100,25 @@ importers:
         specifier: ^4.1.5
         version: 4.1.5(@types/node@22.19.17)(vite@8.0.9(@types/node@22.19.17)(esbuild@0.27.7)(yaml@2.8.3))
 
+  packages/workflow-utils:
+    dependencies:
+      '@uncaged/nerve-core':
+        specifier: workspace:*
+        version: link:../core
+      zod:
+        specifier: ^4.3.6
+        version: 4.3.6
+    devDependencies:
+      '@rslib/core':
+        specifier: ^0.21.3
+        version: 0.21.3(typescript@5.9.3)
+      '@types/node':
+        specifier: ^22.0.0
+        version: 22.19.17
+      vitest:
+        specifier: ^4.1.5
+        version: 4.1.5(@types/node@22.19.17)(vite@8.0.9(@types/node@22.19.17)(esbuild@0.27.7)(yaml@2.8.3))
+
 packages:
 
   '@ast-grep/napi-darwin-arm64@0.37.0':
@@ -1472,6 +1491,9 @@ packages:
     engines: {node: '>= 14.6'}
     hasBin: true
 
+  zod@4.3.6:
+    resolution: {integrity: sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==}
+
 snapshots:
 
   '@ast-grep/napi-darwin-arm64@0.37.0':
@@ -2169,13 +2191,14 @@ snapshots:
 
   detect-libc@2.1.2: {}
 
-  drizzle-orm@1.0.0-beta.23-c10d10c(@types/better-sqlite3@7.6.13)(@types/mssql@9.1.11(@azure/core-client@1.10.1))(better-sqlite3@11.10.0)(mssql@11.0.1(@azure/core-client@1.10.1))(sql.js@1.14.1):
+  drizzle-orm@1.0.0-beta.23-c10d10c(@types/better-sqlite3@7.6.13)(@types/mssql@9.1.11(@azure/core-client@1.10.1))(better-sqlite3@11.10.0)(mssql@11.0.1(@azure/core-client@1.10.1))(sql.js@1.14.1)(zod@4.3.6):
     optionalDependencies:
       '@types/better-sqlite3': 7.6.13
       '@types/mssql': 9.1.11(@azure/core-client@1.10.1)
       better-sqlite3: 11.10.0
       mssql: 11.0.1(@azure/core-client@1.10.1)
       sql.js: 1.14.1
+      zod: 4.3.6
 
   ecdsa-sig-formatter@1.0.11:
     dependencies:
@@ -2772,3 +2795,5 @@ snapshots:
     optional: true
 
   yaml@2.8.3: {}
+
+  zod@4.3.6: {}