docs: add core concepts (sense, signal, reflex, workflow) to agent rules

- .cursor/rules/global.mdc: coding conventions as Cursor agent rules
- CLAUDE.md: same conventions for Claude Code / Hermes agents
- Content derived from docs/coding-conventions.md
- Includes no-dynamic-import rule in CLAUDE.md for completeness

.cursor/rules/global.mdc

@@ -0,0 +1,189 @@
+---
+description: Nerve project coding conventions — style, patterns, and toolchain
+globs: packages/*/src/**/*.ts
+alwaysApply: true
+---
+
+# Nerve Coding Conventions
+
+## Core Concepts
+
+```
+External World → Sense → Signal → Reflex → Workflow → Log
+                  ↑                                     ↑
+              "what to observe"                  "what to do"
+```
+
+**Nerve** is a lightweight observation engine daemon for autonomous agents. It continuously observes external state, reacts to changes via declarative rules, and orchestrates multi-step workflows.
+
+### Key Terms
+
+| Concept | What it is |
+|---------|-----------|
+| **Sense** | A `compute()` function that samples or derives data. Returns `T \| null` — non-null emits a Signal, null is silent. Each Sense has its own SQLite database. |
+| **Signal** | A notification emitted when a Sense returns non-null. Pure fact, no intent. Distributed via an in-memory Signal Bus. Not persisted. |
+| **Reflex** | A declarative trigger (YAML) connecting Senses to actions. Trigger types: `interval` (periodic), `on` (react to Signals). Action types: trigger a Sense, or start a Workflow. |
+| **Workflow** | A stateful multi-step execution. Contains **Roles** (actors with side effects) and a **Moderator** (pure router). Each instance is a **Thread** with a unique `runId`. |
+| **Log** | Immutable audit trail. Records executions, state transitions, errors. **Cannot trigger Reflexes** — prevents feedback loops. |
+| **Engine** | The kernel orchestrating everything. Holds Signal Bus, Reflex Scheduler, Process Manager, Workflow Manager. Never loads user code directly — all user code runs in isolated Workers. |
+| **Daemon** | The `nerve-daemon` package — engine runtime. Runs as a background process. |
+
+### Architecture Rules
+
+- **Three orthogonal extension points**: Sense (what to compute), Reflex (when to compute), Workflow (what to do)
+- **Process isolation**: One worker per Sense group (long-lived), one per Workflow type (on-demand). Workers never talk to each other.
+- **Causality is one-directional**: External world → Sense → Signal → Reflex → Action + Log. Logs are the end of the chain.
+
+
+
+## Language & Paradigm
+
+### Functional-first
+
+Use `function` + `type`, not `class` + `interface`.
+
+```typescript
+// ✅ Good
+type Signal = {
+  senseId: string;
+  value: unknown;
+  ts: number;
+};
+
+function createSignal(senseId: string, value: unknown): Signal {
+  return { senseId, value, ts: Date.now() };
+}
+
+// ❌ Bad — no class, no interface
+class Signal implements ISignal { ... }
+```
+
+### Rules
+
+| Rule | Description |
+|------|-------------|
+| `type` over `interface` | All type definitions use `type` |
+| `function` over `class` | Pure functions + closures, no class |
+| No `this` | Functions must not depend on `this` context |
+| No inheritance | No `extends`, `implements`, `abstract` |
+| Composition over inheritance | Use function composition |
+| Immutability first | Use `Readonly<T>`, `as const`, avoid mutation |
+| No optional properties | Use `T \| null` instead of `?:` — see below |
+
+### Exceptions
+
+Classes are allowed when:
+- Required by a third-party library (e.g. Drizzle's `sqliteTable`)
+- Error subclasses (`class NerveError extends Error`)
+
+### No Optional Properties
+
+Never use `?:`. All nullable fields must be explicit `T | null`.
+
+```typescript
+// ✅ Good
+type SenseConfig = {
+  group: string;
+  throttle: string | null;
+  timeout: string | null;
+};
+
+// ❌ Bad
+type SenseConfig = {
+  group: string;
+  throttle?: string;
+  timeout?: string;
+};
+```
+
+For mutually exclusive fields, use discriminated unions:
+
+```typescript
+// ✅ Good
+type ReflexConfig =
+  | { kind: "sense"; sense: string; interval: string | null; on: string[] | null }
+  | { kind: "workflow"; workflow: string; on: string[] | null };
+```
+
+## Modules & Exports
+
+- Always named exports, never default exports
+- One module = one responsibility, filename = purpose
+
+```typescript
+// ✅ Named exports only
+export function startEngine(config: EngineConfig): Engine { ... }
+export type EngineConfig = { ... };
+
+// ❌ No default exports
+export default function startEngine() { ... }
+```
+
+## Naming
+
+| Type | Style | Example |
+|------|-------|---------|
+| Files | kebab-case | `signal-bus.ts` |
+| Types | PascalCase | `SignalBus` |
+| Functions/variables | camelCase | `createSignalBus` |
+| Constants | UPPER_SNAKE | `MAX_RETRY_COUNT` |
+| Generics | Single letter or descriptive | `T`, `TValue` |
+
+## Error Handling
+
+- Use `Result` type for expected failures
+- `throw` only for unrecoverable bugs (programmer errors)
+- No try-catch for flow control
+
+```typescript
+type Result<T, E = Error> = { ok: true; value: T } | { ok: false; error: E };
+
+function parseSenseConfig(raw: unknown): Result<SenseConfig> { ... }
+```
+
+## Async
+
+- Always `async/await`, never `.then()` chains
+
+## Toolchain
+
+| Tool | Purpose |
+|------|---------|
+| **pnpm** | Package manager |
+| **TypeScript** | Type checking (strict mode) |
+| **Biome** | Lint + format (replaces ESLint + Prettier) |
+| **tsup** | Bundling |
+
+### Commands
+
+```bash
+pnpm run check      # biome check (lint + format)
+pnpm run format     # biome format --write
+pnpm run build      # full build
+pnpm test           # run tests
+```
+
+## Monorepo Structure
+
+```
+nerve/
+  packages/
+    core/           # @nerve/core — shared types and utils
+    cli/            # @nerve/cli — CLI entry point
+    daemon/         # @nerve/daemon — engine runtime
+  docs/             # RFCs, conventions
+  biome.json        # root Biome config
+  tsconfig.json     # root TypeScript config (composite project references)
+```
+
+- `core` is the shared layer; `cli` and `daemon` both depend on it
+- `cli` and `daemon` must NOT depend on each other
+
+## Commit Convention
+
+```
+<type>(<scope>): <description>
+
+type: feat | fix | refactor | docs | chore | test
+scope: core | cli | daemon | rfc-001 | ...
+```

.github/copilot-instructions.md

@@ -0,0 +1,180 @@
+# Nerve Coding Conventions
+
+## Core Concepts
+
+```
+External World → Sense → Signal → Reflex → Workflow → Log
+                  ↑                                     ↑
+              "what to observe"                  "what to do"
+```
+
+**Nerve** is a lightweight observation engine daemon for autonomous agents. It continuously observes external state, reacts to changes via declarative rules, and orchestrates multi-step workflows.
+
+### Key Terms
+
+| Concept | What it is |
+|---------|-----------|
+| **Sense** | A `compute()` function that samples or derives data. Returns `T \| null` — non-null emits a Signal, null is silent. Each Sense has its own SQLite database. |
+| **Signal** | A notification emitted when a Sense returns non-null. Pure fact, no intent. Distributed via an in-memory Signal Bus. Not persisted. |
+| **Reflex** | A declarative trigger (YAML) connecting Senses to actions. Trigger types: `interval` (periodic), `on` (react to Signals). Action types: trigger a Sense, or start a Workflow. |
+| **Workflow** | A stateful multi-step execution. Contains **Roles** (actors with side effects) and a **Moderator** (pure router). Each instance is a **Thread** with a unique `runId`. |
+| **Log** | Immutable audit trail. Records executions, state transitions, errors. **Cannot trigger Reflexes** — prevents feedback loops. |
+| **Engine** | The kernel orchestrating everything. Holds Signal Bus, Reflex Scheduler, Process Manager, Workflow Manager. Never loads user code directly — all user code runs in isolated Workers. |
+| **Daemon** | The `nerve-daemon` package — engine runtime. Runs as a background process. |
+
+### Architecture Rules
+
+- **Three orthogonal extension points**: Sense (what to compute), Reflex (when to compute), Workflow (what to do)
+- **Process isolation**: One worker per Sense group (long-lived), one per Workflow type (on-demand). Workers never talk to each other.
+- **Causality is one-directional**: External world → Sense → Signal → Reflex → Action + Log. Logs are the end of the chain.
+
+
+
+## Language & Paradigm
+
+### Functional-first
+
+Use `function` + `type`, not `class` + `interface`.
+
+```typescript
+// ✅ Good
+type Signal = {
+  senseId: string;
+  value: unknown;
+  ts: number;
+};
+
+function createSignal(senseId: string, value: unknown): Signal {
+  return { senseId, value, ts: Date.now() };
+}
+
+// ❌ Bad — no class, no interface
+class Signal implements ISignal { ... }
+```
+
+### Rules
+
+| Rule | Description |
+|------|-------------|
+| `type` over `interface` | All type definitions use `type` |
+| `function` over `class` | Pure functions + closures, no class |
+| No `this` | Functions must not depend on `this` context |
+| No inheritance | No `extends`, `implements`, `abstract` |
+| Composition over inheritance | Use function composition |
+| Immutability first | Use `Readonly<T>`, `as const`, avoid mutation |
+| No optional properties | Use `T \| null` instead of `?:` — see below |
+
+### Exceptions
+
+Classes are allowed when:
+- Required by a third-party library (e.g. Drizzle's `sqliteTable`)
+- Error subclasses (`class NerveError extends Error`)
+
+### No Optional Properties
+
+Never use `?:`. All nullable fields must be explicit `T | null`.
+
+```typescript
+// ✅ Good
+type SenseConfig = {
+  group: string;
+  throttle: string | null;
+  timeout: string | null;
+};
+
+// ❌ Bad
+type SenseConfig = {
+  group: string;
+  throttle?: string;
+  timeout?: string;
+};
+```
+
+For mutually exclusive fields, use discriminated unions:
+
+```typescript
+// ✅ Good
+type ReflexConfig =
+  | { kind: "sense"; sense: string; interval: string | null; on: string[] | null }
+  | { kind: "workflow"; workflow: string; on: string[] | null };
+```
+
+## Modules & Exports
+
+- Always named exports, never default exports
+- One module = one responsibility, filename = purpose
+
+## Naming
+
+| Type | Style | Example |
+|------|-------|---------|
+| Files | kebab-case | `signal-bus.ts` |
+| Types | PascalCase | `SignalBus` |
+| Functions/variables | camelCase | `createSignalBus` |
+| Constants | UPPER_SNAKE | `MAX_RETRY_COUNT` |
+| Generics | Single letter or descriptive | `T`, `TValue` |
+
+## Error Handling
+
+- Use `Result` type for expected failures
+- `throw` only for unrecoverable bugs (programmer errors)
+- No try-catch for flow control
+
+```typescript
+type Result<T, E = Error> = { ok: true; value: T } | { ok: false; error: E };
+```
+
+## Async
+
+- Always `async/await`, never `.then()` chains
+
+## No Dynamic Import
+
+Do NOT use `await import()` in production code. Always use static top-level `import`.
+
+Exceptions (must include a comment):
+1. `sense-runtime.ts` — user module paths known only at runtime
+2. `workflow-worker.ts` — user module paths known only at runtime
+
+Test files (`__tests__/**`) are exempt.
+
+## Toolchain
+
+| Tool | Purpose |
+|------|---------|
+| **pnpm** | Package manager |
+| **TypeScript** | Type checking (strict mode) |
+| **Biome** | Lint + format (replaces ESLint + Prettier) |
+| **tsup** | Bundling |
+
+### Commands
+
+```bash
+pnpm run check      # biome check (lint + format)
+pnpm run format     # biome format --write
+pnpm run build      # full build
+pnpm test           # run tests
+```
+
+## Monorepo Structure
+
+```
+nerve/
+  packages/
+    core/           # @nerve/core — shared types and utils
+    cli/            # @nerve/cli — CLI entry point
+    daemon/         # @nerve/daemon — engine runtime
+  docs/             # RFCs, conventions
+```
+
+- `core` is the shared layer; `cli` and `daemon` both depend on it
+- `cli` and `daemon` must NOT depend on each other
+
+## Commit Convention
+
+```
+<type>(<scope>): <description>
+
+type: feat | fix | refactor | docs | chore | test
+scope: core | cli | daemon | rfc-001 | ...
+```

CLAUDE.md

@@ -0,0 +1,180 @@
+# Nerve Coding Conventions
+
+## Core Concepts
+
+```
+External World → Sense → Signal → Reflex → Workflow → Log
+                  ↑                                     ↑
+              "what to observe"                  "what to do"
+```
+
+**Nerve** is a lightweight observation engine daemon for autonomous agents. It continuously observes external state, reacts to changes via declarative rules, and orchestrates multi-step workflows.
+
+### Key Terms
+
+| Concept | What it is |
+|---------|-----------|
+| **Sense** | A `compute()` function that samples or derives data. Returns `T \| null` — non-null emits a Signal, null is silent. Each Sense has its own SQLite database. |
+| **Signal** | A notification emitted when a Sense returns non-null. Pure fact, no intent. Distributed via an in-memory Signal Bus. Not persisted. |
+| **Reflex** | A declarative trigger (YAML) connecting Senses to actions. Trigger types: `interval` (periodic), `on` (react to Signals). Action types: trigger a Sense, or start a Workflow. |
+| **Workflow** | A stateful multi-step execution. Contains **Roles** (actors with side effects) and a **Moderator** (pure router). Each instance is a **Thread** with a unique `runId`. |
+| **Log** | Immutable audit trail. Records executions, state transitions, errors. **Cannot trigger Reflexes** — prevents feedback loops. |
+| **Engine** | The kernel orchestrating everything. Holds Signal Bus, Reflex Scheduler, Process Manager, Workflow Manager. Never loads user code directly — all user code runs in isolated Workers. |
+| **Daemon** | The `nerve-daemon` package — engine runtime. Runs as a background process. |
+
+### Architecture Rules
+
+- **Three orthogonal extension points**: Sense (what to compute), Reflex (when to compute), Workflow (what to do)
+- **Process isolation**: One worker per Sense group (long-lived), one per Workflow type (on-demand). Workers never talk to each other.
+- **Causality is one-directional**: External world → Sense → Signal → Reflex → Action + Log. Logs are the end of the chain.
+
+
+
+## Language & Paradigm
+
+### Functional-first
+
+Use `function` + `type`, not `class` + `interface`.
+
+```typescript
+// ✅ Good
+type Signal = {
+  senseId: string;
+  value: unknown;
+  ts: number;
+};
+
+function createSignal(senseId: string, value: unknown): Signal {
+  return { senseId, value, ts: Date.now() };
+}
+
+// ❌ Bad — no class, no interface
+class Signal implements ISignal { ... }
+```
+
+### Rules
+
+| Rule | Description |
+|------|-------------|
+| `type` over `interface` | All type definitions use `type` |
+| `function` over `class` | Pure functions + closures, no class |
+| No `this` | Functions must not depend on `this` context |
+| No inheritance | No `extends`, `implements`, `abstract` |
+| Composition over inheritance | Use function composition |
+| Immutability first | Use `Readonly<T>`, `as const`, avoid mutation |
+| No optional properties | Use `T \| null` instead of `?:` — see below |
+
+### Exceptions
+
+Classes are allowed when:
+- Required by a third-party library (e.g. Drizzle's `sqliteTable`)
+- Error subclasses (`class NerveError extends Error`)
+
+### No Optional Properties
+
+Never use `?:`. All nullable fields must be explicit `T | null`.
+
+```typescript
+// ✅ Good
+type SenseConfig = {
+  group: string;
+  throttle: string | null;
+  timeout: string | null;
+};
+
+// ❌ Bad
+type SenseConfig = {
+  group: string;
+  throttle?: string;
+  timeout?: string;
+};
+```
+
+For mutually exclusive fields, use discriminated unions:
+
+```typescript
+// ✅ Good
+type ReflexConfig =
+  | { kind: "sense"; sense: string; interval: string | null; on: string[] | null }
+  | { kind: "workflow"; workflow: string; on: string[] | null };
+```
+
+## Modules & Exports
+
+- Always named exports, never default exports
+- One module = one responsibility, filename = purpose
+
+## Naming
+
+| Type | Style | Example |
+|------|-------|---------|
+| Files | kebab-case | `signal-bus.ts` |
+| Types | PascalCase | `SignalBus` |
+| Functions/variables | camelCase | `createSignalBus` |
+| Constants | UPPER_SNAKE | `MAX_RETRY_COUNT` |
+| Generics | Single letter or descriptive | `T`, `TValue` |
+
+## Error Handling
+
+- Use `Result` type for expected failures
+- `throw` only for unrecoverable bugs (programmer errors)
+- No try-catch for flow control
+
+```typescript
+type Result<T, E = Error> = { ok: true; value: T } | { ok: false; error: E };
+```
+
+## Async
+
+- Always `async/await`, never `.then()` chains
+
+## No Dynamic Import
+
+Do NOT use `await import()` in production code. Always use static top-level `import`.
+
+Exceptions (must include a comment):
+1. `sense-runtime.ts` — user module paths known only at runtime
+2. `workflow-worker.ts` — user module paths known only at runtime
+
+Test files (`__tests__/**`) are exempt.
+
+## Toolchain
+
+| Tool | Purpose |
+|------|---------|
+| **pnpm** | Package manager |
+| **TypeScript** | Type checking (strict mode) |
+| **Biome** | Lint + format (replaces ESLint + Prettier) |
+| **tsup** | Bundling |
+
+### Commands
+
+```bash
+pnpm run check      # biome check (lint + format)
+pnpm run format     # biome format --write
+pnpm run build      # full build
+pnpm test           # run tests
+```
+
+## Monorepo Structure
+
+```
+nerve/
+  packages/
+    core/           # @nerve/core — shared types and utils
+    cli/            # @nerve/cli — CLI entry point
+    daemon/         # @nerve/daemon — engine runtime
+  docs/             # RFCs, conventions
+```
+
+- `core` is the shared layer; `cli` and `daemon` both depend on it
+- `cli` and `daemon` must NOT depend on each other
+
+## Commit Convention
+
+```
+<type>(<scope>): <description>
+
+type: feat | fix | refactor | docs | chore | test
+scope: core | cli | daemon | rfc-001 | ...
+```

packages/cli/package.json

@@ -3,7 +3,7 @@
   "engines": {
     "node": ">=22.5.0"
   },
-  "version": "0.1.8",
+  "version": "0.2.0",
   "type": "module",
   "bin": {
     "nerve": "dist/cli.js"

packages/cli/src/cli.ts

@@ -12,6 +12,26 @@ import { storeCommand } from "./commands/store.js";
 import { validateCommand } from "./commands/validate.js";
 import { workflowCommand } from "./commands/workflow.js";
 
+/**
+ * Citty picks the first non-flag token as a subcommand name. Rewrite
+ * `nerve init --from <url>` so the URL is not mistaken for `workflow`/`workspace`.
+ */
+function normalizeNerveArgv(argv: string[]): string[] {
+  const initIdx = argv.indexOf("init");
+  if (initIdx === -1) return argv;
+  const tail = argv.slice(initIdx + 1);
+  const fromAt = tail.indexOf("--from");
+  if (fromAt === -1) return argv;
+  const beforeFrom = tail.slice(0, fromAt);
+  if (beforeFrom.some((a) => !a.startsWith("-"))) return argv;
+  const next = tail[fromAt + 1];
+  if (next === undefined || next.startsWith("-")) return argv;
+  const reserved = new Set(["workflow", "workspace"]);
+  if (reserved.has(next)) return argv;
+  const mergedTail = [...tail.slice(0, fromAt), `--from=${next}`, ...tail.slice(fromAt + 2)];
+  return [...argv.slice(0, initIdx + 1), ...mergedTail];
+}
+
 const main = defineCommand({
   meta: {
     name: "nerve",
@@ -32,4 +52,4 @@ const main = defineCommand({
   },
 });
 
-runMain(main);
+runMain(main, { rawArgs: normalizeNerveArgv(process.argv.slice(2)) });

packages/cli/src/commands/init.ts

@@ -1,5 +1,5 @@
 import { execFile, spawn } from "node:child_process";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { promisify } from "node:util";
 
@@ -236,6 +236,76 @@ async function verifyNodeSqlite(): Promise<boolean> {
   }
 }
 
+function isNerveRootNonEmpty(nerveRoot: string): boolean {
+  if (!existsSync(nerveRoot)) return false;
+  return readdirSync(nerveRoot).length > 0;
+}
+
+async function runInitFromGit(url: string): Promise<void> {
+  const trimmed = url.trim();
+  if (trimmed.length === 0) {
+    process.stderr.write("❌ --from requires a non-empty git URL.\n");
+    process.exit(1);
+  }
+
+  const nerveRoot = getNerveRoot();
+  if (isNerveRootNonEmpty(nerveRoot)) {
+    process.stderr.write(
+      `❌ ${nerveRoot} already exists and is not empty. Remove it (or empty it) before using --from.\n`,
+    );
+    process.exit(1);
+  }
+
+  try {
+    await execFileAsync("git", ["--version"]);
+  } catch {
+    process.stderr.write("❌ git is not available. Install git and retry.\n");
+    process.exit(1);
+  }
+
+  try {
+    await execFileAsync("pnpm", ["--version"]);
+  } catch {
+    process.stderr.write("❌ pnpm is not available. Install pnpm and retry.\n");
+    process.exit(1);
+  }
+
+  process.stdout.write(`Cloning ${trimmed} → ${nerveRoot} …\n`);
+  try {
+    await runCommand("git", ["clone", trimmed, nerveRoot], process.cwd());
+  } catch {
+    process.stderr.write("❌ git clone failed.\n");
+    process.exit(1);
+  }
+
+  if (!existsSync(join(nerveRoot, "nerve.yaml"))) {
+    process.stdout.write(`⚠️ ${join(nerveRoot, "nerve.yaml")} not found after clone.\n`);
+  }
+  if (!existsSync(join(nerveRoot, "package.json"))) {
+    process.stdout.write(`⚠️ ${join(nerveRoot, "package.json")} not found after clone.\n`);
+  }
+
+  process.stdout.write("Installing dependencies with pnpm …\n");
+  try {
+    await runCommand("pnpm", ["install", "--no-cache"], nerveRoot);
+  } catch {
+    process.stdout.write(
+      `⚠️ pnpm install failed. Try manually:\n   cd ${nerveRoot} && pnpm install --no-cache\n`,
+    );
+  }
+
+  if (!(await verifyNodeSqlite())) {
+    process.stdout.write(
+      "⚠️ Built-in SQLite (node:sqlite) is not available in this Node.js build. " +
+        "The daemon requires Node.js 22.5 or newer with SQLite enabled.\n",
+    );
+  }
+
+  process.stdout.write(
+    `✅ Workspace cloned to ${nerveRoot}\n\n💡 Next steps:\n   1. Review nerve.yaml and install any missing tooling.\n   2. Run \`nerve start\` to launch the daemon.\n`,
+  );
+}
+
 async function runInitWorkspace(force: boolean): Promise<void> {
   const nerveRoot = getNerveRoot();
 
@@ -294,7 +364,7 @@ export const initCommand = defineCommand({
   meta: {
     name: "init",
     description:
-      "Initialize workspace (nerve init) or scaffold templates (nerve init workflow <name>)",
+      "Initialize workspace (nerve init), clone from git (nerve init --from <url>), or scaffold templates (nerve init workflow <name>)",
   },
   args: {
     force: {
@@ -302,12 +372,21 @@ export const initCommand = defineCommand({
       description: "Reinitialize even if workspace already exists (preserves data/)",
       default: false,
     },
+    from: {
+      type: "string",
+      description: "Clone an existing git repo into ~/.uncaged-nerve instead of scaffolding",
+      required: false,
+    },
   },
   subCommands: {
     workflow: initWorkflowCommand,
     workspace: initWorkspaceCommand,
   },
   async run({ args }) {
+    if (args.from !== undefined) {
+      await runInitFromGit(String(args.from));
+      return;
+    }
     await runInitWorkspace(args.force);
   },
 });

packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uncaged/nerve-core",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "type": "module",
   "main": "dist/index.js",
   "files": [

packages/daemon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uncaged/nerve-daemon",
-  "version": "0.1.5",
+  "version": "0.2.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

packages/daemon/src/workflow-worker.ts

@@ -120,8 +120,7 @@ async function runThread(
 
   const initialEvent: CommandEvent = {
     type: "thread_start",
-    triggerPayload:
-      triggerPayload != null && typeof triggerPayload === "object" ? triggerPayload : {},
+    triggerPayload: triggerPayload ?? {},
   };
 
   // On resume: replay persisted events, run the next un-executed role, then continue.