@@ -0,0 +1,11 @@
+---
+'@pgflow/core': minor
+'@pgflow/dsl': minor
+'@pgflow/client': minor
+'@pgflow/edge-worker': minor
+'pgflow': minor
+---
+
+Remove migration-based flow compilation. Flow workers now always compile or verify their imported definition before registration and polling.
+
+This removes `compileFlow()`, `compareFlowShapes()`, `ControlPlane`, `pgflow compile`, `FlowWorkerConfig.compilation`, and production `allowDataLoss`. The database migration removes `pgflow.ensure_flow_compiled(text, jsonb, boolean)`, so stop old workers before applying it and upgrade the fixed pgflow package set together.
@@ -123,13 +123,7 @@ const CompleteExample = new Flow<{ urls: string[] }>({
 export default CompleteExample;
 ```
 
-**Compilation**:
-```bash
-npx pgflow compile path/to/flow.ts
-# Generates migration with:
-# - SELECT pgflow.create_flow(...)
-# - SELECT pgflow.add_step(...) for each step
-```
+**Compilation**: Worker startup extracts the complete flow shape (`extractFlowShape()`) and PostgreSQL compiles or verifies it via `pgflow.ensure_flow_compiled(flow_slug, shape)` before any registration.
 
 **Important**: See DSL package files for:
 - Type inference utilities: `ExtractFlowInput`, `ExtractFlowOutput`, `StepInput`, `StepOutput`
@@ -203,7 +197,10 @@ npx pgflow compile path/to/flow.ts
 **Mental model**: Execution engine. Doesn't know where tasks come from or overall workflow state.
 
 **Worker Lifecycle**:
-1. `acknowledgeStart()` - Register worker with `workerId` in database
+1. `acknowledgeStart()`:
+   - Compile or verify the imported flow shape (`ensureFlowCompiled`)
+   - Track the worker function (`track_worker_function`)
+   - Insert the worker row with `workerId` in the database
 2. Main loop:
    - `sendHeartbeat()` - Update status, check deprecation
    - If deprecated → exit gracefully
@@ -281,7 +278,6 @@ await worker.start();
 
 **Commands**:
 - `pgflow install [--supabase-path <path>] [-y, --yes]` - Sets up pgflow
-- `pgflow compile <flow.ts> [--deno-json <path>] [--supabase-path <path>]` - Compiles flows to SQL
 
 **See**: `/pkgs/cli/src/commands/` for implementation details
 
@@ -330,12 +326,13 @@ await worker.start();
 **Why**: Prevents infinite waiting on steps that will never have tasks.
 
 **How**:
-- DSL: Map steps compiled with `step_type => 'map'`
+- DSL: Map steps carry `stepType: 'map'` in the extracted shape; `_create_flow_from_shape` persists it as `step_type = 'map'`
 - SQL Core: `complete_task()` detects array parent completed with `[]`, sets dependent map `initial_tasks=0`
 - SQL Core: `cascade_complete_taskless_steps()` completes all `initial_tasks=0` steps in chain (max 50 iterations)
 
 **See**:
-- DSL compilation: `/pkgs/dsl/src/compiler/compileFlow.ts`
+- Shape extraction: `/pkgs/dsl/src/flow-shape.ts`
+- SQL compiler: `/pkgs/core/schemas/0100_function_create_flow_from_shape.sql`
 - Cascade logic: `/pkgs/core/src/migrations/` (function: `cascade_complete_taskless_steps`)
 
 ### 3. Realtime Events (SQL Core + Client)
 
@@ -241,12 +241,10 @@ Step handlers use **asymmetric signatures** based on whether they have dependenc
 | Command                            | Description                              |
 | ---------------------------------- | ---------------------------------------- |
 | `npx pgflow@latest install`        | Install pgflow in Supabase project       |
-| `npx pgflow@latest compile <file>` | Compile TypeScript flow to SQL migration |
 
 **Common Options**:
 
 - `--supabase-path <path>` - Custom Supabase directory
-- `--deno-json <path>` - Custom deno.json config
 - `--yes` / `-y` - Skip confirmation prompts
 
 ## Client API
 
@@ -84,8 +84,8 @@ See how pgflow compares to [Trigger.dev](https://pgflow.dev/comparisons/trigger/
 ## How it works
 
 1. **Define workflows** using the TypeScript DSL
-2. **Compile** them to SQL migrations
-3. **Deploy** as Supabase Edge Functions
+2. **Deploy** as Supabase Edge Functions
+3. **Compile & verify** automatically in the database at worker startup
 4. **Trigger** from your app, SQL, or pg_cron
 
 The execution engine handles scheduling, retries, and result aggregation automatically.
@@ -94,7 +94,7 @@ The execution engine handles scheduling, retries, and result aggregation automat
 
 | Package                                    | Version                                                                                             | Description                                             |
 | ------------------------------------------ | --------------------------------------------------------------------------------------------------- | ------------------------------------------------------- |
-| [pgflow](./pkgs/cli/)                      | [![npm](https://img.shields.io/npm/v/pgflow)](https://www.npmjs.com/package/pgflow)                 | CLI for installing and compiling flows                  |
+| [pgflow](./pkgs/cli/)                      | [![npm](https://img.shields.io/npm/v/pgflow)](https://www.npmjs.com/package/pgflow)                 | CLI for installing pgflow into your Supabase project      |
 | [@pgflow/core](./pkgs/core/)               | [![npm](https://img.shields.io/npm/v/@pgflow/core)](https://www.npmjs.com/package/@pgflow/core)     | SQL Core - foundational tables and functions            |
 | [@pgflow/dsl](./pkgs/dsl/)                 | [![npm](https://img.shields.io/npm/v/@pgflow/dsl)](https://www.npmjs.com/package/@pgflow/dsl)       | TypeScript DSL for defining flows with type inference   |
 | [@pgflow/edge-worker](./pkgs/edge-worker/) | [![JSR](https://jsr.io/badges/@pgflow/edge-worker)](https://jsr.io/@pgflow/edge-worker)             | Task queue worker for Supabase Edge Functions           |
 
@@ -27,7 +27,7 @@
     "Root map steps omit `array:`, dependent maps require it - Root maps process flow input directly without `array:` property (e.g., `new Flow<string[]>().map({ slug: 'process' }, ...)`); dependent maps must specify `array:` to indicate which step's output to process.",
     "Steps with the same dependencies run in parallel - pgflow automatically maximizes parallelism by running independent steps concurrently once their dependencies are satisfied.",
     "Handler functions receive context as second parameter - Root steps: `(flowInput, ctx)`, dependent steps: `(deps, ctx)`. Context provides platform resources like `ctx.sql`, `ctx.supabase`, `ctx.env`, `ctx.flowInput`, `ctx.stepTask`, and `ctx.rawMessage` without requiring global imports or connection setup.",
-    "Flows must be compiled before execution - Run `npx pgflow@latest compile` to convert TypeScript flow definitions into SQL migrations that register the flow structure in the database.",
+    "Flows are deployed by worker startup - A worker compiles or verifies its imported flow definition in the database before registration and polling; there is no separate compile command or migration.",
     "Registered flows are immutable - Once a flow is registered in the database, its structure cannot be modified; use versioning or deletion (development only) to make changes.",
     "Use camelCase for step slugs - Step slugs follow JavaScript naming conventions (e.g., `fetchData`, not `fetch_data`) since they become property names in TypeScript for accessing outputs.",
     "Name steps based on their primary purpose - Use nouns when downstream steps process the returned data (e.g., `website`, `userProfiles`); use verb-noun when the side effect is primary (e.g., `sendEmails`, `saveToDb`).",
 
@@ -7,11 +7,10 @@ The Command Line Interface for pgflow - a PostgreSQL-native workflow engine.
 
 ## Overview
 
-This package provides essential tools for setting up, managing, and deploying pgflow workflows in your Supabase environment. The CLI handles:
+This package provides essential tools for setting up pgflow in your Supabase project. The CLI handles:
 
 - Installing pgflow in your Supabase project
-- Compiling TypeScript workflow definitions into SQL migrations
-- Managing workflow deployment and updates
+- Updating pgflow's project files (safe to re-run)
 
 ## Prerequisites
 
@@ -59,26 +58,6 @@ The installer will:
 3. Configure environment variables for Edge Functions
 4. Guide you through applying migrations
 
-### Compile Flow Definition
-
-Convert a TypeScript flow definition into a SQL migration:
-
-```bash
-npx pgflow@latest compile my_flow
-```
-
-Options:
-
-- `--supabase-path <path>` - Path to custom Supabase directory
-- `--control-plane-url <url>` - ControlPlane URL (default: `http://127.0.0.1:54321/functions/v1/pgflow`)
-
-The compiler will:
-
-1. Parse your TypeScript flow definition
-2. Extract step dependencies and configuration
-3. Generate SQL commands for database registration
-4. Create a timestamped migration file in your migrations folder
-
 ## Building
 
 Run `nx build cli` to build the library.
@@ -91,6 +70,6 @@ Run `nx test cli` to execute the unit tests via [Vitest](https://vitest.dev/).
 
 For detailed documentation, visit:
 
-- [Installation Guide](https://pgflow.dev/getting-started/install-pgflow/)
-- [Compiling Flows](https://pgflow.dev/getting-started/compile-to-sql/)
-- [Running Flows](https://pgflow.dev/getting-started/run-flow/)
+- [Installation Guide](https://pgflow.dev/get-started/installation/)
+- [Startup Compilation](https://pgflow.dev/concepts/startup-compilation/)
+- [Running Flows](https://pgflow.dev/get-started/flows/run-flow/)