diff --git a/AGENTS.md b/AGENTS.md
index 0f445b3..ba83e2d 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -1,3 +1,389 @@
 # pgconductor
 
-Read @CLAUDE.md
+A durable task execution system built on PostgreSQL.
+
+> **Important**: Keep this documentation up-to-date. When making architectural changes, refactoring core components, or introducing new patterns worth mentioning, update this file accordingly.
+
+## Project Structure
+
+```
+pgconductor/
+├── justfile                          # Command runner (use `just` for all commands)
+├── migrations/
+│   └── 0000000001_setup.sql          # Core schema, tables, SQL functions
+└── packages/
+    └── pgconductor-js/
+        ├── src/
+        │   ├── conductor.ts          # Task registry and invocation entry point
+        │   ├── orchestrator.ts       # Worker lifecycle manager
+        │   ├── worker.ts             # Fetch→execute→flush pipeline
+        │   ├── task.ts               # Task wrapper with execute method
+        │   ├── task-definition.ts    # Zod-based task definitions
+        │   ├── task-context.ts       # Context API (step, sleep, invoke)
+        │   ├── database-client.ts    # PostgreSQL client wrapper
+        │   ├── lib/                  # Utilities (deferred, async-queue, etc.)
+        │   └── generated/
+        │       └── sql.ts            # Auto-generated types from SQL
+        └── tests/
+            ├── unit/                 # Unit tests for utilities (no DB)
+            ├── integration/          # End-to-end tests with real DB
+            └── fixtures/             # Test utilities (TestDatabasePool)
+```
+
+## Development Workflow
+
+### Command Runner
+
+Use `just` for all project commands (defined in `justfile`):
+
+```bash
+just build-migrations              # Rebuild TypeScript types from migrations
+```
+
+### Running Tests
+
+Tests use Bun test runner. **Always run typecheck with tests:**
+
+```bash
+bun test && bun run typecheck      # Run tests and type checking (ALWAYS)
+bun test                           # All tests (unit + integration)
+bun test tests/unit/               # Unit tests only
+bun test tests/integration/        # Integration tests only
+```
+
+**Unit Tests** (`tests/unit/`)
+- Test utility functions in isolation (no database required)
+- Examples: `deferred.test.ts`, `map-concurrent.test.ts`, `async-queue.test.ts`, `wait-for.test.ts`
+- Fast, no setup required
+
+```typescript
+import { test, expect } from "bun:test";
+import { Deferred } from "../../../src/lib/deferred";
+
+test("deferred resolves", async () => {
+  const deferred = new Deferred<number>();
+  deferred.resolve(42);
+  expect(await deferred.promise).toBe(42);
+});
+```
+
+**Integration Tests** (`tests/integration/`)
+- Test end-to-end workflows with real PostgreSQL database
+- Examples: `basic-execution.test.ts`, `step-support.test.ts`, `invoke-support.test.ts`
+- Use `TestDatabasePool` fixture for isolated database instances
+
+```typescript
+import { TestDatabasePool } from "../fixtures/test-database";
+
+let pool: TestDatabasePool;
+
+beforeAll(async () => {
+  pool = await TestDatabasePool.create();
+}, 60000);
+
+afterAll(async () => {
+  await pool?.destroy();
+});
+
+test("example", async () => {
+  const db = await pool.child();  // Isolated connection
+
+  // Create conductor and task
+  const conductor = Conductor.create({
+    sql: db.sql,
+    tasks: TaskSchemas.fromSchema([taskDefinition]),
+    context: {},
+  });
+
+  conductor.createTask(
+    { name: "example-task" },
+    { invocable: true },
+    async (event, _ctx) => { /* handler */ },
+  );
+
+  // Initialize schema before invoking tasks
+  await conductor.ensureInstalled();
+
+  // Now safe to invoke tasks
+  await conductor.invoke({ name: "example-task" }, {});
+});
+```
+
+**Important**: Integration tests must call `await conductor.ensureInstalled()` before invoking tasks. This initializes the database schema (tables, functions, etc.). Without this, `conductor.invoke()` will fail with "schema pgconductor does not exist".
+
+### Modifying Migrations
+
+1. Edit `migrations/0000000001_setup.sql` directly (in-place)
+2. Run `just build-migrations` to regenerate types
+3. Run tests to verify changes
+
+**Note**: This project is under active development. All SQL changes should be made **in-place** by editing the existing migration file, not by creating new migration files.
+
+The migration file contains:
+- Table schemas (`tasks`, `executions`, `steps`, `failed_executions`, `test_config`)
+- SQL functions (all logic is in SQL, not application code)
+- Indexes
+
+**Note**: The `test_config` table is used for testing purposes (e.g., controlling time with `fake_now`).
+
+## Architecture
+
+### Core Components
+
+**Worker** (`worker.ts`)
+- Implements async pipeline: fetch → execute → flush
+- Polls database for ready executions using `get_executions()`
+- Executes tasks with concurrency control (via `mapConcurrent`)
+- Batches and flushes results back to database
+- Handles graceful shutdown via AbortController
+
+**TaskContext** (`task-context.ts`)
+- Provides API to task functions: `step()`, `sleep()`, `invoke()`
+- All operations are idempotent (use steps as memoization)
+- Hangup pattern: abort execution and return never-resolving promise
+- Resume happens automatically when database wakes execution
+
+**Conductor** (`conductor.ts`)
+- Task registry and factory
+- Entry point for invoking tasks
+- Manages database client lifecycle
+
+**Orchestrator** (`orchestrator.ts`)
+- Manages multiple workers
+- Handles startup/shutdown coordination
+- Provides `stopped` promise for graceful shutdown
+
+**DatabaseClient** (`database-client.ts`)
+- Wraps all SQL function calls for easier unit testing and mocking
+- All SQL functions are called through this interface
+- Example: `db.getExecutions()`, `db.returnExecutions()`, `db.invoke()`
+
+### SQL Functions
+
+**Important**: Keep durability, claiming, and atomic state transitions in Postgres. Use TypeScript for validation and multi-query orchestration through `DatabaseClient` transactions.
+
+SQL functions in `migrations/0000000001_setup.sql`:
+- `get_executions()`: Fetch and claim ready executions
+- `return_executions()`: Process results (completed/failed/released)
+- `invoke()`: Create child execution and set parent waiting state
+- `backoff_seconds()`: Return retry delay based on attempt number
+- Helper functions: `current_time()`, `portable_uuidv7()`, etc.
+
+### Key Design Patterns
+
+**Hangup/Resume**
+- When a task calls `ctx.sleep()` or `ctx.invoke()`, the worker aborts the task
+- The execution remains in the database with updated `run_at` or `waiting_on_execution_id`
+- Worker polls and resumes execution when ready
+- Steps provide memoization across hangups
+
+**Step Memoization**
+- `ctx.step(name, fn)` checks if step exists in database before executing
+- If exists, returns cached result
+- If not, executes fn and saves result
+- This enables idempotent retries and resume after hangup
+
+**Cascade Failures**
+- When child fails permanently (attempts >= max_attempts), parent is moved to `failed_executions`
+- Implemented in `return_executions()` via `permanently_failed_children` CTE
+- Parent receives error like "Child execution failed: <child_error>"
+
+**Infinity Pattern**
+- PostgreSQL `'infinity'::timestamptz` for indefinite waiting
+- Used when `invoke()` called without timeout
+- Parent waits forever until child completes
+
+### Task Configuration Options
+
+Tasks accept a configuration object with these options:
+
+```typescript
+conductor.createTask(
+  {
+    name: "my-task",
+    queue: "default",      // Queue name (default: "default")
+    maxAttempts: 3,        // Max retry attempts before permanent failure (default: from DB)
+    flushInterval: 2000,   // How often to flush results to DB in ms (default: 2000)
+    pollInterval: 1000,    // How often to poll for new executions in ms (default: 1000)
+    partition: false,      // Enable partitioning (default: false)
+    window: ["09:00", "17:00"],  // Time window for execution [start, end]
+  },
+  handler,
+);
+```
+
+**Note**: Lower `pollInterval` values (e.g., 100ms) are useful in tests for faster execution cycles.
+
+## Query Optimization Principles
+
+Guidelines for SQL functions:
+
+1. **Filter before joining**: Apply WHERE on small result sets before joining large tables
+   ```sql
+   -- Good: filter results first (0-1 rows), then join to find parent
+   FROM results r
+   WHERE r.status = 'completed'
+   JOIN pgconductor.executions parent_e ON parent_e.waiting_on_execution_id = r.execution_id
+   ```
+
+2. **Materialize expensive operations**: Use CTEs to compute once and reuse
+   ```sql
+   permanently_failed_children AS (
+     SELECT r.execution_id, r.error
+     FROM results r
+     JOIN pgconductor.executions e ON e.id = r.execution_id
+     JOIN pgconductor.tasks w ON w.key = e.task_key
+     WHERE r.status = 'failed' AND e.attempts >= w.max_attempts
+   )
+   -- Reuse in multiple places without recomputing join
+   ```
+
+3. **Prefer SQL functions with CTEs over plpgsql**: CTEs are declarative and easier to optimize
+
+4. **Target foreign keys**: Use cascading foreign keys for cold configuration and metadata tables. Avoid adding foreign keys to hot execution tables; maintain those relationships in application/SQL logic.
+
+## Common Development Tasks
+
+### Adding New Context Method
+
+1. Add method to `TaskContext` class in `task-context.ts`
+2. Implement using steps/database operations
+3. Add integration test in `tests/integration/`
+4. Update documentation
+
+### Adding New SQL Function
+
+1. Add function to `migrations/0000000001_setup.sql`
+2. Run `just build-migrations` to regenerate types
+3. Update `database-client.ts` if wrapper needed
+4. Add tests
+
+### Debugging Test Failures
+
+Common issues:
+- **Timing issues**: Increase wait times (backoff schedule is 15s, 30s, 60s...)
+- **Cascade failures**: Check `permanently_failed_children` CTE logic
+- **Infinity serialization**: postgres.js serializes infinity as null in JSON
+
+Use `console.log()` in tests to inspect database state:
+```typescript
+const rows = await db.sql`SELECT * FROM pgconductor.executions`;
+console.log(JSON.stringify(rows, null, 2));
+```
+
+### Controlling Time in Tests
+
+The `pgconductor.current_time()` function checks `current_setting('pgconductor.fake_now')` before returning the real time. This allows tests to control time without waiting:
+
+```typescript
+// Test databases use max: 1 connection pool (see TestDatabase.create())
+// This ensures all queries share the same connection and see the same fake time
+
+// Set fake time before starting orchestrator
+const fakeTime = new Date("2024-01-01T12:00:00Z");
+await db.client.setFakeTime(fakeTime);
+
+// Now all operations use fake time
+await db.sql`SELECT pgconductor.current_time()`; // Returns 2024-01-01 12:00:00
+
+// Advance time by 1 hour (works immediately with session-level SET)
+const laterTime = new Date(fakeTime.getTime() + 3600000);
+await db.client.setFakeTime(laterTime);
+
+// Reset to real time
+await db.client.clearFakeTime();
+```
+
+**How it works:**
+- Each test creates an isolated database via `pool.child()`
+- The database connection uses `max: 1` pool size
+- All queries (test, conductor, worker) share the same connection
+- `setFakeTime()` uses session-level `SET pgconductor.fake_now`
+- Since everyone shares the connection, everyone sees the same time
+
+This is particularly useful for testing:
+- Sleep/delayed executions
+- Timeouts
+- Backoff schedules
+- Time-based windows
+
+**Note**: Always clean up fake_now at the end of tests to avoid affecting other tests.
+
+---
+
+## Planned Changes
+
+### Queue System (In Progress)
+
+See **QUEUE-IMPLEMENTATION-PLAN.md** for detailed implementation plan.
+
+**Goal**: Transition from one-worker-per-task to queue-based worker model with explicit partitioning and batch processing.
+
+**Key Changes**:
+- Tasks will have a `queue` field (defaults to "default")
+- Workers operate on queues (handling multiple tasks)
+- Explicit `createWorker(queueName, settings, tasks)` API
+- Auto-provisioned default queue with zero config
+- Task-level batching support
+
+**Status**: Phase 1 complete (type system updates) ✅
+
+---
+
+## Development Environment
+
+### Bun Runtime
+
+This project uses Bun for running TypeScript, tests, and package management.
+
+```bash
+# Package management
+bun install                        # Install dependencies
+
+# Running code
+bun <file.ts>                      # Run TypeScript directly
+bun run <script>                   # Run package.json script
+
+# Testing
+bun test                           # Run all tests
+bun test tests/unit/               # Run unit tests
+bun test tests/integration/        # Run integration tests
+```
+
+### Code Quality
+
+- **Console logs**: Always remove debug `console.log()` statements before committing
+- **Tests**: Ensure all tests pass and clean up resources (database connections, fake_now, etc.)
+- **Type checking**: Always run both tests AND typecheck together:
+  ```bash
+  bun run typecheck && bun test
+  ```
+**Format**: Ensure the code follows the formatting guidelines:
+```bash
+just format
+```
+**Linter**: Ensure the code does not emit any lint warnings:
+```bash
+just lint-fix
+```
+
+### Code Style Guidelines
+
+**TypeScript**:
+- **Array types**: Always use `T[]` syntax, never `Array<T>`
+  ```typescript
+  // ✅ Correct
+  const tasks: Task[] = [];
+  function process(items: string[]): number[] { }
+
+  // ❌ Wrong
+  const tasks: Array<Task> = [];
+  function process(items: Array<string>): Array<number> { }
+  ```
+- always add AGENT=1 as an env var when running anything
+- always use lower-case when writing SQL, also for keywords
+- prefer || ofer ?? in typescript. good: runAtMs || null. bad: runAtMs ?? null
+- NEVER use `as unknown` or `as any`
+- never use `!` in typescript
+- Always use "Postgres Conductor" when referring to this project
+- Always use "Postgres" over "PostgreSQL"
\ No newline at end of file
diff --git a/CLAUDE.md b/CLAUDE.md
deleted file mode 100644
index 295ee63..0000000
--- a/CLAUDE.md
+++ /dev/null
@@ -1,389 +0,0 @@
-# pgconductor
-
-A durable task execution system built on PostgreSQL.
-
-> **Important**: Keep this documentation up-to-date. When making architectural changes, refactoring core components, or introducing new patterns worth mentioning, update this file accordingly.
-
-## Project Structure
-
-```
-pgconductor/
-├── justfile                          # Command runner (use `just` for all commands)
-├── migrations/
-│   └── 0000000001_setup.sql          # Core schema, tables, SQL functions
-└── packages/
-    └── pgconductor-js/
-        ├── src/
-        │   ├── conductor.ts          # Task registry and invocation entry point
-        │   ├── orchestrator.ts       # Worker lifecycle manager
-        │   ├── worker.ts             # Fetch→execute→flush pipeline
-        │   ├── task.ts               # Task wrapper with execute method
-        │   ├── task-definition.ts    # Zod-based task definitions
-        │   ├── task-context.ts       # Context API (step, sleep, invoke)
-        │   ├── database-client.ts    # PostgreSQL client wrapper
-        │   ├── lib/                  # Utilities (deferred, async-queue, etc.)
-        │   └── generated/
-        │       └── sql.ts            # Auto-generated types from SQL
-        └── tests/
-            ├── unit/                 # Unit tests for utilities (no DB)
-            ├── integration/          # End-to-end tests with real DB
-            └── fixtures/             # Test utilities (TestDatabasePool)
-```
-
-## Development Workflow
-
-### Command Runner
-
-Use `just` for all project commands (defined in `justfile`):
-
-```bash
-just build-migrations              # Rebuild TypeScript types from migrations
-```
-
-### Running Tests
-
-Tests use Bun test runner. **Always run typecheck with tests:**
-
-```bash
-bun test && bun run typecheck      # Run tests and type checking (ALWAYS)
-bun test                           # All tests (unit + integration)
-bun test tests/unit/               # Unit tests only
-bun test tests/integration/        # Integration tests only
-```
-
-**Unit Tests** (`tests/unit/`)
-- Test utility functions in isolation (no database required)
-- Examples: `deferred.test.ts`, `map-concurrent.test.ts`, `async-queue.test.ts`, `wait-for.test.ts`
-- Fast, no setup required
-
-```typescript
-import { test, expect } from "bun:test";
-import { Deferred } from "../../../src/lib/deferred";
-
-test("deferred resolves", async () => {
-  const deferred = new Deferred<number>();
-  deferred.resolve(42);
-  expect(await deferred.promise).toBe(42);
-});
-```
-
-**Integration Tests** (`tests/integration/`)
-- Test end-to-end workflows with real PostgreSQL database
-- Examples: `basic-execution.test.ts`, `step-support.test.ts`, `invoke-support.test.ts`
-- Use `TestDatabasePool` fixture for isolated database instances
-
-```typescript
-import { TestDatabasePool } from "../fixtures/test-database";
-
-let pool: TestDatabasePool;
-
-beforeAll(async () => {
-  pool = await TestDatabasePool.create();
-}, 60000);
-
-afterAll(async () => {
-  await pool?.destroy();
-});
-
-test("example", async () => {
-  const db = await pool.child();  // Isolated connection
-
-  // Create conductor and task
-  const conductor = Conductor.create({
-    sql: db.sql,
-    tasks: TaskSchemas.fromSchema([taskDefinition]),
-    context: {},
-  });
-
-  conductor.createTask(
-    { name: "example-task" },
-    { invocable: true },
-    async (event, _ctx) => { /* handler */ },
-  );
-
-  // Initialize schema before invoking tasks
-  await conductor.ensureInstalled();
-
-  // Now safe to invoke tasks
-  await conductor.invoke({ name: "example-task" }, {});
-});
-```
-
-**Important**: Integration tests must call `await conductor.ensureInstalled()` before invoking tasks. This initializes the database schema (tables, functions, etc.). Without this, `conductor.invoke()` will fail with "schema pgconductor does not exist".
-
-### Modifying Migrations
-
-1. Edit `migrations/0000000001_setup.sql` directly (in-place)
-2. Run `just build-migrations` to regenerate types
-3. Run tests to verify changes
-
-**Note**: This project is under active development. All SQL changes should be made **in-place** by editing the existing migration file, not by creating new migration files.
-
-The migration file contains:
-- Table schemas (`tasks`, `executions`, `steps`, `failed_executions`, `test_config`)
-- SQL functions (all logic is in SQL, not application code)
-- Indexes
-
-**Note**: The `test_config` table is used for testing purposes (e.g., controlling time with `fake_now`).
-
-## Architecture
-
-### Core Components
-
-**Worker** (`worker.ts`)
-- Implements async pipeline: fetch → execute → flush
-- Polls database for ready executions using `get_executions()`
-- Executes tasks with concurrency control (via `mapConcurrent`)
-- Batches and flushes results back to database
-- Handles graceful shutdown via AbortController
-
-**TaskContext** (`task-context.ts`)
-- Provides API to task functions: `step()`, `sleep()`, `invoke()`
-- All operations are idempotent (use steps as memoization)
-- Hangup pattern: abort execution and return never-resolving promise
-- Resume happens automatically when database wakes execution
-
-**Conductor** (`conductor.ts`)
-- Task registry and factory
-- Entry point for invoking tasks
-- Manages database client lifecycle
-
-**Orchestrator** (`orchestrator.ts`)
-- Manages multiple workers
-- Handles startup/shutdown coordination
-- Provides `stopped` promise for graceful shutdown
-
-**DatabaseClient** (`database-client.ts`)
-- Wraps all SQL function calls for easier unit testing and mocking
-- All SQL functions are called through this interface
-- Example: `db.getExecutions()`, `db.returnExecutions()`, `db.invoke()`
-
-### SQL Functions
-
-**Important**: All core logic lives in PostgreSQL functions (not application code). The TypeScript layer is intentionally thin - it only orchestrates calls to SQL functions via `DatabaseClient`.
-
-SQL functions in `migrations/0000000001_setup.sql`:
-- `get_executions()`: Fetch and claim ready executions
-- `return_executions()`: Process results (completed/failed/released)
-- `invoke()`: Create child execution and set parent waiting state
-- `backoff_seconds()`: Return retry delay based on attempt number
-- Helper functions: `current_time()`, `portable_uuidv7()`, etc.
-
-### Key Design Patterns
-
-**Hangup/Resume**
-- When a task calls `ctx.sleep()` or `ctx.invoke()`, the worker aborts the task
-- The execution remains in the database with updated `run_at` or `waiting_on_execution_id`
-- Worker polls and resumes execution when ready
-- Steps provide memoization across hangups
-
-**Step Memoization**
-- `ctx.step(name, fn)` checks if step exists in database before executing
-- If exists, returns cached result
-- If not, executes fn and saves result
-- This enables idempotent retries and resume after hangup
-
-**Cascade Failures**
-- When child fails permanently (attempts >= max_attempts), parent is moved to `failed_executions`
-- Implemented in `return_executions()` via `permanently_failed_children` CTE
-- Parent receives error like "Child execution failed: <child_error>"
-
-**Infinity Pattern**
-- PostgreSQL `'infinity'::timestamptz` for indefinite waiting
-- Used when `invoke()` called without timeout
-- Parent waits forever until child completes
-
-### Task Configuration Options
-
-Tasks accept a configuration object with these options:
-
-```typescript
-conductor.createTask(
-  {
-    name: "my-task",
-    queue: "default",      // Queue name (default: "default")
-    maxAttempts: 3,        // Max retry attempts before permanent failure (default: from DB)
-    flushInterval: 2000,   // How often to flush results to DB in ms (default: 2000)
-    pollInterval: 1000,    // How often to poll for new executions in ms (default: 1000)
-    partition: false,      // Enable partitioning (default: false)
-    window: ["09:00", "17:00"],  // Time window for execution [start, end]
-  },
-  handler,
-);
-```
-
-**Note**: Lower `pollInterval` values (e.g., 100ms) are useful in tests for faster execution cycles.
-
-## Query Optimization Principles
-
-Guidelines for SQL functions:
-
-1. **Filter before joining**: Apply WHERE on small result sets before joining large tables
-   ```sql
-   -- Good: filter results first (0-1 rows), then join to find parent
-   FROM results r
-   WHERE r.status = 'completed'
-   JOIN pgconductor.executions parent_e ON parent_e.waiting_on_execution_id = r.execution_id
-   ```
-
-2. **Materialize expensive operations**: Use CTEs to compute once and reuse
-   ```sql
-   permanently_failed_children AS (
-     SELECT r.execution_id, r.error
-     FROM results r
-     JOIN pgconductor.executions e ON e.id = r.execution_id
-     JOIN pgconductor.tasks w ON w.key = e.task_key
-     WHERE r.status = 'failed' AND e.attempts >= w.max_attempts
-   )
-   -- Reuse in multiple places without recomputing join
-   ```
-
-3. **Prefer SQL functions with CTEs over plpgsql**: CTEs are declarative and easier to optimize
-
-4. **No foreign keys**: Performance optimization - rely on application/SQL function logic
-
-## Common Development Tasks
-
-### Adding New Context Method
-
-1. Add method to `TaskContext` class in `task-context.ts`
-2. Implement using steps/database operations
-3. Add integration test in `tests/integration/`
-4. Update documentation
-
-### Adding New SQL Function
-
-1. Add function to `migrations/0000000001_setup.sql`
-2. Run `just build-migrations` to regenerate types
-3. Update `database-client.ts` if wrapper needed
-4. Add tests
-
-### Debugging Test Failures
-
-Common issues:
-- **Timing issues**: Increase wait times (backoff schedule is 15s, 30s, 60s...)
-- **Cascade failures**: Check `permanently_failed_children` CTE logic
-- **Infinity serialization**: postgres.js serializes infinity as null in JSON
-
-Use `console.log()` in tests to inspect database state:
-```typescript
-const rows = await db.sql`SELECT * FROM pgconductor.executions`;
-console.log(JSON.stringify(rows, null, 2));
-```
-
-### Controlling Time in Tests
-
-The `pgconductor.current_time()` function checks `current_setting('pgconductor.fake_now')` before returning the real time. This allows tests to control time without waiting:
-
-```typescript
-// Test databases use max: 1 connection pool (see TestDatabase.create())
-// This ensures all queries share the same connection and see the same fake time
-
-// Set fake time before starting orchestrator
-const fakeTime = new Date("2024-01-01T12:00:00Z");
-await db.client.setFakeTime(fakeTime);
-
-// Now all operations use fake time
-await db.sql`SELECT pgconductor.current_time()`; // Returns 2024-01-01 12:00:00
-
-// Advance time by 1 hour (works immediately with session-level SET)
-const laterTime = new Date(fakeTime.getTime() + 3600000);
-await db.client.setFakeTime(laterTime);
-
-// Reset to real time
-await db.client.clearFakeTime();
-```
-
-**How it works:**
-- Each test creates an isolated database via `pool.child()`
-- The database connection uses `max: 1` pool size
-- All queries (test, conductor, worker) share the same connection
-- `setFakeTime()` uses session-level `SET pgconductor.fake_now`
-- Since everyone shares the connection, everyone sees the same time
-
-This is particularly useful for testing:
-- Sleep/delayed executions
-- Timeouts
-- Backoff schedules
-- Time-based windows
-
-**Note**: Always clean up fake_now at the end of tests to avoid affecting other tests.
-
----
-
-## Planned Changes
-
-### Queue System (In Progress)
-
-See **QUEUE-IMPLEMENTATION-PLAN.md** for detailed implementation plan.
-
-**Goal**: Transition from one-worker-per-task to queue-based worker model with explicit partitioning and batch processing.
-
-**Key Changes**:
-- Tasks will have a `queue` field (defaults to "default")
-- Workers operate on queues (handling multiple tasks)
-- Explicit `createWorker(queueName, settings, tasks)` API
-- Auto-provisioned default queue with zero config
-- Task-level batching support
-
-**Status**: Phase 1 complete (type system updates) ✅
-
----
-
-## Development Environment
-
-### Bun Runtime
-
-This project uses Bun for running TypeScript, tests, and package management.
-
-```bash
-# Package management
-bun install                        # Install dependencies
-
-# Running code
-bun <file.ts>                      # Run TypeScript directly
-bun run <script>                   # Run package.json script
-
-# Testing
-bun test                           # Run all tests
-bun test tests/unit/               # Run unit tests
-bun test tests/integration/        # Run integration tests
-```
-
-### Code Quality
-
-- **Console logs**: Always remove debug `console.log()` statements before committing
-- **Tests**: Ensure all tests pass and clean up resources (database connections, fake_now, etc.)
-- **Type checking**: Always run both tests AND typecheck together:
-  ```bash
-  bun run typecheck && bun test
-  ```
-**Format**: Ensure the code follows the formatting guidelines:
-```bash
-just format
-```
-**Linter**: Ensure the code does not emit any lint warnings:
-```bash
-just lint-fix
-```
-
-### Code Style Guidelines
-
-**TypeScript**:
-- **Array types**: Always use `T[]` syntax, never `Array<T>`
-  ```typescript
-  // ✅ Correct
-  const tasks: Task[] = [];
-  function process(items: string[]): number[] { }
-
-  // ❌ Wrong
-  const tasks: Array<Task> = [];
-  function process(items: Array<string>): Array<number> { }
-  ```
-- always add AGENT=1 as an env var when running anything
-- always use lower-case when writing SQL, also for keywords
-- prefer || ofer ?? in typescript. good: runAtMs || null. bad: runAtMs ?? null
-- NEVER use `as unknown` or `as any`
-- never use `!` in typescript
-- Always use "Postgres Conductor" when referring to this project
-- Always use "Postgres" over "PostgreSQL"
\ No newline at end of file
diff --git a/README.md b/README.md
index 1b7ab26..5875740 100644
--- a/README.md
+++ b/README.md
@@ -14,7 +14,7 @@
 
 **Durable Execution** - Tasks survive crashes and restarts through automatic step memoization
 
-**Multiple Triggers** - Invocable APIs, cron schedules, custom events, and database triggers
+**Multiple Triggers** - Invocable APIs, cron schedules, and durable custom events
 
 **Workflows** - Invoke child tasks and wait for results with full type safety
 
diff --git a/bun.lock b/bun.lock
index 9215bed..a6c74f4 100644
--- a/bun.lock
+++ b/bun.lock
@@ -21,12 +21,12 @@
         "cron-parser": "catalog:",
         "postgres": "catalog:",
         "prettier": "catalog:",
+        "zod": "catalog:",
       },
       "devDependencies": {
         "@testcontainers/postgresql": "catalog:",
         "@types/bun": "catalog:",
         "expect-type": "catalog:",
-        "zod": "catalog:",
       },
       "peerDependencies": {
         "typescript": "catalog:",
diff --git a/docs/content/api/conductor.md b/docs/content/api/conductor.md
index 1956b1a..3eb14cf 100644
--- a/docs/content/api/conductor.md
+++ b/docs/content/api/conductor.md
@@ -16,7 +16,6 @@ const conductor = Conductor.create({
   context,              // Custom context object
   logger?,              // Optional custom logger
   events?,              // Optional EventSchemas
-  database?,            // Optional DatabaseSchema
 });
 ```
 
@@ -28,7 +27,6 @@ const conductor = Conductor.create({
 - `context`: Object passed to task handlers as `ctx.{property}` (see [Custom Context](../crafting-tasks/custom-context.md))
 - `logger`: (optional) Custom logger implementation
 - `events`: (optional) `EventSchemas.fromSchema([...])` for typed custom events
-- `database`: (optional) `DatabaseSchema.fromSchema({...})` for database event triggers
 
 **Connection options:**
 
diff --git a/docs/content/api/orchestrator.md b/docs/content/api/orchestrator.md
index d7b043e..b9e86a2 100644
--- a/docs/content/api/orchestrator.md
+++ b/docs/content/api/orchestrator.md
@@ -24,6 +24,11 @@ const orchestrator = Orchestrator.create({
 - `workers`: (optional) Array of custom workers from `conductor.createWorker()`
 - `defaultWorker`: (optional) Configuration for default worker
 
+The Orchestrator is the registration authority for its workers. Configure at
+most one worker for each queue (including the implicit `default` worker); put
+all tasks for a queue on that worker. Multiple workers for one queue are
+rejected rather than competing for registrations.
+
 **Default worker config:**
 
 ```typescript
@@ -71,7 +76,8 @@ await orchestrator.drain();
 ```
 
 - Starts the orchestrator
-- Processes until queue is empty
+- Processes until all queues are globally quiescent, including event fan-out
+  created while another queue is finishing
 - Automatically stops
 - Returns when all work is done
 
diff --git a/docs/content/crafting-tasks/defining-tasks.md b/docs/content/crafting-tasks/defining-tasks.md
index 4e06f6d..b4ef20e 100644
--- a/docs/content/crafting-tasks/defining-tasks.md
+++ b/docs/content/crafting-tasks/defining-tasks.md
@@ -1,6 +1,6 @@
 # Defining Tasks and Events
 
-Define type-safe tasks, events, and database schemas that work across your entire application.
+Define type-safe tasks and events that work across your entire application.
 
 ## Why Define Schemas?
 
@@ -151,60 +151,6 @@ const conductor = Conductor.create({
 });
 ```
 
-## Database Schema
-
-Database schemas enable type-safe database triggers. These are always TypeScript types generated from your database.
-
-### Generating Types
-
-Use your preferred tool to generate types from your database:
-
-**With pgconductor CLI:**
-
-```bash
-pnpx pgconductor gen types typescript --db-url "postgres://localhost/mydb" --schemas "public" > database.types.ts
-```
-
-**With Supabase CLI:**
-
-```bash
-pnpx supabase gen types typescript --linked > database.types.ts
-```
-
-### Registering Database Schema
-
-```typescript
-import { DatabaseSchema } from "pgconductor-js";
-import type { Database } from "./database.types";
-
-const conductor = Conductor.create({
-  connectionString: "postgres://localhost/mydb",
-  tasks: TaskSchemas.fromSchema([...]),
-  database: DatabaseSchema.fromGeneratedTypes<Database>(),
-  // or if you are using Supabase CLI
-  // database: DatabaseSchema.fromSupabaseTypes<Database>(),
-  context: {},
-});
-```
-
-Now database triggers are fully typed:
-
-```typescript
-conductor.createTask(
-  { name: "on-user-created" },
-  {
-    schema: "public",
-    table: "users",
-    operation: "insert",
-    columns: "id,email,name", // TypeScript validates these columns exist!
-  },
-  async (event, ctx) => {
-    // event.payload.new is typed as { id: string, email: string, name: string }
-    const { id, email, name } = event.payload.new;
-  }
-);
-```
-
 ## Return Types
 
 Tasks can return typed results when invoked from other tasks using `ctx.invoke()`:
@@ -264,8 +210,7 @@ packages/
 ├── schemas/              # Shared schema package
 │   ├── package.json
 │   ├── tasks.ts          # Task definitions
-│   ├── events.ts         # Event definitions
-│   └── database.types.ts # Generated database types
+│   └── events.ts         # Event definitions
 ├── worker/               # Worker service
 │   ├── package.json
 │   └── src/
@@ -328,16 +273,14 @@ export const userCreated = defineEvent({
 `worker/src/index.ts`:
 
 ```typescript
-import { Conductor, Orchestrator, TaskSchemas, EventSchemas, DatabaseSchema } from "pgconductor-js";
+import { Conductor, Orchestrator, TaskSchemas, EventSchemas } from "pgconductor-js";
 import { sendEmailTask, processOrderTask } from "@myapp/schemas/tasks";
 import { userCreated } from "@myapp/schemas/events";
-import type { Database } from "@myapp/schemas/database.types";
 
 const conductor = Conductor.create({
   connectionString: process.env.DATABASE_URL,
   tasks: TaskSchemas.fromSchema([sendEmailTask, processOrderTask]),
   events: EventSchemas.fromSchema([userCreated]),
-  database: DatabaseSchema.fromGeneratedTypes<Database>(),
   context: {},
 });
 
@@ -407,6 +350,6 @@ await conductor.emit("user.created", {
 
 ## What's Next?
 
-- [Task Triggers](triggers.md) - Configure invocable, cron, event, and database triggers
+- [Task Triggers](triggers.md) - Configure invocable, cron, and custom event triggers
 - [Testing](testing.md) - Unit test tasks with type-safe mocks
 - [Conductor API](../api/conductor.md) - Full API documentation
diff --git a/docs/content/crafting-tasks/triggers.md b/docs/content/crafting-tasks/triggers.md
index b4de1f2..fac8b28 100644
--- a/docs/content/crafting-tasks/triggers.md
+++ b/docs/content/crafting-tasks/triggers.md
@@ -5,7 +5,6 @@ Tasks can be triggered in multiple ways:
 - **Invocable** - Triggered manually via `conductor.invoke()`
 - **Cron** - Triggered on a schedule
 - **Custom Events** - Triggered when you emit custom application events
-- **Database Triggers** - Triggered automatically by Postgres triggers on INSERT/UPDATE/DELETE
 
 ## Invocable Tasks
 
@@ -109,139 +108,88 @@ await conductor.emit("user.created", {
 });
 ```
 
-### Field Selection
+Each event is stored as a short-lived internal dispatch execution. Destination fan-out and a reserved completion marker commit in one database transaction. A committed marker freezes the matched destination set; a transaction that rolls back retries against the current subscriptions without leaving partial destinations.
 
-For large events, you can select only specific fields to reduce payload size:
+### Emitting from Database Triggers
 
-```typescript
-conductor.createTask(
-  { name: "log-user-id" },
-  { event: "user.created", fields: "userId" },
-  async (event, ctx) => {
-    // event.payload only contains { userId: string }
-    ctx.logger.info("User created:", event.payload.userId);
-  }
-);
-```
+Postgres Conductor does not create or manage triggers on application tables. If a database change should emit an event, define the trigger in your own migrations and call `pgconductor.emit_event()`:
 
-## Database Triggers
+```sql
+create function app.emit_user_created()
+returns trigger
+language plpgsql
+as $$
+begin
+  perform pgconductor.emit_event('user.created', to_jsonb(new));
+  return new;
+end;
+$$;
 
-React to database changes automatically using Postgres triggers. When a row is inserted, updated, or deleted, Postgres Conductor creates a task execution with the row data.
+create trigger emit_user_created
+after insert on app.users
+for each row execute function app.emit_user_created();
+```
 
-### Setup
+Because `emit_event()` inserts the dispatch execution in the current transaction, emission is committed or rolled back with the database change.
 
-Provide your database schema types to enable type-safe database triggers:
+### Event Filters
 
-```typescript
-import { DatabaseSchema } from "pgconductor-js";
-import type { Database } from "./database.types"; // Generated types
+Declare top-level scalar fields as filterable, then register typed predicates on handlers:
 
-const conductor = Conductor.create({
-  connectionString: "postgres://localhost/mydb",
-  tasks: TaskSchemas.fromSchema([taskDef]),
-  database: DatabaseSchema.fromGeneratedTypes<Database>(),
-  context: {},
+```typescript
+const orderChanged = defineEvent({
+  name: "order.changed",
+  payload: z.object({
+    status: z.string(),
+    region: z.string(),
+    amount: z.number(),
+    note: z.string().optional(),
+  }),
+  filterable: ["status", "region", "amount", "note"],
 });
-```
 
-### Creating Database Triggers
-
-```typescript
-const onContactInsert = conductor.createTask(
-  { name: "on-contact-insert" },
+conductor.createTask(
+  { name: "handle-paid-us-orders" },
   {
-    schema: "public",
-    table: "contact",
-    operation: "insert",
-    columns: "id,email,first_name", // Required
+    event: "order.changed",
+    filter: {
+      status: ["paid", "trial"],
+      region: [{ prefix: "us-" }],
+      amount: [{ numeric: [">=", 10, "<", 100] }],
+      note: [{ exists: false }],
+    },
   },
   async (event, ctx) => {
-    // event.name === "public.contact.insert"
-    // event.payload.tg_op === "INSERT"
-    // event.payload.old === null (no old row on insert)
-    // event.payload.new contains selected columns
-
-    const { id, email, first_name } = event.payload.new;
-    ctx.logger.info(`New contact: ${first_name} (${email})`);
+    // Both fields matched; values within one field are alternatives.
   }
 );
 ```
 
-The orchestrator automatically creates Postgres triggers on your tables when it starts.
+Fields are combined with AND and alternatives within a field with OR. Supported alternatives are:
 
-### Operations
+- a string, number, boolean, or `null` for type-sensitive equality;
+- `{ prefix: "literal" }` for a literal string prefix (`%`, `_`, and `\\` have no special meaning);
+- `{ numeric: [">=", 10, "<", 100] }` for a one- or two-bound numeric range;
+- `{ exists: true }` or `{ exists: false }` for field presence;
+- `{ "anything-but": value }` for one atomic scalar exclusion.
 
-Support for INSERT, UPDATE, and DELETE:
+Missing fields differ from JSON `null`. An `anything-but` predicate must be the field's only alternative. Filters are stored as normalized, typed predicates, narrowed through exact/prefix/range indexes or an explicit route-local fallback, and then completely verified. A filter may contain up to 8 fields and 4 alternatives per field; literal prefixes are limited to 64 characters.
 
-**INSERT** - Only `new` row available:
-```typescript
-{
-  schema: "public",
-  table: "contact",
-  operation: "insert",
-  columns: "id,email"
-}
-// event.payload.old === null
-// event.payload.new === { id: string, email: string | null }
-```
-
-**UPDATE** - Both `old` and `new` rows available:
-```typescript
-{
-  schema: "public",
-  table: "contact",
-  operation: "update",
-  columns: "id,email,name"
-}
-// event.payload.old === { id: string, email: string | null, name: string }
-// event.payload.new === { id: string, email: string | null, name: string }
-```
-
-**DELETE** - Only `old` row available:
-```typescript
-{
-  schema: "public",
-  table: "contact",
-  operation: "delete",
-  columns: "id,email"
-}
-// event.payload.old === { id: string, email: string | null }
-// event.payload.new === null
-```
-
-### Conditional Triggers
+### Field Selection
 
-Use `when` clause to filter which rows trigger task execution:
+For large events, you can select only specific fields to reduce payload size:
 
 ```typescript
 conductor.createTask(
-  { name: "on-active-user" },
-  {
-    schema: "public",
-    table: "users",
-    operation: "insert",
-    columns: "id,email,name",
-    when: "NEW.active = true", // Only trigger for active users
-  },
+  { name: "log-user-id" },
+  { event: "user.created", fields: "userId" },
   async (event, ctx) => {
-    // Only called when active = true
+    // event.payload only contains { userId: string }
+    ctx.logger.info("User created:", event.payload.userId);
   }
 );
 ```
 
-The `when` clause is evaluated in the Postgres trigger before creating a task execution.
-
-### How It Works
-
-When you start the orchestrator:
-
-1. Postgres triggers are created on your specified tables
-2. When a row changes, the trigger captures the row data
-3. A task execution is created with the selected columns
-4. Your task handler receives the event with typed payload
-
-The triggers persist in the database even after the orchestrator stops.
-
 ## Multiple Triggers
 
 Tasks can respond to multiple trigger types:
@@ -253,12 +201,6 @@ const flexibleTask = conductor.createTask(
     { invocable: true },
     { cron: "0 * * * *", name: "hourly" },
     { event: "user.created" },
-    {
-      schema: "public",
-      table: "contact",
-      operation: "insert",
-      columns: "id,email"
-    },
   ],
   async (event, ctx) => {
     // Discriminate based on event.name
@@ -270,9 +212,6 @@ const flexibleTask = conductor.createTask(
     } else if (event.name === "user.created") {
       // Custom event
       const { userId, email, name } = event.payload;
-    } else if (event.name === "public.contact.insert") {
-      // Database trigger
-      const { id, email } = event.payload.new;
     }
   }
 );
diff --git a/docs/content/index.md b/docs/content/index.md
index cbf1830..76f8afa 100644
--- a/docs/content/index.md
+++ b/docs/content/index.md
@@ -14,7 +14,7 @@
 
 **Durable Execution** - Tasks survive crashes and restarts through automatic step memoization
 
-**Multiple Triggers** - Invocable APIs, cron schedules, custom events, and database triggers
+**Multiple Triggers** - Invocable APIs, cron schedules, and durable custom events
 
 **Workflows** - Invoke child tasks and wait for results with full type safety
 
diff --git a/docs/content/scaling/maintenance.md b/docs/content/scaling/maintenance.md
index 00299cb..0e8dda4 100644
--- a/docs/content/scaling/maintenance.md
+++ b/docs/content/scaling/maintenance.md
@@ -9,7 +9,7 @@ Maintenance runs daily on each queue:
 - Removes old completed executions (based on task retention config)
 - Removes old failed executions (based on task retention config)
 
-No manual intervention required.
+Custom events use ordinary internal executions and therefore do not require a separate event-log cleanup pass.
 
 ## What's Next?
 
diff --git a/implementation-notes.md b/implementation-notes.md
new file mode 100644
index 0000000..9aa9dbe
--- /dev/null
+++ b/implementation-notes.md
@@ -0,0 +1,54 @@
+# Implementation Notes
+
+Running notes for the custom-event pipeline implementation.
+
+## Design decisions
+
+- An emitted event is a short-lived execution on `pgconductor.internal` for `pgconductor.event-dispatch`. Its execution ID is the public event ID and its payload is `{ eventKey, payload }`; there is no separate event-log table.
+- The hidden dispatcher uses the ordinary execution lifecycle for claiming, retries, recovery, settlement, drain, and shutdown. User workers register before dispatcher fetching begins, so dispatch never sees a partially registered local worker set.
+- Emission inserts only the dispatch execution and takes no event-key advisory lock. Application-owned PostgreSQL triggers can call `pgconductor.emit_event()` transactionally with their source change.
+- A reserved `_private_steps` row, `pgconductor.internal.event-fanout.v1`, is the atomic fan-out commit marker. TypeScript holds the source locks while destination and marker insertion commit in the same transaction. A retry that sees the marker completes without re-reading subscriptions, including zero-destination events.
+- Source completion removes the immediate-retention dispatch execution and cascades marker removal. Destinations remain because they have no foreign key to the source.
+- Destination identity is `(parent_execution_id, subscription_id)`. `parent_execution_id` records source-event lineage, while non-null `subscription_id` excludes the delivery from workflow child settlement, orphaning, wake-up, and failure propagation.
+- Each subscription stores one canonical filter object directly. Fields are AND clauses and each field's alternatives are OR predicates supporting exact scalars, literal prefixes, numeric ranges, presence, and atomic `anything-but`.
+- Registration deterministically chooses one complete candidate-safe field by operator rank and field name. Only that field's exact, prefix, or numeric-range alternatives are stored in `_private_event_filter_anchors`; filters without a safe field store one event-key fallback anchor.
+- Dispatch uses one SQL statement to lock/fence sources, inspect markers, and perform typed indexed anchor probes. It returns one row per candidate subscription rather than one row per predicate. TypeScript evaluates the already-canonical filter directly, then one SQL statement atomically inserts destinations and markers.
+- Zod validates and canonicalizes each event trigger once when its `Task` is constructed. The compiled subscription and anchors are cached on the task and worker registration persists them without recompilation. The private SQL trusts this compiled policy and only converts anchor transport values into indexed typed columns.
+- A cascading foreign key maintains the cold subscription → anchor relationship. Hot execution and destination lineage remain independent of subscription metadata.
+- The in-memory client reuses the production filter matcher instead of maintaining a second implementation.
+- Registration remains queue-scoped and atomic under the existing queue-row lock. Dispatch sees either the old or new committed subscription snapshot.
+
+## Lifecycle invariants
+
+- Before fan-out commits, any matching or insertion error rolls back destinations and the marker; normal dispatch retry applies.
+- After fan-out commits, the marker freezes the matched subscription set. Recovery retries complete from the marker without duplicating or changing destinations.
+- Destination completion or failure cannot complete, fail, cancel, or retain the source dispatch execution. A destination may still invoke a normal workflow child; that child has `subscription_id = null` and uses the existing workflow lifecycle.
+- The source execution may be deleted immediately after successful settlement. Destination identity remains valid without source or subscription rows.
+- Notifications are optional wake-up hints. Persisted executions and polling remain authoritative.
+
+## Matching semantics
+
+- Fields are AND clauses; scalar alternatives within a field are OR predicates.
+- Scalar equality and `anything-but` are type-sensitive.
+- Prefixes are literal, bounded to 64 characters, and never use `LIKE` semantics.
+- Numeric range boundaries preserve strict versus inclusive comparisons.
+- Missing values differ from JSON null; `exists` tests presence directly.
+- `{}` is unconditional and uses the explicit fallback path.
+- Event names are limited to 255 UTF-8 bytes, field names to 128 bytes, and indexed scalar JSON text to 1,024 bytes.
+- Event payloads and private filter transport values must be JSON objects at their database boundaries. Because final matching uses JavaScript numbers, top-level numeric fields emitted directly from SQL must round-trip through PostgreSQL `double precision` without changing their decimal value.
+
+## Deviations
+
+- Migrations are rewritten in place under the active-development policy. Databases created from earlier unreleased snapshots must be recreated.
+- There is no independent event replay or custom-event retention layer. A future one-shot wait feature must define its own no-miss registration/replay protocol rather than inferring commit order from event IDs.
+
+## Tradeoffs
+
+- Presence and `anything-but` are residual-only operators. A filter without a complete exact, prefix, or numeric-range candidate field intentionally uses the event-key-local fallback index.
+- Canonical filters remain JSONB because TypeScript owns final matching. Only candidate anchors are relational and typed; fully normalizing residual predicates would duplicate the matcher and increase query results.
+- Combining source locking and candidate lookup into one SQL statement can use the statement's pre-wait snapshot during a concurrent dispatch. The commit statement rechecks the marker before inserting destinations, so a dispatcher that waited for an already-committed fan-out cannot extend its frozen destination set.
+- Dispatcher batches remain 10. Fan-out is one atomic transaction per batch and reuses the existing hidden Worker path.
+
+## Open questions
+
+- None.
diff --git a/migrations/0000000001_setup.sql b/migrations/0000000001_setup.sql
index 01a65df..ef1e4f9 100644
--- a/migrations/0000000001_setup.sql
+++ b/migrations/0000000001_setup.sql
@@ -1,4 +1,6 @@
 
+create extension if not exists btree_gist;
+
 -- Returns either the actual current timestamp or a fake one for tests.
 -- Uses session variable (current_setting) for test time control.
 create function pgconductor._private_current_time ()
@@ -104,6 +106,7 @@ create table pgconductor._private_executions (
     waiting_on_execution_id uuid,
     waiting_step_key text,
     parent_execution_id uuid,
+    subscription_id uuid,
     singleton_on timestamptz,
 
     -- Dead-letter metadata is denormalized so retained source rows are optional.
@@ -114,7 +117,9 @@ create table pgconductor._private_executions (
     dead_letter_attempts integer,
     dead_letter_failed_at timestamptz,
     primary key (id, queue),
-    unique (task_key, dedupe_key, queue)
+    unique (task_key, dedupe_key, queue),
+    constraint chk_executions_event_delivery_parent
+        check (subscription_id is null or parent_execution_id is not null)
 ) partition by list (queue);
 
 -- unique index for singleton throttle/debounce enforcement on parent table
@@ -278,7 +283,11 @@ begin
     RETURN NEW;
 
   elsif tg_op = 'UPDATE' then
-    -- protect default queue from modification
+    -- protect queues required by the runtime
+    if old.name = 'pgconductor.internal' or new.name = 'pgconductor.internal' then
+      raise exception 'Modifying the internal queue is not allowed';
+    end if;
+
     if old.name = 'default' or new.name = 'default' then
       raise exception 'Modifying the default queue is not allowed';
     end if;
@@ -291,7 +300,11 @@ begin
     return new;
 
   elsif tg_op = 'DELETE' then
-    -- protect default queue from deletion
+    -- protect queues required by the runtime
+    if old.name = 'pgconductor.internal' then
+      raise exception 'Deleting the internal queue is not allowed';
+    end if;
+
     if old.name = 'default' then
       raise exception 'Deleting the default queue is not allowed';
     end if;
@@ -355,22 +368,12 @@ create type pgconductor.task_spec as (
     dead_letter_task_key text
 );
 
-create type pgconductor._private_event_operation as enum (
-    'insert',
-    'update',
-    'delete'
-);
-
 create type pgconductor.event_subscription_spec as (
     task_key text,
-    queue text,
     event_key text,
-    schema_name text,
-    table_name text,
-    operation pgconductor._private_event_operation,
-    when_clause text,
     payload_fields text[],
-    column_names text[]
+    filter jsonb,
+    anchors jsonb
 );
 
 create or replace function pgconductor._private_register_worker(
@@ -385,19 +388,35 @@ volatile
 set search_path to ''
 as $function$
 begin
-  -- step 1: upsert queue (triggers partition creation)
+  -- Upsert every required queue in a stable order (triggers partition
+  -- creation).  Registrations may reference one another as dead-letter queues,
+  -- so queue creation and locking share a global order.
   insert into pgconductor._private_queues (name)
-  values (p_queue_name)
+  select required.name
+  from (
+    select p_queue_name as name
+    union
+    select spec.dead_letter_queue
+    from unnest(p_task_specs) as spec
+    where spec.dead_letter_queue is not null
+  ) required
+  order by required.name
   on conflict (name) do nothing;
 
-  -- Dead-letter destinations may not have a worker yet; create their partitions.
-  insert into pgconductor._private_queues (name)
-  select distinct spec.dead_letter_queue
-  from unnest(p_task_specs) as spec
-  where spec.dead_letter_queue is not null
-  on conflict (name) do nothing;
+  -- Queue row locks are the only registration locks; acquire them in order.
+  perform 1
+  from pgconductor._private_queues queue
+  where queue.name in (
+    select p_queue_name
+    union
+    select spec.dead_letter_queue
+    from unnest(p_task_specs) as spec
+    where spec.dead_letter_queue is not null
+  )
+  order by queue.name
+  for update;
 
-  -- step 2: register/update tasks
+  -- Register/update tasks.
   insert into pgconductor._private_tasks (key, queue, max_attempts, remove_on_complete_days, remove_on_fail_days, window_start, window_end, concurrency_limit, group_concurrency_limit, dead_letter_queue, dead_letter_task_key)
   select
     spec.key,
@@ -425,7 +444,7 @@ begin
     dead_letter_queue = excluded.dead_letter_queue,
     dead_letter_task_key = excluded.dead_letter_task_key;
 
-  -- step 3: insert scheduled cron executions
+  -- Insert scheduled cron executions.
   insert into pgconductor._private_executions (task_key, queue, payload, run_at, dedupe_key, cron_expression, "group")
   select
     spec.task_key,
@@ -443,8 +462,7 @@ begin
     cron_expression = excluded.cron_expression,
     "group" = excluded."group";
 
-  -- step 4: clean up stale schedules for this queue
-  -- delete future executions for schedules that no longer exist
+  -- Clean up stale schedules for this queue.
   delete from pgconductor._private_executions
   where queue = p_queue_name
     and cron_expression is not null
@@ -456,7 +474,6 @@ begin
       where spec.dedupe_key is not null and spec.dedupe_key like 'scheduled::%'
     );
 
-  -- mark running executions as cancelled for schedules that no longer exist
   update pgconductor._private_executions
   set cancelled = true
   where queue = p_queue_name
@@ -472,59 +489,10 @@ begin
       where spec.dedupe_key is not null and spec.dedupe_key like 'scheduled::%'
     );
 
-  -- step 5: manage event subscriptions (only recreate triggers when subscriptions change)
-  merge into pgconductor._private_event_subscriptions as target
-  using (
-    select
-      s.task_key,
-      s.queue,
-      s.event_key,
-      s.schema_name,
-      s.table_name,
-      s.operation,
-      s.when_clause,
-      s.payload_fields,
-      s.column_names
-    from unnest(p_event_subscriptions) as s
-  ) as source
-  on (
-    target.queue = source.queue and
-    target.task_key = source.task_key and
-    coalesce(target.event_key, '') = coalesce(source.event_key, '') and
-    coalesce(target.schema_name, '') = coalesce(source.schema_name, '') and
-    coalesce(target.table_name, '') = coalesce(source.table_name, '') and
-    coalesce(target.operation::text, '') = coalesce(source.operation::text, '') and
-    coalesce(target.when_clause, '') = coalesce(source.when_clause, '') and
-    coalesce(array_to_string(target.payload_fields, ','), '') =
-      coalesce(array_to_string(source.payload_fields, ','), '') and
-    coalesce(array_to_string(target.column_names, ','), '') =
-      coalesce(array_to_string(source.column_names, ','), '')
-  )
-  when not matched then insert (
-    task_key, queue, event_key, schema_name, table_name, operation,
-    when_clause, payload_fields, column_names
-  ) values (
-    source.task_key, source.queue, source.event_key,
-    source.schema_name, source.table_name, source.operation,
-    source.when_clause, source.payload_fields, source.column_names
+  perform pgconductor._private_replace_custom_event_subscriptions(
+    p_queue_name,
+    p_event_subscriptions
   );
-
-  -- step 6: delete old subscriptions for this queue not in new set
-  delete from pgconductor._private_event_subscriptions target
-  where target.queue = p_queue_name
-    and not exists (
-      select 1 from unnest(p_event_subscriptions) source
-      where target.task_key = source.task_key
-        and coalesce(target.event_key, '') = coalesce(source.event_key, '')
-        and coalesce(target.schema_name, '') = coalesce(source.schema_name, '')
-        and coalesce(target.table_name, '') = coalesce(source.table_name, '')
-        and coalesce(target.operation::text, '') = coalesce(source.operation::text, '')
-        and coalesce(target.when_clause, '') = coalesce(source.when_clause, '')
-        and coalesce(array_to_string(target.payload_fields, ','), '') =
-          coalesce(array_to_string(source.payload_fields, ','), '')
-        and coalesce(array_to_string(target.column_names, ','), '') =
-          coalesce(array_to_string(source.column_names, ','), '')
-    );
 end;
 $function$;
 
@@ -908,3 +876,233 @@ begin
 end;
 $function$;
 
+-- Event deliveries use the source dispatch execution as durable lineage without
+-- participating in workflow parent/child settlement.
+create unique index idx_executions_event_destination
+    on pgconductor._private_executions (parent_execution_id, subscription_id, queue)
+    where subscription_id is not null;
+
+create table pgconductor._private_custom_event_subscriptions (
+    id uuid primary key default pgconductor._private_portable_uuidv7(),
+    event_key text not null,
+    task_key text not null,
+    queue text not null,
+    payload_fields text[],
+    filter jsonb not null default '{}'::jsonb,
+    created_at timestamptz not null default pgconductor._private_current_time(),
+    constraint chk_custom_event_subscription_event_key check (
+        btrim(event_key) <> '' and octet_length(event_key) between 1 and 255
+    ),
+    constraint chk_custom_event_subscription_filter check (
+        jsonb_typeof(filter) = 'object'
+    )
+);
+
+create index idx_custom_event_subscriptions_event
+    on pgconductor._private_custom_event_subscriptions (event_key, id);
+
+-- TypeScript compiles and validates complete filters once. Postgres stores only
+-- the candidate-safe alternatives from one clause, or one fallback row when no
+-- selective clause exists.
+create table pgconductor._private_event_filter_anchors (
+    subscription_id uuid not null,
+    anchor_number smallint not null check (anchor_number > 0),
+    event_key text not null,
+    field_name text,
+    operator text not null check (
+        operator in ('fallback', 'exact', 'prefix', 'numeric_range')
+    ),
+    scalar_type text check (scalar_type in ('string', 'number', 'boolean', 'null')),
+    text_value text,
+    number_value numeric,
+    boolean_value boolean,
+    prefix_length smallint generated always as (
+        case when operator = 'prefix' then length(text_value)::smallint end
+    ) stored,
+    number_range numrange,
+    primary key (subscription_id, anchor_number),
+    constraint fk_event_filter_anchor_subscription foreign key (subscription_id)
+        references pgconductor._private_custom_event_subscriptions(id) on delete cascade
+);
+
+create index idx_event_filter_anchor_fallback
+    on pgconductor._private_event_filter_anchors (event_key, subscription_id)
+    where operator = 'fallback';
+create index idx_event_filter_anchor_exact_text
+    on pgconductor._private_event_filter_anchors
+       (event_key collate "C", field_name collate "C", text_value collate "C", subscription_id)
+    where operator = 'exact' and scalar_type = 'string';
+create index idx_event_filter_anchor_exact_number
+    on pgconductor._private_event_filter_anchors
+       (event_key, field_name, number_value, subscription_id)
+    where operator = 'exact' and scalar_type = 'number';
+create index idx_event_filter_anchor_exact_boolean
+    on pgconductor._private_event_filter_anchors
+       (event_key, field_name, boolean_value, subscription_id)
+    where operator = 'exact' and scalar_type = 'boolean';
+create index idx_event_filter_anchor_exact_null
+    on pgconductor._private_event_filter_anchors
+       (event_key, field_name, subscription_id)
+    where operator = 'exact' and scalar_type = 'null';
+create index idx_event_filter_anchor_prefix
+    on pgconductor._private_event_filter_anchors
+       (event_key collate "C", field_name collate "C", prefix_length,
+        text_value collate "C", subscription_id)
+    where operator = 'prefix';
+create index idx_event_filter_anchor_numeric_range
+    on pgconductor._private_event_filter_anchors using gist
+       (event_key, field_name, number_range, subscription_id)
+    where operator = 'numeric_range';
+
+-- Persistent worker subscriptions are replaced as one queue-scoped snapshot.
+-- The private transport is already compiled; SQL only persists subscriptions
+-- and converts their candidate anchors into indexed typed columns.
+create or replace function pgconductor._private_replace_custom_event_subscriptions(
+    p_queue_name text,
+    p_subscriptions pgconductor.event_subscription_spec[]
+)
+returns void
+language sql
+volatile
+set search_path to ''
+as $function$
+    with removed as materialized (
+        delete from pgconductor._private_custom_event_subscriptions
+        where queue = p_queue_name
+        returning id
+    ), input as materialized (
+        select task_key, event_key, payload_fields,
+            coalesce(filter, '{}'::jsonb) as filter,
+            coalesce(anchors, '[]'::jsonb) as anchors,
+            input_ordinal
+        from unnest(p_subscriptions) with ordinality
+          as subscription(task_key, event_key, payload_fields, filter, anchors, input_ordinal)
+        cross join (select count(*) from removed) removal_barrier
+    ), prepared as materialized (
+        select pgconductor._private_portable_uuidv7() as id, input.*
+        from input
+    ), inserted_subscriptions as (
+        insert into pgconductor._private_custom_event_subscriptions (
+            id, event_key, task_key, queue, payload_fields, filter
+        )
+        select id, event_key, task_key, p_queue_name, payload_fields, filter
+        from prepared
+        order by input_ordinal
+        returning id
+    ), anchors as materialized (
+        select prepared.id as subscription_id, prepared.event_key,
+            anchor.ordinality::smallint as anchor_number,
+            fields.field_name, fields.operator, fields.scalar_type,
+            fields.text_value, fields.number_value, fields.boolean_value,
+            fields.lower_value, fields.upper_value,
+            fields.lower_inclusive, fields.upper_inclusive
+        from prepared
+        cross join lateral jsonb_array_elements(prepared.anchors)
+            with ordinality as anchor(value, ordinality)
+        cross join lateral jsonb_to_record(anchor.value) as fields(
+            field_name text,
+            operator text,
+            scalar_type text,
+            text_value text,
+            number_value numeric,
+            boolean_value boolean,
+            lower_value numeric,
+            upper_value numeric,
+            lower_inclusive boolean,
+            upper_inclusive boolean
+        )
+    )
+    insert into pgconductor._private_event_filter_anchors (
+        subscription_id, anchor_number, event_key, field_name, operator,
+        scalar_type, text_value, number_value, boolean_value, number_range
+    )
+    select
+        anchors.subscription_id,
+        anchors.anchor_number,
+        anchors.event_key,
+        anchors.field_name,
+        anchors.operator,
+        anchors.scalar_type,
+        anchors.text_value,
+        anchors.number_value,
+        anchors.boolean_value,
+        case when anchors.operator = 'numeric_range' then numrange(
+            anchors.lower_value,
+            anchors.upper_value,
+            (case when anchors.lower_inclusive then '[' else '(' end)
+                ||
+            (case when anchors.upper_inclusive then ']' else ')' end)
+        ) end
+    from anchors
+    join inserted_subscriptions on inserted_subscriptions.id = anchors.subscription_id;
+$function$;
+
+insert into pgconductor._private_queues (name)
+values ('pgconductor.internal')
+on conflict do nothing;
+
+insert into pgconductor._private_tasks (
+    key, queue, max_attempts, remove_on_complete_days, remove_on_fail_days
+)
+values (
+    'pgconductor.event-dispatch', 'pgconductor.internal', 3, 0, null
+)
+on conflict (queue, key) do update set
+    max_attempts = excluded.max_attempts,
+    remove_on_complete_days = excluded.remove_on_complete_days,
+    remove_on_fail_days = excluded.remove_on_fail_days;
+
+create or replace function pgconductor.emit_event(
+    p_event_key text,
+    p_payload jsonb default '{}'::jsonb
+)
+returns uuid
+language plpgsql
+volatile
+set search_path to ''
+as $function$
+declare
+    v_payload jsonb := p_payload;
+    v_event_id uuid;
+begin
+    if p_event_key is null
+        or btrim(p_event_key) = ''
+        or octet_length(p_event_key) > 255
+    then
+        raise exception 'Event name must contain between 1 and 255 UTF-8 bytes';
+    end if;
+
+    if v_payload is null or jsonb_typeof(v_payload) <> 'object' then
+        raise exception 'Event payload must be a JSON object';
+    end if;
+
+    -- Final filter matching runs in TypeScript. Reject top-level SQL numeric
+    -- values whose decimal value would change when decoded as a JS number.
+    if exists (
+        select 1
+        from jsonb_each(v_payload) field
+        where jsonb_typeof(field.value) = 'number'
+          and not case
+              when abs((field.value #>> '{}')::numeric)
+                  <= '1.7976931348623157e308'::numeric
+              then (field.value #>> '{}')::numeric
+                  = ((field.value #>> '{}')::double precision)::text::numeric
+              else false
+          end
+    ) then
+        raise exception 'Event payload contains a number that cannot be represented as a JavaScript number';
+    end if;
+
+    insert into pgconductor._private_executions (
+        id, task_key, queue, payload
+    ) values (
+        pgconductor._private_portable_uuidv7(),
+        'pgconductor.event-dispatch',
+        'pgconductor.internal',
+        jsonb_build_object('eventKey', p_event_key, 'payload', v_payload)
+    )
+    returning id into v_event_id;
+
+    return v_event_id;
+end;
+$function$;
diff --git a/migrations/0000000002_events.sql b/migrations/0000000002_events.sql
deleted file mode 100644
index 2d3b223..0000000
--- a/migrations/0000000002_events.sql
+++ /dev/null
@@ -1,346 +0,0 @@
-alter table pgconductor._private_executions
-    add column if not exists subscription_id uuid;
-
-create table if not exists pgconductor._private_custom_events (
-    id uuid default pgconductor._private_portable_uuidv7() not null,
-    event_key text not null,
-    payload jsonb not null default '{}'::jsonb,
-    created_at timestamptz default pgconductor._private_current_time() not null,
-    primary key (created_at, id)
-) partition by range (created_at);
-
-create index if not exists idx_custom_events_event_key
-    on pgconductor._private_custom_events (event_key, created_at desc);
-
--- Create initial partition for custom events (will cover many years)
-create table if not exists pgconductor._private_custom_events_default
-    partition of pgconductor._private_custom_events
-    for values from (minvalue) to (maxvalue);
-
-create table if not exists pgconductor._private_event_subscriptions (
-    id uuid primary key default pgconductor._private_portable_uuidv7(),
-
-    task_key text not null,
-    queue text not null,
-
-    event_key text,
-    schema_name text,
-    table_name text,
-    operation pgconductor._private_event_operation,
-
-    when_clause text,
-    payload_fields text[],
-    column_names text[],
-
-    created_at timestamptz not null default pgconductor._private_current_time(),
-
-    constraint chk_event_type check (
-        (event_key is not null and schema_name is null and table_name is null and operation is null)
-        or
-        (event_key is null and schema_name is not null and table_name is not null and operation is not null)
-    )
-);
-
-create index if not exists idx_event_subscriptions_custom
-    on pgconductor._private_event_subscriptions (event_key)
-    where event_key is not null;
-
-create index if not exists idx_event_subscriptions_database
-    on pgconductor._private_event_subscriptions (schema_name, table_name, operation)
-    where schema_name is not null;
-
-create or replace function pgconductor._private_sync_custom_event_trigger()
-    returns trigger
-    language plpgsql
-    security definer
-    set search_path to ''
-as $_$
-declare
-    v_invoke_blocks text;
-    v_has_subscriptions boolean;
-begin
-    -- Only process custom event subscriptions (event_key is not null)
-    if coalesce(new.event_key, old.event_key) is null then
-        return coalesce(new, old);
-    end if;
-
-    drop trigger if exists pgconductor_custom_event on pgconductor._private_custom_events;
-    drop function if exists pgconductor._private_trigger_custom_event;
-
-    select exists(
-        select 1
-        from pgconductor._private_event_subscriptions
-        where event_key is not null
-    ) into v_has_subscriptions;
-
-    if v_has_subscriptions then
-        v_invoke_blocks := (
-            select string_agg(format(
-                $sql$
-                if new.event_key = %L and (%s) then
-                    v_task_keys := array_append(v_task_keys, %L);
-                    v_queues := array_append(v_queues, %L);
-                    v_payloads := array_append(v_payloads, jsonb_build_object('event', new.event_key, 'payload', %s));
-                    v_subscription_ids := array_append(v_subscription_ids, %L);
-                end if;
-                $sql$,
-                sub.event_key,
-                coalesce(nullif(sub.when_clause, ''), 'true'),
-                sub.task_key,
-                t.queue,
-                pgconductor._private_build_payload_fields(sub.payload_fields, 'new.payload'),
-                sub.id
-            ), e'\n')
-            from pgconductor._private_event_subscriptions as sub
-            join pgconductor._private_tasks as t on t.key = sub.task_key and t.queue = sub.queue
-            where sub.event_key is not null
-        );
-
-        execute format(
-            $sql$
-            create or replace function pgconductor._private_trigger_custom_event()
-                returns trigger
-                language plpgsql
-                security definer
-                set search_path to ''
-            as $inner$
-            declare
-                v_task_keys text[];
-                v_queues text[];
-                v_payloads jsonb[];
-                v_subscription_ids uuid[];
-            begin
-                %s
-
-                if array_length(v_task_keys, 1) > 0 then
-                    insert into pgconductor._private_executions (task_key, queue, payload, subscription_id)
-                    select unnest(v_task_keys), unnest(v_queues), unnest(v_payloads), unnest(v_subscription_ids);
-                end if;
-
-                return new;
-            end
-            $inner$
-            $sql$,
-            v_invoke_blocks
-        );
-
-        execute $sql$
-            create trigger pgconductor_custom_event
-                after insert on pgconductor._private_custom_events
-                for each row
-                execute function pgconductor._private_trigger_custom_event()
-        $sql$;
-    end if;
-
-    if tg_op = 'DELETE' then
-        return old;
-    end if;
-
-    return new;
-end;
-$_$;
-
-create trigger sync_custom_event_trigger
-    after insert or delete or update on pgconductor._private_event_subscriptions
-    for each row
-    execute function pgconductor._private_sync_custom_event_trigger();
-
-create or replace function pgconductor._private_build_payload_fields(
-    p_payload_fields text[],
-    p_payload_expr text
-)
-    returns text
-    language sql
-    immutable
-    set search_path to ''
-as $_$
-    select case
-        when p_payload_fields is null then p_payload_expr
-        else 'jsonb_build_object(' || array_to_string(
-            array(
-                select format('%L, %s->%L', field, p_payload_expr, field)
-                from unnest(p_payload_fields) as field
-            ),
-            ', '
-        ) || ')'
-    end;
-$_$;
-
-create or replace function pgconductor._private_build_column_list(
-    p_column_names text[],
-    p_record_name text
-)
-    returns text
-    language sql
-    immutable
-    set search_path to ''
-as $_$
-    select case
-        when p_column_names is null then format('row_to_json(%I.*)', p_record_name)
-        else 'jsonb_build_object(' || array_to_string(
-            array(
-                select format('%L, %I.%I', col, p_record_name, col)
-                from unnest(p_column_names) as col
-            ),
-            ', '
-        ) || ')'
-    end;
-$_$;
-
-create or replace function pgconductor._private_sync_database_trigger()
-    returns trigger
-    language plpgsql
-    security definer
-    set search_path to ''
-as $_$
-declare
-    v_table_name text := coalesce(new.table_name, old.table_name);
-    v_schema_name text := coalesce(new.schema_name, old.schema_name);
-    v_op pgconductor._private_event_operation;
-    v_invoke_blocks text;
-    v_has_subscriptions boolean;
-begin
-    -- Only process database event subscriptions (schema_name is not null)
-    if v_schema_name is null then
-        return coalesce(new, old);
-    end if;
-
-    -- Process each operation type (insert, update, delete)
-    foreach v_op in array array['insert', 'update', 'delete']::pgconductor._private_event_operation[] loop
-        -- Drop existing trigger and function
-        execute format(
-            'drop trigger if exists pgconductor_event_%s on %I.%I',
-            v_op::text, v_schema_name, v_table_name
-        );
-
-        execute format(
-            'drop function if exists pgconductor._private_trigger_event_%s_on_%I_%I',
-            v_op::text, v_schema_name, v_table_name
-        );
-
-        -- Check if there are any subscriptions for this operation
-        select exists(
-            select 1
-            from pgconductor._private_event_subscriptions
-            where table_name = v_table_name
-                and schema_name = v_schema_name
-                and operation = v_op
-        ) into v_has_subscriptions;
-
-        if v_has_subscriptions then
-            -- Build if blocks to check conditions and append to arrays
-            -- Each subscription's when_clause is evaluated inside the trigger function
-            v_invoke_blocks := (
-                select string_agg(format(
-                    $sql$
-                    if %s then
-                        v_task_keys := array_append(v_task_keys, %L);
-                        v_queues := array_append(v_queues, %L);
-                        v_payloads := array_append(v_payloads, jsonb_build_object(
-                            'event', %L,
-                            'payload', jsonb_build_object(
-                                'old', case when tg_op is distinct from 'INSERT' then %s else null end,
-                                'new', case when tg_op is distinct from 'DELETE' then %s else null end,
-                                'tg_table', tg_table_name,
-                                'tg_op', tg_op
-                            )
-                        ));
-                        v_subscription_ids := array_append(v_subscription_ids, %L);
-                    end if;
-                    $sql$,
-                    coalesce(nullif(sub.when_clause, ''), 'true'),
-                    sub.task_key,
-                    t.queue,
-                    format('%s.%s.%s', v_schema_name, v_table_name, v_op::text),
-                    pgconductor._private_build_column_list(sub.column_names, 'old'),
-                    pgconductor._private_build_column_list(sub.column_names, 'new'),
-                    sub.id
-                ), e'\n')
-                from pgconductor._private_event_subscriptions as sub
-                join pgconductor._private_tasks as t on t.key = sub.task_key and t.queue = sub.queue
-                where sub.table_name = v_table_name
-                    and sub.schema_name = v_schema_name
-                    and sub.operation = v_op
-            );
-
-            -- Create trigger function
-            execute format(
-                $sql$
-                create or replace function pgconductor._private_trigger_event_%s_on_%I_%I()
-                    returns trigger
-                    language plpgsql
-                    security definer
-                    set search_path to ''
-                as $inner$
-                declare
-                    v_task_keys text[];
-                    v_queues text[];
-                    v_payloads jsonb[];
-                    v_subscription_ids uuid[];
-                begin
-                    %s
-
-                    if array_length(v_task_keys, 1) > 0 then
-                        insert into pgconductor._private_executions (task_key, queue, payload, subscription_id)
-                        select unnest(v_task_keys), unnest(v_queues), unnest(v_payloads), unnest(v_subscription_ids);
-                    end if;
-
-                    if tg_op = 'DELETE' then
-                        return old;
-                    end if;
-
-                    return new;
-                end
-                $inner$
-                $sql$,
-                v_op::text,
-                v_schema_name,
-                v_table_name,
-                v_invoke_blocks
-            );
-
-            -- Create trigger
-            execute format(
-                $sql$
-                create trigger pgconductor_event_%s
-                    after %s on %I.%I
-                    for each row
-                    execute function pgconductor._private_trigger_event_%s_on_%I_%I()
-                $sql$,
-                v_op::text,
-                upper(v_op::text),
-                v_schema_name,
-                v_table_name,
-                v_op::text,
-                v_schema_name,
-                v_table_name
-            );
-        end if;
-    end loop;
-
-    if tg_op = 'DELETE' then
-        return old;
-    end if;
-
-    return new;
-end;
-$_$;
-
-create trigger sync_database_trigger
-    after insert or delete or update on pgconductor._private_event_subscriptions
-    for each row
-    execute function pgconductor._private_sync_database_trigger();
-
-create or replace function pgconductor.emit_event(
-    p_event_key text,
-    p_payload jsonb default '{}'::jsonb
-)
-    returns uuid
-    language sql
-    volatile
-    set search_path to ''
-as $_$
-    insert into pgconductor._private_custom_events (event_key, payload)
-    values (p_event_key, p_payload)
-    returning id;
-$_$;
diff --git a/packages/pgconductor-js/package.json b/packages/pgconductor-js/package.json
index a3adf91..553de4a 100644
--- a/packages/pgconductor-js/package.json
+++ b/packages/pgconductor-js/package.json
@@ -43,8 +43,7 @@
 	"devDependencies": {
 		"@testcontainers/postgresql": "catalog:",
 		"@types/bun": "catalog:",
-		"expect-type": "catalog:",
-		"zod": "catalog:",
+		"expect-type": "catalog:"
 	},
 	"peerDependencies": {
 		"typescript": "catalog:"
@@ -53,6 +52,7 @@
 		"@standard-schema/spec": "catalog:",
 		"cron-parser": "catalog:",
 		"postgres": "catalog:",
-		"prettier": "catalog:"
+		"prettier": "catalog:",
+		"zod": "catalog:"
 	}
 }
diff --git a/packages/pgconductor-js/src/conductor.ts b/packages/pgconductor-js/src/conductor.ts
index 52116c6..144f617 100644
--- a/packages/pgconductor-js/src/conductor.ts
+++ b/packages/pgconductor-js/src/conductor.ts
@@ -20,13 +20,13 @@ import {
 	type TaskName,
 	type Trigger,
 	type ValidateTriggers,
+	type ValidateEventTriggers,
 } from "./task-definition";
-import { Worker, type WorkerConfig } from "./worker";
+import { EVENT_DISPATCH_QUEUE, Worker, type WorkerConfig } from "./worker";
 import { DefaultLogger, type Logger } from "./lib/logger";
 import { SchemaManager } from "./schema-manager";
 import type {
 	EventDefinition,
-	GenericDatabase,
 	EventName,
 	FindEventByIdentifier,
 	InferEventPayload,
@@ -34,10 +34,8 @@ import type {
 import {
 	TaskSchemas,
 	EventSchemas,
-	DatabaseSchema,
 	type InferTasksFromSchema,
 	type InferEventsFromSchema,
-	type InferDatabaseFromSchema,
 } from "./schemas";
 
 type ConnectionOptions =
@@ -67,15 +65,12 @@ type ResolvedReturns<
 export type ConductorOptions<
 	TTaskSchemas extends TaskSchemas<any> | undefined,
 	TEventSchemas extends EventSchemas<any> | undefined,
-	TDatabaseSchema extends DatabaseSchema<any> | undefined,
 	ExtraContext extends object,
 > = ConnectionOptions & {
 	tasks?: TTaskSchemas;
 
 	events?: TEventSchemas;
 
-	database?: TDatabaseSchema;
-
 	context: ExtraContext;
 
 	logger?: Logger;
@@ -86,13 +81,12 @@ export type ConductorOptions<
 export class Conductor<
 	TTaskSchemas extends TaskSchemas<any> | undefined = undefined,
 	TEventSchemas extends EventSchemas<any> | undefined = undefined,
-	TDatabaseSchema extends DatabaseSchema<any> | undefined = undefined,
 	ExtraContext extends object = {},
 	// Inferred types from schemas
 	Tasks extends readonly TaskDefinition<string, any, any, string>[] =
 		InferTasksFromSchema<TTaskSchemas>,
-	Events extends readonly EventDefinition<string, any>[] = InferEventsFromSchema<TEventSchemas>,
-	Database extends GenericDatabase = InferDatabaseFromSchema<TDatabaseSchema>,
+	Events extends readonly EventDefinition<string, any, any>[] =
+		InferEventsFromSchema<TEventSchemas>,
 > {
 	/**
 	 * @internal
@@ -107,12 +101,7 @@ export class Conductor<
 	readonly logger: Logger;
 
 	private constructor(
-		public readonly options: ConductorOptions<
-			TTaskSchemas,
-			TEventSchemas,
-			TDatabaseSchema,
-			ExtraContext
-		>,
+		public readonly options: ConductorOptions<TTaskSchemas, TEventSchemas, ExtraContext>,
 	) {
 		this.logger = options.logger || new DefaultLogger();
 
@@ -131,18 +120,16 @@ export class Conductor<
 	static create<
 		TTaskSchemas extends TaskSchemas<any> | undefined = undefined,
 		TEventSchemas extends EventSchemas<any> | undefined = undefined,
-		TDatabaseSchema extends DatabaseSchema<any> | undefined = undefined,
 		TExtraContext extends object = {},
 	>(
 		options: ConnectionOptions & {
 			tasks?: TTaskSchemas;
 			events?: TEventSchemas;
-			database?: TDatabaseSchema;
 			context: TExtraContext;
 			logger?: Logger;
 		},
-	): Conductor<TTaskSchemas, TEventSchemas, TDatabaseSchema, TExtraContext> {
-		return new Conductor<TTaskSchemas, TEventSchemas, TDatabaseSchema, TExtraContext>(options);
+	): Conductor<TTaskSchemas, TEventSchemas, TExtraContext> {
+		return new Conductor<TTaskSchemas, TEventSchemas, TExtraContext>(options);
 	}
 
 	/**
@@ -164,23 +151,21 @@ export class Conductor<
 		const TTriggers extends object | readonly object[],
 	>(
 		definition: TDef & ValidateDeadLetterConfiguration<TDef, ResolvedPayload<Tasks, TDef>>,
-		triggers: TTriggers & ValidateTriggers<Tasks, TDef["name"], TTriggers, ResolvedQueue<TDef>>,
+		triggers: TTriggers &
+			ValidateTriggers<Tasks, TDef["name"], TTriggers, ResolvedQueue<TDef>> &
+			ValidateEventTriggers<Events, TTriggers>,
 		fn: TDef extends { readonly batch: BatchConfig }
 			? ResolvedReturns<Tasks, TDef> extends void
 				? (
-						events: Array<
-							TaskEventFromTriggers<TTriggers, ResolvedPayload<Tasks, TDef>, Events, Database>
-						>,
+						events: Array<TaskEventFromTriggers<TTriggers, ResolvedPayload<Tasks, TDef>, Events>>,
 						ctx: BatchTaskContext,
 					) => Promise<void>
 				: (
-						events: Array<
-							TaskEventFromTriggers<TTriggers, ResolvedPayload<Tasks, TDef>, Events, Database>
-						>,
+						events: Array<TaskEventFromTriggers<TTriggers, ResolvedPayload<Tasks, TDef>, Events>>,
 						ctx: BatchTaskContext,
 					) => Promise<Array<ResolvedReturns<Tasks, TDef>>>
 			: (
-					event: TaskEventFromTriggers<TTriggers, ResolvedPayload<Tasks, TDef>, Events, Database>,
+					event: TaskEventFromTriggers<TTriggers, ResolvedPayload<Tasks, TDef>, Events>,
 					ctx: TaskContext<Tasks, Events> & ExtraContext,
 				) => Promise<ResolvedReturns<Tasks, TDef>>,
 	): Task<
@@ -189,7 +174,7 @@ export class Conductor<
 		ResolvedPayload<Tasks, TDef>,
 		ResolvedReturns<Tasks, TDef>,
 		TaskContext<Tasks, Events> & ExtraContext,
-		TaskEventFromTriggers<TTriggers, ResolvedPayload<Tasks, TDef>, Events, Database>
+		TaskEventFromTriggers<TTriggers, ResolvedPayload<Tasks, TDef>, Events>
 	> {
 		return Task.create<
 			TDef["name"],
@@ -197,7 +182,7 @@ export class Conductor<
 			ResolvedPayload<Tasks, TDef>,
 			ResolvedReturns<Tasks, TDef>,
 			TaskContext<Tasks, Events> & ExtraContext,
-			TaskEventFromTriggers<TTriggers, ResolvedPayload<Tasks, TDef>, Events, Database>
+			TaskEventFromTriggers<TTriggers, ResolvedPayload<Tasks, TDef>, Events>
 		>(
 			definition as TaskConfiguration<
 				TDef["name"],
@@ -206,10 +191,12 @@ export class Conductor<
 			>,
 			triggers as NonEmptyArray<Trigger> | Trigger,
 			fn as ExecuteFunction<
-				TaskEventFromTriggers<TTriggers, ResolvedPayload<Tasks, TDef>, Events, Database>,
+				TaskEventFromTriggers<TTriggers, ResolvedPayload<Tasks, TDef>, Events>,
 				ResolvedReturns<Tasks, TDef>,
 				TaskContext<Tasks, Events> & ExtraContext
 			>,
+			this.options.events?.definitions ?? [],
+			this.options.events?.hasTypeOnlyDefinitions ?? false,
 		);
 	}
 
@@ -221,6 +208,9 @@ export class Conductor<
 		tasks: ValidateTasksQueue<TQueue, TTasks>;
 		config?: Partial<WorkerConfig>;
 	}): Worker<Tasks> {
+		if (options.queue === EVENT_DISPATCH_QUEUE) {
+			throw new Error(`Queue "${EVENT_DISPATCH_QUEUE}" is reserved for internal use`);
+		}
 		return new Worker<Tasks>(
 			options.queue,
 			options.tasks as AnyTask[],
@@ -228,6 +218,9 @@ export class Conductor<
 			this.logger,
 			options.config,
 			this.options.context,
+			this.options.events?.definitions ?? [],
+			true,
+			this.options.events?.hasTypeOnlyDefinitions ?? false,
 		);
 	}
 
@@ -298,6 +291,20 @@ export class Conductor<
 		TName extends EventName<Events>,
 		TDef extends FindEventByIdentifier<Events, TName> = FindEventByIdentifier<Events, TName>,
 	>(event: TName, payload: InferEventPayload<TDef>): Promise<string> {
+		// Runtime schemas are deliberately validated before the database call. This
+		// keeps emit a persistence boundary: an invalid event can never be queued.
+		const definition = this.options.events?.definitions.find(
+			(candidate: EventDefinition<string, any, any>) => candidate.name === event,
+		);
+		const standard = (definition?.payload as any)?.["~standard"];
+		if (standard?.validate) {
+			const result = await standard.validate(payload);
+			if (result && typeof result === "object" && "issues" in result && result.issues) {
+				throw new Error(`Invalid payload for event "${String(event)}"`);
+			}
+			payload = ((result as any)?.value ?? payload) as InferEventPayload<TDef>;
+		}
+
 		return this.db.emitEvent({
 			eventKey: event,
 			payload: payload as any,
diff --git a/packages/pgconductor-js/src/database-client.ts b/packages/pgconductor-js/src/database-client.ts
index 80d4f5f..1a5e7ef 100644
--- a/packages/pgconductor-js/src/database-client.ts
+++ b/packages/pgconductor-js/src/database-client.ts
@@ -10,6 +10,7 @@ import {
 	type CountActiveOrchestratorsBelowArgs,
 	type GetExecutionsArgs,
 	type RemoveExecutionsArgs,
+	type DispatchCustomEventsArgs,
 	type RegisterWorkerArgs,
 	type ScheduleCronExecutionArgs,
 	type UnscheduleCronExecutionArgs,
@@ -19,6 +20,7 @@ import {
 	type EmitEventArgs,
 } from "./query-builder";
 import { makeChildLogger, type Logger } from "./lib/logger";
+import { buildEventDispatchDestinations } from "./event-dispatch";
 
 export type JsonValue = string | number | boolean | null | Payload | JsonValue[];
 export type Payload = { [key: string]: JsonValue };
@@ -74,6 +76,7 @@ export interface Execution {
 	dedupe_key?: string | null;
 	cron_expression?: string | null;
 	group?: string | null;
+	subscription_id?: string | null;
 	dead_letter_source_execution_id?: string | null;
 	dead_letter_source_queue?: string | null;
 	dead_letter_source_task_key?: string | null;
@@ -152,16 +155,25 @@ export interface ExecutionInvokeChild {
 	child_payload: Payload | null;
 }
 
+export type EventFilterAnchor = Record<string, JsonValue | undefined> & {
+	operator: "fallback" | "exact" | "prefix" | "numeric_range";
+	field_name?: string;
+	scalar_type?: "string" | "number" | "boolean" | "null";
+	text_value?: string;
+	number_value?: number;
+	boolean_value?: boolean;
+	lower_value?: number | null;
+	upper_value?: number | null;
+	lower_inclusive?: boolean;
+	upper_inclusive?: boolean;
+};
+
 export interface EventSubscriptionSpec {
 	task_key: string;
-	queue: string;
-	event_key: string | null;
-	schema_name: string | null;
-	table_name: string | null;
-	operation: "insert" | "update" | "delete" | null;
-	when_clause: string | null;
+	event_key: string;
 	payload_fields: string[] | null;
-	column_names: string[] | null;
+	filter: Record<string, JsonValue[]> | null;
+	anchors: EventFilterAnchor[];
 }
 
 const RETRYABLE_SQLSTATE_CODES = new Set([
@@ -581,6 +593,40 @@ export class DatabaseClient {
 		});
 	}
 
+	async dispatchCustomEvents(
+		args: DispatchCustomEventsArgs,
+		opts?: QueryMethodOptions,
+	): Promise<string[]> {
+		return this.query(
+			(sql) =>
+				sql.begin(async (transaction) => {
+					const builder = new QueryBuilder(transaction);
+					const candidates = await builder.buildGetEventDispatchCandidates(args);
+					const completedIds = new Set(
+						candidates
+							.filter((candidate) => candidate.completed)
+							.map((candidate) => candidate.event_id),
+					);
+					const pendingIds = [
+						...new Set(
+							candidates
+								.filter((candidate) => !candidate.completed)
+								.map((candidate) => candidate.event_id),
+						),
+					];
+					if (pendingIds.length === 0) return [...completedIds];
+
+					const destinations = buildEventDispatchDestinations(candidates);
+					const committed = await builder.buildCommitEventDispatches(pendingIds, destinations);
+					return [...completedIds, ...committed.map((row) => row.event_id)];
+				}),
+			{
+				label: "dispatchCustomEvents",
+				...opts,
+			},
+		);
+	}
+
 	async emitEvent(args: EmitEventArgs, opts?: QueryMethodOptions): Promise<string> {
 		const result = await this.query(() => this.builder.buildEmitEvent(args), {
 			label: "emitEvent",
diff --git a/packages/pgconductor-js/src/event-definition.ts b/packages/pgconductor-js/src/event-definition.ts
index 6825092..ee846db 100644
--- a/packages/pgconductor-js/src/event-definition.ts
+++ b/packages/pgconductor-js/src/event-definition.ts
@@ -1,11 +1,59 @@
 import type { StandardSchemaV1 } from "@standard-schema/spec";
-import type { ColumnSelectionError, SelectedRow, ValidateColumns } from "./select-columns";
 
 type ObjectSchema = StandardSchemaV1<unknown, object>;
+type EnsureObject<T> = T extends object ? T : {};
+type SchemaOutput<T> = T extends StandardSchemaV1<any, infer O> ? O : T;
+type EventPayload<T> = T extends undefined ? {} : EnsureObject<SchemaOutput<T>>;
+
+export type EventFilterScalar = string | number | boolean | null;
+type ScalarFilterValue<T> = Extract<T, EventFilterScalar>;
+
+type EventFilterPrefix = { readonly prefix: string };
+type EventFilterNumeric = {
+	readonly numeric:
+		| readonly [">" | ">=" | "<" | "<=", number]
+		| readonly [">" | ">=" | "<" | "<=", number, ">" | ">=" | "<" | "<=", number];
+};
+type EventFilterExists = { readonly exists: boolean };
+type EventFilterAnythingBut<T> = { readonly "anything-but": ScalarFilterValue<T> };
+
+type EventFilterPredicate<T> =
+	| ScalarFilterValue<T>
+	| (Extract<T, string> extends never ? never : EventFilterPrefix)
+	| (Extract<T, number> extends never ? never : EventFilterNumeric)
+	| EventFilterExists
+	| EventFilterAnythingBut<T>;
+
+export type FilterableKeys<T> = {
+	[K in keyof EventPayload<T> & string]: Exclude<
+		EventPayload<T>[K],
+		undefined
+	> extends EventFilterScalar
+		? Exclude<EventPayload<T>[K], undefined> extends never
+			? never
+			: K
+		: never;
+}[keyof EventPayload<T> & string];
+
+export type EventFilter<T> = {
+	readonly [K in FilterableKeys<T>]?: readonly EventFilterPredicate<EventPayload<T>[K]>[];
+};
+
+export type FilterForEvent<T> =
+	T extends EventDefinition<string, infer P, infer K>
+		? {
+				readonly [F in K & FilterableKeys<P>]?: readonly EventFilterPredicate<EventPayload<P>[F]>[];
+			}
+		: never;
 
-export type EventDefinition<Name extends string, Payload = undefined> = {
+export type EventDefinition<
+	Name extends string,
+	Payload = undefined,
+	Filterable extends string = never,
+> = {
 	readonly name: Name;
 	readonly payload: Payload;
+	readonly filterable?: readonly Filterable[];
 };
 
 /**
@@ -21,75 +69,43 @@ export type DefineEvent<
 	T extends {
 		name: string;
 		payload?: unknown;
+		filterable?: readonly FilterableKeys<T["payload"]>[];
 	},
-> = EventDefinition<T["name"], T extends { payload: infer P } ? P : undefined>;
+> = EventDefinition<
+	T["name"],
+	T extends { payload: infer P } ? P : undefined,
+	T extends { filterable: readonly (infer K extends string)[] } ? K : never
+>;
 
 export function defineEvent<Name extends string, Payload extends ObjectSchema>(def: {
 	name: Name;
 	payload?: Payload;
+	filterable?: undefined;
 }): EventDefinition<Name, Payload>;
+export function defineEvent<
+	Name extends string,
+	Payload extends ObjectSchema,
+	const Filterable extends readonly FilterableKeys<Payload>[],
+>(def: {
+	name: Name;
+	payload: Payload;
+	filterable: Filterable;
+}): EventDefinition<Name, Payload, Filterable[number]>;
 export function defineEvent(def: any) {
 	return def;
 }
 
-export type EventName<TEvents extends readonly EventDefinition<string, any>[]> =
+export type EventName<TEvents extends readonly EventDefinition<string, any, any>[]> =
 	TEvents[number]["name"];
 
 export type FindEventByIdentifier<
-	TEvents extends readonly EventDefinition<string, any>[],
+	TEvents extends readonly EventDefinition<string, any, any>[],
 	TName extends string,
 > = Extract<TEvents[number], { name: TName }>;
 
-type EnsureObject<T> = T extends object ? T : {};
-
 export type InferEventPayload<T> =
-	T extends EventDefinition<string, infer P>
-		? P extends undefined
-			? {}
-			: P extends StandardSchemaV1<any, infer O>
-				? EnsureObject<O>
-				: EnsureObject<P> // Plain type (type-only definition)
-		: never;
-
-export type GenericDatabase = Record<string, Record<string, unknown>>;
-export type SchemaName<TDatabase extends GenericDatabase> = keyof TDatabase;
-export type TableName<
-	TDatabase extends GenericDatabase,
-	TSchema extends SchemaName<TDatabase>,
-> = keyof TDatabase[TSchema];
-export type RowType<
-	TDatabase extends GenericDatabase,
-	TSchema extends SchemaName<TDatabase>,
-	TTable extends TableName<TDatabase, TSchema>,
-> = TDatabase[TSchema][TTable];
-export type DatabaseEventPayload<
-	TRow,
-	TOp extends "insert" | "update" | "delete",
-	TSelection extends string,
-> =
-	SelectedRow<TRow, TSelection> extends infer Selection
-		? Selection extends ColumnSelectionError<any>
-			? Selection
-			: {
-					old: TOp extends "delete" | "update" ? Selection : null;
-					new: TOp extends "insert" | "update" ? Selection : null;
-					tg_table: string;
-					tg_op: Uppercase<TOp>;
-				}
-		: never;
+	T extends EventDefinition<string, infer P, any> ? EventPayload<P> : never;
 
 export type CustomEventConfig<TName extends string> = {
 	event: TName;
 };
-export type DatabaseEventConfig<
-	TDatabase extends GenericDatabase,
-	TSchema extends SchemaName<TDatabase>,
-	TTable extends TableName<TDatabase, TSchema>,
-	TOp extends "insert" | "update" | "delete",
-	TSelection extends string = string,
-> = {
-	schema: TSchema;
-	table: TTable;
-	operation: TOp;
-	columns: ValidateColumns<TSelection, RowType<TDatabase, TSchema, TTable>>;
-};
diff --git a/packages/pgconductor-js/src/event-dispatch.ts b/packages/pgconductor-js/src/event-dispatch.ts
new file mode 100644
index 0000000..ba562b3
--- /dev/null
+++ b/packages/pgconductor-js/src/event-dispatch.ts
@@ -0,0 +1,106 @@
+import type { JsonValue, Payload } from "./database-client";
+
+export type EventDispatchCandidate = {
+	event_id: string;
+	event_key: string;
+	event_payload: Payload;
+	completed: boolean;
+	subscription_id: string | null;
+	task_key: string | null;
+	queue: string | null;
+	payload_fields: string[] | null;
+	filter: Record<string, JsonValue[]> | null;
+};
+
+export type EventDispatchDestination = {
+	eventId: string;
+	subscriptionId: string;
+	taskKey: string;
+	queue: string;
+	payload: Payload;
+};
+
+function isScalar(value: unknown): value is string | number | boolean | null {
+	return value === null || ["string", "number", "boolean"].includes(typeof value);
+}
+
+function exactMatch(left: unknown, right: unknown): boolean {
+	return isScalar(left) && isScalar(right) && typeof left === typeof right && left === right;
+}
+
+function predicateMatches(present: boolean, value: unknown, predicate: JsonValue): boolean {
+	if (isScalar(predicate)) return present && exactMatch(value, predicate);
+	if (Array.isArray(predicate)) return false;
+
+	switch (predicate.$operator) {
+		case "prefix":
+			return (
+				present &&
+				typeof value === "string" &&
+				typeof predicate.value === "string" &&
+				value.startsWith(predicate.value)
+			);
+		case "numeric_range": {
+			if (!present || typeof value !== "number") return false;
+			const lower = predicate.lower as number | null;
+			const upper = predicate.upper as number | null;
+			return (
+				(lower === null || (predicate.lowerInclusive === true ? value >= lower : value > lower)) &&
+				(upper === null || (predicate.upperInclusive === true ? value <= upper : value < upper))
+			);
+		}
+		case "exists":
+			return present === predicate.value;
+		case "anything_but":
+			return present && isScalar(value) && !exactMatch(value, predicate.value);
+		default:
+			return false;
+	}
+}
+
+export function eventFilterMatches(
+	payload: Payload,
+	filter: Record<string, JsonValue[]> | null,
+): boolean {
+	if (!filter) return true;
+	return Object.entries(filter).every(([field, predicates]) => {
+		const present = Object.hasOwn(payload, field);
+		const value = payload[field];
+		return predicates.some((predicate) => predicateMatches(present, value, predicate));
+	});
+}
+
+function projectPayload(payload: Payload, fields: string[] | null): Payload {
+	if (!fields) return payload;
+	return Object.fromEntries(
+		fields.filter((field) => Object.hasOwn(payload, field)).map((field) => [field, payload[field]]),
+	) as Payload;
+}
+
+export function buildEventDispatchDestinations(
+	candidates: EventDispatchCandidate[],
+): EventDispatchDestination[] {
+	return candidates.flatMap((candidate) => {
+		if (
+			candidate.completed ||
+			!candidate.subscription_id ||
+			!candidate.task_key ||
+			!candidate.queue ||
+			!eventFilterMatches(candidate.event_payload, candidate.filter)
+		) {
+			return [];
+		}
+		return [
+			{
+				eventId: candidate.event_id,
+				subscriptionId: candidate.subscription_id,
+				taskKey: candidate.task_key,
+				queue: candidate.queue,
+				payload: {
+					event: candidate.event_key,
+					payload: projectPayload(candidate.event_payload, candidate.payload_fields),
+				},
+			},
+		];
+	});
+}
diff --git a/packages/pgconductor-js/src/event-trigger-validation.ts b/packages/pgconductor-js/src/event-trigger-validation.ts
new file mode 100644
index 0000000..014b366
--- /dev/null
+++ b/packages/pgconductor-js/src/event-trigger-validation.ts
@@ -0,0 +1,381 @@
+import { z } from "zod";
+import type { EventDefinition } from "./event-definition";
+import type { EventFilterAnchor, EventSubscriptionSpec, JsonValue } from "./database-client";
+
+const EVENT_FIELD_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const MAX_EVENT_NAME_BYTES = 255;
+const MAX_EVENT_FIELD_BYTES = 128;
+const MAX_FILTER_VALUE_BYTES = 1024;
+const MAX_FILTER_FIELDS = 8;
+const MAX_FILTER_ALTERNATIVES = 4;
+const MAX_PREFIX_CHARACTERS = 64;
+
+const EVENT_TRIGGER_SCHEMA = z.looseObject({
+	event: z
+		.string({ error: "Custom event triggers require a non-empty event name" })
+		.refine(
+			(value) => value.trim().length > 0,
+			"Custom event triggers require a non-empty event name",
+		),
+	fields: z.unknown().optional(),
+	filter: z.unknown().optional(),
+});
+const FILTER_SCALAR_SCHEMA = z.union([z.string(), z.number().finite(), z.boolean(), z.null()], {
+	error: "requires one scalar value",
+});
+const FILTER_SCHEMA = z.record(
+	z.string(),
+	z
+		.array(z.unknown(), { error: "must be an array" })
+		.min(1, "cannot be empty")
+		.max(MAX_FILTER_ALTERNATIVES, "supports at most 4 values"),
+);
+const NUMERIC_OPERATOR_SCHEMA = z.enum([">", ">=", "<", "<="], {
+	error: "has an unsupported operator",
+});
+const FINITE_NUMBER_SCHEMA = z
+	.number({ error: "requires finite operands" })
+	.finite("requires finite operands");
+const PREFIX_SCHEMA = z
+	.string({ error: "must be a non-empty string" })
+	.min(1, "must be a non-empty string")
+	.refine((value) => Array.from(value).length <= MAX_PREFIX_CHARACTERS, "exceeds 64 characters");
+const EXISTS_SCHEMA = z.boolean({ error: "must be boolean" });
+
+type FilterScalar = z.infer<typeof FILTER_SCALAR_SCHEMA>;
+export type CanonicalEventPredicate = JsonValue;
+export type CanonicalEventFilter = Record<string, CanonicalEventPredicate[]>;
+
+function parse<T>(schema: z.ZodType<T>, value: unknown, context: string): T {
+	const parsed = schema.safeParse(value);
+	if (parsed.success) return parsed.data;
+	const message = parsed.error.issues[0]?.message || "is invalid";
+	throw new Error(`${context} ${message}`);
+}
+
+function utf8ByteLength(value: string): number {
+	return new TextEncoder().encode(value).length;
+}
+
+function assertFieldName(field: string, eventName: string): void {
+	if (!EVENT_FIELD_PATTERN.test(field)) {
+		throw new Error(`Fields for event "${eventName}" contains invalid field "${field}"`);
+	}
+	if (utf8ByteLength(field) > MAX_EVENT_FIELD_BYTES) {
+		throw new Error(`Field "${field}" for event "${eventName}" exceeds 128 UTF-8 bytes`);
+	}
+}
+
+export function parseEventPayloadFields(fields: unknown, eventName: string): string[] | null {
+	if (fields === undefined) return null;
+	const value = parse(
+		z.string({ error: "must be a comma-separated string" }),
+		fields,
+		`Fields for event "${eventName}"`,
+	);
+	const selected = value.split(",").map((field) => field.trim());
+	if (selected.some((field) => field.length === 0)) {
+		throw new Error(`Fields for event "${eventName}" cannot contain empty names`);
+	}
+	for (const field of selected) assertFieldName(field, eventName);
+	if (new Set(selected).size !== selected.length) {
+		throw new Error(`Fields for event "${eventName}" cannot contain duplicate names`);
+	}
+	return selected;
+}
+
+function scalarSortKey(value: FilterScalar): string {
+	if (value === null) return "0:null";
+	if (typeof value === "boolean") return `1:${value ? "true" : "false"}`;
+	if (typeof value === "number") return `2:${JSON.stringify(value)}`;
+	return `3:${JSON.stringify(value)}`;
+}
+
+function assertScalarSize(value: FilterScalar, eventName: string, field: string): void {
+	if (utf8ByteLength(JSON.stringify(value)) > MAX_FILTER_VALUE_BYTES) {
+		throw new Error(
+			`Filter value for event "${eventName}" field "${field}" exceeds 1024 UTF-8 bytes`,
+		);
+	}
+}
+
+function canonicalNumericRange(
+	value: unknown,
+	eventName: string,
+	field: string,
+): CanonicalEventPredicate {
+	const context = `Numeric filter for event "${eventName}" field "${field}"`;
+	const values = parse(
+		z.array(z.unknown()).refine((items) => items.length === 2 || items.length === 4, {
+			message: "must contain one or two operator/value pairs",
+		}),
+		value,
+		context,
+	);
+
+	let lower: number | null = null;
+	let lowerInclusive = false;
+	let upper: number | null = null;
+	let upperInclusive = false;
+	for (let index = 0; index < values.length; index += 2) {
+		const operator = parse(NUMERIC_OPERATOR_SCHEMA, values[index], context);
+		const operand = parse(FINITE_NUMBER_SCHEMA, values[index + 1], context);
+		if (operator === ">" || operator === ">=") {
+			if (lower !== null) throw new Error(`${context} contains duplicate lower bounds`);
+			lower = operand;
+			lowerInclusive = operator === ">=";
+		} else {
+			if (upper !== null) throw new Error(`${context} contains duplicate upper bounds`);
+			upper = operand;
+			upperInclusive = operator === "<=";
+		}
+	}
+	if (
+		lower !== null &&
+		upper !== null &&
+		(lower > upper || (lower === upper && (!lowerInclusive || !upperInclusive)))
+	) {
+		throw new Error(`${context} is empty`);
+	}
+	return { $operator: "numeric_range", lower, lowerInclusive, upper, upperInclusive };
+}
+
+function canonicalPredicate(
+	value: unknown,
+	eventName: string,
+	field: string,
+): CanonicalEventPredicate {
+	const scalar = FILTER_SCALAR_SCHEMA.safeParse(value);
+	if (scalar.success) {
+		assertScalarSize(scalar.data, eventName, field);
+		return scalar.data;
+	}
+
+	const context = `Filter for event "${eventName}" field "${field}"`;
+	const operator = parse(z.record(z.string(), z.unknown()), value, context);
+	const entries = Object.entries(operator);
+	if (entries.length !== 1) {
+		throw new Error(`${context} operator must contain exactly one key`);
+	}
+	const entry = entries[0];
+	if (!entry) throw new Error(`${context} operator must contain exactly one key`);
+	const [name, operand] = entry;
+
+	switch (name) {
+		case "prefix": {
+			const prefix = parse(
+				PREFIX_SCHEMA,
+				operand,
+				`Prefix filter for event "${eventName}" field "${field}"`,
+			);
+			assertScalarSize(prefix, eventName, field);
+			return { $operator: "prefix", value: prefix };
+		}
+		case "numeric":
+			return canonicalNumericRange(operand, eventName, field);
+		case "exists":
+			return {
+				$operator: "exists",
+				value: parse(
+					EXISTS_SCHEMA,
+					operand,
+					`Exists filter for event "${eventName}" field "${field}"`,
+				),
+			};
+		case "anything-but": {
+			const scalarOperand = parse(
+				FILTER_SCALAR_SCHEMA,
+				operand,
+				`Anything-but filter for event "${eventName}" field "${field}"`,
+			);
+			assertScalarSize(scalarOperand, eventName, field);
+			return { $operator: "anything_but", value: scalarOperand };
+		}
+		default:
+			throw new Error(`${context} uses unsupported operator "${name}"`);
+	}
+}
+
+function predicateSortKey(value: CanonicalEventPredicate): string {
+	const scalar = FILTER_SCALAR_SCHEMA.safeParse(value);
+	return scalar.success ? `0:${scalarSortKey(scalar.data)}` : `1:${JSON.stringify(value)}`;
+}
+
+function canonicalFilter(
+	filter: unknown,
+	eventName: string,
+	definition: EventDefinition<string, any, any> | undefined,
+	allowUnknownEvents: boolean,
+): CanonicalEventFilter | null {
+	if (filter === undefined || filter === null) return null;
+	parse(FILTER_SCHEMA, filter, `Filter for event "${eventName}"`);
+	const entries = Object.entries(filter as Record<string, unknown[]>);
+	if (entries.length > MAX_FILTER_FIELDS) {
+		throw new Error(`Filter for event "${eventName}" supports at most 8 fields`);
+	}
+	if (!definition && !allowUnknownEvents) {
+		throw new Error(`Filtered event "${eventName}" has no runtime event definition`);
+	}
+
+	const allowed = definition ? new Set(definition.filterable || []) : null;
+	const canonical: CanonicalEventFilter = Object.create(null) as CanonicalEventFilter;
+	for (const [field, values] of entries.sort(([left], [right]) => left.localeCompare(right))) {
+		if (field.trim().length === 0) {
+			throw new Error(`Filter for event "${eventName}" cannot contain empty field names`);
+		}
+		if (utf8ByteLength(field) > MAX_EVENT_FIELD_BYTES) {
+			throw new Error(`Filter field "${field}" for event "${eventName}" exceeds 128 UTF-8 bytes`);
+		}
+		if (allowed && !allowed.has(field)) {
+			throw new Error(`Filter for event "${eventName}" contains undeclared field "${field}"`);
+		}
+
+		const predicates = values.map((value) => canonicalPredicate(value, eventName, field));
+		if (
+			predicates.length > 1 &&
+			predicates.some(
+				(predicate) =>
+					typeof predicate === "object" &&
+					predicate !== null &&
+					!Array.isArray(predicate) &&
+					predicate.$operator === "anything_but",
+			)
+		) {
+			throw new Error(
+				`Anything-but filter for event "${eventName}" field "${field}" must be atomic`,
+			);
+		}
+		const unique = new Map(predicates.map((predicate) => [predicateSortKey(predicate), predicate]));
+		canonical[field] = [...unique.entries()]
+			.sort(([left], [right]) => left.localeCompare(right))
+			.map(([, predicate]) => predicate);
+	}
+	return canonical;
+}
+
+function fallbackAnchor(): EventFilterAnchor {
+	return { operator: "fallback" };
+}
+
+function anchorForPredicate(field: string, predicate: CanonicalEventPredicate): EventFilterAnchor {
+	if (predicate === null) {
+		return { field_name: field, operator: "exact", scalar_type: "null" };
+	}
+	if (typeof predicate === "string") {
+		return {
+			field_name: field,
+			operator: "exact",
+			scalar_type: "string",
+			text_value: predicate,
+		};
+	}
+	if (typeof predicate === "number") {
+		return {
+			field_name: field,
+			operator: "exact",
+			scalar_type: "number",
+			number_value: predicate,
+		};
+	}
+	if (typeof predicate === "boolean") {
+		return {
+			field_name: field,
+			operator: "exact",
+			scalar_type: "boolean",
+			boolean_value: predicate,
+		};
+	}
+
+	const operator = predicate as Record<string, JsonValue>;
+	if (operator.$operator === "prefix") {
+		return {
+			field_name: field,
+			operator: "prefix",
+			scalar_type: "string",
+			text_value: operator.value as string,
+		};
+	}
+	return {
+		field_name: field,
+		operator: "numeric_range",
+		scalar_type: "number",
+		lower_value: operator.lower as number | null,
+		upper_value: operator.upper as number | null,
+		lower_inclusive: operator.lowerInclusive as boolean,
+		upper_inclusive: operator.upperInclusive as boolean,
+	};
+}
+
+export function compileEventFilterAnchors(
+	filter: CanonicalEventFilter | null,
+): EventFilterAnchor[] {
+	if (!filter || Object.keys(filter).length === 0) return [fallbackAnchor()];
+
+	const candidates = Object.entries(filter).flatMap(([field, predicates]) => {
+		const anchors = predicates.flatMap((predicate) => {
+			if (typeof predicate === "object" && predicate !== null) {
+				if (Array.isArray(predicate)) return [];
+				const operator = (predicate as Record<string, JsonValue>).$operator;
+				if (operator !== "prefix" && operator !== "numeric_range") return [];
+			}
+			return [anchorForPredicate(field, predicate)];
+		});
+		if (anchors.length !== predicates.length) return [];
+		const rank = Math.max(
+			...anchors.map((anchor) => {
+				if (anchor.operator === "exact") return 1;
+				if (anchor.operator === "prefix") return 2;
+				return 3;
+			}),
+		);
+		return [{ field, rank, anchors }];
+	});
+	candidates.sort((left, right) => left.rank - right.rank || left.field.localeCompare(right.field));
+	return candidates[0]?.anchors ?? [fallbackAnchor()];
+}
+
+export type CompiledEventTrigger = Pick<
+	EventSubscriptionSpec,
+	"event_key" | "payload_fields" | "filter" | "anchors"
+>;
+
+/** Validate and canonicalize one trigger. Non-event triggers return null. */
+export function compileEventTrigger(
+	trigger: object,
+	eventDefinitions: readonly EventDefinition<string, any, any>[],
+	allowUnknownEvents = false,
+): CompiledEventTrigger | null {
+	if (!("event" in trigger)) return null;
+	const candidate = parse(EVENT_TRIGGER_SCHEMA, trigger, "Custom event trigger");
+	const eventName = candidate.event;
+	if (utf8ByteLength(eventName) > MAX_EVENT_NAME_BYTES) {
+		throw new Error(`Event "${eventName}" exceeds 255 UTF-8 bytes`);
+	}
+	if ("when" in trigger) {
+		throw new Error(`Custom event "${eventName}" does not support a when clause`);
+	}
+
+	const definition = eventDefinitions.find((event) => event.name === eventName);
+	if (eventDefinitions.length > 0 && !definition && !allowUnknownEvents) {
+		throw new Error(`Event "${eventName}" is not defined in the conductor event catalog`);
+	}
+	const filter = canonicalFilter(candidate.filter, eventName, definition, allowUnknownEvents);
+	return {
+		event_key: eventName,
+		payload_fields: parseEventPayloadFields(candidate.fields, eventName),
+		filter,
+		anchors: compileEventFilterAnchors(filter),
+	};
+}
+
+export function compileEventTriggers(
+	triggers: object | readonly object[],
+	eventDefinitions: readonly EventDefinition<string, any, any>[],
+	allowUnknownEvents = false,
+): CompiledEventTrigger[] {
+	const list = Array.isArray(triggers) ? triggers : [triggers];
+	return list.flatMap((trigger) => {
+		const compiled = compileEventTrigger(trigger, eventDefinitions, allowUnknownEvents);
+		return compiled ? [compiled] : [];
+	});
+}
diff --git a/packages/pgconductor-js/src/generated/sql.ts b/packages/pgconductor-js/src/generated/sql.ts
index 199045a..3235054 100644
--- a/packages/pgconductor-js/src/generated/sql.ts
+++ b/packages/pgconductor-js/src/generated/sql.ts
@@ -15,6 +15,8 @@ create table if not exists pgconductor.schema_migrations (
 `,
   "0000000001_setup.sql": String.raw`
 
+create extension if not exists btree_gist;
+
 -- Returns either the actual current timestamp or a fake one for tests.
 -- Uses session variable (current_setting) for test time control.
 create function pgconductor._private_current_time ()
@@ -120,6 +122,7 @@ create table pgconductor._private_executions (
     waiting_on_execution_id uuid,
     waiting_step_key text,
     parent_execution_id uuid,
+    subscription_id uuid,
     singleton_on timestamptz,
 
     -- Dead-letter metadata is denormalized so retained source rows are optional.
@@ -130,7 +133,9 @@ create table pgconductor._private_executions (
     dead_letter_attempts integer,
     dead_letter_failed_at timestamptz,
     primary key (id, queue),
-    unique (task_key, dedupe_key, queue)
+    unique (task_key, dedupe_key, queue),
+    constraint chk_executions_event_delivery_parent
+        check (subscription_id is null or parent_execution_id is not null)
 ) partition by list (queue);
 
 -- unique index for singleton throttle/debounce enforcement on parent table
@@ -294,7 +299,11 @@ begin
     RETURN NEW;
 
   elsif tg_op = 'UPDATE' then
-    -- protect default queue from modification
+    -- protect queues required by the runtime
+    if old.name = 'pgconductor.internal' or new.name = 'pgconductor.internal' then
+      raise exception 'Modifying the internal queue is not allowed';
+    end if;
+
     if old.name = 'default' or new.name = 'default' then
       raise exception 'Modifying the default queue is not allowed';
     end if;
@@ -307,7 +316,11 @@ begin
     return new;
 
   elsif tg_op = 'DELETE' then
-    -- protect default queue from deletion
+    -- protect queues required by the runtime
+    if old.name = 'pgconductor.internal' then
+      raise exception 'Deleting the internal queue is not allowed';
+    end if;
+
     if old.name = 'default' then
       raise exception 'Deleting the default queue is not allowed';
     end if;
@@ -371,22 +384,12 @@ create type pgconductor.task_spec as (
     dead_letter_task_key text
 );
 
-create type pgconductor._private_event_operation as enum (
-    'insert',
-    'update',
-    'delete'
-);
-
 create type pgconductor.event_subscription_spec as (
     task_key text,
-    queue text,
     event_key text,
-    schema_name text,
-    table_name text,
-    operation pgconductor._private_event_operation,
-    when_clause text,
     payload_fields text[],
-    column_names text[]
+    filter jsonb,
+    anchors jsonb
 );
 
 create or replace function pgconductor._private_register_worker(
@@ -401,19 +404,35 @@ volatile
 set search_path to ''
 as $function$
 begin
-  -- step 1: upsert queue (triggers partition creation)
+  -- Upsert every required queue in a stable order (triggers partition
+  -- creation).  Registrations may reference one another as dead-letter queues,
+  -- so queue creation and locking share a global order.
   insert into pgconductor._private_queues (name)
-  values (p_queue_name)
+  select required.name
+  from (
+    select p_queue_name as name
+    union
+    select spec.dead_letter_queue
+    from unnest(p_task_specs) as spec
+    where spec.dead_letter_queue is not null
+  ) required
+  order by required.name
   on conflict (name) do nothing;
 
-  -- Dead-letter destinations may not have a worker yet; create their partitions.
-  insert into pgconductor._private_queues (name)
-  select distinct spec.dead_letter_queue
-  from unnest(p_task_specs) as spec
-  where spec.dead_letter_queue is not null
-  on conflict (name) do nothing;
+  -- Queue row locks are the only registration locks; acquire them in order.
+  perform 1
+  from pgconductor._private_queues queue
+  where queue.name in (
+    select p_queue_name
+    union
+    select spec.dead_letter_queue
+    from unnest(p_task_specs) as spec
+    where spec.dead_letter_queue is not null
+  )
+  order by queue.name
+  for update;
 
-  -- step 2: register/update tasks
+  -- Register/update tasks.
   insert into pgconductor._private_tasks (key, queue, max_attempts, remove_on_complete_days, remove_on_fail_days, window_start, window_end, concurrency_limit, group_concurrency_limit, dead_letter_queue, dead_letter_task_key)
   select
     spec.key,
@@ -441,7 +460,7 @@ begin
     dead_letter_queue = excluded.dead_letter_queue,
     dead_letter_task_key = excluded.dead_letter_task_key;
 
-  -- step 3: insert scheduled cron executions
+  -- Insert scheduled cron executions.
   insert into pgconductor._private_executions (task_key, queue, payload, run_at, dedupe_key, cron_expression, "group")
   select
     spec.task_key,
@@ -459,8 +478,7 @@ begin
     cron_expression = excluded.cron_expression,
     "group" = excluded."group";
 
-  -- step 4: clean up stale schedules for this queue
-  -- delete future executions for schedules that no longer exist
+  -- Clean up stale schedules for this queue.
   delete from pgconductor._private_executions
   where queue = p_queue_name
     and cron_expression is not null
@@ -472,7 +490,6 @@ begin
       where spec.dedupe_key is not null and spec.dedupe_key like 'scheduled::%'
     );
 
-  -- mark running executions as cancelled for schedules that no longer exist
   update pgconductor._private_executions
   set cancelled = true
   where queue = p_queue_name
@@ -488,59 +505,10 @@ begin
       where spec.dedupe_key is not null and spec.dedupe_key like 'scheduled::%'
     );
 
-  -- step 5: manage event subscriptions (only recreate triggers when subscriptions change)
-  merge into pgconductor._private_event_subscriptions as target
-  using (
-    select
-      s.task_key,
-      s.queue,
-      s.event_key,
-      s.schema_name,
-      s.table_name,
-      s.operation,
-      s.when_clause,
-      s.payload_fields,
-      s.column_names
-    from unnest(p_event_subscriptions) as s
-  ) as source
-  on (
-    target.queue = source.queue and
-    target.task_key = source.task_key and
-    coalesce(target.event_key, '') = coalesce(source.event_key, '') and
-    coalesce(target.schema_name, '') = coalesce(source.schema_name, '') and
-    coalesce(target.table_name, '') = coalesce(source.table_name, '') and
-    coalesce(target.operation::text, '') = coalesce(source.operation::text, '') and
-    coalesce(target.when_clause, '') = coalesce(source.when_clause, '') and
-    coalesce(array_to_string(target.payload_fields, ','), '') =
-      coalesce(array_to_string(source.payload_fields, ','), '') and
-    coalesce(array_to_string(target.column_names, ','), '') =
-      coalesce(array_to_string(source.column_names, ','), '')
-  )
-  when not matched then insert (
-    task_key, queue, event_key, schema_name, table_name, operation,
-    when_clause, payload_fields, column_names
-  ) values (
-    source.task_key, source.queue, source.event_key,
-    source.schema_name, source.table_name, source.operation,
-    source.when_clause, source.payload_fields, source.column_names
+  perform pgconductor._private_replace_custom_event_subscriptions(
+    p_queue_name,
+    p_event_subscriptions
   );
-
-  -- step 6: delete old subscriptions for this queue not in new set
-  delete from pgconductor._private_event_subscriptions target
-  where target.queue = p_queue_name
-    and not exists (
-      select 1 from unnest(p_event_subscriptions) source
-      where target.task_key = source.task_key
-        and coalesce(target.event_key, '') = coalesce(source.event_key, '')
-        and coalesce(target.schema_name, '') = coalesce(source.schema_name, '')
-        and coalesce(target.table_name, '') = coalesce(source.table_name, '')
-        and coalesce(target.operation::text, '') = coalesce(source.operation::text, '')
-        and coalesce(target.when_clause, '') = coalesce(source.when_clause, '')
-        and coalesce(array_to_string(target.payload_fields, ','), '') =
-          coalesce(array_to_string(source.payload_fields, ','), '')
-        and coalesce(array_to_string(target.column_names, ','), '') =
-          coalesce(array_to_string(source.column_names, ','), '')
-    );
 end;
 $function$;
 
@@ -924,353 +892,235 @@ begin
 end;
 $function$;
 
-`,
-  "0000000002_events.sql": String.raw`
-alter table pgconductor._private_executions
-    add column if not exists subscription_id uuid;
+-- Event deliveries use the source dispatch execution as durable lineage without
+-- participating in workflow parent/child settlement.
+create unique index idx_executions_event_destination
+    on pgconductor._private_executions (parent_execution_id, subscription_id, queue)
+    where subscription_id is not null;
 
-create table if not exists pgconductor._private_custom_events (
-    id uuid default pgconductor._private_portable_uuidv7() not null,
-    event_key text not null,
-    payload jsonb not null default '{}'::jsonb,
-    created_at timestamptz default pgconductor._private_current_time() not null,
-    primary key (created_at, id)
-) partition by range (created_at);
-
-create index if not exists idx_custom_events_event_key
-    on pgconductor._private_custom_events (event_key, created_at desc);
-
--- Create initial partition for custom events (will cover many years)
-create table if not exists pgconductor._private_custom_events_default
-    partition of pgconductor._private_custom_events
-    for values from (minvalue) to (maxvalue);
-
-create table if not exists pgconductor._private_event_subscriptions (
+create table pgconductor._private_custom_event_subscriptions (
     id uuid primary key default pgconductor._private_portable_uuidv7(),
-
+    event_key text not null,
     task_key text not null,
     queue text not null,
-
-    event_key text,
-    schema_name text,
-    table_name text,
-    operation pgconductor._private_event_operation,
-
-    when_clause text,
     payload_fields text[],
-    column_names text[],
-
+    filter jsonb not null default '{}'::jsonb,
     created_at timestamptz not null default pgconductor._private_current_time(),
-
-    constraint chk_event_type check (
-        (event_key is not null and schema_name is null and table_name is null and operation is null)
-        or
-        (event_key is null and schema_name is not null and table_name is not null and operation is not null)
+    constraint chk_custom_event_subscription_event_key check (
+        btrim(event_key) <> '' and octet_length(event_key) between 1 and 255
+    ),
+    constraint chk_custom_event_subscription_filter check (
+        jsonb_typeof(filter) = 'object'
     )
 );
 
-create index if not exists idx_event_subscriptions_custom
-    on pgconductor._private_event_subscriptions (event_key)
-    where event_key is not null;
+create index idx_custom_event_subscriptions_event
+    on pgconductor._private_custom_event_subscriptions (event_key, id);
 
-create index if not exists idx_event_subscriptions_database
-    on pgconductor._private_event_subscriptions (schema_name, table_name, operation)
-    where schema_name is not null;
-
-create or replace function pgconductor._private_sync_custom_event_trigger()
-    returns trigger
-    language plpgsql
-    security definer
-    set search_path to ''
-as $_$
-declare
-    v_invoke_blocks text;
-    v_has_subscriptions boolean;
-begin
-    -- Only process custom event subscriptions (event_key is not null)
-    if coalesce(new.event_key, old.event_key) is null then
-        return coalesce(new, old);
-    end if;
-
-    drop trigger if exists pgconductor_custom_event on pgconductor._private_custom_events;
-    drop function if exists pgconductor._private_trigger_custom_event;
-
-    select exists(
-        select 1
-        from pgconductor._private_event_subscriptions
-        where event_key is not null
-    ) into v_has_subscriptions;
-
-    if v_has_subscriptions then
-        v_invoke_blocks := (
-            select string_agg(format(
-                $sql$
-                if new.event_key = %L and (%s) then
-                    v_task_keys := array_append(v_task_keys, %L);
-                    v_queues := array_append(v_queues, %L);
-                    v_payloads := array_append(v_payloads, jsonb_build_object('event', new.event_key, 'payload', %s));
-                    v_subscription_ids := array_append(v_subscription_ids, %L);
-                end if;
-                $sql$,
-                sub.event_key,
-                coalesce(nullif(sub.when_clause, ''), 'true'),
-                sub.task_key,
-                t.queue,
-                pgconductor._private_build_payload_fields(sub.payload_fields, 'new.payload'),
-                sub.id
-            ), e'\n')
-            from pgconductor._private_event_subscriptions as sub
-            join pgconductor._private_tasks as t on t.key = sub.task_key and t.queue = sub.queue
-            where sub.event_key is not null
-        );
-
-        execute format(
-            $sql$
-            create or replace function pgconductor._private_trigger_custom_event()
-                returns trigger
-                language plpgsql
-                security definer
-                set search_path to ''
-            as $inner$
-            declare
-                v_task_keys text[];
-                v_queues text[];
-                v_payloads jsonb[];
-                v_subscription_ids uuid[];
-            begin
-                %s
-
-                if array_length(v_task_keys, 1) > 0 then
-                    insert into pgconductor._private_executions (task_key, queue, payload, subscription_id)
-                    select unnest(v_task_keys), unnest(v_queues), unnest(v_payloads), unnest(v_subscription_ids);
-                end if;
-
-                return new;
-            end
-            $inner$
-            $sql$,
-            v_invoke_blocks
-        );
-
-        execute $sql$
-            create trigger pgconductor_custom_event
-                after insert on pgconductor._private_custom_events
-                for each row
-                execute function pgconductor._private_trigger_custom_event()
-        $sql$;
-    end if;
-
-    if tg_op = 'DELETE' then
-        return old;
-    end if;
+-- TypeScript compiles and validates complete filters once. Postgres stores only
+-- the candidate-safe alternatives from one clause, or one fallback row when no
+-- selective clause exists.
+create table pgconductor._private_event_filter_anchors (
+    subscription_id uuid not null,
+    anchor_number smallint not null check (anchor_number > 0),
+    event_key text not null,
+    field_name text,
+    operator text not null check (
+        operator in ('fallback', 'exact', 'prefix', 'numeric_range')
+    ),
+    scalar_type text check (scalar_type in ('string', 'number', 'boolean', 'null')),
+    text_value text,
+    number_value numeric,
+    boolean_value boolean,
+    prefix_length smallint generated always as (
+        case when operator = 'prefix' then length(text_value)::smallint end
+    ) stored,
+    number_range numrange,
+    primary key (subscription_id, anchor_number),
+    constraint fk_event_filter_anchor_subscription foreign key (subscription_id)
+        references pgconductor._private_custom_event_subscriptions(id) on delete cascade
+);
 
-    return new;
-end;
-$_$;
+create index idx_event_filter_anchor_fallback
+    on pgconductor._private_event_filter_anchors (event_key, subscription_id)
+    where operator = 'fallback';
+create index idx_event_filter_anchor_exact_text
+    on pgconductor._private_event_filter_anchors
+       (event_key collate "C", field_name collate "C", text_value collate "C", subscription_id)
+    where operator = 'exact' and scalar_type = 'string';
+create index idx_event_filter_anchor_exact_number
+    on pgconductor._private_event_filter_anchors
+       (event_key, field_name, number_value, subscription_id)
+    where operator = 'exact' and scalar_type = 'number';
+create index idx_event_filter_anchor_exact_boolean
+    on pgconductor._private_event_filter_anchors
+       (event_key, field_name, boolean_value, subscription_id)
+    where operator = 'exact' and scalar_type = 'boolean';
+create index idx_event_filter_anchor_exact_null
+    on pgconductor._private_event_filter_anchors
+       (event_key, field_name, subscription_id)
+    where operator = 'exact' and scalar_type = 'null';
+create index idx_event_filter_anchor_prefix
+    on pgconductor._private_event_filter_anchors
+       (event_key collate "C", field_name collate "C", prefix_length,
+        text_value collate "C", subscription_id)
+    where operator = 'prefix';
+create index idx_event_filter_anchor_numeric_range
+    on pgconductor._private_event_filter_anchors using gist
+       (event_key, field_name, number_range, subscription_id)
+    where operator = 'numeric_range';
+
+-- Persistent worker subscriptions are replaced as one queue-scoped snapshot.
+-- The private transport is already compiled; SQL only persists subscriptions
+-- and converts their candidate anchors into indexed typed columns.
+create or replace function pgconductor._private_replace_custom_event_subscriptions(
+    p_queue_name text,
+    p_subscriptions pgconductor.event_subscription_spec[]
+)
+returns void
+language sql
+volatile
+set search_path to ''
+as $function$
+    with removed as materialized (
+        delete from pgconductor._private_custom_event_subscriptions
+        where queue = p_queue_name
+        returning id
+    ), input as materialized (
+        select task_key, event_key, payload_fields,
+            coalesce(filter, '{}'::jsonb) as filter,
+            coalesce(anchors, '[]'::jsonb) as anchors,
+            input_ordinal
+        from unnest(p_subscriptions) with ordinality
+          as subscription(task_key, event_key, payload_fields, filter, anchors, input_ordinal)
+        cross join (select count(*) from removed) removal_barrier
+    ), prepared as materialized (
+        select pgconductor._private_portable_uuidv7() as id, input.*
+        from input
+    ), inserted_subscriptions as (
+        insert into pgconductor._private_custom_event_subscriptions (
+            id, event_key, task_key, queue, payload_fields, filter
+        )
+        select id, event_key, task_key, p_queue_name, payload_fields, filter
+        from prepared
+        order by input_ordinal
+        returning id
+    ), anchors as materialized (
+        select prepared.id as subscription_id, prepared.event_key,
+            anchor.ordinality::smallint as anchor_number,
+            fields.field_name, fields.operator, fields.scalar_type,
+            fields.text_value, fields.number_value, fields.boolean_value,
+            fields.lower_value, fields.upper_value,
+            fields.lower_inclusive, fields.upper_inclusive
+        from prepared
+        cross join lateral jsonb_array_elements(prepared.anchors)
+            with ordinality as anchor(value, ordinality)
+        cross join lateral jsonb_to_record(anchor.value) as fields(
+            field_name text,
+            operator text,
+            scalar_type text,
+            text_value text,
+            number_value numeric,
+            boolean_value boolean,
+            lower_value numeric,
+            upper_value numeric,
+            lower_inclusive boolean,
+            upper_inclusive boolean
+        )
+    )
+    insert into pgconductor._private_event_filter_anchors (
+        subscription_id, anchor_number, event_key, field_name, operator,
+        scalar_type, text_value, number_value, boolean_value, number_range
+    )
+    select
+        anchors.subscription_id,
+        anchors.anchor_number,
+        anchors.event_key,
+        anchors.field_name,
+        anchors.operator,
+        anchors.scalar_type,
+        anchors.text_value,
+        anchors.number_value,
+        anchors.boolean_value,
+        case when anchors.operator = 'numeric_range' then numrange(
+            anchors.lower_value,
+            anchors.upper_value,
+            (case when anchors.lower_inclusive then '[' else '(' end)
+                ||
+            (case when anchors.upper_inclusive then ']' else ')' end)
+        ) end
+    from anchors
+    join inserted_subscriptions on inserted_subscriptions.id = anchors.subscription_id;
+$function$;
 
-create trigger sync_custom_event_trigger
-    after insert or delete or update on pgconductor._private_event_subscriptions
-    for each row
-    execute function pgconductor._private_sync_custom_event_trigger();
+insert into pgconductor._private_queues (name)
+values ('pgconductor.internal')
+on conflict do nothing;
 
-create or replace function pgconductor._private_build_payload_fields(
-    p_payload_fields text[],
-    p_payload_expr text
+insert into pgconductor._private_tasks (
+    key, queue, max_attempts, remove_on_complete_days, remove_on_fail_days
+)
+values (
+    'pgconductor.event-dispatch', 'pgconductor.internal', 3, 0, null
 )
-    returns text
-    language sql
-    immutable
-    set search_path to ''
-as $_$
-    select case
-        when p_payload_fields is null then p_payload_expr
-        else 'jsonb_build_object(' || array_to_string(
-            array(
-                select format('%L, %s->%L', field, p_payload_expr, field)
-                from unnest(p_payload_fields) as field
-            ),
-            ', '
-        ) || ')'
-    end;
-$_$;
-
-create or replace function pgconductor._private_build_column_list(
-    p_column_names text[],
-    p_record_name text
+on conflict (queue, key) do update set
+    max_attempts = excluded.max_attempts,
+    remove_on_complete_days = excluded.remove_on_complete_days,
+    remove_on_fail_days = excluded.remove_on_fail_days;
+
+create or replace function pgconductor.emit_event(
+    p_event_key text,
+    p_payload jsonb default '{}'::jsonb
 )
-    returns text
-    language sql
-    immutable
-    set search_path to ''
-as $_$
-    select case
-        when p_column_names is null then format('row_to_json(%I.*)', p_record_name)
-        else 'jsonb_build_object(' || array_to_string(
-            array(
-                select format('%L, %I.%I', col, p_record_name, col)
-                from unnest(p_column_names) as col
-            ),
-            ', '
-        ) || ')'
-    end;
-$_$;
-
-create or replace function pgconductor._private_sync_database_trigger()
-    returns trigger
-    language plpgsql
-    security definer
-    set search_path to ''
-as $_$
+returns uuid
+language plpgsql
+volatile
+set search_path to ''
+as $function$
 declare
-    v_table_name text := coalesce(new.table_name, old.table_name);
-    v_schema_name text := coalesce(new.schema_name, old.schema_name);
-    v_op pgconductor._private_event_operation;
-    v_invoke_blocks text;
-    v_has_subscriptions boolean;
+    v_payload jsonb := p_payload;
+    v_event_id uuid;
 begin
-    -- Only process database event subscriptions (schema_name is not null)
-    if v_schema_name is null then
-        return coalesce(new, old);
+    if p_event_key is null
+        or btrim(p_event_key) = ''
+        or octet_length(p_event_key) > 255
+    then
+        raise exception 'Event name must contain between 1 and 255 UTF-8 bytes';
     end if;
 
-    -- Process each operation type (insert, update, delete)
-    foreach v_op in array array['insert', 'update', 'delete']::pgconductor._private_event_operation[] loop
-        -- Drop existing trigger and function
-        execute format(
-            'drop trigger if exists pgconductor_event_%s on %I.%I',
-            v_op::text, v_schema_name, v_table_name
-        );
-
-        execute format(
-            'drop function if exists pgconductor._private_trigger_event_%s_on_%I_%I',
-            v_op::text, v_schema_name, v_table_name
-        );
-
-        -- Check if there are any subscriptions for this operation
-        select exists(
-            select 1
-            from pgconductor._private_event_subscriptions
-            where table_name = v_table_name
-                and schema_name = v_schema_name
-                and operation = v_op
-        ) into v_has_subscriptions;
-
-        if v_has_subscriptions then
-            -- Build if blocks to check conditions and append to arrays
-            -- Each subscription's when_clause is evaluated inside the trigger function
-            v_invoke_blocks := (
-                select string_agg(format(
-                    $sql$
-                    if %s then
-                        v_task_keys := array_append(v_task_keys, %L);
-                        v_queues := array_append(v_queues, %L);
-                        v_payloads := array_append(v_payloads, jsonb_build_object(
-                            'event', %L,
-                            'payload', jsonb_build_object(
-                                'old', case when tg_op is distinct from 'INSERT' then %s else null end,
-                                'new', case when tg_op is distinct from 'DELETE' then %s else null end,
-                                'tg_table', tg_table_name,
-                                'tg_op', tg_op
-                            )
-                        ));
-                        v_subscription_ids := array_append(v_subscription_ids, %L);
-                    end if;
-                    $sql$,
-                    coalesce(nullif(sub.when_clause, ''), 'true'),
-                    sub.task_key,
-                    t.queue,
-                    format('%s.%s.%s', v_schema_name, v_table_name, v_op::text),
-                    pgconductor._private_build_column_list(sub.column_names, 'old'),
-                    pgconductor._private_build_column_list(sub.column_names, 'new'),
-                    sub.id
-                ), e'\n')
-                from pgconductor._private_event_subscriptions as sub
-                join pgconductor._private_tasks as t on t.key = sub.task_key and t.queue = sub.queue
-                where sub.table_name = v_table_name
-                    and sub.schema_name = v_schema_name
-                    and sub.operation = v_op
-            );
-
-            -- Create trigger function
-            execute format(
-                $sql$
-                create or replace function pgconductor._private_trigger_event_%s_on_%I_%I()
-                    returns trigger
-                    language plpgsql
-                    security definer
-                    set search_path to ''
-                as $inner$
-                declare
-                    v_task_keys text[];
-                    v_queues text[];
-                    v_payloads jsonb[];
-                    v_subscription_ids uuid[];
-                begin
-                    %s
-
-                    if array_length(v_task_keys, 1) > 0 then
-                        insert into pgconductor._private_executions (task_key, queue, payload, subscription_id)
-                        select unnest(v_task_keys), unnest(v_queues), unnest(v_payloads), unnest(v_subscription_ids);
-                    end if;
-
-                    if tg_op = 'DELETE' then
-                        return old;
-                    end if;
-
-                    return new;
-                end
-                $inner$
-                $sql$,
-                v_op::text,
-                v_schema_name,
-                v_table_name,
-                v_invoke_blocks
-            );
-
-            -- Create trigger
-            execute format(
-                $sql$
-                create trigger pgconductor_event_%s
-                    after %s on %I.%I
-                    for each row
-                    execute function pgconductor._private_trigger_event_%s_on_%I_%I()
-                $sql$,
-                v_op::text,
-                upper(v_op::text),
-                v_schema_name,
-                v_table_name,
-                v_op::text,
-                v_schema_name,
-                v_table_name
-            );
-        end if;
-    end loop;
-
-    if tg_op = 'DELETE' then
-        return old;
+    if v_payload is null or jsonb_typeof(v_payload) <> 'object' then
+        raise exception 'Event payload must be a JSON object';
     end if;
 
-    return new;
-end;
-$_$;
+    -- Final filter matching runs in TypeScript. Reject top-level SQL numeric
+    -- values whose decimal value would change when decoded as a JS number.
+    if exists (
+        select 1
+        from jsonb_each(v_payload) field
+        where jsonb_typeof(field.value) = 'number'
+          and not case
+              when abs((field.value #>> '{}')::numeric)
+                  <= '1.7976931348623157e308'::numeric
+              then (field.value #>> '{}')::numeric
+                  = ((field.value #>> '{}')::double precision)::text::numeric
+              else false
+          end
+    ) then
+        raise exception 'Event payload contains a number that cannot be represented as a JavaScript number';
+    end if;
 
-create trigger sync_database_trigger
-    after insert or delete or update on pgconductor._private_event_subscriptions
-    for each row
-    execute function pgconductor._private_sync_database_trigger();
+    insert into pgconductor._private_executions (
+        id, task_key, queue, payload
+    ) values (
+        pgconductor._private_portable_uuidv7(),
+        'pgconductor.event-dispatch',
+        'pgconductor.internal',
+        jsonb_build_object('eventKey', p_event_key, 'payload', v_payload)
+    )
+    returning id into v_event_id;
 
-create or replace function pgconductor.emit_event(
-    p_event_key text,
-    p_payload jsonb default '{}'::jsonb
-)
-    returns uuid
-    language sql
-    volatile
-    set search_path to ''
-as $_$
-    insert into pgconductor._private_custom_events (event_key, payload)
-    values (p_event_key, p_payload)
-    returning id;
-$_$;
+    return v_event_id;
+end;
+$function$;
 `,
 });
diff --git a/packages/pgconductor-js/src/maintenance-task.ts b/packages/pgconductor-js/src/maintenance-task.ts
index 0ab6a78..7bd7659 100644
--- a/packages/pgconductor-js/src/maintenance-task.ts
+++ b/packages/pgconductor-js/src/maintenance-task.ts
@@ -37,7 +37,8 @@ export const createMaintenanceTask = <Queue extends string = "default">(queue: Q
 		},
 		async (_, ctx) => {
 			const { db, tasks, signal } = ctx;
-			// Skip if no tasks have retention settings (check in-memory config)
+
+			// Skip execution cleanup when no tasks have retention settings (check in-memory config)
 			const hasRetention = Array.from(tasks.values()).some(
 				(t) => t.removeOnComplete || t.removeOnFail,
 			);
diff --git a/packages/pgconductor-js/src/orchestrator.ts b/packages/pgconductor-js/src/orchestrator.ts
index 8f68a64..87e4115 100644
--- a/packages/pgconductor-js/src/orchestrator.ts
+++ b/packages/pgconductor-js/src/orchestrator.ts
@@ -1,4 +1,4 @@
-import { Worker, type WorkerConfig } from "./worker";
+import { createEventDispatchTask, EVENT_DISPATCH_QUEUE, Worker, type WorkerConfig } from "./worker";
 import { DatabaseClient } from "./database-client";
 import { MigrationStore } from "./migration-store";
 import { SchemaManager } from "./schema-manager";
@@ -13,14 +13,14 @@ import { noop } from "./lib/noop";
 import { coerceError } from "./lib/coerce-error";
 
 export type OrchestratorOptions<TTasks extends readonly AnyTask[] = readonly AnyTask[]> = {
-	conductor: Conductor<any, any, any, any, any, any, any>;
+	conductor: Conductor<any, any, any, any, any>;
 	tasks?: ValidateTasksQueue<"default", TTasks>;
 	defaultWorker?: Partial<WorkerConfig>;
 	workers?: Worker[];
 };
 
 type InternalOrchestratorOptions = {
-	conductor: Conductor<any, any, any, any, any, any, any>;
+	conductor: Conductor<any, any, any, any, any>;
 	tasks?: readonly AnyTask[];
 	defaultWorker?: Partial<WorkerConfig>;
 	workers?: Worker[];
@@ -39,6 +39,7 @@ const STALE_ORCHESTRATOR_MAX_AGE_MS = HEARTBEAT_INTERVAL_MS * 10;
 export class Orchestrator {
 	private readonly db: DatabaseClient;
 	private readonly workers: Worker[] = [];
+	private readonly eventWorker: Worker;
 	private readonly orchestratorId: string;
 	private readonly migrationStore: MigrationStore;
 	private readonly schemaManager: SchemaManager;
@@ -69,17 +70,47 @@ export class Orchestrator {
 				this.logger,
 				options.defaultWorker,
 				options.conductor.options.context,
+				options.conductor.options.events?.definitions ?? [],
+				true,
+				options.conductor.options.events?.hasTypeOnlyDefinitions ?? false,
 			);
 			this.workers.push(worker);
 		}
 
 		for (const w of options.workers || []) {
-			if (this.workers.find((existing) => existing.queueName === w.queueName)) {
-				throw new Error(`Duplicate worker name: ${w.queueName}`);
-			}
-
 			this.workers.push(w);
 		}
+
+		const queues = new Set<string>();
+		for (const worker of this.workers) {
+			if (worker.queueName === EVENT_DISPATCH_QUEUE) {
+				throw new Error(`Queue "${EVENT_DISPATCH_QUEUE}" is reserved for internal use`);
+			}
+			if (queues.has(worker.queueName)) {
+				throw new Error(
+					`Orchestrator cannot configure multiple workers for queue "${worker.queueName}"; configure one worker with all tasks for that queue`,
+				);
+			}
+			queues.add(worker.queueName);
+		}
+
+		this.eventWorker = new Worker(
+			EVENT_DISPATCH_QUEUE,
+			[createEventDispatchTask()],
+			this.db,
+			this.logger,
+			{
+				concurrency: 1,
+				fetchBatchSize: 10,
+				flushBatchSize: 10,
+				pollIntervalMs: options.defaultWorker?.pollIntervalMs || 1000,
+				flushIntervalMs: options.defaultWorker?.flushIntervalMs || 2000,
+			},
+			{},
+			[],
+			true,
+			false,
+		);
 	}
 
 	static create<const TTasks extends readonly Task<any, "default", any, any, any, any>[]>(
@@ -139,6 +170,9 @@ export class Orchestrator {
 		}
 
 		this._stopDeferred = new Deferred<void>();
+		// Startup can fail before callers have a reason to observe `stopped`.
+		// Keep the rejection available to explicit awaiters while marking it handled.
+		this._stopDeferred.promise.catch(noop);
 		this._startDeferred = new Deferred<void>();
 		this._abortController = new AbortController();
 		this.registerSignalHandlers();
@@ -189,32 +223,59 @@ export class Orchestrator {
 				// Start heartbeat loop
 				this.startHeartbeatLoop();
 
-				// Kick off all workers (don't await yet!)
-				if (runOnce) {
-					// Drain mode: workers will process and stop
-					this.workers.forEach((w) => void w.drain(this.orchestratorId));
-				} else {
-					// Normal mode: workers will run continuously
-					this.workers.forEach((w) => void w.run(this.orchestratorId));
-				}
-
-				// Wait for ALL workers to finish starting (register() complete)
-				await Promise.all(this.workers.map((w) => w.started));
+				const startWorkers = async () => {
+					const userWorkerLifecycles = this.workers.map((worker) => {
+						const lifecycle = runOnce
+							? worker.drain(this.orchestratorId)
+							: worker.run(this.orchestratorId);
+						// A sibling may fail registration before these promises are returned
+						// to the caller. Mark every lifecycle as observed immediately.
+						lifecycle.catch(noop);
+						return lifecycle;
+					});
+
+					// Subscription registration must commit before the dispatcher can
+					// claim source executions and freeze their delivery snapshot.
+					await Promise.all(this.workers.map((worker) => worker.started));
+
+					const eventWorkerLifecycle = runOnce
+						? this.eventWorker.drain(this.orchestratorId)
+						: this.eventWorker.run(this.orchestratorId);
+					eventWorkerLifecycle.catch(noop);
+					await this.eventWorker.started;
+
+					return {
+						allWorkers: Promise.all([...userWorkerLifecycles, eventWorkerLifecycle]),
+					};
+				};
+
+				let { allWorkers } = await startWorkers();
 
 				// NOW signal that orchestrator has started
 				this.startDeferred.resolve();
 
-				// Wait for shutdown signal or all workers to complete
-				await Promise.race([
-					Promise.all(this.workers.map((w) => w.stopped)),
-					this.waitForShutdownSignal(),
-				]);
+				if (runOnce) {
+					// Event fan-out can create work in a queue that already finished its
+					// pass, and destination tasks can recursively emit more events.
+					await allWorkers;
+					while (
+						this.eventWorker.drainDidWork ||
+						this.workers.some((worker) => worker.drainDidWork)
+					) {
+						({ allWorkers } = await startWorkers());
+						await allWorkers;
+					}
+				} else {
+					// Wait for shutdown signal or all workers to complete
+					await Promise.race([allWorkers, this.waitForShutdownSignal()]);
+				}
 
 				// Stop gracefully
 				await this.stopWorkers();
 			} catch (err) {
 				error = coerceError(err);
 				this.logger.error(err);
+				await this.stopWorkers();
 
 				// Only reject startDeferred if startup hasn't completed yet
 				if (!this.startDeferred.isSettled) {
@@ -329,9 +390,10 @@ export class Orchestrator {
 								signal.signal_payload &&
 								signal.signal_payload.queue
 							) {
-								const worker = this.workers.find(
-									(w) => w.queueName === signal.signal_payload?.queue,
-								);
+								const worker =
+									signal.signal_payload.queue === EVENT_DISPATCH_QUEUE
+										? this.eventWorker
+										: this.workers.find((w) => w.queueName === signal.signal_payload?.queue);
 								if (worker) {
 									worker.cancelExecutions([signal.signal_execution_id]);
 								}
@@ -373,7 +435,7 @@ export class Orchestrator {
 	 * Stop all workers gracefully
 	 */
 	private async stopWorkers(): Promise<void> {
-		await Promise.all(this.workers.map((worker) => worker.stop()));
+		await Promise.all([...this.workers.map((worker) => worker.stop()), this.eventWorker.stop()]);
 	}
 
 	/**
diff --git a/packages/pgconductor-js/src/query-builder.ts b/packages/pgconductor-js/src/query-builder.ts
index efee09b..fcf8063 100644
--- a/packages/pgconductor-js/src/query-builder.ts
+++ b/packages/pgconductor-js/src/query-builder.ts
@@ -7,8 +7,8 @@ import type {
 	EventSubscriptionSpec,
 	Payload,
 	TaskSpec,
-	JsonValue,
 } from "./database-client";
+import type { EventDispatchCandidate, EventDispatchDestination } from "./event-dispatch";
 
 export type OrchestratorHeartbeatArgs = {
 	orchestratorId: string;
@@ -44,6 +44,11 @@ export type RemoveExecutionsArgs = {
 	batchSize: number;
 };
 
+export type DispatchCustomEventsArgs = {
+	eventIds: string[];
+	orchestratorId: string;
+};
+
 export type RegisterWorkerArgs = {
 	queueName: string;
 	taskSpecs: TaskSpec[];
@@ -86,7 +91,7 @@ export type ClearWaitingStateArgs = {
 
 export type EmitEventArgs = {
 	eventKey: string;
-	payload?: JsonValue;
+	payload?: Payload;
 };
 
 export class QueryBuilder {
@@ -374,12 +379,14 @@ export class QueryBuilder {
 				returning e.id, e.task_key, e.queue, e.payload, e.waiting_on_execution_id,
 					e.waiting_step_key, e.cancelled, e.last_error, e.dedupe_key, e.cron_expression,
 					e.locked_by, e."group", e.priority, e.run_at, e.created_at,
+					e.subscription_id,
 					e.dead_letter_source_execution_id, e.dead_letter_source_queue,
 					e.dead_letter_source_task_key, e.dead_letter_error,
 					e.dead_letter_attempts, e.dead_letter_failed_at
 			)
 			select id, task_key, queue, payload, waiting_on_execution_id, waiting_step_key,
 				cancelled, last_error, dedupe_key, cron_expression, locked_by, "group",
+				subscription_id,
 				dead_letter_source_execution_id, dead_letter_source_queue,
 				dead_letter_source_task_key, dead_letter_error, dead_letter_attempts, dead_letter_failed_at
 			from claimed
@@ -413,7 +420,8 @@ export class QueryBuilder {
 		// new claim from racing the side effects below.
 		ctes.push(this.sql`valid_results as materialized (
 			select r.*,
-				e.cancelled as execution_cancelled, e.last_error as execution_last_error
+				e.cancelled as execution_cancelled, e.last_error as execution_last_error,
+				e.subscription_id
 			from result_data r
 			join pgconductor._private_executions e
 				on e.id = r.execution_id
@@ -452,7 +460,8 @@ export class QueryBuilder {
 			from completed_results r
 			join pgconductor._private_executions parent
 				on parent.waiting_on_execution_id = r.execution_id
-			where parent.completed_at is null
+			where r.subscription_id is null
+				and parent.completed_at is null
 				and parent.failed_at is null
 				and parent.locked_by is null
 			for update of parent
@@ -474,6 +483,7 @@ export class QueryBuilder {
 			where e.id = r.execution_id and e.queue = r.queue
 				and e.locked_by = r.orchestrator_id
 				and e.parent_execution_id is not null
+				and e.subscription_id is null
 				and not exists (
 					select 1 from pgconductor._private_executions parent
 					where parent.waiting_on_execution_id = r.execution_id
@@ -516,6 +526,7 @@ export class QueryBuilder {
 				e."group" as execution_group,
 				e.payload as execution_payload,
 				e.attempts as execution_attempts,
+				e.subscription_id,
 				tc.remove_on_fail_days = 0 as should_remove,
 				tc.dead_letter_queue, tc.dead_letter_task_key
 			from failed_results r
@@ -539,7 +550,8 @@ export class QueryBuilder {
 				on parent.waiting_on_execution_id = p.execution_id
 			join pgconductor._private_tasks pt
 				on pt.key = parent.task_key and pt.queue = parent.queue
-			where parent.completed_at is null and parent.failed_at is null and parent.locked_by is null
+			where p.subscription_id is null
+				and parent.completed_at is null and parent.failed_at is null and parent.locked_by is null
 			for update of parent
 		)`);
 		ctes.push(this.sql`terminal_failures as materialized (
@@ -751,14 +763,10 @@ export class QueryBuilder {
 
 		const eventSubscriptionRows = eventSubscriptions.map((spec) => ({
 			task_key: spec.task_key,
-			queue: spec.queue,
 			event_key: spec.event_key,
-			schema_name: spec.schema_name,
-			table_name: spec.table_name,
-			operation: spec.operation,
-			when_clause: spec.when_clause,
 			payload_fields: spec.payload_fields,
-			column_names: spec.column_names,
+			filter: spec.filter,
+			anchors: spec.anchors,
 		}));
 
 		return this.sql`
@@ -1067,6 +1075,201 @@ export class QueryBuilder {
 		`;
 	}
 
+	buildGetEventDispatchCandidates({
+		eventIds,
+		orchestratorId,
+	}: DispatchCustomEventsArgs): PendingQuery<EventDispatchCandidate[]> {
+		return this.sql<EventDispatchCandidate[]>`
+			with sources as materialized (
+				select
+					source.id as event_id,
+					source.payload ->> 'eventKey' as event_key,
+					source.payload -> 'payload' as event_payload,
+					exists (
+						select 1
+						from pgconductor._private_steps marker
+						where marker.execution_id = source.id
+							and marker.queue = 'pgconductor.internal'
+							and marker.key = 'pgconductor.internal.event-fanout.v1'
+					) as completed
+				from pgconductor._private_executions source
+				where source.id = any(${this.sql.array(eventIds, 2951)}::uuid[])
+					and source.queue = 'pgconductor.internal'
+					and source.task_key = 'pgconductor.event-dispatch'
+					and source.locked_by = ${orchestratorId}::uuid
+					and source.completed_at is null
+					and source.failed_at is null
+					and not source.cancelled
+				order by source.id
+				for update of source
+			), pending as materialized (
+				select * from sources where not completed
+			), event_values as materialized (
+				select source.event_id, source.event_key, field.key as field_name,
+					field.value, jsonb_typeof(field.value) as scalar_type
+				from pending source
+				cross join lateral jsonb_each(source.event_payload) field
+				where jsonb_typeof(field.value) in ('string', 'number', 'boolean', 'null')
+			), event_prefixes as materialized (
+				select distinct
+					event_value.event_id,
+					event_value.event_key,
+					event_value.field_name,
+					anchor.prefix_length,
+					left(event_value.value #>> '{}', anchor.prefix_length) as prefix_value
+				from event_values event_value
+				cross join lateral (
+					select distinct candidate.prefix_length
+					from pgconductor._private_event_filter_anchors candidate
+					where candidate.operator = 'prefix'
+						and candidate.event_key collate "C" = event_value.event_key collate "C"
+						and candidate.field_name collate "C" = event_value.field_name collate "C"
+				) anchor
+				where event_value.scalar_type = 'string'
+			), candidate_subscriptions as materialized (
+				select event_value.event_id, anchor.subscription_id
+				from event_values event_value
+				join pgconductor._private_event_filter_anchors anchor
+					on anchor.operator = 'exact'
+					and anchor.scalar_type = 'string'
+					and event_value.scalar_type = 'string'
+					and anchor.event_key collate "C" = event_value.event_key collate "C"
+					and anchor.field_name collate "C" = event_value.field_name collate "C"
+					and anchor.text_value collate "C" = (event_value.value #>> '{}') collate "C"
+				union
+				select event_value.event_id, anchor.subscription_id
+				from event_values event_value
+				join pgconductor._private_event_filter_anchors anchor
+					on anchor.operator = 'exact'
+					and anchor.scalar_type = 'number'
+					and event_value.scalar_type = 'number'
+					and anchor.event_key = event_value.event_key
+					and anchor.field_name = event_value.field_name
+					and anchor.number_value = case when event_value.scalar_type = 'number'
+						then (event_value.value #>> '{}')::numeric end
+				union
+				select event_value.event_id, anchor.subscription_id
+				from event_values event_value
+				join pgconductor._private_event_filter_anchors anchor
+					on anchor.operator = 'exact'
+					and anchor.scalar_type = 'boolean'
+					and event_value.scalar_type = 'boolean'
+					and anchor.event_key = event_value.event_key
+					and anchor.field_name = event_value.field_name
+					and anchor.boolean_value = case when event_value.scalar_type = 'boolean'
+						then (event_value.value #>> '{}')::boolean end
+				union
+				select event_value.event_id, anchor.subscription_id
+				from event_values event_value
+				join pgconductor._private_event_filter_anchors anchor
+					on anchor.operator = 'exact'
+					and anchor.scalar_type = 'null'
+					and event_value.scalar_type = 'null'
+					and anchor.event_key = event_value.event_key
+					and anchor.field_name = event_value.field_name
+				union
+				select event_prefix.event_id, anchor.subscription_id
+				from event_prefixes event_prefix
+				join pgconductor._private_event_filter_anchors anchor
+					on anchor.operator = 'prefix'
+					and anchor.event_key collate "C" = event_prefix.event_key collate "C"
+					and anchor.field_name collate "C" = event_prefix.field_name collate "C"
+					and anchor.prefix_length = event_prefix.prefix_length
+					and anchor.text_value collate "C" = event_prefix.prefix_value collate "C"
+				union
+				select event_value.event_id, anchor.subscription_id
+				from event_values event_value
+				join pgconductor._private_event_filter_anchors anchor
+					on anchor.operator = 'numeric_range'
+					and event_value.scalar_type = 'number'
+					and anchor.event_key = event_value.event_key
+					and anchor.field_name = event_value.field_name
+					and anchor.number_range @> case when event_value.scalar_type = 'number'
+						then (event_value.value #>> '{}')::numeric end
+				union
+				select source.event_id, anchor.subscription_id
+				from pending source
+				join pgconductor._private_event_filter_anchors anchor
+					on anchor.event_key = source.event_key
+					and anchor.operator = 'fallback'
+			), candidates as materialized (
+				select candidate.event_id, subscription.id as subscription_id,
+					subscription.task_key, subscription.queue,
+					subscription.payload_fields, subscription.filter
+				from candidate_subscriptions candidate
+				join pgconductor._private_custom_event_subscriptions subscription
+					on subscription.id = candidate.subscription_id
+				join pgconductor._private_tasks task
+					on task.key = subscription.task_key and task.queue = subscription.queue
+			)
+			select
+				source.event_id,
+				source.event_key,
+				source.event_payload,
+				source.completed,
+				candidate.subscription_id,
+				candidate.task_key,
+				candidate.queue,
+				candidate.payload_fields,
+				candidate.filter
+			from sources source
+			left join candidates candidate on candidate.event_id = source.event_id
+			order by source.event_id, candidate.subscription_id
+		`;
+	}
+
+	buildCommitEventDispatches(
+		eventIds: string[],
+		destinations: EventDispatchDestination[],
+	): PendingQuery<{ event_id: string }[]> {
+		return this.sql<{ event_id: string }[]>`
+			with destinations as materialized (
+				select *
+				from jsonb_to_recordset(${this.sql.json(destinations)}::jsonb) as destination(
+					"eventId" uuid,
+					"subscriptionId" uuid,
+					"taskKey" text,
+					queue text,
+					payload jsonb
+				)
+			), inserted_destinations as (
+				insert into pgconductor._private_executions (
+					id, task_key, queue, payload, parent_execution_id, subscription_id
+				)
+				select
+					pgconductor._private_portable_uuidv7(),
+					destination."taskKey",
+					destination.queue,
+					destination.payload,
+					destination."eventId",
+					destination."subscriptionId"
+				from destinations destination
+				where not exists (
+					select 1
+					from pgconductor._private_steps marker
+					where marker.execution_id = destination."eventId"
+						and marker.queue = 'pgconductor.internal'
+						and marker.key = 'pgconductor.internal.event-fanout.v1'
+				)
+				on conflict (parent_execution_id, subscription_id, queue)
+				where subscription_id is not null
+				do nothing
+				returning parent_execution_id
+			), inserted_markers as (
+				insert into pgconductor._private_steps (execution_id, queue, key, result)
+				select event_id, 'pgconductor.internal',
+					'pgconductor.internal.event-fanout.v1', null::jsonb
+				from unnest(${this.sql.array(eventIds, 2951)}::uuid[]) event_id
+				cross join (select count(*) from inserted_destinations) destination_barrier
+				on conflict (execution_id, key) do nothing
+				returning execution_id
+			)
+			select event_id
+			from unnest(${this.sql.array(eventIds, 2951)}::uuid[]) event_id
+			cross join (select count(*) from inserted_markers) marker_barrier
+		`;
+	}
+
 	buildEmitEvent({ eventKey, payload }: EmitEventArgs): PendingQuery<{ id: string }[]> {
 		return this.sql<{ id: string }[]>`
 			select pgconductor.emit_event(
diff --git a/packages/pgconductor-js/src/schemas.ts b/packages/pgconductor-js/src/schemas.ts
index 749a4a7..7e0aa83 100644
--- a/packages/pgconductor-js/src/schemas.ts
+++ b/packages/pgconductor-js/src/schemas.ts
@@ -1,5 +1,5 @@
 import type { TaskDefinition } from "./task-definition";
-import type { EventDefinition, GenericDatabase } from "./event-definition";
+import type { EventDefinition } from "./event-definition";
 
 /**
  * Stackable adapter for task definitions.
@@ -65,89 +65,50 @@ export class TaskSchemas<
  *   .fromUnion<AppAccountCreated | UserDeleted>()
  */
 export class EventSchemas<
-	TSchemaTypes extends readonly EventDefinition<string, any>[] = readonly [],
-	TUnionTypes extends EventDefinition<string, any> = never,
+	TSchemaTypes extends readonly EventDefinition<string, any, any>[] = readonly [],
+	TUnionTypes extends EventDefinition<string, any, any> = never,
 > {
-	private constructor(readonly definitions: TSchemaTypes) {}
+	private constructor(
+		readonly definitions: TSchemaTypes,
+		readonly hasTypeOnlyDefinitions: boolean,
+	) {}
 
 	/**
 	 * Create EventSchemas from standard-schema based event definitions.
 	 */
-	static fromSchema<const T extends readonly EventDefinition<string, any>[]>(
+	static fromSchema<const T extends readonly EventDefinition<string, any, any>[]>(
 		events: T,
 	): EventSchemas<T, never> {
-		return new EventSchemas(events);
+		return new EventSchemas(events, false);
 	}
 
 	/**
 	 * Add type-only event definitions via union type.
 	 */
-	static fromUnion<TUnion extends EventDefinition<string, any>>(): EventSchemas<
+	static fromUnion<TUnion extends EventDefinition<string, any, any>>(): EventSchemas<
 		readonly [],
 		TUnion
 	> {
-		return new EventSchemas([]);
+		return new EventSchemas([], true);
 	}
 
 	/**
 	 * Chain: Add more standard-schema based event definitions.
 	 */
-	fromSchema<const T extends readonly EventDefinition<string, any>[]>(
+	fromSchema<const T extends readonly EventDefinition<string, any, any>[]>(
 		events: T,
 	): EventSchemas<readonly [...TSchemaTypes, ...T], TUnionTypes> {
-		return new EventSchemas([...this.definitions, ...events]);
+		return new EventSchemas([...this.definitions, ...events], this.hasTypeOnlyDefinitions);
 	}
 
 	/**
 	 * Chain: Add type-only event definitions via union type.
 	 */
-	fromUnion<TUnion extends EventDefinition<string, any>>(): EventSchemas<
+	fromUnion<TUnion extends EventDefinition<string, any, any>>(): EventSchemas<
 		TSchemaTypes,
 		TUnionTypes | TUnion
 	> {
-		return new EventSchemas(this.definitions);
-	}
-}
-
-type SupabaseDatabase = {
-	[schema_name: string]: {
-		Tables: {
-			[table_name: string]: {
-				Row: unknown;
-				Insert?: unknown;
-				Update?: unknown;
-			};
-		};
-	};
-};
-
-type ConvertSupabaseTables<T> = {
-	[Schema in keyof T]: T[Schema] extends { Tables: infer Tables }
-		? {
-				[Table in keyof Tables]: Tables[Table] extends { Row: infer Row } ? Row : unknown;
-			}
-		: {};
-};
-
-/**
- * Adapter for database type definitions.
- * Wraps database types to allow different sources in the future (e.g., Supabase).
- */
-export class DatabaseSchema<_TDatabase extends GenericDatabase> {
-	private constructor() {}
-
-	/**
-	 * Create DatabaseSchema from generated types (e.g., from pgtyped, kysely, etc.).
-	 */
-	static fromGeneratedTypes<T extends GenericDatabase>(): DatabaseSchema<T> {
-		return new DatabaseSchema();
-	}
-
-	/**
-	 * Create DatabaseSchema from Supabase generated types.
-	 */
-	static fromSupabaseTypes<T extends SupabaseDatabase>(): DatabaseSchema<ConvertSupabaseTables<T>> {
-		return new DatabaseSchema();
+		return new EventSchemas(this.definitions, true);
 	}
 }
 
@@ -165,5 +126,3 @@ export type InferEventsFromSchema<T> =
 			? TSchema
 			: readonly [...TSchema, TUnion]
 		: readonly [];
-
-export type InferDatabaseFromSchema<T> = T extends DatabaseSchema<infer U> ? U : GenericDatabase;
diff --git a/packages/pgconductor-js/src/select-columns.ts b/packages/pgconductor-js/src/select-columns.ts
index 767585c..e2b96ac 100644
--- a/packages/pgconductor-js/src/select-columns.ts
+++ b/packages/pgconductor-js/src/select-columns.ts
@@ -115,29 +115,23 @@ type FirstError<T extends readonly any[]> = T extends [infer Head, ...infer Tail
 			: undefined
 	: undefined;
 
+type FirstDuplicate<T extends readonly any[]> = T extends [infer Head, ...infer Tail]
+	? Head extends Tail[number]
+		? Head
+		: FirstDuplicate<Tail>
+	: never;
+
 type PickFromKeys<Keys extends keyof Obj, Obj> = { [K in Keys]: Obj[K] };
 
 type ValidatePart<Part extends string, Obj> =
 	Trim<Part> extends infer P extends string
 		? P extends ""
 			? `[Column Selection Error]: Empty entry. Remove trailing commas or extra spaces.`
-			: // quoted identifier
-				P extends `"${infer Body}"`
-				? // forbid raw " inside quoted body
-					Body extends `${string}"${string}`
-					? `[Column Selection Error]: Invalid quote in "${P}". Use "" to escape quotes inside identifiers.`
-					: Body extends keyof Obj
-						? Body
-						: `[Column Selection Error]: Column "${Body}" does not exist.`
-				: // malformed quoting
-					P extends `${string}"${string}`
-					? `[Column Selection Error]: Malformed quotes in "${P}". Quoted identifiers must be fully wrapped.`
-					: // unquoted identifier
-						IsValidUnquoted<P> extends false
-						? `[Column Selection Error]: Invalid identifier "${P}". Must start with a letter or underscore.`
-						: P extends keyof Obj
-							? P
-							: `[Column Selection Error]: Column "${P}" does not exist.`
+			: IsValidUnquoted<P> extends false
+				? `[Column Selection Error]: Invalid identifier "${P}". Must start with a letter or underscore.`
+				: P extends keyof Obj
+					? P
+					: `[Column Selection Error]: Column "${P}" does not exist.`
 		: never;
 
 type ValidateParts<Parts extends readonly string[], Obj> = {
@@ -151,7 +145,11 @@ export type ParseSelection<S extends string, Obj> =
 				? FirstError<V> extends string
 					? ColumnSelectionError<FirstError<V>>
 					: never
-				: PickFromKeys<ExtractKeys<V>, Obj>
+				: FirstDuplicate<V> extends infer Duplicate extends string
+					? [Duplicate] extends [never]
+						? PickFromKeys<ExtractKeys<V>, Obj>
+						: ColumnSelectionError<`[Column Selection Error]: Duplicate column "${Duplicate}".`>
+					: never
 			: never
 		: never;
 
diff --git a/packages/pgconductor-js/src/task-context.ts b/packages/pgconductor-js/src/task-context.ts
index 14fc735..8f04b3b 100644
--- a/packages/pgconductor-js/src/task-context.ts
+++ b/packages/pgconductor-js/src/task-context.ts
@@ -104,7 +104,11 @@ export class TaskContext<
 		any,
 		string
 	>[],
-	Events extends readonly EventDefinition<string, any>[] = readonly EventDefinition<string, any>[],
+	Events extends readonly EventDefinition<string, any, any>[] = readonly EventDefinition<
+		string,
+		any,
+		any
+	>[],
 > {
 	private readonly windowChecker?: WindowChecker;
 
@@ -116,7 +120,7 @@ export class TaskContext<
 
 	static create<
 		Tasks extends readonly TaskDefinition<string, any, any, string>[],
-		Events extends readonly EventDefinition<string, any>[],
+		Events extends readonly EventDefinition<string, any, any>[],
 		Extra extends object,
 	>(opts: TaskContextOptions, extra?: Extra): TaskContext<Tasks, Events> & Extra {
 		const base = new TaskContext<Tasks, Events>(opts);
diff --git a/packages/pgconductor-js/src/task-definition.ts b/packages/pgconductor-js/src/task-definition.ts
index cf7257b..90cb2bf 100644
--- a/packages/pgconductor-js/src/task-definition.ts
+++ b/packages/pgconductor-js/src/task-definition.ts
@@ -1,4 +1,11 @@
 import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type {
+	EventDefinition,
+	FilterForEvent,
+	FindEventByIdentifier,
+	InferEventPayload,
+} from "./event-definition";
+import type { ValidateColumns } from "./select-columns";
 
 type ObjectSchema = StandardSchemaV1<unknown, object>;
 
@@ -123,28 +130,53 @@ export type CronTrigger = { cron: string; name: string; group?: string };
 // Event trigger - triggers when a custom event is emitted
 export type CustomEventTrigger<
 	TName extends string = string,
-	TFields extends string | undefined = undefined,
+	TFields extends string | undefined = string | undefined,
+	TFilter extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
 > = {
 	event: TName;
-	when?: string;
 	fields?: TFields;
+	filter?: TFilter;
 };
 
-// Database event trigger - triggers on CDC events
-export type DatabaseEventTrigger<
-	TSchema extends string = string,
-	TTable extends string = string,
-	TOp extends "insert" | "update" | "delete" = "insert" | "update" | "delete",
-	TColumns extends string = string,
-> = {
-	schema: TSchema;
-	table: TTable;
-	operation: TOp;
-	when?: string;
-	columns: TColumns;
-};
-
-export type Trigger = InvocableTrigger | CronTrigger | CustomEventTrigger | DatabaseEventTrigger;
+export type Trigger = InvocableTrigger | CronTrigger | CustomEventTrigger;
+
+type ValidateEventFields<Event, T> = T extends { fields: infer Fields extends string }
+	? ValidateColumns<Fields, InferEventPayload<Event>> extends Fields
+		? T
+		: ValidateColumns<Fields, InferEventPayload<Event>>
+	: T;
+
+type ValidateEventFilter<Event, Name extends string, T> = T extends { filter: infer Filter }
+	? Filter extends FilterForEvent<Event>
+		? Exclude<keyof Filter, keyof FilterForEvent<Event>> extends never
+			? T
+			: `Filter for event "${Name}" contains undeclared fields.`
+		: `Filter for event "${Name}" contains undeclared or incorrectly typed fields.`
+	: T;
+
+type ValidateCustomEventTrigger<
+	Events extends readonly EventDefinition<string, any, any>[],
+	T,
+> = T extends { event: infer Name extends string }
+	? Events extends readonly []
+		? T
+		: FindEventByIdentifier<Events, Name> extends infer Event
+			? [Event] extends [never]
+				? `Event "${Name}" is not defined in the conductor event catalog.`
+				: ValidateEventFields<Event, T> extends infer FieldsResult
+					? FieldsResult extends T
+						? ValidateEventFilter<Event, Name, T>
+						: FieldsResult
+					: never
+			: never
+	: T;
+
+export type ValidateEventTriggers<
+	Events extends readonly EventDefinition<string, any, any>[],
+	TTriggers,
+> = TTriggers extends readonly any[]
+	? { [K in keyof TTriggers]: ValidateCustomEventTrigger<Events, TTriggers[K]> }
+	: ValidateCustomEventTrigger<Events, TTriggers>;
 
 // Check if triggers include invocable
 export type HasInvocable<TTriggers> = TTriggers extends readonly any[]
@@ -164,36 +196,12 @@ export type HasCron<TTriggers> = TTriggers extends readonly any[]
 		? true
 		: false;
 
-// Check if triggers include custom event
+// Check if triggers include a custom event.
 export type HasCustomEvent<TTriggers> = TTriggers extends readonly any[]
-	? Extract<TTriggers[number], { event: string }> extends infer Extracted
-		? Extracted extends never
-			? false
-			: Exclude<Extracted, { schema: string }> extends never
-				? false // All events are database events
-				: true // At least one custom event
-		: false
-	: TTriggers extends { event: string }
-		? TTriggers extends { schema: string }
-			? false // Database event, not custom event
-			: true
-		: false;
-
-// Check if triggers include database event
-export type HasDatabaseEvent<TTriggers> = TTriggers extends readonly any[]
-	? {
-			schema: string;
-			table: string;
-			operation: "insert" | "update" | "delete";
-		} extends TTriggers[number]
+	? Extract<TTriggers[number], { event: string }> extends never
 		? false
-		: Extract<
-					TTriggers[number],
-					{ schema: string; table: string; operation: "insert" | "update" | "delete" }
-			  > extends never
-			? false
-			: true
-	: TTriggers extends { schema: string; table: string; operation: "insert" | "update" | "delete" }
+		: true
+	: TTriggers extends { event: string }
 		? true
 		: false;
 
@@ -229,8 +237,10 @@ export type ValidateTriggers<
 			: TTriggers
 		: `Triggers array cannot be empty. Provide at least one trigger.`
 	: // Single trigger case
-		TTriggers extends InvocableTrigger
-		? TaskIdentifierIsDefined<Tasks, TName, TQueue> extends true
-			? TTriggers
-			: `Task "${TName}" of queue "${TQueue}" is not defined in the conductor catalog. Remove { invocable: true } from triggers, or add a task definition to the conductor's tasks array.`
-		: TTriggers;
+		TTriggers extends Trigger
+		? TTriggers extends InvocableTrigger
+			? TaskIdentifierIsDefined<Tasks, TName, TQueue> extends true
+				? TTriggers
+				: `Task "${TName}" of queue "${TQueue}" is not defined in the conductor catalog. Remove { invocable: true } from triggers, or add a task definition to the conductor's tasks array.`
+			: TTriggers
+		: "Invalid trigger. Use an invocable, cron, or custom event trigger.";
diff --git a/packages/pgconductor-js/src/task.ts b/packages/pgconductor-js/src/task.ts
index b611feb..174fb5f 100644
--- a/packages/pgconductor-js/src/task.ts
+++ b/packages/pgconductor-js/src/task.ts
@@ -4,21 +4,12 @@ import type {
 	HasInvocable,
 	HasCron,
 	HasCustomEvent,
-	HasDatabaseEvent,
 	CronTrigger,
 } from "./task-definition";
-import type {
-	EventDefinition,
-	FindEventByIdentifier,
-	InferEventPayload,
-	GenericDatabase,
-	DatabaseEventPayload,
-	SchemaName,
-	TableName,
-	RowType,
-} from "./event-definition";
+import type { EventDefinition, FindEventByIdentifier, InferEventPayload } from "./event-definition";
 import type { SelectedRow } from "./select-columns";
 import * as assert from "./lib/assert";
+import { compileEventTriggers, type CompiledEventTrigger } from "./event-trigger-validation";
 
 export type TaskIdentifier<TName extends string = string, TQueue extends string = "default"> = {
 	readonly name: TName;
@@ -100,29 +91,10 @@ type ExtractCronTriggers<TTriggers> = TTriggers extends readonly any[]
 		? TTriggers
 		: never;
 
-// Extract custom event triggers from array
+// Extract custom event triggers from array.
 type ExtractCustomEventTriggers<TTriggers> = TTriggers extends readonly any[]
-	? TTriggers[number] extends infer T
-		? T extends { event: string }
-			? T extends { schema: string }
-				? never // Database event, not custom event
-				: T
-			: never
-		: never
+	? Extract<TTriggers[number], { event: string }>
 	: TTriggers extends { event: string }
-		? TTriggers extends { schema: string }
-			? never // Database event, not custom event
-			: TTriggers
-		: never;
-
-// Extract database event triggers from array
-type ExtractDatabaseEventTriggers<TTriggers> = TTriggers extends readonly any[]
-	? TTriggers[number] extends infer T
-		? T extends { schema: string; table: string; operation: "insert" | "update" | "delete" }
-			? T
-			: never
-		: never
-	: TTriggers extends { schema: string; table: string; operation: "insert" | "update" | "delete" }
 		? TTriggers
 		: never;
 
@@ -135,11 +107,11 @@ type CronEventUnion<TTriggers> =
 		: never;
 
 // Build custom event union from triggers
-type CustomEventUnion<TTriggers, Events extends readonly EventDefinition<string, any>[]> =
+type CustomEventUnion<TTriggers, Events extends readonly EventDefinition<string, any, any>[]> =
 	ExtractCustomEventTriggers<TTriggers> extends infer T
 		? T extends { event: infer TName extends string }
 			? FindEventByIdentifier<Events, TName> extends infer TEvent
-				? TEvent extends EventDefinition<string, any>
+				? TEvent extends EventDefinition<string, any, any>
 					? T extends { fields: infer TFields extends string }
 						? {
 								name: TName;
@@ -151,64 +123,17 @@ type CustomEventUnion<TTriggers, Events extends readonly EventDefinition<string,
 			: never
 		: never;
 
-// Build database event union from triggers
-type DatabaseEventUnion<TTriggers, Database extends GenericDatabase> =
-	ExtractDatabaseEventTriggers<TTriggers> extends infer T
-		? T extends { schema: infer TSchema extends string }
-			? T extends { table: infer TTable extends string }
-				? T extends { operation: infer TOp extends "insert" | "update" | "delete" }
-					? TSchema extends SchemaName<Database>
-						? TTable extends TableName<Database, TSchema>
-							? T extends { columns: infer TColumns extends string }
-								? {
-										name: `${TSchema}.${TTable}.${TOp}`;
-										payload: DatabaseEventPayload<
-											RowType<Database, TSchema, TTable>,
-											TOp,
-											TColumns
-										>;
-									}
-								: never
-							: T extends { columns: infer _TColumns extends string }
-								? {
-										name: `${TSchema}.${TTable}.${TOp}`;
-										payload: {
-											old: TOp extends "delete" | "update" ? Record<string, unknown> : null;
-											new: TOp extends "insert" | "update" ? Record<string, unknown> : null;
-											tg_table: string;
-											tg_op: Uppercase<TOp>;
-										};
-									}
-								: never
-						: T extends { columns: infer _TColumns extends string }
-							? {
-									name: `${TSchema}.${TTable}.${TOp}`;
-									payload: {
-										old: TOp extends "delete" | "update" ? Record<string, unknown> : null;
-										new: TOp extends "insert" | "update" ? Record<string, unknown> : null;
-										tg_table: string;
-										tg_op: Uppercase<TOp>;
-									};
-								}
-							: never
-					: never
-				: never
-			: never
-		: never;
-
 // Conditional event type based on triggers
 export type TaskEventFromTriggers<
 	TTriggers,
 	TPayload extends object,
-	Events extends readonly EventDefinition<string, any>[] = [],
-	Database extends GenericDatabase = {},
+	Events extends readonly EventDefinition<string, any, any>[] = [],
 > =
 	| (HasInvocable<TTriggers> extends true
 			? { name: "pgconductor.invoke"; payload: TPayload }
 			: never)
 	| (HasCron<TTriggers> extends true ? CronEventUnion<TTriggers> : never)
-	| (HasCustomEvent<TTriggers> extends true ? CustomEventUnion<TTriggers, Events> : never)
-	| (HasDatabaseEvent<TTriggers> extends true ? DatabaseEventUnion<TTriggers, Database> : never);
+	| (HasCustomEvent<TTriggers> extends true ? CustomEventUnion<TTriggers, Events> : never);
 
 // Conditional execute function type based on whether task has batch config
 export type ExecuteFunction<
@@ -243,11 +168,14 @@ export class Task<
 	public readonly deadLetter?: DeadLetterConfiguration<Payload>;
 
 	public readonly triggers: NonEmptyArray<Trigger>;
+	public readonly eventTriggers: CompiledEventTrigger[];
 
 	constructor(
 		definition: TaskConfiguration<Key, Queue, Payload>,
 		triggers: NonEmptyArray<Trigger> | Trigger,
 		public readonly execute: ExecuteFunction<EventType, Returns, Context>,
+		eventDefinitions: readonly EventDefinition<string, any, any>[] = [],
+		allowUnknownEvents = true,
 	) {
 		const { name, queue, ...config } = definition;
 		this.name = name;
@@ -272,6 +200,7 @@ export class Task<
 		}
 
 		this.triggers = Array.isArray(triggers) ? triggers : [triggers];
+		this.eventTriggers = compileEventTriggers(this.triggers, eventDefinitions, allowUnknownEvents);
 	}
 
 	static create<
@@ -285,11 +214,15 @@ export class Task<
 		definition: TaskConfiguration<Key, Queue, Payload>,
 		triggers: NonEmptyArray<Trigger> | Trigger,
 		execute: ExecuteFunction<EventType, Returns, Context>,
+		eventDefinitions: readonly EventDefinition<string, any, any>[] = [],
+		allowUnknownEvents = true,
 	): Task<Key, Queue, Payload, Returns, Context, EventType> {
 		return new Task<Key, Queue, Payload, Returns, Context, EventType>(
 			definition,
 			triggers,
 			execute,
+			eventDefinitions,
+			allowUnknownEvents,
 		);
 	}
 }
diff --git a/packages/pgconductor-js/src/versions.ts b/packages/pgconductor-js/src/versions.ts
index 3273eeb..0699e59 100644
--- a/packages/pgconductor-js/src/versions.ts
+++ b/packages/pgconductor-js/src/versions.ts
@@ -1,3 +1,3 @@
 /* This file is auto-generated by `just build-migrations`; DO NOT EDIT */
 export const PACKAGE_VERSION = "0.1.0";
-export const MIGRATION_NUMBER = 2;
+export const MIGRATION_NUMBER = 1;
diff --git a/packages/pgconductor-js/src/worker.ts b/packages/pgconductor-js/src/worker.ts
index 2274566..36c9f02 100644
--- a/packages/pgconductor-js/src/worker.ts
+++ b/packages/pgconductor-js/src/worker.ts
@@ -10,7 +10,7 @@ import type {
 	ExecutionReleased,
 	ExecutionInvokeChild,
 } from "./database-client";
-import type { AnyTask, BatchConfig } from "./task";
+import { Task, type AnyTask, type BatchConfig } from "./task";
 import type { TaskDefinition } from "./task-definition";
 import { waitFor } from "./lib/wait-for";
 import { mapConcurrent } from "./lib/map-concurrent";
@@ -47,6 +47,26 @@ export type WorkerConfig = {
 /**
  * The default configuration for the Worker.
  */
+export const EVENT_DISPATCH_QUEUE = "pgconductor.internal";
+export const EVENT_DISPATCH_TASK = "pgconductor.event-dispatch";
+const EVENT_DISPATCH_BATCH_SIZE = 10;
+
+export function createEventDispatchTask(): AnyTask {
+	return new Task(
+		{
+			name: EVENT_DISPATCH_TASK,
+			queue: EVENT_DISPATCH_QUEUE,
+			maxAttempts: 3,
+			removeOnComplete: true,
+			batch: { size: EVENT_DISPATCH_BATCH_SIZE, timeoutMs: 10 },
+		},
+		{ invocable: true },
+		async () => {
+			throw new Error("Event dispatch must be executed by the internal worker");
+		},
+	);
+}
+
 export const DEFAULT_WORKER_CONFIG: WorkerConfig = {
 	concurrency: 1,
 	flushBatchSize: 2,
@@ -124,7 +144,11 @@ export class Worker<
 		any,
 		string
 	>[],
-	Events extends readonly EventDefinition<string, any>[] = readonly EventDefinition<string, any>[],
+	Events extends readonly EventDefinition<string, any, any>[] = readonly EventDefinition<
+		string,
+		any,
+		any
+	>[],
 > {
 	private orchestratorId: string | null = null;
 
@@ -140,6 +164,7 @@ export class Worker<
 	private _startDeferred: Deferred<void> | null = null;
 	private _stopDeferred: Deferred<void> | null = null;
 	private _abortController: AbortController | null = null;
+	private _drainDidWork = false;
 	private _runningTasks = new Map<string, TypedAbortController<TaskAbortReasons>>();
 
 	constructor(
@@ -149,15 +174,19 @@ export class Worker<
 		private readonly logger: Logger,
 		config: Partial<WorkerConfig> = {},
 		private readonly extraContext: object = {},
+		_eventDefinitions: readonly EventDefinition<string, any, any>[] = [],
+		includeMaintenance = true,
+		_allowUnknownEvents = false,
 	) {
-		const maintenanceTask = createMaintenanceTask(this.queueName);
-		this.tasks = tasks.reduce(
-			(m, task) => {
-				m.set(task.name, task);
-				return m;
-			},
-			new Map<string, AnyTask>([[maintenanceTask.name, maintenanceTask]]),
-		);
+		const initialTasks = new Map<string, AnyTask>();
+		if (includeMaintenance) {
+			const maintenanceTask = createMaintenanceTask(this.queueName);
+			initialTasks.set(maintenanceTask.name, maintenanceTask);
+		}
+		this.tasks = tasks.reduce((registered, task) => {
+			registered.set(task.name, task);
+			return registered;
+		}, initialTasks);
 
 		const fullConfig = { ...DEFAULT_WORKER_CONFIG, ...config };
 
@@ -188,6 +217,11 @@ export class Worker<
 		return this._stopDeferred?.promise || Promise.resolve();
 	}
 
+	/** @internal Whether the last run-once pass observed any work. */
+	get drainDidWork(): boolean {
+		return this._drainDidWork;
+	}
+
 	/**
 	 * Start the worker.
 	 * Returns when startup is complete (registration done).
@@ -226,13 +260,32 @@ export class Worker<
 		}
 
 		this.orchestratorId = orchestratorId;
+		this._drainDidWork = false;
 		this._startDeferred = new Deferred<void>();
 		this._stopDeferred = new Deferred<void>();
 		this._abortController = new AbortController();
 
-		// Sample before calculating or registering cron schedules.
-		await this.clock.start(this.abortController.signal);
-		await this.register();
+		// Startup failures reject both lifecycle promises; callers must never
+		// observe a worker that started partially.
+		try {
+			// Sample before calculating or registering cron schedules.
+			await this.clock.start(this.abortController.signal);
+			await this.register();
+		} catch (error) {
+			// Registration is part of startup, not a running pipeline. Resolve the
+			// stop promise so callers that only await `start()` do not get an
+			// unhandled rejection, then discard every piece of this failed attempt.
+			const stopDeferred = this._stopDeferred;
+			this._abortController.abort();
+			// Reject `started` so an Orchestrator observes registration failure, but
+			// attach a noop handler because callers that only use start() do not
+			// necessarily observe this internal lifecycle promise.
+			this._startDeferred.promise.catch(() => {});
+			this._startDeferred.reject(error);
+			if (!stopDeferred.isSettled) stopDeferred.resolve();
+			this.resetLifecycle();
+			throw error;
+		}
 
 		// Worker is now started
 		this._startDeferred.resolve();
@@ -247,27 +300,49 @@ export class Worker<
 		}
 
 		const queue = new BatchingAsyncQueue<Execution>(this.fetchBatchSize * 2, batchConfigs);
-		void this.fetchExecutions(queue, { runOnce });
-
-		(async () => {
-			try {
-				// Consume from queue → execute → flush
-				await this.flushResults(this.executeTasks(queue));
-			} catch (err) {
-				this.logger.error("Worker pipeline error:", err);
-			} finally {
-				queue.close();
-				this.clock.stop();
-				this._stopDeferred?.resolve();
-				this._startDeferred = null;
-				this._stopDeferred = null;
-				this._abortController = null;
-			}
-		})();
+		if (runOnce) {
+			void this.runDrainPipeline(queue);
+		} else {
+			void this.fetchExecutions(queue, { runOnce });
+			void (async () => {
+				try {
+					await this.flushResults(this.executeTasks(queue));
+				} catch (error) {
+					this.logger.error("Worker pipeline error:", error);
+					this._stopDeferred?.reject(error);
+				} finally {
+					queue.close();
+					if (this._stopDeferred && !this._stopDeferred.isSettled) this._stopDeferred.resolve();
+					this.resetLifecycle();
+				}
+			})();
+		}
 
 		return this._startDeferred.promise;
 	}
 
+	private async runDrainPipeline(queue: BatchingAsyncQueue<Execution>): Promise<void> {
+		try {
+			const fetched = this.fetchExecutions(queue, { runOnce: true });
+			await this.flushResults(this.executeTasks(queue));
+			this._drainDidWork = (await fetched) > 0;
+		} catch (error) {
+			this.logger.error("Worker pipeline error:", error);
+			this._stopDeferred?.reject(error);
+		} finally {
+			if (this._stopDeferred && !this._stopDeferred.isSettled) this._stopDeferred.resolve();
+			this.resetLifecycle();
+		}
+	}
+
+	private resetLifecycle(): void {
+		this.clock.stop();
+		this._startDeferred = null;
+		this._stopDeferred = null;
+		this._abortController = null;
+		this.orchestratorId = null;
+	}
+
 	/**
 	 * Stop the worker gracefully.
 	 * Returns when shutdown is complete.
@@ -344,43 +419,12 @@ export class Worker<
 				}),
 		);
 
-		const eventSubscriptions: EventSubscriptionSpec[] = allTasks.flatMap((task) => {
-			const customEvents = task.triggers
-				.filter((t) => "event" in t && typeof t.event === "string")
-				.map((trigger): EventSubscriptionSpec => {
-					const customTrigger = trigger as any;
-					return {
-						task_key: task.name,
-						queue: this.queueName,
-						event_key: customTrigger.event,
-						schema_name: null,
-						table_name: null,
-						operation: null,
-						when_clause: customTrigger.when || null,
-						payload_fields: customTrigger.fields?.split(",").map((f: string) => f.trim()) || null,
-						column_names: null,
-					};
-				});
-
-			const dbEvents = task.triggers
-				.filter((t) => "schema" in t && "table" in t && "operation" in t)
-				.map((trigger): EventSubscriptionSpec => {
-					const dbTrigger = trigger as any;
-					return {
-						task_key: task.name,
-						queue: this.queueName,
-						event_key: null,
-						schema_name: dbTrigger.schema,
-						table_name: dbTrigger.table,
-						operation: dbTrigger.operation,
-						when_clause: dbTrigger.when || null,
-						payload_fields: null,
-						column_names: dbTrigger.columns?.split(",").map((c: string) => c.trim()) || null,
-					};
-				});
-
-			return [...customEvents, ...dbEvents];
-		});
+		const eventSubscriptions: EventSubscriptionSpec[] = allTasks.flatMap((task) =>
+			(task.eventTriggers ?? []).map((spec) => ({
+				task_key: task.name,
+				...spec,
+			})),
+		);
 
 		await this.db.registerWorker(
 			{
@@ -397,7 +441,8 @@ export class Worker<
 	private async fetchExecutions(
 		queue: BatchingAsyncQueue<Execution>,
 		{ runOnce = false }: { runOnce?: boolean },
-	) {
+	): Promise<number> {
+		let fetched = 0;
 		assert.ok(this.orchestratorId, "orchestratorId must be set when starting the pipeline");
 
 		// Pre-compute task metadata once
@@ -460,6 +505,7 @@ export class Worker<
 				}
 
 				for (const exec of executions) {
+					fetched++;
 					await queue.push(exec); // waits if full
 					if (this.signal.aborted) break;
 				}
@@ -469,6 +515,7 @@ export class Worker<
 		}
 
 		queue.close();
+		return fetched;
 	}
 
 	// --- Stage 2: Execute tasks concurrently ---
@@ -521,6 +568,10 @@ export class Worker<
 					return [];
 				}
 
+				if (this.queueName === EVENT_DISPATCH_QUEUE && taskKey === EVENT_DISPATCH_TASK) {
+					return this.executeEventDispatchBatch(activeExecs);
+				}
+
 				// If task has batch config, always use batch execution (even for single items)
 				if (task.batch) {
 					return this.executeBatchTask(task, taskKey, activeExecs);
@@ -541,6 +592,52 @@ export class Worker<
 		}
 	}
 
+	private async executeEventDispatchBatch(executions: Execution[]): Promise<ExecutionResult[]> {
+		assert.ok(this.orchestratorId, "orchestratorId must be set while dispatching events");
+
+		try {
+			const dispatched = await this.db.dispatchCustomEvents(
+				{
+					eventIds: executions.map((execution) => execution.id),
+					orchestratorId: this.orchestratorId,
+				},
+				{ signal: this.signal },
+			);
+			const dispatchedIds = new Set(dispatched);
+
+			return executions.map((execution) => {
+				if (!dispatchedIds.has(execution.id)) {
+					return {
+						execution_id: execution.id,
+						orchestrator_id: execution.locked_by,
+						queue: execution.queue,
+						task_key: execution.task_key,
+						status: "failed" as const,
+						error: "Event dispatch claim is no longer valid",
+					};
+				}
+				return {
+					execution_id: execution.id,
+					orchestrator_id: execution.locked_by,
+					queue: execution.queue,
+					task_key: execution.task_key,
+					status: "completed" as const,
+					result: undefined,
+				};
+			});
+		} catch (error) {
+			const message = coerceError(error).message;
+			return executions.map((execution) => ({
+				execution_id: execution.id,
+				orchestrator_id: execution.locked_by,
+				queue: execution.queue,
+				task_key: execution.task_key,
+				status: "failed" as const,
+				error: message,
+			}));
+		}
+	}
+
 	/**
 	 * Execute a single task execution.
 	 *
@@ -567,12 +664,12 @@ export class Worker<
 				const scheduleName = exec.dedupe_key?.split("::")[1] || "unknown";
 				taskEvent = { name: scheduleName };
 			} else if (
+				exec.subscription_id != null &&
 				exec.payload &&
 				typeof exec.payload === "object" &&
-				"event" in exec.payload &&
-				exec.payload.event !== "pgconductor.invoke"
+				"event" in exec.payload
 			) {
-				// Event-triggered execution (custom event or db event)
+				// Event-triggered executions carry dedicated database identity.
 				taskEvent = {
 					name: exec.payload.event,
 					payload: exec.payload.payload,
@@ -693,10 +790,10 @@ export class Worker<
 				const scheduleName = exec.dedupe_key?.split("::")[1] || "unknown";
 				return { name: scheduleName };
 			} else if (
+				exec.subscription_id != null &&
 				exec.payload &&
 				typeof exec.payload === "object" &&
-				"event" in exec.payload &&
-				exec.payload.event !== "pgconductor.invoke"
+				"event" in exec.payload
 			) {
 				return {
 					name: exec.payload.event,
diff --git a/packages/pgconductor-js/tests/integration/event-pipeline.test.ts b/packages/pgconductor-js/tests/integration/event-pipeline.test.ts
new file mode 100644
index 0000000..eba9839
--- /dev/null
+++ b/packages/pgconductor-js/tests/integration/event-pipeline.test.ts
@@ -0,0 +1,942 @@
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
+import postgres from "postgres";
+import { z } from "zod";
+import { Conductor } from "../../src/conductor";
+import {
+	DatabaseClient,
+	type EventSubscriptionSpec,
+	type JsonValue,
+} from "../../src/database-client";
+import { defineEvent } from "../../src/event-definition";
+import { compileEventFilterAnchors, compileEventTrigger } from "../../src/event-trigger-validation";
+import { DefaultLogger } from "../../src/lib/logger";
+import { Orchestrator } from "../../src/orchestrator";
+import { EventSchemas, TaskSchemas } from "../../src/schemas";
+import { defineTask } from "../../src/task-definition";
+import { TestDatabasePool, type TestDatabase } from "../fixtures/test-database";
+import { waitForCondition } from "../test-utils";
+
+const INTERNAL_QUEUE = "pgconductor.internal";
+const DISPATCH_TASK = "pgconductor.event-dispatch";
+const FANOUT_STEP = "pgconductor.internal.event-fanout.v1";
+
+type CustomSubscription = {
+	taskKey: string;
+	eventKey: string;
+	filter?: Record<string, JsonValue[]>;
+	payloadFields?: string[];
+	maxAttempts?: number;
+};
+
+describe("event pipeline", () => {
+	let pool: TestDatabasePool;
+	const databases: TestDatabase[] = [];
+
+	beforeAll(async () => {
+		pool = await TestDatabasePool.create();
+	}, 60_000);
+
+	afterEach(async () => {
+		await Promise.all(databases.map((database) => database.destroy()));
+		databases.length = 0;
+	});
+
+	afterAll(async () => {
+		await pool?.destroy();
+	});
+
+	async function database(): Promise<TestDatabase> {
+		const db = await pool.child();
+		databases.push(db);
+		await Conductor.create({ sql: db.sql, context: {} }).ensureInstalled();
+		return db;
+	}
+
+	async function registerSubscriptions(
+		db: TestDatabase,
+		subscriptions: CustomSubscription[],
+	): Promise<void> {
+		const eventSubscriptions: EventSubscriptionSpec[] = subscriptions.map((subscription) => {
+			const filter = subscription.filter || null;
+			return {
+				task_key: subscription.taskKey,
+				event_key: subscription.eventKey,
+				payload_fields: subscription.payloadFields || null,
+				filter,
+				anchors: compileEventFilterAnchors(filter),
+			};
+		});
+		await db.client.registerWorker({
+			queueName: "default",
+			taskSpecs: subscriptions.map((subscription) => ({
+				key: subscription.taskKey,
+				queue: "default",
+				maxAttempts: subscription.maxAttempts || 3,
+			})),
+			cronSchedules: [],
+			eventSubscriptions,
+		});
+	}
+
+	async function claimEvent(
+		db: TestDatabase,
+		eventId: string,
+		orchestratorId = crypto.randomUUID(),
+	): Promise<string> {
+		const claimed = await db.client.getExecutions({
+			orchestratorId,
+			queueName: INTERNAL_QUEUE,
+			batchSize: 10,
+			filterTaskKeys: [],
+		});
+		expect(claimed.some((execution) => execution.id === eventId)).toBe(true);
+		return orchestratorId;
+	}
+
+	async function settleSource(
+		db: TestDatabase,
+		eventId: string,
+		orchestratorId: string,
+	): Promise<void> {
+		await db.client.returnExecutions({
+			count: 1,
+			orchestratorId,
+			completed: [
+				{
+					execution_id: eventId,
+					orchestrator_id: orchestratorId,
+					queue: INTERNAL_QUEUE,
+					task_key: DISPATCH_TASK,
+					status: "completed",
+				},
+			],
+			failed: [],
+			released: [],
+			invokeChild: [],
+			taskKeys: new Set([DISPATCH_TASK]),
+		});
+	}
+
+	test("rejects SQL numeric fields that cannot round-trip through JavaScript", async () => {
+		const db = await database();
+
+		let rejection: unknown;
+		try {
+			await db.sql`
+				select pgconductor.emit_event(
+					'pipeline.numeric-boundary',
+					'{"value": 9007199254740993}'::jsonb
+				)
+			`;
+		} catch (error) {
+			rejection = error;
+		}
+		expect(String(rejection)).toContain(
+			"Event payload contains a number that cannot be represented as a JavaScript number",
+		);
+		const accepted = await db.sql`
+			select pgconductor.emit_event(
+				'pipeline.numeric-boundary',
+				'{"value": 0.1}'::jsonb
+			)
+		`;
+		expect(accepted).toHaveLength(1);
+	}, 15_000);
+
+	test("uses subscription identity rather than payload shape for direct invocations", async () => {
+		const db = await database();
+		const payload = z.object({
+			event: z.string(),
+			payload: z.object({ value: z.string() }),
+		});
+		const singleDefinition = defineTask({ name: "pipeline.direct-single", payload });
+		const batchDefinition = defineTask({ name: "pipeline.direct-batch", payload });
+		const conductor = Conductor.create({
+			sql: db.sql,
+			tasks: TaskSchemas.fromSchema([singleDefinition, batchDefinition]),
+			context: {},
+		});
+		const received: unknown[] = [];
+		const single = conductor.createTask(
+			{ name: "pipeline.direct-single" },
+			{ invocable: true },
+			async (event) => {
+				received.push(event);
+			},
+		);
+		const batch = conductor.createTask(
+			{ name: "pipeline.direct-batch", batch: { size: 10, timeoutMs: 10 } },
+			{ invocable: true },
+			async (events) => {
+				received.push(...events);
+			},
+		);
+		await conductor.invoke(
+			{ name: "pipeline.direct-single" },
+			{ event: "customer-action", payload: { value: "single" } },
+		);
+		await conductor.invoke(
+			{ name: "pipeline.direct-batch" },
+			{ event: "customer-action", payload: { value: "batch" } },
+		);
+		await Orchestrator.create({
+			conductor,
+			tasks: [single, batch],
+			defaultWorker: { pollIntervalMs: 10, flushIntervalMs: 10 },
+		}).drain();
+
+		expect(received).toEqual([
+			{
+				name: "pgconductor.invoke",
+				payload: { event: "customer-action", payload: { value: "single" } },
+			},
+			{
+				name: "pgconductor.invoke",
+				payload: { event: "customer-action", payload: { value: "batch" } },
+			},
+		]);
+	});
+
+	test("stores the event only in its durable dispatch execution", async () => {
+		const db = await database();
+		const eventId = await db.client.emitEvent({
+			eventKey: "pipeline.persisted",
+			payload: { value: "ready" },
+		});
+		const [source] = await db.sql<
+			{ id: string; queue: string; task_key: string; payload: Record<string, unknown> }[]
+		>`
+			select id, queue, task_key, payload
+			from pgconductor._private_executions
+			where id = ${eventId}::uuid and queue = ${INTERNAL_QUEUE}
+		`;
+		expect(source).toEqual({
+			id: eventId,
+			queue: INTERNAL_QUEUE,
+			task_key: DISPATCH_TASK,
+			payload: { eventKey: "pipeline.persisted", payload: { value: "ready" } },
+		});
+		const [schema] = await db.sql<{ event_table: string | null }[]>`
+			select to_regclass('pgconductor._private_custom_events')::text as event_table
+		`;
+		expect(schema?.event_table).toBeNull();
+	});
+
+	test("validates event names and payload objects at the database boundary", async () => {
+		const db = await database();
+		await db.sql`
+			do $$
+			begin
+				begin
+					perform pgconductor.emit_event('', '{}'::jsonb);
+					raise exception 'invalid event name was accepted';
+				exception when others then
+					if sqlerrm <> 'Event name must contain between 1 and 255 UTF-8 bytes' then
+						raise;
+					end if;
+				end;
+
+				begin
+					perform pgconductor.emit_event('pipeline.invalid', '[]'::jsonb);
+					raise exception 'invalid event payload was accepted';
+				exception when others then
+					if sqlerrm <> 'Event payload must be a JSON object' then
+						raise;
+					end if;
+				end;
+
+				begin
+					perform pgconductor.emit_event('pipeline.invalid', null);
+					raise exception 'null event payload was accepted';
+				exception when others then
+					if sqlerrm <> 'Event payload must be a JSON object' then
+						raise;
+					end if;
+				end;
+			end;
+			$$
+		`;
+	}, 30_000);
+
+	test("does not serialize same-key emitters for caller transaction lifetimes", async () => {
+		const db = await database();
+		const firstSql = postgres(db.url, { max: 1 });
+		const secondSql = postgres(db.url, { max: 1 });
+		let releaseFirst = () => {};
+		let markFirstInserted = () => {};
+		const release = new Promise<void>((resolve) => {
+			releaseFirst = resolve;
+		});
+		const firstInserted = new Promise<void>((resolve) => {
+			markFirstInserted = resolve;
+		});
+		const firstTransaction = firstSql.begin(async (transaction) => {
+			await transaction`select pgconductor.emit_event('pipeline.concurrent', '{}'::jsonb)`;
+			markFirstInserted();
+			await release;
+		});
+
+		try {
+			await firstInserted;
+			let timeout: Timer | undefined;
+			const [second] = await Promise.race([
+				secondSql`select pgconductor.emit_event('pipeline.concurrent', '{}'::jsonb) as id`,
+				new Promise<never>((_, reject) => {
+					timeout = setTimeout(
+						() => reject(new Error("same-key emission was transaction-serialized")),
+						2_000,
+					);
+				}),
+			]);
+			if (timeout) clearTimeout(timeout);
+			expect(second?.id).toBeString();
+		} finally {
+			releaseFirst();
+			await firstTransaction;
+			await Promise.all([firstSql.end(), secondSql.end()]);
+		}
+	});
+
+	test("matches typed DNF predicates, distinguishes missing from null, and projects payload", async () => {
+		const db = await database();
+		const event = defineEvent({
+			name: "pipeline.order",
+			payload: z.object({
+				status: z.enum(["paid", "trial", "cancelled"]),
+				region: z.string(),
+				attempt: z.number(),
+				active: z.boolean(),
+				coupon: z.string().nullable().optional(),
+			}),
+			filterable: ["status", "region", "attempt", "active", "coupon"],
+		});
+		const filteredDefinition = defineTask({ name: "pipeline.filtered", payload: z.object({}) });
+		const nullDefinition = defineTask({ name: "pipeline.null", payload: z.object({}) });
+		const allDefinition = defineTask({ name: "pipeline.all", payload: z.object({}) });
+		const conductor = Conductor.create({
+			sql: db.sql,
+			tasks: TaskSchemas.fromSchema([filteredDefinition, nullDefinition, allDefinition]),
+			events: EventSchemas.fromSchema([event]),
+			context: {},
+		});
+		const received: { task: string; payload: Record<string, unknown> }[] = [];
+		const filtered = conductor.createTask(
+			{ name: "pipeline.filtered" },
+			{
+				event: "pipeline.order",
+				filter: { status: ["paid", "trial"], region: ["us"], attempt: [1], active: [true] },
+			},
+			async (receivedEvent) => {
+				received.push({ task: "filtered", payload: receivedEvent.payload });
+			},
+		);
+		const explicitNull = conductor.createTask(
+			{ name: "pipeline.null" },
+			{ event: "pipeline.order", filter: { coupon: [null] } },
+			async (receivedEvent) => {
+				received.push({ task: "null", payload: receivedEvent.payload });
+			},
+		);
+		const all = conductor.createTask(
+			{ name: "pipeline.all" },
+			{ event: "pipeline.order", fields: "status, region, coupon" },
+			async (receivedEvent) => {
+				received.push({ task: "all", payload: receivedEvent.payload });
+			},
+		);
+		const orchestrator = Orchestrator.create({
+			conductor,
+			tasks: [filtered, explicitNull, all],
+			defaultWorker: { pollIntervalMs: 10, flushIntervalMs: 10 },
+		});
+		await conductor.emit("pipeline.order", {
+			status: "paid",
+			region: "us",
+			attempt: 1,
+			active: true,
+			coupon: null,
+		});
+		await orchestrator.start();
+		try {
+			await conductor.emit("pipeline.order", {
+				status: "trial",
+				region: "us",
+				attempt: 1,
+				active: true,
+			});
+			await conductor.emit("pipeline.order", {
+				status: "paid",
+				region: "eu",
+				attempt: 1,
+				active: true,
+				coupon: "SAVE",
+			});
+			await waitForCondition(() => received.length === 6);
+			expect(received.filter((item) => item.task === "filtered")).toHaveLength(2);
+			expect(received.filter((item) => item.task === "null")).toHaveLength(1);
+			expect(received.filter((item) => item.task === "all")).toEqual([
+				{ task: "all", payload: { status: "paid", region: "us", coupon: null } },
+				{ task: "all", payload: { status: "trial", region: "us" } },
+				{ task: "all", payload: { status: "paid", region: "eu", coupon: "SAVE" } },
+			]);
+		} finally {
+			await orchestrator.stop();
+		}
+	});
+
+	test("matches literal prefixes, numeric ranges, exists, and atomic anything-but", async () => {
+		const db = await database();
+		const compileFilter = (filter: Record<string, unknown[]>) =>
+			compileEventTrigger({ event: "pipeline.operators", filter }, [], true)?.filter || undefined;
+		await registerSubscriptions(db, [
+			{
+				taskKey: "pipeline.prefix",
+				eventKey: "pipeline.operators",
+				filter: compileFilter({ code: [{ prefix: "a%_\\" }] }),
+			},
+			{
+				taskKey: "pipeline.range",
+				eventKey: "pipeline.operators",
+				filter: compileFilter({ amount: [{ numeric: [">=", 10, "<", 20] }] }),
+			},
+			{
+				taskKey: "pipeline.missing",
+				eventKey: "pipeline.operators",
+				filter: compileFilter({ note: [{ exists: false }] }),
+			},
+			{
+				taskKey: "pipeline.anything",
+				eventKey: "pipeline.operators",
+				filter: compileFilter({ status: [{ "anything-but": "blocked" }] }),
+			},
+		]);
+
+		const eventId = await db.client.emitEvent({
+			eventKey: "pipeline.operators",
+			payload: { code: "a%_\\suffix", amount: 10, status: 42 },
+		});
+		const owner = await claimEvent(db, eventId);
+		expect(
+			await db.client.dispatchCustomEvents({ eventIds: [eventId], orchestratorId: owner }),
+		).toEqual([eventId]);
+		const destinations = await db.sql<{ task_key: string }[]>`
+			select task_key from pgconductor._private_executions
+			where parent_execution_id = ${eventId}::uuid and subscription_id is not null
+			order by task_key
+		`;
+		expect(destinations.map(({ task_key }) => task_key)).toEqual([
+			"pipeline.anything",
+			"pipeline.missing",
+			"pipeline.prefix",
+			"pipeline.range",
+		]);
+
+		const negativeId = await db.client.emitEvent({
+			eventKey: "pipeline.operators",
+			payload: { code: "other", amount: 20, note: "present", status: "blocked" },
+		});
+		const negativeOwner = await claimEvent(db, negativeId);
+		expect(
+			await db.client.dispatchCustomEvents({
+				eventIds: [negativeId],
+				orchestratorId: negativeOwner,
+			}),
+		).toEqual([negativeId]);
+		const [negative] = await db.sql<{ count: number }[]>`
+			select count(*)::integer as count from pgconductor._private_executions
+			where parent_execution_id = ${negativeId}::uuid and subscription_id is not null
+		`;
+		expect(negative?.count).toBe(0);
+	});
+
+	test("treats wrong residual scalar types as non-matches instead of cast errors", async () => {
+		const db = await database();
+		await registerSubscriptions(db, [
+			{
+				taskKey: "pipeline.residual",
+				eventKey: "pipeline.residual",
+				filter: { anchor: ["match"], count: [1], enabled: [true] },
+			},
+		]);
+		const eventId = await db.client.emitEvent({
+			eventKey: "pipeline.residual",
+			payload: { anchor: "match", count: "not-a-number", enabled: "not-a-boolean" },
+		});
+		const owner = await claimEvent(db, eventId);
+		expect(
+			await db.client.dispatchCustomEvents({ eventIds: [eventId], orchestratorId: owner }),
+		).toEqual([eventId]);
+		const [result] = await db.sql<{ count: number }[]>`
+			select count(*)::integer as count from pgconductor._private_executions
+			where parent_execution_id = ${eventId}::uuid and subscription_id is not null
+		`;
+		expect(result?.count).toBe(0);
+	});
+
+	test("commits destinations with a fan-out marker and freezes retries", async () => {
+		const db = await database();
+		await registerSubscriptions(db, [
+			{ taskKey: "pipeline.first", eventKey: "pipeline.snapshot", filter: { kind: ["first"] } },
+		]);
+		const eventId = await db.client.emitEvent({
+			eventKey: "pipeline.snapshot",
+			payload: { kind: "first" },
+		});
+		const orchestratorId = await claimEvent(db, eventId);
+		expect(await db.client.dispatchCustomEvents({ eventIds: [eventId], orchestratorId })).toEqual([
+			eventId,
+		]);
+
+		await registerSubscriptions(db, [
+			{ taskKey: "pipeline.second", eventKey: "pipeline.snapshot", filter: { kind: ["first"] } },
+		]);
+		expect(await db.client.dispatchCustomEvents({ eventIds: [eventId], orchestratorId })).toEqual([
+			eventId,
+		]);
+		const destinations = await db.sql<
+			{ task_key: string; parent_execution_id: string; subscription_id: string }[]
+		>`
+			select task_key, parent_execution_id, subscription_id
+			from pgconductor._private_executions
+			where parent_execution_id = ${eventId}::uuid and subscription_id is not null
+		`;
+		expect([...destinations]).toEqual([
+			{
+				task_key: "pipeline.first",
+				parent_execution_id: eventId,
+				subscription_id: expect.any(String),
+			},
+		]);
+		const [marker] = await db.sql<{ count: number }[]>`
+			select count(*)::integer as count
+			from pgconductor._private_steps
+			where execution_id = ${eventId}::uuid and key = ${FANOUT_STEP}
+		`;
+		expect(marker?.count).toBe(1);
+
+		await settleSource(db, eventId, orchestratorId);
+		const [settled] = await db.sql<
+			{ source_exists: boolean; marker_exists: boolean; destination_exists: boolean }[]
+		>`
+			select
+				exists(
+					select 1 from pgconductor._private_executions
+					where id = ${eventId}::uuid and queue = ${INTERNAL_QUEUE}
+				) as source_exists,
+				exists(
+					select 1 from pgconductor._private_steps
+					where execution_id = ${eventId}::uuid and key = ${FANOUT_STEP}
+				) as marker_exists,
+				exists(
+					select 1 from pgconductor._private_executions
+					where parent_execution_id = ${eventId}::uuid and subscription_id is not null
+				) as destination_exists
+		`;
+		expect(settled).toEqual({
+			source_exists: false,
+			marker_exists: false,
+			destination_exists: true,
+		});
+	});
+
+	test("serializes concurrent dispatch and freezes the first committed subscription snapshot", async () => {
+		const db = await database();
+		await registerSubscriptions(db, [
+			{ taskKey: "pipeline.concurrent-destination", eventKey: "pipeline.dispatch-race" },
+		]);
+		const eventId = await db.client.emitEvent({ eventKey: "pipeline.dispatch-race", payload: {} });
+		const owner = await claimEvent(db, eventId);
+		await db.sql`
+			create function public.slow_event_destination() returns trigger language plpgsql as $$
+			begin
+				if new.subscription_id is not null then
+					perform pg_sleep(0.2);
+				end if;
+				return new;
+			end;
+			$$
+		`;
+		await db.sql`
+			create trigger slow_event_destination
+			before insert on pgconductor._private_executions
+			for each row execute function public.slow_event_destination()
+		`;
+		const firstSql = postgres(db.url, { max: 1 });
+		const secondSql = postgres(db.url, { max: 1 });
+		const firstClient = new DatabaseClient({ sql: firstSql, logger: new DefaultLogger() });
+		const secondClient = new DatabaseClient({ sql: secondSql, logger: new DefaultLogger() });
+		try {
+			const first = firstClient.dispatchCustomEvents({
+				eventIds: [eventId],
+				orchestratorId: owner,
+			});
+			await new Promise((resolve) => setTimeout(resolve, 25));
+			await registerSubscriptions(db, [
+				{ taskKey: "pipeline.replacement-destination", eventKey: "pipeline.dispatch-race" },
+			]);
+			const second = secondClient.dispatchCustomEvents({
+				eventIds: [eventId],
+				orchestratorId: owner,
+			});
+			expect(await Promise.all([first, second])).toEqual([[eventId], [eventId]]);
+		} finally {
+			await Promise.all([firstSql.end(), secondSql.end()]);
+			await db.sql`drop trigger slow_event_destination on pgconductor._private_executions`;
+			await db.sql`drop function public.slow_event_destination()`;
+		}
+		const [counts] = await db.sql<{ destinations: number; markers: number }[]>`
+			select
+				count(*) filter (
+					where execution_id = ${eventId}::uuid and key = ${FANOUT_STEP}
+				)::integer as markers,
+				(
+					select count(*)::integer from pgconductor._private_executions
+					where parent_execution_id = ${eventId}::uuid and subscription_id is not null
+				) as destinations
+			from pgconductor._private_steps
+		`;
+		expect(counts).toEqual({ destinations: 1, markers: 1 });
+	});
+
+	test("marks zero-match fan-out complete", async () => {
+		const db = await database();
+		const eventId = await db.client.emitEvent({ eventKey: "pipeline.none", payload: {} });
+		const orchestratorId = await claimEvent(db, eventId);
+		expect(await db.client.dispatchCustomEvents({ eventIds: [eventId], orchestratorId })).toEqual([
+			eventId,
+		]);
+		const [state] = await db.sql<{ destinations: number; markers: number }[]>`
+			select
+				count(*) filter (
+					where execution_id = ${eventId}::uuid and key = ${FANOUT_STEP}
+				)::integer as markers,
+				(
+					select count(*)::integer from pgconductor._private_executions
+					where parent_execution_id = ${eventId}::uuid and subscription_id is not null
+				) as destinations
+			from pgconductor._private_steps
+		`;
+		expect(state).toEqual({ destinations: 0, markers: 1 });
+	});
+
+	test("rejects stale claims and rolls destination insertion back with the marker", async () => {
+		const db = await database();
+		await registerSubscriptions(db, [{ taskKey: "pipeline.atomic", eventKey: "pipeline.atomic" }]);
+		const eventId = await db.client.emitEvent({ eventKey: "pipeline.atomic", payload: {} });
+		const owner = await claimEvent(db, eventId);
+		expect(
+			await db.client.dispatchCustomEvents({
+				eventIds: [eventId],
+				orchestratorId: crypto.randomUUID(),
+			}),
+		).toEqual([]);
+
+		await db.sql`
+			create function public.fail_event_destination() returns trigger language plpgsql as $$
+			begin
+				if new.subscription_id is not null then
+					raise exception 'event destination insert failed';
+				end if;
+				return new;
+			end;
+			$$
+		`;
+		await db.sql`
+			create trigger fail_event_destination
+			before insert on pgconductor._private_executions
+			for each row execute function public.fail_event_destination()
+		`;
+		await expect(
+			db.client.dispatchCustomEvents({ eventIds: [eventId], orchestratorId: owner }),
+		).rejects.toThrow("event destination insert failed");
+		const [rolledBack] = await db.sql<{ destinations: number; markers: number }[]>`
+			select
+				count(*) filter (
+					where execution_id = ${eventId}::uuid and key = ${FANOUT_STEP}
+				)::integer as markers,
+				(
+					select count(*)::integer from pgconductor._private_executions
+					where parent_execution_id = ${eventId}::uuid and subscription_id is not null
+				) as destinations
+			from pgconductor._private_steps
+		`;
+		expect(rolledBack).toEqual({ destinations: 0, markers: 0 });
+		await db.sql`drop trigger fail_event_destination on pgconductor._private_executions`;
+		await db.sql`drop function public.fail_event_destination()`;
+
+		await db.sql`
+			create function public.fail_event_marker() returns trigger language plpgsql as $$
+			begin
+				if new.key = 'pgconductor.internal.event-fanout.v1' then
+					raise exception 'event marker insert failed';
+				end if;
+				return new;
+			end;
+			$$
+		`;
+		await db.sql`
+			create trigger fail_event_marker
+			before insert on pgconductor._private_steps
+			for each row execute function public.fail_event_marker()
+		`;
+		await expect(
+			db.client.dispatchCustomEvents({ eventIds: [eventId], orchestratorId: owner }),
+		).rejects.toThrow("event marker insert failed");
+		const [markerRollback] = await db.sql<{ destinations: number; markers: number }[]>`
+			select
+				count(*) filter (
+					where execution_id = ${eventId}::uuid and key = ${FANOUT_STEP}
+				)::integer as markers,
+				(
+					select count(*)::integer from pgconductor._private_executions
+					where parent_execution_id = ${eventId}::uuid and subscription_id is not null
+				) as destinations
+			from pgconductor._private_steps
+		`;
+		expect(markerRollback).toEqual({ destinations: 0, markers: 0 });
+		await db.sql`drop trigger fail_event_marker on pgconductor._private_steps`;
+		await db.sql`drop function public.fail_event_marker()`;
+
+		expect(
+			await db.client.dispatchCustomEvents({ eventIds: [eventId], orchestratorId: owner }),
+		).toEqual([eventId]);
+	});
+
+	test("settles event destinations independently from dispatch sources", async () => {
+		const db = await database();
+		await registerSubscriptions(db, [
+			{ taskKey: "pipeline.independent", eventKey: "pipeline.independent", maxAttempts: 1 },
+		]);
+		const eventId = await db.client.emitEvent({ eventKey: "pipeline.independent", payload: {} });
+		const sourceOwner = await claimEvent(db, eventId);
+		await db.client.dispatchCustomEvents({ eventIds: [eventId], orchestratorId: sourceOwner });
+		const destinationOwner = crypto.randomUUID();
+		const [failedDestination] = await db.client.getExecutions({
+			orchestratorId: destinationOwner,
+			queueName: "default",
+			batchSize: 1,
+			filterTaskKeys: [],
+		});
+		if (!failedDestination) throw new Error("destination was not claimed");
+		await db.client.returnExecutions({
+			count: 1,
+			orchestratorId: destinationOwner,
+			completed: [],
+			failed: [
+				{
+					execution_id: failedDestination.id,
+					orchestrator_id: destinationOwner,
+					queue: failedDestination.queue,
+					task_key: failedDestination.task_key,
+					status: "failed",
+					error: "destination failed",
+				},
+			],
+			released: [],
+			invokeChild: [],
+			taskKeys: new Set([failedDestination.task_key]),
+		});
+		const [source] = await db.sql<{ failed_at: Date | null; locked_by: string | null }[]>`
+			select failed_at, locked_by
+			from pgconductor._private_executions
+			where id = ${eventId}::uuid and queue = ${INTERNAL_QUEUE}
+		`;
+		expect(source).toEqual({ failed_at: null, locked_by: sourceOwner });
+
+		const completedEventId = await db.client.emitEvent({
+			eventKey: "pipeline.independent",
+			payload: {},
+		});
+		const secondSourceOwner = await claimEvent(db, completedEventId, crypto.randomUUID());
+		await db.client.dispatchCustomEvents({
+			eventIds: [completedEventId],
+			orchestratorId: secondSourceOwner,
+		});
+		const completionOwner = crypto.randomUUID();
+		const [completedDestination] = await db.client.getExecutions({
+			orchestratorId: completionOwner,
+			queueName: "default",
+			batchSize: 1,
+			filterTaskKeys: [],
+		});
+		if (!completedDestination) throw new Error("second destination was not claimed");
+		await db.client.returnExecutions({
+			count: 1,
+			orchestratorId: completionOwner,
+			completed: [
+				{
+					execution_id: completedDestination.id,
+					orchestrator_id: completionOwner,
+					queue: completedDestination.queue,
+					task_key: completedDestination.task_key,
+					status: "completed",
+				},
+			],
+			failed: [],
+			released: [],
+			invokeChild: [],
+			taskKeys: new Set([completedDestination.task_key]),
+		});
+		const [destinationState] = await db.sql<
+			{ completed_at: Date | null; failed_at: Date | null; subscription_id: string | null }[]
+		>`
+			select completed_at, failed_at, subscription_id
+			from pgconductor._private_executions
+			where id = ${completedDestination.id}::uuid and queue = 'default'
+		`;
+		expect(destinationState?.completed_at).not.toBeNull();
+		expect(destinationState?.failed_at).toBeNull();
+		expect(destinationState?.subscription_id).not.toBeNull();
+	});
+
+	test("serializes queue-scoped subscription replacement", async () => {
+		const db = await database();
+		const blockerSql = postgres(db.url, { max: 1 });
+		const registrationSql = postgres(db.url, { max: 1 });
+		const client = new DatabaseClient({ sql: registrationSql, logger: new DefaultLogger() });
+		let registration: Promise<void> | undefined;
+		try {
+			await blockerSql.begin(async (transaction) => {
+				await transaction`
+					select 1 from pgconductor._private_queues
+					where name = 'default' for update
+				`;
+				registration = client.registerWorker({
+					queueName: "default",
+					taskSpecs: [{ key: "pipeline.serialized", queue: "default", maxAttempts: 3 }],
+					cronSchedules: [],
+					eventSubscriptions: [
+						{
+							task_key: "pipeline.serialized",
+							event_key: "pipeline.serialized",
+							payload_fields: null,
+							filter: null,
+							anchors: compileEventFilterAnchors(null),
+						},
+					],
+				});
+				await waitForCondition(async () => {
+					const [waiting] = await db.sql<{ exists: boolean }[]>`
+						select exists(
+							select 1 from pg_stat_activity
+							where datname = current_database()
+								and cardinality(pg_blocking_pids(pid)) > 0
+						) as exists
+					`;
+					return waiting?.exists === true;
+				});
+			});
+			if (!registration) throw new Error("registration did not start");
+			await registration;
+		} finally {
+			await Promise.all([blockerSql.end(), registrationSql.end()]);
+		}
+
+		const [count] = await db.sql<{ count: number }[]>`
+			select count(*)::integer as count
+			from pgconductor._private_custom_event_subscriptions
+			where queue = 'default' and event_key = 'pipeline.serialized'
+		`;
+		expect(count?.count).toBe(1);
+	}, 30_000);
+
+	test("coordinates claims and recursively drains event fan-out", async () => {
+		const db = await database();
+		await registerSubscriptions(db, [{ taskKey: "pipeline.once", eventKey: "pipeline.once" }]);
+		const eventId = await db.client.emitEvent({ eventKey: "pipeline.once", payload: {} });
+		const sql = postgres(db.url, { max: 2 });
+		const clients = [
+			new DatabaseClient({ sql, logger: new DefaultLogger() }),
+			new DatabaseClient({ sql, logger: new DefaultLogger() }),
+		];
+		try {
+			const owners = [crypto.randomUUID(), crypto.randomUUID()];
+			const claims = await Promise.all(
+				clients.map((client, index) =>
+					client.getExecutions({
+						orchestratorId: owners[index] || "",
+						queueName: INTERNAL_QUEUE,
+						batchSize: 1,
+						filterTaskKeys: [],
+					}),
+				),
+			);
+			expect(claims.flat()).toHaveLength(1);
+			const winner = claims[0]?.length ? 0 : 1;
+			expect(
+				await clients[winner]?.dispatchCustomEvents({
+					eventIds: [eventId],
+					orchestratorId: owners[winner] || "",
+				}),
+			).toEqual([eventId]);
+		} finally {
+			await sql.end();
+		}
+
+		const event = defineEvent({
+			name: "pipeline.drain-fanout",
+			payload: z.object({ value: z.string() }),
+		});
+		const sourceDefinition = defineTask({ name: "pipeline.source", payload: z.object({}) });
+		const destinationDefinition = defineTask({
+			name: "pipeline.destination",
+			queue: "destination",
+			payload: z.object({}),
+		});
+		const conductor = Conductor.create({
+			sql: db.sql,
+			tasks: TaskSchemas.fromSchema([sourceDefinition, destinationDefinition]),
+			events: EventSchemas.fromSchema([event]),
+			context: {},
+		});
+		const received: string[] = [];
+		const source = conductor.createTask(
+			{ name: "pipeline.source" },
+			{ invocable: true },
+			async () => {
+				await conductor.emit("pipeline.drain-fanout", { value: "done" });
+			},
+		);
+		const destination = conductor.createTask(
+			{ name: "pipeline.destination", queue: "destination" },
+			{ event: "pipeline.drain-fanout" },
+			async (receivedEvent) => {
+				received.push(receivedEvent.payload.value);
+			},
+		);
+		await conductor.invoke({ name: "pipeline.source" }, {});
+		await Orchestrator.create({
+			conductor,
+			tasks: [source],
+			workers: [conductor.createWorker({ queue: "destination", tasks: [destination] })],
+			defaultWorker: { pollIntervalMs: 10, flushIntervalMs: 10 },
+		}).drain();
+		expect(received).toEqual(["done"]);
+	});
+
+	test("rejects malformed filters and the reserved internal queue", async () => {
+		const db = await database();
+		const event = defineEvent({
+			name: "pipeline.validation",
+			payload: z.object({ status: z.string(), metadata: z.object({ source: z.string() }) }),
+			filterable: ["status"],
+		});
+		const definition = defineTask({ name: "pipeline.validation-task", payload: z.object({}) });
+		const conductor = Conductor.create({
+			sql: db.sql,
+			tasks: TaskSchemas.fromSchema([definition]),
+			events: EventSchemas.fromSchema([event]),
+			context: {},
+		});
+		expect(() =>
+			conductor.createTask(
+				{ name: "pipeline.validation-task" },
+				{ event: "pipeline.validation", filter: { status: [{ source: "api" }] } } as never,
+				async () => {},
+			),
+		).toThrow(/unsupported operator/);
+		expect(() => conductor.createWorker({ queue: INTERNAL_QUEUE, tasks: [] as never })).toThrow(
+			/reserved for internal use/,
+		);
+	});
+});
diff --git a/packages/pgconductor-js/tests/integration/event-triggers.test.ts b/packages/pgconductor-js/tests/integration/event-triggers.test.ts
index 2975e54..ef10786 100644
--- a/packages/pgconductor-js/tests/integration/event-triggers.test.ts
+++ b/packages/pgconductor-js/tests/integration/event-triggers.test.ts
@@ -4,10 +4,10 @@ import { Conductor } from "../../src/conductor";
 import { Orchestrator } from "../../src/orchestrator";
 import { defineTask } from "../../src/task-definition";
 import { defineEvent } from "../../src/event-definition";
-import { TaskSchemas, EventSchemas, DatabaseSchema } from "../../src/schemas";
+import { TaskSchemas, EventSchemas } from "../../src/schemas";
 import { TestDatabasePool } from "../fixtures/test-database";
 import type { TestDatabase } from "../fixtures/test-database";
-import type { Database } from "../database.types";
+import { waitForCondition } from "../test-utils";
 
 describe("Event Triggers - Custom Events", () => {
 	let pool: TestDatabasePool;
@@ -146,6 +146,7 @@ describe("Event Triggers - Custom Events", () => {
 		const orderPlaced = defineEvent({
 			name: "order.placed",
 			payload: z.object({ orderId: z.string(), total: z.number() }),
+			filterable: ["total"],
 		});
 
 		const taskDef = defineTask({
@@ -167,7 +168,7 @@ describe("Event Triggers - Custom Events", () => {
 
 		const task = conductor.createTask(
 			{ name: "on-large-order" },
-			{ event: "order.placed", when: "(new.payload->>'total')::numeric > 1000" },
+			{ event: "order.placed", filter: { total: [1500] } },
 			taskFn,
 		);
 
@@ -255,347 +256,83 @@ describe("Event Triggers - Custom Events", () => {
 
 		await orchestrator.stop();
 	}, 30000);
-});
-
-describe("Event Triggers - Database CDC", () => {
-	let pool: TestDatabasePool;
-	const databases: TestDatabase[] = [];
-
-	beforeAll(async () => {
-		pool = await TestDatabasePool.create();
-	}, 60000);
-
-	afterEach(async () => {
-		await Promise.all(databases.map((db) => db.destroy()));
-		databases.length = 0;
-	});
 
-	afterAll(async () => {
-		await pool?.destroy();
-	});
-
-	test("task triggered on INSERT", async () => {
+	test("user-owned database triggers can emit transactional custom events", async () => {
 		const db = await pool.child();
 		databases.push(db);
 
-		// Create contact table for testing
 		await db.sql`
-			create table if not exists public.contact (
-				id text primary key default gen_random_uuid()::text,
-				email text,
-				name text,
-				active boolean default true
+			create table public.contact (
+				id text primary key,
+				email text not null
 			)
 		`;
-
-		// Insert initial data so table exists before orchestrator starts
-		// (triggers are created during orchestrator.start(), so table must exist first)
-		await db.sql`insert into public.contact (email, name) values ('initial@example.com', 'Initial')`;
-
-		const taskDef = defineTask({
-			name: "on-contact-insert",
-			payload: z.object({}),
-		});
-
-		const taskFn = mock(async (event) => {
-			expect(event.name).toBe("public.contact.insert");
-			expect(event.payload.tg_op).toBe("INSERT");
-			expect(event.payload.old).toBeNull();
-			expect(event.payload.new).toBeTruthy();
-			expect(event.payload.new.email).toBe("test@example.com");
-		});
-
-		const conductor = Conductor.create({
-			sql: db.sql,
-			tasks: TaskSchemas.fromSchema([taskDef]),
-			database: DatabaseSchema.fromGeneratedTypes<Database>(),
-			context: {},
-		});
-
-		const task = conductor.createTask(
-			{ name: "on-contact-insert" },
-			{ schema: "public", table: "contact", operation: "insert", columns: "id,email,name" },
-			taskFn,
-		);
-
-		const orchestrator = Orchestrator.create({
-			conductor,
-			tasks: [task],
-			defaultWorker: { pollIntervalMs: 50, flushIntervalMs: 50 },
-		});
-
-		await orchestrator.start();
-
-		// Insert a contact (this should trigger the task)
-		await db.sql`insert into public.contact (email, name) values ('test@example.com', 'Test User')`;
-
-		// Wait for task to execute
-		await new Promise((r) => setTimeout(r, 300));
-
-		expect(taskFn).toHaveBeenCalledTimes(1);
-
-		await orchestrator.stop();
-	}, 30000);
-
-	test("task triggered on UPDATE", async () => {
-		const db = await pool.child();
-		databases.push(db);
-
-		// Create contact table
 		await db.sql`
-			create table if not exists public.contact (
-				id text primary key default gen_random_uuid()::text,
-				email text,
-				name text,
-				active boolean default true
-			)
+			create function public.emit_contact_created()
+			returns trigger
+			language plpgsql
+			as $$
+			begin
+				perform pgconductor.emit_event(
+					'contact.created',
+					jsonb_build_object('id', new.id, 'email', new.email)
+				);
+				return new;
+			end;
+			$$
 		`;
-
-		// Insert initial contact
-		const [contact] = await db.sql<[{ id: string }]>`
-			insert into public.contact (email, name)
-			values ('test@example.com', 'Test User')
-			returning id
-		`;
-
-		const taskDef = defineTask({
-			name: "on-contact-update",
-			payload: z.object({}),
-		});
-
-		const taskFn = mock(async (event) => {
-			expect(event.name).toBe("public.contact.update");
-			expect(event.payload.tg_op).toBe("UPDATE");
-			expect(event.payload.old).toBeTruthy();
-			expect(event.payload.new).toBeTruthy();
-			expect(event.payload.old.name).toBe("Test User");
-			expect(event.payload.new.name).toBe("Updated User");
-		});
-
-		const conductor = Conductor.create({
-			sql: db.sql,
-			tasks: TaskSchemas.fromSchema([taskDef]),
-			database: DatabaseSchema.fromGeneratedTypes<Database>(),
-			context: {},
-		});
-
-		const task = conductor.createTask(
-			{ name: "on-contact-update" },
-			{ schema: "public", table: "contact", operation: "update", columns: "id,email,name" },
-			taskFn,
-		);
-
-		const orchestrator = Orchestrator.create({
-			conductor,
-			tasks: [task],
-			defaultWorker: { pollIntervalMs: 50, flushIntervalMs: 50 },
-		});
-
-		await orchestrator.start();
-
-		// Update the contact
-		await db.sql`update public.contact set name = 'Updated User' where id = ${contact?.id}`;
-
-		// Wait for task to execute
-		await new Promise((r) => setTimeout(r, 300));
-
-		expect(taskFn).toHaveBeenCalledTimes(1);
-
-		await orchestrator.stop();
-	}, 30000);
-
-	test("task triggered on DELETE", async () => {
-		const db = await pool.child();
-		databases.push(db);
-
-		// Create contact table
 		await db.sql`
-			create table if not exists public.contact (
-				id text primary key default gen_random_uuid()::text,
-				email text,
-				name text,
-				active boolean default true
-			)
-		`;
-
-		// Insert initial contact
-		const [contact] = await db.sql<[{ id: string }]>`
-			insert into public.contact (email, name)
-			values ('test@example.com', 'Test User')
-			returning id
+			create trigger emit_contact_created
+			after insert on public.contact
+			for each row execute function public.emit_contact_created()
 		`;
 
-		const taskDef = defineTask({
-			name: "on-contact-delete",
-			payload: z.object({}),
-		});
-
-		const taskFn = mock(async (event) => {
-			expect(event.name).toBe("public.contact.delete");
-			expect(event.payload.tg_op).toBe("DELETE");
-			expect(event.payload.old).toBeTruthy();
-			expect(event.payload.new).toBeNull();
-			expect(event.payload.old.email).toBe("test@example.com");
-		});
-
-		const conductor = Conductor.create({
-			sql: db.sql,
-			tasks: TaskSchemas.fromSchema([taskDef]),
-			database: DatabaseSchema.fromGeneratedTypes<Database>(),
-			context: {},
-		});
-
-		const task = conductor.createTask(
-			{ name: "on-contact-delete" },
-			{ schema: "public", table: "contact", operation: "delete", columns: "id,email,name" },
-			taskFn,
-		);
-
-		const orchestrator = Orchestrator.create({
-			conductor,
-			tasks: [task],
-			defaultWorker: { pollIntervalMs: 50, flushIntervalMs: 50 },
-		});
-
-		await orchestrator.start();
-
-		// Delete the contact
-		await db.sql`delete from public.contact where id = ${contact?.id}`;
-
-		// Wait for task to execute
-		await new Promise((r) => setTimeout(r, 300));
-
-		expect(taskFn).toHaveBeenCalledTimes(1);
-
-		await orchestrator.stop();
-	}, 30000);
-
-	test("database trigger with column selection", async () => {
-		const db = await pool.child();
-		databases.push(db);
-
-		// Create contact table for testing
-		await db.sql`
-			create table if not exists public.contact (
-				id text primary key default gen_random_uuid()::text,
-				email text,
-				name text,
-				active boolean default true
-			)
-		`;
-
-		const taskDef = defineTask({
-			name: "on-contact-update-columns",
-			payload: z.object({}),
-		});
-
-		const taskFn = mock(async (event) => {
-			// Should only have selected columns
-			expect(event.payload.new.id).toBeTruthy();
-			expect(event.payload.new.email).toBe("updated@example.com");
-			// Non-selected columns should not exist
-			expect(event.payload.new.name).toBeUndefined();
+		const contactCreated = defineEvent({
+			name: "contact.created",
+			payload: z.object({ id: z.string(), email: z.string() }),
 		});
-
+		const taskDef = defineTask({ name: "handle-contact-created", payload: z.object({}) });
+		const taskFn = mock(async () => {});
 		const conductor = Conductor.create({
 			sql: db.sql,
 			tasks: TaskSchemas.fromSchema([taskDef]),
-			database: DatabaseSchema.fromGeneratedTypes<Database>(),
+			events: EventSchemas.fromSchema([contactCreated]),
 			context: {},
 		});
-
 		const task = conductor.createTask(
-			{ name: "on-contact-update-columns" },
-			{ schema: "public", table: "contact", operation: "update", columns: "id,email" },
+			{ name: "handle-contact-created" },
+			{ event: "contact.created" },
 			taskFn,
 		);
-
 		const orchestrator = Orchestrator.create({
 			conductor,
 			tasks: [task],
-			defaultWorker: { pollIntervalMs: 50, flushIntervalMs: 50 },
+			defaultWorker: { pollIntervalMs: 10, flushIntervalMs: 10 },
 		});
 
 		await orchestrator.start();
-
-		// Insert and update a contact
-		const [contact] = await db.sql<[{ id: string }]>`
-			insert into public.contact (email, name)
-			values ('test@example.com', 'Test User')
-			returning id
-		`;
-		await db.sql`update public.contact set email = 'updated@example.com', name = 'Updated Name' where id = ${contact?.id}`;
-
-		// Wait for task to execute
-		await new Promise((r) => setTimeout(r, 300));
-
-		expect(taskFn).toHaveBeenCalledTimes(1);
-
-		await orchestrator.stop();
-	}, 30000);
-
-	test("database trigger with when clause filters rows", async () => {
-		const db = await pool.child();
-		databases.push(db);
-
-		// Create contact table for testing
-		await db.sql`
-			create table if not exists public.contact (
-				id text primary key default gen_random_uuid()::text,
-				email text,
-				name text,
-				active boolean default true
-			)
+		await db.sql`insert into public.contact (id, email) values ('committed', 'ok@example.com')`;
+		await waitForCondition(() => taskFn.mock.calls.length === 1);
+
+		await expect(
+			db.sql.begin(async (transaction) => {
+				await transaction`
+					insert into public.contact (id, email)
+					values ('rolled-back', 'rollback@example.com')
+				`;
+				throw new Error("roll back");
+			}),
+		).rejects.toThrow("roll back");
+
+		const [rolledBack] = await db.sql<{ count: number }[]>`
+			select count(*)::int as count
+			from pgconductor._private_executions
+			where queue = 'pgconductor.internal'
+				and task_key = 'pgconductor.event-dispatch'
+				and payload ->> 'eventKey' = 'contact.created'
+				and payload -> 'payload' ->> 'id' = 'rolled-back'
 		`;
-
-		const taskDef = defineTask({
-			name: "on-contact-active",
-			payload: z.object({}),
-		});
-
-		const taskFn = mock(async (event) => {
-			// Should only be called for active contacts
-			expect(event.payload.new.active).toBe(true);
-		});
-
-		const conductor = Conductor.create({
-			sql: db.sql,
-			tasks: TaskSchemas.fromSchema([taskDef]),
-			database: DatabaseSchema.fromGeneratedTypes<Database>(),
-			context: {},
-		});
-
-		const task = conductor.createTask(
-			{ name: "on-contact-active" },
-			{
-				schema: "public",
-				table: "contact",
-				operation: "insert",
-				when: "NEW.active = true",
-				columns: "id,email,name,active",
-			},
-			taskFn,
-		);
-
-		const orchestrator = Orchestrator.create({
-			conductor,
-			tasks: [task],
-			defaultWorker: { pollIntervalMs: 50, flushIntervalMs: 50 },
-		});
-
-		await orchestrator.start();
-
-		// Insert inactive contact (should not trigger)
-		await db.sql`insert into public.contact (email, name, active) values ('inactive@example.com', 'Inactive', false)`;
-
-		// Insert active contact (should trigger)
-		await db.sql`insert into public.contact (email, name, active) values ('active@example.com', 'Active', true)`;
-
-		// Wait for tasks to execute
-		await new Promise((r) => setTimeout(r, 300));
-
-		// Should only be called once (for active contact)
-		expect(taskFn).toHaveBeenCalledTimes(1);
+		expect(rolledBack?.count).toBe(0);
 
 		await orchestrator.stop();
 	}, 30000);
diff --git a/packages/pgconductor-js/tests/integration/maintenance-task.test.ts b/packages/pgconductor-js/tests/integration/maintenance-task.test.ts
index e85fe8c..2656b06 100644
--- a/packages/pgconductor-js/tests/integration/maintenance-task.test.ts
+++ b/packages/pgconductor-js/tests/integration/maintenance-task.test.ts
@@ -7,6 +7,7 @@ import { TestDatabasePool } from "../fixtures/test-database";
 import type { TestDatabase } from "../fixtures/test-database";
 import crypto from "crypto";
 import { TaskSchemas } from "../../src/schemas";
+import { createMaintenanceTask } from "../../src/maintenance-task";
 
 function hashToJitter(str: string): number {
 	const hash = crypto.createHash("sha256").update(str).digest();
diff --git a/packages/pgconductor-js/tests/integration/schema-manager.test.ts b/packages/pgconductor-js/tests/integration/schema-manager.test.ts
index 18cb73b..151dea4 100644
--- a/packages/pgconductor-js/tests/integration/schema-manager.test.ts
+++ b/packages/pgconductor-js/tests/integration/schema-manager.test.ts
@@ -45,6 +45,7 @@ describe("SchemaManager", () => {
 		expect(tableNames).toContain("schema_migrations");
 		expect(tableNames).toContain("_private_tasks");
 		expect(tableNames).toContain("_private_executions");
+		expect(tableNames).not.toContain("_private_event_subscriptions");
 
 		// Calling again should report no migration needed
 		const result2 = await schemaManager.ensureLatest(controller.signal);
diff --git a/packages/pgconductor-js/tests/integration/subscription-lifecycle.test.ts b/packages/pgconductor-js/tests/integration/subscription-lifecycle.test.ts
index a535272..8c4d0d3 100644
--- a/packages/pgconductor-js/tests/integration/subscription-lifecycle.test.ts
+++ b/packages/pgconductor-js/tests/integration/subscription-lifecycle.test.ts
@@ -1,25 +1,26 @@
-import { test, expect, describe, beforeAll, afterAll, afterEach, mock } from "bun:test";
+import { afterAll, afterEach, beforeAll, describe, expect, mock, test } from "bun:test";
+import { z } from "zod";
 import { Conductor } from "../../src/conductor";
+import { defineEvent } from "../../src/event-definition";
 import { Orchestrator } from "../../src/orchestrator";
+import { EventSchemas, TaskSchemas } from "../../src/schemas";
 import { defineTask } from "../../src/task-definition";
-import { defineEvent } from "../../src/event-definition";
-import { TaskSchemas } from "../../src/schemas";
-import { EventSchemas } from "../../src/schemas";
-import { DatabaseSchema } from "../../src/schemas";
-import { z } from "zod";
-import { TestDatabasePool, TestDatabase } from "../fixtures/test-database";
-import type { Database } from "../database.types";
+import { TestDatabasePool, type TestDatabase } from "../fixtures/test-database";
+import { waitForCondition } from "../test-utils";
 
-describe("Event Subscription Lifecycle", () => {
+describe("event subscription lifecycle", () => {
 	let pool: TestDatabasePool;
 	const databases: TestDatabase[] = [];
+	const orchestrators: Orchestrator[] = [];
 
 	beforeAll(async () => {
 		pool = await TestDatabasePool.create();
-	}, 60000);
+	}, 60_000);
 
 	afterEach(async () => {
-		await Promise.all(databases.map((db) => db.destroy()));
+		await Promise.all(orchestrators.map((orchestrator) => orchestrator.stop()));
+		orchestrators.length = 0;
+		await Promise.all(databases.map((database) => database.destroy()));
 		databases.length = 0;
 	});
 
@@ -27,437 +28,247 @@ describe("Event Subscription Lifecycle", () => {
 		await pool?.destroy();
 	});
 
-	test("custom event triggers are created on orchestrator start", async () => {
+	async function database(): Promise<TestDatabase> {
 		const db = await pool.child();
 		databases.push(db);
+		return db;
+	}
 
-		const userCreated = defineEvent({
+	test("persists an unconditional subscription with one fallback anchor", async () => {
+		const db = await database();
+		const event = defineEvent({
 			name: "user.created",
 			payload: z.object({ userId: z.string() }),
 		});
-
-		const taskDef = defineTask({
-			name: "on-user-created",
-			payload: z.object({}),
-		});
-
+		const definition = defineTask({ name: "on-user-created", payload: z.object({}) });
 		const conductor = Conductor.create({
 			sql: db.sql,
-			tasks: TaskSchemas.fromSchema([taskDef]),
-			events: EventSchemas.fromSchema([userCreated]),
+			tasks: TaskSchemas.fromSchema([definition]),
+			events: EventSchemas.fromSchema([event]),
 			context: {},
 		});
-
+		const handler = mock(async () => {});
 		const task = conductor.createTask(
 			{ name: "on-user-created" },
 			{ event: "user.created" },
-			mock(async () => {}),
+			handler,
 		);
-
 		const orchestrator = Orchestrator.create({
 			conductor,
 			tasks: [task],
-			defaultWorker: { pollIntervalMs: 50, flushIntervalMs: 50 },
+			defaultWorker: { pollIntervalMs: 10, flushIntervalMs: 10 },
 		});
+		orchestrators.push(orchestrator);
 
 		await orchestrator.start();
 
-		// Check subscription was created
-		const [sub] = await db.sql<[{ event_key: string; task_key: string }]>`
-			select event_key, task_key
-			from pgconductor._private_event_subscriptions
-			where event_key = 'user.created'
-		`;
-
-		expect(sub).toBeTruthy();
-		expect(sub.event_key).toBe("user.created");
-		expect(sub.task_key).toBe("on-user-created");
-
-		// Check trigger function was created
-		const [trigger] = await db.sql<[{ exists: boolean }]>`
-			select exists(
-				select 1
-				from pg_trigger
-				where tgname = 'pgconductor_custom_event'
-					and tgrelid = 'pgconductor._private_custom_events'::regclass
-			)
-		`;
-
-		expect(trigger.exists).toBe(true);
-
-		await orchestrator.stop();
-	}, 30000);
-
-	test("database triggers are created on orchestrator start", async () => {
-		const db = await pool.child();
-		databases.push(db);
-
-		// Create contact table
-		await db.sql`
-			create table if not exists public.contact (
-				id text primary key default gen_random_uuid()::text,
-				email text,
-				name text
-			)
+		const [stored] = await db.sql<
+			{
+				id: string;
+				event_key: string;
+				task_key: string;
+				filter: Record<string, unknown>;
+				operator: string;
+				field_name: string | null;
+			}[]
+		>`
+			select subscription.id, subscription.event_key, subscription.task_key,
+				subscription.filter, anchor.operator, anchor.field_name
+			from pgconductor._private_custom_event_subscriptions subscription
+			join pgconductor._private_event_filter_anchors anchor
+				on anchor.subscription_id = subscription.id
+			where subscription.event_key = 'user.created'
 		`;
-
-		const taskDef = defineTask({
-			name: "on-contact-insert",
-			payload: z.object({}),
-		});
-
-		const conductor = Conductor.create({
-			sql: db.sql,
-			tasks: TaskSchemas.fromSchema([taskDef]),
-			database: DatabaseSchema.fromGeneratedTypes<Database>(),
-			context: {},
+		expect(stored).toEqual({
+			id: expect.any(String),
+			event_key: "user.created",
+			task_key: "on-user-created",
+			filter: {},
+			operator: "fallback",
+			field_name: null,
 		});
 
-		const task = conductor.createTask(
-			{ name: "on-contact-insert" },
-			{ schema: "public", table: "contact", operation: "insert", columns: "id,email,name" },
-			mock(async () => {}),
-		);
-
-		const orchestrator = Orchestrator.create({
-			conductor,
-			tasks: [task],
-			defaultWorker: { pollIntervalMs: 50, flushIntervalMs: 50 },
-		});
-
-		await orchestrator.start();
-
-		// Check subscription was created
-		const [sub] = await db.sql<[{ schema_name: string; table_name: string; operation: string }]>`
-			select schema_name, table_name, operation::text
-			from pgconductor._private_event_subscriptions
-			where schema_name = 'public' and table_name = 'contact' and operation = 'insert'
-		`;
-
-		expect(sub).toBeTruthy();
-		expect(sub.schema_name).toBe("public");
-		expect(sub.table_name).toBe("contact");
-		expect(sub.operation).toBe("insert");
-
-		// Check trigger was created on table
-		const [trigger] = await db.sql<[{ exists: boolean }]>`
-			select exists(
-				select 1
-				from pg_trigger
-				where tgname = 'pgconductor_event_insert'
-					and tgrelid = 'public.contact'::regclass
-			)
-		`;
-
-		expect(trigger.exists).toBe(true);
-
-		await orchestrator.stop();
-	}, 30000);
-
-	test("stopping orchestrator does not remove triggers", async () => {
-		const db = await pool.child();
-		databases.push(db);
-
-		const userCreated = defineEvent({
-			name: "user.created.persistent",
-			payload: z.object({ userId: z.string() }),
+		const eventId = await conductor.emit("user.created", { userId: "user-123" });
+		await waitForCondition(() => handler.mock.calls.length === 1);
+		await waitForCondition(async () => {
+			const [source] = await db.sql<{ exists: boolean }[]>`
+				select exists(
+					select 1 from pgconductor._private_executions
+					where id = ${eventId}::uuid and queue = 'pgconductor.internal'
+				) as exists
+			`;
+			return source?.exists === false;
 		});
-
-		const taskDef = defineTask({
-			name: "on-user-persistent",
-			payload: z.object({}),
+	}, 30_000);
+
+	test("stores the canonical filter and only its selected candidate anchors", async () => {
+		const db = await database();
+		const event = defineEvent({
+			name: "user.qualified",
+			payload: z.object({ active: z.boolean(), region: z.string(), score: z.number() }),
+			filterable: ["active", "region", "score"],
 		});
-
+		const definition = defineTask({ name: "on-qualified-user", payload: z.object({}) });
 		const conductor = Conductor.create({
 			sql: db.sql,
-			tasks: TaskSchemas.fromSchema([taskDef]),
-			events: EventSchemas.fromSchema([userCreated]),
+			tasks: TaskSchemas.fromSchema([definition]),
+			events: EventSchemas.fromSchema([event]),
 			context: {},
 		});
-
 		const task = conductor.createTask(
-			{ name: "on-user-persistent" },
-			{ event: "user.created.persistent" },
+			{ name: "on-qualified-user" },
+			{
+				event: "user.qualified",
+				filter: { score: [7], region: ["us", "eu", "us"], active: [true] },
+			},
 			mock(async () => {}),
 		);
-
-		const orchestrator = Orchestrator.create({
-			conductor,
-			tasks: [task],
-			defaultWorker: { pollIntervalMs: 50, flushIntervalMs: 50 },
-		});
-
+		const orchestrator = Orchestrator.create({ conductor, tasks: [task] });
+		orchestrators.push(orchestrator);
 		await orchestrator.start();
 
-		// Verify trigger exists
-		const [beforeStop] = await db.sql<[{ exists: boolean }]>`
-			select exists(
-				select 1
-				from pg_trigger
-				where tgname = 'pgconductor_custom_event'
-					and tgrelid = 'pgconductor._private_custom_events'::regclass
-			)
+		const rows = await db.sql<
+			{
+				filter: Record<string, unknown[]>;
+				field_name: string;
+				operator: string;
+				scalar_type: string;
+				boolean_value: boolean | null;
+			}[]
+		>`
+			select subscription.filter, anchor.field_name, anchor.operator,
+				anchor.scalar_type, anchor.boolean_value
+			from pgconductor._private_custom_event_subscriptions subscription
+			join pgconductor._private_event_filter_anchors anchor
+				on anchor.subscription_id = subscription.id
+			where subscription.event_key = 'user.qualified'
+			order by anchor.anchor_number
 		`;
-		expect(beforeStop.exists).toBe(true);
+		expect([...rows]).toEqual([
+			{
+				filter: { active: [true], region: ["eu", "us"], score: [7] },
+				field_name: "active",
+				operator: "exact",
+				scalar_type: "boolean",
+				boolean_value: true,
+			},
+		]);
 
 		await orchestrator.stop();
-
-		// Verify trigger still exists after stop
-		const [afterStop] = await db.sql<[{ exists: boolean }]>`
-			select exists(
-				select 1
-				from pg_trigger
-				where tgname = 'pgconductor_custom_event'
-					and tgrelid = 'pgconductor._private_custom_events'::regclass
-			)
+		const [counts] = await db.sql<{ subscriptions: number; anchors: number }[]>`
+			select
+				(select count(*)::integer from pgconductor._private_custom_event_subscriptions)
+					as subscriptions,
+				(select count(*)::integer from pgconductor._private_event_filter_anchors) as anchors
 		`;
-		expect(afterStop.exists).toBe(true);
+		expect(counts).toEqual({ subscriptions: 1, anchors: 1 });
+	}, 30_000);
 
-		// Verify subscription still exists
-		const [sub] = await db.sql<[{ exists: boolean }]>`
-			select exists(
-				select 1
-				from pgconductor._private_event_subscriptions
-				where event_key = 'user.created.persistent'
-			)
-		`;
-		expect(sub.exists).toBe(true);
-	}, 30000);
-
-	test("triggers are recreated when subscriptions change", async () => {
-		const db = await pool.child();
-		databases.push(db);
-
-		const userCreated = defineEvent({
-			name: "user.created.change",
+	test("replaces only the registered queue subscription snapshot", async () => {
+		const db = await database();
+		const event = defineEvent({
+			name: "user.changed",
 			payload: z.object({ userId: z.string(), email: z.string() }),
 		});
+		const firstDefinition = defineTask({ name: "first-handler", payload: z.object({}) });
+		const secondDefinition = defineTask({ name: "second-handler", payload: z.object({}) });
 
-		const taskDef1 = defineTask({
-			name: "task-version-1",
-			payload: z.object({}),
-		});
-
-		const taskDef2 = defineTask({
-			name: "task-version-2",
-			payload: z.object({}),
-		});
-
-		// First orchestrator with no field selection
-		const conductor1 = Conductor.create({
+		const firstConductor = Conductor.create({
 			sql: db.sql,
-			tasks: TaskSchemas.fromSchema([taskDef1]),
-			events: EventSchemas.fromSchema([userCreated]),
+			tasks: TaskSchemas.fromSchema([firstDefinition]),
+			events: EventSchemas.fromSchema([event]),
 			context: {},
 		});
-
-		const task1 = conductor1.createTask(
-			{ name: "task-version-1" },
-			{ event: "user.created.change" },
-			mock(async () => {}),
-		);
-
-		const orchestrator1 = Orchestrator.create({
-			conductor: conductor1,
-			tasks: [task1],
-			defaultWorker: { pollIntervalMs: 50, flushIntervalMs: 50 },
+		const first = Orchestrator.create({
+			conductor: firstConductor,
+			tasks: [
+				firstConductor.createTask(
+					{ name: "first-handler" },
+					{ event: "user.changed" },
+					mock(async () => {}),
+				),
+			],
 		});
+		orchestrators.push(first);
+		await first.start();
+		await first.stop();
 
-		await orchestrator1.start();
-
-		// Check subscription without field selection
-		const [sub1] = await db.sql<[{ payload_fields: string[] | null }]>`
-			select payload_fields
-			from pgconductor._private_event_subscriptions
-			where event_key = 'user.created.change'
-		`;
-		expect(sub1.payload_fields).toBeNull();
-
-		await orchestrator1.stop();
-
-		// Second orchestrator with field selection
-		const conductor2 = Conductor.create({
+		const secondConductor = Conductor.create({
 			sql: db.sql,
-			tasks: TaskSchemas.fromSchema([taskDef2]),
-			events: EventSchemas.fromSchema([userCreated]),
+			tasks: TaskSchemas.fromSchema([secondDefinition]),
+			events: EventSchemas.fromSchema([event]),
 			context: {},
 		});
-
-		const orchestrator2 = Orchestrator.create({
-			conductor: conductor2,
+		const second = Orchestrator.create({
+			conductor: secondConductor,
 			tasks: [
-				conductor2.createTask(
-					{ name: "task-version-2" },
-					{ event: "user.created.change", fields: "userId" },
+				secondConductor.createTask(
+					{ name: "second-handler" },
+					{ event: "user.changed", fields: "userId" },
 					mock(async () => {}),
 				),
 			],
-			defaultWorker: { pollIntervalMs: 50, flushIntervalMs: 50 },
 		});
+		orchestrators.push(second);
+		await second.start();
 
-		await orchestrator2.start();
-
-		// Check subscription was updated with field selection
-		const [sub2] = await db.sql<[{ payload_fields: string[]; task_key: string }]>`
-			select payload_fields, task_key
-			from pgconductor._private_event_subscriptions
-			where event_key = 'user.created.change'
+		const subscriptions = await db.sql<{ task_key: string; payload_fields: string[] | null }[]>`
+			select task_key, payload_fields
+			from pgconductor._private_custom_event_subscriptions
+			where queue = 'default' and event_key = 'user.changed'
 		`;
-		expect(sub2.payload_fields).toEqual(["userId"]);
-		expect(sub2.task_key).toBe("task-version-2");
-
-		await orchestrator2.stop();
-	}, 30000);
-
-	test("multiple workers can register different subscriptions on same event", async () => {
-		const db = await pool.child();
-		databases.push(db);
+		expect([...subscriptions]).toEqual([
+			{ task_key: "second-handler", payload_fields: ["userId"] },
+		]);
+		const [normalized] = await db.sql<{ anchors: number; orphan_anchors: number }[]>`
+			select
+				count(*)::integer as anchors,
+				count(*) filter (where subscription.id is null)::integer as orphan_anchors
+			from pgconductor._private_event_filter_anchors anchor
+			left join pgconductor._private_custom_event_subscriptions subscription
+				on subscription.id = anchor.subscription_id
+		`;
+		expect(normalized).toEqual({ anchors: 1, orphan_anchors: 0 });
+	}, 30_000);
 
-		const userCreated = defineEvent({
-			name: "user.created.multi",
+	test("stores multiple subscriptions on the same event", async () => {
+		const db = await database();
+		const event = defineEvent({
+			name: "user.multi",
 			payload: z.object({ userId: z.string() }),
 		});
-
-		const taskDef1 = defineTask({
-			name: "handler-1",
-			payload: z.object({}),
-		});
-
-		const taskDef2 = defineTask({
-			name: "handler-2",
-			payload: z.object({}),
-		});
-
+		const firstDefinition = defineTask({ name: "handler-1", payload: z.object({}) });
+		const secondDefinition = defineTask({ name: "handler-2", payload: z.object({}) });
 		const conductor = Conductor.create({
 			sql: db.sql,
-			tasks: TaskSchemas.fromSchema([taskDef1, taskDef2]),
-			events: EventSchemas.fromSchema([userCreated]),
+			tasks: TaskSchemas.fromSchema([firstDefinition, secondDefinition]),
+			events: EventSchemas.fromSchema([event]),
 			context: {},
 		});
-
-		const task1 = conductor.createTask(
-			{ name: "handler-1" },
-			{ event: "user.created.multi" },
-			mock(async () => {}),
-		);
-
-		const task2 = conductor.createTask(
-			{ name: "handler-2" },
-			{ event: "user.created.multi" },
-			mock(async () => {}),
-		);
-
 		const orchestrator = Orchestrator.create({
 			conductor,
-			tasks: [task1, task2],
-			defaultWorker: { pollIntervalMs: 50, flushIntervalMs: 50 },
+			tasks: [
+				conductor.createTask(
+					{ name: "handler-1" },
+					{ event: "user.multi" },
+					mock(async () => {}),
+				),
+				conductor.createTask(
+					{ name: "handler-2" },
+					{ event: "user.multi" },
+					mock(async () => {}),
+				),
+			],
 		});
-
+		orchestrators.push(orchestrator);
 		await orchestrator.start();
 
-		// Check both subscriptions exist
-		const subs = await db.sql<{ task_key: string }[]>`
+		const subscriptions = await db.sql<{ task_key: string }[]>`
 			select task_key
-			from pgconductor._private_event_subscriptions
-			where event_key = 'user.created.multi'
+			from pgconductor._private_custom_event_subscriptions
+			where event_key = 'user.multi'
 			order by task_key
 		`;
-
-		expect(subs.length).toBe(2);
-		if (subs[0] && subs[1]) {
-			expect(subs[0].task_key).toBe("handler-1");
-			expect(subs[1].task_key).toBe("handler-2");
-		}
-
-		await orchestrator.stop();
-	}, 30000);
-
-	test("when clause changes trigger recreation", async () => {
-		const db = await pool.child();
-		databases.push(db);
-
-		// Create contact table
-		await db.sql`
-			create table if not exists public.contact (
-				id text primary key default gen_random_uuid()::text,
-				email text,
-				active boolean default true
-			)
-		`;
-
-		const taskDef = defineTask({
-			name: "on-contact-conditional",
-			payload: z.object({}),
-		});
-
-		// First orchestrator without when clause
-		const conductor1 = Conductor.create({
-			sql: db.sql,
-			tasks: TaskSchemas.fromSchema([taskDef]),
-			database: DatabaseSchema.fromGeneratedTypes<Database>(),
-			context: {},
-		});
-
-		const task1 = conductor1.createTask(
-			{ name: "on-contact-conditional" },
-			{ schema: "public", table: "contact", operation: "insert", columns: "id,email,active" },
-			mock(async () => {}),
-		);
-
-		const orchestrator1 = Orchestrator.create({
-			conductor: conductor1,
-			tasks: [task1],
-			defaultWorker: { pollIntervalMs: 50, flushIntervalMs: 50 },
-		});
-
-		await orchestrator1.start();
-
-		// Check subscription without when clause
-		const [sub1] = await db.sql<[{ when_clause: string | null }]>`
-			select when_clause
-			from pgconductor._private_event_subscriptions
-			where schema_name = 'public' and table_name = 'contact'
-		`;
-		expect(sub1.when_clause).toBeNull();
-
-		await orchestrator1.stop();
-
-		// Second orchestrator with when clause
-		const conductor2 = Conductor.create({
-			sql: db.sql,
-			tasks: TaskSchemas.fromSchema([taskDef]),
-			database: DatabaseSchema.fromGeneratedTypes<Database>(),
-			context: {},
-		});
-
-		const task2 = conductor2.createTask(
-			{ name: "on-contact-conditional" },
-			{
-				schema: "public",
-				table: "contact",
-				operation: "insert",
-				when: "NEW.active = true",
-				columns: "id,email,active",
-			},
-			mock(async () => {}),
-		);
-
-		const orchestrator2 = Orchestrator.create({
-			conductor: conductor2,
-			tasks: [task2],
-			defaultWorker: { pollIntervalMs: 50, flushIntervalMs: 50 },
-		});
-
-		await orchestrator2.start();
-
-		// Check subscription was updated with when clause
-		const [sub2] = await db.sql<[{ when_clause: string }]>`
-			select when_clause
-			from pgconductor._private_event_subscriptions
-			where schema_name = 'public' and table_name = 'contact'
-		`;
-		expect(sub2.when_clause).toBe("NEW.active = true");
-
-		await orchestrator2.stop();
-	}, 30000);
+		expect([...subscriptions]).toEqual([{ task_key: "handler-1" }, { task_key: "handler-2" }]);
+	}, 30_000);
 });
diff --git a/packages/pgconductor-js/tests/mocks/database-client.mock.ts b/packages/pgconductor-js/tests/mocks/database-client.mock.ts
index b799b5f..4635bbe 100644
--- a/packages/pgconductor-js/tests/mocks/database-client.mock.ts
+++ b/packages/pgconductor-js/tests/mocks/database-client.mock.ts
@@ -33,9 +33,8 @@ export class MockDatabaseClient implements IDatabaseClient {
 	getDatabaseTime = mock(async () => new Date());
 	setFakeTime = mock(async () => {});
 	clearFakeTime = mock(async () => {});
-	subscribeEvent = mock(async () => "mock-subscription-id");
-	subscribeDbChange = mock(async () => "mock-subscription-id");
 	emitEvent = mock(async () => "mock-event-id");
+	dispatchCustomEvents = mock(async ({ eventIds }: { eventIds: string[] }) => eventIds);
 
 	constructor(overrides: Partial<IDatabaseClient> = {}) {
 		Object.assign(this, overrides);
diff --git a/packages/pgconductor-js/tests/mocks/in-memory-database-client.ts b/packages/pgconductor-js/tests/mocks/in-memory-database-client.ts
index 73f11ce..0a49343 100644
--- a/packages/pgconductor-js/tests/mocks/in-memory-database-client.ts
+++ b/packages/pgconductor-js/tests/mocks/in-memory-database-client.ts
@@ -5,8 +5,8 @@ import type {
 	ExecutionSpec,
 	TaskSpec,
 	Payload,
+	JsonValue,
 	SetFakeTimeArgs,
-	// EventSubscriptionSpec,
 } from "../../src/database-client";
 import { DatabaseClient as RealDatabaseClient } from "../../src/database-client";
 import type {
@@ -23,11 +23,12 @@ import type {
 	SaveStepArgs,
 	ClearWaitingStateArgs,
 	OrchestratorShutdownArgs,
-	// EmitEventArgs,
+	EmitEventArgs,
 } from "../../src/query-builder";
 import type { Migration } from "../../src/migration-store";
 import type { Logger } from "../../src/lib/logger";
 import CronExpressionParser from "cron-parser";
+import { eventFilterMatches } from "../../src/event-dispatch";
 
 type PublicMethodsOf<T> = {
 	[K in keyof T as T[K] extends Function ? K : never]: T[K];
@@ -35,6 +36,10 @@ type PublicMethodsOf<T> = {
 
 type IDatabaseClient = PublicMethodsOf<DatabaseClient>;
 
+const EVENT_DISPATCH_QUEUE = "pgconductor.internal";
+const EVENT_DISPATCH_TASK = "pgconductor.event-dispatch";
+const EVENT_FANOUT_STEP = "pgconductor.internal.event-fanout.v1";
+
 interface StoredExecution {
 	id: string;
 	task_key: string;
@@ -61,6 +66,7 @@ interface StoredExecution {
 	created_at: Date;
 	updated_at: Date;
 	failed_at: Date | null;
+	subscription_id: string | null;
 	dead_letter_source_execution_id: string | null;
 	dead_letter_source_queue: string | null;
 	dead_letter_source_task_key: string | null;
@@ -107,15 +113,11 @@ interface StoredOrchestrator {
 
 interface StoredEventSubscription {
 	id: string;
-	execution_id: string;
-	step_key: string;
-	source: "event" | "db";
-	event_key?: string;
-	schema_name?: string;
-	table_name?: string;
-	operation?: string;
-	columns?: string[];
-	timeout_at: Date | null;
+	task_key: string;
+	queue: string;
+	event_key: string;
+	payload_fields: string[] | null;
+	filter: Record<string, JsonValue[]> | null;
 }
 
 interface SignalData {
@@ -133,13 +135,13 @@ export class InMemoryDatabaseClient implements IDatabaseClient {
 	private cronSchedules = new Map<string, StoredCronSchedule>();
 	private orchestrators = new Map<string, StoredOrchestrator>();
 	private eventSubscriptions = new Map<string, StoredEventSubscription>();
-	private eventPartitions = new Set<string>();
 	private currentTime: Date;
 	private migrationNumber = -1;
 	private idCounter = 0;
 
 	constructor(initialTime: Date = new Date()) {
 		this.currentTime = new Date(initialTime);
+		this.registerInternalEventTask();
 	}
 
 	// ============================================================================
@@ -163,6 +165,46 @@ export class InMemoryDatabaseClient implements IDatabaseClient {
 		return new Date(this.currentTime);
 	}
 
+	private createExecution(spec: ExecutionSpec, now: Date, singletonOn: Date | null = null): string {
+		const task = this.tasks.get(this.taskId(spec.task_key, spec.queue));
+		const id = this.generateId();
+		this.executions.set(id, {
+			id,
+			task_key: spec.task_key,
+			queue: spec.queue,
+			group: spec.group || null,
+			payload: spec.payload || {},
+			state: "pending",
+			run_at: spec.run_at || now,
+			attempts: 0,
+			max_attempts: task?.max_attempts || 3,
+			last_error: null,
+			result: null,
+			cancelled: false,
+			waiting_on_execution_id: null,
+			waiting_step_key: null,
+			waiting_timeout_at: null,
+			dedupe_key: spec.dedupe_key || null,
+			singleton_on: singletonOn,
+			cron_expression: spec.cron_expression || null,
+			priority: spec.priority || 0,
+			orchestrator_id: null,
+			parent_execution_id: spec.parent_execution_id || null,
+			parent_step_key: spec.parent_step_key || null,
+			created_at: now,
+			updated_at: now,
+			failed_at: null,
+			subscription_id: null,
+			dead_letter_source_execution_id: null,
+			dead_letter_source_queue: null,
+			dead_letter_source_task_key: null,
+			dead_letter_error: null,
+			dead_letter_attempts: null,
+			dead_letter_failed_at: null,
+		});
+		return id;
+	}
+
 	// Public synchronous method for test assertions
 	getCurrentTimeSync(): Date {
 		return this.getInternalTime();
@@ -297,8 +339,8 @@ export class InMemoryDatabaseClient implements IDatabaseClient {
 				key: taskSpec.key,
 				queue: taskSpec.queue || args.queueName,
 				max_attempts: taskSpec.maxAttempts || 3,
-				remove_on_complete_days: taskSpec.removeOnCompleteDays || null,
-				remove_on_fail_days: taskSpec.removeOnFailDays || null,
+				remove_on_complete_days: taskSpec.removeOnCompleteDays ?? null,
+				remove_on_fail_days: taskSpec.removeOnFailDays ?? null,
 				window_start: taskSpec.window?.[0] || null,
 				window_end: taskSpec.window?.[1] || null,
 				concurrency: taskSpec.concurrency || null,
@@ -309,6 +351,23 @@ export class InMemoryDatabaseClient implements IDatabaseClient {
 			this.tasks.set(this.taskId(taskSpec.key, task.queue), task);
 		}
 
+		// Registration is authoritative for this queue, just like PostgreSQL.
+		for (const id of [...this.eventSubscriptions.keys()]) {
+			if (this.eventSubscriptions.get(id)?.queue === args.queueName)
+				this.eventSubscriptions.delete(id);
+		}
+		for (const spec of args.eventSubscriptions || []) {
+			const id = this.generateId();
+			this.eventSubscriptions.set(id, {
+				id,
+				task_key: spec.task_key,
+				queue: args.queueName,
+				event_key: spec.event_key,
+				payload_fields: spec.payload_fields,
+				filter: spec.filter,
+			});
+		}
+
 		// Register cron schedules (ExecutionSpec[])
 		for (const cronSpec of args.cronSchedules || []) {
 			if (cronSpec.cron_expression) {
@@ -416,6 +475,7 @@ export class InMemoryDatabaseClient implements IDatabaseClient {
 				dedupe_key: exec.dedupe_key || undefined,
 				cron_expression: exec.cron_expression || undefined,
 				group: exec.group,
+				subscription_id: exec.subscription_id,
 				dead_letter_source_execution_id: exec.dead_letter_source_execution_id,
 				dead_letter_source_queue: exec.dead_letter_source_queue,
 				dead_letter_source_task_key: exec.dead_letter_source_task_key,
@@ -468,8 +528,8 @@ export class InMemoryDatabaseClient implements IDatabaseClient {
 					exec.result = result.result || null;
 					exec.orchestrator_id = null;
 
-					// Wake up parent if waiting
-					if (exec.parent_execution_id) {
+					// Event deliveries retain lineage without workflow-child behavior.
+					if (exec.parent_execution_id && exec.subscription_id === null) {
 						const parent = this.executions.get(exec.parent_execution_id);
 						if (parent && parent.waiting_on_execution_id === exec.id) {
 							parent.waiting_on_execution_id = null;
@@ -485,9 +545,9 @@ export class InMemoryDatabaseClient implements IDatabaseClient {
 						await this.scheduleNextCronExecution(exec);
 					}
 
-					// Remove if cleanup is configured (only if task registered)
+					// Zero-day retention removes immediately; positive retention is swept later.
 					const task = this.tasks.get(this.taskId(exec.task_key, exec.queue));
-					if (task && task.remove_on_complete_days != null) {
+					if (task?.remove_on_complete_days === 0) {
 						this.executions.delete(exec.id);
 						this.steps.delete(exec.id);
 					}
@@ -507,9 +567,8 @@ export class InMemoryDatabaseClient implements IDatabaseClient {
 						exec.failed_at = now;
 						if (!exec.cancelled) this.deliverToDeadLetterQueue(exec, task, result.error, now);
 
-						// Fail parent if waiting. A force-failed parent is itself terminal and
-						// follows its own DLQ and retention policy.
-						if (exec.parent_execution_id) {
+						// Fail a workflow parent only. Event delivery lineage is independent.
+						if (exec.parent_execution_id && exec.subscription_id === null) {
 							const parent = this.executions.get(exec.parent_execution_id);
 							if (parent && parent.waiting_on_execution_id === exec.id) {
 								parent.state = "failed";
@@ -520,15 +579,15 @@ export class InMemoryDatabaseClient implements IDatabaseClient {
 								if (!exec.cancelled) {
 									this.deliverToDeadLetterQueue(parent, parentTask, parent.last_error, now);
 								}
-								if (parentTask?.remove_on_fail_days != null) {
+								if (parentTask?.remove_on_fail_days === 0) {
 									this.executions.delete(parent.id);
 									this.steps.delete(parent.id);
 								}
 							}
 						}
 
-						// Remove if cleanup is configured (only if task registered)
-						if (task && task.remove_on_fail_days != null) {
+						// Zero-day retention removes immediately; positive retention is swept later.
+						if (task?.remove_on_fail_days === 0) {
 							this.executions.delete(exec.id);
 							this.steps.delete(exec.id);
 						}
@@ -569,9 +628,8 @@ export class InMemoryDatabaseClient implements IDatabaseClient {
 					if (!exec.cancelled) this.deliverToDeadLetterQueue(exec, task, result.error, now);
 					exec.orchestrator_id = null;
 
-					// Fail parent if waiting. A force-failed parent is itself terminal and
-					// follows its own DLQ and retention policy.
-					if (exec.parent_execution_id) {
+					// Fail a workflow parent only. Event delivery lineage is independent.
+					if (exec.parent_execution_id && exec.subscription_id === null) {
 						const parent = this.executions.get(exec.parent_execution_id);
 						if (parent && parent.waiting_on_execution_id === exec.id) {
 							parent.state = "failed";
@@ -583,14 +641,14 @@ export class InMemoryDatabaseClient implements IDatabaseClient {
 							if (!exec.cancelled) {
 								this.deliverToDeadLetterQueue(parent, parentTask, parent.last_error, now);
 							}
-							if (parentTask?.remove_on_fail_days != null) {
+							if (parentTask?.remove_on_fail_days === 0) {
 								this.executions.delete(parent.id);
 								this.steps.delete(parent.id);
 							}
 						}
 					}
 
-					if (task && task.remove_on_fail_days != null) {
+					if (task?.remove_on_fail_days === 0) {
 						this.executions.delete(exec.id);
 						this.steps.delete(exec.id);
 					}
@@ -642,30 +700,6 @@ export class InMemoryDatabaseClient implements IDatabaseClient {
 				// 	exec.orchestrator_id = null;
 				// 	break;
 				// }
-
-				// case "wait_for_db_event": {
-				// 	// Create subscription
-				// 	const subscriptionId = this.generateId();
-				// 	this.eventSubscriptions.set(subscriptionId, {
-				// 		id: subscriptionId,
-				// 		execution_id: exec.id,
-				// 		step_key: result.step_key,
-				// 		source: "db",
-				// 		schema_name: result.schema_name,
-				// 		table_name: result.table_name,
-				// 		operation: result.operation,
-				// 		columns: result.columns,
-				// 		timeout_at:
-				// 			result.timeout_ms === "infinity"
-				// 				? new Date(8640000000000000)
-				// 				: new Date(now.getTime() + result.timeout_ms),
-				// 	});
-
-				// 	exec.state = "pending";
-				// 	exec.run_at = new Date(8640000000000000); // Wait indefinitely
-				// 	exec.orchestrator_id = null;
-				// 	break;
-				// }
 			}
 
 			exec.updated_at = now;
@@ -673,12 +707,35 @@ export class InMemoryDatabaseClient implements IDatabaseClient {
 	}
 
 	async removeExecutions(
-		_args: RemoveExecutionsArgs,
+		args: RemoveExecutionsArgs,
 		_opts?: { signal?: AbortSignal },
 	): Promise<boolean> {
-		// In the real implementation, this removes old completed/failed executions
-		// For the in-memory client, we'll just return true (could be enhanced later)
-		return true;
+		const now = this.getInternalTime();
+		const candidates = Array.from(this.executions.values())
+			.filter((exec) => {
+				if (
+					exec.queue !== args.queueName ||
+					(exec.state !== "completed" && exec.state !== "failed")
+				) {
+					return false;
+				}
+				const task = this.tasks.get(this.taskId(exec.task_key, exec.queue));
+				if (!task) return false;
+				const retentionDays =
+					exec.state === "completed" ? task.remove_on_complete_days : task.remove_on_fail_days;
+				if (retentionDays == null || retentionDays <= 0) return false;
+				const terminalAt = exec.state === "completed" ? exec.updated_at : exec.failed_at;
+				return (
+					terminalAt != null && terminalAt.getTime() < now.getTime() - retentionDays * 86400000
+				);
+			})
+			.slice(0, args.batchSize);
+
+		for (const exec of candidates) {
+			this.executions.delete(exec.id);
+			this.steps.delete(exec.id);
+		}
+		return candidates.length >= args.batchSize;
 	}
 
 	async invoke(spec: ExecutionSpec, _opts?: { signal?: AbortSignal }): Promise<string | null> {
@@ -709,48 +766,8 @@ export class InMemoryDatabaseClient implements IDatabaseClient {
 			singletonOn = new Date(slotNumber * dedupeSeconds * 1000);
 		}
 
-		// Helper to create execution
-		const createExecution = (singletonOnValue: Date | null): string => {
-			const task = this.tasks.get(this.taskId(spec.task_key, spec.queue));
-			const id = this.generateId();
-
-			const execution: StoredExecution = {
-				id,
-				task_key: spec.task_key,
-				queue: spec.queue,
-				group: spec.group || null,
-				payload: spec.payload || {},
-				state: "pending",
-				run_at: spec.run_at || now,
-				attempts: 0,
-				max_attempts: task?.max_attempts || 3,
-				last_error: null,
-				result: null,
-				cancelled: false,
-				waiting_on_execution_id: null,
-				waiting_step_key: null,
-				waiting_timeout_at: null,
-				dedupe_key: spec.dedupe_key || null,
-				singleton_on: singletonOnValue,
-				cron_expression: spec.cron_expression || null,
-				priority: spec.priority || 0,
-				orchestrator_id: null,
-				parent_execution_id: spec.parent_execution_id || null,
-				parent_step_key: spec.parent_step_key || null,
-				created_at: now,
-				updated_at: now,
-				failed_at: null,
-				dead_letter_source_execution_id: null,
-				dead_letter_source_queue: null,
-				dead_letter_source_task_key: null,
-				dead_letter_error: null,
-				dead_letter_attempts: null,
-				dead_letter_failed_at: null,
-			};
-
-			this.executions.set(id, execution);
-			return id;
-		};
+		const createExecution = (singletonOnValue: Date | null): string =>
+			this.createExecution(spec, now, singletonOnValue);
 
 		// Throttle/debounce logic
 		if (singletonOn) {
@@ -1065,51 +1082,115 @@ export class InMemoryDatabaseClient implements IDatabaseClient {
 		exec.waiting_timeout_at = null;
 	}
 
-	// // ============================================================================
-	// // Events
-	// // ============================================================================
-	//
-	// async emitEvent(args: { eventKey: string; payload: unknown }, _opts?: { signal?: AbortSignal }): Promise<string> {
-	// 	const eventId = this.generateId();
-	// 	const now = this.getInternalTime();
-	//
-	// 	// Find subscriptions waiting for this event
-	// 	for (const [subId, sub] of this.eventSubscriptions.entries()) {
-	// 		if (sub.source === "event" && sub.event_key === args.eventKey) {
-	// 			// Check timeout
-	// 			if (sub.timeout_at && now > sub.timeout_at) {
-	// 				this.eventSubscriptions.delete(subId);
-	// 				continue;
-	// 			}
-	//
-	// 			// Wake up execution
-	// 			const exec = this.executions.get(sub.execution_id);
-	// 			if (exec) {
-	// 				exec.state = "pending";
-	// 				exec.run_at = now;
-	// 				this.eventSubscriptions.delete(subId);
-	// 			}
-	// 		}
-	// 	}
-	//
-	// 	return eventId;
-	// }
-	//
-	// // Methods referenced in mock but not in main interface
-	// async subscribeEvent(): Promise<string> {
-	// 	return this.generateId();
-	// }
-	//
-	// async subscribeDbChange(): Promise<string> {
-	// 	return this.generateId();
-	// }
+	// ============================================================================
+	// Events
+	// ============================================================================
 
 	async invokeChild(): Promise<string> {
 		return this.generateId();
 	}
 
-	async emitEvent(): Promise<string> {
-		return this.generateId();
+	async emitEvent(args: EmitEventArgs): Promise<string> {
+		if (
+			typeof args.eventKey !== "string" ||
+			args.eventKey.trim().length === 0 ||
+			new TextEncoder().encode(args.eventKey).length > 255
+		) {
+			throw new Error("Event name must contain between 1 and 255 UTF-8 bytes");
+		}
+		const payload = args.payload === undefined ? {} : args.payload;
+		if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
+			throw new Error("Event payload must be a JSON object");
+		}
+		return this.createExecution(
+			{
+				task_key: EVENT_DISPATCH_TASK,
+				queue: EVENT_DISPATCH_QUEUE,
+				payload: { eventKey: args.eventKey, payload },
+			},
+			this.getInternalTime(),
+		);
+	}
+
+	async dispatchCustomEvents(args: {
+		eventIds: string[];
+		orchestratorId: string;
+	}): Promise<string[]> {
+		const dispatched: string[] = [];
+		for (const eventId of args.eventIds) {
+			const source = this.executions.get(eventId);
+			if (
+				!source ||
+				source.queue !== EVENT_DISPATCH_QUEUE ||
+				source.task_key !== EVENT_DISPATCH_TASK ||
+				source.orchestrator_id !== args.orchestratorId ||
+				source.state === "completed" ||
+				source.state === "failed" ||
+				source.cancelled
+			) {
+				continue;
+			}
+			if (this.steps.get(eventId)?.has(EVENT_FANOUT_STEP)) {
+				dispatched.push(eventId);
+				continue;
+			}
+
+			const eventKey = String(source.payload.eventKey);
+			const payload = source.payload.payload as Payload;
+			const destinations: Array<{ spec: ExecutionSpec; subscriptionId: string }> = [];
+			for (const subscription of this.eventSubscriptions.values()) {
+				if (
+					subscription.event_key !== eventKey ||
+					!this.tasks.has(this.taskId(subscription.task_key, subscription.queue))
+				) {
+					continue;
+				}
+				if (!eventFilterMatches(payload, subscription.filter)) continue;
+
+				const destinationPayload = subscription.payload_fields
+					? (Object.fromEntries(
+							subscription.payload_fields
+								.filter((field) => Object.prototype.hasOwnProperty.call(payload, field))
+								.map((field) => [field, payload[field]]),
+						) as Payload)
+					: structuredClone(payload);
+				destinations.push({
+					spec: {
+						task_key: subscription.task_key,
+						queue: subscription.queue,
+						payload: { event: eventKey, payload: destinationPayload },
+						parent_execution_id: eventId,
+					},
+					subscriptionId: subscription.id,
+				});
+			}
+
+			const insertedIds: string[] = [];
+			try {
+				const now = this.getInternalTime();
+				for (const destination of destinations) {
+					const destinationId = this.createExecution(destination.spec, now);
+					insertedIds.push(destinationId);
+					this.executions.get(destinationId)!.subscription_id = destination.subscriptionId;
+				}
+				let sourceSteps = this.steps.get(eventId);
+				if (!sourceSteps) {
+					sourceSteps = new Map();
+					this.steps.set(eventId, sourceSteps);
+				}
+				sourceSteps.set(EVENT_FANOUT_STEP, {
+					execution_id: eventId,
+					step_key: EVENT_FANOUT_STEP,
+					result: {},
+					created_at: now,
+				});
+			} catch (error) {
+				for (const destinationId of insertedIds) this.executions.delete(destinationId);
+				throw error;
+			}
+			dispatched.push(eventId);
+		}
+		return dispatched;
 	}
 
 	// ============================================================================
@@ -1155,6 +1236,7 @@ export class InMemoryDatabaseClient implements IDatabaseClient {
 			created_at: now,
 			updated_at: now,
 			failed_at: null,
+			subscription_id: null,
 			dead_letter_source_execution_id: exec.id,
 			dead_letter_source_queue: exec.queue,
 			dead_letter_source_task_key: exec.task_key,
@@ -1167,6 +1249,22 @@ export class InMemoryDatabaseClient implements IDatabaseClient {
 	// Helpers
 	// ============================================================================
 
+	private registerInternalEventTask(): void {
+		this.tasks.set(this.taskId(EVENT_DISPATCH_TASK, EVENT_DISPATCH_QUEUE), {
+			key: EVENT_DISPATCH_TASK,
+			queue: EVENT_DISPATCH_QUEUE,
+			max_attempts: 3,
+			remove_on_complete_days: 0,
+			remove_on_fail_days: null,
+			window_start: null,
+			window_end: null,
+			concurrency: null,
+			group_concurrency: null,
+			dead_letter_queue: null,
+			dead_letter_task_key: null,
+		});
+	}
+
 	private taskId(key: string, queue: string): string {
 		return `${queue}\u0000${key}`;
 	}
@@ -1237,10 +1335,10 @@ export class InMemoryDatabaseClient implements IDatabaseClient {
 		this.executions.clear();
 		this.steps.clear();
 		this.tasks.clear();
+		this.registerInternalEventTask();
 		this.cronSchedules.clear();
 		this.orchestrators.clear();
 		this.eventSubscriptions.clear();
-		this.eventPartitions.clear();
 		this.idCounter = 0;
 	}
 
diff --git a/packages/pgconductor-js/tests/unit/emit-types.test.ts b/packages/pgconductor-js/tests/unit/emit-types.test.ts
index 09a6244..e92eb72 100644
--- a/packages/pgconductor-js/tests/unit/emit-types.test.ts
+++ b/packages/pgconductor-js/tests/unit/emit-types.test.ts
@@ -41,11 +41,13 @@ describe("emit method types", () => {
 			Promise<string>
 		>();
 
-		// @ts-expect-error - wrong payload type
-		conductor.emit("user.created", { orderId: 123 });
+		if (false) {
+			// @ts-expect-error - wrong payload type
+			conductor.emit("user.created", { orderId: 123 });
 
-		// @ts-expect-error - non-existent event
-		conductor.emit("non.existent", {});
+			// @ts-expect-error - non-existent event
+			conductor.emit("non.existent", {});
+		}
 	});
 
 	test("ctx.emit accepts typed event payload", () => {
diff --git a/packages/pgconductor-js/tests/unit/event-pipeline-types.test.ts b/packages/pgconductor-js/tests/unit/event-pipeline-types.test.ts
new file mode 100644
index 0000000..aabf9f5
--- /dev/null
+++ b/packages/pgconductor-js/tests/unit/event-pipeline-types.test.ts
@@ -0,0 +1,25 @@
+import { describe, expectTypeOf, test } from "bun:test";
+import { z } from "zod";
+import { defineEvent, type FilterForEvent } from "../../src/event-definition";
+
+describe("event filter types", () => {
+	test("omitting filterable fields permits no filters", () => {
+		const event = defineEvent({
+			name: "account.created",
+			payload: z.object({ accountId: z.string() }),
+		});
+		expectTypeOf<FilterForEvent<typeof event>>().toEqualTypeOf<{}>();
+	});
+
+	test("infer allowed fields and values from the payload", () => {
+		const event = defineEvent({
+			name: "order.changed",
+			payload: z.object({ status: z.enum(["pending", "paid"]), accountId: z.string() }),
+			filterable: ["status"],
+		});
+
+		expectTypeOf<{
+			readonly status?: readonly ("pending" | "paid")[];
+		}>().toExtend<FilterForEvent<typeof event>>();
+	});
+});
diff --git a/packages/pgconductor-js/tests/unit/event-trigger-types.test.ts b/packages/pgconductor-js/tests/unit/event-trigger-types.test.ts
index 1b5f5e6..8b6d691 100644
--- a/packages/pgconductor-js/tests/unit/event-trigger-types.test.ts
+++ b/packages/pgconductor-js/tests/unit/event-trigger-types.test.ts
@@ -2,10 +2,9 @@ import { test, expect, describe } from "bun:test";
 import { expectTypeOf } from "expect-type";
 import { Conductor } from "../../src/conductor";
 import { defineTask } from "../../src/task-definition";
-import { defineEvent } from "../../src/event-definition";
-import { TaskSchemas, EventSchemas, DatabaseSchema } from "../../src/schemas";
+import { defineEvent, type DefineEvent } from "../../src/event-definition";
+import { TaskSchemas, EventSchemas } from "../../src/schemas";
 import { z } from "zod";
-import type { Database } from "../database.types";
 
 describe("event triggers", () => {
 	test("task with custom event trigger receives typed event", () => {
@@ -36,41 +35,6 @@ describe("event triggers", () => {
 		});
 	});
 
-	test("task with database event trigger receives typed payload", () => {
-		const taskDef = defineTask({
-			name: "on-contact-insert",
-			payload: z.object({}),
-		});
-
-		const conductor = Conductor.create({
-			sql: {} as any,
-			tasks: TaskSchemas.fromSchema([taskDef]),
-			database: DatabaseSchema.fromGeneratedTypes<Database>(),
-			context: {},
-		});
-
-		// Task triggered by database insert - not invocable
-		conductor.createTask(
-			{ name: "on-contact-insert" },
-			{
-				schema: "public",
-				table: "contact",
-				operation: "insert",
-				columns: "id,email,first_name",
-			},
-			async (event) => {
-				// Event should have database event payload with schema.table.op format
-				expectTypeOf(event.name).toEqualTypeOf<"public.contact.insert">();
-				expectTypeOf(event.payload.tg_op).toEqualTypeOf<"INSERT">();
-				expectTypeOf(event.payload.old).toEqualTypeOf<null>();
-				// new should have selected contact columns
-				expectTypeOf(event.payload.new.id).toEqualTypeOf<string>();
-				expectTypeOf(event.payload.new.email).toEqualTypeOf<string | null>();
-				expectTypeOf(event.payload.new.first_name).toEqualTypeOf<string>();
-			},
-		);
-	});
-
 	test("task with multiple triggers including event trigger", () => {
 		const userCreated = defineEvent({
 			name: "user.created",
@@ -104,44 +68,6 @@ describe("event triggers", () => {
 		);
 	});
 
-	test("task with cron and event triggers", () => {
-		const taskDef = defineTask({
-			name: "cron-and-event",
-			payload: z.object({}),
-		});
-
-		const conductor = Conductor.create({
-			sql: {} as any,
-			tasks: TaskSchemas.fromSchema([taskDef]),
-			database: DatabaseSchema.fromGeneratedTypes<Database>(),
-			context: {},
-		});
-
-		// Task with cron and database event trigger - neither is invocable
-		conductor.createTask(
-			{ name: "cron-and-event" },
-			[
-				{ cron: "0 * * * *", name: "hourly" },
-				{
-					schema: "public",
-					table: "contact",
-					operation: "update",
-					columns: "id,email",
-				},
-			],
-			async (event) => {
-				// Event should be union of cron and database event
-				if (event.name === "hourly") {
-					// Cron event has no payload
-					expectTypeOf(event).toEqualTypeOf<{ name: "hourly" }>();
-				} else if (event.name === "public.contact.update") {
-					// Database update event
-					expectTypeOf(event.payload.tg_op).toEqualTypeOf<"UPDATE">();
-				}
-			},
-		);
-	});
-
 	test("custom event trigger with field selection", () => {
 		const userCreated = defineEvent({
 			name: "user.created",
@@ -193,183 +119,209 @@ describe("event triggers", () => {
 		);
 	});
 
-	test("custom event trigger with when clause", () => {
-		const orderPlaced = defineEvent({
-			name: "order.placed",
-			payload: z.object({ orderId: z.string(), total: z.number() }),
-		});
-
-		const taskDef = defineTask({
-			name: "on-large-order",
-			payload: z.object({}),
+	test("custom event triggers validate event names and projected fields", () => {
+		const userCreated = defineEvent({
+			name: "user.created",
+			payload: z.object({ userId: z.string(), email: z.string() }),
 		});
-
+		const taskDef = defineTask({ name: "on-user-created", payload: z.object({}) });
 		const conductor = Conductor.create({
 			sql: {} as any,
 			tasks: TaskSchemas.fromSchema([taskDef]),
-			events: EventSchemas.fromSchema([orderPlaced]),
+			events: EventSchemas.fromSchema([userCreated]),
 			context: {},
 		});
 
-		// Task with when clause - still receives full payload
-		conductor.createTask(
-			{ name: "on-large-order" },
-			{ event: "order.placed", when: "new.payload->>'total'::numeric > 1000" },
-			async (event) => {
-				expectTypeOf(event.payload).toEqualTypeOf<{
-					orderId: string;
-					total: number;
-				}>();
-			},
-		);
+		if (false) {
+			conductor.createTask(
+				{ name: "on-user-created" },
+				// @ts-expect-error The event is not in the conductor catalog.
+				{ event: "user.typo" },
+				async () => {},
+			);
+			conductor.createTask(
+				{ name: "on-user-created" },
+				// @ts-expect-error The selected field is not in the event payload.
+				{ event: "user.created", fields: "userId,missing" },
+				async () => {},
+			);
+			conductor.createTask(
+				{ name: "on-user-created" },
+				// @ts-expect-error Selected event fields must be unique.
+				{ event: "user.created", fields: "userId,userId" },
+				async () => {},
+			);
+			conductor.createTask(
+				{ name: "on-user-created" },
+				// @ts-expect-error Event field names use unquoted identifier syntax.
+				{ event: "user.created", fields: '"userId"' },
+				async () => {},
+			);
+		}
+
+		expect(() =>
+			conductor.createTask(
+				{ name: "on-user-created" },
+				{ event: "user.typo" } as any,
+				async () => {},
+			),
+		).toThrow('Event "user.typo" is not defined in the conductor event catalog');
+		expect(() =>
+			conductor.createTask(
+				{ name: "on-user-created" },
+				{ event: "user.created", fields: "userId,userId" } as any,
+				async () => {},
+			),
+		).toThrow('Fields for event "user.created" cannot contain duplicate names');
+		expect(() =>
+			conductor.createTask(
+				{ name: "on-user-created" },
+				{ event: "user.created", fields: '"userId"' } as any,
+				async () => {},
+			),
+		).toThrow('Fields for event "user.created" contains invalid field');
 	});
 
-	test("database trigger with column selection", () => {
-		const taskDef = defineTask({
-			name: "on-contact-update-columns",
-			payload: z.object({}),
+	test("type-only events remain valid beside runtime event definitions", () => {
+		type ExternalEvent = DefineEvent<{
+			name: "external.received";
+			payload: { externalId: string };
+			filterable: ["externalId"];
+		}>;
+		const runtimeEvent = defineEvent({
+			name: "user.created",
+			payload: z.object({ userId: z.string() }),
 		});
-
+		const taskDef = defineTask({ name: "external-task", payload: z.object({}) });
 		const conductor = Conductor.create({
 			sql: {} as any,
 			tasks: TaskSchemas.fromSchema([taskDef]),
-			database: DatabaseSchema.fromGeneratedTypes<Database>(),
+			events: EventSchemas.fromSchema([runtimeEvent]).fromUnion<ExternalEvent>(),
 			context: {},
 		});
 
-		// Task with column selection - should only receive selected columns
-		conductor.createTask(
-			{ name: "on-contact-update-columns" },
-			{
-				schema: "public",
-				table: "contact",
-				operation: "update",
-				columns: "id,email",
-			},
-			async (event) => {
-				expectTypeOf(event.name).toEqualTypeOf<"public.contact.update">();
-				expectTypeOf(event.payload.tg_op).toEqualTypeOf<"UPDATE">();
-
-				// OLD and NEW should only have selected columns
-				if (event.payload.old) {
-					expectTypeOf(event.payload.old).toEqualTypeOf<{
-						id: string;
-						email: string | null;
-					}>();
-
-					// @ts-expect-error - name was not selected
-					event.payload.old.name;
-				}
-
-				if (event.payload.new) {
-					expectTypeOf(event.payload.new).toEqualTypeOf<{
-						id: string;
-						email: string | null;
-					}>();
-
-					// @ts-expect-error - name was not selected
-					event.payload.new.name;
-				}
-			},
-		);
+		expect(() =>
+			conductor.createTask(
+				{ name: "external-task" },
+				{ event: "external.received", filter: { externalId: ["external-1"] } },
+				async () => {},
+			),
+		).not.toThrow();
 	});
 
-	test("database trigger with when clause", () => {
-		const taskDef = defineTask({
-			name: "on-contact-active",
-			payload: z.object({}),
+	test("filter operators follow the filterable field type", () => {
+		const changed = defineEvent({
+			name: "order.changed",
+			payload: z.object({
+				status: z.string(),
+				total: z.number(),
+				active: z.boolean(),
+				note: z.string().optional(),
+			}),
+			filterable: ["status", "total", "active", "note"],
 		});
-
+		const taskDef = defineTask({ name: "filtered-order", payload: z.object({}) });
 		const conductor = Conductor.create({
 			sql: {} as any,
 			tasks: TaskSchemas.fromSchema([taskDef]),
-			database: DatabaseSchema.fromGeneratedTypes<Database>(),
+			events: EventSchemas.fromSchema([changed]),
 			context: {},
 		});
 
-		// Task with when clause - still receives selected columns
 		conductor.createTask(
-			{ name: "on-contact-active" },
+			{ name: "filtered-order" },
 			{
-				schema: "public",
-				table: "contact",
-				operation: "insert",
-				when: "NEW.active = true",
-				columns: "id,email,first_name",
-			},
-			async (event) => {
-				if (event.payload.new) {
-					expectTypeOf(event.payload.new.id).toEqualTypeOf<string>();
-					expectTypeOf(event.payload.new.email).toEqualTypeOf<string | null>();
-					expectTypeOf(event.payload.new.first_name).toEqualTypeOf<string>();
-				}
+				event: "order.changed",
+				filter: {
+					status: [{ prefix: "paid-" }],
+					total: [{ numeric: [">=", 10, "<", 20] }],
+					active: [{ "anything-but": false }],
+					note: [{ exists: true }],
+				},
 			},
+			async () => {},
 		);
+
+		if (false) {
+			conductor.createTask(
+				{ name: "filtered-order" },
+				// @ts-expect-error Prefix filters require a string-valued field.
+				{ event: "order.changed", filter: { total: [{ prefix: "10" }] } },
+				async () => {},
+			);
+			conductor.createTask(
+				{ name: "filtered-order" },
+				// @ts-expect-error Numeric filters require a number-valued field.
+				{ event: "order.changed", filter: { status: [{ numeric: [">", 10] }] } },
+				async () => {},
+			);
+			conductor.createTask(
+				{ name: "filtered-order" },
+				// @ts-expect-error Anything-but operands must match the field scalar type.
+				{ event: "order.changed", filter: { active: [{ "anything-but": "true" }] } },
+				async () => {},
+			);
+		}
 	});
 
-	test("database trigger DELETE operation has correct OLD/NEW types", () => {
+	test("filterable event fields must contain scalar values", () => {
+		if (false) {
+			// @ts-expect-error Object-valued payload fields cannot be filterable.
+			defineEvent({
+				name: "user.metadata",
+				payload: z.object({ userId: z.string(), metadata: z.object({ source: z.string() }) }),
+				filterable: ["metadata"],
+			});
+		}
+	});
+
+	test("custom event trigger rejects a when clause", () => {
+		const orderPlaced = defineEvent({
+			name: "order.placed",
+			payload: z.object({ orderId: z.string(), total: z.number() }),
+		});
+
 		const taskDef = defineTask({
-			name: "on-contact-delete",
+			name: "on-large-order",
 			payload: z.object({}),
 		});
 
 		const conductor = Conductor.create({
 			sql: {} as any,
 			tasks: TaskSchemas.fromSchema([taskDef]),
-			database: DatabaseSchema.fromGeneratedTypes<Database>(),
+			events: EventSchemas.fromSchema([orderPlaced]),
 			context: {},
 		});
 
-		conductor.createTask(
-			{ name: "on-contact-delete" },
-			{
-				schema: "public",
-				table: "contact",
-				operation: "delete",
-				columns: "id",
-			},
-			async (event) => {
-				expectTypeOf(event.payload.tg_op).toEqualTypeOf<"DELETE">();
-				// DELETE has OLD but not NEW
-				expectTypeOf(event.payload.new).toEqualTypeOf<null>();
-				if (event.payload.old) {
-					expectTypeOf(event.payload.old.id).toEqualTypeOf<string>();
-				}
-			},
-		);
+		expect(() =>
+			conductor.createTask(
+				{ name: "on-large-order" },
+				{ event: "order.placed", when: "new.payload->>'total'::numeric > 1000" },
+				async (event) => {
+					expectTypeOf(event.payload).toEqualTypeOf<{
+						orderId: string;
+						total: number;
+					}>();
+				},
+			),
+		).toThrow("does not support a when clause");
 	});
 
-	test("database trigger UPDATE operation has both OLD and NEW", () => {
-		const taskDef = defineTask({
-			name: "on-contact-update",
-			payload: z.object({}),
-		});
-
+	test("managed database trigger configuration is not exposed", () => {
+		const taskDef = defineTask({ name: "database-change", payload: z.object({}) });
 		const conductor = Conductor.create({
 			sql: {} as any,
 			tasks: TaskSchemas.fromSchema([taskDef]),
-			database: DatabaseSchema.fromGeneratedTypes<Database>(),
 			context: {},
+			// @ts-expect-error Database schemas are not a Conductor option.
+			database: {},
 		});
 
 		conductor.createTask(
-			{ name: "on-contact-update" },
-			{
-				schema: "public",
-				table: "contact",
-				operation: "update",
-				columns: "id",
-			},
-			async (event) => {
-				expectTypeOf(event.payload.tg_op).toEqualTypeOf<"UPDATE">();
-				// UPDATE has both OLD and NEW
-				if (event.payload.old) {
-					expectTypeOf(event.payload.old.id).toEqualTypeOf<string>();
-				}
-				if (event.payload.new) {
-					expectTypeOf(event.payload.new.id).toEqualTypeOf<string>();
-				}
-			},
+			{ name: "database-change" },
+			// @ts-expect-error Applications own database triggers and emit custom events from them.
+			{ schema: "public", table: "contact", operation: "insert", columns: "id" },
+			async () => {},
 		);
 	});
 });
diff --git a/packages/pgconductor-js/tests/unit/event-trigger-validation.test.ts b/packages/pgconductor-js/tests/unit/event-trigger-validation.test.ts
new file mode 100644
index 0000000..95c1f63
--- /dev/null
+++ b/packages/pgconductor-js/tests/unit/event-trigger-validation.test.ts
@@ -0,0 +1,123 @@
+import { describe, expect, test } from "bun:test";
+import { compileEventTrigger } from "../../src/event-trigger-validation";
+
+describe("event trigger compilation", () => {
+	test("canonicalizes field order and deduplicates scalar alternatives type-sensitively", () => {
+		const compiled = compileEventTrigger(
+			{
+				event: "catalog.changed",
+				filter: {
+					z: [1, 1, 0],
+					a: ["1", 1, true, null],
+				},
+			},
+			[],
+			true,
+		);
+
+		if (!compiled) throw new Error("expected an event trigger");
+		const { anchors, ...subscription } = compiled;
+		expect(subscription).toEqual({
+			event_key: "catalog.changed",
+			payload_fields: null,
+			filter: {
+				a: [null, true, 1, "1"],
+				z: [0, 1],
+			},
+		});
+		expect(
+			anchors.map(({ field_name, operator, scalar_type }) => ({
+				field_name,
+				operator,
+				scalar_type,
+			})),
+		).toEqual([
+			{ field_name: "a", operator: "exact", scalar_type: "null" },
+			{ field_name: "a", operator: "exact", scalar_type: "boolean" },
+			{ field_name: "a", operator: "exact", scalar_type: "number" },
+			{ field_name: "a", operator: "exact", scalar_type: "string" },
+		]);
+	});
+
+	test("preserves prototype-named filter fields", () => {
+		const compiled = compileEventTrigger(
+			{
+				event: "catalog.changed",
+				filter: JSON.parse('{"__proto__":["safe"]}') as Record<string, unknown>,
+			},
+			[],
+			true,
+		);
+
+		expect(compiled?.filter).toEqual(JSON.parse('{"__proto__":["safe"]}'));
+		expect(compiled?.anchors).toEqual([
+			{
+				field_name: "__proto__",
+				operator: "exact",
+				scalar_type: "string",
+				text_value: "safe",
+			},
+		]);
+	});
+
+	test("canonicalizes supported atomic operators", () => {
+		const compiled = compileEventTrigger(
+			{
+				event: "catalog.changed",
+				filter: {
+					status: [{ "anything-but": "blocked" }],
+					score: [{ numeric: ["<", 20, ">=", 10] }],
+					name: [{ prefix: "literal%_\\" }, "exact"],
+					deleted: [{ exists: false }],
+				},
+			},
+			[],
+			true,
+		);
+
+		expect(compiled?.filter).toEqual({
+			deleted: [{ $operator: "exists", value: false }],
+			name: ["exact", { $operator: "prefix", value: "literal%_\\" }],
+			score: [
+				{
+					$operator: "numeric_range",
+					lower: 10,
+					lowerInclusive: true,
+					upper: 20,
+					upperInclusive: false,
+				},
+			],
+			status: [{ $operator: "anything_but", value: "blocked" }],
+		});
+	});
+
+	test("rejects malformed, unbounded, and non-atomic operators", () => {
+		const compile = (value: unknown[]) =>
+			compileEventTrigger({ event: "catalog.changed", filter: { value } }, [], true);
+
+		expect(() => compile([{ prefix: "" }])).toThrow(/non-empty string/);
+		expect(() => compile([{ prefix: "x".repeat(65) }])).toThrow(/64 characters/);
+		expect(() => compile([{ numeric: [">", 10, ">=", 11] }])).toThrow(/duplicate lower bounds/);
+		expect(() => compile([{ numeric: [">", 10, "<", 10] }])).toThrow(/is empty/);
+		expect(() => compile([{ exists: "yes" }])).toThrow(/must be boolean/);
+		expect(() => compile([{ "anything-but": ["a", "b"] }])).toThrow(/requires one scalar value/);
+		expect(() => compile([{ "anything-but": "a" }, "b"])).toThrow(/must be atomic/);
+		expect(() => compile([{ suffix: "x" }])).toThrow(/unsupported operator/);
+	});
+
+	test("enforces index-safe names and UTF-8 byte limits before registration", () => {
+		expect(() =>
+			compileEventTrigger({ event: "catalog.changed", filter: { " ": [true] } }, [], true),
+		).toThrow(/empty field names/);
+		expect(() => compileEventTrigger({ event: "e".repeat(256) }, [], true)).toThrow(
+			/255 UTF-8 bytes/,
+		);
+		expect(() =>
+			compileEventTrigger(
+				{ event: "catalog.changed", filter: { value: ["x".repeat(1023)] } },
+				[],
+				true,
+			),
+		).toThrow(/1024 UTF-8 bytes/);
+	});
+});
diff --git a/packages/pgconductor-js/tests/unit/in-memory-database-client.test.ts b/packages/pgconductor-js/tests/unit/in-memory-database-client.test.ts
index 8b57b09..0654eac 100644
--- a/packages/pgconductor-js/tests/unit/in-memory-database-client.test.ts
+++ b/packages/pgconductor-js/tests/unit/in-memory-database-client.test.ts
@@ -1,4 +1,4 @@
-// @ts-nocheck - Event support commented out
+// @ts-nocheck
 import { test, expect, describe } from "bun:test";
 import { InMemoryDatabaseClient } from "../mocks/in-memory-database-client";
 
@@ -856,6 +856,123 @@ describe("InMemoryDatabaseClient", () => {
 		});
 	});
 
+	describe("Event dispatch", () => {
+		test("validates payload objects and persists one idempotent fan-out marker", async () => {
+			const db = new InMemoryDatabaseClient();
+			await expect(db.emitEvent({ eventKey: "mock.invalid", payload: [] } as any)).rejects.toThrow(
+				"Event payload must be a JSON object",
+			);
+			await expect(
+				db.emitEvent({ eventKey: "mock.invalid", payload: null } as any),
+			).rejects.toThrow("Event payload must be a JSON object");
+			await db.registerWorker({
+				queueName: "default",
+				taskSpecs: [{ key: "event-target", maxAttempts: 3 }],
+				cronSchedules: [],
+				eventSubscriptions: [
+					{
+						task_key: "event-target",
+						event_key: "mock.event",
+						payload_fields: null,
+						filter: { code: [{ $operator: "prefix", value: "ok-" }] },
+					},
+				],
+			});
+			const eventId = await db.emitEvent({
+				eventKey: "mock.event",
+				payload: { code: "ok-value" },
+			});
+			await db.getExecutions({
+				orchestratorId: "event-orchestrator",
+				queueName: "pgconductor.internal",
+				batchSize: 10,
+				filterTaskKeys: [],
+			});
+
+			expect(
+				await db.dispatchCustomEvents({
+					eventIds: [eventId],
+					orchestratorId: "event-orchestrator",
+				}),
+			).toEqual([eventId]);
+			expect(
+				await db.dispatchCustomEvents({
+					eventIds: [eventId],
+					orchestratorId: "event-orchestrator",
+				}),
+			).toEqual([eventId]);
+			expect(
+				db
+					.getAllExecutions()
+					.filter(
+						(execution) =>
+							execution.parent_execution_id === eventId && execution.subscription_id != null,
+					),
+			).toHaveLength(1);
+			expect(
+				await db.loadStep({
+					executionId: eventId,
+					queue: "pgconductor.internal",
+					orchestratorId: "event-orchestrator",
+					key: "pgconductor.internal.event-fanout.v1",
+				}),
+			).toEqual({});
+
+			await db.returnExecutions([
+				{
+					execution_id: eventId,
+					...fencing(db, eventId),
+					queue: "pgconductor.internal",
+					task_key: "pgconductor.event-dispatch",
+					status: "completed",
+					result: null,
+				},
+			]);
+			expect(db.getExecution(eventId)).toBeUndefined();
+			expect(
+				await db.loadStep({
+					executionId: eventId,
+					queue: "pgconductor.internal",
+					orchestratorId: "event-orchestrator",
+					key: "pgconductor.internal.event-fanout.v1",
+				}),
+			).toBeUndefined();
+
+			await db.registerWorker({
+				queueName: "default",
+				taskSpecs: [{ key: "event-target", maxAttempts: 3 }],
+				cronSchedules: [],
+				eventSubscriptions: [
+					{
+						task_key: "event-target",
+						event_key: "mock.event",
+						payload_fields: null,
+						filter: { value: [{ $operator: "anything_but", value: "blocked" }] },
+					},
+				],
+			});
+			const nonScalarEventId = await db.emitEvent({
+				eventKey: "mock.event",
+				payload: { value: { nested: true } },
+			});
+			await db.getExecutions({
+				orchestratorId: "event-orchestrator",
+				queueName: "pgconductor.internal",
+				batchSize: 10,
+				filterTaskKeys: [],
+			});
+			await db.dispatchCustomEvents({
+				eventIds: [nonScalarEventId],
+				orchestratorId: "event-orchestrator",
+			});
+			expect(
+				db
+					.getAllExecutions()
+					.filter((execution) => execution.parent_execution_id === nonScalarEventId),
+			).toHaveLength(0);
+		});
+	});
+
 	describe("Deduplication", () => {
 		test("dedupe_key prevents duplicate executions", async () => {
 			const db = new InMemoryDatabaseClient();
diff --git a/packages/pgconductor-js/tests/unit/task-event-types.test.ts b/packages/pgconductor-js/tests/unit/task-event-types.test.ts
index ee15f44..ab53581 100644
--- a/packages/pgconductor-js/tests/unit/task-event-types.test.ts
+++ b/packages/pgconductor-js/tests/unit/task-event-types.test.ts
@@ -3,7 +3,7 @@ import { expectTypeOf } from "expect-type";
 import { Conductor } from "../../src/conductor";
 import { defineTask } from "../../src/task-definition";
 // import { defineEvent } from "../../src/event-definition";
-import { TaskSchemas /*, EventSchemas, DatabaseSchema */ } from "../../src/schemas";
+import { TaskSchemas /*, EventSchemas */ } from "../../src/schemas";
 import { z } from "zod";
 import type { Database } from "../database.types";
 
@@ -242,72 +242,6 @@ describe("task event types", () => {
 	// 	expect(task.name).toBe("on-user-created");
 	// });
 	//
-	// test.skip("createTask with only database event trigger", () => {
-	// 	const taskDef = defineTask({
-	// 		name: "on-contact-insert",
-	// 	});
-	//
-	// 	const conductor = Conductor.create({
-	// 		sql: {} as any,
-	// 		tasks: TaskSchemas.fromSchema([taskDef]),
-	// 		database: DatabaseSchema.fromGeneratedTypes<Database>(),
-	// 		context: {},
-	// 	});
-	//
-	// 	const task = conductor.createTask(
-	// 		{ name: "on-contact-insert" },
-	// 		{ schema: "public", table: "contact", operation: "insert" },
-	// 		async (event, _ctx) => {
-	// 			// Event should be the database event
-	// 			expectTypeOf(event.name).toEqualTypeOf<"public.contact.insert">();
-	// 			expectTypeOf(event.payload.tg_op).toEqualTypeOf<"INSERT">();
-	// 			expectTypeOf(event.payload.old).toEqualTypeOf<null>();
-	//
-	// 			// new should have contact row type
-	// 			if (event.payload.new) {
-	// 				expectTypeOf(event.payload.new.id).toEqualTypeOf<string>();
-	// 				expectTypeOf(event.payload.new.first_name).toEqualTypeOf<string>();
-	// 				expectTypeOf(event.payload.new.email).toEqualTypeOf<string | null>();
-	// 			}
-	// 		},
-	// 	);
-	//
-	// 	expect(task.name).toBe("on-contact-insert");
-	// });
-	//
-	// test.skip("createTask with database event trigger and column selection", () => {
-	// 	const taskDef = defineTask({
-	// 		name: "on-contact-columns",
-	// 	});
-	//
-	// 	const conductor = Conductor.create({
-	// 		sql: {} as any,
-	// 		tasks: TaskSchemas.fromSchema([taskDef]),
-	// 		database: DatabaseSchema.fromGeneratedTypes<Database>(),
-	// 		context: {},
-	// 	});
-	//
-	// 	conductor.createTask(
-	// 		{ name: "on-contact-columns" },
-	// 		{ schema: "public", table: "contact", operation: "insert", columns: "id, email" },
-	// 		async (event, _ctx) => {
-	// 			// Event should be the database event with column selection
-	// 			expectTypeOf(event.name).toEqualTypeOf<"public.contact.insert">();
-	// 			expectTypeOf(event.payload.tg_op).toEqualTypeOf<"INSERT">();
-	// 			expectTypeOf(event.payload.old).toEqualTypeOf<null>();
-	//
-	// 			// new should only have selected columns
-	// 			if (event.payload.new) {
-	// 				expectTypeOf(event.payload.new.id).toEqualTypeOf<string>();
-	// 				expectTypeOf(event.payload.new.email).toEqualTypeOf<string | null>();
-	//
-	// 				// @ts-expect-error - first_name not in column selection
-	// 				const _invalid = event.payload.new.first_name;
-	// 			}
-	// 		},
-	// 	);
-	// });
-	//
 	// test.skip("createTask with custom event and invocable triggers", () => {
 	// 	const orderPlaced = defineEvent({
 	// 		name: "order.placed",
@@ -347,88 +281,6 @@ describe("task event types", () => {
 	// 	expect(task.name).toBe("process-order");
 	// });
 	//
-	// test.skip("createTask with database event and cron triggers", () => {
-	// 	const taskDef = defineTask({
-	// 		name: "sync-contacts",
-	// 	});
-	//
-	// 	const conductor = Conductor.create({
-	// 		sql: {} as any,
-	// 		tasks: TaskSchemas.fromSchema([taskDef]),
-	// 		database: DatabaseSchema.fromGeneratedTypes<Database>(),
-	// 		context: {},
-	// 	});
-	//
-	// 	const task = conductor.createTask(
-	// 		{ name: "sync-contacts" },
-	// 		[
-	// 			{ cron: "0 * * * *", name: "hourly" },
-	// 			{ schema: "public", table: "contact", operation: "update" },
-	// 		],
-	// 		async (event, _ctx) => {
-	// 			// Event can be either cron or database event
-	// 			if (event.name === "hourly") {
-	// 				expectTypeOf(event).toEqualTypeOf<{ name: "hourly" }>();
-	// 			} else if (event.name === "public.contact.update") {
-	// 				expectTypeOf(event.payload.tg_op).toEqualTypeOf<"UPDATE">();
-	// 				// Both old and new should have values for update
-	// 				expectTypeOf(event.payload.old).not.toEqualTypeOf<null>();
-	// 				expectTypeOf(event.payload.new).not.toEqualTypeOf<null>();
-	// 			}
-	// 		},
-	// 	);
-	//
-	// 	expect(task.name).toBe("sync-contacts");
-	// });
-	//
-	// test.skip("createTask with all trigger types", () => {
-	// 	const paymentReceived = defineEvent({
-	// 		name: "payment.received",
-	// 		payload: z.object({ paymentId: z.string(), amount: z.number() }),
-	// 	});
-	//
-	// 	const taskDef = defineTask({
-	// 		name: "audit-task",
-	// 		payload: z.object({ reason: z.string() }),
-	// 	});
-	//
-	// 	const conductor = Conductor.create({
-	// 		sql: {} as any,
-	// 		tasks: TaskSchemas.fromSchema([taskDef]),
-	// 		events: EventSchemas.fromSchema([paymentReceived]),
-	// 		database: DatabaseSchema.fromGeneratedTypes<Database>(),
-	// 		context: {},
-	// 	});
-	//
-	// 	const task = conductor.createTask(
-	// 		{ name: "audit-task" },
-	// 		[
-	// 			{ invocable: true },
-	// 			{ cron: "0 0 * * *", name: "daily" },
-	// 			{ event: "payment.received" },
-	// 			{ schema: "public", table: "contact", operation: "delete" },
-	// 		],
-	// 		async (event, _ctx) => {
-	// 			// Event can be any of the four types
-	// 			if (event.name === "pgconductor.invoke") {
-	// 				expectTypeOf(event.payload).toEqualTypeOf<{ reason: string }>();
-	// 			} else if (event.name === "daily") {
-	// 				expectTypeOf(event).toEqualTypeOf<{ name: "daily" }>();
-	// 			} else if (event.name === "payment.received") {
-	// 				expectTypeOf(event.payload.paymentId).toEqualTypeOf<string>();
-	// 				expectTypeOf(event.payload.amount).toEqualTypeOf<number>();
-	// 			} else if (event.name === "public.contact.delete") {
-	// 				expectTypeOf(event.payload.tg_op).toEqualTypeOf<"DELETE">();
-	// 				expectTypeOf(event.payload.new).toEqualTypeOf<null>();
-	// 				// old should have the deleted row
-	// 				expectTypeOf(event.payload.old).not.toEqualTypeOf<null>();
-	// 			}
-	// 		},
-	// 	);
-	//
-	// 	expect(task.name).toBe("audit-task");
-	// });
-	//
 	// test.skip("type error: custom event trigger without event definition", () => {
 	// 	const taskDef = defineTask({
 	// 		name: "undefined-event-task",
diff --git a/packages/pgconductor-js/tests/unit/worker-lifecycle.test.ts b/packages/pgconductor-js/tests/unit/worker-lifecycle.test.ts
new file mode 100644
index 0000000..6da1797
--- /dev/null
+++ b/packages/pgconductor-js/tests/unit/worker-lifecycle.test.ts
@@ -0,0 +1,32 @@
+import { expect, test } from "bun:test";
+import { Worker } from "../../src/worker";
+import { DefaultLogger } from "../../src/lib/logger";
+import { MockDatabaseClient } from "../mocks/database-client.mock";
+import type { AnyTask } from "../../src/task";
+
+const task = {
+	name: "lifecycle-task",
+	triggers: [{ invocable: true }],
+	maxAttempts: 3,
+	execute: async () => {},
+} as unknown as AnyTask;
+
+test("resets a worker after registration failure and permits retry", async () => {
+	let shouldFail = true;
+	const db = new MockDatabaseClient({
+		registerWorker: async () => {
+			if (shouldFail) throw new Error("registration failed");
+		},
+	});
+	const worker = new Worker("default", [task], db as never, new DefaultLogger());
+
+	await expect(worker.start("first-orchestrator")).rejects.toThrow("registration failed");
+	// A failed startup is not a running worker: stopped must be already settled,
+	// rather than an unhandled rejected lifecycle promise.
+	await expect(worker.stopped).resolves.toBeUndefined();
+
+	shouldFail = false;
+	await worker.start("second-orchestrator");
+	await worker.stop();
+	await expect(worker.stopped).resolves.toBeUndefined();
+});