diff --git a/AGENTS.md b/AGENTS.md
index ac00741c49..83b68f7d36 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -24,7 +24,8 @@ Open-source platform for internal tools, workflows, API integrations, background
 ## Dev Environment
 
 - **Backend**: `cargo run` from `backend/` (API at http://localhost:8000)
-- **DuckDB local jobs**: before running DuckDB scripts locally, build the FFI shared library with `cd backend/windmill-duckdb-ffi-internal && ./build_dev.sh`. Re-run it after clean builds or when `backend/target/debug/libwindmill_duckdb_ffi_internal.*` is missing.
+- **DuckDB local jobs**: before running DuckDB scripts locally, build the FFI shared library with `cd backend/windmill-duckdb-ffi-internal && ./build_dev.sh`. Re-run it after clean builds or when `backend/target/debug/libwindmill_duckdb_ffi_internal.*` is missing. The bundled DuckDB compile (~2min) is cached in a per-user dir shared across worktrees, so a fresh worktree reuses it and the build is near-instant.
+- **Data pipelines (DuckLake) from source**: a plain `cargo run` (even `--features quickjs`) advertises a `duckdb` worker tag but **cannot** execute DuckDB scripts and has **no** working S3 proxy (DuckLake writes 404). Build CE DuckLake with `cargo run --features quickjs,duckdb,parquet,private` (add `,python` for Python scripts, `,enterprise,license` for EE) **and** build the FFI (bullet above). See `backend/CLAUDE.md` → "Running data pipelines (DuckLake) from source" for the exact feature sets and the two feature-gate gotchas.
 - **Frontend**: `REMOTE=http://localhost:8000 npm run dev` from `frontend/` (port 3000+)
 - **DB**: `psql postgres://postgres:changeme@localhost:5432/windmill`
 - **Login**: `admin@windmill.dev` / `changeme`
diff --git a/CHANGELOG.md b/CHANGELOG.md
index b5342e3024..365084fbfb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,49 @@
 # Changelog
 
+## [1.749.0](https://github.com/windmill-labs/windmill/compare/v1.748.0...v1.749.0) (2026-07-05)
+
+
+### Features
+
+* **pipelines:** mid-DAG selective execution (dbt `model+`) for pipeline runs ([#9945](https://github.com/windmill-labs/windmill/issues/9945)) ([2d3a773](https://github.com/windmill-labs/windmill/commit/2d3a77344104a587548f23f1b614ceffd52a5778))
+* **pipelines:** partition run-arg picker + first-run setup signpost ([#9943](https://github.com/windmill-labs/windmill/issues/9943)) ([475b072](https://github.com/windmill-labs/windmill/commit/475b072987b33d50111f5251a5f69f4245f930ae))
+* **pipelines:** self-teaching custom data_test errors + scaffold ([#9937](https://github.com/windmill-labs/windmill/issues/9937)) ([0ad174f](https://github.com/windmill-labs/windmill/commit/0ad174fa490e17eeb26280b5bdfd62956dfed9ff))
+
+
+### Bug Fixes
+
+* **cli:** macro-library parity in --local pipeline graph + read-only run --dry-run ([#9942](https://github.com/windmill-labs/windmill/issues/9942)) ([e3f4303](https://github.com/windmill-labs/windmill/commit/e3f43033cafcdb5df253aeb55ce93e599b2584d2))
+* **datatable:** self-teaching error for unresolved datatable:// references ([#9941](https://github.com/windmill-labs/windmill/issues/9941)) ([55451db](https://github.com/windmill-labs/windmill/commit/55451db009e3060c21948ece2c97e102a3c9b171))
+* **object-storage:** remove 20-file bucket-browser listing cap in CE ([#9935](https://github.com/windmill-labs/windmill/issues/9935)) ([22452ce](https://github.com/windmill-labs/windmill/commit/22452ce54034a9bea8f7d48946818fd148b938c0))
+* **pipelines:** dedup guard for keyed merge + deploy-time SCD2 validation ([#9936](https://github.com/windmill-labs/windmill/issues/9936)) ([52ce805](https://github.com/windmill-labs/windmill/commit/52ce805f619747af4f998cde7819a164c754205a))
+* **pipelines:** link SCD2 <dim>_current view to its producer across all graph surfaces ([#9933](https://github.com/windmill-labs/windmill/issues/9933)) ([574d3ac](https://github.com/windmill-labs/windmill/commit/574d3ac9ff5015b5d3f53040c9d4dfbfd161a076))
+* **pipelines:** order data_test relationships refs before the tested script in a cascade ([#9934](https://github.com/windmill-labs/windmill/issues/9934)) ([46be39d](https://github.com/windmill-labs/windmill/commit/46be39dfb7fbfb2b70e61819d6065b45810c41c9))
+* **pipelines:** pipeline-level run control, tables label, data-test rollback + fork badges ([#9944](https://github.com/windmill-labs/windmill/issues/9944)) ([6ae8dd3](https://github.com/windmill-labs/windmill/commit/6ae8dd37b1de930ab17344cebf7c28385c6cfdba))
+* rebuild windows bun loader main.ts filter from forward-slash cdir ([#9946](https://github.com/windmill-labs/windmill/issues/9946)) ([a582e04](https://github.com/windmill-labs/windmill/commit/a582e04bf40cf685f88bceaf88e3d24bde3d420a))
+
+## [1.748.0](https://github.com/windmill-labs/windmill/compare/v1.747.0...v1.748.0) (2026-07-05)
+
+
+### Features
+
+* **ai-agent:** support reasoning effort in AI agent workflow steps ([#9886](https://github.com/windmill-labs/windmill/issues/9886)) ([a368d49](https://github.com/windmill-labs/windmill/commit/a368d49bd8786a2dca6771f2051f1d44d1b2363d))
+* **ducklake:** scheduled lake maintenance (expiry, compaction, orphan cleanup) ([#9916](https://github.com/windmill-labs/windmill/issues/9916)) ([3352150](https://github.com/windmill-labs/windmill/commit/33521505dbc34f22b575d21fda1cc76d698a8840))
+* **pipelines:** asset freshness — fresh/stale badge (CE) + watchdog (EE) ([#9909](https://github.com/windmill-labs/windmill/issues/9909)) ([5d7fb6d](https://github.com/windmill-labs/windmill/commit/5d7fb6deca3e02e89d77e5d3856483beb8b8bfeb))
+* **pipelines:** capture violating-row samples for data tests ([#9919](https://github.com/windmill-labs/windmill/issues/9919)) ([d4b4374](https://github.com/windmill-labs/windmill/commit/d4b4374de8f8a7875b050c16d1236fcd0355812b))
+* **pipelines:** fork data environments for ducklake materialization (dev data) ([#9915](https://github.com/windmill-labs/windmill/issues/9915)) ([39eb9de](https://github.com/windmill-labs/windmill/commit/39eb9de1bce400109c130a081807e40e995ae068))
+* **pipelines:** on_schema_change write guardrails + data_test deploy validation ([#9930](https://github.com/windmill-labs/windmill/issues/9930)) ([377c02e](https://github.com/windmill-labs/windmill/commit/377c02ec47389e64b7ef5cbbae0de05df648266d))
+* **pipelines:** record upstream snapshot ids on cascade-dispatched jobs ([#9910](https://github.com/windmill-labs/windmill/issues/9910)) ([af36498](https://github.com/windmill-labs/windmill/commit/af36498432e643108308e1c03b5d986d0f0f8888))
+* **pipelines:** schema contracts — save-time consumer checks vs captured schemas ([#9917](https://github.com/windmill-labs/windmill/issues/9917)) ([42e11c6](https://github.com/windmill-labs/windmill/commit/42e11c6570b62ffaa86598438fa8ddf462c4035f))
+* **pipeline:** write-audit-publish for materialization data tests ([#9911](https://github.com/windmill-labs/windmill/issues/9911)) ([dce247c](https://github.com/windmill-labs/windmill/commit/dce247c6d2678a2c95bd728027e17ae3965638e2))
+* **sdk:** enforce s3:// URIs for string S3 params + ingestion (EL) docs ([#9912](https://github.com/windmill-labs/windmill/issues/9912)) ([5ad2de9](https://github.com/windmill-labs/windmill/commit/5ad2de91a26b312bf27124ceca16ef331621bde8))
+
+
+### Bug Fixes
+
+* **cli:** pipeline + workspace UX batch (init/bind stub, run errors, macro libs, lock-job report, upgrade errors) ([#9929](https://github.com/windmill-labs/windmill/issues/9929)) ([28a6b08](https://github.com/windmill-labs/windmill/commit/28a6b086c842105298f236baa0a61868f71a5eb1))
+* **cli:** publish all windmill-parser-wasm-* deps so local pipeline graph keeps write edges ([#9926](https://github.com/windmill-labs/windmill/issues/9926)) ([744a759](https://github.com/windmill-labs/windmill/commit/744a7597edaf3ca9a7fd2b21a34fb33457913a64))
+* **pipelines:** activity-axis label clarity + select failed node on cascade failure ([#9931](https://github.com/windmill-labs/windmill/issues/9931)) ([5769b60](https://github.com/windmill-labs/windmill/commit/5769b6036cf14b0cb424c5b3d9d878c600a5652e))
+
 ## [1.747.0](https://github.com/windmill-labs/windmill/compare/v1.746.0...v1.747.0) (2026-07-03)
 
 
diff --git a/backend/.sqlx/query-089d7bc7acdbb97cf477159e111bc7e9ee85289ff5c52af43166928337c257e7.json b/backend/.sqlx/query-089d7bc7acdbb97cf477159e111bc7e9ee85289ff5c52af43166928337c257e7.json
index a779aa0e95..6efb66005d 100644
--- a/backend/.sqlx/query-089d7bc7acdbb97cf477159e111bc7e9ee85289ff5c52af43166928337c257e7.json
+++ b/backend/.sqlx/query-089d7bc7acdbb97cf477159e111bc7e9ee85289ff5c52af43166928337c257e7.json
@@ -35,7 +35,8 @@
                 "ci_test",
                 "github",
                 "azure",
-                "asset"
+                "asset",
+                "freshness"
               ]
             }
           }
diff --git a/backend/.sqlx/query-0e22295e40bfc173d85f0a962d491f3afd87eeea5e4e8d935b1b86eb02f061e7.json b/backend/.sqlx/query-0e22295e40bfc173d85f0a962d491f3afd87eeea5e4e8d935b1b86eb02f061e7.json
new file mode 100644
index 0000000000..906c710fdf
--- /dev/null
+++ b/backend/.sqlx/query-0e22295e40bfc173d85f0a962d491f3afd87eeea5e4e8d935b1b86eb02f061e7.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM pipeline_freshness_state WHERE workspace_id = $1 AND script_path = $2",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "0e22295e40bfc173d85f0a962d491f3afd87eeea5e4e8d935b1b86eb02f061e7"
+}
diff --git a/backend/.sqlx/query-0f141ca6a58901dee1ddcf25694d76a4e5702c0324a27ef3a5740ef5d98d8946.json b/backend/.sqlx/query-0f141ca6a58901dee1ddcf25694d76a4e5702c0324a27ef3a5740ef5d98d8946.json
new file mode 100644
index 0000000000..0dbcf04c6e
--- /dev/null
+++ b/backend/.sqlx/query-0f141ca6a58901dee1ddcf25694d76a4e5702c0324a27ef3a5740ef5d98d8946.json
@@ -0,0 +1,31 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT\n            schedule.path, t.jobs FROM schedule,\n            LATERAL(SELECT ARRAY(\n                SELECT json_build_object('id', id, 'success', status = 'success', 'duration_ms', duration_ms)\n                FROM v2_job_completed c JOIN v2_job j USING (id)\n                WHERE trigger_kind = 'schedule'\n                    AND trigger = schedule.path\n                    AND c.workspace_id = $1\n                    AND j.workspace_id = $1\n                    AND parent_job IS NULL AND runnable_path = schedule.script_path\n                    AND status <> 'skipped'\n                ORDER BY completed_at DESC\n                LIMIT 20\n            ) AS jobs) t\n        WHERE workspace_id = $1 AND NOT starts_with(schedule.path, $4)\n        ORDER BY edited_at DESC\n        LIMIT $2 OFFSET $3",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "path",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 1,
+        "name": "jobs",
+        "type_info": "JsonArray"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Int8",
+        "Int8",
+        "Text"
+      ]
+    },
+    "nullable": [
+      false,
+      null
+    ]
+  },
+  "hash": "0f141ca6a58901dee1ddcf25694d76a4e5702c0324a27ef3a5740ef5d98d8946"
+}
diff --git a/backend/.sqlx/query-142ae6939440654da21ebb06acf838563f28e832e37e5c165329441d8471acdb.json b/backend/.sqlx/query-142ae6939440654da21ebb06acf838563f28e832e37e5c165329441d8471acdb.json
new file mode 100644
index 0000000000..c19df789d4
--- /dev/null
+++ b/backend/.sqlx/query-142ae6939440654da21ebb06acf838563f28e832e37e5c165329441d8471acdb.json
@@ -0,0 +1,16 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO schedule (\n            workspace_id, path, edited_by, edited_at, schedule, enabled, script_path,\n            args, extra_perms, is_flow, email, error, timezone, on_failure,\n            on_recovery, on_failure_times, on_failure_exact, on_failure_extra_args,\n            on_recovery_times, on_recovery_extra_args, ws_error_handler_muted, retry,\n            summary, no_flow_overlap, tag, paused_until, on_success, on_success_extra_args,\n            cron_version, description, dynamic_skip, permissioned_as, labels\n        )\n        SELECT\n            $1, path, edited_by, edited_at, schedule, FALSE, script_path,\n            args, extra_perms, is_flow, email, error, timezone, on_failure,\n            on_recovery, on_failure_times, on_failure_exact, on_failure_extra_args,\n            on_recovery_times, on_recovery_extra_args, ws_error_handler_muted, retry,\n            summary, no_flow_overlap, tag, paused_until, on_success, on_success_extra_args,\n            cron_version, description, dynamic_skip, permissioned_as, labels\n        FROM schedule WHERE workspace_id = $2 AND path NOT LIKE $3",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "142ae6939440654da21ebb06acf838563f28e832e37e5c165329441d8471acdb"
+}
diff --git a/backend/.sqlx/query-212553c83e4dcdc6d045eb2fe2dadbb2860ce52d37a56b2861de1215260ecff8.json b/backend/.sqlx/query-212553c83e4dcdc6d045eb2fe2dadbb2860ce52d37a56b2861de1215260ecff8.json
index f9bc97d29d..704883d4f1 100644
--- a/backend/.sqlx/query-212553c83e4dcdc6d045eb2fe2dadbb2860ce52d37a56b2861de1215260ecff8.json
+++ b/backend/.sqlx/query-212553c83e4dcdc6d045eb2fe2dadbb2860ce52d37a56b2861de1215260ecff8.json
@@ -39,7 +39,8 @@
                 "ci_test",
                 "github",
                 "azure",
-                "asset"
+                "asset",
+                "freshness"
               ]
             }
           }
@@ -77,7 +78,8 @@
                 "ci_test",
                 "github",
                 "azure",
-                "asset"
+                "asset",
+                "freshness"
               ]
             }
           }
diff --git a/backend/.sqlx/query-256a302afef987857016f2fa636d15474599734bc46ede6930650e2cba5d8a46.json b/backend/.sqlx/query-256a302afef987857016f2fa636d15474599734bc46ede6930650e2cba5d8a46.json
new file mode 100644
index 0000000000..5f74d57491
--- /dev/null
+++ b/backend/.sqlx/query-256a302afef987857016f2fa636d15474599734bc46ede6930650e2cba5d8a46.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO script_trigger (workspace_id, runnable_kind, runnable_path, trigger_kind, trigger_ref, join_all, debounce_s, retry_count, retry_delay_s)\n         SELECT $2, runnable_kind, runnable_path, trigger_kind, trigger_ref, join_all, debounce_s, retry_count, retry_delay_s\n         FROM script_trigger WHERE workspace_id = $1",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Varchar"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "256a302afef987857016f2fa636d15474599734bc46ede6930650e2cba5d8a46"
+}
diff --git a/backend/.sqlx/query-28ec31481bdaae8b0512d21d074da5d913caa8d935b33ad8f21336dedefd1c23.json b/backend/.sqlx/query-28ec31481bdaae8b0512d21d074da5d913caa8d935b33ad8f21336dedefd1c23.json
new file mode 100644
index 0000000000..a1e3edbbe2
--- /dev/null
+++ b/backend/.sqlx/query-28ec31481bdaae8b0512d21d074da5d913caa8d935b33ad8f21336dedefd1c23.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM schedule WHERE workspace_id = $1 AND path = ANY($2)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "TextArray"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "28ec31481bdaae8b0512d21d074da5d913caa8d935b33ad8f21336dedefd1c23"
+}
diff --git a/backend/.sqlx/query-333a703a53cc760842b047ad420efef25885a9bca64bb2ba4bb173bc19dcbdba.json b/backend/.sqlx/query-333a703a53cc760842b047ad420efef25885a9bca64bb2ba4bb173bc19dcbdba.json
new file mode 100644
index 0000000000..dfbc2b75e6
--- /dev/null
+++ b/backend/.sqlx/query-333a703a53cc760842b047ad420efef25885a9bca64bb2ba4bb173bc19dcbdba.json
@@ -0,0 +1,23 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT path FROM schedule WHERE workspace_id = $1 AND path LIKE $2",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "path",
+        "type_info": "Varchar"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": [
+      false
+    ]
+  },
+  "hash": "333a703a53cc760842b047ad420efef25885a9bca64bb2ba4bb173bc19dcbdba"
+}
diff --git a/backend/.sqlx/query-36da136cf9b9554702e3b3ec364368a6862e35350ae43383fb2335e2c82a9419.json b/backend/.sqlx/query-36da136cf9b9554702e3b3ec364368a6862e35350ae43383fb2335e2c82a9419.json
new file mode 100644
index 0000000000..d05abd4f3a
--- /dev/null
+++ b/backend/.sqlx/query-36da136cf9b9554702e3b3ec364368a6862e35350ae43383fb2335e2c82a9419.json
@@ -0,0 +1,29 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT DISTINCT path AS \"asset_path!\", usage_path AS \"producer_path!\"\n             FROM asset\n            WHERE workspace_id = $1 AND kind = 'ducklake' AND path = ANY($2)\n              AND usage_kind = 'script' AND usage_access_type IN ('w', 'rw')",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "asset_path!",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 1,
+        "name": "producer_path!",
+        "type_info": "Varchar"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "TextArray"
+      ]
+    },
+    "nullable": [
+      false,
+      false
+    ]
+  },
+  "hash": "36da136cf9b9554702e3b3ec364368a6862e35350ae43383fb2335e2c82a9419"
+}
diff --git a/backend/.sqlx/query-3c84781704b84b8a927ecce5a3fcb3adcf0175d0a71013f2497397c1c8ccc619.json b/backend/.sqlx/query-3c84781704b84b8a927ecce5a3fcb3adcf0175d0a71013f2497397c1c8ccc619.json
index 3568d1723e..f5ee767768 100644
--- a/backend/.sqlx/query-3c84781704b84b8a927ecce5a3fcb3adcf0175d0a71013f2497397c1c8ccc619.json
+++ b/backend/.sqlx/query-3c84781704b84b8a927ecce5a3fcb3adcf0175d0a71013f2497397c1c8ccc619.json
@@ -128,7 +128,8 @@
                 "ci_test",
                 "github",
                 "azure",
-                "asset"
+                "asset",
+                "freshness"
               ]
             }
           }
diff --git a/backend/.sqlx/query-3ea82f16050318a0b3b87c12beb66b49254036ca93f7a6415ceb4e316ed64eed.json b/backend/.sqlx/query-3ea82f16050318a0b3b87c12beb66b49254036ca93f7a6415ceb4e316ed64eed.json
new file mode 100644
index 0000000000..60dbee76ab
--- /dev/null
+++ b/backend/.sqlx/query-3ea82f16050318a0b3b87c12beb66b49254036ca93f7a6415ceb4e316ed64eed.json
@@ -0,0 +1,29 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "\n        SELECT p.path AS \"path!\",\n               (SELECT c.completed_at\n                  FROM v2_job j\n                  JOIN v2_job_completed c ON c.id = j.id\n                 WHERE j.workspace_id = $1\n                   AND j.runnable_path = p.path\n                   AND j.parent_job IS NULL\n                   -- No 'singlestepflow': flows may share a script's path, and\n                   -- a same-path flow run must not read as the script being\n                   -- fresh (false-fresh). Script retries land as native\n                   -- 'script' jobs; only the rare flow-wrapper fallback is\n                   -- missed, which errs stale. Kept in lockstep with the\n                   -- freshness watchdog's queries (freshness_watchdog_ee).\n                   AND j.kind IN ('script', 'preview')\n                   AND c.status = 'success'\n                 ORDER BY j.created_at DESC\n                 LIMIT 1) AS last_success_at\n          FROM unnest($2::text[]) AS p(path)\n        ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "path!",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 1,
+        "name": "last_success_at",
+        "type_info": "Timestamptz"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "TextArray"
+      ]
+    },
+    "nullable": [
+      null,
+      null
+    ]
+  },
+  "hash": "3ea82f16050318a0b3b87c12beb66b49254036ca93f7a6415ceb4e316ed64eed"
+}
diff --git a/backend/.sqlx/query-3eeecc4bb26163cf6c2c19bc7c2950a1563bd516e730aaa9d0f1501ea8cea7f9.json b/backend/.sqlx/query-3eeecc4bb26163cf6c2c19bc7c2950a1563bd516e730aaa9d0f1501ea8cea7f9.json
new file mode 100644
index 0000000000..4599073796
--- /dev/null
+++ b/backend/.sqlx/query-3eeecc4bb26163cf6c2c19bc7c2950a1563bd516e730aaa9d0f1501ea8cea7f9.json
@@ -0,0 +1,58 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT ducklake_name AS \"ducklake_name!\", metadata_schema AS \"metadata_schema!\",\n                  catalog AS \"catalog!\", storage AS \"storage!\",\n                  storage_ref AS \"storage_ref!\", data_path AS \"data_path!\",\n                  schema_dropped AS \"schema_dropped!\"\n             FROM fork_ducklake_namespace WHERE workspace_id = $1",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "ducklake_name!",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 1,
+        "name": "metadata_schema!",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 2,
+        "name": "catalog!",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 3,
+        "name": "storage!",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 4,
+        "name": "storage_ref!",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 5,
+        "name": "data_path!",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 6,
+        "name": "schema_dropped!",
+        "type_info": "Bool"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text"
+      ]
+    },
+    "nullable": [
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false
+    ]
+  },
+  "hash": "3eeecc4bb26163cf6c2c19bc7c2950a1563bd516e730aaa9d0f1501ea8cea7f9"
+}
diff --git a/backend/.sqlx/query-431a5eb2eb5a0b57e096cc78f68eb5a0665c90c4926f1afb689d6cd16bd5b722.json b/backend/.sqlx/query-431a5eb2eb5a0b57e096cc78f68eb5a0665c90c4926f1afb689d6cd16bd5b722.json
new file mode 100644
index 0000000000..b554ef8b55
--- /dev/null
+++ b/backend/.sqlx/query-431a5eb2eb5a0b57e096cc78f68eb5a0665c90c4926f1afb689d6cd16bd5b722.json
@@ -0,0 +1,29 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT DISTINCT ON (path) path, content\n                 FROM script\n                WHERE workspace_id = $1 AND path = ANY($2)\n                  AND archived = false AND deleted = false\n                ORDER BY path, created_at DESC",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "path",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 1,
+        "name": "content",
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "TextArray"
+      ]
+    },
+    "nullable": [
+      false,
+      false
+    ]
+  },
+  "hash": "431a5eb2eb5a0b57e096cc78f68eb5a0665c90c4926f1afb689d6cd16bd5b722"
+}
diff --git a/backend/.sqlx/query-45a539e61a3c35098fb6d59c3d5de8b6fcebe83002c74647666e3a6f5b8490dd.json b/backend/.sqlx/query-45a539e61a3c35098fb6d59c3d5de8b6fcebe83002c74647666e3a6f5b8490dd.json
new file mode 100644
index 0000000000..5b3e70acbf
--- /dev/null
+++ b/backend/.sqlx/query-45a539e61a3c35098fb6d59c3d5de8b6fcebe83002c74647666e3a6f5b8490dd.json
@@ -0,0 +1,23 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "\n        SELECT EXISTS(\n            SELECT 1 FROM v2_job_queue q\n            JOIN v2_job j ON j.id = q.id\n            WHERE q.workspace_id = $1\n              AND j.runnable_path = $2\n              AND j.parent_job IS NULL\n              AND j.kind IN ('script', 'preview')\n              AND (q.running = true OR q.scheduled_for <= now())\n        ) AS \"in_flight!\"\n        ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "in_flight!",
+        "type_info": "Bool"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": [
+      null
+    ]
+  },
+  "hash": "45a539e61a3c35098fb6d59c3d5de8b6fcebe83002c74647666e3a6f5b8490dd"
+}
diff --git a/backend/.sqlx/query-45c73bd8742601753ad947c88b65ff3ae182ff7c0631d4fa44b67b11a133498f.json b/backend/.sqlx/query-45c73bd8742601753ad947c88b65ff3ae182ff7c0631d4fa44b67b11a133498f.json
new file mode 100644
index 0000000000..6dc5fdb9a6
--- /dev/null
+++ b/backend/.sqlx/query-45c73bd8742601753ad947c88b65ff3ae182ff7c0631d4fa44b67b11a133498f.json
@@ -0,0 +1,17 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "\n        UPDATE pipeline_freshness_state\n        SET attempts = attempts + 1,\n            last_push_at = now(),\n            next_attempt_at = now()\n                + (LEAST($3::bigint, $4::bigint * (1::bigint << LEAST(attempts + 1, 20)))::text\n                   || ' seconds')::interval\n        WHERE workspace_id = $1 AND script_path = $2 AND next_attempt_at <= now()\n        ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text",
+        "Int8",
+        "Int8"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "45c73bd8742601753ad947c88b65ff3ae182ff7c0631d4fa44b67b11a133498f"
+}
diff --git a/backend/.sqlx/query-4a43d4df6c5b2e8dda4308dcb88c23caf312ec377dd91e5307f00d3fb8ec325d.json b/backend/.sqlx/query-4a43d4df6c5b2e8dda4308dcb88c23caf312ec377dd91e5307f00d3fb8ec325d.json
index 7d950f6d8f..7474818bf3 100644
--- a/backend/.sqlx/query-4a43d4df6c5b2e8dda4308dcb88c23caf312ec377dd91e5307f00d3fb8ec325d.json
+++ b/backend/.sqlx/query-4a43d4df6c5b2e8dda4308dcb88c23caf312ec377dd91e5307f00d3fb8ec325d.json
@@ -80,7 +80,8 @@
                 "ci_test",
                 "github",
                 "azure",
-                "asset"
+                "asset",
+                "freshness"
               ]
             }
           }
diff --git a/backend/.sqlx/query-5323858a017814206179d35fdb708c547742851975163550ec4f3823057e91fe.json b/backend/.sqlx/query-5323858a017814206179d35fdb708c547742851975163550ec4f3823057e91fe.json
new file mode 100644
index 0000000000..a8facb9d1b
--- /dev/null
+++ b/backend/.sqlx/query-5323858a017814206179d35fdb708c547742851975163550ec4f3823057e91fe.json
@@ -0,0 +1,20 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO schedule (\n                workspace_id, path, schedule, timezone, edited_by, script_path,\n                is_flow, enabled, email, permissioned_as, summary, tag, cron_version\n            ) VALUES ($1, $2, $3, 'Etc/UTC', $4, $2, false, true, $5, $6, $7, 'duckdb', 'v2')\n            ON CONFLICT (workspace_id, path) DO UPDATE SET\n                schedule = EXCLUDED.schedule,\n                timezone = EXCLUDED.timezone,\n                edited_by = EXCLUDED.edited_by,\n                edited_at = now(),\n                script_path = EXCLUDED.script_path,\n                is_flow = false,\n                enabled = true,\n                email = EXCLUDED.email,\n                permissioned_as = EXCLUDED.permissioned_as,\n                summary = EXCLUDED.summary,\n                tag = EXCLUDED.tag,\n                cron_version = EXCLUDED.cron_version,\n                error = NULL",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Varchar",
+        "Varchar",
+        "Varchar",
+        "Varchar",
+        "Varchar",
+        "Varchar"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "5323858a017814206179d35fdb708c547742851975163550ec4f3823057e91fe"
+}
diff --git a/backend/.sqlx/query-53a1ec83aedcec2cdf6495637464e6219434de4d2f9ae5e484ed8ce5da426109.json b/backend/.sqlx/query-53a1ec83aedcec2cdf6495637464e6219434de4d2f9ae5e484ed8ce5da426109.json
new file mode 100644
index 0000000000..8bce508e75
--- /dev/null
+++ b/backend/.sqlx/query-53a1ec83aedcec2cdf6495637464e6219434de4d2f9ae5e484ed8ce5da426109.json
@@ -0,0 +1,16 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM schedule WHERE workspace_id = $1 AND path = ANY($2) AND path != ALL($3)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "TextArray",
+        "TextArray"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "53a1ec83aedcec2cdf6495637464e6219434de4d2f9ae5e484ed8ce5da426109"
+}
diff --git a/backend/.sqlx/query-572b80f7b16fd5d1a05f8fe9bbb07667fc1b5e802dc2465ffd13178a042e4f89.json b/backend/.sqlx/query-572b80f7b16fd5d1a05f8fe9bbb07667fc1b5e802dc2465ffd13178a042e4f89.json
new file mode 100644
index 0000000000..580666f07d
--- /dev/null
+++ b/backend/.sqlx/query-572b80f7b16fd5d1a05f8fe9bbb07667fc1b5e802dc2465ffd13178a042e4f89.json
@@ -0,0 +1,24 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "\n        SELECT EXISTS(\n            SELECT 1 FROM v2_job j\n            JOIN v2_job_completed c ON c.id = j.id\n            WHERE j.workspace_id = $1\n              AND j.runnable_path = $2\n              AND j.parent_job IS NULL\n              AND j.kind IN ('script', 'preview')\n              AND c.status = 'success'\n              AND c.completed_at > now() - ($3::bigint::text || ' seconds')::interval\n        ) AS \"fresh!\"\n        ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "fresh!",
+        "type_info": "Bool"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text",
+        "Int8"
+      ]
+    },
+    "nullable": [
+      null
+    ]
+  },
+  "hash": "572b80f7b16fd5d1a05f8fe9bbb07667fc1b5e802dc2465ffd13178a042e4f89"
+}
diff --git a/backend/.sqlx/query-5e0569092c559a1b19f636fae68f6d740a1720f7746c01f9ea693c70271ff55c.json b/backend/.sqlx/query-5e0569092c559a1b19f636fae68f6d740a1720f7746c01f9ea693c70271ff55c.json
new file mode 100644
index 0000000000..18e0936d3a
--- /dev/null
+++ b/backend/.sqlx/query-5e0569092c559a1b19f636fae68f6d740a1720f7746c01f9ea693c70271ff55c.json
@@ -0,0 +1,17 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "\n            INSERT INTO pipeline_freshness_state\n                (workspace_id, script_path, attempts, last_push_at, next_attempt_at)\n            VALUES ($1, $2, 1, now(),\n                    now() + (LEAST($3::bigint, $4::bigint * 2)::text || ' seconds')::interval)\n            ON CONFLICT (workspace_id, script_path) DO NOTHING\n            ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Varchar",
+        "Int8",
+        "Int8"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "5e0569092c559a1b19f636fae68f6d740a1720f7746c01f9ea693c70271ff55c"
+}
diff --git a/backend/.sqlx/query-63b0f39e3ea2b8d01d4c055258b6fc3dc4e9e1f237ba7c86cbdd70140bc55541.json b/backend/.sqlx/query-63b0f39e3ea2b8d01d4c055258b6fc3dc4e9e1f237ba7c86cbdd70140bc55541.json
new file mode 100644
index 0000000000..1bcb7e6e53
--- /dev/null
+++ b/backend/.sqlx/query-63b0f39e3ea2b8d01d4c055258b6fc3dc4e9e1f237ba7c86cbdd70140bc55541.json
@@ -0,0 +1,36 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "\n        WITH ancestor AS (\n            SELECT wid, ord FROM unnest($1::text[]) WITH ORDINALITY AS a(wid, ord)\n        ), anc_mat AS (\n            -- Per table, the nearest ancestor (lowest ord) that materialized it.\n            SELECT DISTINCT ON (mp.asset_path) mp.asset_path, a.wid, a.ord\n            FROM materialized_partition mp\n            JOIN ancestor a ON a.wid = mp.workspace_id\n            WHERE mp.asset_kind = 'ducklake' AND mp.status = 'materialized'\n              AND split_part(mp.asset_path, '/', 1) = $3 AND mp.asset_path LIKE '%/%'\n            ORDER BY mp.asset_path, a.ord\n        ), fork_mat AS (\n            -- Fork-OWNED assets: anything whose physical table exists in the fork\n            -- namespace, not just clean materializations. A committed write whose data\n            -- tests failed afterwards records status='failed' WITH a snapshot — its table\n            -- is real, and a defer view emitted over it would silently yield to it\n            -- (CREATE VIEW IF NOT EXISTS) while claiming the read defers to the parent.\n            SELECT DISTINCT asset_path FROM materialized_partition\n            WHERE workspace_id = $2 AND asset_kind = 'ducklake'\n              AND (status = 'materialized' OR snapshot_id IS NOT NULL)\n        ), latest_schema AS (\n            SELECT DISTINCT ON (workspace_id, asset_path) workspace_id, asset_path, columns\n            FROM materialized_asset_schema\n            WHERE workspace_id = ANY($1) AND asset_kind = 'ducklake'\n            ORDER BY workspace_id, asset_path, version DESC\n        )\n        SELECT am.asset_path AS \"asset_path!\",\n               am.ord AS \"ord!\",\n               COALESCE(EXISTS (\n                   SELECT 1 FROM jsonb_array_elements(ls.columns) e\n                   WHERE e->>'name' = 'is_current'\n               ), false) AS \"has_current!\"\n        FROM anc_mat am\n        LEFT JOIN latest_schema ls\n               ON ls.asset_path = am.asset_path AND ls.workspace_id = am.wid\n        WHERE am.asset_path NOT IN (SELECT asset_path FROM fork_mat)\n        ORDER BY am.asset_path\n        ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "asset_path!",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 1,
+        "name": "ord!",
+        "type_info": "Int8"
+      },
+      {
+        "ordinal": 2,
+        "name": "has_current!",
+        "type_info": "Bool"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "TextArray",
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": [
+      false,
+      null,
+      null
+    ]
+  },
+  "hash": "63b0f39e3ea2b8d01d4c055258b6fc3dc4e9e1f237ba7c86cbdd70140bc55541"
+}
diff --git a/backend/.sqlx/query-67e25a7c19ea0ffaf7ea5303fcd04af5a7eb488c76f783e690af0c2153b1d6a8.json b/backend/.sqlx/query-67e25a7c19ea0ffaf7ea5303fcd04af5a7eb488c76f783e690af0c2153b1d6a8.json
index 08ebe6bba5..fcc16e9a7c 100644
--- a/backend/.sqlx/query-67e25a7c19ea0ffaf7ea5303fcd04af5a7eb488c76f783e690af0c2153b1d6a8.json
+++ b/backend/.sqlx/query-67e25a7c19ea0ffaf7ea5303fcd04af5a7eb488c76f783e690af0c2153b1d6a8.json
@@ -161,7 +161,8 @@
                 "ci_test",
                 "github",
                 "azure",
-                "asset"
+                "asset",
+                "freshness"
               ]
             }
           }
diff --git a/backend/.sqlx/query-6ca5cbe50df89e6eead890758e34a6ae5091c37ec901975c3d564fd817a405b7.json b/backend/.sqlx/query-6ca5cbe50df89e6eead890758e34a6ae5091c37ec901975c3d564fd817a405b7.json
new file mode 100644
index 0000000000..9a0bbf46ef
--- /dev/null
+++ b/backend/.sqlx/query-6ca5cbe50df89e6eead890758e34a6ae5091c37ec901975c3d564fd817a405b7.json
@@ -0,0 +1,23 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "UPDATE workspace_settings\n               SET ducklake = jsonb_set(ducklake, ARRAY['ducklakes', $2, 'fork_behavior'], '\"shared\"')\n               WHERE workspace_id = $1 AND ducklake->'ducklakes' ? $2\n               RETURNING 1 AS \"one!\"",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "one!",
+        "type_info": "Int4"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": [
+      null
+    ]
+  },
+  "hash": "6ca5cbe50df89e6eead890758e34a6ae5091c37ec901975c3d564fd817a405b7"
+}
diff --git a/backend/.sqlx/query-6d81570849980f316b08487a03f6017386cf2767c953e0d152e7983a00218c6f.json b/backend/.sqlx/query-6d81570849980f316b08487a03f6017386cf2767c953e0d152e7983a00218c6f.json
new file mode 100644
index 0000000000..4e8c7acee2
--- /dev/null
+++ b/backend/.sqlx/query-6d81570849980f316b08487a03f6017386cf2767c953e0d152e7983a00218c6f.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "UPDATE pipeline_freshness_state SET next_attempt_at = now() - interval '1 second'\n         WHERE workspace_id = $1 AND script_path = $2",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "6d81570849980f316b08487a03f6017386cf2767c953e0d152e7983a00218c6f"
+}
diff --git a/backend/.sqlx/query-76af9b978fccef61f50a5eab335d4e427342fb78c66980984aefa7b8c7592ecb.json b/backend/.sqlx/query-76af9b978fccef61f50a5eab335d4e427342fb78c66980984aefa7b8c7592ecb.json
new file mode 100644
index 0000000000..b6b0f06be5
--- /dev/null
+++ b/backend/.sqlx/query-76af9b978fccef61f50a5eab335d4e427342fb78c66980984aefa7b8c7592ecb.json
@@ -0,0 +1,22 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT ducklake->'ducklakes' FROM workspace_settings WHERE workspace_id = $1",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "?column?",
+        "type_info": "Jsonb"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text"
+      ]
+    },
+    "nullable": [
+      null
+    ]
+  },
+  "hash": "76af9b978fccef61f50a5eab335d4e427342fb78c66980984aefa7b8c7592ecb"
+}
diff --git a/backend/.sqlx/query-7cd0b27f4b4a20b05ac876861b934128c3a6ade024d6662379857905a7447a2a.json b/backend/.sqlx/query-7cd0b27f4b4a20b05ac876861b934128c3a6ade024d6662379857905a7447a2a.json
new file mode 100644
index 0000000000..5c8ab6fb5b
--- /dev/null
+++ b/backend/.sqlx/query-7cd0b27f4b4a20b05ac876861b934128c3a6ade024d6662379857905a7447a2a.json
@@ -0,0 +1,32 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "\n        SELECT DISTINCT ON (workspace_id, path)\n               workspace_id AS \"workspace_id!\", path AS \"path!\", content AS \"content!\"\n        FROM script\n        WHERE auto_kind = 'pipeline'\n          AND archived = false\n          AND deleted = false\n          AND content ILIKE '%freshness%'\n          -- Workspace archival stops all execution but leaves script rows\n          -- intact for unarchival; without this the watchdog would keep\n          -- resurrecting runs in a workspace the admin shut down.\n          AND EXISTS (SELECT 1 FROM workspace w\n                      WHERE w.id = script.workspace_id AND w.deleted = false)\n        ORDER BY workspace_id, path, created_at DESC\n        ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "workspace_id!",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 1,
+        "name": "path!",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 2,
+        "name": "content!",
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Left": []
+    },
+    "nullable": [
+      false,
+      false,
+      false
+    ]
+  },
+  "hash": "7cd0b27f4b4a20b05ac876861b934128c3a6ade024d6662379857905a7447a2a"
+}
diff --git a/backend/.sqlx/query-81d1c56c369c5328d947f1ad21da995a8a555e4a9c2d1387dd8cee9c81efd40b.json b/backend/.sqlx/query-81d1c56c369c5328d947f1ad21da995a8a555e4a9c2d1387dd8cee9c81efd40b.json
new file mode 100644
index 0000000000..3f6a4a8136
--- /dev/null
+++ b/backend/.sqlx/query-81d1c56c369c5328d947f1ad21da995a8a555e4a9c2d1387dd8cee9c81efd40b.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "\n        DELETE FROM pipeline_freshness_state s\n        WHERE NOT EXISTS (\n            SELECT 1 FROM unnest($1::text[], $2::text[]) AS w(workspace_id, script_path)\n            WHERE w.workspace_id = s.workspace_id AND w.script_path = s.script_path\n        )\n        ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "TextArray",
+        "TextArray"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "81d1c56c369c5328d947f1ad21da995a8a555e4a9c2d1387dd8cee9c81efd40b"
+}
diff --git a/backend/.sqlx/query-5e50ba0ae27b09a3ea1530c223e5039aa631bb5b0993ad09bc9a1381f6715f19.json b/backend/.sqlx/query-853230da671371fd8bbeeb4c87f8c20a9e310092ae787efe4b0657399c799424.json
similarity index 63%
rename from backend/.sqlx/query-5e50ba0ae27b09a3ea1530c223e5039aa631bb5b0993ad09bc9a1381f6715f19.json
rename to backend/.sqlx/query-853230da671371fd8bbeeb4c87f8c20a9e310092ae787efe4b0657399c799424.json
index 17d372249b..5aacf1a295 100644
--- a/backend/.sqlx/query-5e50ba0ae27b09a3ea1530c223e5039aa631bb5b0993ad09bc9a1381f6715f19.json
+++ b/backend/.sqlx/query-853230da671371fd8bbeeb4c87f8c20a9e310092ae787efe4b0657399c799424.json
@@ -1,6 +1,6 @@
 {
   "db_name": "PostgreSQL",
-  "query": "INSERT INTO materialized_partition\n           (workspace_id, asset_kind, asset_path, partition, status,\n            snapshot_id, row_count, job_id, materialized_at, error)\n         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, now(), $9)\n         ON CONFLICT (workspace_id, asset_kind, asset_path, partition)\n         DO UPDATE SET status = EXCLUDED.status,\n                       snapshot_id = EXCLUDED.snapshot_id,\n                       row_count = EXCLUDED.row_count,\n                       job_id = EXCLUDED.job_id,\n                       materialized_at = now(),\n                       error = EXCLUDED.error",
+  "query": "INSERT INTO materialized_partition\n           (workspace_id, asset_kind, asset_path, partition, status,\n            snapshot_id, row_count, job_id, materialized_at, error)\n         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, now(), $9)\n         ON CONFLICT (workspace_id, asset_kind, asset_path, partition)\n         DO UPDATE SET status = EXCLUDED.status,\n                       -- A failed run records no snapshot, but must not erase the last\n                       -- committed one: a physical table from an earlier commit (or from a\n                       -- committed write whose data tests then failed) still exists, and\n                       -- fork defer/graph state keys on that evidence.\n                       snapshot_id = COALESCE(EXCLUDED.snapshot_id, materialized_partition.snapshot_id),\n                       row_count = EXCLUDED.row_count,\n                       job_id = EXCLUDED.job_id,\n                       materialized_at = now(),\n                       error = EXCLUDED.error",
   "describe": {
     "columns": [],
     "parameters": {
@@ -43,5 +43,5 @@
     },
     "nullable": []
   },
-  "hash": "5e50ba0ae27b09a3ea1530c223e5039aa631bb5b0993ad09bc9a1381f6715f19"
+  "hash": "853230da671371fd8bbeeb4c87f8c20a9e310092ae787efe4b0657399c799424"
 }
diff --git a/backend/.sqlx/query-8756a8100d6fd6ecb64ef73d6f2c8453d53c973dce61cc8ace7d278773c7506f.json b/backend/.sqlx/query-8756a8100d6fd6ecb64ef73d6f2c8453d53c973dce61cc8ace7d278773c7506f.json
new file mode 100644
index 0000000000..5741a1aa5b
--- /dev/null
+++ b/backend/.sqlx/query-8756a8100d6fd6ecb64ef73d6f2c8453d53c973dce61cc8ace7d278773c7506f.json
@@ -0,0 +1,31 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT\n            schedule.path, t.jobs FROM schedule,\n            LATERAL(SELECT ARRAY(\n                SELECT json_build_object('id', id, 'success', status = 'success', 'duration_ms', duration_ms)\n                FROM v2_job_completed c JOIN v2_job j USING (id)\n                WHERE trigger_kind = 'schedule'\n                    AND trigger = schedule.path\n                    AND c.workspace_id = $1\n                    AND j.workspace_id = $1\n                    AND parent_job IS NULL AND runnable_path = schedule.script_path\n                    AND status <> 'skipped'\n                ORDER BY completed_at DESC\n                LIMIT 20\n            ) AS jobs) t\n        WHERE workspace_id = $1 AND schedule.path NOT LIKE $4\n        ORDER BY edited_at DESC\n        LIMIT $2 OFFSET $3",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "path",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 1,
+        "name": "jobs",
+        "type_info": "JsonArray"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Int8",
+        "Int8",
+        "Text"
+      ]
+    },
+    "nullable": [
+      false,
+      null
+    ]
+  },
+  "hash": "8756a8100d6fd6ecb64ef73d6f2c8453d53c973dce61cc8ace7d278773c7506f"
+}
diff --git a/backend/.sqlx/query-8837a126698d924eb9014cfee0e6afc85a8350706fe694935b25ef46a847409e.json b/backend/.sqlx/query-8837a126698d924eb9014cfee0e6afc85a8350706fe694935b25ef46a847409e.json
new file mode 100644
index 0000000000..829083e0ec
--- /dev/null
+++ b/backend/.sqlx/query-8837a126698d924eb9014cfee0e6afc85a8350706fe694935b25ef46a847409e.json
@@ -0,0 +1,22 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "\n            SELECT ws.ducklake->'ducklakes' AS ducklake_name\n            FROM workspace_settings ws\n            WHERE ws.workspace_id = $1\n        ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "ducklake_name",
+        "type_info": "Jsonb"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text"
+      ]
+    },
+    "nullable": [
+      null
+    ]
+  },
+  "hash": "8837a126698d924eb9014cfee0e6afc85a8350706fe694935b25ef46a847409e"
+}
diff --git a/backend/.sqlx/query-8a1e2e59c05b0f67e32c517a0c46e1a9307335b0e7a27613cd690e99812a99f3.json b/backend/.sqlx/query-8a1e2e59c05b0f67e32c517a0c46e1a9307335b0e7a27613cd690e99812a99f3.json
new file mode 100644
index 0000000000..9fc8cf1336
--- /dev/null
+++ b/backend/.sqlx/query-8a1e2e59c05b0f67e32c517a0c46e1a9307335b0e7a27613cd690e99812a99f3.json
@@ -0,0 +1,23 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT path FROM schedule WHERE workspace_id = $1 AND starts_with(path, $2)",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "path",
+        "type_info": "Varchar"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": [
+      false
+    ]
+  },
+  "hash": "8a1e2e59c05b0f67e32c517a0c46e1a9307335b0e7a27613cd690e99812a99f3"
+}
diff --git a/backend/.sqlx/query-8dec884a4c3b2d105afe22d1d7a01fcab837629fd3c1a09cf82b21641a890444.json b/backend/.sqlx/query-8dec884a4c3b2d105afe22d1d7a01fcab837629fd3c1a09cf82b21641a890444.json
new file mode 100644
index 0000000000..efd12114f3
--- /dev/null
+++ b/backend/.sqlx/query-8dec884a4c3b2d105afe22d1d7a01fcab837629fd3c1a09cf82b21641a890444.json
@@ -0,0 +1,29 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "\n                    -- Fork rows also count when a snapshot ever committed (a failed run\n                    -- preserves it): the physical table exists, so reads hit the FORK's\n                    -- data — showing 'deferred' would misstate what a query returns.\n                    -- Ancestor rows still require a clean materialization.\n                    SELECT DISTINCT asset_path AS \"asset_path!\", workspace_id AS \"workspace_id!\"\n                    FROM materialized_partition\n                    WHERE (workspace_id = $1 OR workspace_id = ANY($2))\n                      AND asset_kind = 'ducklake'\n                      AND (status = 'materialized'\n                           OR (workspace_id = $1 AND snapshot_id IS NOT NULL))\n                    ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "asset_path!",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 1,
+        "name": "workspace_id!",
+        "type_info": "Varchar"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "TextArray"
+      ]
+    },
+    "nullable": [
+      false,
+      false
+    ]
+  },
+  "hash": "8dec884a4c3b2d105afe22d1d7a01fcab837629fd3c1a09cf82b21641a890444"
+}
diff --git a/backend/.sqlx/query-9ecb404e46a4eac55f977f05a3afbafe5dc3cdecc17a3d5a7476b160c1b6e7e1.json b/backend/.sqlx/query-9ecb404e46a4eac55f977f05a3afbafe5dc3cdecc17a3d5a7476b160c1b6e7e1.json
index ad9e57801e..ab01730c02 100644
--- a/backend/.sqlx/query-9ecb404e46a4eac55f977f05a3afbafe5dc3cdecc17a3d5a7476b160c1b6e7e1.json
+++ b/backend/.sqlx/query-9ecb404e46a4eac55f977f05a3afbafe5dc3cdecc17a3d5a7476b160c1b6e7e1.json
@@ -35,7 +35,8 @@
                 "ci_test",
                 "github",
                 "azure",
-                "asset"
+                "asset",
+                "freshness"
               ]
             }
           }
diff --git a/backend/.sqlx/query-a0faa5b042bac00bcd09b925bcf548e2783c2de7e92ba0ff7e6f4637419fcf7d.json b/backend/.sqlx/query-a0faa5b042bac00bcd09b925bcf548e2783c2de7e92ba0ff7e6f4637419fcf7d.json
new file mode 100644
index 0000000000..e3e8e3f2ad
--- /dev/null
+++ b/backend/.sqlx/query-a0faa5b042bac00bcd09b925bcf548e2783c2de7e92ba0ff7e6f4637419fcf7d.json
@@ -0,0 +1,16 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM schedule WHERE workspace_id = $1 AND path LIKE $2 AND path != ALL($3)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text",
+        "TextArray"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "a0faa5b042bac00bcd09b925bcf548e2783c2de7e92ba0ff7e6f4637419fcf7d"
+}
diff --git a/backend/.sqlx/query-a4b6371d33206010b2f3ffd2b09e33244fe8ab9a803248fc23f334034d24aad4.json b/backend/.sqlx/query-a4b6371d33206010b2f3ffd2b09e33244fe8ab9a803248fc23f334034d24aad4.json
index 9a21f228ea..405904604a 100644
--- a/backend/.sqlx/query-a4b6371d33206010b2f3ffd2b09e33244fe8ab9a803248fc23f334034d24aad4.json
+++ b/backend/.sqlx/query-a4b6371d33206010b2f3ffd2b09e33244fe8ab9a803248fc23f334034d24aad4.json
@@ -191,7 +191,8 @@
                 "ci_test",
                 "github",
                 "azure",
-                "asset"
+                "asset",
+                "freshness"
               ]
             }
           }
diff --git a/backend/.sqlx/query-a7f0ed0081e98a9861ea4b081b8a14576509147e51a86a95a2cc786bee3199d9.json b/backend/.sqlx/query-a7f0ed0081e98a9861ea4b081b8a14576509147e51a86a95a2cc786bee3199d9.json
new file mode 100644
index 0000000000..21e0f4613b
--- /dev/null
+++ b/backend/.sqlx/query-a7f0ed0081e98a9861ea4b081b8a14576509147e51a86a95a2cc786bee3199d9.json
@@ -0,0 +1,16 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM schedule WHERE workspace_id = $1 AND starts_with(path, $2) AND path != ALL($3)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text",
+        "TextArray"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "a7f0ed0081e98a9861ea4b081b8a14576509147e51a86a95a2cc786bee3199d9"
+}
diff --git a/backend/.sqlx/query-b10e21ec9edf2d22ff956fdcd085bd601b7dcabdf70e85543455cb4fc3986d74.json b/backend/.sqlx/query-b10e21ec9edf2d22ff956fdcd085bd601b7dcabdf70e85543455cb4fc3986d74.json
new file mode 100644
index 0000000000..d5b10b13b9
--- /dev/null
+++ b/backend/.sqlx/query-b10e21ec9edf2d22ff956fdcd085bd601b7dcabdf70e85543455cb4fc3986d74.json
@@ -0,0 +1,23 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT attempts FROM pipeline_freshness_state WHERE workspace_id = $1 AND script_path = $2",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "attempts",
+        "type_info": "Int4"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": [
+      false
+    ]
+  },
+  "hash": "b10e21ec9edf2d22ff956fdcd085bd601b7dcabdf70e85543455cb4fc3986d74"
+}
diff --git a/backend/.sqlx/query-b3771b690c5966272b1f42c9965bb6a8f961c119516e4c33dc928cd3b4f4edbc.json b/backend/.sqlx/query-b3771b690c5966272b1f42c9965bb6a8f961c119516e4c33dc928cd3b4f4edbc.json
index 3efa843923..092d15e592 100644
--- a/backend/.sqlx/query-b3771b690c5966272b1f42c9965bb6a8f961c119516e4c33dc928cd3b4f4edbc.json
+++ b/backend/.sqlx/query-b3771b690c5966272b1f42c9965bb6a8f961c119516e4c33dc928cd3b4f4edbc.json
@@ -166,7 +166,8 @@
                 "ci_test",
                 "github",
                 "azure",
-                "asset"
+                "asset",
+                "freshness"
               ]
             }
           }
diff --git a/backend/.sqlx/query-bc6f566bc958923045dc3e1ff1639a26f649c960a4ee8d0a584884a236129d43.json b/backend/.sqlx/query-bc6f566bc958923045dc3e1ff1639a26f649c960a4ee8d0a584884a236129d43.json
new file mode 100644
index 0000000000..ce77275faf
--- /dev/null
+++ b/backend/.sqlx/query-bc6f566bc958923045dc3e1ff1639a26f649c960a4ee8d0a584884a236129d43.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO pipeline_freshness_state (workspace_id, script_path, attempts) VALUES ($1, $2, 3)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Varchar"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "bc6f566bc958923045dc3e1ff1639a26f649c960a4ee8d0a584884a236129d43"
+}
diff --git a/backend/.sqlx/query-bcfa34cf80abea05f0c24883b9e77429c51e6166c414bcc5ce2e97fac25bcd77.json b/backend/.sqlx/query-bcfa34cf80abea05f0c24883b9e77429c51e6166c414bcc5ce2e97fac25bcd77.json
index f6ff25a4bf..419ab26383 100644
--- a/backend/.sqlx/query-bcfa34cf80abea05f0c24883b9e77429c51e6166c414bcc5ce2e97fac25bcd77.json
+++ b/backend/.sqlx/query-bcfa34cf80abea05f0c24883b9e77429c51e6166c414bcc5ce2e97fac25bcd77.json
@@ -80,7 +80,8 @@
                 "ci_test",
                 "github",
                 "azure",
-                "asset"
+                "asset",
+                "freshness"
               ]
             }
           }
diff --git a/backend/.sqlx/query-be6d2c92a62b7b284651c45af809746147aa9b8d0a81642a7b7cb4738a0cad66.json b/backend/.sqlx/query-be6d2c92a62b7b284651c45af809746147aa9b8d0a81642a7b7cb4738a0cad66.json
index 8dc66064dc..b9d33a6b5f 100644
--- a/backend/.sqlx/query-be6d2c92a62b7b284651c45af809746147aa9b8d0a81642a7b7cb4738a0cad66.json
+++ b/backend/.sqlx/query-be6d2c92a62b7b284651c45af809746147aa9b8d0a81642a7b7cb4738a0cad66.json
@@ -111,7 +111,8 @@
                 "ci_test",
                 "github",
                 "azure",
-                "asset"
+                "asset",
+                "freshness"
               ]
             }
           }
diff --git a/backend/.sqlx/query-c6c186eb3a108e1f695bf5730c23ef4ab1ccfdc4ed33904e83e5130ac0bf5896.json b/backend/.sqlx/query-c6c186eb3a108e1f695bf5730c23ef4ab1ccfdc4ed33904e83e5130ac0bf5896.json
new file mode 100644
index 0000000000..7cfc1f109f
--- /dev/null
+++ b/backend/.sqlx/query-c6c186eb3a108e1f695bf5730c23ef4ab1ccfdc4ed33904e83e5130ac0bf5896.json
@@ -0,0 +1,41 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT DISTINCT ON (asset_path)\n                  asset_path, version, columns AS \"columns: Json<Vec<SchemaColumn>>\", captured_at\n             FROM materialized_asset_schema\n            WHERE workspace_id = $1 AND asset_kind = 'ducklake' AND asset_path = ANY($2)\n            ORDER BY asset_path, version DESC",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "asset_path",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 1,
+        "name": "version",
+        "type_info": "Int8"
+      },
+      {
+        "ordinal": 2,
+        "name": "columns: Json<Vec<SchemaColumn>>",
+        "type_info": "Jsonb"
+      },
+      {
+        "ordinal": 3,
+        "name": "captured_at",
+        "type_info": "Timestamptz"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "TextArray"
+      ]
+    },
+    "nullable": [
+      false,
+      false,
+      false,
+      false
+    ]
+  },
+  "hash": "c6c186eb3a108e1f695bf5730c23ef4ab1ccfdc4ed33904e83e5130ac0bf5896"
+}
diff --git a/backend/.sqlx/query-c832ebc7ff0be446bf36628f6e06f59d0fbe8df62e0bd0be636d7cf70dcf95f0.json b/backend/.sqlx/query-c832ebc7ff0be446bf36628f6e06f59d0fbe8df62e0bd0be636d7cf70dcf95f0.json
new file mode 100644
index 0000000000..d316c16fff
--- /dev/null
+++ b/backend/.sqlx/query-c832ebc7ff0be446bf36628f6e06f59d0fbe8df62e0bd0be636d7cf70dcf95f0.json
@@ -0,0 +1,16 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO schedule (\n            workspace_id, path, edited_by, edited_at, schedule, enabled, script_path,\n            args, extra_perms, is_flow, email, error, timezone, on_failure,\n            on_recovery, on_failure_times, on_failure_exact, on_failure_extra_args,\n            on_recovery_times, on_recovery_extra_args, ws_error_handler_muted, retry,\n            summary, no_flow_overlap, tag, paused_until, on_success, on_success_extra_args,\n            cron_version, description, dynamic_skip, permissioned_as, labels\n        )\n        SELECT\n            $1, path, edited_by, edited_at, schedule, FALSE, script_path,\n            args, extra_perms, is_flow, email, error, timezone, on_failure,\n            on_recovery, on_failure_times, on_failure_exact, on_failure_extra_args,\n            on_recovery_times, on_recovery_extra_args, ws_error_handler_muted, retry,\n            summary, no_flow_overlap, tag, paused_until, on_success, on_success_extra_args,\n            cron_version, description, dynamic_skip, permissioned_as, labels\n        FROM schedule WHERE workspace_id = $2 AND NOT starts_with(path, $3)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "c832ebc7ff0be446bf36628f6e06f59d0fbe8df62e0bd0be636d7cf70dcf95f0"
+}
diff --git a/backend/.sqlx/query-cbbc6a894b6421d2cd49e59b7ed650fb861aa19a009d6dfe9937304057f2b91f.json b/backend/.sqlx/query-cbbc6a894b6421d2cd49e59b7ed650fb861aa19a009d6dfe9937304057f2b91f.json
new file mode 100644
index 0000000000..0fac858572
--- /dev/null
+++ b/backend/.sqlx/query-cbbc6a894b6421d2cd49e59b7ed650fb861aa19a009d6dfe9937304057f2b91f.json
@@ -0,0 +1,22 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "\n            WITH RECURSIVE chain AS (\n                SELECT id, parent_workspace_id, 0 AS depth\n                FROM workspace WHERE id = $1\n                UNION ALL\n                SELECT w.id, w.parent_workspace_id, chain.depth + 1\n                FROM workspace w\n                JOIN chain ON w.id = chain.parent_workspace_id\n                WHERE chain.depth < 20\n            )\n            SELECT id AS \"id!\" FROM chain WHERE depth > 0 ORDER BY depth\n        ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "id!",
+        "type_info": "Varchar"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text"
+      ]
+    },
+    "nullable": [
+      null
+    ]
+  },
+  "hash": "cbbc6a894b6421d2cd49e59b7ed650fb861aa19a009d6dfe9937304057f2b91f"
+}
diff --git a/backend/.sqlx/query-cd492743a27a158c9f5ff1fdb50a48ebfed85ad8800e293945eadc874d7e42f3.json b/backend/.sqlx/query-cd492743a27a158c9f5ff1fdb50a48ebfed85ad8800e293945eadc874d7e42f3.json
new file mode 100644
index 0000000000..83f7394250
--- /dev/null
+++ b/backend/.sqlx/query-cd492743a27a158c9f5ff1fdb50a48ebfed85ad8800e293945eadc874d7e42f3.json
@@ -0,0 +1,19 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "UPDATE fork_ducklake_namespace SET schema_dropped = true\n                 WHERE workspace_id = $1 AND ducklake_name = $2 AND catalog = $3\n                   AND storage = $4 AND storage_ref = $5 AND data_path = $6",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text",
+        "Text",
+        "Text",
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "cd492743a27a158c9f5ff1fdb50a48ebfed85ad8800e293945eadc874d7e42f3"
+}
diff --git a/backend/.sqlx/query-d1142126245cdaf5d01dc67ab2488958b335f6a24d1e93641eab6aaac86301f7.json b/backend/.sqlx/query-d1142126245cdaf5d01dc67ab2488958b335f6a24d1e93641eab6aaac86301f7.json
new file mode 100644
index 0000000000..f705dbc337
--- /dev/null
+++ b/backend/.sqlx/query-d1142126245cdaf5d01dc67ab2488958b335f6a24d1e93641eab6aaac86301f7.json
@@ -0,0 +1,14 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "UPDATE workspace_settings\n           SET ducklake = jsonb_set(ducklake, '{ducklakes}', (\n               SELECT COALESCE(jsonb_object_agg(key, value - 'fork_behavior'), '{}'::jsonb)\n               FROM jsonb_each(ducklake->'ducklakes')\n           ))\n           WHERE workspace_id = $1 AND jsonb_typeof(ducklake->'ducklakes') = 'object'",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "d1142126245cdaf5d01dc67ab2488958b335f6a24d1e93641eab6aaac86301f7"
+}
diff --git a/backend/.sqlx/query-d1a1f64cb6b14c561c53c44910cad8bc7a2d226a9f22418782bcc66e46d0f706.json b/backend/.sqlx/query-d1a1f64cb6b14c561c53c44910cad8bc7a2d226a9f22418782bcc66e46d0f706.json
new file mode 100644
index 0000000000..cbf96dad52
--- /dev/null
+++ b/backend/.sqlx/query-d1a1f64cb6b14c561c53c44910cad8bc7a2d226a9f22418782bcc66e46d0f706.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO pipeline_freshness_state (workspace_id, script_path) VALUES ($1, $2)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Varchar"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "d1a1f64cb6b14c561c53c44910cad8bc7a2d226a9f22418782bcc66e46d0f706"
+}
diff --git a/backend/.sqlx/query-d41ea93fd58381b89e151c965eae1ea2fe96a1b94f5a92953fb1c1642d15c016.json b/backend/.sqlx/query-d41ea93fd58381b89e151c965eae1ea2fe96a1b94f5a92953fb1c1642d15c016.json
index d5365ffe94..d97c02d26b 100644
--- a/backend/.sqlx/query-d41ea93fd58381b89e151c965eae1ea2fe96a1b94f5a92953fb1c1642d15c016.json
+++ b/backend/.sqlx/query-d41ea93fd58381b89e151c965eae1ea2fe96a1b94f5a92953fb1c1642d15c016.json
@@ -111,7 +111,8 @@
                 "ci_test",
                 "github",
                 "azure",
-                "asset"
+                "asset",
+                "freshness"
               ]
             }
           }
diff --git a/backend/.sqlx/query-d4211392e174a0e8f89c7fcebdf120e5b0f629f9f04e08a2982df33ff23ac7a9.json b/backend/.sqlx/query-d4211392e174a0e8f89c7fcebdf120e5b0f629f9f04e08a2982df33ff23ac7a9.json
index 33a5534b42..052d83fcd9 100644
--- a/backend/.sqlx/query-d4211392e174a0e8f89c7fcebdf120e5b0f629f9f04e08a2982df33ff23ac7a9.json
+++ b/backend/.sqlx/query-d4211392e174a0e8f89c7fcebdf120e5b0f629f9f04e08a2982df33ff23ac7a9.json
@@ -251,7 +251,8 @@
                 "ci_test",
                 "github",
                 "azure",
-                "asset"
+                "asset",
+                "freshness"
               ]
             }
           }
diff --git a/backend/.sqlx/query-caf4dc1046769f410d1277cdd3747763e0d674e8a1d9f3512629cb5a9e5a3439.json b/backend/.sqlx/query-dc60d43814e2b5220db648677dbb3656e27f1c962c2f0438e0cc06530661fbf8.json
similarity index 53%
rename from backend/.sqlx/query-caf4dc1046769f410d1277cdd3747763e0d674e8a1d9f3512629cb5a9e5a3439.json
rename to backend/.sqlx/query-dc60d43814e2b5220db648677dbb3656e27f1c962c2f0438e0cc06530661fbf8.json
index f2398bf143..0d36677337 100644
--- a/backend/.sqlx/query-caf4dc1046769f410d1277cdd3747763e0d674e8a1d9f3512629cb5a9e5a3439.json
+++ b/backend/.sqlx/query-dc60d43814e2b5220db648677dbb3656e27f1c962c2f0438e0cc06530661fbf8.json
@@ -1,17 +1,16 @@
 {
   "db_name": "PostgreSQL",
-  "query": "\n            SELECT ws.datatable->'datatables'->$2 AS config\n            FROM workspace_settings ws\n            WHERE ws.workspace_id = $1\n        ",
+  "query": "\n            SELECT ws.datatable->'datatables' AS datatables\n            FROM workspace_settings ws\n            WHERE ws.workspace_id = $1\n        ",
   "describe": {
     "columns": [
       {
         "ordinal": 0,
-        "name": "config",
+        "name": "datatables",
         "type_info": "Jsonb"
       }
     ],
     "parameters": {
       "Left": [
-        "Text",
         "Text"
       ]
     },
@@ -19,5 +18,5 @@
       null
     ]
   },
-  "hash": "caf4dc1046769f410d1277cdd3747763e0d674e8a1d9f3512629cb5a9e5a3439"
+  "hash": "dc60d43814e2b5220db648677dbb3656e27f1c962c2f0438e0cc06530661fbf8"
 }
diff --git a/backend/.sqlx/query-e27cc16414c181a055bf0666eb0cb16a356cb6be5c48f95b5ba200e7e6ab0efd.json b/backend/.sqlx/query-e27cc16414c181a055bf0666eb0cb16a356cb6be5c48f95b5ba200e7e6ab0efd.json
new file mode 100644
index 0000000000..37bd25eb98
--- /dev/null
+++ b/backend/.sqlx/query-e27cc16414c181a055bf0666eb0cb16a356cb6be5c48f95b5ba200e7e6ab0efd.json
@@ -0,0 +1,20 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO fork_ducklake_namespace\n           (workspace_id, ducklake_name, metadata_schema, catalog, storage, storage_ref, data_path)\n         VALUES ($1, $2, $3, $4, $5, $6, $7)\n         ON CONFLICT (workspace_id, ducklake_name, catalog, storage, storage_ref, data_path)\n         DO UPDATE SET schema_dropped = false",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Varchar",
+        "Varchar",
+        "Text",
+        "Text",
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "e27cc16414c181a055bf0666eb0cb16a356cb6be5c48f95b5ba200e7e6ab0efd"
+}
diff --git a/backend/.sqlx/query-e4d71278fb80126a7a9da73f1889352d4d1e3cb3a8a08f1c9c03055a1cab1235.json b/backend/.sqlx/query-e4d71278fb80126a7a9da73f1889352d4d1e3cb3a8a08f1c9c03055a1cab1235.json
index 470c651020..a35373a959 100644
--- a/backend/.sqlx/query-e4d71278fb80126a7a9da73f1889352d4d1e3cb3a8a08f1c9c03055a1cab1235.json
+++ b/backend/.sqlx/query-e4d71278fb80126a7a9da73f1889352d4d1e3cb3a8a08f1c9c03055a1cab1235.json
@@ -191,7 +191,8 @@
                 "ci_test",
                 "github",
                 "azure",
-                "asset"
+                "asset",
+                "freshness"
               ]
             }
           }
diff --git a/backend/.sqlx/query-e50bce4bba01c90171973862bcfa088b5c0c1ad601146ff1c57d4a3ddc30556a.json b/backend/.sqlx/query-e50bce4bba01c90171973862bcfa088b5c0c1ad601146ff1c57d4a3ddc30556a.json
new file mode 100644
index 0000000000..8c80c14ea4
--- /dev/null
+++ b/backend/.sqlx/query-e50bce4bba01c90171973862bcfa088b5c0c1ad601146ff1c57d4a3ddc30556a.json
@@ -0,0 +1,34 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT runnable_path AS \"runnable_path!\", created_by AS \"created_by!\",\n                  args AS \"args: sqlx::types::Json<serde_json::Value>\"\n             FROM v2_job\n             WHERE workspace_id = $1 AND trigger_kind = 'freshness'\n             ORDER BY created_at",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "runnable_path!",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 1,
+        "name": "created_by!",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 2,
+        "name": "args: sqlx::types::Json<serde_json::Value>",
+        "type_info": "Jsonb"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text"
+      ]
+    },
+    "nullable": [
+      true,
+      false,
+      true
+    ]
+  },
+  "hash": "e50bce4bba01c90171973862bcfa088b5c0c1ad601146ff1c57d4a3ddc30556a"
+}
diff --git a/backend/.sqlx/query-f26cde14890cc754e04341264c4dba01f2f3a02bb36a8d7c20e1990dc81e0472.json b/backend/.sqlx/query-f26cde14890cc754e04341264c4dba01f2f3a02bb36a8d7c20e1990dc81e0472.json
new file mode 100644
index 0000000000..8257722c5c
--- /dev/null
+++ b/backend/.sqlx/query-f26cde14890cc754e04341264c4dba01f2f3a02bb36a8d7c20e1990dc81e0472.json
@@ -0,0 +1,22 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT COUNT(*) AS \"count!\" FROM pipeline_freshness_state WHERE workspace_id = $1",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "count!",
+        "type_info": "Int8"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text"
+      ]
+    },
+    "nullable": [
+      null
+    ]
+  },
+  "hash": "f26cde14890cc754e04341264c4dba01f2f3a02bb36a8d7c20e1990dc81e0472"
+}
diff --git a/backend/.sqlx/query-f3fef6964a211872b01c984b19192da8ee231c772f88dd9145f01d7cf3b8f8c1.json b/backend/.sqlx/query-f3fef6964a211872b01c984b19192da8ee231c772f88dd9145f01d7cf3b8f8c1.json
new file mode 100644
index 0000000000..7049fafe37
--- /dev/null
+++ b/backend/.sqlx/query-f3fef6964a211872b01c984b19192da8ee231c772f88dd9145f01d7cf3b8f8c1.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO asset (workspace_id, path, kind, usage_access_type, usage_path, usage_kind, columns)\n         SELECT $2, path, kind, usage_access_type, usage_path, usage_kind, columns\n         FROM asset WHERE workspace_id = $1 AND usage_kind IN ('script', 'flow')",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Varchar"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "f3fef6964a211872b01c984b19192da8ee231c772f88dd9145f01d7cf3b8f8c1"
+}
diff --git a/backend/.sqlx/query-fbd1b02b9bbf86e17d6ee0da3e9b134780e55a521a5cee8eb657b67bbd4b2588.json b/backend/.sqlx/query-fbd1b02b9bbf86e17d6ee0da3e9b134780e55a521a5cee8eb657b67bbd4b2588.json
new file mode 100644
index 0000000000..ad17a60330
--- /dev/null
+++ b/backend/.sqlx/query-fbd1b02b9bbf86e17d6ee0da3e9b134780e55a521a5cee8eb657b67bbd4b2588.json
@@ -0,0 +1,19 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM fork_ducklake_namespace\n             WHERE workspace_id = $1 AND ducklake_name = $2 AND catalog = $3\n               AND storage = $4 AND storage_ref = $5 AND data_path = $6",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text",
+        "Text",
+        "Text",
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "fbd1b02b9bbf86e17d6ee0da3e9b134780e55a521a5cee8eb657b67bbd4b2588"
+}
diff --git a/backend/CLAUDE.md b/backend/CLAUDE.md
index ff5d9b2f22..24cf2cb837 100644
--- a/backend/CLAUDE.md
+++ b/backend/CLAUDE.md
@@ -11,6 +11,45 @@
   cd backend/windmill-duckdb-ffi-internal && ./build_dev.sh
   ```
   Re-run after clean builds or when `target/debug/libwindmill_duckdb_ffi_internal.*` is missing.
+  The bundled DuckDB compile (~2min) is cached in a per-user dir shared across
+  worktrees (keyed by the crate's `Cargo.lock`), so a fresh worktree reuses it and
+  the build is near-instant — you don't pay the full compile per worktree. Editing
+  the FFI crate's own source falls back to an isolated per-worktree `./target`.
+- **Running data pipelines (DuckLake) from source**: see the section below — a plain build
+  advertises the `duckdb` tag but cannot execute DuckDB scripts and has no working S3 proxy.
+
+## Running data pipelines (DuckLake) from source
+
+DuckLake pipelines need **both** the right cargo features **and** the prebuilt DuckDB FFI. A
+plain `cargo run` (or `cargo run --features quickjs`) does **not** suffice, and the failure modes
+are silent-ish, so agents lose time. Verify feature names against `backend/Cargo.toml` `[features]`.
+
+**Feature sets** (run from `backend/`):
+
+| Goal | Command |
+|---|---|
+| CE DuckLake (DuckDB scripts + S3 proxy) | `cargo run --features quickjs,duckdb,parquet,private` |
+| + Python scripts | add `,python` |
+| EE features (WAP, partitioning, forks, …) | add `,enterprise,license` |
+
+`enterprise` already pulls in `license`, but list both when you want the license-gated paths.
+`quickjs` is for JS eval, not DuckLake per se — keep it if your baseline build had it.
+
+**Before running any DuckDB script**, build the FFI (see the bullet above):
+`cd backend/windmill-duckdb-ffi-internal && ./build_dev.sh`.
+
+**Two gotchas that a wrong feature set produces:**
+
+1. **`duckdb` tag advertised, feature missing.** The `duckdb` worker tag is in the *unconditional*
+   default tag list (`windmill-common/src/worker.rs`, `DEFAULT_TAGS`), so a worker advertises it even
+   without the `duckdb` feature. Jobs then dispatch but fail at execution with
+   `"Duck DB requires the duckdb feature to be enabled"` (`windmill-worker/src/worker.rs`). Fix:
+   compile with `--features duckdb`.
+2. **DuckLake writes 404 (no S3 proxy).** The workspace S3 proxy (`/w/{ws}/s3_proxy/*`) that
+   DuckLake uses for reads/writes only mounts the real service under
+   `#[cfg(all(feature = "private", feature = "parquet"))]` (`windmill-api/src/s3_proxy_oss.rs`);
+   otherwise it's an empty router and every proxied request 404s. Fix: compile with **both**
+   `private` and `parquet`.
 
 ## Cloud vs self-hosted gating
 
diff --git a/backend/Cargo.lock b/backend/Cargo.lock
index 36858ddfda..88eaca4bbd 100644
--- a/backend/Cargo.lock
+++ b/backend/Cargo.lock
@@ -2057,9 +2057,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.2.65"
+version = "1.2.66"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e228eec9be7c17ccb640b59b36a5cd805ea2a564a4c5e162c2f659fea30d3b96"
+checksum = "f5d6cac793997bd970000024b2934968efe83b382de4fdcf4fcb46b6ee4ad996"
 dependencies = [
  "find-msvc-tools",
  "jobserver",
@@ -5072,9 +5072,11 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099"
 dependencies = [
  "cfg-if",
+ "js-sys",
  "libc",
  "r-efi 6.0.0",
  "rand_core 0.10.1",
+ "wasm-bindgen",
 ]
 
 [[package]]
@@ -7563,9 +7565,9 @@ dependencies = [
 
 [[package]]
 name = "num-bigint"
-version = "0.4.7"
+version = "0.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c863e9ab5e7bf9c99ba75e1050f1e4d624ae87ed3532d6238ffbdc7b585dbbe6"
+checksum = "c89e69e7e0f03bea5ef08013795c25018e101932225a656383bd384495ecc367"
 dependencies = [
  "num-integer",
  "num-traits",
@@ -8361,9 +8363,9 @@ checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 
 [[package]]
 name = "pest"
-version = "2.8.6"
+version = "2.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0848c601009d37dfa3430c4666e147e49cdcf1b92ecd3e63657d8a5f19da662"
+checksum = "47627dd7305c6a2d6c8c6bcd24c5a4c17dbbf425f4f9c5313e724b38fc9782e9"
 dependencies = [
  "memchr",
  "ucd-trie",
@@ -8371,9 +8373,9 @@ dependencies = [
 
 [[package]]
 name = "pest_derive"
-version = "2.8.6"
+version = "2.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11f486f1ea21e6c10ed15d5a7c77165d0ee443402f0780849d1768e7d9d6fe77"
+checksum = "4b4254325ecad416ab689e27ba51da03ba01a9632bc6e108f5fe7c3c4ad29d58"
 dependencies = [
  "pest",
  "pest_generator",
@@ -8381,9 +8383,9 @@ dependencies = [
 
 [[package]]
 name = "pest_generator"
-version = "2.8.6"
+version = "2.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8040c4647b13b210a963c1ed407c1ff4fdfa01c31d6d2a098218702e6664f94f"
+checksum = "6c4c0e91ead7a8f7acecbca6f003fc2e8282b1dbe2dd9c9d2f16aba42995e0a7"
 dependencies = [
  "pest",
  "pest_meta",
@@ -8394,12 +8396,11 @@ dependencies = [
 
 [[package]]
 name = "pest_meta"
-version = "2.8.6"
+version = "2.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89815c69d36021a140146f26659a81d6c2afa33d216d736dd4be5381a7362220"
+checksum = "f9744bc48116fee06334924bb5f2bad41eed5e89bd26e29b0b799f9a3f82c210"
 dependencies = [
  "pest",
- "sha2 0.10.9",
 ]
 
 [[package]]
@@ -8995,15 +8996,16 @@ dependencies = [
 
 [[package]]
 name = "quinn-proto"
-version = "0.11.15"
+version = "0.11.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fcb935c5bec503c2f0e306bdd3e58bb9029dcb14fa8d9ac76e3a5256ac0763e"
+checksum = "2f4bfc015262b9df63c8845072ce59068853ff5872180c2ce2f13038b970e560"
 dependencies = [
  "aws-lc-rs",
  "bytes",
- "getrandom 0.3.4",
+ "getrandom 0.4.3",
  "lru-slab",
- "rand 0.9.0",
+ "rand 0.10.2",
+ "rand_pcg",
  "ring 0.17.14",
  "rustc-hash 2.1.3",
  "rustls 0.23.35",
@@ -9017,16 +9019,16 @@ dependencies = [
 
 [[package]]
 name = "quinn-udp"
-version = "0.5.14"
+version = "0.5.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "addec6a0dcad8a8d96a771f815f0eaf55f9d1805756410b39f5fa81332574cbd"
+checksum = "35a133f956daabe89a61a685c2649f13d82d5aa4bd5d12d1277e1072a21c0694"
 dependencies = [
  "cfg_aliases",
  "libc",
  "once_cell",
  "socket2 0.6.4",
  "tracing",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -9184,6 +9186,15 @@ dependencies = [
  "rand_core 0.5.1",
 ]
 
+[[package]]
+name = "rand_pcg"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "caa0f4137e1c0a72f4c651489402276c8e8e1cf081f3b0ba156d2cbeef09e86a"
+dependencies = [
+ "rand_core 0.10.1",
+]
+
 [[package]]
 name = "raw-cpuid"
 version = "11.6.0"
@@ -13322,9 +13333,9 @@ checksum = "7fcfc827f90e53a02eaef5e535ee14266c1d569214c6aa70133a624d8a3164ba"
 
 [[package]]
 name = "utf8-width"
-version = "0.1.8"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1292c0d970b54115d14f2492fe0170adf21d68a1de108eebc51c1df4f346a091"
+checksum = "159a7cadce548703edd50d24069bc294c5415ecab0a480e0cd1ca06d112dc94a"
 
 [[package]]
 name = "utf8_iter"
@@ -13735,7 +13746,7 @@ dependencies = [
 
 [[package]]
 name = "windmill"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "async-nats",
@@ -13817,7 +13828,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-ai"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "async-stream",
  "async-trait",
@@ -13850,7 +13861,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-alerting"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "axum 0.8.9",
  "chrono",
@@ -13863,7 +13874,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "argon2",
@@ -14001,7 +14012,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-agent-workers"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "axum 0.8.9",
  "chrono",
@@ -14024,7 +14035,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-assets"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "axum 0.8.9",
  "chrono",
@@ -14039,7 +14050,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-auth"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "axum 0.8.9",
@@ -14065,7 +14076,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-client"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "reqwest 0.12.28",
  "serde",
@@ -14075,7 +14086,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-configs"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "axum 0.8.9",
  "chrono",
@@ -14092,7 +14103,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-debug"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "axum 0.8.9",
  "base64 0.22.1",
@@ -14114,7 +14125,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-embeddings"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "axum 0.8.9",
@@ -14137,7 +14148,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-flow-conversations"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "axum 0.8.9",
  "chrono",
@@ -14153,7 +14164,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-flows"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "axum 0.8.9",
  "chrono",
@@ -14174,7 +14185,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-groups"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "axum 0.8.9",
  "chrono",
@@ -14195,7 +14206,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-inputs"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "axum 0.8.9",
  "chrono",
@@ -14209,7 +14220,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-integration-tests"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "async-nats",
@@ -14244,7 +14255,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-jobs"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "axum 0.8.9",
@@ -14269,7 +14280,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-npm-proxy"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "axum 0.8.9",
  "flate2",
@@ -14287,7 +14298,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-openapi"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "axum 0.8.9",
@@ -14309,7 +14320,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-schedule"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "axum 0.8.9",
  "chrono",
@@ -14329,7 +14340,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-scripts"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "axum 0.8.9",
  "chrono",
@@ -14366,7 +14377,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-settings"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "axum 0.8.9",
@@ -14394,7 +14405,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-sse"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "lazy_static",
  "serde",
@@ -14406,7 +14417,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-users"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "argon2",
  "axum 0.8.9",
@@ -14431,7 +14442,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-workers"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "axum 0.8.9",
  "chrono",
@@ -14445,10 +14456,11 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-workspaces"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "axum 0.8.9",
  "chrono",
+ "futures",
  "hex",
  "http 1.4.2",
  "hyper 1.10.1",
@@ -14479,7 +14491,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-audit"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "chrono",
  "lazy_static",
@@ -14493,7 +14505,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-autoscaling"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "axum 0.8.9",
@@ -14512,7 +14524,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-common"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "aes-gcm",
  "aho-corasick",
@@ -14614,7 +14626,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-dep-map"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "chrono",
  "itertools 0.14.0",
@@ -14633,7 +14645,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-git-sync"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "regex",
  "serde",
@@ -14648,7 +14660,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-indexer"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "astral-tokio-tar",
@@ -14672,7 +14684,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-jseval"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "futures",
@@ -14689,7 +14701,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-macros"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "itertools 0.14.0",
  "lazy_static",
@@ -14705,7 +14717,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-mcp"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -14726,7 +14738,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-native-triggers"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -14757,7 +14769,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-oauth"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "arc-swap",
@@ -14782,7 +14794,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-object-store"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "async-stream",
@@ -14816,7 +14828,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-operator"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "futures",
@@ -14834,7 +14846,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "convert_case 0.6.0",
  "serde",
@@ -14843,7 +14855,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-bash"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "lazy_static",
@@ -14855,7 +14867,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-csharp"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "serde_json",
@@ -14867,7 +14879,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-go"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "gosyn",
@@ -14879,7 +14891,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-graphql"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "lazy_static",
@@ -14891,7 +14903,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-java"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "serde_json",
@@ -14903,7 +14915,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-nu"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "nu-parser",
@@ -14914,7 +14926,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-php"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "itertools 0.14.0",
@@ -14925,7 +14937,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-py"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "itertools 0.14.0",
@@ -14937,7 +14949,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-py-asset"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "rustpython-ast",
@@ -14948,7 +14960,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-py-imports"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "async-recursion",
@@ -14970,7 +14982,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-r"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "serde_json",
@@ -14982,7 +14994,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-ruby"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "lazy_static",
@@ -14996,7 +15008,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-rust"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "convert_case 0.6.0",
@@ -15013,7 +15025,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-sql"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "lazy_static",
@@ -15026,7 +15038,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-sql-asset"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "serde",
@@ -15038,7 +15050,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-ts"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "lazy_static",
@@ -15056,7 +15068,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-ts-asset"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "serde-wasm-bindgen",
@@ -15072,7 +15084,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-wac"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "rustpython-ast",
@@ -15088,7 +15100,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-yaml"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "serde",
@@ -15099,7 +15111,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-queue"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "async-recursion",
@@ -15138,7 +15150,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-runtime-nativets"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "const_format",
@@ -15177,7 +15189,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-sql-datatype-parser-wasm"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "getrandom 0.3.4",
  "wasm-bindgen",
@@ -15188,7 +15200,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-store"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "async-recursion",
@@ -15222,7 +15234,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-test-utils"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -15246,7 +15258,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-trigger"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -15279,7 +15291,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-trigger-azure"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -15312,7 +15324,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-trigger-email"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -15332,7 +15344,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-trigger-gcp"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -15366,7 +15378,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-trigger-http"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -15402,7 +15414,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-trigger-kafka"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -15425,7 +15437,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-trigger-mqtt"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -15449,7 +15461,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-trigger-nats"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "async-nats",
@@ -15473,7 +15485,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-trigger-postgres"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -15508,7 +15520,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-trigger-sqs"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -15536,7 +15548,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-trigger-websocket"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -15561,7 +15573,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-types"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "bitflags 2.13.0",
@@ -15580,7 +15592,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-worker"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "async-once-cell",
@@ -15690,7 +15702,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-worker-volumes"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "bytes",
  "futures",
diff --git a/backend/Cargo.toml b/backend/Cargo.toml
index a91518dc38..48e48da15d 100644
--- a/backend/Cargo.toml
+++ b/backend/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "windmill"
-version = "1.747.0"
+version = "1.749.0"
 authors.workspace = true
 edition.workspace = true
 
@@ -87,7 +87,7 @@ members = [
 exclude = ["./windmill-duckdb-ffi-internal", "./parsers/windmill-parser-wasm"]
 
 [workspace.package]
-version = "1.747.0"
+version = "1.749.0"
 authors = ["Ruben Fiszel <ruben@windmill.dev>"]
 edition = "2021"
 
diff --git a/backend/ee-repo-ref.txt b/backend/ee-repo-ref.txt
index f0cdaad407..71a3acdda6 100644
--- a/backend/ee-repo-ref.txt
+++ b/backend/ee-repo-ref.txt
@@ -1 +1 @@
-d36555eb8891becdb66f2135684387367450ed1d
\ No newline at end of file
+6c287041cd7edd4a77a4bc07ad0e156cec32cce4
diff --git a/backend/migrations/20260703165613_pipeline_freshness_watchdog.down.sql b/backend/migrations/20260703165613_pipeline_freshness_watchdog.down.sql
new file mode 100644
index 0000000000..aed2f9d32a
--- /dev/null
+++ b/backend/migrations/20260703165613_pipeline_freshness_watchdog.down.sql
@@ -0,0 +1,5 @@
+-- Postgres has no ALTER TYPE ... DROP VALUE for enums. The 'freshness' value
+-- stays even on rollback, consistent with prior job_trigger_kind additions
+-- (see 20260510174213_asset_trigger_dispatch).
+DROP INDEX IF EXISTS idx_script_pipeline_freshness_scan;
+DROP TABLE IF EXISTS pipeline_freshness_state;
diff --git a/backend/migrations/20260703165613_pipeline_freshness_watchdog.up.sql b/backend/migrations/20260703165613_pipeline_freshness_watchdog.up.sql
new file mode 100644
index 0000000000..acf9545c96
--- /dev/null
+++ b/backend/migrations/20260703165613_pipeline_freshness_watchdog.up.sql
@@ -0,0 +1,35 @@
+-- Attribution for runs pushed by the pipeline freshness watchdog (the EE
+-- background loop that re-runs a `// freshness`-annotated producer whose
+-- output aged past its window).
+ALTER TYPE job_trigger_kind ADD VALUE IF NOT EXISTS 'freshness';
+
+-- Per-(workspace, script) watchdog state: exponential-backoff bookkeeping so
+-- a persistently failing producer isn't re-pushed on every scan tick, and an
+-- atomic claim so concurrent servers can't double-push in the same tick
+-- (claim = the UPDATE/INSERT that advances next_attempt_at; only the winner
+-- pushes). Rows exist only while a script is stale — observing it fresh (or
+-- its annotation gone) deletes the row, resetting the backoff.
+CREATE TABLE pipeline_freshness_state (
+    workspace_id VARCHAR(50) NOT NULL REFERENCES workspace (id) ON DELETE CASCADE,
+    script_path VARCHAR(510) NOT NULL,
+    attempts INTEGER NOT NULL DEFAULT 1,
+    last_push_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    next_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (workspace_id, script_path)
+);
+
+-- Written only by the server monitor loop on the raw (non-RLS) pool, but
+-- granted like every other app table so a future user-transaction reader
+-- doesn't hit the recurring missing-GRANT class of bug.
+GRANT ALL ON pipeline_freshness_state TO windmill_user;
+GRANT ALL ON pipeline_freshness_state TO windmill_admin;
+
+-- The watchdog's ~60s candidate scan (latest deployed pipeline members)
+-- filters on this exact predicate and orders by (workspace_id, path,
+-- created_at DESC); without a matching partial index it seq-scans the whole
+-- script-version heap on every tick, on instances that mostly have zero
+-- pipeline scripts. (idx_script_pipeline_path is text_pattern_ops for
+-- prefix LIKE — it can't serve this ordering.)
+CREATE INDEX idx_script_pipeline_freshness_scan
+    ON script (workspace_id, path, created_at DESC)
+    WHERE auto_kind = 'pipeline' AND archived = false AND deleted = false;
diff --git a/backend/migrations/20260703170745_fork_ducklake_namespace.down.sql b/backend/migrations/20260703170745_fork_ducklake_namespace.down.sql
new file mode 100644
index 0000000000..fd722bf414
--- /dev/null
+++ b/backend/migrations/20260703170745_fork_ducklake_namespace.down.sql
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS fork_ducklake_namespace;
diff --git a/backend/migrations/20260703170745_fork_ducklake_namespace.up.sql b/backend/migrations/20260703170745_fork_ducklake_namespace.up.sql
new file mode 100644
index 0000000000..7762304199
--- /dev/null
+++ b/backend/migrations/20260703170745_fork_ducklake_namespace.up.sql
@@ -0,0 +1,51 @@
+-- Registry of ducklake namespaces provisioned for fork/dev workspaces. One row per
+-- (fork workspace, lake name): records the exact catalog metadata schema and data
+-- sub-path the fork's jobs attach to, so fork deletion can drop the pg schema and
+-- delete the S3 prefix deterministically (the row is written on first resolution,
+-- before any physical state exists).
+--
+-- Deliberately NO foreign key to workspace(id): rows are the durable cleanup ledger and
+-- must OUTLIVE the workspace row when physical cleanup fails after the delete commits
+-- (unreachable catalog, storage outage) — a CASCADE would erase the only record of the
+-- orphaned namespace, letting a recreated same-id fork silently reattach stale tables.
+-- Rows are deleted explicitly after each successful cleanup; leftover rows for a reused
+-- id are retried at fork creation, which refuses to proceed while they cannot be cleaned.
+CREATE TABLE fork_ducklake_namespace (
+    workspace_id VARCHAR(50) NOT NULL,
+    ducklake_name VARCHAR(255) NOT NULL,
+    metadata_schema VARCHAR(63) NOT NULL,
+    -- Canonical identity of the catalog database the metadata schema lives in
+    -- (`<resource_type>:<resource_path>`, e.g. `instance:wm_ducklake` or
+    -- `postgres:u/admin/pg`). Cleanup connects to THIS catalog, not whatever the fork's
+    -- settings point at by then — a drifted catalog resource must not make cleanup drop a
+    -- schema in the wrong database and orphan the real one.
+    catalog TEXT NOT NULL,
+    -- Named workspace storage holding the fork's data files; '' = the default storage
+    -- (part of the PK, which cannot hold NULL).
+    storage TEXT NOT NULL DEFAULT '',
+    -- The storage's RESOLVED identity at registration time (`<lfs type>:<resource path or
+    -- root path>`, e.g. `s3:u/admin/minio` or `filesystem:/data/lfs`; '' = unknown). Cleanup
+    -- deletes the fork prefix from THIS storage, not whatever the logical name points at by
+    -- then — repointing a storage after attach must not orphan the original fork data (or
+    -- delete a colliding prefix from the new one).
+    storage_ref TEXT NOT NULL DEFAULT '',
+    -- The fork namespace's data path within that storage (a bucket-root
+    -- `__wm_forks/<fork wid>/…` prefix).
+    data_path TEXT NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    -- Cleanup phase state: true once the metadata schema has been dropped but data files (or
+    -- the row delete) still failed. Later retries then skip the schema phase entirely — they
+    -- need NO catalog credentials, which may be gone for good with the deleted fork's
+    -- resources. Reset to false whenever a live fork re-registers the row (re-attaching
+    -- recreates the schema).
+    schema_dropped BOOLEAN NOT NULL DEFAULT false,
+    -- One row per physical location EVER attached: if the fork's lake settings drift
+    -- (catalog/storage/path change), later attaches add rows rather than replace them, so
+    -- cleanup covers every location the fork wrote, not just the first.
+    PRIMARY KEY (workspace_id, ducklake_name, catalog, storage, storage_ref, data_path)
+);
+
+-- Resolution runs under user_db transactions (SET LOCAL ROLE) in API contexts, so the
+-- windmill roles need explicit grants (default privileges don't apply to app-created tables).
+GRANT ALL ON fork_ducklake_namespace TO windmill_user;
+GRANT ALL ON fork_ducklake_namespace TO windmill_admin;
diff --git a/backend/parsers/windmill-parser-py-asset/src/lib.rs b/backend/parsers/windmill-parser-py-asset/src/lib.rs
index 2282025092..8d2e87a53e 100644
--- a/backend/parsers/windmill-parser-py-asset/src/lib.rs
+++ b/backend/parsers/windmill-parser-py-asset/src/lib.rs
@@ -319,12 +319,24 @@ fn dict_str_value(dict: &rustpython_ast::ExprDict, name: &str) -> Option<String>
 /// `write_s3_file` to a canonical asset path, mirroring `windmill-parser-ts-asset`:
 /// `S3Object(s3="<key>", storage="<bucket>"?)` — or the equivalent dict literal —
 /// maps to the URI `s3://<bucket>/<key>` (empty bucket for default storage, i.e.
-/// `s3:///<key>`), and a bare `"s3://bucket/key"` string is passed through.
+/// `s3:///<key>`), and a `"s3://bucket/key"` URI string is passed through.
+/// String args mirror the runtime `parse_s3_object` contract exactly: only a
+/// `s3://<storage>/<key>` URI with a non-empty key is valid — any other
+/// string (bare key, `s3://x`, empty key) raises at run time, so recording an
+/// edge for it would be a phantom node for a call that can only error.
 /// The resulting URI is fed through `parse_asset_syntax` so the stored path
 /// matches the TS object form and the `# on s3:///…` trigger form exactly.
 fn s3_object_arg_path(expr: &Expr) -> Option<String> {
     let uri = match expr {
-        Expr::Constant(ExprConstant { value: Constant::Str(s), .. }) => s.clone(),
+        Expr::Constant(ExprConstant { value: Constant::Str(s), .. }) => {
+            match s
+                .strip_prefix("s3://")
+                .and_then(|rest| rest.split_once('/'))
+            {
+                Some((_, key)) if !key.is_empty() => s.clone(),
+                _ => return None,
+            }
+        }
         Expr::Call(call) => {
             // `S3Object(...)` imported directly or as `wmill.S3Object(...)`
             let func_name = call
@@ -371,13 +383,47 @@ def main():
             s.map_err(|e| e.to_string()),
             Ok(vec![ParseAssetsResult {
                 kind: AssetKind::S3Object,
-                path: "/test.csv".to_string(),
+                path: "test.csv".to_string(),
                 access_type: Some(R),
                 columns: None,
             },])
         );
     }
 
+    #[test]
+    fn test_py_asset_parser_bare_string_no_asset() {
+        // A plain (non-`s3://`) string is rejected by the runtime
+        // `parse_s3_object`, so the parser must not record a phantom asset
+        // for a call that can only error.
+        let input = r#"
+import wmill
+def main():
+    wmill.write_s3_file("pipelines/etl/out.jsonl", b"")
+"#;
+        let s = parse_assets(input).map(|o| o.assets);
+        assert_eq!(s.map_err(|e| e.to_string()), Ok(vec![]));
+    }
+
+    #[test]
+    fn test_py_asset_parser_invalid_uri_no_write_edge() {
+        // `s3://x` (no key part) and `s3://bucket/` (empty key) are rejected
+        // by the runtime `parse_s3_object` — same rule for the SDK-arg path:
+        // no R/W edge. The generic URI-literal scan may still record them as
+        // ambiguous (`access_type: None`) assets, like any `s3://…` string
+        // constant anywhere in a script.
+        let input = r#"
+import wmill
+def main():
+    wmill.write_s3_file("s3://broken", b"")
+    wmill.write_s3_file("s3://bucket/", b"")
+"#;
+        let assets = parse_assets(input).expect("parse").assets;
+        assert!(
+            assets.iter().all(|a| a.access_type.is_none()),
+            "invalid URIs must not produce R/W edges: {assets:?}"
+        );
+    }
+
     #[test]
     fn test_py_asset_parser_write_s3_object_constructor() {
         // The SDK signature is `write_s3_file(s3object: S3Object | str, ...)` and
@@ -395,7 +441,31 @@ def main():
             s.map_err(|e| e.to_string()),
             Ok(vec![ParseAssetsResult {
                 kind: AssetKind::S3Object,
-                path: "/analytics/x.csv".to_string(),
+                path: "analytics/x.csv".to_string(),
+                access_type: Some(W),
+                columns: None,
+            },])
+        );
+    }
+
+    #[test]
+    fn test_py_write_key_matches_duckdb_read_key() {
+        // Cross-language lineage: this write records `exports/x`, the same path a
+        // DuckDB `read_csv('s3://exports/x')` resolves to (see
+        // windmill-parser-sql-asset `test_duckdb_read_key_matches_sdk_write_key`),
+        // so the producer and consumer connect in the pipeline graph.
+        let input = r#"
+import wmill
+from wmill import S3Object
+def main():
+    wmill.write_s3_file(S3Object(s3="exports/x"), b"content")
+"#;
+        let s = parse_assets(input).map(|o| o.assets);
+        assert_eq!(
+            s.map_err(|e| e.to_string()),
+            Ok(vec![ParseAssetsResult {
+                kind: AssetKind::S3Object,
+                path: "exports/x".to_string(),
                 access_type: Some(W),
                 columns: None,
             },])
@@ -438,7 +508,7 @@ def main():
             s.map_err(|e| e.to_string()),
             Ok(vec![ParseAssetsResult {
                 kind: AssetKind::S3Object,
-                path: "/dir/in.csv".to_string(),
+                path: "dir/in.csv".to_string(),
                 access_type: Some(R),
                 columns: None,
             },])
@@ -461,14 +531,14 @@ def main():
             Ok(vec![
                 ParseAssetsResult {
                     kind: AssetKind::S3Object,
-                    path: "/out.json".to_string(),
-                    access_type: Some(W),
+                    path: "mybucket/dir/in.csv".to_string(),
+                    access_type: Some(R),
                     columns: None,
                 },
                 ParseAssetsResult {
                     kind: AssetKind::S3Object,
-                    path: "mybucket/dir/in.csv".to_string(),
-                    access_type: Some(R),
+                    path: "out.json".to_string(),
+                    access_type: Some(W),
                     columns: None,
                 },
             ])
@@ -494,25 +564,25 @@ def main():
             Ok(vec![
                 ParseAssetsResult {
                     kind: AssetKind::S3Object,
-                    path: "/pipelines/km_real/enriched.json".to_string(),
+                    path: "pipelines/km_real/enriched.json".to_string(),
                     access_type: Some(W),
                     columns: None,
                 },
                 ParseAssetsResult {
                     kind: AssetKind::S3Object,
-                    path: "/pipelines/km_real/raw_events.json".to_string(),
+                    path: "pipelines/km_real/raw_events.json".to_string(),
                     access_type: Some(W),
                     columns: None,
                 },
                 ParseAssetsResult {
                     kind: AssetKind::S3Object,
-                    path: "/pipelines/km_real/report.json".to_string(),
+                    path: "pipelines/km_real/report.json".to_string(),
                     access_type: Some(W),
                     columns: None,
                 },
                 ParseAssetsResult {
                     kind: AssetKind::S3Object,
-                    path: "/pipelines/km_real/summary.json".to_string(),
+                    path: "pipelines/km_real/summary.json".to_string(),
                     access_type: Some(W),
                     columns: None,
                 },
diff --git a/backend/parsers/windmill-parser-sql-asset/src/asset_parser.rs b/backend/parsers/windmill-parser-sql-asset/src/asset_parser.rs
index c4f93efdb7..d2ab5b51a7 100644
--- a/backend/parsers/windmill-parser-sql-asset/src/asset_parser.rs
+++ b/backend/parsers/windmill-parser-sql-asset/src/asset_parser.rs
@@ -1145,13 +1145,13 @@ mod tests {
             Ok(vec![
                 ParseAssetsResult {
                     kind: AssetKind::S3Object,
-                    path: "/a.parquet".to_string(),
+                    path: "a.parquet".to_string(),
                     access_type: Some(R),
                     columns: None
                 },
                 ParseAssetsResult {
                     kind: AssetKind::S3Object,
-                    path: "/c.parquet".to_string(),
+                    path: "c.parquet".to_string(),
                     access_type: Some(W),
                     columns: None
                 },
@@ -1165,6 +1165,30 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_duckdb_read_key_matches_sdk_write_key() {
+        // Cross-language lineage: a TS `writeS3File({ s3: "exports/x" })` or
+        // Python `write_s3_file(S3Object(s3="exports/x"))` records the asset path
+        // `exports/x` (default storage). A DuckDB reader of the same object must
+        // resolve to the identical path so the graph connects the producer and
+        // consumer — both the bare `s3://exports/x` and the triple-slash
+        // `s3:///exports/x` default-storage form must yield `exports/x`.
+        for uri in ["s3://exports/x", "s3:///exports/x"] {
+            let input = format!("SELECT * FROM read_csv('{uri}');");
+            let assets = parse_assets(&input).expect("parse").assets;
+            assert_eq!(
+                assets,
+                vec![ParseAssetsResult {
+                    kind: AssetKind::S3Object,
+                    path: "exports/x".to_string(),
+                    access_type: Some(R),
+                    columns: None
+                }],
+                "DuckDB read of {uri} must resolve to the SDK write key"
+            );
+        }
+    }
+
     #[test]
     fn test_copy_target_echoed_in_select_stays_write_only() {
         // The trailing summary SELECT merely mentions the COPY target — it
@@ -1178,7 +1202,7 @@ mod tests {
             s.map_err(|e| e.to_string()),
             Ok(vec![ParseAssetsResult {
                 kind: AssetKind::S3Object,
-                path: "/out.csv".to_string(),
+                path: "out.csv".to_string(),
                 access_type: Some(W),
                 columns: None
             }])
@@ -1195,7 +1219,7 @@ mod tests {
             s.map_err(|e| e.to_string()),
             Ok(vec![ParseAssetsResult {
                 kind: AssetKind::S3Object,
-                path: "/referenced.csv".to_string(),
+                path: "referenced.csv".to_string(),
                 access_type: Some(R),
                 columns: None
             }])
@@ -1215,7 +1239,7 @@ mod tests {
             s.map_err(|e| e.to_string()),
             Ok(vec![ParseAssetsResult {
                 kind: AssetKind::S3Object,
-                path: "/data.csv".to_string(),
+                path: "data.csv".to_string(),
                 access_type: Some(RW),
                 columns: None
             }])
@@ -1235,7 +1259,7 @@ mod tests {
             s.map_err(|e| e.to_string()),
             Ok(vec![ParseAssetsResult {
                 kind: AssetKind::S3Object,
-                path: "/data.parquet".to_string(),
+                path: "data.parquet".to_string(),
                 access_type: Some(RW),
                 columns: None
             }])
@@ -1253,13 +1277,13 @@ mod tests {
             Ok(vec![
                 ParseAssetsResult {
                     kind: AssetKind::S3Object,
-                    path: "/a.parquet".to_string(),
+                    path: "a.parquet".to_string(),
                     access_type: Some(R),
                     columns: None
                 },
                 ParseAssetsResult {
                     kind: AssetKind::S3Object,
-                    path: "/b.parquet".to_string(),
+                    path: "b.parquet".to_string(),
                     access_type: Some(R),
                     columns: None
                 }
@@ -1279,7 +1303,7 @@ mod tests {
             s.map_err(|e| e.to_string()),
             Ok(vec![ParseAssetsResult {
                 kind: AssetKind::S3Object,
-                path: "/data.parquet".to_string(),
+                path: "data.parquet".to_string(),
                 access_type: Some(RW),
                 columns: None
             }])
@@ -1961,7 +1985,7 @@ mod tests {
 
         assert_eq!(result.len(), 1);
         assert_eq!(result[0].kind, AssetKind::S3Object);
-        assert_eq!(result[0].path, "/example_file.parquet");
+        assert_eq!(result[0].path, "example_file.parquet");
         assert_eq!(result[0].access_type, Some(R));
 
         let columns = result[0].columns.as_ref().expect("Should have columns");
@@ -1992,7 +2016,7 @@ mod tests {
 
         assert_eq!(result.len(), 1);
         assert_eq!(result[0].kind, AssetKind::S3Object);
-        assert_eq!(result[0].path, "/example_file.parquet");
+        assert_eq!(result[0].path, "example_file.parquet");
         assert!(result[0].columns.is_none());
     }
 
@@ -2005,7 +2029,7 @@ mod tests {
 
         assert_eq!(result.len(), 1);
         assert_eq!(result[0].kind, AssetKind::S3Object);
-        assert_eq!(result[0].path, "/example_file.parquet");
+        assert_eq!(result[0].path, "example_file.parquet");
 
         let columns = result[0].columns.as_ref().expect("Should have columns");
         assert_eq!(columns.get("col1"), Some(&R));
@@ -2024,7 +2048,7 @@ mod tests {
         assert_eq!(result.len(), 2);
 
         assert!(result.iter().any(|a| {
-            a.path == "/file1.parquet"
+            a.path == "file1.parquet"
                 && a.columns.as_ref().map_or(false, |c| c.contains_key("col1"))
         }));
         assert!(result.iter().any(|a| {
@@ -2057,7 +2081,7 @@ mod tests {
 
         assert_eq!(result.len(), 1);
         assert_eq!(result[0].kind, AssetKind::S3Object);
-        assert_eq!(result[0].path, "/test.parquet");
+        assert_eq!(result[0].path, "test.parquet");
         assert_eq!(result[0].access_type, Some(R));
 
         let columns = result[0].columns.as_ref().expect("Should have columns");
diff --git a/backend/parsers/windmill-parser-ts-asset/src/lib.rs b/backend/parsers/windmill-parser-ts-asset/src/lib.rs
index b7fe0fea5c..f273db5cbe 100644
--- a/backend/parsers/windmill-parser-ts-asset/src/lib.rs
+++ b/backend/parsers/windmill-parser-ts-asset/src/lib.rs
@@ -341,12 +341,25 @@ fn object_str_prop(obj: &ObjectLit, name: &str) -> Option<String> {
 /// `writeS3File` to a canonical asset path, mirroring the runtime
 /// `parseS3Object`: an object `{ s3: "<key>", storage?: "<bucket>" }` maps to
 /// the URI `s3://<bucket>/<key>` (empty bucket for default storage, i.e.
-/// `s3:///<key>`), and a bare `"s3://bucket/key"` string is passed through.
+/// `s3:///<key>`), and a `"s3://bucket/key"` URI string is passed through.
+/// String args mirror the runtime `parseS3Object` contract exactly: only a
+/// `s3://<storage>/<key>` URI with a non-empty key is valid — any other
+/// string (bare key, `s3://x`, empty key) throws at run time, so recording an
+/// edge for it would be a phantom node for a call that can only error.
 /// The resulting URI is fed through `parse_asset_syntax` so the stored path
 /// matches the `// on s3:///…` trigger form exactly.
 fn s3_object_arg_path(arg: &Expr) -> Option<String> {
     let uri = match arg {
-        Expr::Lit(Lit::Str(s)) => s.value.to_string(),
+        Expr::Lit(Lit::Str(s)) => {
+            let v = s.value.to_string();
+            match v
+                .strip_prefix("s3://")
+                .and_then(|rest| rest.split_once('/'))
+            {
+                Some((_, key)) if !key.is_empty() => v,
+                _ => return None,
+            }
+        }
         Expr::Object(obj) => {
             let key = object_str_prop(obj, "s3")?;
             let storage = object_str_prop(obj, "storage").unwrap_or_default();
@@ -420,7 +433,7 @@ mod tests {
             s.map(|r| r.assets).map_err(|e| e.to_string()),
             Ok(vec![ParseAssetsResult {
                 kind: AssetKind::S3Object,
-                path: "/test.csv".to_string(),
+                path: "test.csv".to_string(),
                 access_type: Some(R),
                 columns: None,
             },])
@@ -448,7 +461,31 @@ mod tests {
             s.map(|r| r.assets).map_err(|e| e.to_string()),
             Ok(vec![ParseAssetsResult {
                 kind: AssetKind::S3Object,
-                path: "/pipelines/km_real/raw_events.json".to_string(),
+                path: "pipelines/km_real/raw_events.json".to_string(),
+                access_type: Some(W),
+                columns: None,
+            },])
+        );
+    }
+
+    #[test]
+    fn test_ts_write_key_matches_duckdb_read_key() {
+        // Cross-language lineage: this write records `exports/x`, the same path a
+        // DuckDB `read_csv('s3://exports/x')` resolves to (see
+        // windmill-parser-sql-asset `test_duckdb_read_key_matches_sdk_write_key`),
+        // so the producer and consumer connect in the pipeline graph.
+        let input = r#"
+            import * as wmill from "windmill-client"
+            export async function main() {
+                await wmill.writeS3File({ s3: "exports/x" }, "[]")
+            }
+        "#;
+        let s = parse_assets(input);
+        assert_eq!(
+            s.map(|r| r.assets).map_err(|e| e.to_string()),
+            Ok(vec![ParseAssetsResult {
+                kind: AssetKind::S3Object,
+                path: "exports/x".to_string(),
                 access_type: Some(W),
                 columns: None,
             },])
@@ -477,6 +514,42 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_ts_asset_parser_bare_string_no_asset() {
+        // A plain (non-`s3://`) string is rejected by the runtime
+        // `parseS3Object`, so the parser must not record a phantom asset for
+        // a call that can only error.
+        let input = r#"
+            import * as wmill from "windmill-client"
+            export async function main() {
+                await wmill.writeS3File("pipelines/etl/out.jsonl", "[]")
+            }
+        "#;
+        let s = parse_assets(input);
+        assert_eq!(s.map(|r| r.assets).map_err(|e| e.to_string()), Ok(vec![]));
+    }
+
+    #[test]
+    fn test_ts_asset_parser_invalid_uri_no_write_edge() {
+        // `s3://x` (no key part) and `s3://bucket/` (empty key) are rejected
+        // by the runtime `parseS3Object` — same rule for the SDK-arg path:
+        // no R/W edge. The generic URI-literal scan may still record them as
+        // ambiguous (`access_type: None`) assets, like any `s3://…` string
+        // constant anywhere in a script.
+        let input = r#"
+            import * as wmill from "windmill-client"
+            export async function main() {
+                await wmill.writeS3File("s3://broken", "[]")
+                await wmill.writeS3File("s3://bucket/", "[]")
+            }
+        "#;
+        let assets = parse_assets(input).expect("parse").assets;
+        assert!(
+            assets.iter().all(|a| a.access_type.is_none()),
+            "invalid URIs must not produce R/W edges: {assets:?}"
+        );
+    }
+
     #[test]
     fn test_ts_asset_parser_multiple_s3_object_writes() {
         // Mirrors the f/km/r_seed shape: several direct object-form writes in
@@ -497,25 +570,25 @@ mod tests {
             Ok(vec![
                 ParseAssetsResult {
                     kind: AssetKind::S3Object,
-                    path: "/pipelines/km_real/enriched.json".to_string(),
+                    path: "pipelines/km_real/enriched.json".to_string(),
                     access_type: Some(W),
                     columns: None,
                 },
                 ParseAssetsResult {
                     kind: AssetKind::S3Object,
-                    path: "/pipelines/km_real/raw_events.json".to_string(),
+                    path: "pipelines/km_real/raw_events.json".to_string(),
                     access_type: Some(W),
                     columns: None,
                 },
                 ParseAssetsResult {
                     kind: AssetKind::S3Object,
-                    path: "/pipelines/km_real/report.json".to_string(),
+                    path: "pipelines/km_real/report.json".to_string(),
                     access_type: Some(W),
                     columns: None,
                 },
                 ParseAssetsResult {
                     kind: AssetKind::S3Object,
-                    path: "/pipelines/km_real/summary.json".to_string(),
+                    path: "pipelines/km_real/summary.json".to_string(),
                     access_type: Some(W),
                     columns: None,
                 },
@@ -536,7 +609,7 @@ mod tests {
             s.map(|r| r.assets).map_err(|e| e.to_string()),
             Ok(vec![ParseAssetsResult {
                 kind: AssetKind::S3Object,
-                path: "/out.json".to_string(),
+                path: "out.json".to_string(),
                 access_type: Some(W),
                 columns: None,
             },])
diff --git a/backend/parsers/windmill-parser-wasm/Cargo.lock b/backend/parsers/windmill-parser-wasm/Cargo.lock
index 815d62644f..6d36c2f8f2 100644
--- a/backend/parsers/windmill-parser-wasm/Cargo.lock
+++ b/backend/parsers/windmill-parser-wasm/Cargo.lock
@@ -6191,7 +6191,7 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
 name = "windmill-common"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "aho-corasick",
  "anyhow",
@@ -6272,7 +6272,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-macros"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -6284,7 +6284,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "convert_case",
  "serde",
@@ -6293,7 +6293,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-bash"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "lazy_static",
@@ -6305,7 +6305,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-csharp"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "serde_json",
@@ -6317,7 +6317,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-go"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "gosyn",
@@ -6329,7 +6329,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-graphql"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "lazy_static",
@@ -6341,7 +6341,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-java"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "serde_json",
@@ -6353,7 +6353,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-nu"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "nu-parser",
@@ -6364,7 +6364,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-php"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "itertools 0.14.0",
@@ -6375,7 +6375,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-py"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "itertools 0.14.0",
@@ -6387,7 +6387,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-py-asset"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "rustpython-ast",
@@ -6398,7 +6398,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-py-imports"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "async-recursion",
@@ -6420,7 +6420,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-r"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "serde_json",
@@ -6432,7 +6432,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-ruby"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "lazy_static",
@@ -6446,7 +6446,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-rust"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "convert_case",
@@ -6463,7 +6463,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-sql"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "lazy_static",
@@ -6476,7 +6476,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-sql-asset"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "serde",
@@ -6488,7 +6488,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-ts"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "lazy_static",
@@ -6506,7 +6506,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-ts-asset"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "serde-wasm-bindgen",
@@ -6522,7 +6522,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-wac"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "rustpython-ast",
@@ -6538,7 +6538,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-wasm"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "getrandom 0.2.17",
@@ -6570,7 +6570,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-yaml"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "serde",
@@ -6581,7 +6581,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-types"
-version = "1.747.0"
+version = "1.749.0"
 dependencies = [
  "anyhow",
  "bitflags",
diff --git a/backend/parsers/windmill-parser-wasm/Cargo.toml b/backend/parsers/windmill-parser-wasm/Cargo.toml
index 9111ca8ccb..b8b9263a91 100644
--- a/backend/parsers/windmill-parser-wasm/Cargo.toml
+++ b/backend/parsers/windmill-parser-wasm/Cargo.toml
@@ -12,7 +12,7 @@ resolver = "2"
 members = ["."]
 
 [workspace.package]
-version = "1.747.0"
+version = "1.749.0"
 edition = "2021"
 authors = ["Ruben Fiszel <ruben@windmill.dev>"]
 
diff --git a/backend/parsers/windmill-parser/src/asset_parser.rs b/backend/parsers/windmill-parser/src/asset_parser.rs
index c22359f6b0..94b43c1d7f 100644
--- a/backend/parsers/windmill-parser/src/asset_parser.rs
+++ b/backend/parsers/windmill-parser/src/asset_parser.rs
@@ -77,10 +77,12 @@ pub struct ParseAssetsOutput {
     #[serde(skip_serializing_if = "Option::is_none", default)]
     pub partition: Option<PartitionSpec>,
     // `// freshness <duration>` — SLA stating outputs must be at most
-    // `duration` old. Active backstop: when no other trigger has fired the
-    // script within the window, a watchdog re-runs it. Distinct from
-    // schedule (which is producer cadence); freshness is consumer SLA and
-    // applies regardless of which trigger last fired.
+    // `duration` old. Drives passive monitoring in CE (the asset graph
+    // colors the node's badge fresh/stale against its last successful run)
+    // and the enterprise watchdog (windmill-queue `freshness_watchdog`),
+    // which re-runs a stale unpartitioned producer. Distinct from schedule
+    // (which is producer cadence); freshness is consumer SLA and applies
+    // regardless of which trigger last fired.
     #[serde(skip_serializing_if = "Option::is_none", default)]
     pub freshness: Option<FreshnessSpec>,
     // `// trigger all` → AND join barrier; default (`any`) = OR (current
@@ -250,6 +252,8 @@ pub struct RetrySpec {
 // history (`valid_from`/`valid_to`/`is_current`). The leading keyword `scd2` is a
 // recognized alias for `history`. `deletes=close` (scd2 only) also closes a key
 // that disappears from the snapshot; default leaves absent keys current.
+// `on_schema_change=ignore` suppresses downstream schema-contract warnings for
+// the produced asset (save-time metadata only; default `warn`).
 #[derive(Serialize, Debug, PartialEq, Clone)]
 pub struct MaterializeSpec {
     pub target_kind: AssetKind,
@@ -274,6 +278,117 @@ pub struct MaterializeSpec {
     // `hard_deletes=close`). Default (false) leaves absent keys current.
     #[serde(skip_serializing_if = "std::ops::Not::not", default)]
     pub close_deleted: bool,
+    // `on_schema_change=warn|ignore|fail|sync` governs two orthogonal things:
+    //   • Save-time contract warnings (gap #2b): consumers referencing columns
+    //     the captured schema no longer has warn by default; only `ignore`
+    //     suppresses those warnings (`warn`/`fail`/`sync` all keep them).
+    //   • Run-time write guardrails for the persist-and-mutate strategies
+    //     (partitioned replace, merge, append), where the table schema is fixed
+    //     at first CREATE and the write is positional — a renamed/added/removed
+    //     SELECT column silently lands in the wrong column. `warn` logs the
+    //     drift and proceeds positionally; `fail` aborts before mutating; `sync`
+    //     ALTERs the table to match and writes by name. Whole-table replace and
+    //     scd2 are unaffected. See `sql_materialize.rs`.
+    #[serde(skip_serializing_if = "OnSchemaChange::is_warn", default)]
+    pub on_schema_change: OnSchemaChange,
+}
+
+impl MaterializeSpec {
+    /// The `<target>_current` SCD2 companion view this managed materialize also
+    /// produces, or `None` when it isn't a managed scd2 target. Managed scd2
+    /// creates the base table *and* a `<dim>_current` "latest row per key" view
+    /// each run (see `sql_materialize.rs`); `manual` mode owns its own DDL and
+    /// short-circuits before that codegen, so it produces no companion.
+    pub fn scd2_current_target(&self) -> Option<(AssetKind, String)> {
+        (self.scd2 && !self.manual)
+            .then(|| (self.target_kind, format!("{}_current", self.target_path)))
+    }
+
+    /// Every asset this managed materialize produces: the base table, plus — for
+    /// managed scd2 — the `<target>_current` companion view. The producer's
+    /// trailing `SELECT` doesn't express these writes (the runtime generates the
+    /// DDL), so this is the single source of truth every graph surface (deploy
+    /// asset rows, the CLI `--local` graph, and the frontend live graph) uses to
+    /// link reads of the base *and* the `_current` view back to this producer.
+    pub fn write_targets(&self) -> Vec<(AssetKind, String)> {
+        let mut targets = vec![(self.target_kind, self.target_path.clone())];
+        targets.extend(self.scd2_current_target());
+        targets
+    }
+}
+
+// dbt's `on_schema_change`, covering both the save-time contract check and the
+// run-time write guardrail for the positional persist-and-mutate strategies:
+//   • `warn` (default): surface consumer contract warnings; at write time, log
+//     the drift loudly and proceed with the positional write against the fixed
+//     table schema.
+//   • `ignore`: suppress consumer contract warnings; at write time, no guard
+//     (the pre-guardrail behaviour).
+//   • `fail`: keep contract warnings; at write time, abort the run before
+//     mutating when the SELECT's column *set* diverges from the table's.
+//   • `sync`: keep contract warnings; at write time, ALTER the table to match
+//     the SELECT (add/drop columns) and INSERT BY NAME.
+// `warn`/`fail` drift detection is name-set based (added/removed columns), which
+// is what the positional persist-and-mutate INSERT can misalign on. It does NOT
+// flag a pure *reorder* of same-named columns: `SELECT b, a` into a `(a, b)`
+// table has an identical column set, so `fail` does not abort and the positional
+// INSERT swaps the values. Reorder-safety is exactly what `sync` provides
+// (INSERT BY NAME maps by name), so a SELECT whose column order is not pinned to
+// the table's should use `sync`, not `fail`. (An ordered-list comparison would
+// close this, but a false positive there would abort a correctly-aligned write,
+// so the guard stays on the set difference.)
+// `fail`/`sync` only affect partitioned replace, merge and append; whole-table
+// replace already rebuilds each run, and scd2 has no positional write — for an
+// scd2 target `sync` degrades to `warn` (no write-time effect; deploy-time
+// rejection is out of scope here).
+#[derive(Serialize, Debug, PartialEq, Eq, Clone, Copy, Default)]
+#[serde(rename_all = "lowercase")]
+pub enum OnSchemaChange {
+    #[default]
+    Warn,
+    Ignore,
+    Fail,
+    Sync,
+}
+
+impl OnSchemaChange {
+    pub fn is_warn(&self) -> bool {
+        matches!(self, OnSchemaChange::Warn)
+    }
+}
+
+impl MaterializeSpec {
+    /// Deploy-time validation of the option combination against the script's
+    /// partitioning, returning a human-facing error for combinations the
+    /// runtime cannot honor. Called at save (`create_script_internal`) so a
+    /// misconfigured script is rejected up front, and again in the DuckDB
+    /// executor as a safety net for preview/test runs that never deploy. Both
+    /// checks are SCD2-specific and inert for `manual` mode (which owns its DDL
+    /// and ignores the reconciliation strategy). `partitioned` is whether the
+    /// script declares `// partitioned`.
+    pub fn validate(&self, partitioned: bool) -> Result<(), String> {
+        if self.manual || !self.scd2 {
+            return Ok(());
+        }
+        // SCD2 needs a natural key to identify an entity across versions.
+        if self.unique_key.as_deref().map_or(true, str::is_empty) {
+            return Err(
+                "materialize scd2: requires a natural key — add `key=<col>` (e.g. \
+                 `// materialize ducklake://<name>/<table> key=id history`)"
+                    .to_string(),
+            );
+        }
+        // SCD2's diff/close/open shape has no partition-scoped form in v1.
+        if partitioned {
+            return Err(
+                "materialize scd2: `// partitioned` is not supported with scd2 in v1 — remove \
+                 `// partitioned`, or drop `history`/`scd2` to materialize the partition without \
+                 history"
+                    .to_string(),
+            );
+        }
+        Ok(())
+    }
 }
 
 // `// data_test <kind> …` — a data-quality assertion run against the
@@ -522,6 +637,24 @@ pub fn parse_asset_syntax(s: &str, enable_default_syntax: bool) -> Option<(Asset
     for (prefix, kind) in ASSET_KINDS.iter() {
         if s.starts_with(prefix) {
             let path = &s[prefix.len()..];
+            // Canonicalize S3 keys to a single asset identity. The SDK object
+            // form (`{ s3: "key" }` / `S3Object(s3="key")`, default storage)
+            // resolves to `s3:///key`, whose path is `/key`, while DuckDB
+            // `s3://key` and `// on s3://key` yield the bare `key`. Strip every
+            // leading slash so the triple-slash default-storage form and the
+            // `s3://storage/key` form share one path — otherwise a TS/Python
+            // writer and a DuckDB reader of the same object become disconnected
+            // nodes in the pipeline graph. Stripping ALL leading slashes (not
+            // just one) keeps the identity stable through URI reconstruction:
+            // `trigger_spec_to_row` rebuilds `s3://<path>`, so a canonical path
+            // must never itself start with `/` or the rebuilt ref would parse
+            // back to a different key. Only leading slashes are touched, so
+            // Hive-partition keys (`s3://b/y=2024/f.parquet`) are untouched.
+            let path = if matches!(kind, AssetKind::S3Object) {
+                path.trim_start_matches('/')
+            } else {
+                path
+            };
             return Some((*kind, path));
         }
     }
@@ -637,7 +770,7 @@ fn parse_kv_opts(s: &str) -> BTreeMap<String, String> {
 //   - `on <trigger-spec>`        → asset / native trigger edge (including
 //                                  the marker-only `on schedule` form)
 //   - `partitioned <kind> [opts]` → partition declaration
-//   - `freshness <duration>`     → SLA / active backstop
+//   - `freshness <duration>`     → SLA window (badge + EE watchdog)
 //   - `tag <name>`               → worker-tag override (annotation wins
 //                                  over UI-set value at deploy)
 //   - `retry <count> [<delay>]`  → cascade-only retry policy
@@ -839,6 +972,39 @@ pub fn parse_pipeline_annotations(code: &str) -> PipelineAnnotations {
     out
 }
 
+// Count `// data_test <…>` lines in the leading comment header whose right-hand
+// side fails to parse into a check. `parse_pipeline_annotations` drops these
+// fail-safe (a malformed line just yields no check), which is the wrong default
+// for a data-quality assertion: a typo silently disables the test. The deploy
+// path uses this count to warn. Same leading-block boundary as the parser (stop
+// at the first non-comment line) so a body comment can't be miscounted, and the
+// same `parse_data_test_spec` grammar so "malformed" means exactly what the
+// parser rejects — no second grammar to drift.
+pub fn count_malformed_data_tests(code: &str) -> usize {
+    let mut malformed = 0;
+    for raw_line in code.lines() {
+        let line = raw_line.trim_start();
+        if line.is_empty() {
+            continue;
+        }
+        let rest = if let Some(r) = line.strip_prefix("//") {
+            r
+        } else if let Some(r) = line.strip_prefix("--") {
+            r
+        } else if let Some(r) = line.strip_prefix('#') {
+            r
+        } else {
+            break;
+        };
+        if let Some(after_kw) = consume_keyword(rest.trim_start(), "data_test") {
+            if parse_data_test_spec(after_kw.trim()).is_none() {
+                malformed += 1;
+            }
+        }
+    }
+    malformed
+}
+
 // Parse a `// retry <count> [<delay>]` right-hand side. `<count>` is a
 // non-negative decimal; `<delay>` is an optional raw duration string left
 // for `parse_duration_secs` to validate at deploy. A bare zero count (or
@@ -915,6 +1081,15 @@ fn parse_materialize_spec(s: &str) -> Option<MaterializeSpec> {
     // `deletes=close` (scd2 only) opts into hard-delete-close; any other value
     // (or absence) keeps the soft-delete default.
     let close_deleted = opts.get("deletes").map(|v| v == "close").unwrap_or(false);
+    // `on_schema_change=ignore|fail|sync`; any other value (or absence) keeps
+    // the `warn` default, fail-safe like `deletes=` above (a typo must never
+    // silently disable the guardrail).
+    let on_schema_change = match opts.get("on_schema_change").map(String::as_str) {
+        Some("ignore") => OnSchemaChange::Ignore,
+        Some("fail") => OnSchemaChange::Fail,
+        Some("sync") => OnSchemaChange::Sync,
+        _ => OnSchemaChange::Warn,
+    };
     Some(MaterializeSpec {
         target_kind,
         target_path: path.to_string(),
@@ -924,6 +1099,7 @@ fn parse_materialize_spec(s: &str) -> Option<MaterializeSpec> {
         scd2,
         track,
         close_deleted,
+        on_schema_change,
     })
 }
 
@@ -1123,6 +1299,83 @@ fn parse_trigger_spec(s: &str) -> Option<TriggerSpec> {
 mod pipeline_annotation_tests {
     use super::*;
 
+    #[test]
+    fn s3_key_normalization_unifies_uri_forms() {
+        // A TS/Python SDK write of `{ s3: "exports/x" }` (default storage)
+        // resolves to the URI `s3:///exports/x`, while a DuckDB read of
+        // `s3://exports/x` and the `// on s3://exports/x` trigger form yield the
+        // bare `exports/x`. All three must canonicalize to one asset key so
+        // the writer and reader connect in the pipeline graph.
+        let sdk_write = parse_asset_syntax("s3:///exports/x", false);
+        let duckdb_read = parse_asset_syntax("s3://exports/x", false);
+        assert_eq!(sdk_write, Some((AssetKind::S3Object, "exports/x")));
+        assert_eq!(duckdb_read, Some((AssetKind::S3Object, "exports/x")));
+        assert_eq!(sdk_write, duckdb_read);
+
+        // The `// on` trigger annotation goes through the same function.
+        assert_eq!(
+            parse_asset_syntax("s3:///exports/x", true),
+            parse_asset_syntax("s3://exports/x", true)
+        );
+
+        // Explicit-storage form is unaffected (no leading slash to strip).
+        assert_eq!(
+            parse_asset_syntax("s3://mybucket/exports/x", false),
+            Some((AssetKind::S3Object, "mybucket/exports/x"))
+        );
+
+        // Hive-partition keys and nested paths under default storage are
+        // preserved verbatim (only leading slashes are stripped).
+        assert_eq!(
+            parse_asset_syntax("s3:///t/year=2024/month=01/f.parquet", false),
+            Some((AssetKind::S3Object, "t/year=2024/month=01/f.parquet"))
+        );
+
+        // Every leading slash is stripped so a canonical S3 path never starts
+        // with `/`. `S3Object(s3="/x")` resolves to the quad-slash URI
+        // `s3:////x`; the identity must be the bare `x` (not `/x`) so the ref
+        // that `trigger_spec_to_row` rebuilds round-trips back to it.
+        assert_eq!(
+            parse_asset_syntax("s3:////x", false),
+            Some((AssetKind::S3Object, "x"))
+        );
+        assert_eq!(
+            parse_asset_syntax("s3://///deep///", false),
+            Some((AssetKind::S3Object, "deep///"))
+        );
+
+        // Non-S3 kinds keep their leading slash (their paths are workspace-
+        // relative and the slash is significant).
+        assert_eq!(
+            parse_asset_syntax("res://f/foo", false),
+            Some((AssetKind::Resource, "f/foo"))
+        );
+        assert_eq!(
+            parse_asset_syntax("ducklake://analytics/orders", false),
+            Some((AssetKind::Ducklake, "analytics/orders"))
+        );
+    }
+
+    #[test]
+    fn s3_explicit_storage_aliases_default_storage_nested_key() {
+        // Accepted tradeoff of one canonical key: the explicit-storage form
+        // `s3://storage/key` and the default-storage nested-key form
+        // `s3:///storage/key` collapse to the same node `storage/key`, even
+        // though they name different objects. This is a best-effort lineage
+        // graph that does not split the first segment as a storage name; the
+        // collision only happens when a storage config is named to match a
+        // default-storage prefix. Pinned so the aliasing is intentional, not a
+        // latent surprise.
+        assert_eq!(
+            parse_asset_syntax("s3://mybucket/x", false),
+            parse_asset_syntax("s3:///mybucket/x", false)
+        );
+        assert_eq!(
+            parse_asset_syntax("s3://mybucket/x", false),
+            Some((AssetKind::S3Object, "mybucket/x"))
+        );
+    }
+
     #[test]
     fn bare_pipeline_marker() {
         let out = parse_pipeline_annotations("// pipeline\nconsole.log('hi')");
@@ -1606,6 +1859,62 @@ mod pipeline_annotation_tests {
         assert!(!m.close_deleted);
     }
 
+    #[test]
+    fn materialize_scd2_write_targets_include_current_view() {
+        // A managed scd2 materialize produces the base table AND the
+        // `<dim>_current` companion view, so the producer must be recorded as
+        // writing both (reads of the view otherwise resolve to an orphan asset).
+        let out = parse_pipeline_annotations(
+            "// materialize ducklake://main/dim_customers key=id history",
+        );
+        let m = out.materialize.expect("materialize");
+        assert_eq!(
+            m.write_targets(),
+            vec![
+                (AssetKind::Ducklake, "main/dim_customers".to_string()),
+                (
+                    AssetKind::Ducklake,
+                    "main/dim_customers_current".to_string()
+                ),
+            ]
+        );
+        assert_eq!(
+            m.scd2_current_target(),
+            Some((
+                AssetKind::Ducklake,
+                "main/dim_customers_current".to_string()
+            ))
+        );
+    }
+
+    #[test]
+    fn materialize_non_scd2_write_targets_are_base_only() {
+        // A plain merge (no `history`) creates no companion view — only the base.
+        let out = parse_pipeline_annotations("// materialize ducklake://main/dim_customers key=id");
+        let m = out.materialize.expect("materialize");
+        assert_eq!(
+            m.write_targets(),
+            vec![(AssetKind::Ducklake, "main/dim_customers".to_string())]
+        );
+        assert_eq!(m.scd2_current_target(), None);
+    }
+
+    #[test]
+    fn materialize_manual_scd2_has_no_companion_view() {
+        // `manual` mode owns its own DDL and never creates the `_current` view,
+        // so registering it would be a false producer edge.
+        let out = parse_pipeline_annotations(
+            "// materialize manual ducklake://main/dim_customers key=id history",
+        );
+        let m = out.materialize.expect("materialize");
+        assert!(m.manual && m.scd2);
+        assert_eq!(m.scd2_current_target(), None);
+        assert_eq!(
+            m.write_targets(),
+            vec![(AssetKind::Ducklake, "main/dim_customers".to_string())]
+        );
+    }
+
     #[test]
     fn materialize_scd2_deletes_close_opt() {
         let out = parse_pipeline_annotations(
@@ -1621,6 +1930,93 @@ mod pipeline_annotation_tests {
         assert!(!out.materialize.expect("materialize").close_deleted);
     }
 
+    #[test]
+    fn materialize_validate_scd2_requires_key() {
+        // scd2 without `key=` is rejected at deploy (was a run-time error).
+        let m = parse_pipeline_annotations("// materialize ducklake://a/dim history")
+            .materialize
+            .expect("materialize");
+        assert!(m.scd2 && m.unique_key.is_none());
+        let err = m.validate(false).expect_err("scd2 without key must fail");
+        assert!(err.contains("requires a natural key"));
+        // with a key it validates
+        let m = parse_pipeline_annotations("// materialize ducklake://a/dim key=id history")
+            .materialize
+            .expect("materialize");
+        assert!(m.validate(false).is_ok());
+    }
+
+    #[test]
+    fn materialize_validate_scd2_rejects_partitioned() {
+        // scd2 + `// partitioned` has no v1 form — rejected at deploy.
+        let m = parse_pipeline_annotations("// materialize ducklake://a/dim key=id history")
+            .materialize
+            .expect("materialize");
+        let err = m.validate(true).expect_err("scd2 + partitioned must fail");
+        assert!(err.contains("`// partitioned` is not supported with scd2"));
+        // unpartitioned scd2 is fine
+        assert!(m.validate(false).is_ok());
+    }
+
+    #[test]
+    fn materialize_validate_non_scd2_and_manual_are_inert() {
+        // Non-scd2 strategies are unconstrained by these checks, partitioned or not.
+        let m = parse_pipeline_annotations("// materialize ducklake://a/orders key=id")
+            .materialize
+            .expect("materialize");
+        assert!(m.validate(true).is_ok());
+        assert!(m.validate(false).is_ok());
+        // `manual` owns its DDL and ignores the strategy — never rejected here,
+        // even with a partitioned scd2-looking combo.
+        let m = parse_pipeline_annotations("// materialize manual ducklake://a/dim history")
+            .materialize
+            .expect("materialize");
+        assert!(m.manual && m.scd2);
+        assert!(m.validate(true).is_ok());
+    }
+
+    #[test]
+    fn materialize_on_schema_change_opt() {
+        let out = parse_pipeline_annotations(
+            "// materialize ducklake://a/orders on_schema_change=ignore",
+        );
+        let m = out.materialize.expect("materialize");
+        assert_eq!(m.on_schema_change, OnSchemaChange::Ignore);
+        // default is warn
+        let out = parse_pipeline_annotations("// materialize ducklake://a/orders");
+        assert_eq!(
+            out.materialize.expect("materialize").on_schema_change,
+            OnSchemaChange::Warn
+        );
+        // fail + sync parse to their own variants
+        let out =
+            parse_pipeline_annotations("// materialize ducklake://a/orders on_schema_change=fail");
+        assert_eq!(
+            out.materialize.expect("materialize").on_schema_change,
+            OnSchemaChange::Fail
+        );
+        let out =
+            parse_pipeline_annotations("// materialize ducklake://a/orders on_schema_change=sync");
+        assert_eq!(
+            out.materialize.expect("materialize").on_schema_change,
+            OnSchemaChange::Sync
+        );
+        // unknown/junk value keeps the warn default (fail-safe, like `deletes=`)
+        let out =
+            parse_pipeline_annotations("// materialize ducklake://a/orders on_schema_change=bogus");
+        assert_eq!(
+            out.materialize.expect("materialize").on_schema_change,
+            OnSchemaChange::Warn
+        );
+        // composes with other opts
+        let out = parse_pipeline_annotations(
+            "// materialize ducklake://a/dim key=id history on_schema_change=ignore",
+        );
+        let m = out.materialize.expect("materialize");
+        assert!(m.scd2);
+        assert_eq!(m.on_schema_change, OnSchemaChange::Ignore);
+    }
+
     #[test]
     fn materialize_key_without_history_is_plain_merge() {
         let out = parse_pipeline_annotations("// materialize ducklake://a/dim key=id");
@@ -1950,4 +2346,23 @@ mod pipeline_annotation_tests {
         ));
         assert!(out.column_lineage.is_empty());
     }
+
+    #[test]
+    fn count_malformed_data_tests_counts_only_broken_header_lines() {
+        let n = count_malformed_data_tests(concat!(
+            "-- data_test not_null id\n",                 // valid
+            "-- data_test unique id\n",                   // valid
+            "-- data_test accepted_values status paid\n", // malformed: missing `=`
+            "-- data_test relationships cust ducklake\n", // malformed: no `->`
+            "-- data_test\n",                             // malformed: bare keyword
+            "-- data_test f/tests/custom\n",              // valid: custom script path
+            "SELECT 1 -- data_test not_a_test\n",         // body line: not counted
+        ));
+        assert_eq!(n, 3);
+        // A clean header has zero.
+        assert_eq!(
+            count_malformed_data_tests("-- data_test unique id\nSELECT 1"),
+            0
+        );
+    }
 }
diff --git a/backend/parsers/windmill-parser/src/sql_materialize.rs b/backend/parsers/windmill-parser/src/sql_materialize.rs
index e40cd0f057..1b24a5bccd 100644
--- a/backend/parsers/windmill-parser/src/sql_materialize.rs
+++ b/backend/parsers/windmill-parser/src/sql_materialize.rs
@@ -390,9 +390,39 @@ pub struct MaterializeCodegen<'a> {
     /// and the partition column / `SET PARTITIONED BY` are omitted.
     pub partitioned: bool,
     pub strategy: MaterializeStrategy,
+    /// Write-time guardrail for a drifted SELECT vs the fixed table schema.
+    /// Only the persist-and-mutate strategies (partitioned replace, merge,
+    /// append) act on it: `Fail` emits an in-txn guard that raises on drift,
+    /// `Sync` writes BY NAME and expects the executor to inject `ALTER TABLE`
+    /// DDL at the [`SYNC_ALTER_SENTINEL`] slot, `Warn`/`Ignore` write
+    /// positionally (drift surfaced by the summary in `Warn`, silent in
+    /// `Ignore`). See [`MaterializeCodegen::is_persist_and_mutate`].
+    pub on_schema_change: OnSchemaChange,
 }
 
+/// The exact statement the `sync` codegen emits right after `BEGIN
+/// TRANSACTION;` as the injection slot for `ALTER TABLE … ADD/DROP COLUMN`
+/// DDL. The executor computes the drift with a pre-pass probe and replaces this
+/// literal in the assembled query text (with the DDL, or removes it when there
+/// is no drift). Classified `Write` so the EE write-audit-publish reassembly
+/// keeps it inside the transaction with the mutations; a plain no-op SELECT so
+/// that if it is somehow left un-replaced the run still succeeds unchanged.
+pub const SYNC_ALTER_SENTINEL: &str = "SELECT '__wm_sync_alter_sentinel__' AS _wm_sync;";
+
 impl<'a> MaterializeCodegen<'a> {
+    /// Whether this (strategy, partitioned) uses the positional persist-and-
+    /// mutate write whose table schema is fixed at first CREATE — the only case
+    /// the `on_schema_change` write-time guardrail applies to. Whole-table
+    /// replace (`CREATE OR REPLACE`) and scd2 self-heal / are name-mapped, so
+    /// they are excluded.
+    pub fn is_persist_and_mutate(&self) -> bool {
+        match self.strategy {
+            MaterializeStrategy::Scd2 { .. } => false,
+            MaterializeStrategy::Replace => self.partitioned,
+            MaterializeStrategy::Append | MaterializeStrategy::Merge { .. } => true,
+        }
+    }
+
     /// The ordered statements that perform the materialization, to be run after
     /// the setup blocks and inside the caller's execution. The first-run
     /// bootstrap is idempotent (`IF NOT EXISTS`), so this is safe to run every
@@ -440,22 +470,39 @@ impl<'a> MaterializeCodegen<'a> {
                 "CREATE TABLE IF NOT EXISTS {t} AS SELECT * FROM ({sel}) WHERE false;"
             ));
         }
-
         out.push("BEGIN TRANSACTION;".to_string());
+        // Write-time schema guardrail, emitted right after BEGIN so it runs
+        // before any mutation (a failing guard aborts before touching data; the
+        // sync ALTERs run before the INSERT so the sets match). Reached only on
+        // the persist-and-mutate path here (whole-table replace and scd2 return
+        // above), so no extra strategy gate is needed.
+        match self.on_schema_change {
+            OnSchemaChange::Fail => out.push(schema_drift_guard_sql(sel, t, pcol)),
+            OnSchemaChange::Sync => out.push(SYNC_ALTER_SENTINEL.to_string()),
+            OnSchemaChange::Warn | OnSchemaChange::Ignore => {}
+        }
         // The rows to write, with the partition column appended when partitioned.
         let source = if self.partitioned {
             format!("SELECT *, {pval} AS {pcol} FROM ({sel})")
         } else {
             format!("SELECT * FROM ({sel})")
         };
+        // `sync` maps columns by name (positional would cross-wire: an ALTERed
+        // ADD COLUMN appends at the end, so a positional INSERT of the SELECT
+        // would fill it from the wrong source column).
+        let by_name = if self.on_schema_change == OnSchemaChange::Sync {
+            " BY NAME"
+        } else {
+            ""
+        };
         match &self.strategy {
             MaterializeStrategy::Replace => {
                 // Only reached when partitioned (whole-table replace returned above).
                 out.push(format!("DELETE FROM {t} WHERE {pcol} = {pval};"));
-                out.push(format!("INSERT INTO {t} {source};"));
+                out.push(format!("INSERT INTO {t}{by_name} {source};"));
             }
             MaterializeStrategy::Append => {
-                out.push(format!("INSERT INTO {t} {source};"));
+                out.push(format!("INSERT INTO {t}{by_name} {source};"));
             }
             MaterializeStrategy::Merge { unique_key } => {
                 // Upsert within the slice via delete-by-key + insert (dbt's
@@ -467,6 +514,11 @@ impl<'a> MaterializeCodegen<'a> {
                 // same write shape as `replace`, which is reliable. The DELETE is
                 // scoped to the current partition when partitioned so it stays
                 // slice-local (a key present in another partition is untouched).
+                //
+                // Guard first: the DELETE+INSERT does not dedup the source, so
+                // two incoming rows sharing a key would both persist under it.
+                // Raise instead of silently double-writing (see the helper).
+                out.push(duplicate_source_key_guard_sql(sel, unique_key));
                 let scope = if self.partitioned {
                     format!("{pcol} = {pval} AND ")
                 } else {
@@ -475,7 +527,7 @@ impl<'a> MaterializeCodegen<'a> {
                 out.push(format!(
                     "DELETE FROM {t} WHERE {scope}{unique_key} IN (SELECT {unique_key} FROM ({sel}));"
                 ));
-                out.push(format!("INSERT INTO {t} {source};"));
+                out.push(format!("INSERT INTO {t}{by_name} {source};"));
             }
             // Handled by the early return above (scd2 has no partitioned form).
             MaterializeStrategy::Scd2 { .. } => unreachable!("scd2 handled before this match"),
@@ -578,7 +630,7 @@ impl<'a> MaterializeCodegen<'a> {
         ];
         // Hard-delete-close (`deletes=close`): the keys that vanished from the
         // snapshot — present-and-current in the table, absent from the SELECT.
-        // Captured before the transaction (like `changed`) and disjoint from it (a
+        // Captured before the close (like `changed`) and disjoint from it (a
         // key is either in the snapshot or not), so the two closes never overlap.
         if close_deleted {
             out.push(format!(
@@ -633,6 +685,112 @@ impl<'a> MaterializeCodegen<'a> {
     }
 }
 
+// ---------------------------------------------------------------------------
+// on_schema_change drift detection (write-time guardrail)
+// ---------------------------------------------------------------------------
+//
+// Drift is computed entirely in SQL against the live DuckDB session: the
+// SELECT's output columns come from `DESCRIBE`, the table's from `DESCRIBE` of
+// the target (the managed `_wm_partition` column is excluded so it is compared
+// as the producer's logical output, matching schema capture). `added` = SELECT
+// columns absent from the table, `removed` = table columns absent from the
+// SELECT. When the table was just created this run (first materialize) the two
+// DESCRIBEs agree, so both lists are empty and no guard fires.
+
+/// A `DESCRIBE`-derived set of column names of `rel_sql` (any SELECT-able
+/// relation, already parenthesized/qualified by the caller), optionally
+/// dropping the managed partition column.
+fn describe_col_names(rel_sql: &str, exclude_col: Option<&str>) -> String {
+    let filter = match exclude_col {
+        Some(c) => format!(" WHERE column_name <> {}", quote_lit(c)),
+        None => String::new(),
+    };
+    format!("SELECT column_name FROM (DESCRIBE SELECT * FROM {rel_sql}){filter}")
+}
+
+/// Scalar subqueries `(added, removed)` — the list of column names in the
+/// SELECT but not the table, and vice versa. Each is a `list(...)` over an
+/// `EXCEPT`; empty ⇒ `list()` yields an empty list (`len` 0). The partition
+/// column is excluded on the table side only.
+///
+/// Set difference, not ordered: this catches the add/remove/rename that a
+/// positional INSERT misaligns on, but by design NOT a pure reorder of
+/// same-named columns (identical sets ⇒ empty added/removed). See the
+/// `OnSchemaChange` doc in asset_parser.rs — reorder-safety is `sync`'s job
+/// (INSERT BY NAME); the set difference is deliberately kept over an ordered
+/// comparison so the `fail` guard cannot false-positive on a correctly-aligned
+/// write.
+fn drift_lists(sel_sql: &str, target_qualified: &str, partition_col: &str) -> (String, String) {
+    let sel = describe_col_names(&format!("({sel_sql})"), None);
+    let tbl = describe_col_names(target_qualified, Some(partition_col));
+    let added = format!("(SELECT list(column_name) FROM (({sel}) EXCEPT ({tbl})))");
+    let removed = format!("(SELECT list(column_name) FROM (({tbl}) EXCEPT ({sel})))");
+    (added, removed)
+}
+
+/// The `fail`-mode guard: a single statement that raises via DuckDB `error(...)`
+/// when the SELECT's columns diverge from the table's, naming the added/removed
+/// columns and the target. Both `CASE` branches are cast to VARCHAR so the
+/// planner cannot constant-fold the `error(...)` away, and the condition depends
+/// on the runtime drift subqueries so it is never folded to a constant.
+fn schema_drift_guard_sql(sel_sql: &str, target_qualified: &str, partition_col: &str) -> String {
+    let (added, removed) = drift_lists(sel_sql, target_qualified, partition_col);
+    // `target_qualified` is safe in table-reference position (quoted identifiers)
+    // but here it lands inside a SQL string literal, so single-quotes must be
+    // doubled (same as `quote_lit`).
+    let tq = target_qualified.replace('\'', "''");
+    format!(
+        "SELECT CASE WHEN coalesce(len(_wm_added), 0) + coalesce(len(_wm_removed), 0) > 0 \
+         THEN CAST(error('managed materialize: on_schema_change=fail blocked a schema-drifted \
+         write to {tq} — added column(s): [' || coalesce(array_to_string(_wm_added, ', '), '') || \
+         '], removed column(s): [' || coalesce(array_to_string(_wm_removed, ', '), '') || \
+         ']. The table schema is fixed at first create; set on_schema_change=sync to auto-migrate, \
+         or align the SELECT with the table.') AS VARCHAR) ELSE 'ok' END \
+         FROM (SELECT {added} AS _wm_added, {removed} AS _wm_removed);",
+        tq = tq,
+    )
+}
+
+/// In-transaction guard for the keyed `merge` strategy: raises via DuckDB
+/// `error(...)` when the source SELECT holds more than one row for the same
+/// non-NULL `unique_key`. A keyed merge is delete-by-key + insert-all (it does
+/// NOT deduplicate the source), so duplicate source keys would land every
+/// duplicate row under one key — the exact silent double-write this guards
+/// against. Erroring keeps the semantics explicit: the author must deduplicate
+/// in the SELECT (or use `append`). NULL keys are excluded to match the delete's
+/// `key IN (...)` scope, which never matches NULL. `unique_key` is embedded raw
+/// in identifier position (matching the merge's own DELETE/IN) and doubled-quote
+/// escaped where it lands inside the error string literal.
+fn duplicate_source_key_guard_sql(sel_sql: &str, unique_key: &str) -> String {
+    let key_lit = unique_key.replace('\'', "''");
+    format!(
+        "SELECT CASE WHEN _wm_dup_keys > 0 THEN CAST(error('managed materialize: keyed merge on \
+         `{key_lit}` blocked — the source has ' || _wm_dup_keys || ' key value(s) with more than \
+         one row. A keyed merge keeps one row per key and does not deduplicate; deduplicate in the \
+         SELECT (e.g. QUALIFY row_number() OVER (PARTITION BY {key_lit} ORDER BY …) = 1) or use \
+         `append`.') AS VARCHAR) ELSE 'ok' END FROM (SELECT count(*) AS _wm_dup_keys FROM (SELECT \
+         {unique_key} FROM ({sel_sql}) WHERE {unique_key} IS NOT NULL GROUP BY {unique_key} HAVING \
+         count(*) > 1));"
+    )
+}
+
+/// The `warn`-mode summary column: a `schema_drift` struct `{added, removed}`
+/// when the SELECT drifted from the table, else NULL. Appended to the
+/// materialize summary row so the executor can log it and fold it into the job
+/// result without an extra round-trip.
+fn schema_drift_summary_field(
+    sel_sql: &str,
+    target_qualified: &str,
+    partition_col: &str,
+) -> String {
+    let (added, removed) = drift_lists(sel_sql, target_qualified, partition_col);
+    format!(
+        "(SELECT CASE WHEN coalesce(len(_wm_added), 0) + coalesce(len(_wm_removed), 0) > 0 \
+         THEN {{'added': _wm_added, 'removed': _wm_removed}} END \
+         FROM (SELECT {added} AS _wm_added, {removed} AS _wm_removed)) AS schema_drift"
+    )
+}
+
 /// The read that captures the DuckLake snapshot id produced by the write, for
 /// the given attach alias (e.g. `_wm_target`). The worker runs this last and
 /// records the result into `materialized_partition`.
@@ -646,6 +804,44 @@ pub fn snapshot_capture_sql(alias: &str) -> String {
 /// from the target ducklake's config and passes it in as `target_attach`.
 pub const TARGET_ALIAS: &str = "_wm_target";
 
+/// Structural role of one statement in a [`MaterializePlan`]. The public build
+/// executes the plan verbatim, so the kinds are pure metadata there; they exist
+/// so a downstream assembler (`pipeline_advanced::finalize_materialize_query`)
+/// can reason about the plan without parsing SQL.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum MaterializeStmtKind {
+    /// Pre-write statement: user setup, the target ATTACH, referenced-asset
+    /// ATTACHes.
+    Setup,
+    /// Write work against the target: bootstrap DDL, SCD2 temp-table captures,
+    /// the mutation itself, the `_current` view.
+    Write,
+    /// The `BEGIN TRANSACTION;` marker emitted by the strategy codegen.
+    TxnBegin,
+    /// The `COMMIT;` marker emitted by the strategy codegen.
+    TxnCommit,
+    /// The trailing one-row summary read (asset / rows / snapshot_id /
+    /// data_tests breakdown).
+    Summary,
+}
+
+/// One planned statement: its structural role and the SQL text.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct MaterializeStmt {
+    pub kind: MaterializeStmtKind,
+    pub sql: String,
+}
+
+/// The full ordered materialization plan [`build_wrap_blocks`] produces:
+/// statements in execution order plus the compiled data-test checks (also
+/// embedded in the summary statement's breakdown). Assembled into the final
+/// statement list by `pipeline_advanced::finalize_materialize_query`.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct MaterializePlan {
+    pub stmts: Vec<MaterializeStmt>,
+    pub checks: Vec<DataTestCheck>,
+}
+
 /// Assemble the full ordered statement list the DuckDB executor runs for a
 /// managed `// materialize` script. This is the single entry point the worker
 /// calls; it composes the already-tested pieces (classifier split → target
@@ -659,6 +855,14 @@ pub const TARGET_ALIAS: &str = "_wm_target";
 /// the full `<name>/<table>` for the result summary. The trailing statement is
 /// a one-row summary read (asset / rows / snapshot_id) that is both the job's
 /// result (a useful preview) and what the worker records.
+///
+/// Returns a [`MaterializePlan`] — the statements plus their structural role
+/// and the compiled data-test checks — rather than raw SQL: the executor hands
+/// the plan to `windmill_common::pipeline_advanced::finalize_materialize_query`
+/// (which this crate cannot depend on), whose public-build implementation
+/// assembles the statements verbatim. Everything this function produces runs
+/// as-is on the public build; the plan's structure is metadata about it, not a
+/// second mode.
 pub fn build_wrap_blocks(
     plan: &WrapPlan,
     target_attach: &str,
@@ -668,18 +872,11 @@ pub fn build_wrap_blocks(
     partition_value_sql: &str,
     partitioned: bool,
     strategy: MaterializeStrategy,
+    on_schema_change: OnSchemaChange,
     tests: &[DataTestResolved],
-) -> Result<Vec<String>, String> {
+) -> Result<MaterializePlan, String> {
     let target_qualified = format!("{TARGET_ALIAS}.{target_table}");
     let scd2 = matches!(strategy, MaterializeStrategy::Scd2 { .. });
-    let cg = MaterializeCodegen {
-        target_qualified: &target_qualified,
-        select_sql: &plan.output,
-        partition_col,
-        partition_value_sql,
-        partitioned,
-        strategy,
-    };
     let ctx = DataTestCtx {
         target_qualified: &target_qualified,
         asset_path,
@@ -689,27 +886,60 @@ pub fn build_wrap_blocks(
         scd2,
     };
     let test_sql = build_data_test_checks(tests, &ctx)?;
-    let mut blocks: Vec<String> = Vec::new();
+    let cg = MaterializeCodegen {
+        target_qualified: &target_qualified,
+        select_sql: &plan.output,
+        partition_col,
+        partition_value_sql,
+        partitioned,
+        strategy,
+        on_schema_change,
+    };
+    // `warn` folds the post-write drift into the summary row (executor logs it +
+    // returns it) — only for the positional persist-and-mutate path, and only in
+    // `warn`: `fail`/`sync` guard the write itself, `ignore` is silent.
+    let drift_summary_select =
+        if on_schema_change == OnSchemaChange::Warn && cg.is_persist_and_mutate() {
+            Some(plan.output.as_str())
+        } else {
+            None
+        };
+    let mut stmts: Vec<MaterializeStmt> = Vec::new();
+    let setup = |sql: String| MaterializeStmt { kind: MaterializeStmtKind::Setup, sql };
     // Setup blocks come from the splitter with their `;` stripped — re-terminate
     // each so that when the executor re-joins and re-splits the assembled query,
     // adjacent statements (e.g. the user ATTACH and the synthetic target ATTACH)
     // don't merge into one malformed statement.
-    blocks.extend(plan.setup.iter().map(|s| terminate(s)));
-    blocks.push(target_attach.to_string());
+    stmts.extend(plan.setup.iter().map(|s| setup(terminate(s))));
+    stmts.push(setup(target_attach.to_string()));
     // Referenced-asset ATTACHes (relationships tests) — read-only, before the
     // write and the summary that probes them.
-    blocks.extend(test_sql.attaches);
-    blocks.extend(cg.statements());
+    stmts.extend(test_sql.attaches.into_iter().map(setup));
+    // Classify the codegen statements by matching the exact transaction-marker
+    // literals this module emits (`BEGIN TRANSACTION;` / `COMMIT;`); everything
+    // else the codegen produces is write work.
+    stmts.extend(cg.statements().into_iter().map(|sql| {
+        let kind = match sql.as_str() {
+            "BEGIN TRANSACTION;" => MaterializeStmtKind::TxnBegin,
+            "COMMIT;" => MaterializeStmtKind::TxnCommit,
+            _ => MaterializeStmtKind::Write,
+        };
+        MaterializeStmt { kind, sql }
+    }));
     // The summary read carries the per-test breakdown (when any tests apply).
-    blocks.push(materialize_result_sql(
-        &target_qualified,
-        asset_path,
-        partition_col,
-        partition_value_sql,
-        partitioned,
-        &test_sql.checks,
-    ));
-    Ok(blocks)
+    stmts.push(MaterializeStmt {
+        kind: MaterializeStmtKind::Summary,
+        sql: materialize_result_sql(
+            &target_qualified,
+            asset_path,
+            partition_col,
+            partition_value_sql,
+            partitioned,
+            &test_sql.checks,
+            drift_summary_select,
+        ),
+    });
+    Ok(MaterializePlan { stmts, checks: test_sql.checks })
 }
 
 /// The trailing one-row summary the materialize run returns: the asset it
@@ -723,6 +953,10 @@ pub fn materialize_result_sql(
     partition_value_sql: &str,
     partitioned: bool,
     checks: &[DataTestCheck],
+    // `on_schema_change=warn` on a persist-and-mutate strategy: the SELECT to
+    // diff against the (post-write) table for the `schema_drift` summary column.
+    // `None` ⇒ no drift column (every other mode / strategy).
+    drift_summary_select: Option<&str>,
 ) -> String {
     let (count_expr, partition_sel) = if partitioned {
         // Row count is the slice this run wrote (the partition); `partition`
@@ -769,25 +1003,47 @@ pub fn materialize_result_sql(
          FROM (SELECT column_name, column_type, row_number() OVER () AS _wm_ord \
                FROM (DESCRIBE SELECT * FROM {target_qualified}){partition_filter})) AS output_schema"
     );
+    // `on_schema_change=warn`: fold the drift `{added, removed}` (or NULL) into
+    // the same row so the executor logs it + returns it with no extra probe.
+    let drift_col = match drift_summary_select {
+        Some(sel) => format!(
+            ", {}",
+            schema_drift_summary_field(sel, target_qualified, partition_col)
+        ),
+        None => String::new(),
+    };
     let base_cols = format!(
         "'ducklake://{asset_path}' AS materialized, \
          {partition_sel}{count_expr} AS rows, \
          (SELECT max(snapshot_id) FROM ducklake_snapshots('{TARGET_ALIAS}')) AS snapshot_id, \
-         {schema_capture}"
+         {schema_capture}{drift_col}"
     );
     if checks.is_empty() {
         return format!("SELECT {base_cols};");
     }
-    // Per-test breakdown. Each check's violating-count is computed once as a CTE
-    // column (`c0`, `c1`, …); the `data_tests` list-of-struct then references
-    // those columns — DuckDB rejects scalar subqueries *inside* a struct/list
-    // literal, hence the CTE. Names are single-quote-escaped. The result row
-    // carries the whole breakdown so the worker runs every test (no
-    // abort-on-first) and decides pass/fail itself.
-    let cte_cols = checks
+    // Per-test breakdown. Each check's one-row probe `(v, s)` becomes a CTE
+    // (`_wm_t0`, `_wm_t1`, …); `_wm_tr` cross-joins them (all one-row, so the
+    // join stays one row) and the `data_tests` list-of-struct references the
+    // flattened columns — DuckDB rejects scalar subqueries *inside* a
+    // struct/list literal, hence the CTE lift. Names are single-quote-escaped.
+    // The result row carries the whole breakdown so the worker runs every
+    // test (no abort-on-first) and decides pass/fail itself.
+    let probe_ctes = checks
         .iter()
         .enumerate()
-        .map(|(i, c)| format!("{} AS c{i}", c.violating))
+        .map(|(i, c)| format!("_wm_t{i} AS ({})", c.probe))
+        .collect::<Vec<_>>()
+        .join(", ");
+    let tr_cols = checks
+        .iter()
+        .enumerate()
+        .map(|(i, _)| format!("_wm_t{i}.v AS c{i}, _wm_t{i}.s AS s{i}"))
+        .collect::<Vec<_>>()
+        .join(", ");
+    let tr_from = checks
+        .iter()
+        .enumerate()
+        .map(|(i, _)| format!("_wm_t{i}"))
         .collect::<Vec<_>>()
         .join(", ");
     let list_items = checks
@@ -795,12 +1051,12 @@ pub fn materialize_result_sql(
         .enumerate()
         .map(|(i, c)| {
             let name = c.name.replace('\'', "''");
-            format!("{{'test': '{name}', 'violating': c{i}}}")
+            format!("{{'test': '{name}', 'violating': c{i}, 'sample': s{i}}}")
         })
         .collect::<Vec<_>>()
         .join(", ");
     format!(
-        "WITH _wm_tr AS (SELECT {cte_cols}) \
+        "WITH {probe_ctes}, _wm_tr AS (SELECT {tr_cols} FROM {tr_from}) \
          SELECT {base_cols}, [{list_items}] AS data_tests FROM _wm_tr;"
     )
 }
@@ -821,20 +1077,21 @@ fn terminate(stmt: &str) -> String {
 //
 // A data test is the FIRST extensible annotation: the parser yields a
 // `DataTest` from a known vocabulary, and this module turns each into a
-// *check* — a `(name, violating-row-count query)` pair — that runs against the
-// freshly-materialized target after the write commits. The materialize summary
-// query embeds every check's count in one `data_tests` column, so all tests
-// run in a single pass (no abort-on-first) and the worker, not the SQL,
-// decides pass/fail and reports the full per-test breakdown.
+// *check* — a `(name, probe)` pair whose probe counts and samples the
+// violating rows — that runs against the freshly-materialized target after
+// the write commits. The materialize summary query embeds every check's
+// outcome in one `data_tests` column, so all tests run in a single pass (no
+// abort-on-first) and the worker, not the SQL, decides pass/fail and reports
+// the full per-test breakdown.
 //
-// The pattern is deliberately open: a verifier is just `(name, count query)`.
-// Built-ins differ only in their count query; the `Custom` escape hatch
-// supplies its own (a user SELECT returning the violating rows). A sibling
-// annotation family (column-lineage) can emit its own checks through the same
-// `push_check` shape rather than bolting on a parallel mechanism. See
-// `docs/ducklake-materialization.md`.
+// The pattern is deliberately open: a verifier is just `(name, violating-rows
+// query)` handed to `push_check`. Built-ins differ only in their rows query;
+// the `Custom` escape hatch supplies its own (a user SELECT returning the
+// violating rows). A sibling annotation family (column-lineage) can emit its
+// own checks through the same `push_check` shape rather than bolting on a
+// parallel mechanism. See `docs/ducklake-materialization.md`.
 
-use crate::asset_parser::{AssetKind, DataTest};
+use crate::asset_parser::{AssetKind, DataTest, OnSchemaChange};
 
 /// Target context a data-test probe runs against — the materialized table and
 /// the partition slice (when partitioned, tests are scoped to the slice just
@@ -867,19 +1124,31 @@ pub enum DataTestResolved {
     Custom { path: String, body: String },
 }
 
-/// One compiled data-test check: a human-readable `name` and a scalar SQL
-/// expression (`violating`) yielding the number of rows that violate it (0 =
-/// pass). The materialize summary query embeds every check's count so the
-/// worker gets the whole breakdown in one result — all tests run (no
-/// abort-on-first) and the worker, not the SQL, decides pass/fail.
+/// One compiled data-test check: a human-readable `name` and a one-row probe
+/// query yielding `(v, s)` — the violating-row count (0 = pass) and a bounded
+/// `to_json` sample of the violating rows as a VARCHAR (NULL when there are
+/// none, or when the serialized sample exceeds the size cap). The materialize
+/// summary query embeds every check's outcome so the worker gets the whole
+/// breakdown in one result — all tests run (no abort-on-first) and the
+/// worker, not the SQL, decides pass/fail. The sample is decoration only:
+/// enforcement reads `v`, never `s`.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct DataTestCheck {
     pub name: String,
-    /// Scalar subquery yielding the violating-row count, e.g.
-    /// `(SELECT count(*) AS v FROM (…))`.
-    pub violating: String,
+    /// One-row subquery `SELECT … AS v, … AS s FROM (…)` counting and
+    /// sampling the check's violating rows in a single scan.
+    pub probe: String,
 }
 
+/// Row cap on a data-test sample. Bounded so the sample stays a debugging aid
+/// (the full count is still reported); no ORDER BY on the violating rows, so
+/// which rows land in the sample is nondeterministic.
+const SAMPLE_MAX_ROWS: usize = 20;
+/// Byte cap on one serialized sample. Oversized samples are dropped entirely
+/// (NULL), never truncated — truncated JSON would fail parsing downstream
+/// after paying the bytes anyway.
+const SAMPLE_MAX_BYTES: usize = 51_200;
+
 /// The SQL a set of data tests compiles to: referenced-asset `ATTACH`
 /// statements (resolved by the executor's ATTACH-transform pass) and the
 /// per-test checks, both in declaration order.
@@ -943,11 +1212,62 @@ fn partition_scope(ctx: &DataTestCtx, prefix: &str, table_alias: Option<&str>) -
     format!("{prefix}{}", conds.join(" AND "))
 }
 
-// Record one check: its display `name` plus `count_query` (which yields a
-// single-column violating-row count) wrapped as a scalar subquery.
-fn push_check(out: &mut DataTestChecks, name: String, count_query: String) {
-    out.checks
-        .push(DataTestCheck { name, violating: format!("({count_query})") });
+// Record one check: its display `name` plus `rows_query`, the SELECT of its
+// violating rows. The probe counts and samples those rows in one scan:
+// `_wm_v` (the subquery alias) referenced as a column is the whole row as a
+// struct; `to_json(...)::VARCHAR` keeps the sample a JSON *string* through
+// the FFI — expanded rows would be visible to the executor's key-recursive
+// `extract_i64(result, "rows"/"snapshot_id")` scans, which a user column of
+// the same name could corrupt. `list()` over zero rows and an over-cap
+// sample both degrade to NULL (`s` is optional by contract).
+fn push_check(out: &mut DataTestChecks, name: String, rows_query: String) {
+    // `strlen` counts bytes (unlike `length`, characters) — the cap bounds
+    // payload size on the wire, so bytes are the right unit.
+    let probe = format!(
+        "SELECT v, CASE WHEN strlen(s_raw) <= {SAMPLE_MAX_BYTES} THEN s_raw END AS s \
+         FROM (SELECT count(*) AS v, \
+         to_json(list(_wm_v ORDER BY _wm_rn) FILTER (WHERE _wm_rn <= {SAMPLE_MAX_ROWS}))::VARCHAR AS s_raw \
+         FROM (SELECT _wm_v, row_number() OVER () AS _wm_rn FROM ({rows_query}) _wm_v))"
+    );
+    out.checks.push(DataTestCheck { name, probe });
+}
+
+// `SELECT *` for a sample rows-query, excluding the synthetic physical
+// partition column on partitioned targets — it's Windmill's storage detail,
+// not part of the producer's logical output (same rule as schema capture).
+// `qualifier` scopes the star when the query aliases the target (`_wm_src`).
+fn sample_star(ctx: &DataTestCtx, qualifier: Option<&str>) -> String {
+    let star = match qualifier {
+        Some(q) => format!("{q}.*"),
+        None => "*".to_string(),
+    };
+    if ctx.partitioned {
+        format!("{star} EXCLUDE ({})", quote_ident(ctx.partition_col))
+    } else {
+        star
+    }
+}
+
+// Self-teaching tail appended to every malformed-custom-test error. It states
+// the two rules that aren't documented or scaffolded anywhere else — the body
+// is a single SELECT, and it reads the freshly-materialized target through the
+// internal `_wm_target.<table>` alias — and doubles that alias into a copyable
+// one-line example. `target_qualified` is already `_wm_target.<table>`.
+fn custom_test_hint(target_qualified: &str) -> String {
+    format!(
+        "Write a single SELECT against `{target_qualified}` returning the offending rows, e.g. \
+         `SELECT * FROM {target_qualified} WHERE <condition>` — an empty result means the test \
+         passes."
+    )
+}
+
+// Whether a custom-test statement reads the materialized target through the
+// reserved `_wm_target` alias (the only handle the runtime attaches it under).
+// SQL identifiers are case-insensitive, so match case-insensitively;
+// `split_statements` has already stripped comments, so a match here is a real
+// reference, not one buried in a comment. `TARGET_ALIAS` is lowercase.
+fn references_target(stmt: &str) -> bool {
+    stmt.to_lowercase().contains(TARGET_ALIAS)
 }
 
 /// Compile resolved data tests into ATTACH statements + per-test checks for
@@ -969,28 +1289,34 @@ pub fn build_data_test_checks(
             DataTestResolved::BuiltIn(DataTest::Unique { column }) => {
                 let c = quote_ident(column);
                 let scope = partition_scope(ctx, " AND ", None);
+                // The rows are the GROUP BY result — one `{value, count}` per
+                // duplicated key — so the count (number of duplicated values,
+                // not of rows) and the sample share one grain and can't
+                // contradict each other in the UI.
                 let q = format!(
-                    "SELECT count(*) AS v FROM (SELECT {c} FROM {t} WHERE {c} IS NOT NULL{scope} \
-                     GROUP BY {c} HAVING count(*) > 1)"
+                    "SELECT {c} AS \"value\", count(*) AS \"count\" FROM {t} \
+                     WHERE {c} IS NOT NULL{scope} GROUP BY {c} HAVING count(*) > 1"
                 );
                 push_check(&mut out, format!("unique({column})"), q);
             }
             DataTestResolved::BuiltIn(DataTest::NotNull { column }) => {
                 let c = quote_ident(column);
                 let scope = partition_scope(ctx, " AND ", None);
-                let q = format!("SELECT count(*) AS v FROM {t} WHERE {c} IS NULL{scope}");
+                let star = sample_star(ctx, None);
+                let q = format!("SELECT {star} FROM {t} WHERE {c} IS NULL{scope}");
                 push_check(&mut out, format!("not_null({column})"), q);
             }
             DataTestResolved::BuiltIn(DataTest::AcceptedValues { column, values }) => {
                 let c = quote_ident(column);
                 let scope = partition_scope(ctx, " AND ", None);
+                let star = sample_star(ctx, None);
                 let list = values
                     .iter()
                     .map(|v| quote_lit(v))
                     .collect::<Vec<_>>()
                     .join(", ");
                 let q = format!(
-                    "SELECT count(*) AS v FROM {t} WHERE {c} IS NOT NULL AND {c} NOT IN ({list}){scope}"
+                    "SELECT {star} FROM {t} WHERE {c} IS NOT NULL AND {c} NOT IN ({list}){scope}"
                 );
                 push_check(&mut out, format!("accepted_values({column})"), q);
             }
@@ -1054,8 +1380,9 @@ pub fn build_data_test_checks(
                 // segment so the dot stays a schema separator, not a literal.
                 let rt = quote_qualified(ref_table);
                 let scope = partition_scope(ctx, " AND ", Some("_wm_src"));
+                let star = sample_star(ctx, Some("_wm_src"));
                 let q = format!(
-                    "SELECT count(*) AS v FROM {t} _wm_src \
+                    "SELECT {star} FROM {t} _wm_src \
                      WHERE _wm_src.{c} IS NOT NULL{scope} \
                      AND NOT EXISTS (SELECT 1 FROM {alias}.{rt} _wm_ref \
                      WHERE _wm_ref.{rc} = _wm_src.{c})"
@@ -1074,25 +1401,44 @@ pub fn build_data_test_checks(
             }
             DataTestResolved::Custom { path, body } => {
                 // dbt singular-test convention: the body is a *single* SELECT
-                // (or CTE) returning the violating rows. It is embedded as a
-                // subquery (`FROM (<body>)`), so a multi-statement body would
-                // produce invalid SQL — validate up front with an actionable
-                // error. It runs in the target's connection (can read
-                // `_wm_target` + the user's attaches); partition substitution is
-                // already applied by the worker.
+                // (or CTE) returning the violating rows, reading the
+                // freshly-materialized target through the internal `_wm_target`
+                // schema. It is embedded as a subquery (`FROM (<body>)`), so a
+                // multi-statement or non-SELECT body would produce invalid SQL.
+                // Neither rule is documented or scaffolded elsewhere, so the
+                // errors are self-teaching: they name the exact violation and
+                // append a correct one-line example. It runs in the target's
+                // connection (can read `_wm_target` + the user's attaches);
+                // partition substitution is already applied by the worker.
+                let hint = custom_test_hint(t);
                 let stmts = split_statements(body);
                 if stmts.is_empty() {
-                    return Err(format!("data_test custom `{path}`: empty test body"));
+                    return Err(format!(
+                        "data_test custom `{path}`: empty test body. {hint}"
+                    ));
                 }
                 if stmts.len() > 1 {
                     return Err(format!(
-                        "data_test custom `{path}`: must be a single SELECT returning the \
-                         violating rows (found {} statements)",
+                        "data_test custom `{path}`: a custom data test must be a single SELECT, \
+                         but found {} statements. {hint}",
                         stmts.len()
                     ));
                 }
-                let q = format!("SELECT count(*) AS v FROM ({})", stmts[0]);
-                push_check(&mut out, format!("custom({path})"), q);
+                let stmt = &stmts[0];
+                if classify_block(stmt) != BlockClass::Output {
+                    return Err(format!(
+                        "data_test custom `{path}`: a custom data test must be a single SELECT, \
+                         not a write or DDL statement. {hint}"
+                    ));
+                }
+                if !references_target(stmt) {
+                    return Err(format!(
+                        "data_test custom `{path}`: the test never reads the freshly-materialized \
+                         target — reference it through the internal `{TARGET_ALIAS}` schema (as \
+                         `{t}`), not the table name on its own. {hint}"
+                    ));
+                }
+                push_check(&mut out, format!("custom({path})"), stmt.to_string());
             }
         }
     }
@@ -1235,6 +1581,7 @@ mod tests {
             partition_value_sql: "'2026-06-19'",
             partitioned: true,
             strategy: MaterializeStrategy::Replace,
+            on_schema_change: OnSchemaChange::Warn,
         };
         let st = cg.statements();
         assert!(st[0].contains("CREATE TABLE IF NOT EXISTS _wm_target.orders_daily"));
@@ -1260,6 +1607,7 @@ mod tests {
             partition_value_sql: "'2026-06-19'",
             partitioned: true,
             strategy: MaterializeStrategy::Merge { unique_key: "order_id".to_string() },
+            on_schema_change: OnSchemaChange::Warn,
         };
         let st = cg.statements();
         // upsert = delete-by-key (partition-scoped) + insert — NO `MERGE INTO`
@@ -1277,6 +1625,42 @@ mod tests {
             .any(|s| s.starts_with("INSERT INTO _wm_target.orders_daily SELECT *, '2026-06-19'")));
     }
 
+    #[test]
+    fn codegen_merge_emits_duplicate_source_key_guard() {
+        // A keyed merge does not dedup its source, so codegen must emit a guard
+        // that fails the write when the SELECT has >1 row per key — otherwise
+        // duplicate source keys silently double-write.
+        let cg = MaterializeCodegen {
+            target_qualified: "_wm_target.orders_daily",
+            select_sql: "SELECT order_id, amount FROM dl.orders",
+            partition_col: "_wm_partition",
+            partition_value_sql: "'2026-06-19'",
+            partitioned: false,
+            strategy: MaterializeStrategy::Merge { unique_key: "order_id".to_string() },
+            on_schema_change: OnSchemaChange::Warn,
+        };
+        let st = cg.statements();
+        let guard = st
+            .iter()
+            .find(|s| s.contains("_wm_dup_keys"))
+            .expect("duplicate-key guard stmt");
+        // raises via error(), counts non-NULL keys appearing more than once
+        assert!(guard.contains("error('managed materialize: keyed merge on `order_id` blocked"));
+        assert!(guard.contains("GROUP BY order_id HAVING count(*) > 1"));
+        assert!(guard.contains("WHERE order_id IS NOT NULL"));
+        // must run before the mutations so a violation aborts before any write
+        let guard_pos = st.iter().position(|s| s.contains("_wm_dup_keys")).unwrap();
+        let del_pos = st
+            .iter()
+            .position(|s| s.starts_with("DELETE FROM"))
+            .unwrap();
+        let ins_pos = st
+            .iter()
+            .position(|s| s.starts_with("INSERT INTO"))
+            .unwrap();
+        assert!(guard_pos < del_pos && guard_pos < ins_pos);
+    }
+
     #[test]
     fn codegen_append_inserts_only() {
         let cg = MaterializeCodegen {
@@ -1286,6 +1670,7 @@ mod tests {
             partition_value_sql: "'2026-06-19'",
             partitioned: true,
             strategy: MaterializeStrategy::Append,
+            on_schema_change: OnSchemaChange::Warn,
         };
         let st = cg.statements();
         assert!(st
@@ -1307,6 +1692,7 @@ mod tests {
             partition_value_sql: "''",
             partitioned: false,
             strategy: MaterializeStrategy::Replace,
+            on_schema_change: OnSchemaChange::Warn,
         };
         let st = cg.statements();
         assert_eq!(
@@ -1332,6 +1718,7 @@ mod tests {
                 track: vec![],
                 close_deleted: false,
             },
+            on_schema_change: OnSchemaChange::Warn,
         };
         let st = cg.statements();
         // bootstrap adds the three SCD metadata columns
@@ -1388,6 +1775,7 @@ mod tests {
                 track: vec!["name".to_string()],
                 close_deleted: false,
             },
+            on_schema_change: OnSchemaChange::Warn,
         };
         let st = cg.statements();
         // only key + tracked cols are compared (addr changes don't rotate a version)
@@ -1407,6 +1795,7 @@ mod tests {
                 track: vec![],
                 close_deleted: true,
             },
+            on_schema_change: OnSchemaChange::Warn,
         };
         let st = cg.statements();
         // the deleted-key set: current keys absent from the snapshot, captured
@@ -1443,6 +1832,169 @@ mod tests {
         assert!(begin < del_close && del_close < commit);
     }
 
+    fn persist_cg(strategy: MaterializeStrategy, osc: OnSchemaChange) -> Vec<String> {
+        MaterializeCodegen {
+            target_qualified: "_wm_target.t",
+            select_sql: "SELECT a, c FROM dl.src",
+            partition_col: "_wm_partition",
+            partition_value_sql: "''",
+            partitioned: false,
+            strategy,
+            on_schema_change: osc,
+        }
+        .statements()
+    }
+
+    #[test]
+    fn codegen_fail_emits_drift_guard_inside_txn_before_write() {
+        let st = persist_cg(
+            MaterializeStrategy::Merge { unique_key: "a".into() },
+            OnSchemaChange::Fail,
+        );
+        let begin = st.iter().position(|s| s == "BEGIN TRANSACTION;").unwrap();
+        let guard = st
+            .iter()
+            .position(|s| s.contains("error(") && s.contains("on_schema_change=fail"))
+            .expect("fail emits a guard");
+        let del = st
+            .iter()
+            .position(|s| s.starts_with("DELETE FROM"))
+            .unwrap();
+        let insert = st
+            .iter()
+            .position(|s| s.starts_with("INSERT INTO"))
+            .unwrap();
+        let commit = st.iter().position(|s| s == "COMMIT;").unwrap();
+        // guard runs right after BEGIN and before any mutation, inside the txn
+        assert!(begin < guard && guard < del && del < insert && insert < commit);
+        // both CASE branches are VARCHAR so the planner can't fold error() away
+        assert!(st[guard].contains("CAST(error("));
+        assert!(st[guard].contains("ELSE 'ok' END"));
+        // fail is positional (no BY NAME) and emits no sync sentinel
+        assert!(st[insert].starts_with("INSERT INTO _wm_target.t SELECT"));
+        assert!(!st.iter().any(|s| s == SYNC_ALTER_SENTINEL));
+    }
+
+    #[test]
+    fn fail_guard_drift_is_name_set_based_not_ordered() {
+        // Documents a deliberate boundary: the fail guard fires on the column
+        // SET difference (EXCEPT over column_name), so a pure reorder of
+        // same-named columns is NOT caught here — that is `sync`'s job (BY NAME).
+        // Keeping this name-set (not an ordered comparison) is what prevents the
+        // guard from false-positive-aborting a correctly-aligned write. If this
+        // ever moves to an ordered comparison, update the OnSchemaChange doc.
+        let guard =
+            schema_drift_guard_sql("SELECT b, a FROM dl.src", "_wm_target.t", "_wm_partition");
+        assert!(guard.contains("column_name"));
+        assert!(guard.contains("EXCEPT"));
+        // No positional/ordinal comparison in the guard condition.
+        assert!(!guard.to_lowercase().contains("ordinal"));
+        assert!(!guard.to_lowercase().contains("row_number"));
+    }
+
+    #[test]
+    fn codegen_sync_uses_by_name_and_sentinel() {
+        let st = persist_cg(MaterializeStrategy::Append, OnSchemaChange::Sync);
+        let begin = st.iter().position(|s| s == "BEGIN TRANSACTION;").unwrap();
+        let sentinel = st.iter().position(|s| s == SYNC_ALTER_SENTINEL).unwrap();
+        let insert = st
+            .iter()
+            .position(|s| s.starts_with("INSERT INTO"))
+            .unwrap();
+        // the ALTER-injection slot is right after BEGIN, before the write
+        assert!(begin < sentinel && sentinel < insert);
+        // name-mapped insert (a positional insert would cross-wire ALTERed cols)
+        assert!(st[insert].starts_with("INSERT INTO _wm_target.t BY NAME SELECT"));
+        assert!(!st.iter().any(|s| s.contains("error(")));
+    }
+
+    #[test]
+    fn codegen_ignore_and_warn_write_positionally_no_guard() {
+        for osc in [OnSchemaChange::Ignore, OnSchemaChange::Warn] {
+            let st = persist_cg(MaterializeStrategy::Append, osc);
+            assert!(!st.iter().any(|s| s.contains("error(")), "{osc:?}");
+            assert!(!st.iter().any(|s| s == SYNC_ALTER_SENTINEL), "{osc:?}");
+            let insert = st.iter().find(|s| s.starts_with("INSERT INTO")).unwrap();
+            assert!(
+                insert.starts_with("INSERT INTO _wm_target.t SELECT"),
+                "{osc:?}"
+            );
+        }
+    }
+
+    #[test]
+    fn codegen_whole_table_replace_and_scd2_ignore_guardrail() {
+        // Whole-table replace (unpartitioned) and scd2 are not persist-and-mutate:
+        // fail/sync must not add a guard/sentinel/BY NAME there.
+        let repl = MaterializeCodegen {
+            target_qualified: "_wm_target.t",
+            select_sql: "SELECT a FROM dl.src",
+            partition_col: "_wm_partition",
+            partition_value_sql: "''",
+            partitioned: false,
+            strategy: MaterializeStrategy::Replace,
+            on_schema_change: OnSchemaChange::Fail,
+        };
+        assert!(!repl.is_persist_and_mutate());
+        let st = repl.statements();
+        assert!(!st
+            .iter()
+            .any(|s| s.contains("error(") || s == SYNC_ALTER_SENTINEL));
+
+        let scd2 = MaterializeCodegen {
+            strategy: MaterializeStrategy::Scd2 {
+                key: "a".into(),
+                track: vec![],
+                close_deleted: false,
+            },
+            on_schema_change: OnSchemaChange::Sync,
+            ..repl
+        };
+        assert!(!scd2.is_persist_and_mutate());
+        let st = scd2.statements();
+        assert!(!st.iter().any(|s| s == SYNC_ALTER_SENTINEL));
+        assert!(!st.iter().any(|s| s.contains(" BY NAME ")));
+    }
+
+    #[test]
+    fn summary_schema_drift_field_only_for_warn_persist_and_mutate() {
+        // warn + persist-and-mutate ⇒ summary carries the drift column
+        let warn = plan_for_osc(MaterializeStrategy::Append, false, OnSchemaChange::Warn);
+        assert!(warn.stmts.last().unwrap().sql.contains("AS schema_drift"));
+        // ignore / fail / sync ⇒ no summary drift column (they guard the write)
+        for osc in [
+            OnSchemaChange::Ignore,
+            OnSchemaChange::Fail,
+            OnSchemaChange::Sync,
+        ] {
+            let p = plan_for_osc(MaterializeStrategy::Append, false, osc);
+            assert!(
+                !p.stmts.last().unwrap().sql.contains("schema_drift"),
+                "{osc:?} must not emit the summary drift column"
+            );
+        }
+        // whole-table replace + warn ⇒ not persist-and-mutate ⇒ no drift column
+        let repl = plan_for_osc(MaterializeStrategy::Replace, false, OnSchemaChange::Warn);
+        assert!(!repl.stmts.last().unwrap().sql.contains("schema_drift"));
+    }
+
+    #[test]
+    fn fail_guard_is_write_kind_between_txn_markers() {
+        use MaterializeStmtKind::*;
+        let plan = plan_for_osc(
+            MaterializeStrategy::Merge { unique_key: "a".into() },
+            false,
+            OnSchemaChange::Fail,
+        );
+        let begin = kidx(&plan, |s| s.kind == TxnBegin);
+        let commit = kidx(&plan, |s| s.kind == TxnCommit);
+        let guard = kidx(&plan, |s| {
+            s.sql.contains("error(") && s.sql.contains("on_schema_change=fail")
+        });
+        assert_eq!(plan.stmts[guard].kind, Write);
+        assert!(begin < guard && guard < commit);
+    }
+
     #[test]
     fn snapshot_capture_targets_alias() {
         assert_eq!(
@@ -1454,7 +2006,7 @@ mod tests {
     #[test]
     fn build_wrap_blocks_orders_setup_attach_codegen_snapshot() {
         let plan = ok("ATTACH 'ducklake://main' AS dl;\n SELECT a FROM dl.orders WHERE d = '{p}'");
-        let blocks = build_wrap_blocks(
+        let blocks: Vec<String> = build_wrap_blocks(
             &plan,
             "ATTACH 'ducklake:postgres:…' AS _wm_target (DATA_PATH 's3://b/p');",
             "orders_daily",
@@ -1463,9 +2015,14 @@ mod tests {
             "'2026-06-19'",
             true,
             MaterializeStrategy::Replace,
+            OnSchemaChange::Warn,
             &[],
         )
-        .unwrap();
+        .unwrap()
+        .stmts
+        .into_iter()
+        .map(|s| s.sql)
+        .collect();
         // setup block first, then the target ATTACH, then codegen, then result.
         assert!(blocks[0].starts_with("ATTACH 'ducklake://main' AS dl"));
         // every setup block must be `;`-terminated so re-splitting can't merge it
@@ -1488,6 +2045,112 @@ mod tests {
         assert!(last.contains("ducklake_snapshots('_wm_target')"));
     }
 
+    // -- materialize plan structure ------------------------------------------
+
+    fn plan_for(strategy: MaterializeStrategy, partitioned: bool) -> MaterializePlan {
+        plan_for_osc(strategy, partitioned, OnSchemaChange::Warn)
+    }
+
+    fn plan_for_osc(
+        strategy: MaterializeStrategy,
+        partitioned: bool,
+        on_schema_change: OnSchemaChange,
+    ) -> MaterializePlan {
+        let plan = ok("SELECT a, b FROM src");
+        build_wrap_blocks(
+            &plan,
+            "ATTACH 'ducklake:…' AS _wm_target;",
+            "orders",
+            "main/orders",
+            "_wm_partition",
+            "'2026-06-19'",
+            partitioned,
+            strategy,
+            on_schema_change,
+            &[
+                DataTestResolved::BuiltIn(DataTest::NotNull { column: "a".into() }),
+                DataTestResolved::BuiltIn(DataTest::Unique { column: "b".into() }),
+            ],
+        )
+        .unwrap()
+    }
+
+    fn kidx(plan: &MaterializePlan, pred: impl Fn(&MaterializeStmt) -> bool) -> usize {
+        plan.stmts
+            .iter()
+            .position(|s| pred(s))
+            .expect("stmt present")
+    }
+
+    #[test]
+    fn plan_tags_structure_and_carries_checks() {
+        use MaterializeStmtKind::*;
+        let plan = plan_for(MaterializeStrategy::Replace, true);
+        // leading statements are Setup, ending with the target ATTACH
+        assert!(plan.stmts[0].kind == Setup);
+        assert!(plan
+            .stmts
+            .iter()
+            .take_while(|s| s.kind == Setup)
+            .any(|s| s.sql.contains("_wm_target")));
+        // txn markers are tagged, everything between them is Write
+        let begin = kidx(&plan, |s| s.kind == TxnBegin);
+        let commit = kidx(&plan, |s| s.kind == TxnCommit);
+        assert!(begin < commit);
+        assert!(plan.stmts[begin + 1..commit]
+            .iter()
+            .all(|s| s.kind == Write));
+        // bootstrap DDL is Write work (it targets the table, not the session)
+        let bootstrap = kidx(&plan, |s| s.sql.starts_with("CREATE TABLE IF NOT EXISTS"));
+        assert_eq!(plan.stmts[bootstrap].kind, Write);
+        // summary is last and carries the breakdown; checks ride along
+        let last = plan.stmts.last().unwrap();
+        assert_eq!(last.kind, Summary);
+        assert!(last.sql.contains("AS data_tests"));
+        assert_eq!(plan.checks.len(), 2);
+        assert!(plan.checks[0].name.contains("not_null(a)"));
+    }
+
+    #[test]
+    fn plan_whole_table_replace_has_no_txn_markers() {
+        use MaterializeStmtKind::*;
+        let plan = plan_for(MaterializeStrategy::Replace, false);
+        assert!(!plan.stmts.iter().any(|s| s.kind == TxnBegin));
+        assert!(!plan.stmts.iter().any(|s| s.kind == TxnCommit));
+        assert_eq!(
+            plan.stmts.iter().filter(|s| s.kind == Write).count(),
+            1,
+            "single atomic CREATE OR REPLACE"
+        );
+    }
+
+    #[test]
+    fn plan_scd2_captures_are_write_kind() {
+        use MaterializeStmtKind::*;
+        let plan = plan_for(
+            MaterializeStrategy::Scd2 { key: "a".into(), track: vec![], close_deleted: false },
+            false,
+        );
+        let capture = kidx(&plan, |s| s.sql.contains("TEMP TABLE _wm_scd2_changed"));
+        assert_eq!(plan.stmts[capture].kind, Write);
+        // no test declared ⇒ empty checks
+        let plain = ok("SELECT a FROM src");
+        let no_tests = build_wrap_blocks(
+            &plain,
+            "ATTACH 'ducklake:…' AS _wm_target;",
+            "orders",
+            "main/orders",
+            "_wm_partition",
+            "''",
+            false,
+            MaterializeStrategy::Append,
+            OnSchemaChange::Warn,
+            &[],
+        )
+        .unwrap();
+        assert!(no_tests.checks.is_empty());
+    }
+
     // -- data tests ---------------------------------------------------------
 
     fn ctx_partitioned() -> DataTestCtx<'static> {
@@ -1519,21 +2182,34 @@ mod tests {
         // short, asset-free names (the asset is shown once by the breakdown).
         assert_eq!(sql.checks[0].name, "unique(order_id)");
         assert_eq!(sql.checks[1].name, "not_null(user_id)");
-        // each `violating` is a scalar count subquery.
+        // each probe counts and samples the violating rows in one scan, with
+        // the size guard on the serialized sample.
+        for c in &sql.checks {
+            assert!(c
+                .probe
+                .starts_with("SELECT v, CASE WHEN strlen(s_raw) <= 51200 THEN s_raw END AS s"));
+            assert!(c.probe.contains("count(*) AS v"));
+            assert!(c.probe.contains("FILTER (WHERE _wm_rn <= 20)"));
+        }
+        // unique: groups non-null keys within the slice, having count>1; the
+        // sample is `{value, count}` pairs at the same grain as the count.
         assert!(sql.checks[0]
-            .violating
-            .starts_with("(SELECT count(*) AS v FROM"));
-        // unique: groups non-null keys within the slice, having count>1
-        assert!(sql.checks[0]
-            .violating
+            .probe
             .contains("GROUP BY \"order_id\" HAVING count(*) > 1"));
         assert!(sql.checks[0]
-            .violating
+            .probe
+            .contains("SELECT \"order_id\" AS \"value\", count(*) AS \"count\""));
+        assert!(sql.checks[0]
+            .probe
             .contains("\"order_id\" IS NOT NULL AND \"_wm_partition\" = '2026-06-19'"));
-        // not_null: null rows in the slice
+        // not_null: null rows in the slice; the sample excludes the synthetic
+        // partition column (storage detail, not producer output).
         assert!(sql.checks[1]
-            .violating
+            .probe
             .contains("WHERE \"user_id\" IS NULL AND \"_wm_partition\" = '2026-06-19'"));
+        assert!(sql.checks[1]
+            .probe
+            .contains("SELECT * EXCLUDE (\"_wm_partition\") FROM"));
     }
 
     #[test]
@@ -1542,8 +2218,9 @@ mod tests {
             column: "id".into(),
         })];
         let sql = build_data_test_checks(&tests, &ctx_unpartitioned()).unwrap();
-        assert!(sql.checks[0].violating.contains("WHERE \"id\" IS NULL"));
-        assert!(!sql.checks[0].violating.contains("_wm_partition"));
+        assert!(sql.checks[0].probe.contains("WHERE \"id\" IS NULL"));
+        assert!(!sql.checks[0].probe.contains("_wm_partition"));
+        assert!(!sql.checks[0].probe.contains("EXCLUDE"));
     }
 
     #[test]
@@ -1560,14 +2237,14 @@ mod tests {
         ];
         let sql = build_data_test_checks(&tests, &ctx_scd2()).unwrap();
         assert!(sql.checks[0]
-            .violating
+            .probe
             .contains("WHERE \"customer_id\" IS NOT NULL AND is_current"));
         assert!(sql.checks[1]
-            .violating
+            .probe
             .contains("WHERE \"tier\" IS NULL AND is_current"));
-        assert!(sql.checks[2].violating.contains("AND is_current"));
+        assert!(sql.checks[2].probe.contains("AND is_current"));
         // no partition scope leaks in (scd2 is unpartitioned in v1)
-        assert!(!sql.checks[0].violating.contains("_wm_partition"));
+        assert!(!sql.checks[0].probe.contains("_wm_partition"));
     }
 
     #[test]
@@ -1577,10 +2254,8 @@ mod tests {
             values: vec!["paid".into(), "o'brien".into()],
         })];
         let sql = build_data_test_checks(&tests, &ctx_unpartitioned()).unwrap();
-        assert!(sql.checks[0]
-            .violating
-            .contains("NOT IN ('paid', 'o''brien')"));
-        assert!(sql.checks[0].violating.contains("\"status\" IS NOT NULL"));
+        assert!(sql.checks[0].probe.contains("NOT IN ('paid', 'o''brien')"));
+        assert!(sql.checks[0].probe.contains("\"status\" IS NOT NULL"));
     }
 
     #[test]
@@ -1604,14 +2279,19 @@ mod tests {
         assert_eq!(sql.attaches.len(), 1, "same db attached once");
         assert_eq!(sql.attaches[0], "ATTACH 'datatable://prod' AS _wm_ref_0;");
         assert!(sql.checks[0]
-            .violating
+            .probe
             .contains("NOT EXISTS (SELECT 1 FROM _wm_ref_0.\"users\""));
         assert!(sql.checks[1]
-            .violating
+            .probe
             .contains("NOT EXISTS (SELECT 1 FROM _wm_ref_0.\"buyers\""));
         assert!(sql.checks[0]
-            .violating
+            .probe
             .contains("_wm_src.\"_wm_partition\" = '2026-06-19'"));
+        // sample rows come from the aliased target and drop the synthetic
+        // partition column.
+        assert!(sql.checks[0]
+            .probe
+            .contains("SELECT _wm_src.* EXCLUDE (\"_wm_partition\") FROM"));
         assert_eq!(
             sql.checks[0].name,
             "relationships(user_id -> prod/users.id)"
@@ -1648,7 +2328,7 @@ mod tests {
             "same-lake ref must not ATTACH again"
         );
         assert!(sql.checks[0]
-            .violating
+            .probe
             .contains("NOT EXISTS (SELECT 1 FROM _wm_target.\"users\""));
     }
 
@@ -1669,10 +2349,10 @@ mod tests {
         );
         assert!(
             sql.checks[0]
-                .violating
+                .probe
                 .contains("FROM _wm_ref_0.\"main\".\"dim_products\""),
             "schema-qualified target should be quoted per segment: {}",
-            sql.checks[0].violating
+            sql.checks[0].probe
         );
     }
 
@@ -1694,23 +2374,96 @@ mod tests {
             body: "SELECT * FROM _wm_target.orders WHERE amount < 0;".into(),
         }];
         let sql = build_data_test_checks(&tests, &ctx_unpartitioned()).unwrap();
-        // trailing ; stripped, wrapped as a count subquery
-        assert!(sql.checks[0].violating.contains(
-            "SELECT count(*) AS v FROM (SELECT * FROM _wm_target.orders WHERE amount < 0)"
-        ));
+        // trailing ; stripped, body embedded as the probe's rows query
+        assert!(sql.checks[0]
+            .probe
+            .contains("FROM (SELECT * FROM _wm_target.orders WHERE amount < 0) _wm_v"));
+        assert!(sql.checks[0].probe.contains("count(*) AS v"));
         assert_eq!(sql.checks[0].name, "custom(f/tests/amount)");
     }
 
     #[test]
     fn data_test_custom_rejects_multi_statement_body() {
         // The body is embedded as a subquery, so a setup-then-SELECT body would
-        // produce invalid SQL — reject it up front with an actionable error.
+        // produce invalid SQL — reject it up front with a self-teaching error
+        // that names the violation and shows the correct single-SELECT shape.
         let tests = vec![DataTestResolved::Custom {
             path: "f/tests/amount".into(),
             body: "SET threads = 1; SELECT * FROM _wm_target.orders WHERE amount < 0".into(),
         }];
         let err = build_data_test_checks(&tests, &ctx_unpartitioned()).unwrap_err();
         assert!(err.contains("single SELECT"), "unexpected error: {err}");
+        assert!(
+            err.contains("found 2 statements"),
+            "unexpected error: {err}"
+        );
+        // the copyable example points at the internal target alias.
+        assert!(
+            err.contains("SELECT * FROM _wm_target.orders WHERE <condition>"),
+            "unexpected error: {err}"
+        );
+    }
+
+    #[test]
+    fn data_test_custom_rejects_non_select_body() {
+        // A write/DDL body can't be embedded as `FROM (<body>)`; the error must
+        // say so and teach the single-SELECT convention.
+        let tests = vec![DataTestResolved::Custom {
+            path: "f/tests/amount".into(),
+            body: "DELETE FROM _wm_target.orders WHERE amount < 0".into(),
+        }];
+        let err = build_data_test_checks(&tests, &ctx_unpartitioned()).unwrap_err();
+        assert!(err.contains("single SELECT"), "unexpected error: {err}");
+        assert!(
+            err.contains("SELECT * FROM _wm_target.orders WHERE <condition>"),
+            "unexpected error: {err}"
+        );
+    }
+
+    #[test]
+    fn data_test_custom_rejects_wrong_target_alias() {
+        // Referencing the target by its bare table name (not `_wm_target.<table>`)
+        // is the most common custom-test mistake — the runtime only attaches the
+        // freshly-materialized target under `_wm_target`, so the query would fail
+        // at runtime. Catch it at codegen with a self-teaching error.
+        let tests = vec![DataTestResolved::Custom {
+            path: "f/tests/amount".into(),
+            body: "SELECT * FROM orders WHERE amount < 0".into(),
+        }];
+        let err = build_data_test_checks(&tests, &ctx_unpartitioned()).unwrap_err();
+        assert!(err.contains("_wm_target"), "unexpected error: {err}");
+        assert!(
+            err.contains("SELECT * FROM _wm_target.orders WHERE <condition>"),
+            "unexpected error: {err}"
+        );
+    }
+
+    #[test]
+    fn data_test_custom_accepts_from_first_and_uppercased_alias() {
+        // DuckDB's FROM-first syntax is a valid Output, and the alias match is
+        // case-insensitive (SQL identifiers are), so this passes.
+        let tests = vec![DataTestResolved::Custom {
+            path: "f/tests/amount".into(),
+            body: "FROM _WM_TARGET.orders WHERE amount < 0".into(),
+        }];
+        let sql = build_data_test_checks(&tests, &ctx_unpartitioned()).unwrap();
+        assert!(sql.checks[0]
+            .probe
+            .contains("FROM (FROM _WM_TARGET.orders WHERE amount < 0) _wm_v"));
+    }
+
+    #[test]
+    fn data_test_custom_empty_body_teaches_shape() {
+        let tests = vec![DataTestResolved::Custom {
+            path: "f/tests/amount".into(),
+            body: "   \n-- just a comment\n".into(),
+        }];
+        let err = build_data_test_checks(&tests, &ctx_unpartitioned()).unwrap_err();
+        assert!(err.contains("empty test body"), "unexpected error: {err}");
+        assert!(
+            err.contains("SELECT * FROM _wm_target.orders WHERE <condition>"),
+            "unexpected error: {err}"
+        );
     }
 
     #[test]
@@ -1724,14 +2477,8 @@ mod tests {
     #[test]
     fn materialize_result_sql_embeds_data_tests_breakdown() {
         let checks = vec![
-            DataTestCheck {
-                name: "unique(order_id)".into(),
-                violating: "(SELECT count(*) AS v FROM q0)".into(),
-            },
-            DataTestCheck {
-                name: "custom(f/t)".into(),
-                violating: "(SELECT count(*) AS v FROM q1)".into(),
-            },
+            DataTestCheck { name: "unique(order_id)".into(), probe: "SELECT v, s FROM q0".into() },
+            DataTestCheck { name: "custom(f/t)".into(), probe: "SELECT v, s FROM q1".into() },
         ];
         let sql = materialize_result_sql(
             "_wm_target.orders",
@@ -1740,11 +2487,19 @@ mod tests {
             "'2026-06-19'",
             false,
             &checks,
+            None,
+        );
+        // each probe runs once as a one-row CTE; _wm_tr cross-joins them and
+        // the list-of-struct references the flattened count/sample columns.
+        assert!(sql.starts_with(
+            "WITH _wm_t0 AS (SELECT v, s FROM q0), _wm_t1 AS (SELECT v, s FROM q1), \
+             _wm_tr AS (SELECT _wm_t0.v AS c0, _wm_t0.s AS s0, _wm_t1.v AS c1, _wm_t1.s AS s1 \
+             FROM _wm_t0, _wm_t1)"
+        ));
+        assert!(sql.contains("[{'test': 'unique(order_id)', 'violating': c0, 'sample': s0}, "));
+        assert!(
+            sql.contains("{'test': 'custom(f/t)', 'violating': c1, 'sample': s1}] AS data_tests")
         );
-        // counts computed once in a CTE, referenced by the list-of-struct.
-        assert!(sql.starts_with("WITH _wm_tr AS (SELECT (SELECT count(*) AS v FROM q0) AS c0,"));
-        assert!(sql.contains("[{'test': 'unique(order_id)', 'violating': c0}, "));
-        assert!(sql.contains("{'test': 'custom(f/t)', 'violating': c1}] AS data_tests"));
         assert!(sql.contains("FROM _wm_tr;"));
         // no tests -> plain summary, no CTE / data_tests column.
         let plain = materialize_result_sql(
@@ -1754,6 +2509,7 @@ mod tests {
             "'x'",
             false,
             &[],
+            None,
         );
         assert!(plain.starts_with("SELECT 'ducklake://analytics/orders' AS materialized"));
         assert!(!plain.contains("data_tests"));
@@ -1780,6 +2536,7 @@ mod tests {
             "'2026-06-19'",
             true,
             &[],
+            None,
         );
         assert!(sql.contains(
             "FROM (DESCRIBE SELECT * FROM _wm_target.orders_daily) \
diff --git a/backend/parsers/windmill-parser/tests/fixtures/pipeline_annotations.json b/backend/parsers/windmill-parser/tests/fixtures/pipeline_annotations.json
index f7977239c1..cabfe20ddf 100644
--- a/backend/parsers/windmill-parser/tests/fixtures/pipeline_annotations.json
+++ b/backend/parsers/windmill-parser/tests/fixtures/pipeline_annotations.json
@@ -310,6 +310,43 @@
 			}
 		}
 	},
+	{
+		"name": "materialize on_schema_change=ignore opt",
+		"code": "// pipeline\n// materialize ducklake://analytics/orders on_schema_change=ignore\nSELECT 1;",
+		"expected": {
+			"in_pipeline": true,
+			"asset_triggers": [],
+			"native_triggers": [],
+			"partition": null,
+			"freshness": null,
+			"tag": null,
+			"retry": null,
+			"materialize": {
+				"target_kind": "ducklake",
+				"target_path": "analytics/orders",
+				"on_schema_change": "ignore"
+			}
+		}
+	},
+	{
+		"name": "materialize on_schema_change unknown value keeps warn default (fail-safe)",
+		"code": "// materialize ducklake://analytics/orders key=id on_schema_change=bogus\nSELECT 1;",
+		"expected": {
+			"in_pipeline": false,
+			"asset_triggers": [],
+			"native_triggers": [],
+			"partition": null,
+			"freshness": null,
+			"tag": null,
+			"retry": null,
+			"materialize": {
+				"target_kind": "ducklake",
+				"target_path": "analytics/orders",
+				"unique_key": "id",
+				"on_schema_change": "warn"
+			}
+		}
+	},
 	{
 		"name": "materialize key without history is plain merge (SCD1, not scd2)",
 		"code": "// materialize ducklake://analytics/dim key=id\nSELECT 1;",
@@ -702,5 +739,35 @@
 			"tag": null,
 			"retry": null
 		}
+	},
+	{
+		"name": "s3 triple-slash default-storage trigger canonicalizes to bare key",
+		"code": "// pipeline\n// on s3:///exports/x\nexport function main() {}",
+		"expected": {
+			"in_pipeline": true,
+			"asset_triggers": [
+				"s3object:exports/x"
+			],
+			"native_triggers": [],
+			"partition": null,
+			"freshness": null,
+			"tag": null,
+			"retry": null
+		}
+	},
+	{
+		"name": "s3 quad-slash trigger strips all leading slashes to the bare key",
+		"code": "// pipeline\n// on s3:////x\nexport function main() {}",
+		"expected": {
+			"in_pipeline": true,
+			"asset_triggers": [
+				"s3object:x"
+			],
+			"native_triggers": [],
+			"partition": null,
+			"freshness": null,
+			"tag": null,
+			"retry": null
+		}
 	}
 ]
diff --git a/backend/parsers/windmill-parser/tests/pipeline_annotations_parity.rs b/backend/parsers/windmill-parser/tests/pipeline_annotations_parity.rs
index 2df4acd2e4..7adb07b55c 100644
--- a/backend/parsers/windmill-parser/tests/pipeline_annotations_parity.rs
+++ b/backend/parsers/windmill-parser/tests/pipeline_annotations_parity.rs
@@ -71,6 +71,13 @@ struct ExpectedMaterialize {
     track: Vec<String>,
     #[serde(default)]
     close_deleted: bool,
+    // "warn" | "ignore"; absent === "warn" (the default).
+    #[serde(default = "default_on_schema_change")]
+    on_schema_change: String,
+}
+
+fn default_on_schema_change() -> String {
+    "warn".to_string()
 }
 
 #[derive(Deserialize)]
@@ -209,6 +216,16 @@ fn pipeline_annotation_fixtures_match() {
                     m.close_deleted, e.close_deleted,
                     "{ctx}: materialize close_deleted"
                 );
+                let osc = match m.on_schema_change {
+                    windmill_parser::asset_parser::OnSchemaChange::Warn => "warn",
+                    windmill_parser::asset_parser::OnSchemaChange::Ignore => "ignore",
+                    windmill_parser::asset_parser::OnSchemaChange::Fail => "fail",
+                    windmill_parser::asset_parser::OnSchemaChange::Sync => "sync",
+                };
+                assert_eq!(
+                    osc, e.on_schema_change,
+                    "{ctx}: materialize on_schema_change"
+                );
             }
             (got, want) => panic!(
                 "{ctx}: materialize mismatch — got {:?}, want present={}",
diff --git a/backend/src/monitor.rs b/backend/src/monitor.rs
index 817887eaad..60b4024c0a 100644
--- a/backend/src/monitor.rs
+++ b/backend/src/monitor.rs
@@ -178,6 +178,14 @@ lazy_static::lazy_static! {
     .and_then(|x| x.parse::<bool>().ok())
     .unwrap_or(false);
 
+    // Ops kill switch for the pipeline freshness watchdog (a background
+    // pusher — being able to stop it without a redeploy matters more than
+    // for read-only monitors).
+    pub static ref DISABLE_FRESHNESS_WATCHDOG: bool = std::env::var("DISABLE_FRESHNESS_WATCHDOG")
+    .ok()
+    .and_then(|x| x.parse::<bool>().ok())
+    .unwrap_or(false);
+
     pub static ref WORKERS_NAMES: Arc<RwLock<Vec<String>>> = Arc::new(RwLock::new(Vec::new()));
 
     static ref QUEUE_COUNT_TAGS: Arc<RwLock<Vec<String>>> = Arc::new(RwLock::new(Vec::new()));
@@ -2994,6 +3002,28 @@ pub async fn monitor_db(
         }
     };
 
+    // run every ~60s (2 iterations * 30s). Enterprise feature: the active
+    // `// freshness` backstop lives in windmill-queue's `freshness_watchdog`
+    // (`private`); OSS gets a no-op stub. Runtime-gated on an Enterprise
+    // license like the audit export above. Safe on concurrent servers — the
+    // watchdog claims per-script state rows atomically before pushing.
+    let pipeline_freshness_watchdog_f = async {
+        if server_mode
+            && !*DISABLE_FRESHNESS_WATCHDOG
+            && iteration.is_some()
+            && iteration.as_ref().unwrap().should_run(2)
+        {
+            if let Some(db) = conn.as_sql() {
+                if matches!(
+                    windmill_common::ee_oss::get_license_plan().await,
+                    windmill_common::ee_oss::LicensePlan::Enterprise
+                ) {
+                    windmill_queue::freshness_watchdog::tick(db).await;
+                }
+            }
+        }
+    };
+
     join!(
         expired_items_f,
         zombie_jobs_f,
@@ -3021,6 +3051,7 @@ pub async fn monitor_db(
         manage_audit_partitions_f,
         export_audit_logs_to_object_store_f,
         cleanup_scheduled_job_deletions_f,
+        pipeline_freshness_watchdog_f,
     );
 }
 
diff --git a/backend/tests/freshness_watchdog.rs b/backend/tests/freshness_watchdog.rs
new file mode 100644
index 0000000000..17851d0a1e
--- /dev/null
+++ b/backend/tests/freshness_watchdog.rs
@@ -0,0 +1,294 @@
+//! End-to-end tests for the pipeline freshness watchdog (Enterprise).
+//!
+//! `windmill_queue::freshness_watchdog::tick` is called directly against
+//! seeded `script` / `v2_job(_completed)` rows — no worker or API server is
+//! needed, since the watchdog's job ends at the push (the pushed job sitting
+//! in `v2_job_queue` is itself part of the assertions). Covers: staleness on
+//! never-ran and aged-out members, the fresh short-circuit + state reset,
+//! the in-flight suppression, the backoff claim, and the skip rules
+//! (partitioned, malformed window, non-pipeline scripts).
+
+#![cfg(feature = "private")]
+
+use sqlx::{Pool, Postgres};
+use windmill_queue::freshness_watchdog::tick;
+use windmill_test_utils::initialize_tracing;
+
+const WS: &str = "test-workspace";
+const PATH: &str = "u/test-user/freshness_producer";
+
+/// Seed a deployed pipeline-member script. Mirrors the deploy path's output:
+/// `auto_kind = 'pipeline'`, empty (non-NULL) lock so run-by-path resolution
+/// treats it as deployed, hash derived from path+content for uniqueness.
+async fn seed_pipeline_script(
+    db: &Pool<Postgres>,
+    path: &str,
+    content: &str,
+) -> anyhow::Result<()> {
+    let mut h = 0i64;
+    for b in path.bytes().chain(content.bytes()) {
+        h = h.wrapping_mul(31).wrapping_add(b as i64);
+    }
+    sqlx::query(
+        r#"INSERT INTO script (workspace_id, hash, path, summary, description, content,
+                                created_by, language, tag, lock, auto_kind)
+           VALUES ($1, $2, $3, '', '', $4, 'test-user', 'bash'::script_lang, 'bash', '', 'pipeline')
+           ON CONFLICT DO NOTHING"#,
+    )
+    .bind(WS)
+    .bind(h)
+    .bind(path)
+    .bind(content)
+    .execute(db)
+    .await?;
+    // Process-global deployed-script caches are keyed by (workspace, path) /
+    // (workspace, hash) and would leak between #[sqlx::test] isolated DBs
+    // that reuse both — resolve everything from this test's own DB.
+    windmill_common::DEPLOYED_SCRIPT_CACHE_DISABLED
+        .store(true, std::sync::atomic::Ordering::Relaxed);
+    Ok(())
+}
+
+/// Seed a completed root run of `path` that finished `age_s` seconds ago.
+async fn seed_completed_run(
+    db: &Pool<Postgres>,
+    path: &str,
+    age_s: i64,
+    success: bool,
+) -> anyhow::Result<()> {
+    let id = uuid::Uuid::new_v4();
+    sqlx::query(
+        r#"INSERT INTO v2_job (id, workspace_id, runnable_path, kind, created_at,
+                                created_by, permissioned_as, permissioned_as_email, tag)
+           VALUES ($1, $2, $3, 'script'::job_kind,
+                   now() - ($4::bigint::text || ' seconds')::interval,
+                   'test-user', 'u/test-user', 'test@windmill.dev', 'bash')"#,
+    )
+    .bind(id)
+    .bind(WS)
+    .bind(path)
+    .bind(age_s)
+    .execute(db)
+    .await?;
+    sqlx::query(
+        r#"INSERT INTO v2_job_completed (id, workspace_id, duration_ms, status, started_at, completed_at)
+           VALUES ($1, $2, 0, CASE WHEN $3 THEN 'success'::job_status ELSE 'failure'::job_status END,
+                   now() - ($4::bigint::text || ' seconds')::interval,
+                   now() - ($4::bigint::text || ' seconds')::interval)"#,
+    )
+    .bind(id)
+    .bind(WS)
+    .bind(success)
+    .bind(age_s)
+    .execute(db)
+    .await?;
+    Ok(())
+}
+
+/// Jobs the watchdog pushed: (path, created_by, args) rows attributed to
+/// `trigger_kind = 'freshness'`.
+async fn fetch_pushed(
+    db: &Pool<Postgres>,
+) -> anyhow::Result<Vec<(String, String, Option<serde_json::Value>)>> {
+    let rows = sqlx::query!(
+        r#"SELECT runnable_path AS "runnable_path!", created_by AS "created_by!",
+                  args AS "args: sqlx::types::Json<serde_json::Value>"
+             FROM v2_job
+             WHERE workspace_id = $1 AND trigger_kind = 'freshness'
+             ORDER BY created_at"#,
+        WS,
+    )
+    .fetch_all(db)
+    .await?;
+    Ok(rows
+        .into_iter()
+        .map(|r| (r.runnable_path, r.created_by, r.args.map(|a| a.0)))
+        .collect())
+}
+
+async fn state_row(db: &Pool<Postgres>, path: &str) -> anyhow::Result<Option<i32>> {
+    Ok(sqlx::query_scalar!(
+        "SELECT attempts FROM pipeline_freshness_state WHERE workspace_id = $1 AND script_path = $2",
+        WS,
+        path,
+    )
+    .fetch_optional(db)
+    .await?)
+}
+
+#[sqlx::test(fixtures("base"))]
+async fn never_ran_member_is_pushed_once(db: Pool<Postgres>) -> anyhow::Result<()> {
+    initialize_tracing().await;
+    seed_pipeline_script(&db, PATH, "# pipeline\n# freshness 30s\necho hi\n").await?;
+
+    tick(&db).await;
+
+    let pushed = fetch_pushed(&db).await?;
+    assert_eq!(pushed.len(), 1, "one watchdog push expected");
+    let (path, created_by, args) = &pushed[0];
+    assert_eq!(path, PATH);
+    assert_eq!(created_by, &format!("freshness-{PATH}"));
+    let args = args.as_ref().expect("args recorded");
+    assert_eq!(
+        args.get("_wmill_skip_asset_dispatch"),
+        Some(&serde_json::json!(true)),
+        "watchdog runs must not re-fire the cascade"
+    );
+    assert_eq!(
+        args.pointer("/trigger/kind"),
+        Some(&serde_json::json!("freshness"))
+    );
+    assert_eq!(state_row(&db, PATH).await?, Some(1), "claim row recorded");
+
+    // Second tick: the pushed job is queued-and-due, so the in-flight guard
+    // suppresses a duplicate regardless of backoff.
+    tick(&db).await;
+    assert_eq!(
+        fetch_pushed(&db).await?.len(),
+        1,
+        "no duplicate while queued"
+    );
+
+    // Simulate the queued job vanishing without a completion: the backoff
+    // claim (next_attempt_at in the future) now carries the suppression.
+    sqlx::query!("DELETE FROM v2_job_queue WHERE workspace_id = $1", WS)
+        .execute(&db)
+        .await?;
+    tick(&db).await;
+    assert_eq!(fetch_pushed(&db).await?.len(), 1, "backoff holds the retry");
+
+    // Force the backoff window open: the watchdog retries and escalates.
+    sqlx::query!(
+        "UPDATE pipeline_freshness_state SET next_attempt_at = now() - interval '1 second'
+         WHERE workspace_id = $1 AND script_path = $2",
+        WS,
+        PATH,
+    )
+    .execute(&db)
+    .await?;
+    tick(&db).await;
+    assert_eq!(fetch_pushed(&db).await?.len(), 2, "due retry pushed");
+    assert_eq!(state_row(&db, PATH).await?, Some(2), "attempts escalated");
+    Ok(())
+}
+
+#[sqlx::test(fixtures("base"))]
+async fn fresh_member_is_skipped_and_state_reset(db: Pool<Postgres>) -> anyhow::Result<()> {
+    initialize_tracing().await;
+    seed_pipeline_script(&db, PATH, "# pipeline\n# freshness 1h\necho hi\n").await?;
+    seed_completed_run(&db, PATH, 10, true).await?;
+    // Leftover backoff row from an earlier staleness episode.
+    sqlx::query!(
+        "INSERT INTO pipeline_freshness_state (workspace_id, script_path, attempts) VALUES ($1, $2, 3)",
+        WS,
+        PATH,
+    )
+    .execute(&db)
+    .await?;
+
+    tick(&db).await;
+
+    assert!(
+        fetch_pushed(&db).await?.is_empty(),
+        "fresh member not pushed"
+    );
+    assert_eq!(state_row(&db, PATH).await?, None, "backoff reset on fresh");
+    Ok(())
+}
+
+#[sqlx::test(fixtures("base"))]
+async fn aged_out_member_is_pushed(db: Pool<Postgres>) -> anyhow::Result<()> {
+    initialize_tracing().await;
+    seed_pipeline_script(&db, PATH, "# pipeline\n# freshness 1h\necho hi\n").await?;
+    // Old success outside the window + a recent failure: still stale.
+    seed_completed_run(&db, PATH, 7200, true).await?;
+    seed_completed_run(&db, PATH, 60, false).await?;
+
+    tick(&db).await;
+
+    assert_eq!(fetch_pushed(&db).await?.len(), 1, "aged-out member pushed");
+    Ok(())
+}
+
+#[sqlx::test(fixtures("base"))]
+async fn partitioned_malformed_and_plain_members_are_skipped(
+    db: Pool<Postgres>,
+) -> anyhow::Result<()> {
+    initialize_tracing().await;
+    // Partitioned: freshness means partition-gap detection, out of scope.
+    seed_pipeline_script(
+        &db,
+        "u/test-user/partitioned",
+        "# pipeline\n# partitioned daily\n# freshness 1h\necho hi\n",
+    )
+    .await?;
+    // Malformed window: fails safe to unwatched.
+    seed_pipeline_script(
+        &db,
+        "u/test-user/malformed",
+        "# pipeline\n# freshness soonish\necho hi\n",
+    )
+    .await?;
+    // Freshness only in prose (parser must reject; ILIKE prefilter passes).
+    seed_pipeline_script(
+        &db,
+        "u/test-user/prose",
+        "# pipeline\n# ensure freshness of data below\necho hi\n",
+    )
+    .await?;
+
+    tick(&db).await;
+
+    assert!(fetch_pushed(&db).await?.is_empty(), "no member is watched");
+    let rows = sqlx::query_scalar!(
+        r#"SELECT COUNT(*) AS "count!" FROM pipeline_freshness_state WHERE workspace_id = $1"#,
+        WS,
+    )
+    .fetch_one(&db)
+    .await?;
+    assert_eq!(rows, 0, "no state rows for unwatched members");
+    Ok(())
+}
+
+#[sqlx::test(fixtures("base"))]
+async fn archived_workspace_is_not_resurrected(db: Pool<Postgres>) -> anyhow::Result<()> {
+    initialize_tracing().await;
+    // Workspace archival stops all execution but keeps script rows for
+    // unarchival — the watchdog must not keep pushing runs there.
+    seed_pipeline_script(&db, PATH, "# pipeline\n# freshness 30s\necho hi\n").await?;
+    sqlx::query!("UPDATE workspace SET deleted = true WHERE id = $1", WS)
+        .execute(&db)
+        .await?;
+
+    tick(&db).await;
+
+    assert!(
+        fetch_pushed(&db).await?.is_empty(),
+        "no pushes into an archived workspace"
+    );
+    assert_eq!(
+        state_row(&db, PATH).await?,
+        None,
+        "no state bookkeeping either"
+    );
+    Ok(())
+}
+
+#[sqlx::test(fixtures("base"))]
+async fn state_of_unwatched_member_is_cleaned_up(db: Pool<Postgres>) -> anyhow::Result<()> {
+    initialize_tracing().await;
+    // A stale-bookkeeping row whose script no longer declares freshness
+    // (e.g. annotation removed and redeployed) must not survive the sweep.
+    sqlx::query!(
+        "INSERT INTO pipeline_freshness_state (workspace_id, script_path) VALUES ($1, $2)",
+        WS,
+        "u/test-user/gone",
+    )
+    .execute(&db)
+    .await?;
+
+    tick(&db).await;
+
+    assert_eq!(state_row(&db, "u/test-user/gone").await?, None);
+    Ok(())
+}
diff --git a/backend/windmill-ai/src/ai_bedrock.rs b/backend/windmill-ai/src/ai_bedrock.rs
index 8aa9addcae..02ab702d31 100644
--- a/backend/windmill-ai/src/ai_bedrock.rs
+++ b/backend/windmill-ai/src/ai_bedrock.rs
@@ -857,22 +857,91 @@ pub fn bedrock_stream_event_is_block_stop(event: &ConverseStreamOutput) -> bool
     matches!(event, ConverseStreamOutput::ContentBlockStop(_))
 }
 
-/// Convert accumulated streaming tool calls to OpenAI format
-pub fn streaming_tool_calls_to_openai(tool_calls: Vec<StreamingToolCall>) -> Vec<OpenAIToolCall> {
+/// Convert accumulated streaming tool calls to OpenAI format.
+///
+/// When thinking is enabled, `reasoning` carries the turn's Claude reasoning
+/// block; it is attached to the first tool call so the next request replays it
+/// before `toolUse` (required by Claude when thinking is enabled — see
+/// [`convert_message`]). When `None` (thinking off), tool calls carry no extra
+/// content, byte-identical to the pre-feature output.
+pub fn streaming_tool_calls_to_openai(
+    tool_calls: Vec<StreamingToolCall>,
+    reasoning: Option<crate::ai_types::BedrockExtraContent>,
+) -> Vec<OpenAIToolCall> {
+    let mut reasoning = reasoning;
     tool_calls
         .into_iter()
-        .map(|tc| OpenAIToolCall {
-            id: tc.id,
-            function: OpenAIFunction { name: tc.name, arguments: tc.arguments },
-            r#type: FUNCTION_TYPE.to_string(),
-            // Worker agent requests never enable thinking, so there is no
-            // reasoning block to round-trip here (the chat proxy path does —
-            // see providers/bedrock.rs).
-            extra_content: None,
+        .map(|tc| {
+            // `take` so only the first tool call carries the reasoning block.
+            let extra_content = reasoning.take().map(|block| crate::ai_types::ExtraContent {
+                bedrock: Some(block),
+                ..Default::default()
+            });
+            OpenAIToolCall {
+                id: tc.id,
+                function: OpenAIFunction { name: tc.name, arguments: tc.arguments },
+                r#type: FUNCTION_TYPE.to_string(),
+                extra_content,
+            }
         })
         .collect()
 }
 
+/// Fold a Bedrock `ReasoningContent` stream delta into an accumulating reasoning
+/// block (text + signature, or redacted bytes). Returns the readable text delta
+/// when the event carried one, so the caller can stream it as reasoning content.
+/// Mirrors the proxy path's accumulation in `providers/bedrock.rs`.
+pub fn bedrock_stream_event_to_reasoning_delta(
+    event: &ConverseStreamOutput,
+    reasoning: &mut Option<crate::ai_types::BedrockExtraContent>,
+) -> Option<String> {
+    let ConverseStreamOutput::ContentBlockDelta(delta_event) = event else {
+        return None;
+    };
+    let aws_sdk_bedrockruntime::types::ContentBlockDelta::ReasoningContent(rc) =
+        delta_event.delta()?
+    else {
+        return None;
+    };
+
+    let entry = reasoning.get_or_insert_with(Default::default);
+    match rc {
+        aws_sdk_bedrockruntime::types::ReasoningContentBlockDelta::Text(text) => {
+            entry
+                .reasoning_text
+                .get_or_insert_with(String::new)
+                .push_str(text);
+            Some(text.clone())
+        }
+        aws_sdk_bedrockruntime::types::ReasoningContentBlockDelta::Signature(signature) => {
+            entry
+                .signature
+                .get_or_insert_with(String::new)
+                .push_str(signature);
+            None
+        }
+        aws_sdk_bedrockruntime::types::ReasoningContentBlockDelta::RedactedContent(blob) => {
+            // Base64 of concatenated fragments != concatenated base64 fragments,
+            // so accumulate raw bytes and re-encode.
+            let mut bytes = entry
+                .redacted_content
+                .as_deref()
+                .and_then(|existing| {
+                    base64::Engine::decode(&base64::engine::general_purpose::STANDARD, existing)
+                        .ok()
+                })
+                .unwrap_or_default();
+            bytes.extend_from_slice(blob.as_ref());
+            entry.redacted_content = Some(base64::Engine::encode(
+                &base64::engine::general_purpose::STANDARD,
+                bytes,
+            ));
+            None
+        }
+        _ => None,
+    }
+}
+
 // ============================================================================
 // Tool Configuration Builder
 // ============================================================================
@@ -1028,6 +1097,101 @@ mod tests {
         assert!(matches!(&content[1], ContentBlock::ToolUse(_)));
     }
 
+    #[test]
+    fn streaming_tool_calls_to_openai_attaches_reasoning_to_first_call_only() {
+        let calls = vec![
+            StreamingToolCall {
+                id: "call_1".to_string(),
+                name: "a".to_string(),
+                arguments: "{}".to_string(),
+            },
+            StreamingToolCall {
+                id: "call_2".to_string(),
+                name: "b".to_string(),
+                arguments: "{}".to_string(),
+            },
+        ];
+        let reasoning = crate::ai_types::BedrockExtraContent {
+            reasoning_text: Some("thinking".to_string()),
+            signature: Some("sig".to_string()),
+            redacted_content: None,
+        };
+
+        let openai = streaming_tool_calls_to_openai(calls, Some(reasoning));
+
+        let with_reasoning = openai
+            .iter()
+            .filter(|tc| {
+                tc.extra_content
+                    .as_ref()
+                    .and_then(|e| e.bedrock.as_ref())
+                    .is_some()
+            })
+            .count();
+        assert_eq!(
+            with_reasoning, 1,
+            "exactly one tool call carries the reasoning block"
+        );
+        let block = openai[0]
+            .extra_content
+            .as_ref()
+            .and_then(|e| e.bedrock.as_ref())
+            .expect("first tool call carries reasoning");
+        assert_eq!(block.reasoning_text.as_deref(), Some("thinking"));
+        assert_eq!(block.signature.as_deref(), Some("sig"));
+    }
+
+    #[test]
+    fn streaming_tool_calls_to_openai_without_reasoning_has_no_extra_content() {
+        let calls = vec![StreamingToolCall {
+            id: "call_1".to_string(),
+            name: "a".to_string(),
+            arguments: "{}".to_string(),
+        }];
+
+        let openai = streaming_tool_calls_to_openai(calls, None);
+
+        assert!(openai[0].extra_content.is_none());
+    }
+
+    #[test]
+    fn bedrock_reasoning_delta_accumulates_text_and_signature() {
+        use aws_sdk_bedrockruntime::types::{
+            ContentBlockDelta, ContentBlockDeltaEvent, ConverseStreamOutput,
+            ReasoningContentBlockDelta,
+        };
+
+        let mut reasoning = None;
+        let text_event = ConverseStreamOutput::ContentBlockDelta(
+            ContentBlockDeltaEvent::builder()
+                .content_block_index(0)
+                .delta(ContentBlockDelta::ReasoningContent(
+                    ReasoningContentBlockDelta::Text("let me ".to_string()),
+                ))
+                .build()
+                .unwrap(),
+        );
+        assert_eq!(
+            bedrock_stream_event_to_reasoning_delta(&text_event, &mut reasoning).as_deref(),
+            Some("let me ")
+        );
+
+        let sig_event = ConverseStreamOutput::ContentBlockDelta(
+            ContentBlockDeltaEvent::builder()
+                .content_block_index(0)
+                .delta(ContentBlockDelta::ReasoningContent(
+                    ReasoningContentBlockDelta::Signature("sig".to_string()),
+                ))
+                .build()
+                .unwrap(),
+        );
+        assert!(bedrock_stream_event_to_reasoning_delta(&sig_event, &mut reasoning).is_none());
+
+        let block = reasoning.expect("reasoning accumulated");
+        assert_eq!(block.reasoning_text.as_deref(), Some("let me "));
+        assert_eq!(block.signature.as_deref(), Some("sig"));
+    }
+
     #[test]
     fn openai_messages_to_bedrock_skips_cache_points_when_disabled() {
         let messages = vec![
diff --git a/backend/windmill-ai/src/ai_google.rs b/backend/windmill-ai/src/ai_google.rs
index 94d3ef65e0..4374cb8628 100644
--- a/backend/windmill-ai/src/ai_google.rs
+++ b/backend/windmill-ai/src/ai_google.rs
@@ -312,7 +312,7 @@ impl GeminiToolCallEvent {
     pub fn to_extra_content(&self) -> Option<ExtraContent> {
         self.thought_signature.as_ref().map(|sig| ExtraContent {
             google: Some(GoogleExtraContent { thought_signature: Some(sig.clone()) }),
-            bedrock: None,
+            ..Default::default()
         })
     }
 }
@@ -1001,10 +1001,8 @@ mod tests {
 
     #[test]
     fn gemini_streaming_without_usage_emits_no_usage_chunk() {
-        let parsed = GeminiParsedEvent {
-            text: Some("the answer".to_string()),
-            ..Default::default()
-        };
+        let parsed =
+            GeminiParsedEvent { text: Some("the answer".to_string()), ..Default::default() };
 
         let mut tool_call_index = 0;
         let chunks = gemini_event_to_openai_sse_chunks(
diff --git a/backend/windmill-ai/src/ai_types.rs b/backend/windmill-ai/src/ai_types.rs
index c6f171daf3..b80e237920 100644
--- a/backend/windmill-ai/src/ai_types.rs
+++ b/backend/windmill-ai/src/ai_types.rs
@@ -118,6 +118,22 @@ pub struct BedrockExtraContent {
     pub redacted_content: Option<String>,
 }
 
+/// Native-Anthropic reasoning block emitted in the same assistant turn as a
+/// tool call. Like Bedrock, Anthropic requires the thinking block (text +
+/// unmodified signature, or redacted bytes) to precede `tool_use` on replay when
+/// thinking is enabled, so it is round-tripped through the OpenAI-shaped tool call.
+#[derive(Deserialize, Serialize, Clone, Debug, Default)]
+pub struct AnthropicExtraContent {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub thinking: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub signature: Option<String>,
+    /// Base64 `data` of a redacted (encrypted) thinking block, when the provider
+    /// returned one instead of readable text.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub redacted_thinking: Option<String>,
+}
+
 /// Extra content for provider-specific metadata (e.g., Google thought signatures)
 #[derive(Deserialize, Serialize, Clone, Debug, Default)]
 pub struct ExtraContent {
@@ -125,6 +141,8 @@ pub struct ExtraContent {
     pub google: Option<GoogleExtraContent>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub bedrock: Option<BedrockExtraContent>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub anthropic: Option<AnthropicExtraContent>,
 }
 
 #[derive(Deserialize, Serialize, Clone, Debug)]
diff --git a/backend/windmill-ai/src/providers/anthropic.rs b/backend/windmill-ai/src/providers/anthropic.rs
index c2064f2029..d71de2f35f 100644
--- a/backend/windmill-ai/src/providers/anthropic.rs
+++ b/backend/windmill-ai/src/providers/anthropic.rs
@@ -92,6 +92,10 @@ pub enum AnthropicRequestContent {
         #[serde(skip_serializing_if = "Option::is_none")]
         cache_control: Option<CacheControl>,
     },
+    #[serde(rename = "thinking")]
+    Thinking { thinking: String, signature: String },
+    #[serde(rename = "redacted_thinking")]
+    RedactedThinking { data: String },
     #[serde(rename = "image")]
     Image { source: AnthropicBase64Source },
     #[serde(rename = "document")]
@@ -131,6 +135,26 @@ pub struct AnthropicMessage {
     pub content: Vec<AnthropicRequestContent>,
 }
 
+/// Adaptive thinking config for Anthropic native API. `summarized` display
+/// matches the chat proxy path (renders a summarized thinking stream).
+#[derive(Serialize, Debug)]
+pub struct AnthropicThinking {
+    pub r#type: &'static str,
+    pub display: &'static str,
+}
+
+impl AnthropicThinking {
+    fn adaptive() -> Self {
+        Self { r#type: "adaptive", display: "summarized" }
+    }
+}
+
+/// Carries the reasoning effort token alongside adaptive thinking.
+#[derive(Serialize, Debug)]
+pub struct AnthropicOutputConfig {
+    pub effort: String,
+}
+
 /// Anthropic-specific request structure for standard API
 #[derive(Serialize)]
 pub struct AnthropicRequest<'a> {
@@ -145,6 +169,10 @@ pub struct AnthropicRequest<'a> {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub temperature: Option<f32>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    pub thinking: Option<AnthropicThinking>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub output_config: Option<AnthropicOutputConfig>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub max_tokens: Option<u32>,
     pub stream: bool,
 }
@@ -166,6 +194,10 @@ pub struct AnthropicVertexRequest {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub temperature: Option<f32>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    pub thinking: Option<AnthropicThinking>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub output_config: Option<AnthropicOutputConfig>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub max_tokens: Option<u32>,
     pub stream: bool,
 }
@@ -189,6 +221,25 @@ fn convert_messages_to_anthropic(messages: &[OpenAIMessage]) -> Vec<AnthropicMes
             "assistant" => {
                 let mut content: Vec<AnthropicRequestContent> = Vec::new();
 
+                // Replay the turn's thinking block first: when thinking is enabled,
+                // Claude requires the thinking block (with its unmodified signature)
+                // to precede tool_use in the assistant turn it was emitted in. It is
+                // round-tripped on the tool call's extra_content (see AnthropicExtraContent).
+                if let Some(reasoning) = msg
+                    .tool_calls
+                    .as_ref()
+                    .and_then(|tcs| {
+                        tcs.iter().find_map(|tc| {
+                            tc.extra_content
+                                .as_ref()
+                                .and_then(|ec| ec.anthropic.as_ref())
+                        })
+                    })
+                    .and_then(anthropic_reasoning_block_from_extra)
+                {
+                    content.push(reasoning);
+                }
+
                 // Add text content if present
                 if let Some(ref c) = msg.content {
                     let text = extract_text_content(c);
@@ -246,6 +297,25 @@ fn convert_messages_to_anthropic(messages: &[OpenAIMessage]) -> Vec<AnthropicMes
     result
 }
 
+/// Rebuild an Anthropic thinking content block from the round-tripped
+/// [`AnthropicExtraContent`](crate::ai_types::AnthropicExtraContent). Returns
+/// None when there is no replayable block (thinking text without a signature is
+/// rejected by Anthropic, so it is dropped rather than sent).
+fn anthropic_reasoning_block_from_extra(
+    extra: &crate::ai_types::AnthropicExtraContent,
+) -> Option<AnthropicRequestContent> {
+    if let Some(data) = extra.redacted_thinking.as_deref() {
+        return Some(AnthropicRequestContent::RedactedThinking { data: data.to_string() });
+    }
+    match (extra.thinking.as_deref(), extra.signature.as_deref()) {
+        (Some(thinking), Some(signature)) => Some(AnthropicRequestContent::Thinking {
+            thinking: thinking.to_string(),
+            signature: signature.to_string(),
+        }),
+        _ => None,
+    }
+}
+
 /// Convert OpenAI content to Anthropic content blocks
 fn convert_content_to_anthropic(content: &Option<OpenAIContent>) -> Vec<AnthropicRequestContent> {
     let Some(content) = content else {
@@ -591,6 +661,17 @@ impl AnthropicQueryBuilder {
             }
         }
 
+        // Adaptive thinking rejects sampling params, so drop temperature when
+        // reasoning is on (Anthropic returns a hard 400 otherwise).
+        let (thinking, output_config, temperature) = match args.reasoning_effort {
+            Some(effort) => (
+                Some(AnthropicThinking::adaptive()),
+                Some(AnthropicOutputConfig { effort: effort.to_string() }),
+                None,
+            ),
+            None => (None, None, args.temperature),
+        };
+
         // Build request based on platform
         if self.is_vertex() {
             // For Vertex AI: no model field, anthropic_version in body
@@ -600,7 +681,9 @@ impl AnthropicQueryBuilder {
                 messages: anthropic_messages,
                 tools: tools_option,
                 tool_choice,
-                temperature: args.temperature,
+                temperature,
+                thinking,
+                output_config,
                 max_tokens,
                 stream: true,
             };
@@ -614,7 +697,9 @@ impl AnthropicQueryBuilder {
                 messages: anthropic_messages,
                 tools: tools_option,
                 tool_choice,
-                temperature: args.temperature,
+                temperature,
+                thinking,
+                output_config,
                 max_tokens,
                 stream: true,
             };
@@ -843,6 +928,123 @@ mod tests {
         assert!(has_header(&request.headers, "anthropic-beta", "some-beta"));
     }
 
+    #[test]
+    fn convert_messages_replays_thinking_block_before_tool_use() {
+        let tool_call = crate::ai_types::OpenAIToolCall {
+            id: "call_1".to_string(),
+            function: crate::ai_types::OpenAIFunction {
+                name: "lookup".to_string(),
+                arguments: "{}".to_string(),
+            },
+            r#type: "function".to_string(),
+            extra_content: Some(crate::ai_types::ExtraContent {
+                anthropic: Some(crate::ai_types::AnthropicExtraContent {
+                    thinking: Some("let me think".to_string()),
+                    signature: Some("sig-abc".to_string()),
+                    redacted_thinking: None,
+                }),
+                ..Default::default()
+            }),
+        };
+        let assistant = OpenAIMessage {
+            role: "assistant".to_string(),
+            tool_calls: Some(vec![tool_call]),
+            ..Default::default()
+        };
+
+        let messages = convert_messages_to_anthropic(&[assistant]);
+        let content = &messages[0].content;
+        match &content[0] {
+            AnthropicRequestContent::Thinking { thinking, signature } => {
+                assert_eq!(thinking, "let me think");
+                assert_eq!(signature, "sig-abc");
+            }
+            other => panic!("expected thinking block first, got {:?}", other),
+        }
+        assert!(matches!(
+            &content[1],
+            AnthropicRequestContent::ToolUse { .. }
+        ));
+    }
+
+    #[test]
+    fn convert_messages_drops_thinking_without_signature() {
+        let tool_call = crate::ai_types::OpenAIToolCall {
+            id: "call_1".to_string(),
+            function: crate::ai_types::OpenAIFunction {
+                name: "lookup".to_string(),
+                arguments: "{}".to_string(),
+            },
+            r#type: "function".to_string(),
+            extra_content: Some(crate::ai_types::ExtraContent {
+                anthropic: Some(crate::ai_types::AnthropicExtraContent {
+                    thinking: Some("unsigned".to_string()),
+                    signature: None,
+                    redacted_thinking: None,
+                }),
+                ..Default::default()
+            }),
+        };
+        let assistant = OpenAIMessage {
+            role: "assistant".to_string(),
+            tool_calls: Some(vec![tool_call]),
+            ..Default::default()
+        };
+
+        let messages = convert_messages_to_anthropic(&[assistant]);
+        // An unsigned thinking block can't be replayed, so only tool_use remains.
+        assert!(matches!(
+            messages[0].content[0],
+            AnthropicRequestContent::ToolUse { .. }
+        ));
+    }
+
+    #[test]
+    fn anthropic_request_serializes_adaptive_thinking_without_temperature() {
+        let request = AnthropicRequest {
+            model: "claude-opus-4-8",
+            system: None,
+            messages: vec![],
+            tools: None,
+            tool_choice: None,
+            temperature: None,
+            thinking: Some(AnthropicThinking::adaptive()),
+            output_config: Some(AnthropicOutputConfig { effort: "high".to_string() }),
+            max_tokens: Some(64000),
+            stream: true,
+        };
+
+        let body: serde_json::Value =
+            serde_json::from_str(&serde_json::to_string(&request).unwrap()).unwrap();
+        assert_eq!(body["thinking"]["type"], "adaptive");
+        assert_eq!(body["thinking"]["display"], "summarized");
+        assert_eq!(body["output_config"]["effort"], "high");
+        // Sampling params are rejected alongside adaptive thinking.
+        assert!(body.get("temperature").is_none());
+    }
+
+    #[test]
+    fn anthropic_request_omits_thinking_when_reasoning_off() {
+        let request = AnthropicRequest {
+            model: "claude-opus-4-8",
+            system: None,
+            messages: vec![],
+            tools: None,
+            tool_choice: None,
+            temperature: Some(0.5),
+            thinking: None,
+            output_config: None,
+            max_tokens: Some(64000),
+            stream: true,
+        };
+
+        let body: serde_json::Value =
+            serde_json::from_str(&serde_json::to_string(&request).unwrap()).unwrap();
+        assert!(body.get("thinking").is_none());
+        assert!(body.get("output_config").is_none());
+        assert_eq!(body["temperature"], 0.5);
+    }
+
     #[test]
     fn rejects_vertex_proxy_request_without_model() {
         let credentials = credentials(AIPlatform::GoogleVertexAi);
diff --git a/backend/windmill-ai/src/providers/bedrock.rs b/backend/windmill-ai/src/providers/bedrock.rs
index ddc5f33998..4405a50dcb 100644
--- a/backend/windmill-ai/src/providers/bedrock.rs
+++ b/backend/windmill-ai/src/providers/bedrock.rs
@@ -9,10 +9,10 @@
 use crate::{
     ai_bedrock::{
         bedrock_model_supports_prompt_caching, bedrock_stream_event_is_block_stop,
-        bedrock_stream_event_to_text, bedrock_stream_event_to_tool_delta,
-        bedrock_stream_event_to_tool_delta_with_block_index, bedrock_stream_event_to_tool_start,
-        bedrock_stream_event_to_tool_start_with_block_index, build_tool_config,
-        create_inference_config, format_bedrock_error, json_to_document,
+        bedrock_stream_event_to_reasoning_delta, bedrock_stream_event_to_text,
+        bedrock_stream_event_to_tool_delta, bedrock_stream_event_to_tool_delta_with_block_index,
+        bedrock_stream_event_to_tool_start, bedrock_stream_event_to_tool_start_with_block_index,
+        build_tool_config, create_inference_config, format_bedrock_error, json_to_document,
         openai_messages_to_bedrock, streaming_tool_calls_to_openai, BearerTokenProvider,
         BedrockClient, StreamingToolCall,
     },
@@ -641,57 +641,13 @@ fn bedrock_sse_chunks_for_event(
 
 /// Fold a `ReasoningContent` stream delta into the state's pending reasoning
 /// block. Returns the text delta (for a `reasoning_content` SSE chunk) when the
-/// event carried readable reasoning text.
+/// event carried readable reasoning text. Shares the worker path's folding so
+/// the two never drift.
 fn accumulate_reasoning_delta(
     event: &aws_sdk_bedrockruntime::types::ConverseStreamOutput,
     state: &mut BedrockSseStreamState,
 ) -> Option<String> {
-    let aws_sdk_bedrockruntime::types::ConverseStreamOutput::ContentBlockDelta(delta_event) = event
-    else {
-        return None;
-    };
-    let aws_sdk_bedrockruntime::types::ContentBlockDelta::ReasoningContent(reasoning) =
-        delta_event.delta()?
-    else {
-        return None;
-    };
-
-    let entry = state.reasoning.get_or_insert_with(Default::default);
-    match reasoning {
-        aws_sdk_bedrockruntime::types::ReasoningContentBlockDelta::Text(text) => {
-            entry
-                .reasoning_text
-                .get_or_insert_with(String::new)
-                .push_str(text);
-            Some(text.clone())
-        }
-        aws_sdk_bedrockruntime::types::ReasoningContentBlockDelta::Signature(signature) => {
-            entry
-                .signature
-                .get_or_insert_with(String::new)
-                .push_str(signature);
-            None
-        }
-        aws_sdk_bedrockruntime::types::ReasoningContentBlockDelta::RedactedContent(blob) => {
-            // Base64 of concatenated fragments != concatenated base64 fragments,
-            // so accumulate raw bytes and re-encode.
-            let mut bytes = entry
-                .redacted_content
-                .as_deref()
-                .and_then(|existing| {
-                    base64::Engine::decode(&base64::engine::general_purpose::STANDARD, existing)
-                        .ok()
-                })
-                .unwrap_or_default();
-            bytes.extend_from_slice(blob.as_ref());
-            entry.redacted_content = Some(base64::Engine::encode(
-                &base64::engine::general_purpose::STANDARD,
-                bytes,
-            ));
-            None
-        }
-        _ => None,
-    }
+    bedrock_stream_event_to_reasoning_delta(event, &mut state.reasoning)
 }
 
 async fn handle_bedrock_sdk_non_streaming(
@@ -942,6 +898,7 @@ impl BedrockQueryBuilder {
         tools: Option<&[ToolDef]>,
         model: &str,
         temperature: Option<f32>,
+        reasoning_effort: Option<&str>,
         max_tokens: Option<u32>,
         api_key: &str,
         region: &str,
@@ -977,6 +934,9 @@ impl BedrockQueryBuilder {
         let (bedrock_messages, system_prompts) =
             openai_messages_to_bedrock(&prepared_messages, enable_prompt_caching)?;
 
+        // Adaptive thinking rejects sampling params; drop temperature when reasoning is on.
+        let temperature = reasoning_effort.is_none().then_some(temperature).flatten();
+
         // Build inference configuration using shared helper
         let inference_config = create_inference_config(temperature, max_tokens.map(|t| t as i32));
 
@@ -994,6 +954,7 @@ impl BedrockQueryBuilder {
             system_prompts,
             inference_config,
             tool_config,
+            reasoning_effort,
             stream_event_sink,
         )
         .await
@@ -1008,6 +969,7 @@ impl BedrockQueryBuilder {
         system_prompts: Vec<aws_sdk_bedrockruntime::types::SystemContentBlock>,
         inference_config: Option<aws_sdk_bedrockruntime::types::InferenceConfiguration>,
         tool_config: Option<aws_sdk_bedrockruntime::types::ToolConfiguration>,
+        reasoning_effort: Option<&str>,
         stream_event_sink: Option<Box<dyn StreamEventSink>>,
     ) -> Result<ParsedResponse, Error> {
         tracing::debug!(
@@ -1035,6 +997,11 @@ impl BedrockQueryBuilder {
             request_builder = request_builder.set_tool_config(Some(config));
         }
 
+        if let Some(effort) = reasoning_effort {
+            request_builder =
+                request_builder.additional_model_request_fields(bedrock_thinking_fields(effort));
+        }
+
         let mut stream = request_builder
             .send()
             .await
@@ -1053,11 +1020,32 @@ impl BedrockQueryBuilder {
         let mut accumulated_tool_calls: HashMap<String, StreamingToolCall> = HashMap::new();
         let mut current_tool_use_id: Option<String> = None;
         let mut usage: Option<TokenUsage> = None;
+        // Claude reasoning block for the turn (only populated when thinking is on),
+        // attached to the first tool call for replay before toolUse.
+        let mut reasoning: Option<crate::ai_types::BedrockExtraContent> = None;
 
         // Process stream events using shared parsing functions
         loop {
             match stream.recv().await {
                 Ok(Some(event)) => {
+                    // Fold reasoning deltas into the turn's reasoning block (for
+                    // replay before toolUse, required by Claude when thinking is
+                    // on) and stream the readable summary as a thinking affordance.
+                    if let Some(reasoning_delta) =
+                        bedrock_stream_event_to_reasoning_delta(&event, &mut reasoning)
+                    {
+                        if let Some(processor) = stream_event_sink.as_ref() {
+                            processor
+                                .send(
+                                    StreamingEvent::ReasoningTokenDelta {
+                                        content: reasoning_delta,
+                                    },
+                                    &mut events_str,
+                                )
+                                .await?;
+                        }
+                    }
+
                     // Handle tool use start using shared parser
                     if let Some(tool_call) = bedrock_stream_event_to_tool_start(&event) {
                         current_tool_use_id = Some(tool_call.id.clone());
@@ -1143,8 +1131,10 @@ impl BedrockQueryBuilder {
             Some(accumulated_text)
         };
 
-        let tool_calls =
-            streaming_tool_calls_to_openai(accumulated_tool_calls.into_values().collect());
+        let tool_calls = streaming_tool_calls_to_openai(
+            accumulated_tool_calls.into_values().collect(),
+            reasoning,
+        );
 
         Ok(ParsedResponse::Text {
             content,
diff --git a/backend/windmill-ai/src/providers/google_ai.rs b/backend/windmill-ai/src/providers/google_ai.rs
index 650e11c0c7..21428903fa 100644
--- a/backend/windmill-ai/src/providers/google_ai.rs
+++ b/backend/windmill-ai/src/providers/google_ai.rs
@@ -153,13 +153,18 @@ impl GoogleAIQueryBuilder {
             (None, None)
         };
 
+        // Map the effort token onto Gemini's native thinking controls; without
+        // one, leave provider defaults untouched.
+        let thinking_config = args
+            .reasoning_effort
+            .map(|effort| gemini_thinking_config(args.model, effort));
+
         build_gemini_generation_config(
             args.temperature,
             args.max_tokens,
             response_mime_type,
             response_schema,
-            // Worker AI-agent requests carry no reasoning knob; keep provider defaults.
-            None,
+            thinking_config,
         )
     }
 }
diff --git a/backend/windmill-ai/src/providers/openai.rs b/backend/windmill-ai/src/providers/openai.rs
index efd7229ebb..bdb882679b 100644
--- a/backend/windmill-ai/src/providers/openai.rs
+++ b/backend/windmill-ai/src/providers/openai.rs
@@ -192,6 +192,15 @@ pub struct ResponsesApiTextFormat {
     pub format: ResponsesApiTextFormatConfig,
 }
 
+/// Reasoning config for the Responses API (`reasoning: { effort }`).
+/// The summary is intentionally not requested, mirroring the copilot chat: OpenAI
+/// gates reasoning summaries behind organization verification, so asking for one
+/// would fail the request for unverified orgs.
+#[derive(Serialize)]
+pub struct ResponsesApiReasoning {
+    pub effort: String,
+}
+
 #[derive(Serialize)]
 pub struct ResponsesApiRequest<'a> {
     pub model: &'a str,
@@ -204,6 +213,8 @@ pub struct ResponsesApiRequest<'a> {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub temperature: Option<f32>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    pub reasoning: Option<ResponsesApiReasoning>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub max_output_tokens: Option<u32>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub text: Option<ResponsesApiTextFormat>,
@@ -409,6 +420,9 @@ impl OpenAIQueryBuilder {
             tools,
             stream: Some(true),
             temperature: args.temperature,
+            reasoning: args
+                .reasoning_effort
+                .map(|effort| ResponsesApiReasoning { effort: effort.to_string() }),
             max_output_tokens: args.max_tokens,
             text,
         };
@@ -464,6 +478,7 @@ impl OpenAIQueryBuilder {
             tools,
             stream: None, // Image generation doesn't use streaming
             temperature: args.temperature,
+            reasoning: None, // Image generation models don't take a reasoning effort
             max_output_tokens: args.max_tokens,
             text: None, // No structured output for image generation
         };
diff --git a/backend/windmill-ai/src/providers/other.rs b/backend/windmill-ai/src/providers/other.rs
index 7b4dab5ab5..f641daec64 100644
--- a/backend/windmill-ai/src/providers/other.rs
+++ b/backend/windmill-ai/src/providers/other.rs
@@ -35,6 +35,12 @@ pub struct OpenAICompletionRequest<'a> {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub temperature: Option<f32>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    pub reasoning_effort: Option<&'a str>,
+    /// DeepSeek disables reasoning via a `thinking` object rather than an effort
+    /// token (`reasoning_effort: "none"` is rejected by their API).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub thinking: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub max_completion_tokens: Option<u32>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub response_format: Option<ResponseFormat>,
@@ -51,6 +57,32 @@ pub struct BuiltRequests {
     pub without_usage: String,
 }
 
+/// Provider-specific reasoning translation for OpenAI-compatible providers,
+/// mirroring the chat proxy's `applyReasoningToConfig`. Returns the effort token
+/// to send, an optional `thinking` object, and the temperature to keep:
+/// - DeepSeek disables reasoning via `thinking: {type: disabled}` (the effort
+///   token `"none"` is rejected by their API).
+/// - Mistral rejects sampling params when reasoning is on (greedy sampling
+///   requires `top_p == 1`), so temperature is dropped.
+fn provider_reasoning_fields<'a>(
+    provider: &AIProvider,
+    reasoning_effort: Option<&'a str>,
+    temperature: Option<f32>,
+) -> (Option<&'a str>, Option<serde_json::Value>, Option<f32>) {
+    let (effort, thinking) = match provider {
+        AIProvider::DeepSeek if reasoning_effort == Some("none") => {
+            (None, Some(serde_json::json!({ "type": "disabled" })))
+        }
+        _ => (reasoning_effort, None),
+    };
+    let temperature = if *provider == AIProvider::Mistral && reasoning_effort.is_some() {
+        None
+    } else {
+        temperature
+    };
+    (effort, thinking, temperature)
+}
+
 /// Query builder for providers using the OpenAI-compatible completion endpoint
 /// (Mistral, DeepSeek, Groq, TogetherAI, CustomAI, etc.)
 pub struct OtherQueryBuilder {
@@ -109,12 +141,17 @@ impl OtherQueryBuilder {
             None
         };
 
+        let (reasoning_effort, thinking, temperature) =
+            provider_reasoning_fields(&self.provider_kind, args.reasoning_effort, args.temperature);
+
         // Build request with stream_options for usage tracking
         let request_with_usage = OpenAICompletionRequest {
             model: args.model,
             messages: &prepared_messages,
             tools: args.tools,
-            temperature: args.temperature,
+            temperature,
+            reasoning_effort,
+            thinking: thinking.clone(),
             max_completion_tokens: args.max_tokens,
             response_format: response_format.clone(),
             tool_choice: tool_choice.clone(),
@@ -127,7 +164,9 @@ impl OtherQueryBuilder {
             model: args.model,
             messages: &prepared_messages,
             tools: args.tools,
-            temperature: args.temperature,
+            temperature,
+            reasoning_effort,
+            thinking,
             max_completion_tokens: args.max_tokens,
             response_format,
             tool_choice,
@@ -268,3 +307,50 @@ impl QueryBuilder for OtherQueryBuilder {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn deepseek_off_translates_to_thinking_disabled() {
+        let (effort, thinking, temperature) =
+            provider_reasoning_fields(&AIProvider::DeepSeek, Some("none"), Some(0.5));
+        // "none" is rejected as an effort token, so it becomes a thinking disable.
+        assert_eq!(effort, None);
+        assert_eq!(thinking, Some(serde_json::json!({ "type": "disabled" })));
+        assert_eq!(temperature, Some(0.5));
+    }
+
+    #[test]
+    fn deepseek_level_passes_effort_through() {
+        let (effort, thinking, _) =
+            provider_reasoning_fields(&AIProvider::DeepSeek, Some("high"), None);
+        assert_eq!(effort, Some("high"));
+        assert!(thinking.is_none());
+    }
+
+    #[test]
+    fn mistral_drops_temperature_when_reasoning_on() {
+        let (effort, thinking, temperature) =
+            provider_reasoning_fields(&AIProvider::Mistral, Some("high"), Some(0.7));
+        assert_eq!(effort, Some("high"));
+        assert!(thinking.is_none());
+        assert_eq!(temperature, None);
+    }
+
+    #[test]
+    fn mistral_keeps_temperature_when_reasoning_off() {
+        let (_, _, temperature) = provider_reasoning_fields(&AIProvider::Mistral, None, Some(0.7));
+        assert_eq!(temperature, Some(0.7));
+    }
+
+    #[test]
+    fn other_providers_pass_reasoning_and_temperature_through() {
+        let (effort, thinking, temperature) =
+            provider_reasoning_fields(&AIProvider::OpenRouter, Some("high"), Some(0.3));
+        assert_eq!(effort, Some("high"));
+        assert!(thinking.is_none());
+        assert_eq!(temperature, Some(0.3));
+    }
+}
diff --git a/backend/windmill-ai/src/query_builder.rs b/backend/windmill-ai/src/query_builder.rs
index 9830045f57..79fca4bd7d 100644
--- a/backend/windmill-ai/src/query_builder.rs
+++ b/backend/windmill-ai/src/query_builder.rs
@@ -12,6 +12,9 @@ pub struct BuildRequestArgs<'a> {
     pub tools: Option<&'a [ToolDef]>,
     pub model: &'a str,
     pub temperature: Option<f32>,
+    /// Provider-native reasoning effort token (e.g. `low`, `high`, `none`).
+    /// Each `build_request` maps it onto the provider's thinking config.
+    pub reasoning_effort: Option<&'a str>,
     pub max_tokens: Option<u32>,
     pub output_schema: Option<&'a OpenAPISchema>,
     pub output_type: &'a OutputType,
diff --git a/backend/windmill-ai/src/sse.rs b/backend/windmill-ai/src/sse.rs
index bb1b9d9731..66ff7da9de 100644
--- a/backend/windmill-ai/src/sse.rs
+++ b/backend/windmill-ai/src/sse.rs
@@ -9,7 +9,9 @@ use windmill_common::{error::Error, utils::rd_string};
 use crate::{
     ai_google::{parse_gemini_sse_event, GeminiUsageMetadata},
     ai_types::UrlCitation,
-    ai_types::{ExtraContent, GoogleExtraContent, OpenAIFunction, OpenAIToolCall},
+    ai_types::{
+        AnthropicExtraContent, ExtraContent, GoogleExtraContent, OpenAIFunction, OpenAIToolCall,
+    },
     query_builder::StreamEventSink,
     types::StreamingEvent,
 };
@@ -30,6 +32,10 @@ pub struct OpenAIChoiceDeltaToolCall {
 #[derive(Deserialize)]
 pub struct OpenAIChoiceDelta {
     pub content: Option<String>,
+    /// Reasoning summary streamed by providers that expose it (e.g. DeepSeek's
+    /// `reasoning_content`). Rendered as a "thinking" affordance.
+    #[serde(default)]
+    pub reasoning_content: Option<String>,
     pub tool_calls: Option<Vec<OpenAIChoiceDeltaToolCall>>,
 }
 
@@ -142,6 +148,13 @@ impl SSEParser for OpenAISSEParser {
 
             if let Some(mut choices) = event.choices.filter(|s| !s.is_empty()) {
                 if let Some(delta) = choices.remove(0).delta {
+                    if let Some(reasoning) = delta.reasoning_content.filter(|s| !s.is_empty()) {
+                        let event = StreamingEvent::ReasoningTokenDelta { content: reasoning };
+                        self.stream_event_processor
+                            .send(event, &mut self.events_str)
+                            .await?;
+                    }
+
                     if let Some(content) = delta.content.filter(|s| !s.is_empty()) {
                         self.accumulated_content.push_str(&content);
                         let event = StreamingEvent::TokenDelta { content };
@@ -216,6 +229,16 @@ pub enum AnthropicContentBlockStart {
         id: String,
         name: String,
     },
+    #[serde(rename = "thinking")]
+    Thinking {
+        #[serde(default)]
+        thinking: String,
+    },
+    #[serde(rename = "redacted_thinking")]
+    RedactedThinking {
+        #[serde(default)]
+        data: String,
+    },
     #[serde(other)]
     Unknown,
 }
@@ -240,6 +263,10 @@ pub enum AnthropicDelta {
     InputJsonDelta { partial_json: String },
     #[serde(rename = "citations_delta")]
     CitationsDelta { citation: AnthropicCitationDelta },
+    #[serde(rename = "thinking_delta")]
+    ThinkingDelta { thinking: String },
+    #[serde(rename = "signature_delta")]
+    SignatureDelta { signature: String },
     #[serde(other)]
     Unknown,
 }
@@ -292,6 +319,7 @@ pub enum AnthropicSSEEvent {
 #[allow(dead_code)]
 enum ContentBlockState {
     Text,
+    Thinking,
     ToolUse { id: String, name: String },
     Unknown,
 }
@@ -310,6 +338,11 @@ pub struct AnthropicSSEParser {
     pub used_websearch: bool,
     /// Token usage from message_delta event
     pub usage: Option<AnthropicUsage>,
+    /// Claude thinking block accumulated from `thinking`/`signature` deltas
+    /// (or a redacted block). Attached to the first tool call of the turn so it
+    /// can be replayed before `tool_use` (required by Claude when thinking is on).
+    pending_reasoning: Option<AnthropicExtraContent>,
+    reasoning_attached: bool,
 }
 
 impl AnthropicSSEParser {
@@ -323,6 +356,8 @@ impl AnthropicSSEParser {
             annotations: Vec::new(),
             used_websearch: false,
             usage: None,
+            pending_reasoning: None,
+            reasoning_attached: false,
         }
     }
 }
@@ -363,6 +398,17 @@ impl SSEParser for AnthropicSSEParser {
                             self.stream_event_processor
                                 .send(event, &mut self.events_str)
                                 .await?;
+                            // Attach the turn's thinking block to the first tool call so it
+                            // can be replayed before tool_use on the next request.
+                            let extra_content = if self.reasoning_attached {
+                                None
+                            } else {
+                                self.reasoning_attached = true;
+                                self.pending_reasoning.take().map(|anthropic| ExtraContent {
+                                    anthropic: Some(anthropic),
+                                    ..Default::default()
+                                })
+                            };
                             // Initialize tool call accumulator
                             self.accumulated_tool_calls.insert(
                                 index as i64,
@@ -370,10 +416,35 @@ impl SSEParser for AnthropicSSEParser {
                                     id,
                                     function: OpenAIFunction { name, arguments: String::new() },
                                     r#type: "function".to_string(),
-                                    extra_content: None,
+                                    extra_content,
                                 },
                             );
                         }
+                        AnthropicContentBlockStart::Thinking { thinking } => {
+                            self.content_blocks
+                                .insert(index, ContentBlockState::Thinking);
+                            let entry = self.pending_reasoning.get_or_insert_with(Default::default);
+                            if !thinking.is_empty() {
+                                entry
+                                    .thinking
+                                    .get_or_insert_with(String::new)
+                                    .push_str(&thinking);
+                                self.stream_event_processor
+                                    .send(
+                                        StreamingEvent::ReasoningTokenDelta { content: thinking },
+                                        &mut self.events_str,
+                                    )
+                                    .await?;
+                            }
+                        }
+                        AnthropicContentBlockStart::RedactedThinking { data } => {
+                            // Redacted blocks arrive whole (no deltas).
+                            self.content_blocks
+                                .insert(index, ContentBlockState::Unknown);
+                            self.pending_reasoning
+                                .get_or_insert_with(Default::default)
+                                .redacted_thinking = Some(data);
+                        }
                         AnthropicContentBlockStart::ServerToolUse { name, .. } => {
                             // Detect websearch tool usage
                             if name == "web_search" {
@@ -417,6 +488,34 @@ impl SSEParser for AnthropicSSEParser {
                                 title: citation.title,
                             });
                         }
+                        AnthropicDelta::ThinkingDelta { thinking } => {
+                            if let Some(ContentBlockState::Thinking) =
+                                self.content_blocks.get(&index)
+                            {
+                                self.pending_reasoning
+                                    .get_or_insert_with(Default::default)
+                                    .thinking
+                                    .get_or_insert_with(String::new)
+                                    .push_str(&thinking);
+                                self.stream_event_processor
+                                    .send(
+                                        StreamingEvent::ReasoningTokenDelta { content: thinking },
+                                        &mut self.events_str,
+                                    )
+                                    .await?;
+                            }
+                        }
+                        AnthropicDelta::SignatureDelta { signature } => {
+                            if let Some(ContentBlockState::Thinking) =
+                                self.content_blocks.get(&index)
+                            {
+                                self.pending_reasoning
+                                    .get_or_insert_with(Default::default)
+                                    .signature
+                                    .get_or_insert_with(String::new)
+                                    .push_str(&signature);
+                            }
+                        }
                         AnthropicDelta::Unknown => {}
                     }
                 }
@@ -495,6 +594,15 @@ impl SSEParser for GeminiSSEParser {
             return Ok(());
         };
 
+        if let Some(reasoning) = parsed.reasoning.filter(|s| !s.is_empty()) {
+            self.stream_event_processor
+                .send(
+                    StreamingEvent::ReasoningTokenDelta { content: reasoning },
+                    &mut self.events_str,
+                )
+                .await?;
+        }
+
         if let Some(text) = parsed.text {
             self.accumulated_content.push_str(&text);
             self.stream_event_processor
@@ -522,7 +630,7 @@ impl SSEParser for GeminiSSEParser {
 
             let extra_content = tool_call.thought_signature.map(|sig| ExtraContent {
                 google: Some(GoogleExtraContent { thought_signature: Some(sig) }),
-                bedrock: None,
+                ..Default::default()
             });
 
             self.accumulated_tool_calls.insert(
@@ -805,3 +913,76 @@ impl SSEParser for OpenAIResponsesSSEParser {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn reasoning_token_delta_serializes_with_snake_case_tag() {
+        let event = StreamingEvent::ReasoningTokenDelta { content: "hmm".to_string() };
+        let json: serde_json::Value =
+            serde_json::from_str(&serde_json::to_string(&event).unwrap()).unwrap();
+        assert_eq!(json["type"], "reasoning_token_delta");
+        assert_eq!(json["content"], "hmm");
+    }
+
+    #[test]
+    fn openai_delta_parses_reasoning_content() {
+        // DeepSeek and similar stream reasoning under `reasoning_content`.
+        let delta: OpenAIChoiceDelta =
+            serde_json::from_str(r#"{"reasoning_content":"let me think"}"#).unwrap();
+        assert_eq!(delta.reasoning_content.as_deref(), Some("let me think"));
+    }
+
+    #[test]
+    fn parses_anthropic_thinking_events() {
+        let start: AnthropicSSEEvent = serde_json::from_str(
+            r#"{"type":"content_block_start","index":0,"content_block":{"type":"thinking","thinking":"x"}}"#,
+        )
+        .unwrap();
+        assert!(matches!(
+            start,
+            AnthropicSSEEvent::ContentBlockStart {
+                content_block: AnthropicContentBlockStart::Thinking { .. },
+                ..
+            }
+        ));
+
+        let thinking_delta: AnthropicSSEEvent = serde_json::from_str(
+            r#"{"type":"content_block_delta","index":0,"delta":{"type":"thinking_delta","thinking":"more"}}"#,
+        )
+        .unwrap();
+        assert!(matches!(
+            thinking_delta,
+            AnthropicSSEEvent::ContentBlockDelta {
+                delta: AnthropicDelta::ThinkingDelta { .. },
+                ..
+            }
+        ));
+
+        let signature_delta: AnthropicSSEEvent = serde_json::from_str(
+            r#"{"type":"content_block_delta","index":0,"delta":{"type":"signature_delta","signature":"sig"}}"#,
+        )
+        .unwrap();
+        assert!(matches!(
+            signature_delta,
+            AnthropicSSEEvent::ContentBlockDelta {
+                delta: AnthropicDelta::SignatureDelta { .. },
+                ..
+            }
+        ));
+
+        let redacted: AnthropicSSEEvent = serde_json::from_str(
+            r#"{"type":"content_block_start","index":0,"content_block":{"type":"redacted_thinking","data":"abc"}}"#,
+        )
+        .unwrap();
+        assert!(matches!(
+            redacted,
+            AnthropicSSEEvent::ContentBlockStart {
+                content_block: AnthropicContentBlockStart::RedactedThinking { .. },
+                ..
+            }
+        ));
+    }
+}
diff --git a/backend/windmill-ai/src/types.rs b/backend/windmill-ai/src/types.rs
index 8f864468db..6991e0e0d3 100644
--- a/backend/windmill-ai/src/types.rs
+++ b/backend/windmill-ai/src/types.rs
@@ -203,6 +203,10 @@ pub struct ProviderWithResource {
     pub kind: AIProvider,
     pub resource: ProviderResource,
     pub model: String,
+    /// Provider-native reasoning effort token (e.g. `low`, `high`, `none`).
+    /// Belongs to the model selection, so it rides on the provider config.
+    #[serde(default)]
+    pub reasoning_effort: Option<String>,
 }
 
 impl ProviderWithResource {
@@ -214,6 +218,12 @@ impl ProviderWithResource {
         &self.model
     }
 
+    /// The reasoning effort to thread to the provider, treating an empty string
+    /// (e.g. a cleared flow input) as unset.
+    pub fn get_reasoning_effort(&self) -> Option<&str> {
+        self.reasoning_effort.as_deref().filter(|s| !s.is_empty())
+    }
+
     pub async fn get_base_url(&self, db: &DB) -> Result<String, Error> {
         self.kind
             .get_base_url(self.resource.base_url.clone(), db)
@@ -365,6 +375,10 @@ pub struct AIAgentResult<'a> {
 pub enum StreamingEvent {
     /// Individual token from the AI response
     TokenDelta { content: String },
+    /// Individual token of the model's reasoning / thinking summary. Emitted
+    /// before the answer when reasoning is enabled; renderable as a "thinking"
+    /// affordance (thinking tokens bill regardless of whether they are shown).
+    ReasoningTokenDelta { content: String },
     /// Tool call has started
     ToolCall { call_id: String, function_name: String },
     /// Tool call arguments are complete
diff --git a/backend/windmill-api-assets/src/lib.rs b/backend/windmill-api-assets/src/lib.rs
index b4b0583863..997879e155 100644
--- a/backend/windmill-api-assets/src/lib.rs
+++ b/backend/windmill-api-assets/src/lib.rs
@@ -614,6 +614,21 @@ struct GraphQuery {
 struct GraphAssetNode {
     kind: AssetKind,
     path: String,
+    // Fork workspaces only: 'fork' when the fork has materialized this ducklake asset itself,
+    // 'deferred' when reads fall back to the parent workspace's current table (defer view).
+    // Absent outside forks, for non-ducklake assets, and for assets never materialized
+    // anywhere. Lockstep with TS `AssetGraphAssetNode.fork_materialization`.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    fork_materialization: Option<String>,
+    // The base dimension this asset is the SCD2 `<dim>_current` companion view
+    // of — set only on a `ducklake://…/<dim>_current` node whose producer
+    // declares `// materialize … history` on `<dim>`. The producer edge already
+    // links it to that script (both writes are registered at deploy); this lets
+    // the canvas render it as a derived "current view" of the base rather than an
+    // unrelated table. Absent for every other asset. Lockstep with TS
+    // `AssetGraphAssetNode.derived_from`.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    derived_from: Option<String>,
 }
 
 #[derive(Serialize, Debug)]
@@ -632,6 +647,14 @@ struct GraphRunnableNode {
     partition_kind: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none", default)]
     freshness: Option<String>,
+    // Completion time of the most recently started successful run of this
+    // pipeline member. The canvas checks it against the `// freshness` window
+    // to color the badge fresh/stale. The badge itself is passive; on EE the
+    // freshness watchdog (windmill-queue) separately re-runs stale
+    // unpartitioned producers. Absent when no successful run is visible to
+    // the caller (job RLS applies).
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    last_success_at: Option<chrono::DateTime<chrono::Utc>>,
     #[serde(skip_serializing_if = "Option::is_none", default)]
     tag: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none", default)]
@@ -656,6 +679,13 @@ struct GraphRunnableNode {
     // `merge` / any partitioned write INSERTs into a fixed-schema table.
     #[serde(skip_serializing_if = "Option::is_none", default)]
     materialize_strategy: Option<String>,
+    // `on_schema_change=ignore` on the managed materialize — the producer's
+    // opt-out from downstream schema-contract warnings. Threaded to the editor
+    // so its client-side contract mirror suppresses the same warnings the
+    // server check does. Only serialized when set to `ignore` (default `warn`
+    // is absent). Lockstep with TS `AssetGraphRunnableNode.materialize_on_schema_change`.
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    materialize_on_schema_change: Option<String>,
     // Macros this script provides to the workspace registry (deployed
     // `// macros` library). Drives the library node state + details-pane
     // signature list. Lockstep with TS `AssetGraphRunnableNode.macros`.
@@ -776,6 +806,25 @@ enum TriggerEdge {
     },
 }
 
+// Ordering-only "must-run-after" edge: `runnable_path`'s data test reads
+// `asset` (a `// data_test relationships` ref, or a custom test whose body
+// reads a known pipeline asset), so the asset's in-pipeline producer must
+// materialize before `runnable_path` runs. NOT a data-consumption edge — the
+// tested script doesn't ingest the asset's rows, it only needs the table to
+// exist at test time. Rendered dashed (like macro edges) and fed into the
+// cascade topo-sort so a cold cascade orders the referenced dimension first.
+// Only emitted when the referenced asset has a producer in the graph; an
+// external table (no producer) adds no edge — the runtime error stands.
+#[derive(Serialize, Debug)]
+struct TestEdge {
+    producer_kind: AssetUsageKind,
+    producer_path: String,
+    runnable_kind: AssetUsageKind,
+    runnable_path: String,
+    asset_kind: AssetKind,
+    asset_path: String,
+}
+
 #[derive(Serialize, Debug)]
 struct AssetGraphResponse {
     assets: Vec<GraphAssetNode>,
@@ -784,12 +833,15 @@ struct AssetGraphResponse {
     triggers: Vec<TriggerEdge>,
     #[serde(skip_serializing_if = "Vec::is_empty", default)]
     macro_edges: Vec<MacroEdge>,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    test_edges: Vec<TestEdge>,
 }
 
 async fn asset_graph(
     authed: ApiAuthed,
     Path(w_id): Path<String>,
     Extension(user_db): Extension<UserDB>,
+    Extension(db): Extension<windmill_common::DB>,
     Query(q): Query<GraphQuery>,
 ) -> JsonResult<AssetGraphResponse> {
     let mut tx = user_db.begin(&authed).await?;
@@ -920,6 +972,46 @@ async fn asset_graph(
     .fetch_all(&mut *tx)
     .await?;
 
+    // Newest successful completed run per pipeline member, for the passive
+    // freshness status on the canvas. Correlated per-path lookup walks
+    // ix_job_root_job_index_by_path_2 newest-first until the first success,
+    // so cost is bounded by the member count, not run history. "Newest" is
+    // by created_at (the index order), not completed_at: with overlapping
+    // runs of one path this can pick an earlier completion, erring toward
+    // stale — never toward false-fresh. Inside the user tx so job-visibility
+    // RLS applies — a caller who can't see the runs gets no timestamp rather
+    // than leaked completion times.
+    let member_paths: Vec<String> = pipeline_member_paths
+        .iter()
+        .map(|r| r.path.clone())
+        .collect();
+    let last_success_rows = sqlx::query!(
+        r#"
+        SELECT p.path AS "path!",
+               (SELECT c.completed_at
+                  FROM v2_job j
+                  JOIN v2_job_completed c ON c.id = j.id
+                 WHERE j.workspace_id = $1
+                   AND j.runnable_path = p.path
+                   AND j.parent_job IS NULL
+                   -- No 'singlestepflow': flows may share a script's path, and
+                   -- a same-path flow run must not read as the script being
+                   -- fresh (false-fresh). Script retries land as native
+                   -- 'script' jobs; only the rare flow-wrapper fallback is
+                   -- missed, which errs stale. Kept in lockstep with the
+                   -- freshness watchdog's queries (freshness_watchdog_ee).
+                   AND j.kind IN ('script', 'preview')
+                   AND c.status = 'success'
+                 ORDER BY j.created_at DESC
+                 LIMIT 1) AS last_success_at
+          FROM unnest($2::text[]) AS p(path)
+        "#,
+        &w_id,
+        &member_paths,
+    )
+    .fetch_all(&mut *tx)
+    .await?;
+
     // Existing scripts / flows in the workspace. Used to filter out
     // orphan trigger rows whose `script_path` no longer resolves — those
     // would otherwise be added to `runnable_set` below and surface as
@@ -1010,6 +1102,11 @@ async fn asset_graph(
             (r.path.clone(), lineage)
         })
         .collect();
+    let last_success_by_path: std::collections::HashMap<String, chrono::DateTime<chrono::Utc>> =
+        last_success_rows
+            .into_iter()
+            .filter_map(|r| r.last_success_at.map(|t| (r.path, t)))
+            .collect();
     let pipeline_member_script_paths: std::collections::HashSet<String> =
         pipeline_member_paths.into_iter().map(|r| r.path).collect();
     let existing_script_paths: std::collections::HashSet<String> =
@@ -1190,9 +1287,204 @@ async fn asset_graph(
         runnable_set.insert((AssetUsageKind::Script, e.consumer_path.clone()));
     }
 
+    // Data-test ordering edges. A `// data_test relationships <col> -> <asset>`
+    // (and, best-effort, a custom `// data_test <script>` whose body reads a
+    // pipeline asset) needs the referenced asset materialized before the tested
+    // script runs — but that dependency is otherwise absent from the execution
+    // DAG, so a cold cascade can run the tested script first and hard-fail
+    // ("Catalog Error: Table … does not exist"). Resolve the referenced asset's
+    // producer(s) from the write edges built above and add an ordering-only
+    // edge producer → testing_script. No producer (external table) ⇒ no edge.
+    let mut producers_by_asset: std::collections::HashMap<
+        (AssetKind, String),
+        Vec<(AssetUsageKind, String)>,
+    > = Default::default();
+    for e in &edges {
+        if matches!(e.access_type.as_deref(), Some("w") | Some("rw")) {
+            producers_by_asset
+                .entry((e.asset_kind, e.asset_path.clone()))
+                .or_default()
+                .push((e.runnable_kind, e.runnable_path.clone()));
+        }
+    }
+    // Assets a runnable reads, keyed by (usage_kind, path) — used to order a
+    // custom-test *script*'s producers before whichever member declares
+    // `// data_test <path>`. Keyed on the kind too because a flow can share a
+    // script's path; `// data_test <path>` resolves a deployed script body, so
+    // the lookup below pins `Script` and never pulls a same-path flow's reads.
+    let mut reads_by_runnable: std::collections::HashMap<
+        (AssetUsageKind, String),
+        Vec<(AssetKind, String)>,
+    > = Default::default();
+    for e in &edges {
+        if matches!(e.access_type.as_deref(), None | Some("r") | Some("rw")) {
+            reads_by_runnable
+                .entry((e.runnable_kind, e.runnable_path.clone()))
+                .or_default()
+                .push((e.asset_kind, e.asset_path.clone()));
+        }
+    }
+    let mut test_edges: Vec<TestEdge> = Vec::new();
+    // Dedup on (producer, tested_script, asset) so several tests referencing the
+    // same asset, or a repeated producer, yield one edge.
+    let mut seen_test_edges: std::collections::HashSet<(String, String, AssetKind, String)> =
+        Default::default();
+    for (member_path, ann) in &annotations_by_path {
+        for dt in &ann.data_tests {
+            use windmill_common::assets::DataTest;
+            let referenced: Vec<(AssetKind, String)> = match dt {
+                DataTest::Relationships { to_kind, to_path, .. } => {
+                    vec![(
+                        windmill_common::assets::asset_kind_from_parser(*to_kind),
+                        to_path.clone(),
+                    )]
+                }
+                // Best-effort: the custom test *script*'s parsed reads. Reading
+                // the member's OWN output resolves to the member as producer and
+                // is dropped by the self-edge guard below.
+                DataTest::Custom { path } => reads_by_runnable
+                    .get(&(AssetUsageKind::Script, path.clone()))
+                    .cloned()
+                    .unwrap_or_default(),
+                _ => vec![],
+            };
+            for (asset_kind, asset_path) in referenced {
+                let Some(producers) = producers_by_asset.get(&(asset_kind, asset_path.clone()))
+                else {
+                    continue;
+                };
+                for (producer_kind, producer_path) in producers {
+                    // Skip a self-edge: the tested script produces the asset it
+                    // tests (a materialize + relationships/custom on its own output).
+                    if *producer_kind == AssetUsageKind::Script && producer_path == member_path {
+                        continue;
+                    }
+                    if seen_test_edges.insert((
+                        producer_path.clone(),
+                        member_path.clone(),
+                        asset_kind,
+                        asset_path.clone(),
+                    )) {
+                        test_edges.push(TestEdge {
+                            producer_kind: *producer_kind,
+                            producer_path: producer_path.clone(),
+                            runnable_kind: AssetUsageKind::Script,
+                            runnable_path: member_path.clone(),
+                            asset_kind,
+                            asset_path: asset_path.clone(),
+                        });
+                    }
+                }
+            }
+        }
+    }
+    for e in &test_edges {
+        runnable_set.insert((e.producer_kind, e.producer_path.clone()));
+        runnable_set.insert((e.runnable_kind, e.runnable_path.clone()));
+    }
+
+    // Fork data-environment state per ducklake asset. The parent's rows are read on the plain
+    // pool: fork membership does not imply parent membership, and defer already exposes the
+    // parent's data to fork jobs — surfacing its materialization status is strictly less.
+    let fork_materialization_by_path: std::collections::HashMap<String, &'static str> = {
+        // The WHOLE ancestor chain, matching defer discovery: a grandchild fork whose direct
+        // parent only defers a table still reads it (from the grandparent), so it must show
+        // as deferred, not unmarked.
+        let ancestors = windmill_common::workspaces::fork_ancestor_chain(&db, &w_id).await?;
+        match ancestors {
+            // An orphaned `wm-fork-*` (parent deleted, chain empty) is still isolated — its
+            // own materializations must keep their 'fork' chips (nothing can be 'deferred').
+            a if a.is_empty() && !w_id.starts_with(windmill_common::workspaces::WM_FORK_PREFIX) => {
+                std::collections::HashMap::new()
+            }
+            ancestors => {
+                // Lakes the fork chose to SHARE at creation have no fork namespace — their
+                // assets live in the parent's tables for real, so no chip applies.
+                let shared_lakes: std::collections::HashSet<String> = sqlx::query_scalar!(
+                    "SELECT ducklake->'ducklakes' FROM workspace_settings WHERE workspace_id = $1",
+                    &w_id,
+                )
+                .fetch_optional(&db)
+                .await?
+                .flatten()
+                .and_then(|v| v.as_object().cloned())
+                .map(|lakes| {
+                    lakes
+                        .into_iter()
+                        .filter(|(_, cfg)| {
+                            cfg.get("fork_behavior").and_then(|b| b.as_str()) == Some("shared")
+                        })
+                        .map(|(name, _)| name)
+                        .collect()
+                })
+                .unwrap_or_default();
+                sqlx::query!(
+                    r#"
+                    -- Fork rows also count when a snapshot ever committed (a failed run
+                    -- preserves it): the physical table exists, so reads hit the FORK's
+                    -- data — showing 'deferred' would misstate what a query returns.
+                    -- Ancestor rows still require a clean materialization.
+                    SELECT DISTINCT asset_path AS "asset_path!", workspace_id AS "workspace_id!"
+                    FROM materialized_partition
+                    WHERE (workspace_id = $1 OR workspace_id = ANY($2))
+                      AND asset_kind = 'ducklake'
+                      AND (status = 'materialized'
+                           OR (workspace_id = $1 AND snapshot_id IS NOT NULL))
+                    "#,
+                    &w_id,
+                    &ancestors,
+                )
+                .fetch_all(&db)
+                .await?
+                .into_iter()
+                .filter(|r| {
+                    !shared_lakes.contains(r.asset_path.split('/').next().unwrap_or_default())
+                })
+                .fold(std::collections::HashMap::new(), |mut m, r| {
+                    // A fork row wins over an inherited 'deferred' from any ancestor's row.
+                    if r.workspace_id == w_id {
+                        m.insert(r.asset_path, "fork");
+                    } else {
+                        m.entry(r.asset_path).or_insert("deferred");
+                    }
+                    m
+                })
+            }
+        }
+    };
+
+    // (kind, `<dim>_current` path) → base `<dim>` path, for every managed scd2
+    // producer in the graph. Reads of the companion view resolve to a node
+    // whose producer edge already exists (the deploy path registers both writes)
+    // — this map lets that node advertise which base dimension it derives from.
+    let scd2_current_base: std::collections::HashMap<(AssetKind, String), String> =
+        annotations_by_path
+            .values()
+            .filter_map(|a| a.materialize.as_ref())
+            .filter_map(|m| {
+                m.scd2_current_target().map(|(k, current)| {
+                    (
+                        (windmill_common::assets::asset_kind_from_parser(k), current),
+                        m.target_path.clone(),
+                    )
+                })
+            })
+            .collect();
+
     let mut assets: Vec<GraphAssetNode> = asset_set
         .into_iter()
-        .map(|(kind, path)| GraphAssetNode { kind, path })
+        .map(|(kind, path)| GraphAssetNode {
+            fork_materialization: (kind == AssetKind::Ducklake)
+                .then(|| {
+                    fork_materialization_by_path
+                        .get(&path)
+                        .map(|s| s.to_string())
+                })
+                .flatten(),
+            derived_from: scd2_current_base.get(&(kind, path.clone())).cloned(),
+            kind,
+            path,
+        })
         .collect();
     assets.sort_by(|a, b| a.path.cmp(&b.path));
 
@@ -1215,6 +1507,10 @@ async fn asset_graph(
                 freshness: ann
                     .and_then(|a| a.freshness.as_ref())
                     .map(|f| f.duration.clone()),
+                last_success_at: (usage_kind == AssetUsageKind::Script)
+                    .then(|| last_success_by_path.get(&path))
+                    .flatten()
+                    .copied(),
                 tag: ann.and_then(|a| a.tag.clone()),
                 retry: ann.and_then(|a| a.retry.clone()),
                 data_tests: ann.map(|a| a.data_tests.clone()).unwrap_or_default(),
@@ -1232,8 +1528,12 @@ async fn asset_graph(
                     }
                 }),
                 materialize_strategy: ann.and_then(|a| a.materialize.as_ref()).and_then(|m| {
+                    // Precedence mirrors the runtime strategy derivation:
+                    // scd2 (`history`) > append > merge (`key=`) > replace.
                     if m.manual {
                         None
+                    } else if m.scd2 {
+                        Some("scd2".to_string())
                     } else if m.append {
                         Some("append".to_string())
                     } else if m.unique_key.is_some() {
@@ -1242,6 +1542,12 @@ async fn asset_graph(
                         Some("replace".to_string())
                     }
                 }),
+                materialize_on_schema_change: ann
+                    .and_then(|a| a.materialize.as_ref())
+                    .filter(|m| {
+                        m.on_schema_change == windmill_common::assets::OnSchemaChange::Ignore
+                    })
+                    .map(|_| "ignore".to_string()),
                 macros: (usage_kind == AssetUsageKind::Script)
                     .then(|| macros_by_provider.get(&path))
                     .flatten()
@@ -1260,6 +1566,7 @@ async fn asset_graph(
         edges,
         triggers,
         macro_edges,
+        test_edges,
     }))
 }
 
diff --git a/backend/windmill-api-schedule/src/lib.rs b/backend/windmill-api-schedule/src/lib.rs
index 7cc0111c28..573c47e355 100644
--- a/backend/windmill-api-schedule/src/lib.rs
+++ b/backend/windmill-api-schedule/src/lib.rs
@@ -182,6 +182,19 @@ fn to_json_raw_opt(
     value.map(|v| sqlx::types::Json(to_raw_value(&v)))
 }
 
+/// Managed ducklake-maintenance schedules live under a reserved path prefix;
+/// their lifecycle is owned by the workspace ducklake settings, so the
+/// schedule API refuses to create/edit/delete/toggle them.
+fn reject_reserved_schedule_path(path: &str) -> Result<()> {
+    if path.starts_with(windmill_common::workspaces::DUCKLAKE_MAINTENANCE_PATH_PREFIX) {
+        return Err(Error::BadRequest(format!(
+            "Schedules under {} are managed by the workspace ducklake settings",
+            windmill_common::workspaces::DUCKLAKE_MAINTENANCE_PATH_PREFIX
+        )));
+    }
+    Ok(())
+}
+
 /// Validate that a dynamic skip handler (script or flow) exists
 async fn validate_dynamic_skip<'c>(
     tx: &mut Transaction<'c, Postgres>,
@@ -219,6 +232,7 @@ async fn create_schedule(
     Json(ns): Json<NewSchedule>,
 ) -> Result<String> {
     check_scopes(&authed, || format!("schedules:write:{}", ns.path))?;
+    reject_reserved_schedule_path(&ns.path)?;
 
     let authed = maybe_refresh_folders(&ns.path, &w_id, authed, &db).await;
 
@@ -468,6 +482,7 @@ async fn edit_schedule(
 ) -> Result<String> {
     let path = path.to_path();
     check_scopes(&authed, || format!("schedules:write:{}", path))?;
+    reject_reserved_schedule_path(path)?;
 
     let authed = maybe_refresh_folders(&path, &w_id, authed, &db).await;
     let mut tx = user_db.begin(&authed).await?;
@@ -750,6 +765,15 @@ async fn list_schedule(
         )
         .order_by("edited_at", true)
         .and_where("workspace_id = ?".bind(&w_id))
+        // managed ducklake-maintenance schedules are edited from the
+        // workspace ducklake settings, not the schedules UI/CLI.
+        // starts_with, not LIKE: the prefix contains `_` which LIKE treats as
+        // a wildcard, and a user folder like `ducklake-maintenance` must not
+        // be swept up.
+        .and_where(
+            "NOT starts_with(path, ?)"
+                .bind(&windmill_common::workspaces::DUCKLAKE_MAINTENANCE_PATH_PREFIX),
+        )
         .offset(offset)
         .limit(per_page)
         .clone();
@@ -923,12 +947,13 @@ async fn list_schedule_with_jobs(
                 ORDER BY completed_at DESC
                 LIMIT 20
             ) AS jobs) t
-        WHERE workspace_id = $1
+        WHERE workspace_id = $1 AND NOT starts_with(schedule.path, $4)
         ORDER BY edited_at DESC
         LIMIT $2 OFFSET $3",
         w_id,
         per_page as i64,
-        offset as i64
+        offset as i64,
+        windmill_common::workspaces::DUCKLAKE_MAINTENANCE_PATH_PREFIX
     )
     .fetch_all(&mut *tx)
     .await?;
@@ -1014,6 +1039,7 @@ pub async fn set_enabled(
     let mut tx = user_db.begin(&authed).await?;
     let path = path.to_path();
     check_scopes(&authed, || format!("schedules:write:{}", path))?;
+    reject_reserved_schedule_path(path)?;
 
     // Block enabling a schedule in a fork when the parent has the same path
     // (regardless of parent's enabled flag), unless force=true. Two enabled
@@ -1190,6 +1216,7 @@ async fn delete_schedule(
 ) -> Result<String> {
     let path = path.to_path();
     check_scopes(&authed, || format!("schedules:write:{}", path))?;
+    reject_reserved_schedule_path(path)?;
     let mut tx = user_db.begin(&authed).await?;
 
     clear_schedule(&mut tx, path, &w_id).await?;
@@ -1399,6 +1426,14 @@ async fn set_default_error_handler(
             }
         }
         for updated_schedule_path in updated_schedules {
+            // managed ducklake-maintenance rows get the handler update (their
+            // failures should reach workspace handlers) but must not be
+            // pushed into git-sync as deployed schedules
+            if updated_schedule_path
+                .starts_with(windmill_common::workspaces::DUCKLAKE_MAINTENANCE_PATH_PREFIX)
+            {
+                continue;
+            }
             handle_deployment_metadata(
                 &authed.email,
                 &authed.username,
diff --git a/backend/windmill-api-scripts/src/scripts.rs b/backend/windmill-api-scripts/src/scripts.rs
index 4f9de4f416..d7a461dafa 100644
--- a/backend/windmill-api-scripts/src/scripts.rs
+++ b/backend/windmill-api-scripts/src/scripts.rs
@@ -141,6 +141,8 @@ pub fn workspaced_service() -> Router {
         // CI test results
         .route("/ci_test_results/{kind}/{*path}", get(get_ci_test_results))
         .route("/ci_test_results_batch", post(get_ci_test_results_batch))
+        // Save-time schema-contract check (pipelines gap #2b)
+        .route("/check_schema_contracts", post(check_schema_contracts))
 }
 
 #[derive(Serialize, FromRow)]
@@ -1252,16 +1254,6 @@ async fn create_script_internal<'c>(
     // membership; parsed writes tell us what is produced (we don't record
     // them in auto_kind itself).
     let pipeline_annotations = parse_pipeline_annotations(&ns.content);
-    // `// freshness` is parsed but enforcement is a not-yet-implemented
-    // enterprise feature (skeleton in windmill_common::pipeline_advanced).
-    // Surface a clear TODO at deploy rather than silently accepting an
-    // annotation that does nothing.
-    if pipeline_annotations.freshness.is_some() {
-        tracing::warn!(
-            "{}",
-            windmill_common::pipeline_advanced::freshness_enforcement_todo()
-        );
-    }
     // `// materialize` materializes a `ducklake://<name>/<table>` target from a
     // DuckDB script. These two constraints hold for *both* modes: a non-DuckLake
     // target would otherwise deploy, register a producer in the asset graph, then
@@ -1315,6 +1307,38 @@ async fn create_script_internal<'c>(
                 ns.path
             );
         }
+        // SCD2 (`key=<col> history` / `scd2`) option-combination checks the
+        // runtime cannot honor: reject at deploy with a clear message rather
+        // than letting the script deploy and fail on its first run. Mirrors the
+        // executor's safety-net `MaterializeSpec::validate` (duckdb_executor).
+        if let Err(e) = m.validate(pipeline_annotations.partition.is_some()) {
+            return Err(Error::BadRequest(e));
+        }
+        // `manual` materialize never captures a schema (no wrap codegen), so
+        // there is no contract for `on_schema_change` to mute downstream.
+        if m.manual && m.on_schema_change == windmill_parser::asset_parser::OnSchemaChange::Ignore {
+            tracing::warn!(
+                "script {}: `on_schema_change=ignore` on a `manual` materialize is inert — manual mode captures no schema, so consumers have no contract to check",
+                ns.path
+            );
+        }
+    }
+    // A `// data_test` line whose right-hand side doesn't parse into a known
+    // check is dropped silently by the parser (fail-safe). For a data-quality
+    // assertion that is a footgun — a typo disables the test with no signal —
+    // so warn at deploy. Warning, not rejection: it matches the other pipeline
+    // deploy checks above and can't false-positive a deploy on an edge the
+    // coarse count and the parser disagree on.
+    let malformed_data_tests =
+        windmill_parser::asset_parser::count_malformed_data_tests(&ns.content);
+    if malformed_data_tests > 0 {
+        tracing::warn!(
+            "script {}: {} `// data_test` line(s) are malformed and were dropped — the intended \
+             check(s) will not run. Fix the syntax (e.g. `data_test accepted_values <col> = a,b,c`, \
+             `data_test relationships <col> -> <asset>.<refcol>`).",
+            ns.path,
+            malformed_data_tests
+        );
     }
     // `// macros` — this script is a workspace macro library: its body is
     // CREATE [OR REPLACE] MACRO statements plus plain setup, registered into
@@ -1422,21 +1446,17 @@ async fn create_script_internal<'c>(
     // body's `SELECT` doesn't express the write (the runtime generates it), so
     // server-side inference wouldn't otherwise link it.
     let effective_assets = if let Some(m) = pipeline_annotations.materialize.as_ref() {
-        let kind = windmill_common::assets::asset_kind_from_parser(m.target_kind);
         let mut a = effective_assets.unwrap_or_default();
         // Produced assets: the managed table, plus — for managed scd2 — the
-        // `<dim>_current` companion view the runtime (re)creates each run.
-        // Registering the view as a write asset lets `// on
-        // ducklake://…/<dim>_current` subscribers be dispatched by the cascade
-        // (which fans out from these deploy-time asset rows); without it a
-        // subscriber on the view would silently never fire. Gated on `!manual`:
-        // manual mode owns its own DDL and short-circuits before the scd2 codegen
-        // (no view is created), so registering it there would be a false edge.
-        let mut targets = vec![m.target_path.clone()];
-        if m.scd2 && !m.manual {
-            targets.push(format!("{}_current", m.target_path));
-        }
-        for path in targets {
+        // `<dim>_current` companion view the runtime (re)creates each run
+        // (`MaterializeSpec::write_targets`). Registering the view as a write
+        // asset lets `// on ducklake://…/<dim>_current` subscribers be
+        // dispatched by the cascade (which fans out from these deploy-time asset
+        // rows) and connects a consumer that reads only the view back to this
+        // producer; without it a subscriber on the view would silently never
+        // fire and the view would be an orphan node in the lineage graph.
+        for (target_kind, path) in m.write_targets() {
+            let kind = windmill_common::assets::asset_kind_from_parser(target_kind);
             if !a.iter().any(|x| x.kind == kind && x.path == path) {
                 a.push(windmill_common::assets::AssetWithAltAccessType {
                     path,
@@ -3976,3 +3996,46 @@ async fn get_ci_test_results_batch(
 
     Ok(Json(result_map))
 }
+
+#[derive(Deserialize)]
+struct CheckSchemaContractsRequest {
+    language: ScriptLang,
+    content: String,
+}
+
+#[derive(Serialize)]
+struct CheckSchemaContractsResponse {
+    warnings: Vec<windmill_common::schema_contracts::ContractWarning>,
+}
+
+// Save-time schema-contract check (pipelines gap #2b): validate the given
+// script content's asset references (body column reads, `// column` lineage,
+// `// data_test relationships`) against the latest captured producer schemas
+// and return WARNINGS — never errors, and deploy never blocks on this. The
+// frontend calls it right after a successful deploy (post-commit, so a
+// self-produced target resolves to the fresh content) and the editor mirrors
+// the same diff client-side; this endpoint is the authoritative check. Parsing
+// uses the same server path as deploy (`effective_script_assets` +
+// `parse_pipeline_annotations`) so the verdict matches what deployed.
+async fn check_schema_contracts(
+    authed: ApiAuthed,
+    Extension(user_db): Extension<UserDB>,
+    Path(w_id): Path<String>,
+    Json(req): Json<CheckSchemaContractsRequest>,
+) -> JsonResult<CheckSchemaContractsResponse> {
+    let assets = crate::asset_inference::effective_script_assets(&req.language, &req.content, None)
+        .unwrap_or_default();
+    let ann = parse_pipeline_annotations(&req.content);
+    let mut tx = user_db.begin(&authed).await?;
+    let warnings = windmill_common::schema_contracts::check_schema_contracts(
+        &mut tx,
+        &w_id,
+        &assets,
+        &ann.column_lineage,
+        &ann.data_tests,
+        ann.materialize.as_ref(),
+    )
+    .await?;
+    tx.commit().await?;
+    Ok(Json(CheckSchemaContractsResponse { warnings }))
+}
diff --git a/backend/windmill-api-workspaces/Cargo.toml b/backend/windmill-api-workspaces/Cargo.toml
index 364c6a3f0b..52a58aa1a3 100644
--- a/backend/windmill-api-workspaces/Cargo.toml
+++ b/backend/windmill-api-workspaces/Cargo.toml
@@ -11,10 +11,14 @@ path = "src/lib.rs"
 [features]
 default = []
 enterprise = ["windmill-common/enterprise"]
-private = ["windmill-common/private"]
+private = [
+    "windmill-common/private",
+    "windmill-queue/private",
+    "windmill-audit/private",
+]
 cloud = ["windmill-common/cloud"]
 no_auth = ["windmill-api-auth/no_auth"]
-parquet = ["windmill-object-store/parquet"]
+parquet = ["windmill-object-store/parquet", "dep:futures"]
 
 [dependencies]
 windmill-common = { workspace = true, default-features = false }
@@ -31,6 +35,7 @@ windmill-store.workspace = true
 
 axum.workspace = true
 chrono.workspace = true
+futures = { workspace = true, optional = true }
 hex.workspace = true
 magic-crypt.workspace = true
 http.workspace = true
diff --git a/backend/windmill-api-workspaces/src/workspaces.rs b/backend/windmill-api-workspaces/src/workspaces.rs
index 06c157c1a2..7609ea868e 100644
--- a/backend/windmill-api-workspaces/src/workspaces.rs
+++ b/backend/windmill-api-workspaces/src/workspaces.rs
@@ -184,6 +184,10 @@ pub fn workspaced_service() -> Router {
             "/drop_forked_datatable_databases",
             post(crate::workspaces_extra::drop_forked_datatable_databases),
         )
+        .route(
+            "/drop_forked_ducklake_namespaces",
+            post(crate::workspaces_extra::drop_forked_ducklake_namespaces),
+        )
         .route(
             "/get_datatable_full_schema",
             post(get_datatable_full_schema),
@@ -456,6 +460,11 @@ struct CreateWorkspaceFork {
     /// forked workspace's datatable config to point to the new database.
     #[serde(default)]
     forked_datatables: Vec<ForkedDatatableInfo>,
+    /// Lakes the user explicitly chose to SHARE with the parent (the fork then reads and
+    /// writes the parent's lake directly). Every lake not listed gets the default isolated
+    /// fork namespace + read-defer.
+    #[serde(default)]
+    shared_ducklakes: Vec<String>,
     /// Create the fork as a persistent dev workspace: the id is not required to carry the
     /// `wm-fork-` prefix, and at most one dev workspace may exist per parent.
     #[serde(default)]
@@ -2309,6 +2318,17 @@ async fn edit_ducklake_config(
     require_admin(is_admin, &username)?;
     let is_superadmin = require_super_admin(&db, &email).await.is_ok();
 
+    // Lake names end up interpolated in `ATTACH 'ducklake://<name>'`,
+    // generated maintenance SQL and the reserved maintenance schedule path
+    // (CHECK-constrained to [\w-]+ segments).
+    for name in new_config.settings.ducklakes.keys() {
+        if !windmill_common::workspaces::is_valid_ducklake_name(name) {
+            return Err(Error::BadRequest(format!(
+                "Invalid ducklake name '{name}': only letters, digits, '_' and '-' are allowed"
+            )));
+        }
+    }
+
     let mut tx = db.begin().await?;
 
     let args_for_audit = format!("{:?}", new_config.settings);
@@ -2323,21 +2343,22 @@ async fn edit_ducklake_config(
     )
     .await?;
 
+    let old_ducklakes = sqlx::query_scalar!(
+        r#"
+            SELECT ws.ducklake->'ducklakes' AS ducklake_name
+            FROM workspace_settings ws
+            WHERE ws.workspace_id = $1
+        "#,
+        &w_id
+    )
+    .fetch_one(&mut *tx)
+    .await?
+    .unwrap_or(serde_json::Value::Null);
+    let old_ducklakes: HashMap<String, Ducklake> =
+        serde_json::from_value(old_ducklakes).unwrap_or_default();
+
     // Check that non-superadmins are not abusing Instance databases
     if !is_superadmin {
-        let old_ducklakes = sqlx::query_scalar!(
-            r#"
-                SELECT ws.ducklake->'ducklakes' AS ducklake_name
-                FROM workspace_settings ws
-                WHERE ws.workspace_id = $1
-            "#,
-            &w_id
-        )
-        .fetch_one(&mut *tx)
-        .await?
-        .unwrap_or(serde_json::Value::Null);
-        let old_ducklakes: HashMap<String, Ducklake> =
-            serde_json::from_value(old_ducklakes).unwrap_or_default();
         for (name, dl) in new_config.settings.ducklakes.iter() {
             if dl.catalog.resource_type == DucklakeCatalogResourceType::Instance {
                 let old_dl = old_ducklakes.get(name);
@@ -2355,7 +2376,7 @@ async fn edit_ducklake_config(
         }
     }
 
-    let config: serde_json::Value = serde_json::to_value(new_config.settings)
+    let config: serde_json::Value = serde_json::to_value(&new_config.settings)
         .map_err(|err| Error::internal_err(err.to_string()))?;
 
     sqlx::query!(
@@ -2366,6 +2387,19 @@ async fn edit_ducklake_config(
     .execute(&mut *tx)
     .await?;
 
+    // Same tx as the settings update: a failed schedule sync/push must fail
+    // the whole save — nothing reconciles a half-applied state later.
+    let tx = windmill_queue::ducklake_maintenance::sync_ducklake_maintenance_schedules(
+        &db,
+        tx,
+        &w_id,
+        &new_config.settings.ducklakes,
+        &old_ducklakes,
+        &username,
+        &email,
+    )
+    .await?;
+
     tx.commit().await?;
 
     Ok(format!("Edit ducklake config for workspace {}", &w_id))
@@ -4101,6 +4135,7 @@ async fn clone_workspace_data(
     // Clone CI test references
     clone_ci_test_references(tx, source_workspace_id, target_workspace_id).await?;
     clone_macro_registry(tx, source_workspace_id, target_workspace_id).await?;
+    clone_asset_usages_and_triggers(tx, source_workspace_id, target_workspace_id).await?;
 
     // Clone flows with new versions
     clone_flows(tx, source_workspace_id, target_workspace_id).await?;
@@ -4142,6 +4177,9 @@ async fn clone_triggers_and_schedules(
     source_workspace_id: &str,
     target_workspace_id: &str,
 ) -> Result<()> {
+    // Managed ducklake-maintenance schedules are excluded: the fork starts
+    // with no ducklake config, so cloned rows could never resolve a lake and
+    // the schedule API refuses mutations under the reserved prefix.
     sqlx::query!(
         r#"INSERT INTO schedule (
             workspace_id, path, edited_by, edited_at, schedule, enabled, script_path,
@@ -4158,9 +4196,10 @@ async fn clone_triggers_and_schedules(
             on_recovery_times, on_recovery_extra_args, ws_error_handler_muted, retry,
             summary, no_flow_overlap, tag, paused_until, on_success, on_success_extra_args,
             cron_version, description, dynamic_skip, permissioned_as, labels
-        FROM schedule WHERE workspace_id = $2"#,
+        FROM schedule WHERE workspace_id = $2 AND NOT starts_with(path, $3)"#,
         target_workspace_id,
         source_workspace_id,
+        windmill_common::workspaces::DUCKLAKE_MAINTENANCE_PATH_PREFIX,
     )
     .execute(&mut **tx)
     .await?;
@@ -4693,6 +4732,39 @@ async fn clone_macro_registry(
     Ok(())
 }
 
+// Asset usage rows and `// on` subscriber triggers are deploy-derived like
+// ci_test_reference / the macro registry: without cloning them the fork's
+// pipeline graph has no asset nodes or lineage edges, and — worse — the asset
+// dispatch cascade never fires in the fork (it reads `script_trigger`), so
+// materializing an upstream node can't trigger its consumers until every
+// script is manually redeployed. `job`-kind usage rows (runtime-detected,
+// ephemeral) are skipped like the graph does.
+async fn clone_asset_usages_and_triggers(
+    tx: &mut Transaction<'_, Postgres>,
+    source_workspace_id: &str,
+    target_workspace_id: &str,
+) -> Result<()> {
+    sqlx::query!(
+        "INSERT INTO asset (workspace_id, path, kind, usage_access_type, usage_path, usage_kind, columns)
+         SELECT $2, path, kind, usage_access_type, usage_path, usage_kind, columns
+         FROM asset WHERE workspace_id = $1 AND usage_kind IN ('script', 'flow')",
+        source_workspace_id,
+        target_workspace_id,
+    )
+    .execute(&mut **tx)
+    .await?;
+    sqlx::query!(
+        "INSERT INTO script_trigger (workspace_id, runnable_kind, runnable_path, trigger_kind, trigger_ref, join_all, debounce_s, retry_count, retry_delay_s)
+         SELECT $2, runnable_kind, runnable_path, trigger_kind, trigger_ref, join_all, debounce_s, retry_count, retry_delay_s
+         FROM script_trigger WHERE workspace_id = $1",
+        source_workspace_id,
+        target_workspace_id,
+    )
+    .execute(&mut **tx)
+    .await?;
+    Ok(())
+}
+
 async fn clone_flows(
     tx: &mut Transaction<'_, Postgres>,
     source_workspace_id: &str,
@@ -5414,6 +5486,42 @@ async fn create_workspace_fork(
     // conflict instead of a misleading "maximum number of workspaces" error.
     check_fork_w_id_conflict(&db, &nw.id).await?;
     purge_stale_fork_diff_state(&db, &nw.id).await?;
+    // A previously deleted fork with this id may have left ducklake namespaces behind if its
+    // physical cleanup failed after the delete committed (registry rows are the durable
+    // ledger — no FK, they outlive the workspace). Retry that cleanup now, and refuse to
+    // proceed while any metadata schema still can't be dropped: creating the fork anyway
+    // would silently reattach the deterministic namespace and its stale tables. Data-file
+    // leftovers alone don't block — once the schema is gone they are inert (a deleted fork's
+    // `$res:` storage resource is gone forever, so they may never resolve again), and the
+    // surviving registry row has the next successful same-prefix cleanup sweep them.
+    // `$res:` fallback = the workspace being forked: the deleted fork's resource clones came
+    // from a parent, so the new parent is the natural donor for the retry's credentials.
+    let leftover_issues = crate::workspaces_extra::drop_forked_ducklake_namespaces_impl(
+        &db,
+        &nw.id,
+        Some(&parent_workspace_id),
+    )
+    .await?;
+    let blocking: Vec<&str> = leftover_issues
+        .iter()
+        .filter(|i| i.blocking)
+        .map(|i| i.msg.as_str())
+        .collect();
+    if !blocking.is_empty() {
+        return Err(Error::BadRequest(format!(
+            "a previously deleted workspace with id '{}' left ducklake namespaces that could \
+             not be cleaned up: {}; retry once the catalog is reachable again",
+            nw.id,
+            blocking.join("; ")
+        )));
+    }
+    for i in &leftover_issues {
+        tracing::warn!(
+            "creating fork {}: leftover ducklake cleanup: {}",
+            nw.id,
+            i.msg
+        );
+    }
 
     #[cfg(not(feature = "enterprise"))]
     _check_nb_of_workspaces(&db).await?;
@@ -5511,6 +5619,42 @@ async fn create_workspace_fork(
         apply_forked_datatable(&db, &mut tx, &parent_workspace_id, &forked_id, fdt).await?;
     }
 
+    // The settings clone copies the source's ducklake config verbatim — including a parent
+    // fork's own `fork_behavior` stamps. Sharing is a per-fork-creation choice, never
+    // inherited: reset any cloned stamps first, then apply this fork's requested list.
+    sqlx::query!(
+        r#"UPDATE workspace_settings
+           SET ducklake = jsonb_set(ducklake, '{ducklakes}', (
+               SELECT COALESCE(jsonb_object_agg(key, value - 'fork_behavior'), '{}'::jsonb)
+               FROM jsonb_each(ducklake->'ducklakes')
+           ))
+           WHERE workspace_id = $1 AND jsonb_typeof(ducklake->'ducklakes') = 'object'"#,
+        &forked_id,
+    )
+    .execute(&mut *tx)
+    .await?;
+
+    // Stamp the per-lake ducklake fork choice into the fork's own settings. Only the `shared`
+    // opt-out needs stamping — absent `fork_behavior` already means isolated (the default),
+    // so unlisted lakes and API callers that omit the field stay safe.
+    for lake in &nw.shared_ducklakes {
+        let stamped = sqlx::query_scalar!(
+            r#"UPDATE workspace_settings
+               SET ducklake = jsonb_set(ducklake, ARRAY['ducklakes', $2, 'fork_behavior'], '"shared"')
+               WHERE workspace_id = $1 AND ducklake->'ducklakes' ? $2
+               RETURNING 1 AS "one!""#,
+            &forked_id,
+            lake,
+        )
+        .fetch_optional(&mut *tx)
+        .await?;
+        if stamped.is_none() {
+            return Err(Error::BadRequest(format!(
+                "cannot mark ducklake `{lake}` as shared: no such lake in the workspace settings"
+            )));
+        }
+    }
+
     // Lock the parent ("prod") so edits are funneled through this dev workspace.
     let locked_prod = nw.is_dev_workspace && (nw.lock_prod_deploy || nw.lock_prod_forking);
     if locked_prod {
@@ -5535,6 +5679,10 @@ async fn create_workspace_fork(
     .await?;
     tx.commit().await?;
 
+    // A pre-creation lookup could have cached an EMPTY ancestor chain for this id, which
+    // would bypass ducklake fork isolation for the TTL.
+    windmill_common::workspaces::invalidate_fork_ancestor_chain_cache(&forked_id);
+
     if locked_prod {
         windmill_common::workspaces::invalidate_protection_rules_cache(&parent_workspace_id);
     }
@@ -5708,6 +5856,13 @@ async fn attach_dev_workspace(
     // The dev workspace's parent just changed (none -> prod); drop its cached fork->parent mapping
     // so per-workspace job tags route to the prod family immediately rather than after the TTL.
     windmill_queue::tags::invalidate_fork_parent_cache(&dev_w_id);
+    // Drop the cached ancestor chains too — the workspace existed BEFORE the attach, so a
+    // cached empty chain reads as "not a fork" and its ducklake jobs would write the shared
+    // lake until the TTL. Descendants' chains also gained the new root.
+    windmill_common::workspaces::invalidate_fork_ancestor_chain_cache(&dev_w_id);
+    for id in windmill_common::workspaces::list_fork_descendants(&db, &dev_w_id).await? {
+        windmill_common::workspaces::invalidate_fork_ancestor_chain_cache(&id);
+    }
     // Same reparent invalidates the billing-workspace mapping so its usage meters to prod at once. The
     // candidate can bring its own fork subtree, whose descendants had resolved their (now-stale) root
     // to the candidate's old family; invalidate them too so they meter to prod without waiting out the
diff --git a/backend/windmill-api-workspaces/src/workspaces_extra.rs b/backend/windmill-api-workspaces/src/workspaces_extra.rs
index daf83171e4..9fbaad2bf3 100644
--- a/backend/windmill-api-workspaces/src/workspaces_extra.rs
+++ b/backend/windmill-api-workspaces/src/workspaces_extra.rs
@@ -749,6 +749,16 @@ pub(crate) async fn change_workspace_id(
     // (fork-of-fork) self-heal via the 60s billing-cache TTL.
     for child in &reparented_children {
         windmill_queue::tags::invalidate_fork_parent_cache(child);
+        windmill_common::workspaces::invalidate_fork_ancestor_chain_cache(child);
+        // Grandchildren's cached chains contain the old (renamed-away) ancestor id; a stale
+        // chain drops all defer ancestors in the ducklake resolver, so sweep the subtree
+        // rather than letting it wait out the TTL.
+        for id in windmill_common::workspaces::list_fork_descendants(&db, child)
+            .await
+            .unwrap_or_default()
+        {
+            windmill_common::workspaces::invalidate_fork_ancestor_chain_cache(&id);
+        }
         #[cfg(feature = "cloud")]
         windmill_common::workspaces::invalidate_billing_workspace_cache(child);
     }
@@ -829,28 +839,19 @@ pub(crate) async fn delete_workspace(
     // Deleting an attached dev workspace removes the parent prod's dev_workspace_lock (below), so it
     // must be a prod-admin action, not just the dev's own owner (dev ownership can diverge from
     // prod's) — mirrors detach_dev_workspace, which is prod-admin gated.
-    if let Some(prod) = sqlx::query_scalar!(
-        "SELECT parent_workspace_id FROM workspace WHERE id = $1 AND is_dev_workspace",
-        &w_id
-    )
-    .fetch_optional(&mut *tx)
-    .await?
-    .flatten()
-    {
-        let is_prod_admin = sqlx::query_scalar!(
-            "SELECT is_admin FROM usr WHERE workspace_id = $1 AND email = $2",
-            &prod,
-            &authed.email
-        )
-        .fetch_optional(&mut *tx)
-        .await?
-        .unwrap_or(false);
-        if !is_prod_admin && !is_super_admin_email(&db, &authed.email).await? {
-            return Err(Error::PermissionDenied(format!(
-                "Deleting dev workspace '{w_id}' requires being an admin of its parent prod workspace '{prod}' (or a superadmin)"
-            )));
-        }
-    }
+    require_prod_admin_for_dev_workspace(&db, &authed, &w_id).await?;
+
+    // Snapshot the fork's ducklake namespaces + RESOLVE their connection material NOW — the
+    // registry rows and the fork's `$res:` resources both CASCADE with the workspace row —
+    // but the destructive cleanup itself runs only after the commit below: a delete that
+    // fails mid-way must never leave a live workspace with its fork data destroyed and no
+    // registry row to retry from. Read-only: nothing is dropped here.
+    let fork_ducklake_cleanups = prepare_fork_ducklake_cleanups(&db, &w_id, None)
+        .await
+        .unwrap_or_else(|e| {
+            tracing::warn!("deleting workspace {w_id}: preparing ducklake cleanup: {e:#}");
+            vec![]
+        });
 
     sqlx::query!("DELETE FROM ai_agent_memory WHERE workspace_id = $1", &w_id)
         .execute(&mut *tx)
@@ -1086,6 +1087,17 @@ pub(crate) async fn delete_workspace(
     .await?;
     tx.commit().await?;
 
+    // Physical ducklake-namespace cleanup, post-commit, from the pre-read snapshot: fork
+    // namespaces are deterministic from (id, lake), so an orphan would silently REATTACH to a
+    // recreated identical fork id. Runs inline so every delete path is covered (CLI,
+    // force-delete dialog, direct API — not just the sidebar flow, which still calls the
+    // endpoint first for per-lake error toasts; the rerun is an idempotent no-op). Best
+    // effort: failures are logged — the workspace row is already gone, and broken storage
+    // credentials must not have made it undeletable.
+    for e in cleanup_fork_ducklake_namespaces(&db, &w_id, fork_ducklake_cleanups).await {
+        tracing::warn!("deleted workspace {w_id}: ducklake namespace cleanup: {}", e.msg);
+    }
+
     if let Some(parent) = dev_lock_parent {
         windmill_common::workspaces::invalidate_protection_rules_cache(&parent);
     }
@@ -1099,12 +1111,26 @@ pub(crate) async fn delete_workspace(
     // billing TTL.
     for id in std::iter::once(&w_id).chain(orphaned_children.iter()) {
         windmill_queue::tags::invalidate_fork_parent_cache(id);
+        windmill_common::workspaces::invalidate_fork_ancestor_chain_cache(id);
         #[cfg(feature = "cloud")]
         {
             windmill_common::workspaces::invalidate_billing_workspace_cache(id);
             windmill_common::workspaces::invalidate_team_plan_cache(id);
         }
     }
+    // Deeper descendants' cached ancestor CHAINS still contain the deleted workspace; unlike
+    // the sibling caches (which self-heal harmlessly via TTL), a stale chain makes the
+    // ducklake resolver drop all defer ancestors (all-or-nothing on broken links) — a visible
+    // defer/chips outage for up to the TTL. Anchor at the orphaned children: the deleted row
+    // is gone, but their subtrees are intact.
+    for child in orphaned_children.iter() {
+        for id in windmill_common::workspaces::list_fork_descendants(&db, child)
+            .await
+            .unwrap_or_default()
+        {
+            windmill_common::workspaces::invalidate_fork_ancestor_chain_cache(&id);
+        }
+    }
 
     Ok(format!("Deleted workspace {}", &w_id))
 }
@@ -1266,6 +1292,538 @@ pub async fn drop_forked_datatable_databases(
     Ok(Json(errors))
 }
 
+/// Drop this fork workspace's ducklake namespaces: the `wm_fork_*` metadata schema in each
+/// lake's catalog database, plus (best effort) the fork's `__wm_forks/<wid>/…` data files in
+/// the workspace storage. Driven by the `fork_ducklake_namespace` registry written at first
+/// fork attach, so it works even after settings drift. Returns errors per lake that failed;
+/// the registry row is only deleted once both cleanups succeeded, so a retry resumes.
+/// Same permission as delete_workspace: fork owner or super admin. `delete_workspace` also
+/// runs this inline (the UI calls this endpoint first for error visibility; the inline run
+/// covers every other delete path — CLI, force-delete dialogs, direct API — whose row delete
+/// would otherwise CASCADE the registry away while orphaning the physical namespaces, which a
+/// recreated identical fork id would then silently reattach).
+pub async fn drop_forked_ducklake_namespaces(
+    authed: ApiAuthed,
+    Extension(db): Extension<DB>,
+    Path(w_id): Path<String>,
+) -> Result<Json<Vec<String>>> {
+    let is_fork = workspace_is_fork(&db, &w_id).await?;
+    let mut tx = db.begin().await?;
+    if !(is_fork && is_workspace_owner(&authed, &w_id, &mut tx).await?)
+        && !is_super_admin_email(&db, &authed.email).await?
+    {
+        return Err(Error::PermissionDenied(
+            "Dropping forked ducklake namespaces requires being the fork's owner or a superadmin"
+                .to_string(),
+        ));
+    }
+    tx.commit().await?;
+    require_prod_admin_for_dev_workspace(&db, &authed, &w_id).await?;
+    Ok(Json(
+        drop_forked_ducklake_namespaces_impl(&db, &w_id, None)
+            .await?
+            .into_iter()
+            .map(|i| i.msg)
+            .collect(),
+    ))
+}
+
+/// The cleanup itself, shared by the endpoint and the post-commit `delete_workspace` run. No
+/// authorization of its own — callers gate.
+pub(crate) async fn drop_forked_ducklake_namespaces_impl(
+    db: &DB,
+    w_id: &str,
+    res_fallback_w_id: Option<&str>,
+) -> Result<Vec<ForkDucklakeCleanupIssue>> {
+    let prepared = prepare_fork_ducklake_cleanups(db, w_id, res_fallback_w_id).await?;
+    Ok(cleanup_fork_ducklake_namespaces(db, w_id, prepared).await)
+}
+
+struct ForkDucklakeNamespaceRow {
+    ducklake_name: String,
+    metadata_schema: String,
+    catalog: String,
+    storage: String,
+    storage_ref: String,
+    schema_dropped: bool,
+    data_path: String,
+}
+
+/// A namespace row plus its RESOLVED connection material. `delete_workspace` prepares these
+/// BEFORE its transaction commits — the registry rows AND the fork's `$res:` resources both
+/// disappear with the workspace row — and runs the destructive cleanup only AFTER the commit:
+/// a delete that fails mid-way must never leave a live workspace with its fork data
+/// destroyed, and a committed delete must still be able to reach catalogs/storages whose
+/// credentials lived in the (now gone) fork resources. Per-row resolution failures are
+/// carried as strings so they surface with the other cleanup errors.
+pub(crate) struct PreparedForkDucklakeCleanup {
+    ns: ForkDucklakeNamespaceRow,
+    catalog_pg: std::result::Result<windmill_common::PgDatabase, String>,
+    store: std::result::Result<(windmill_types::s3::LargeFileStorage, serde_json::Value), String>,
+}
+
+/// One row per (lake, catalog, storage, data path) ever attached — settings drift adds rows,
+/// so every location the fork wrote gets cleaned, not just the first. Read-only: resolves
+/// credentials but destroys nothing.
+/// `res_fallback_w_id`: second workspace to resolve `$res:` catalog/storage paths against
+/// when the row's own workspace no longer has them — the retry path runs AFTER the fork and
+/// its resources were deleted. Fork resources are clones of a parent's, so the workspace
+/// being forked again is the natural donor. None on live-workspace paths.
+pub(crate) async fn prepare_fork_ducklake_cleanups(
+    db: &DB,
+    w_id: &str,
+    res_fallback_w_id: Option<&str>,
+) -> Result<Vec<PreparedForkDucklakeCleanup>> {
+    let rows = sqlx::query_as!(
+        ForkDucklakeNamespaceRow,
+        r#"SELECT ducklake_name AS "ducklake_name!", metadata_schema AS "metadata_schema!",
+                  catalog AS "catalog!", storage AS "storage!",
+                  storage_ref AS "storage_ref!", data_path AS "data_path!",
+                  schema_dropped AS "schema_dropped!"
+             FROM fork_ducklake_namespace WHERE workspace_id = $1"#,
+        w_id
+    )
+    .fetch_all(db)
+    .await?;
+    let mut prepared = Vec::with_capacity(rows.len());
+    for ns in rows {
+        let catalog_pg = if ns.schema_dropped {
+            // Schema phase already done — the retry needs no catalog connection at all
+            // (its credentials may be unresolvable for good with the fork's resources gone).
+            Err("unused: metadata schema already dropped".to_string())
+        } else {
+            resolve_fork_catalog_pg(db, w_id, res_fallback_w_id, &ns.ducklake_name, &ns.catalog)
+                .await
+                .map_err(|e| e.to_string())
+        };
+        let storage = Some(ns.storage.as_str()).filter(|s| !s.is_empty());
+        let store = resolve_fork_storage(db, w_id, res_fallback_w_id, storage, &ns.storage_ref)
+            .await
+            .map_err(|e| e.to_string());
+        prepared.push(PreparedForkDucklakeCleanup { ns, catalog_pg, store });
+    }
+    Ok(prepared)
+}
+
+/// Drop the prepared namespaces' metadata schemas + data files, deleting each registry row
+/// only after both succeed (a no-op when the row already cascaded away with the workspace).
+/// Returns per-namespace error strings; never fails as a whole.
+/// One failed step of a fork ducklake cleanup. `blocking` = the metadata schema (or its
+/// guards) failed, so the namespace is still attachable and a same-id fork must NOT be
+/// created. Non-blocking = the schema is gone and only data files (or the registry-row
+/// delete) failed — inert storage leftovers, tracked by the surviving row and swept by the
+/// next successful cleanup of the same prefix.
+pub(crate) struct ForkDucklakeCleanupIssue {
+    pub(crate) blocking: bool,
+    pub(crate) msg: String,
+}
+
+pub(crate) async fn cleanup_fork_ducklake_namespaces(
+    db: &DB,
+    w_id: &str,
+    prepared: Vec<PreparedForkDucklakeCleanup>,
+) -> Vec<ForkDucklakeCleanupIssue> {
+    // The registration once-cache must not outlive the rows it mirrors: a same-id fork
+    // recreated within the TTL would otherwise skip re-registration, and ITS eventual
+    // deletion would find no rows — orphaning the deterministic namespace for the next
+    // same-id fork to silently reattach.
+    windmill_common::workspaces::invalidate_fork_ducklake_registration_cache(w_id);
+    let mut errors: Vec<ForkDucklakeCleanupIssue> = Vec::new();
+    for PreparedForkDucklakeCleanup { ns, catalog_pg, store } in prepared {
+        // Hard guards mirroring the forked-datatable drop: never touch a schema outside the
+        // fork prefix, never delete outside the fork data dir — even if a registry row was
+        // somehow tampered with.
+        if !ns
+            .metadata_schema
+            .starts_with(windmill_common::workspaces::FORK_DUCKLAKE_SCHEMA_PREFIX)
+        {
+            errors.push(ForkDucklakeCleanupIssue {
+                blocking: true,
+                msg: format!(
+                    "Refusing to drop schema '{}' for ducklake://{}: name does not start with '{}'",
+                    ns.metadata_schema,
+                    ns.ducklake_name,
+                    windmill_common::workspaces::FORK_DUCKLAKE_SCHEMA_PREFIX
+                ),
+            });
+            continue;
+        }
+        // The fork's directory segment, NOT the raw workspace id: ids are only
+        // git-branch-safe and may contain `/`, which raw would let one fork's prefix nest
+        // inside a sibling's (`wm-fork-a/b` under `wm-fork-a`) and be swept by its cleanup.
+        let expected_prefix = format!(
+            "{}/{}/",
+            windmill_common::workspaces::FORK_DUCKLAKE_DATA_DIR,
+            windmill_common::workspaces::fork_data_dir_segment(w_id)
+        );
+        if !format!("{}/", ns.data_path.trim_end_matches('/')).starts_with(&expected_prefix) {
+            errors.push(ForkDucklakeCleanupIssue {
+                blocking: true,
+                msg: format!(
+                    "Refusing to delete data path '{}' for ducklake://{}: not under '{}'",
+                    ns.data_path, ns.ducklake_name, expected_prefix
+                ),
+            });
+            continue;
+        }
+
+        let drop_res = if ns.schema_dropped {
+            // Recorded as already dropped by a prior partial cleanup; skipping means no
+            // catalog credentials are needed. Registration resets the flag when a live fork
+            // re-attaches (recreating the schema).
+            Ok(())
+        } else {
+            match catalog_pg {
+                Ok(pg) => drop_fork_ducklake_metadata_schema(db, pg, &ns.metadata_schema).await,
+                Err(e) => Err(Error::internal_err(e)),
+            }
+        };
+        if let Err(e) = drop_res {
+            errors.push(ForkDucklakeCleanupIssue {
+                blocking: true,
+                msg: format!(
+                    "Could not drop metadata schema '{}' for ducklake://{}: {e}",
+                    ns.metadata_schema, ns.ducklake_name
+                ),
+            });
+            continue;
+        }
+        let delete_res = match store {
+            Ok((lfs, resource_value)) => {
+                delete_fork_ducklake_data(lfs, resource_value, &ns.data_path).await
+            }
+            Err(e) => Err(Error::internal_err(e)),
+        };
+        if let Err(e) = delete_res {
+            // Record the completed schema phase so retries never need catalog credentials
+            // again (best effort — a failed update just means the next retry re-drops an
+            // absent schema, which requires the catalog to be reachable).
+            sqlx::query!(
+                "UPDATE fork_ducklake_namespace SET schema_dropped = true
+                 WHERE workspace_id = $1 AND ducklake_name = $2 AND catalog = $3
+                   AND storage = $4 AND storage_ref = $5 AND data_path = $6",
+                w_id,
+                &ns.ducklake_name,
+                &ns.catalog,
+                &ns.storage,
+                &ns.storage_ref,
+                &ns.data_path,
+            )
+            .execute(db)
+            .await
+            .ok();
+            errors.push(ForkDucklakeCleanupIssue {
+                blocking: false,
+                msg: format!(
+                    "Dropped metadata schema but could not delete data files under '{}' for ducklake://{}: {e}",
+                    ns.data_path, ns.ducklake_name
+                ),
+            });
+            continue;
+        }
+        sqlx::query!(
+            "DELETE FROM fork_ducklake_namespace
+             WHERE workspace_id = $1 AND ducklake_name = $2 AND catalog = $3
+               AND storage = $4 AND storage_ref = $5 AND data_path = $6",
+            w_id,
+            &ns.ducklake_name,
+            &ns.catalog,
+            &ns.storage,
+            &ns.storage_ref,
+            &ns.data_path,
+        )
+        .execute(db)
+        .await
+        .map_err(|e| {
+            errors.push(ForkDucklakeCleanupIssue {
+                blocking: false,
+                msg: format!(
+                    "Cleaned ducklake://{} but could not delete its registry row: {e}",
+                    ns.ducklake_name
+                ),
+            })
+        })
+        .ok();
+    }
+    errors
+}
+
+/// Drop the fork's metadata schema in the catalog database recorded by the registry row —
+/// NOT whatever the fork's settings point at by now: a drifted catalog resource must not make
+/// cleanup drop a schema in the wrong database while orphaning the real one. The pg schema
+/// holds only DuckLake metadata tables (auto-created at first fork attach), so a plain
+/// `DROP SCHEMA … CASCADE` on the catalog connection removes the whole fork namespace.
+/// Resolve the catalog connection recorded in the registry row (read-only): instance
+/// identities rebuild instance creds; resource identities resolve their `$res:` in the fork's
+/// workspace — which is why this must run BEFORE the workspace (and its resources) are
+/// deleted. Mysql never registers (rejected at resolution).
+async fn resolve_fork_catalog_pg(
+    db: &DB,
+    w_id: &str,
+    res_fallback_w_id: Option<&str>,
+    ducklake_name: &str,
+    catalog: &str,
+) -> Result<windmill_common::PgDatabase> {
+    let (resource_type, resource_path) = catalog.split_once(':').ok_or_else(|| {
+        Error::internal_err(format!(
+            "ducklake://{ducklake_name}: malformed registry catalog identity `{catalog}`"
+        ))
+    })?;
+    let catalog_resource = if resource_type == "instance" {
+        let mut pg_creds = windmill_common::PgDatabase::parse_uri(
+            &windmill_common::get_database_url().await?.as_str().await,
+        )?;
+        pg_creds.dbname = resource_path.to_string();
+        pg_creds.user = Some("custom_instance_user".to_string());
+        pg_creds.password =
+            Some(windmill_common::utils::get_custom_pg_instance_password(db).await?);
+        serde_json::to_value(&pg_creds)
+            .map_err(|e| Error::internal_err(format!("serializing pg creds: {e}")))?
+    } else {
+        resolve_res_with_fallback(db, w_id, res_fallback_w_id, resource_path).await?
+    };
+    serde_json::from_value(catalog_resource).map_err(|e| {
+        Error::internal_err(format!(
+            "ducklake://{ducklake_name}: catalog resource is not a postgres database: {e}"
+        ))
+    })
+}
+
+async fn drop_fork_ducklake_metadata_schema(
+    db: &DB,
+    pg: windmill_common::PgDatabase,
+    metadata_schema: &str,
+) -> Result<()> {
+    let (client, connection) = pg.connect(Some(db)).await?;
+    let join_handle = tokio::spawn(async move { connection.await });
+    let res = client
+        .execute(
+            &format!(
+                "DROP SCHEMA IF EXISTS \"{}\" CASCADE",
+                metadata_schema.replace('"', "\"\"")
+            ),
+            &[],
+        )
+        .await;
+    drop(client);
+    let _ = join_handle.await;
+    res.map_err(|e| Error::internal_err(format!("{e:#}")))?;
+    Ok(())
+}
+
+/// Resolve the storage identified by the registry's `storage_ref` (read-only) — the storage
+/// that was active when the fork's data was WRITTEN, not whatever the logical storage name
+/// points at by deletion time (a repointed storage must not orphan the original fork data,
+/// nor get a colliding prefix deleted). `storage_ref` = '' falls back to resolving the
+/// logical name against current settings (registration couldn't identify the storage — best
+/// effort). Resolves the `$res:` in the fork's workspace, which is why this must run BEFORE
+/// the workspace is deleted.
+async fn resolve_fork_storage(
+    db: &DB,
+    w_id: &str,
+    res_fallback_w_id: Option<&str>,
+    storage: Option<&str>,
+    storage_ref: &str,
+) -> Result<(windmill_types::s3::LargeFileStorage, serde_json::Value)> {
+    use windmill_types::s3::{
+        AzureBlobStorage, FilesystemStorage, GoogleCloudStorage, LargeFileStorage, S3Storage,
+    };
+
+    let lfs: LargeFileStorage = if let Some((typ, path)) = storage_ref.split_once(':') {
+        // Rebuild the LFS entry from the registered identity; only the variant (which
+        // resource parser applies) and the path matter to `lfs_to_object_store_resource`.
+        let s3 = |p: &str| S3Storage {
+            s3_resource_path: p.to_string(),
+            public_resource: None,
+            advanced_permissions: None,
+        };
+        match typ {
+            "S3Storage" => LargeFileStorage::S3Storage(s3(path)),
+            "S3AwsOidc" => LargeFileStorage::S3AwsOidc(s3(path)),
+            "AzureBlobStorage" => LargeFileStorage::AzureBlobStorage(AzureBlobStorage {
+                azure_blob_resource_path: path.to_string(),
+                public_resource: None,
+                advanced_permissions: None,
+            }),
+            "AzureWorkloadIdentity" => LargeFileStorage::AzureWorkloadIdentity(AzureBlobStorage {
+                azure_blob_resource_path: path.to_string(),
+                public_resource: None,
+                advanced_permissions: None,
+            }),
+            "GoogleCloudStorage" => LargeFileStorage::GoogleCloudStorage(GoogleCloudStorage {
+                gcs_resource_path: path.to_string(),
+                public_resource: None,
+                advanced_permissions: None,
+            }),
+            "FilesystemStorage" => LargeFileStorage::FilesystemStorage(FilesystemStorage {
+                root_path: path.to_string(),
+                public_resource: None,
+                advanced_permissions: None,
+            }),
+            other => {
+                return Err(Error::internal_err(format!(
+                    "unknown registered storage type `{other}`"
+                )))
+            }
+        }
+    } else {
+        let lfs_json = sqlx::query_scalar!(
+            "SELECT large_file_storage FROM workspace_settings WHERE workspace_id = $1",
+            w_id
+        )
+        .fetch_optional(db)
+        .await?
+        .flatten()
+        .ok_or_else(|| Error::BadRequest("workspace has no storage configured".to_string()))?;
+        // Named storages live under `secondary_storage`; `None`/`_default_` is the primary.
+        match storage.filter(|s| *s != "_default_") {
+            None => serde_json::from_value(lfs_json.clone())
+                .map_err(|e| Error::internal_err(format!("parsing large_file_storage: {e}")))?,
+            Some(name) => serde_json::from_value(
+                lfs_json
+                    .get("secondary_storage")
+                    .and_then(|s| s.get(name))
+                    .cloned()
+                    .ok_or_else(|| {
+                        Error::BadRequest(format!("workspace has no storage named {name}"))
+                    })?,
+            )
+            .map_err(|e| Error::internal_err(format!("parsing storage {name}: {e}")))?,
+        }
+    };
+    // Filesystem storage stores a direct path (`lfs_to_object_store_resource` ignores the
+    // resource value); everything else references a resource whose stored path may or may not
+    // carry the `$res:` prefix — same normalization as `get_workspace_s3_resource_from_lfs`.
+    let resource_value = if matches!(lfs, LargeFileStorage::FilesystemStorage(_)) {
+        serde_json::Value::Null
+    } else {
+        let path = lfs.get_s3_resource_path();
+        let path = path.strip_prefix("$res:").unwrap_or(path);
+        resolve_res_with_fallback(db, w_id, res_fallback_w_id, path).await?
+    };
+    Ok((lfs, resource_value))
+}
+
+/// Resolve a `$res:` path in `w_id`, falling back to the same path in `res_fallback_w_id`
+/// when the first lookup fails — retry-path cleanups run after the fork workspace (and its
+/// cloned resource rows) were deleted, and the fork's resources were clones of a parent's.
+async fn resolve_res_with_fallback(
+    db: &DB,
+    w_id: &str,
+    res_fallback_w_id: Option<&str>,
+    resource_path: &str,
+) -> Result<serde_json::Value> {
+    let res = windmill_common::workspaces::transform_json_value_unchecked(
+        &serde_json::Value::String(format!("$res:{resource_path}")),
+        w_id,
+        db,
+    )
+    .await;
+    match (res, res_fallback_w_id) {
+        (Ok(v), _) => Ok(v),
+        (Err(e), None) => Err(e),
+        (Err(_), Some(fb)) => {
+            windmill_common::workspaces::transform_json_value_unchecked(
+                &serde_json::Value::String(format!("$res:{resource_path}")),
+                fb,
+                db,
+            )
+            .await
+        }
+    }
+}
+
+/// Delete every object under the fork's data prefix in the pre-resolved storage. Requires the
+/// `parquet` (object store) feature; without it the metadata schema is still dropped and the
+/// unreachable data files are left for manual cleanup.
+#[cfg(feature = "parquet")]
+async fn delete_fork_ducklake_data(
+    lfs: windmill_types::s3::LargeFileStorage,
+    resource_value: serde_json::Value,
+    data_path: &str,
+) -> Result<()> {
+    use futures::{StreamExt, TryStreamExt};
+
+    let store = windmill_object_store::build_object_store_client(
+        &windmill_object_store::lfs_to_object_store_resource(&lfs, resource_value)?,
+    )
+    .await?;
+
+    let prefix = windmill_object_store::object_store_reexports::Path::from(
+        data_path.trim_matches('/').to_string(),
+    );
+    let locations: Vec<_> = store
+        .list(Some(&prefix))
+        .map_ok(|m| m.location)
+        .try_collect()
+        .await
+        .map_err(windmill_object_store::object_store_error_to_error)?;
+    // The object_store crate evaluates list prefixes on a path-SEGMENT basis (`a/b` does not
+    // match `a/bc/…`), so sibling fork segments sharing a string prefix are already excluded.
+    // Filter anyway — deletion must not depend on a listing implementation detail.
+    let boundary = format!("{}/", prefix.as_ref());
+    let locations: Vec<_> = locations
+        .into_iter()
+        .filter(|l| l.as_ref().starts_with(&boundary))
+        .collect();
+    // 1000-object chunks: S3 DeleteObjects caps a batch at 1000 keys.
+    for chunk in locations.chunks(1000) {
+        store
+            .delete_stream(futures::stream::iter(chunk.iter().cloned().map(Ok)).boxed())
+            .try_collect::<Vec<_>>()
+            .await
+            .map_err(windmill_object_store::object_store_error_to_error)?;
+    }
+    Ok(())
+}
+
+#[cfg(not(feature = "parquet"))]
+async fn delete_fork_ducklake_data(
+    _lfs: windmill_types::s3::LargeFileStorage,
+    _resource_value: serde_json::Value,
+    _data_path: &str,
+) -> Result<()> {
+    Err(Error::internal_err(
+        "object storage support (parquet feature) is not compiled in".to_string(),
+    ))
+}
+
+/// Destroying an ATTACHED dev workspace (or its data environments) must be a prod-admin
+/// action, not just the dev's own owner (dev ownership can diverge from prod's) — mirrors
+/// detach_dev_workspace. Shared by `delete_workspace` and `drop_forked_ducklake_namespaces`
+/// so the two gates cannot drift: the sidebar calls the drop endpoint BEFORE deleteWorkspace,
+/// and a weaker gate on the drop would let a non-prod-admin dev owner destroy the live dev's
+/// materializations and then have the deletion itself rejected. No-op for non-dev workspaces.
+async fn require_prod_admin_for_dev_workspace(
+    db: &DB,
+    authed: &ApiAuthed,
+    w_id: &str,
+) -> Result<()> {
+    if let Some(prod) = sqlx::query_scalar!(
+        "SELECT parent_workspace_id FROM workspace WHERE id = $1 AND is_dev_workspace",
+        w_id
+    )
+    .fetch_optional(db)
+    .await?
+    .flatten()
+    {
+        let is_prod_admin = sqlx::query_scalar!(
+            "SELECT is_admin FROM usr WHERE workspace_id = $1 AND email = $2",
+            &prod,
+            &authed.email
+        )
+        .fetch_optional(db)
+        .await?
+        .unwrap_or(false);
+        if !is_prod_admin && !is_super_admin_email(db, &authed.email).await? {
+            return Err(Error::PermissionDenied(format!(
+                "Destroying dev workspace '{w_id}' or its data requires being an admin of its parent prod workspace '{prod}' (or a superadmin)"
+            )));
+        }
+    }
+    Ok(())
+}
+
 async fn is_workspace_owner(
     authed: &ApiAuthed,
     w_id: &str,
diff --git a/backend/windmill-api/Cargo.toml b/backend/windmill-api/Cargo.toml
index ebbc98e83e..fa9ed3f2e5 100644
--- a/backend/windmill-api/Cargo.toml
+++ b/backend/windmill-api/Cargo.toml
@@ -10,7 +10,7 @@ path = "src/lib.rs"
 
 [features]
 default = []
-private = ["windmill-audit/private", "windmill-common/private", "windmill-api-auth/private", "windmill-store/private", "windmill-api-users/private", "windmill-api-workspaces/private", "windmill-api-groups/private", "windmill-api-configs/private", "windmill-api-settings/private", "windmill-api-assets/private", "windmill-api-agent-workers?/private", "windmill-trigger-kafka?/private", "windmill-trigger-postgres?/private", "windmill-trigger-mqtt?/private", "windmill-trigger-websocket?/private", "windmill-trigger-nats?/private", "windmill-trigger-sqs?/private", "windmill-trigger-gcp?/private", "windmill-trigger-azure?/private", "windmill-trigger-email?/private", "windmill-git-sync/private", "windmill-autoscaling?/private"]
+private = ["windmill-audit/private", "windmill-common/private", "windmill-api-auth/private", "windmill-store/private", "windmill-api-users/private", "windmill-api-workspaces/private", "windmill-api-groups/private", "windmill-api-configs/private", "windmill-api-settings/private", "windmill-api-assets/private", "windmill-api-agent-workers?/private", "windmill-trigger-kafka?/private", "windmill-trigger-postgres?/private", "windmill-trigger-mqtt?/private", "windmill-trigger-websocket?/private", "windmill-trigger-nats?/private", "windmill-trigger-sqs?/private", "windmill-trigger-gcp?/private", "windmill-trigger-azure?/private", "windmill-trigger-email?/private", "windmill-git-sync/private", "windmill-autoscaling?/private", "windmill-object-store/private"]
 enterprise = ["windmill-queue/enterprise", "windmill-audit/enterprise", "windmill-git-sync/enterprise", "windmill-common/enterprise", "windmill-worker?/enterprise", "windmill-api-auth/enterprise", "windmill-store/enterprise", "windmill-api-jobs/enterprise", "windmill-api-scripts/enterprise", "windmill-api-flows/enterprise", "windmill-api-users/enterprise", "windmill-api-workspaces/enterprise", "windmill-api-groups/enterprise", "windmill-api-configs/enterprise", "windmill-api-settings/enterprise", "windmill-api-schedule/enterprise", "windmill-api-agent-workers?/enterprise", "windmill-trigger/enterprise", "windmill-trigger-kafka?/enterprise", "windmill-trigger-postgres?/enterprise", "windmill-trigger-mqtt?/enterprise", "windmill-trigger-websocket?/enterprise", "windmill-trigger-email?/enterprise", "windmill-trigger-nats?/enterprise", "windmill-trigger-sqs?/enterprise", "windmill-trigger-gcp?/enterprise", "windmill-trigger-azure?/enterprise", "windmill-trigger-http?/enterprise", "windmill-native-triggers?/enterprise", "dep:windmill-autoscaling", "windmill-autoscaling/enterprise", "license"]
 stripe = []
 run_inline = ["dep:windmill-worker", "windmill-api-configs/run_inline"]
diff --git a/backend/windmill-api/openapi.yaml b/backend/windmill-api/openapi.yaml
index 5227693b18..7714cd89da 100644
--- a/backend/windmill-api/openapi.yaml
+++ b/backend/windmill-api/openapi.yaml
@@ -1,7 +1,7 @@
 openapi: "3.0.3"
 
 info:
-  version: 1.747.0
+  version: 1.749.0
   title: Windmill API
 
   contact:
@@ -4983,6 +4983,24 @@ paths:
                 items:
                   type: string
 
+  /w/{workspace}/workspaces/drop_forked_ducklake_namespaces:
+    post:
+      summary: drop this fork workspace's ducklake namespaces (catalog metadata schemas + data files)
+      operationId: dropForkedDucklakeNamespaces
+      tags:
+        - workspace
+      parameters:
+        - $ref: "#/components/parameters/WorkspaceId"
+      responses:
+        "200":
+          description: list of errors (empty if all succeeded)
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  type: string
+
   /w/{workspace}/workspaces/import_pg_database:
     post:
       summary: import a PostgreSQL database from source to target via pg_dump
@@ -9504,6 +9522,50 @@ paths:
                   items:
                     $ref: "#/components/schemas/CiTestResult"
 
+  /w/{workspace}/scripts/check_schema_contracts:
+    post:
+      summary: check a script's asset references against captured producer schemas
+      description: |
+        Save-time schema-contract check for data pipelines: validates the given
+        script content's asset references (body column reads, `// column` lineage,
+        `// data_test relationships`) against the latest captured producer schemas
+        and returns warnings. Warnings never block a save/deploy; an asset whose
+        producer declares `on_schema_change=ignore` is suppressed to a single
+        informational entry.
+      operationId: checkSchemaContracts
+      tags:
+        - script
+      parameters:
+        - $ref: "#/components/parameters/WorkspaceId"
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              required:
+                - language
+                - content
+              properties:
+                language:
+                  $ref: "#/components/schemas/ScriptLang"
+                content:
+                  type: string
+      responses:
+        "200":
+          description: contract warnings (empty when all references match)
+          content:
+            application/json:
+              schema:
+                type: object
+                required:
+                  - warnings
+                properties:
+                  warnings:
+                    type: array
+                    items:
+                      $ref: "#/components/schemas/ContractWarning"
+
   /w/{workspace}/scripts/raw_temp/store:
     post:
       summary: store raw script content temporarily for CLI lock generation
@@ -21737,6 +21799,10 @@ paths:
                           $ref: "#/components/schemas/AssetKind"
                         path:
                           type: string
+                        fork_materialization:
+                          type: string
+                          enum: [fork, deferred]
+                          description: Fork workspaces only — 'fork' when this ducklake asset was materialized in the fork itself, 'deferred' when reads fall back to the parent workspace's current table via a defer view. Omitted otherwise.
                   runnables:
                     type: array
                     items:
@@ -21846,6 +21912,38 @@ paths:
                             type: string
                         via_use:
                           type: boolean
+                  test_edges:
+                    type: array
+                    description: >-
+                      Ordering-only "must-run-after" edges — a `// data_test relationships`
+                      (or custom test reading a pipeline asset) requires the referenced
+                      asset's producer to run before the tested script. Not a data-consumption
+                      edge; fed into the cascade topo-sort so cold runs order correctly.
+                      Omitted when empty.
+                    items:
+                      type: object
+                      required:
+                        [
+                          producer_kind,
+                          producer_path,
+                          runnable_kind,
+                          runnable_path,
+                          asset_kind,
+                          asset_path,
+                        ]
+                      properties:
+                        producer_kind:
+                          $ref: "#/components/schemas/AssetUsageKind"
+                        producer_path:
+                          type: string
+                        runnable_kind:
+                          $ref: "#/components/schemas/AssetUsageKind"
+                        runnable_path:
+                          type: string
+                        asset_kind:
+                          $ref: "#/components/schemas/AssetKind"
+                        asset_path:
+                          type: string
 
   /w/{workspace}/assets/macros:
     get:
@@ -25909,6 +26007,7 @@ components:
         - google
         - github
         - asset
+        - freshness
 
     TriggerMode:
       description: job trigger mode
@@ -28450,6 +28549,11 @@ components:
               new_dbname:
                 type: string
                 description: "New database name for the fork"
+        shared_ducklakes:
+          type: array
+          items:
+            type: string
+          description: "Lake names the fork SHARES with the parent (reads and writes the parent's lake directly). Every lake not listed gets the default isolated fork namespace with read-defer to the parent."
         is_dev_workspace:
           type: boolean
           description: "Create the fork as a persistent dev workspace (id not required to carry the wm-fork- prefix; at most one per parent)"
@@ -29189,6 +29293,33 @@ components:
                   - path
               extra_args:
                 type: string
+              fork_behavior:
+                type: string
+                enum: [isolated, shared]
+                description:
+                  Fork workspaces only - how this lake behaves in the fork, stamped at fork
+                  creation. Absent = isolated (fork-scoped namespace + read-defer to parent).
+              maintenance:
+                type: object
+                description:
+                  Scheduled maintenance (enterprise) - snapshot expiry, adjacent-file
+                  compaction and orphaned-file cleanup, run as a managed per-lake schedule
+                required: [enabled]
+                properties:
+                  enabled:
+                    type: boolean
+                  schedule:
+                    type: string
+                    description: cron cadence (v2, UTC); defaults to daily at 03h with a per-lake minute offset
+                  retention_days:
+                    type: integer
+                    description: snapshot retention window in days (default 7); time-travel older than this stops working
+                  compaction:
+                    type: boolean
+                    description: merge adjacent small parquet files (default true)
+                  orphan_cleanup:
+                    type: boolean
+                    description: delete orphaned files older than max(retention, 1 day) (default true)
 
     DataTableSettings:
       type: object
@@ -30260,6 +30391,39 @@ components:
         kind:
           $ref: "#/components/schemas/AssetKind"
       required: [path, kind]
+    ContractWarning:
+      description: |
+        One save-time schema-contract warning: a consumer reference that does
+        not match the referenced asset's latest captured schema.
+        `schema_version`/`captured_at` identify the capture the check ran
+        against (as-of the producer's last run, not its latest save).
+      type: object
+      required: [kind, asset_path, message]
+      properties:
+        kind:
+          type: string
+          enum:
+            - missing_column
+            - missing_lineage_source
+            - missing_relationship_column
+            - relationship_type_mismatch
+            - suppressed
+        asset_path:
+          type: string
+        column:
+          type: string
+        expected_type:
+          type: string
+        found_type:
+          type: string
+        schema_version:
+          type: integer
+          format: int64
+        captured_at:
+          type: string
+          format: date-time
+        message:
+          type: string
     Volume:
       type: object
       required:
diff --git a/backend/windmill-api/src/workspaces_export.rs b/backend/windmill-api/src/workspaces_export.rs
index fc2bfab8b4..839057b4b9 100644
--- a/backend/windmill-api/src/workspaces_export.rs
+++ b/backend/windmill-api/src/workspaces_export.rs
@@ -919,11 +919,16 @@ pub(crate) async fn tarball_workspace(
     }
 
     if include_schedules.unwrap_or(false) {
+        // Managed ducklake-maintenance schedules are excluded: they are
+        // derived from the workspace ducklake settings (and admins bypass the
+        // RLS that hides them), so exporting them would drag unsyncable rows
+        // into git.
         let schedules = sqlx::query_as::<_, Schedule>(
             "SELECT workspace_id, path, edited_by, edited_at, schedule, timezone, enabled, script_path, is_flow, args, extra_perms, email, permissioned_as, error, on_failure, on_failure_times, on_failure_exact, on_failure_extra_args, on_recovery, on_recovery_times, on_recovery_extra_args, on_success, on_success_extra_args, ws_error_handler_muted, retry, no_flow_overlap, summary, description, tag, paused_until, cron_version, dynamic_skip, labels FROM schedule
-             WHERE workspace_id = $1",
+             WHERE workspace_id = $1 AND NOT starts_with(path, $2)",
         )
         .bind(&w_id)
+        .bind(windmill_common::workspaces::DUCKLAKE_MAINTENANCE_PATH_PREFIX)
         .fetch_all(&mut *tx)
         .await?;
 
diff --git a/backend/windmill-common/src/assets.rs b/backend/windmill-common/src/assets.rs
index 0757ef6894..862bd645c3 100644
--- a/backend/windmill-common/src/assets.rs
+++ b/backend/windmill-common/src/assets.rs
@@ -6,7 +6,7 @@ use crate::{error, scripts::ScriptHash};
 
 pub use windmill_parser::asset_parser::{
     merge_column_lineage, parse_pipeline_annotations, ColumnLineage, ColumnRef, DataTest,
-    PartitionKind, PipelineAnnotations, RetrySpec, TriggerSpec, PARTITION_TOKEN,
+    OnSchemaChange, PartitionKind, PipelineAnnotations, RetrySpec, TriggerSpec, PARTITION_TOKEN,
 };
 pub use windmill_types::assets::*;
 
@@ -352,6 +352,10 @@ mod debounce_duration_tests {
         assert_eq!(parse_duration_secs("5m"), Some(300));
         assert_eq!(parse_duration_secs("2h"), Some(7200));
         assert_eq!(parse_duration_secs(" 1d "), Some(86400));
+        // Explicit plus sign comes free with i64 parsing; the TS mirror
+        // (parseDurationSecs) matches it — keep the two in lockstep.
+        assert_eq!(parse_duration_secs("+5m"), Some(300));
+        assert_eq!(parse_duration_secs("+45"), Some(45));
     }
 
     #[test]
@@ -365,6 +369,45 @@ mod debounce_duration_tests {
     }
 }
 
+#[cfg(test)]
+mod trigger_ref_roundtrip_tests {
+    use super::{parse_asset_trigger_ref, trigger_spec_to_row, AssetKind, ScriptTriggerKind};
+    use windmill_parser::asset_parser::{parse_asset_syntax, AssetKind as PAssetKind, TriggerSpec};
+
+    // `trigger_spec_to_row` rebuilds a stored ref as `s3://<path>`, and
+    // `parse_asset_trigger_ref` parses it back. The two must be inverse for
+    // every S3 URI form, or a consumer's `// on` trigger lands on a different
+    // graph node than the producer's inferred write. Because `parse_asset_syntax`
+    // strips ALL leading slashes, a canonical path never starts with `/`, so the
+    // naive `prefix + path` rebuild round-trips — including the `S3Object(s3="/x")`
+    // quad-slash case that previously desynced (path `/x` rebuilt to `s3:///x`,
+    // which re-parsed to `x`).
+    fn roundtrip(uri: &str) -> String {
+        let (pkind, path) = parse_asset_syntax(uri, false).expect("parse uri");
+        assert_eq!(pkind, PAssetKind::S3Object);
+        let spec = TriggerSpec::Asset { asset_kind: pkind, path: path.to_string(), debounce: None };
+        let (kind, stored) = trigger_spec_to_row(&spec).expect("to row");
+        assert_eq!(kind, ScriptTriggerKind::Asset);
+        let (rkind, rpath) = parse_asset_trigger_ref(&stored).expect("parse ref");
+        assert_eq!(rkind, AssetKind::S3Object);
+        // The producer path and the round-tripped consumer path must match.
+        assert_eq!(
+            rpath, path,
+            "round-trip diverged for {uri} (stored {stored})"
+        );
+        rpath
+    }
+
+    #[test]
+    fn s3_trigger_ref_roundtrips_for_every_uri_form() {
+        assert_eq!(roundtrip("s3:///exports/x"), "exports/x"); // SDK default storage
+        assert_eq!(roundtrip("s3://exports/x"), "exports/x"); // DuckDB / bare
+        assert_eq!(roundtrip("s3://mybucket/exports/x"), "mybucket/exports/x"); // explicit
+        assert_eq!(roundtrip("s3:////x"), "x"); // S3Object(s3="/x") quad-slash
+        assert_eq!(roundtrip("s3:///y=2024/f.parquet"), "y=2024/f.parquet"); // Hive
+    }
+}
+
 // Inverse of trigger_spec_to_row for the Asset variant: parses a stored
 // trigger_ref (e.g. `s3://foo`, `$res:bar`) back into the (kind, path) pair
 // used as a graph node id. Returns None for refs that don't match any known
diff --git a/backend/windmill-common/src/lib.rs b/backend/windmill-common/src/lib.rs
index baa3e4b500..acf97734d8 100644
--- a/backend/windmill-common/src/lib.rs
+++ b/backend/windmill-common/src/lib.rs
@@ -65,6 +65,7 @@ pub mod materialization;
 pub mod min_version;
 pub mod notify_events;
 pub mod runtime_assets;
+pub mod schema_contracts;
 pub mod workspace_dependencies;
 
 #[cfg(feature = "private")]
diff --git a/backend/windmill-common/src/materialization.rs b/backend/windmill-common/src/materialization.rs
index 8d9e31899f..236a71c855 100644
--- a/backend/windmill-common/src/materialization.rs
+++ b/backend/windmill-common/src/materialization.rs
@@ -94,7 +94,11 @@ pub async fn record_materialization<'e>(
          VALUES ($1, $2, $3, $4, $5, $6, $7, $8, now(), $9)
          ON CONFLICT (workspace_id, asset_kind, asset_path, partition)
          DO UPDATE SET status = EXCLUDED.status,
-                       snapshot_id = EXCLUDED.snapshot_id,
+                       -- A failed run records no snapshot, but must not erase the last
+                       -- committed one: a physical table from an earlier commit (or from a
+                       -- committed write whose data tests then failed) still exists, and
+                       -- fork defer/graph state keys on that evidence.
+                       snapshot_id = COALESCE(EXCLUDED.snapshot_id, materialized_partition.snapshot_id),
                        row_count = EXCLUDED.row_count,
                        job_id = EXCLUDED.job_id,
                        materialized_at = now(),
@@ -255,6 +259,98 @@ pub async fn record_asset_schema(
     Ok(true)
 }
 
+/// One table a fork workspace should read from an ancestor through a defer view.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ForkDeferTable {
+    /// Lake-internal table name: the `asset_path` minus its `<lake>/` prefix (may itself be
+    /// `schema.table`).
+    pub table: String,
+    /// The owning ancestor's latest captured schema carries the SCD2 marker column
+    /// (`is_current`), so that lake also holds a managed `<table>_current` companion view
+    /// that consumers read — defer it alongside the table.
+    #[serde(default)]
+    pub with_current_view: bool,
+    /// Index into `DucklakeForkDefer.ancestors` (nearest-first) of the NEAREST ancestor that
+    /// materialized this table — the defer view must target that ancestor's namespace. In a
+    /// `fork → parent → root` chain where only root materialized a table, the parent has no
+    /// physical copy (it defers too), so a view over the parent would not bind. Defaults to 0
+    /// (the direct parent) for wire compatibility with agents that predate the field.
+    #[serde(default)]
+    pub ancestor_idx: u32,
+}
+
+/// Tables of lake `lake_name` materialized somewhere in the fork's ancestor chain
+/// (nearest-first) but not (yet) in the fork — the fork's read-defer set, each mapped to the
+/// nearest ancestor that owns a physical copy. Only `Materialized` rows count on every side: a
+/// deferred table must physically exist in the targeted ancestor (defer views bind at CREATE
+/// and would otherwise fail the whole job), and any successful fork materialization makes the
+/// fork's own table authoritative.
+///
+/// **Authorization:** performs no access control; trusted server-side callers only. It reads
+/// ancestor workspaces' rows on behalf of a fork — acceptable because defer itself exposes
+/// the ancestors' table contents to fork members.
+pub async fn list_fork_defer_tables<'e>(
+    executor: impl PgExecutor<'e>,
+    ancestor_workspace_ids: &[String],
+    fork_workspace_id: &str,
+    lake_name: &str,
+) -> Result<Vec<ForkDeferTable>> {
+    let rows = sqlx::query!(
+        r#"
+        WITH ancestor AS (
+            SELECT wid, ord FROM unnest($1::text[]) WITH ORDINALITY AS a(wid, ord)
+        ), anc_mat AS (
+            -- Per table, the nearest ancestor (lowest ord) that materialized it.
+            SELECT DISTINCT ON (mp.asset_path) mp.asset_path, a.wid, a.ord
+            FROM materialized_partition mp
+            JOIN ancestor a ON a.wid = mp.workspace_id
+            WHERE mp.asset_kind = 'ducklake' AND mp.status = 'materialized'
+              AND split_part(mp.asset_path, '/', 1) = $3 AND mp.asset_path LIKE '%/%'
+            ORDER BY mp.asset_path, a.ord
+        ), fork_mat AS (
+            -- Fork-OWNED assets: anything whose physical table exists in the fork
+            -- namespace, not just clean materializations. A committed write whose data
+            -- tests failed afterwards records status='failed' WITH a snapshot — its table
+            -- is real, and a defer view emitted over it would silently yield to it
+            -- (CREATE VIEW IF NOT EXISTS) while claiming the read defers to the parent.
+            SELECT DISTINCT asset_path FROM materialized_partition
+            WHERE workspace_id = $2 AND asset_kind = 'ducklake'
+              AND (status = 'materialized' OR snapshot_id IS NOT NULL)
+        ), latest_schema AS (
+            SELECT DISTINCT ON (workspace_id, asset_path) workspace_id, asset_path, columns
+            FROM materialized_asset_schema
+            WHERE workspace_id = ANY($1) AND asset_kind = 'ducklake'
+            ORDER BY workspace_id, asset_path, version DESC
+        )
+        SELECT am.asset_path AS "asset_path!",
+               am.ord AS "ord!",
+               COALESCE(EXISTS (
+                   SELECT 1 FROM jsonb_array_elements(ls.columns) e
+                   WHERE e->>'name' = 'is_current'
+               ), false) AS "has_current!"
+        FROM anc_mat am
+        LEFT JOIN latest_schema ls
+               ON ls.asset_path = am.asset_path AND ls.workspace_id = am.wid
+        WHERE am.asset_path NOT IN (SELECT asset_path FROM fork_mat)
+        ORDER BY am.asset_path
+        "#,
+        ancestor_workspace_ids,
+        fork_workspace_id,
+        lake_name,
+    )
+    .fetch_all(executor)
+    .await?;
+    Ok(rows
+        .into_iter()
+        .map(|r| ForkDeferTable {
+            table: r.asset_path[lake_name.len() + 1..].to_string(),
+            with_current_view: r.has_current,
+            // WITH ORDINALITY is 1-based; ancestors vec is 0-based.
+            ancestor_idx: (r.ord - 1).max(0) as u32,
+        })
+        .collect())
+}
+
 /// All captured schema versions for one asset, newest version first.
 ///
 /// **Authorization:** performs no access control (mirrors
diff --git a/backend/windmill-common/src/pipeline_advanced_oss.rs b/backend/windmill-common/src/pipeline_advanced_oss.rs
index 009e783bd5..3220b251a0 100644
--- a/backend/windmill-common/src/pipeline_advanced_oss.rs
+++ b/backend/windmill-common/src/pipeline_advanced_oss.rs
@@ -1,16 +1,27 @@
-//! OSS fallback: pipeline freshness/SLA enforcement and partition backfills
-//! are enterprise features; their implementations live in windmill-ee-private
-//! (see `pipeline_advanced_ee`). In the public build the entry points report
-//! that the enterprise edition is required.
+//! OSS fallback for enterprise pipeline features (implementations in
+//! windmill-ee-private, see `pipeline_advanced_ee`): partition backfill
+//! reports that the enterprise edition is required, and materialization-plan
+//! assembly runs the plan verbatim — dbt-like commit-then-test instead of the
+//! enterprise write-audit-publish. (Freshness lives elsewhere: the fresh/stale
+//! badge is CE in the assets API, the active watchdog is windmill-queue's
+//! `freshness_watchdog`.)
 
 use crate::error::Error;
 
-pub fn freshness_enforcement_todo() -> Error {
-    Error::internal_err(
-        "Pipeline freshness/SLA enforcement requires the enterprise edition".to_string(),
-    )
-}
-
 pub fn backfill_todo() -> Error {
     Error::internal_err("Pipeline partition backfill requires the enterprise edition".to_string())
 }
+
+/// Assemble a materialization plan into the statement list the DuckDB executor
+/// runs. The public build executes the plan verbatim — dbt-like
+/// commit-then-test: a failing `// data_test` still fails the run and stops
+/// the cascade, but the written slice stays live. The enterprise
+/// implementation (`pipeline_advanced_ee`) instead restructures the plan into
+/// write-audit-publish, where a failing test rolls the whole write back before
+/// anything is published.
+pub fn finalize_materialize_query(
+    plan: windmill_parser::sql_materialize::MaterializePlan,
+    _asset_path: &str,
+) -> Vec<String> {
+    plan.stmts.into_iter().map(|s| s.sql).collect()
+}
diff --git a/backend/windmill-common/src/schema_contracts.rs b/backend/windmill-common/src/schema_contracts.rs
new file mode 100644
index 0000000000..b605aae33b
--- /dev/null
+++ b/backend/windmill-common/src/schema_contracts.rs
@@ -0,0 +1,614 @@
+//! Save-time schema-contract check (pipelines gap #2b): validate a consumer
+//! script's asset references against the latest *captured* producer schema
+//! (`materialized_asset_schema`, written post-materialize by #2a) and return
+//! WARNINGS — never errors. A deliberate upstream reshape must not fail every
+//! consumer save; blocking (`on_schema_change=fail`) is deliberately not
+//! offered in v1.
+//!
+//! Ducklake-only: `// materialize` targets are ducklake-only in v1, so nothing
+//! else has a captured schema to check against; an asset with no captured
+//! schema produces no warnings (first deploy, datatable, external tables).
+//!
+//! The comparison itself (`diff_contract`) is pure so it can be unit-tested
+//! and mirrored 1:1 by the editor-side TS check
+//! (frontend/src/lib/components/assets/AssetGraph/schemaContracts.ts); the
+//! async wrapper owns the DB reads (schemas + producer resolution) and runs on
+//! the caller's RLS-scoped transaction.
+
+use std::collections::{HashMap, HashSet};
+
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use sqlx::types::Json;
+use sqlx::{Postgres, Transaction};
+use windmill_parser::asset_parser::{
+    ColumnLineage, DataTest, MaterializeSpec, OnSchemaChange, PARTITION_TOKEN,
+};
+use windmill_types::assets::{AssetKind, AssetWithAltAccessType};
+
+use crate::error::Result;
+use crate::materialization::SchemaColumn;
+
+/// Columns the materialize engine adds/manages; never part of the captured
+/// schema, so consumer reads of them must not warn (`_wm_partition` is
+/// filtered out of the DESCRIBE capture on purpose).
+const RESERVED_COLUMNS: &[&str] = &["_wm_partition"];
+
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum ContractWarningKind {
+    /// A column the body reads/writes is absent from the captured schema.
+    MissingColumn,
+    /// A `// column … <- <asset>.<col>` source column is absent.
+    MissingLineageSource,
+    /// A `// data_test relationships … -> <asset>.<col>` ref column is absent.
+    MissingRelationshipColumn,
+    /// Relationship join columns have different captured types (may still
+    /// coerce at run time — phrased as "differs", not "will fail").
+    RelationshipTypeMismatch,
+    /// Warnings for this asset were suppressed by the producer's
+    /// `on_schema_change=ignore` (one informational entry per asset).
+    Suppressed,
+}
+
+/// One save-time contract warning. `schema_version`/`captured_at` identify the
+/// capture the check ran against, so a stale-capture warning is
+/// self-explaining (the schema is as-of the producer's last run, not its
+/// latest save).
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
+pub struct ContractWarning {
+    pub kind: ContractWarningKind,
+    /// Normalized ducklake asset path (`<lake>/<table>`).
+    pub asset_path: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub column: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub expected_type: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub found_type: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub schema_version: Option<i64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub captured_at: Option<DateTime<Utc>>,
+    pub message: String,
+}
+
+/// The latest captured schema of one asset, as loaded by the wrapper.
+#[derive(Debug, Clone)]
+pub struct CapturedSchema {
+    pub columns: Vec<SchemaColumn>,
+    pub version: i64,
+    pub captured_at: DateTime<Utc>,
+}
+
+impl CapturedSchema {
+    /// Case-insensitive column lookup — DuckDB matches unquoted identifiers
+    /// case-insensitively, and the body parser preserves source casing while
+    /// DESCRIBE returns stored casing.
+    fn find(&self, name: &str) -> Option<&SchemaColumn> {
+        self.columns
+            .iter()
+            .find(|c| c.name.eq_ignore_ascii_case(name))
+    }
+}
+
+fn is_reserved(name: &str) -> bool {
+    RESERVED_COLUMNS
+        .iter()
+        .any(|r| r.eq_ignore_ascii_case(name))
+}
+
+/// Strip the `{partition}` token a declared URI may carry (`// on
+/// ducklake://lake/t/{partition}` or pasted refs) so lookups hit the captured
+/// path. Body-inferred paths never carry it, but annotation refs can.
+pub fn normalize_asset_path(path: &str) -> String {
+    path.replace(&format!("/{}", PARTITION_TOKEN), "")
+        .replace(PARTITION_TOKEN, "")
+        .trim_end_matches('/')
+        .to_string()
+}
+
+fn column_list(schema: &CapturedSchema) -> String {
+    schema
+        .columns
+        .iter()
+        .map(|c| c.name.as_str())
+        .collect::<Vec<_>>()
+        .join(", ")
+}
+
+/// Pure comparison: consumer refs vs captured schemas. `schemas` is keyed by
+/// normalized ducklake path (the `_current` → base-table fallback is resolved
+/// by the wrapper before this runs); `ignored` holds paths whose producer
+/// declared `on_schema_change=ignore`.
+pub fn diff_contract(
+    assets: &[AssetWithAltAccessType],
+    column_lineage: &[ColumnLineage],
+    data_tests: &[DataTest],
+    materialize: Option<&MaterializeSpec>,
+    schemas: &HashMap<String, CapturedSchema>,
+    ignored: &HashSet<String>,
+) -> Vec<ContractWarning> {
+    let mut warnings: Vec<ContractWarning> = vec![];
+
+    // W1 — body-read/written columns missing from the captured schema. Assets
+    // whose column set the parser could not derive (`columns: None`, e.g.
+    // wildcard SELECT or non-SQL access) are skipped fail-safe; a literal "*"
+    // key is skipped defensively for the same reason.
+    for a in assets {
+        if a.kind != AssetKind::Ducklake {
+            continue;
+        }
+        let Some(columns) = a.columns.as_ref() else {
+            continue;
+        };
+        let path = normalize_asset_path(&a.path);
+        let Some(schema) = schemas.get(&path) else {
+            continue;
+        };
+        for col in columns.keys() {
+            if col == "*" || is_reserved(col) {
+                continue;
+            }
+            if schema.find(col).is_none() {
+                warnings.push(ContractWarning {
+                    kind: ContractWarningKind::MissingColumn,
+                    asset_path: path.clone(),
+                    column: Some(col.clone()),
+                    expected_type: None,
+                    found_type: None,
+                    schema_version: Some(schema.version),
+                    captured_at: Some(schema.captured_at),
+                    message: format!(
+                        "column `{col}` of ducklake://{path} is not in its captured schema \
+                         (v{}, columns: {})",
+                        schema.version,
+                        column_list(schema)
+                    ),
+                });
+            }
+        }
+    }
+
+    // W2 — `// column` lineage source refs. Only annotation-declared lineage
+    // reaches this fn (AST-inferred lineage is redundant with W1 and can
+    // mis-attribute aliases).
+    for cl in column_lineage {
+        for input in &cl.inputs {
+            if input.from_kind != windmill_parser::asset_parser::AssetKind::Ducklake {
+                continue;
+            }
+            let path = normalize_asset_path(&input.from_path);
+            let Some(schema) = schemas.get(&path) else {
+                continue;
+            };
+            if is_reserved(&input.from_column) {
+                continue;
+            }
+            if schema.find(&input.from_column).is_none() {
+                warnings.push(ContractWarning {
+                    kind: ContractWarningKind::MissingLineageSource,
+                    asset_path: path.clone(),
+                    column: Some(input.from_column.clone()),
+                    expected_type: None,
+                    found_type: None,
+                    schema_version: Some(schema.version),
+                    captured_at: Some(schema.captured_at),
+                    message: format!(
+                        "`// column {}` reads `{}` from ducklake://{path}, which is not in \
+                         its captured schema (v{})",
+                        cl.column, input.from_column, schema.version
+                    ),
+                });
+            }
+        }
+    }
+
+    // W3 — relationships data-test refs: the referenced column must exist;
+    // when both sides have captured types, flag a difference. Types come from
+    // DuckDB DESCRIBE on both sides so verbatim spellings are comparable; the
+    // runtime probe's IN-subquery still coerces, so a difference is "differs",
+    // never "will fail".
+    let own_schema = materialize
+        .filter(|m| m.target_kind == windmill_parser::asset_parser::AssetKind::Ducklake)
+        .and_then(|m| schemas.get(&normalize_asset_path(&m.target_path)));
+    for dt in data_tests {
+        let DataTest::Relationships { column, to_kind, to_path, to_column } = dt else {
+            continue;
+        };
+        if *to_kind != windmill_parser::asset_parser::AssetKind::Ducklake {
+            continue;
+        }
+        let path = normalize_asset_path(to_path);
+        let Some(schema) = schemas.get(&path) else {
+            continue;
+        };
+        match schema.find(to_column) {
+            None => {
+                warnings.push(ContractWarning {
+                    kind: ContractWarningKind::MissingRelationshipColumn,
+                    asset_path: path.clone(),
+                    column: Some(to_column.clone()),
+                    expected_type: None,
+                    found_type: None,
+                    schema_version: Some(schema.version),
+                    captured_at: Some(schema.captured_at),
+                    message: format!(
+                        "`// data_test relationships {column}` references \
+                         ducklake://{path}.{to_column}, which is not in its captured schema \
+                         (v{})",
+                        schema.version
+                    ),
+                });
+            }
+            Some(ref_col) => {
+                if let Some(own_col) = own_schema.and_then(|s| s.find(column)) {
+                    if !own_col.data_type.eq_ignore_ascii_case(&ref_col.data_type) {
+                        warnings.push(ContractWarning {
+                            kind: ContractWarningKind::RelationshipTypeMismatch,
+                            asset_path: path.clone(),
+                            column: Some(to_column.clone()),
+                            expected_type: Some(own_col.data_type.clone()),
+                            found_type: Some(ref_col.data_type.clone()),
+                            schema_version: Some(schema.version),
+                            captured_at: Some(schema.captured_at),
+                            message: format!(
+                                "`// data_test relationships {column}` joins `{}` ({}) to \
+                                 ducklake://{path}.{to_column} ({}) — captured types differ",
+                                column, own_col.data_type, ref_col.data_type
+                            ),
+                        });
+                    }
+                }
+            }
+        }
+    }
+
+    // W4 — producer opted the asset out (`on_schema_change=ignore`): drop its
+    // warnings, leaving one informational entry per suppressed asset so the
+    // response still records that a mismatch exists but was muted upstream.
+    if !ignored.is_empty() {
+        let mut suppressed_assets: Vec<String> = vec![];
+        warnings.retain(|w| {
+            if ignored.contains(&w.asset_path) {
+                if !suppressed_assets.contains(&w.asset_path) {
+                    suppressed_assets.push(w.asset_path.clone());
+                }
+                false
+            } else {
+                true
+            }
+        });
+        for path in suppressed_assets {
+            warnings.push(ContractWarning {
+                kind: ContractWarningKind::Suppressed,
+                asset_path: path.clone(),
+                column: None,
+                expected_type: None,
+                found_type: None,
+                schema_version: None,
+                captured_at: None,
+                message: format!(
+                    "schema mismatches on ducklake://{path} suppressed by its producer's \
+                     `on_schema_change=ignore`"
+                ),
+            });
+        }
+    }
+
+    warnings
+}
+
+/// Load captured schemas + producer modes and run the contract check for one
+/// consumer script's parsed refs.
+///
+/// Runs on the caller's RLS-scoped transaction (`user_db`), consistent with
+/// the `listAssetSchemas` read path: a producer script the caller cannot read
+/// simply stays unresolved and keeps the default `warn` behavior. Draft-only
+/// producers have no `asset` write edges yet and likewise default to `warn`.
+pub async fn check_schema_contracts(
+    tx: &mut Transaction<'_, Postgres>,
+    workspace_id: &str,
+    assets: &[AssetWithAltAccessType],
+    column_lineage: &[ColumnLineage],
+    data_tests: &[DataTest],
+    materialize: Option<&MaterializeSpec>,
+) -> Result<Vec<ContractWarning>> {
+    // Referenced ducklake paths (normalized) across every ref family the diff
+    // inspects — plus the consumer's own materialize target (for W3 types).
+    let mut paths: HashSet<String> = HashSet::new();
+    for a in assets {
+        if a.kind == AssetKind::Ducklake && a.columns.is_some() {
+            paths.insert(normalize_asset_path(&a.path));
+        }
+    }
+    for cl in column_lineage {
+        for input in &cl.inputs {
+            if input.from_kind == windmill_parser::asset_parser::AssetKind::Ducklake {
+                paths.insert(normalize_asset_path(&input.from_path));
+            }
+        }
+    }
+    for dt in data_tests {
+        if let DataTest::Relationships { to_kind, to_path, .. } = dt {
+            if *to_kind == windmill_parser::asset_parser::AssetKind::Ducklake {
+                paths.insert(normalize_asset_path(to_path));
+            }
+        }
+    }
+    if let Some(m) = materialize {
+        if m.target_kind == windmill_parser::asset_parser::AssetKind::Ducklake {
+            paths.insert(normalize_asset_path(&m.target_path));
+        }
+    }
+    if paths.is_empty() {
+        return Ok(vec![]);
+    }
+
+    // A managed scd2 producer (re)creates a `<dim>_current` view with the base
+    // table's columns; only the base table's schema is captured. Include the
+    // base path in the lookup so `_current` readers can fall back to it (the
+    // fallback itself is gated on the producer's spec below).
+    let mut lookup_paths: HashSet<String> = paths.clone();
+    for p in &paths {
+        if let Some(base) = p.strip_suffix("_current") {
+            if !base.is_empty() {
+                lookup_paths.insert(base.to_string());
+            }
+        }
+    }
+    let lookup_vec: Vec<String> = lookup_paths.into_iter().collect();
+
+    let schema_rows = sqlx::query!(
+        r#"SELECT DISTINCT ON (asset_path)
+                  asset_path, version, columns AS "columns: Json<Vec<SchemaColumn>>", captured_at
+             FROM materialized_asset_schema
+            WHERE workspace_id = $1 AND asset_kind = 'ducklake' AND asset_path = ANY($2)
+            ORDER BY asset_path, version DESC"#,
+        workspace_id,
+        &lookup_vec,
+    )
+    .fetch_all(&mut **tx)
+    .await?;
+    let mut schemas: HashMap<String, CapturedSchema> = schema_rows
+        .into_iter()
+        .map(|r| {
+            (
+                r.asset_path,
+                CapturedSchema {
+                    columns: r.columns.0,
+                    version: r.version,
+                    captured_at: r.captured_at,
+                },
+            )
+        })
+        .collect();
+
+    // Producer resolution: write edges on the referenced assets → latest
+    // non-archived producer content → parsed `// materialize` spec. Drives
+    // both the `on_schema_change=ignore` suppression and the `_current`
+    // fallback. Flow writers are excluded — they cannot carry the annotation.
+    let paths_vec: Vec<String> = paths.iter().cloned().collect();
+    let producer_edges = sqlx::query!(
+        r#"SELECT DISTINCT path AS "asset_path!", usage_path AS "producer_path!"
+             FROM asset
+            WHERE workspace_id = $1 AND kind = 'ducklake' AND path = ANY($2)
+              AND usage_kind = 'script' AND usage_access_type IN ('w', 'rw')"#,
+        workspace_id,
+        &paths_vec,
+    )
+    .fetch_all(&mut **tx)
+    .await?;
+
+    let mut ignored: HashSet<String> = HashSet::new();
+    if !producer_edges.is_empty() {
+        let producer_paths: Vec<String> = producer_edges
+            .iter()
+            .map(|e| e.producer_path.clone())
+            .collect::<HashSet<_>>()
+            .into_iter()
+            .collect();
+        // Same latest-content pattern as the asset-graph endpoint; NOT
+        // `get_latest_script_hash`, whose `lock IS NOT NULL` filter transiently
+        // excludes a just-deployed producer pending its dependency job.
+        let producer_rows = sqlx::query!(
+            r#"SELECT DISTINCT ON (path) path, content
+                 FROM script
+                WHERE workspace_id = $1 AND path = ANY($2)
+                  AND archived = false AND deleted = false
+                ORDER BY path, created_at DESC"#,
+            workspace_id,
+            &producer_paths,
+        )
+        .fetch_all(&mut **tx)
+        .await?;
+        let producer_specs: HashMap<String, Option<MaterializeSpec>> = producer_rows
+            .into_iter()
+            .map(|r| {
+                (
+                    r.path,
+                    windmill_parser::asset_parser::parse_pipeline_annotations(&r.content)
+                        .materialize,
+                )
+            })
+            .collect();
+
+        for edge in &producer_edges {
+            let Some(Some(spec)) = producer_specs.get(&edge.producer_path) else {
+                continue;
+            };
+            if spec.target_kind != windmill_parser::asset_parser::AssetKind::Ducklake {
+                continue;
+            }
+            let target = normalize_asset_path(&spec.target_path);
+            // `on_schema_change=ignore` — any producer declaring it wins.
+            if spec.on_schema_change == OnSchemaChange::Ignore
+                && (target == edge.asset_path
+                    || (spec.scd2 && format!("{target}_current") == edge.asset_path))
+            {
+                ignored.insert(edge.asset_path.clone());
+            }
+            // `_current` fallback: a managed scd2 producer's view has exactly
+            // the base table's columns.
+            if spec.scd2
+                && !spec.manual
+                && format!("{target}_current") == edge.asset_path
+                && !schemas.contains_key(&edge.asset_path)
+            {
+                if let Some(base) = schemas.get(&target).cloned() {
+                    schemas.insert(edge.asset_path.clone(), base);
+                }
+            }
+        }
+    }
+
+    Ok(diff_contract(
+        assets,
+        column_lineage,
+        data_tests,
+        materialize,
+        &schemas,
+        &ignored,
+    ))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::BTreeMap;
+    use windmill_parser::asset_parser::{parse_pipeline_annotations, ColumnRef};
+    use windmill_types::assets::AssetUsageAccessType;
+
+    fn schema(cols: &[(&str, &str)]) -> CapturedSchema {
+        CapturedSchema {
+            columns: cols
+                .iter()
+                .map(|(n, t)| SchemaColumn { name: n.to_string(), data_type: t.to_string() })
+                .collect(),
+            version: 2,
+            captured_at: DateTime::<Utc>::MIN_UTC,
+        }
+    }
+
+    fn read_asset(path: &str, cols: &[&str]) -> AssetWithAltAccessType {
+        AssetWithAltAccessType {
+            path: path.to_string(),
+            kind: AssetKind::Ducklake,
+            access_type: Some(AssetUsageAccessType::R),
+            alt_access_type: None,
+            columns: Some(
+                cols.iter()
+                    .map(|c| (c.to_string(), AssetUsageAccessType::R))
+                    .collect::<BTreeMap<_, _>>(),
+            ),
+        }
+    }
+
+    #[test]
+    fn missing_read_column_warns_case_insensitively() {
+        let schemas = HashMap::from([(
+            "lake/orders".to_string(),
+            schema(&[("Order_ID", "BIGINT"), ("amount_usd", "DOUBLE")]),
+        )]);
+        let assets = vec![read_asset("lake/orders", &["order_id", "amount"])];
+        let w = diff_contract(&assets, &[], &[], None, &schemas, &HashSet::new());
+        // order_id matches case-insensitively; amount is gone
+        assert_eq!(w.len(), 1);
+        assert_eq!(w[0].kind, ContractWarningKind::MissingColumn);
+        assert_eq!(w[0].column.as_deref(), Some("amount"));
+        assert_eq!(w[0].schema_version, Some(2));
+    }
+
+    #[test]
+    fn unknown_columns_wildcard_and_reserved_are_skipped() {
+        let schemas = HashMap::from([("lake/orders".to_string(), schema(&[("id", "BIGINT")]))]);
+        // columns: None (wildcard SELECT) — skipped entirely
+        let mut a = read_asset("lake/orders", &[]);
+        a.columns = None;
+        assert!(diff_contract(&[a], &[], &[], None, &schemas, &HashSet::new()).is_empty());
+        // literal "*" and the reserved partition column are skipped
+        let a = read_asset("lake/orders", &["*", "_wm_partition", "id"]);
+        assert!(diff_contract(&[a], &[], &[], None, &schemas, &HashSet::new()).is_empty());
+    }
+
+    #[test]
+    fn asset_without_captured_schema_is_silent() {
+        let assets = vec![read_asset("lake/unknown", &["whatever"])];
+        assert!(
+            diff_contract(&assets, &[], &[], None, &HashMap::new(), &HashSet::new()).is_empty()
+        );
+    }
+
+    #[test]
+    fn partition_token_is_normalized() {
+        let schemas = HashMap::from([("lake/orders".to_string(), schema(&[("id", "BIGINT")]))]);
+        let assets = vec![read_asset("lake/orders/{partition}", &["gone"])];
+        let w = diff_contract(&assets, &[], &[], None, &schemas, &HashSet::new());
+        assert_eq!(w.len(), 1);
+        assert_eq!(w[0].asset_path, "lake/orders");
+    }
+
+    #[test]
+    fn lineage_ref_missing_column_warns() {
+        let schemas = HashMap::from([("lake/orders".to_string(), schema(&[("id", "BIGINT")]))]);
+        let lineage = vec![ColumnLineage {
+            column: "total".to_string(),
+            inputs: vec![ColumnRef {
+                from_kind: windmill_parser::asset_parser::AssetKind::Ducklake,
+                from_path: "lake/orders".to_string(),
+                from_column: "amount".to_string(),
+            }],
+        }];
+        let w = diff_contract(&[], &lineage, &[], None, &schemas, &HashSet::new());
+        assert_eq!(w.len(), 1);
+        assert_eq!(w[0].kind, ContractWarningKind::MissingLineageSource);
+    }
+
+    #[test]
+    fn relationships_missing_and_type_mismatch() {
+        let schemas = HashMap::from([
+            ("lake/customers".to_string(), schema(&[("id", "VARCHAR")])),
+            (
+                "lake/orders".to_string(),
+                schema(&[("customer_id", "BIGINT")]),
+            ),
+        ]);
+        let ann = parse_pipeline_annotations(
+            "// materialize ducklake://lake/orders\n\
+             // data_test relationships customer_id -> ducklake://lake/customers.id\n\
+             // data_test relationships customer_id -> ducklake://lake/customers.uuid\n\
+             SELECT 1;",
+        );
+        let w = diff_contract(
+            &[],
+            &[],
+            &ann.data_tests,
+            ann.materialize.as_ref(),
+            &schemas,
+            &HashSet::new(),
+        );
+        assert_eq!(w.len(), 2);
+        assert!(w
+            .iter()
+            .any(|w| w.kind == ContractWarningKind::RelationshipTypeMismatch
+                && w.expected_type.as_deref() == Some("BIGINT")
+                && w.found_type.as_deref() == Some("VARCHAR")));
+        assert!(w
+            .iter()
+            .any(|w| w.kind == ContractWarningKind::MissingRelationshipColumn
+                && w.column.as_deref() == Some("uuid")));
+    }
+
+    #[test]
+    fn ignored_asset_suppresses_to_single_note() {
+        let schemas = HashMap::from([("lake/orders".to_string(), schema(&[("id", "BIGINT")]))]);
+        let assets = vec![read_asset("lake/orders", &["a", "b"])];
+        let ignored = HashSet::from(["lake/orders".to_string()]);
+        let w = diff_contract(&assets, &[], &[], None, &schemas, &ignored);
+        assert_eq!(w.len(), 1);
+        assert_eq!(w[0].kind, ContractWarningKind::Suppressed);
+        // and nothing at all when there was nothing to suppress
+        let assets = vec![read_asset("lake/orders", &["id"])];
+        assert!(diff_contract(&assets, &[], &[], None, &schemas, &ignored).is_empty());
+    }
+}
diff --git a/backend/windmill-common/src/workspaces.rs b/backend/windmill-common/src/workspaces.rs
index 969f3897e4..a8c6e26f0e 100644
--- a/backend/windmill-common/src/workspaces.rs
+++ b/backend/windmill-common/src/workspaces.rs
@@ -802,25 +802,55 @@ pub enum DataTableCatalogResourceType {
     Instance,
 }
 
+/// Build a self-teaching error for an unresolved `datatable://<name>` reference.
+/// The raw "not found" gives the user no way forward — the datatable substrate has
+/// no auto-provisioning (unlike a DuckLake catalog), so the fix is always to create
+/// one in workspace settings. Surface the available names (to catch typos) and point
+/// at the settings page so the message is actionable wherever it bubbles up
+/// (pipeline `ATTACH`, schema fetch, postgres executor, ...).
+fn datatable_not_found_error(name: &str, datatables: Option<&serde_json::Value>) -> Error {
+    let available: Vec<&str> = datatables
+        .and_then(|d| d.as_object())
+        .map(|o| o.keys().map(String::as_str).collect())
+        .unwrap_or_default();
+
+    let hint = if available.is_empty() {
+        "No data table is configured in this workspace yet.".to_string()
+    } else {
+        format!("Configured data tables: {}.", available.join(", "))
+    };
+
+    Error::NotFound(format!(
+        "Data table '{name}' not found. {hint} \
+         Create one in workspace settings under the \"Data tables\" tab \
+         (/workspace_settings?tab=windmill_data_tables) — the name \"main\" is the default \
+         used by `datatable://main`."
+    ))
+}
+
 pub async fn get_datatable_resource_from_db_unchecked(
     db: &DB,
     w_id: &str,
     name: &str,
 ) -> Result<serde_json::Value> {
-    let datatable = sqlx::query_scalar!(
+    let datatables = sqlx::query_scalar!(
         r#"
-            SELECT ws.datatable->'datatables'->$2 AS config
+            SELECT ws.datatable->'datatables' AS datatables
             FROM workspace_settings ws
             WHERE ws.workspace_id = $1
         "#,
         &w_id,
-        name
     )
     .fetch_one(db)
     .await
-    .map_err(|err| Error::internal_err(format!("getting datatable {name}: {err}")))?
-    .ok_or_else(|| Error::internal_err(format!("datatable {name} not found")))?;
-    let datatable = serde_json::from_value::<DataTable>(datatable)?;
+    .map_err(|err| Error::internal_err(format!("getting datatable {name}: {err}")))?;
+
+    let datatable = datatables
+        .as_ref()
+        .and_then(|d| d.get(name))
+        .filter(|v| !v.is_null())
+        .ok_or_else(|| datatable_not_found_error(name, datatables.as_ref()))?;
+    let datatable = serde_json::from_value::<DataTable>(datatable.clone())?;
 
     let db_resource = if datatable.database.resource_type == DataTableCatalogResourceType::Instance
     {
@@ -848,6 +878,97 @@ pub struct Ducklake {
     pub storage: DucklakeStorage,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub extra_args: Option<String>,
+    /// How this lake behaves when the workspace is a fork/dev workspace. Only meaningful in a
+    /// fork's own settings; stamped at fork creation from the user's per-lake choice. Absent =
+    /// `Isolated` — the safe default, so forks created before this field existed (and API
+    /// callers that omit it) never write the parent's lake.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub fork_behavior: Option<DucklakeForkBehavior>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub maintenance: Option<DucklakeMaintenance>,
+}
+
+/// Per-lake fork data-environment choice, made at fork creation.
+#[derive(Deserialize, Serialize, Debug, Clone, Copy, PartialEq)]
+#[serde(rename_all = "snake_case")]
+pub enum DucklakeForkBehavior {
+    /// Fork-scoped namespace + read-defer to the parent (default).
+    Isolated,
+    /// The fork reads AND WRITES the parent's lake directly — explicit opt-out of isolation
+    /// (e.g. a fork meant to run prod-equivalent backfills).
+    Shared,
+}
+
+/// Scheduled maintenance for a ducklake (enterprise): snapshot expiry,
+/// adjacent-file compaction and orphaned-file cleanup, run as a managed
+/// per-lake schedule. Not mirrored in `instance_config::Ducklake`:
+/// instance-level lakes have no workspace to schedule into.
+#[derive(Deserialize, Serialize, Debug, Clone)]
+pub struct DucklakeMaintenance {
+    pub enabled: bool,
+    /// Cron (v2/croner, seconds optional). None → daily at 03:00 UTC with a
+    /// deterministic per-(workspace, lake) minute offset.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub schedule: Option<String>,
+    /// Snapshot retention window in days (default 7). Snapshots older than
+    /// this are expired: time-travel reads (`AT (VERSION => n)`) older than
+    /// the window stop working. 0 keeps only the current snapshot.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub retention_days: Option<u32>,
+    /// Merge adjacent small parquet files (default true).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub compaction: Option<bool>,
+    /// Delete orphaned files older than max(retention, 1 day) (default true).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub orphan_cleanup: Option<bool>,
+}
+
+impl DucklakeMaintenance {
+    pub const DEFAULT_RETENTION_DAYS: u32 = 7;
+
+    pub fn retention_days(&self) -> u32 {
+        self.retention_days.unwrap_or(Self::DEFAULT_RETENTION_DAYS)
+    }
+    pub fn compaction(&self) -> bool {
+        self.compaction.unwrap_or(true)
+    }
+    pub fn orphan_cleanup(&self) -> bool {
+        self.orphan_cleanup.unwrap_or(true)
+    }
+}
+
+/// Reserved schedule path namespace for managed ducklake maintenance
+/// schedules. Must satisfy the `schedule.path` CHECK constraint
+/// (`^[ufg](\/[\w-]+){2,}$`), hence the `f/` prefix; the folder itself never
+/// exists. The schedule API rejects user mutations under this prefix and the
+/// list/export endpoints filter it out — the lifecycle is owned by the
+/// workspace ducklake settings.
+///
+/// Accepted limitation: a schedule that pre-dated this namespace under a real
+/// `ducklake_maintenance` folder keeps running (tick dispatch falls through
+/// to its script when its path's lake has no enabled maintenance config, and
+/// the settings sync only touches rows derived from config) but stays hidden
+/// from list/export and immutable via the schedule API until renamed out of
+/// the namespace. Judged unlikely enough to not warrant a discriminator
+/// column or a rename migration.
+pub const DUCKLAKE_MAINTENANCE_PATH_PREFIX: &str = "f/ducklake_maintenance/";
+
+pub fn ducklake_maintenance_schedule_path(lake: &str) -> String {
+    format!("{DUCKLAKE_MAINTENANCE_PATH_PREFIX}{lake}")
+}
+
+pub fn lake_from_ducklake_maintenance_path(path: &str) -> Option<&str> {
+    path.strip_prefix(DUCKLAKE_MAINTENANCE_PATH_PREFIX)
+}
+
+/// Lake names are interpolated into `ATTACH 'ducklake://<name>'`, generated
+/// maintenance SQL and the reserved schedule path (CHECK-constrained to
+/// `[\w-]+` segments), so they must stay to this charset.
+pub fn is_valid_ducklake_name(name: &str) -> bool {
+    !name.is_empty()
+        && name
+            .chars()
+            .all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-')
 }
 
 #[derive(Deserialize, Serialize, Debug)]
@@ -881,6 +1002,213 @@ pub struct DucklakeWithConnData {
     pub storage: DucklakeStorage,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub extra_args: Option<String>,
+    /// Present when the resolved workspace is a fork/dev workspace. Carries the read-defer
+    /// context (ancestor namespaces + tables to expose as views over the direct parent). The
+    /// fork *write* redirect is folded into `storage.path`/`extra_args` above, so an agent
+    /// worker that predates this field still writes the fork namespace (it only misses the
+    /// defer views).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub fork_defer: Option<DucklakeForkDefer>,
+}
+
+/// Read-defer context for a fork workspace's ducklake: which ancestor namespaces to attach
+/// read-only, and which tables to expose as views over the direct parent because the fork has
+/// not materialized them yet. `ancestors` is empty when defer is unavailable (an ancestor no
+/// longer defines the lake) — the fork namespace still isolates writes in that case.
+#[derive(Deserialize, Serialize)]
+pub struct DucklakeForkDefer {
+    /// Nearest-first (direct parent … root), each resolved from that workspace's own settings.
+    pub ancestors: Vec<DucklakeAncestorAttach>,
+    pub defer_tables: Vec<crate::materialization::ForkDeferTable>,
+    /// Views currently live in the fork namespace (read from the catalog's `ducklake_view` at
+    /// resolution time, lake-internal names). The worker's view→table transition (DROP VIEW
+    /// before a managed materialize) keys on THIS, not on recorded materialization status:
+    /// after a failed run the status can't distinguish a defer view from a real table, and
+    /// `DROP VIEW` against a table (or `CREATE TABLE` against a view) errors — either guess
+    /// would wedge the asset until manual repair.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub fork_views: Vec<String>,
+}
+
+/// Connection data for one ancestor namespace of a fork's ducklake.
+#[derive(Deserialize, Serialize)]
+pub struct DucklakeAncestorAttach {
+    pub workspace_id: String,
+    /// DuckDB catalog alias this namespace must be attached under. Persisted defer-view SQL
+    /// references it, so it is a pure function of (lake name, ancestor workspace id) and every
+    /// session reading those views attaches the ancestor under this exact alias.
+    pub alias: String,
+    pub catalog: DucklakeCatalog,
+    pub catalog_resource: serde_json::Value,
+    pub storage: DucklakeStorage,
+    /// None = the lake's default metadata schema (the ancestor is a root/non-fork workspace).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub metadata_schema: Option<String>,
+    /// The ancestor config's own non-reserved ATTACH args (e.g. `ENCRYPTED true`), already
+    /// stripped of the fork-owned `METADATA_SCHEMA`/`DATA_PATH`/`OVERRIDE_DATA_PATH` — an
+    /// option-dependent lake would otherwise fail its read-only ancestor attach even though
+    /// the same lake attaches fine everywhere else.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub extra_args: Option<String>,
+}
+
+/// Prefix of fork-scoped ducklake metadata schemas. Cleanup refuses to drop any pg schema not
+/// carrying it, mirroring the `wm_fork_` guard on forked datatable databases.
+pub const FORK_DUCKLAKE_SCHEMA_PREFIX: &str = "wm_fork_";
+
+/// Bucket-root directory holding all fork namespaces' data files: each fork writes under
+/// `{FORK_DUCKLAKE_DATA_DIR}/<fork segment>/<lake path>` where the segment is
+/// [`fork_data_dir_segment`] (see [`fork_data_path`] for why it wraps the lake's path instead
+/// of nesting under it).
+pub const FORK_DUCKLAKE_DATA_DIR: &str = "__wm_forks";
+
+fn mangle_identifier(s: &str, max: usize) -> String {
+    s.chars()
+        .take(max)
+        .map(|c| {
+            let c = c.to_ascii_lowercase();
+            if c.is_ascii_alphanumeric() {
+                c
+            } else {
+                '_'
+            }
+        })
+        .collect()
+}
+
+/// Deterministic, injective pg-schema name for a fork workspace's namespace of ONE lake:
+/// `wm_fork_<mangled wid (≤24)>_<mangled lake (≤16)>_<8-hex sha256>`, ≤58 chars (pg limit 63).
+/// Lake-scoped, not just workspace-scoped: two lakes of one workspace may share a catalog
+/// database, and a per-workspace schema would merge their namespaces in the fork (tables and
+/// snapshots colliding across `ducklake://a/…` and `ducklake://b/…`). The hash keeps distinct
+/// (workspace, lake) pairs distinct after mangling. The registry row records the computed name
+/// for cleanup, but ATTACH recomputes it — so this function must stay stable across releases
+/// or existing forks would silently lose their namespace.
+pub fn fork_ducklake_metadata_schema(w_id: &str, lake_name: &str) -> String {
+    use sha2::{Digest, Sha256};
+    let hash = hex::encode(&Sha256::digest(format!("{w_id}\0{lake_name}").as_bytes())[..4]);
+    format!(
+        "{FORK_DUCKLAKE_SCHEMA_PREFIX}{}_{}_{hash}",
+        mangle_identifier(w_id, 24),
+        mangle_identifier(lake_name, 16)
+    )
+}
+
+/// The `METADATA_SCHEMA '<x>'` value carried in a lake config's `extra_args`, if any — the
+/// schema the lake's OWN catalog namespace lives in (how one catalog database hosts several
+/// lakes). Ancestor read-only attaches must preserve it or they'd bind the wrong namespace.
+pub fn extract_metadata_schema_arg(extra_args: &str) -> Option<String> {
+    lazy_static::lazy_static! {
+        static ref MS: regex::Regex = regex::Regex::new(
+            r"(?i)\bMETADATA_SCHEMA\s*(?:'([^']*)'|([A-Za-z0-9_]+))"
+        )
+        .unwrap();
+    }
+    // Last occurrence wins, matching DuckDB's duplicate-option semantics.
+    MS.captures_iter(extra_args)
+        .last()
+        .and_then(|c| c.get(1).or_else(|| c.get(2)))
+        .map(|m| m.as_str().to_string())
+}
+
+/// Deterministic DuckDB attach alias for an ancestor namespace of a fork's lake. Persisted
+/// defer-view SQL references it (same stability requirement as
+/// [`fork_ducklake_metadata_schema`]).
+pub fn fork_ducklake_ancestor_alias(lake_name: &str, ancestor_w_id: &str) -> String {
+    use sha2::{Digest, Sha256};
+    let hash =
+        hex::encode(&Sha256::digest(format!("{lake_name}\0{ancestor_w_id}").as_bytes())[..4]);
+    format!(
+        "__wm_dl_{}_{}_{hash}",
+        mangle_identifier(lake_name, 20),
+        mangle_identifier(ancestor_w_id, 20)
+    )
+}
+
+/// Strip `METADATA_SCHEMA` / `DATA_PATH` / `OVERRIDE_DATA_PATH` tokens from ducklake ATTACH
+/// extra args. In a fork these options are injected by the fork resolution; a user- or
+/// settings-supplied duplicate silently wins (DuckDB keeps the last occurrence) and would
+/// escape the fork namespace back to the parent's, so they are removed rather than overridden.
+pub fn strip_fork_reserved_attach_args(extra_args: &str) -> String {
+    lazy_static::lazy_static! {
+        static ref RESERVED: regex::Regex = regex::Regex::new(
+            r"(?i)\b(METADATA_SCHEMA|DATA_PATH|OVERRIDE_DATA_PATH)\s*('[^']*'|[A-Za-z0-9_]+)"
+        )
+        .unwrap();
+    }
+    RESERVED
+        .replace_all(extra_args, "")
+        .split(',')
+        .map(str::trim)
+        .filter(|s| !s.is_empty())
+        .collect::<Vec<_>>()
+        .join(", ")
+}
+
+lazy_static::lazy_static! {
+    /// fork workspace id -> (ancestor chain nearest-first, expiry ts). Empty chain = not a fork.
+    /// `parent_workspace_id` only changes on dev-workspace attach/detach, so a short TTL is safe.
+    static ref FORK_ANCESTOR_CHAIN_CACHE: Cache<String, (Vec<String>, i64)> = Cache::new(5000);
+    /// fork workspace id -> (locations recently upserted into `fork_ducklake_namespace`,
+    /// expiry ts), so the registry write doesn't run on every job of a fork. Keyed by
+    /// workspace id so cleanup can drop a fork's whole entry: a same-id fork recreated within
+    /// the TTL must re-register, or its materializations would carry no registry row and leak
+    /// at ITS deletion. TTL'd as a second line of defense for cleanup paths that bypass
+    /// `cleanup_fork_ducklake_namespaces` (e.g. manual registry edits).
+    static ref FORK_DUCKLAKE_REGISTERED: Cache<String, (std::collections::HashSet<String>, i64)> =
+        Cache::new(5000);
+}
+
+/// Drop the "already registered" once-cache for a workspace. MUST be called whenever
+/// `fork_ducklake_namespace` rows for that workspace are deleted (namespace cleanup, workspace
+/// deletion): a surviving entry would make a same-id fork recreated within the TTL skip
+/// re-registration, orphaning its namespace at deletion time.
+pub fn invalidate_fork_ducklake_registration_cache(w_id: &str) {
+    FORK_DUCKLAKE_REGISTERED.remove(w_id);
+}
+
+/// Drop the cached ancestor chain for a workspace. MUST be called wherever
+/// `parent_workspace_id` lineage changes (fork creation, dev-workspace attach, reparenting
+/// rename, deletion): a cached EMPTY chain reads as "not a fork" and would bypass ducklake
+/// fork isolation for the TTL — the first jobs after a dev-workspace attach would write the
+/// shared lake.
+pub fn invalidate_fork_ancestor_chain_cache(w_id: &str) {
+    FORK_ANCESTOR_CHAIN_CACHE.remove(w_id);
+}
+
+/// Ancestors of `w_id`, nearest-first (direct parent … root). Empty for a non-fork workspace or
+/// an unknown id. The depth bound is a cycle-safety backstop, same convention as
+/// [`fork_chain_depth`].
+///
+/// Unauthenticated helper: reads workspace hierarchy for any `w_id`, so callers must already be
+/// authorized for that workspace (or run in trusted server-side code).
+pub async fn fork_ancestor_chain(db: &crate::DB, w_id: &str) -> Result<Vec<String>> {
+    let now = chrono::Utc::now().timestamp();
+    if let Some((chain, expiry)) = FORK_ANCESTOR_CHAIN_CACHE.get(w_id) {
+        if expiry > now {
+            return Ok(chain);
+        }
+    }
+    let chain = sqlx::query_scalar!(
+        r#"
+            WITH RECURSIVE chain AS (
+                SELECT id, parent_workspace_id, 0 AS depth
+                FROM workspace WHERE id = $1
+                UNION ALL
+                SELECT w.id, w.parent_workspace_id, chain.depth + 1
+                FROM workspace w
+                JOIN chain ON w.id = chain.parent_workspace_id
+                WHERE chain.depth < 20
+            )
+            SELECT id AS "id!" FROM chain WHERE depth > 0 ORDER BY depth
+        "#,
+        w_id
+    )
+    .fetch_all(db)
+    .await
+    .map_err(|e| Error::internal_err(format!("resolving fork ancestors of {w_id}: {e:#}")))?;
+    FORK_ANCESTOR_CHAIN_CACHE.insert(w_id.to_string(), (chain.clone(), now + 60));
+    Ok(chain)
 }
 
 pub async fn get_ducklake_from_db_unchecked(
@@ -888,6 +1216,29 @@ pub async fn get_ducklake_from_db_unchecked(
     w_id: &str,
     db: &DB,
 ) -> Result<DucklakeWithConnData> {
+    let (base, fork_behavior) = ducklake_conn_data(name, w_id, db).await?;
+    let chain = fork_ancestor_chain(db, w_id).await?;
+    // `Shared` is the explicit fork-creation opt-out of isolation: the fork reads and writes
+    // the parent's lake through its own (cloned) config, exactly like a non-fork workspace.
+    // An empty chain alone does NOT mean "not a fork": `parent_workspace_id` is ON DELETE SET
+    // NULL, so a `wm-fork-*` workspace can outlive its parent — its cloned config still points
+    // at the shared lake, so the prefix keeps it isolated (mirrors `workspace_is_fork`). No
+    // ancestors ⇒ no defer, write redirect only. Prefix-less dev workspaces can't be orphaned
+    // (deletion of their prod is blocked while attached).
+    if (chain.is_empty() && !w_id.starts_with(WM_FORK_PREFIX))
+        || fork_behavior == Some(DucklakeForkBehavior::Shared)
+    {
+        return Ok(base);
+    }
+    fork_scoped_ducklake(name, w_id, base, chain, db).await
+}
+
+/// Resolve one workspace's own config for lake `name` — no fork awareness.
+async fn ducklake_conn_data(
+    name: &str,
+    w_id: &str,
+    db: &DB,
+) -> Result<(DucklakeWithConnData, Option<DucklakeForkBehavior>)> {
     let ducklake = sqlx::query_scalar!(
         r#"
             SELECT ws.ducklake->'ducklakes'->$2 AS config
@@ -920,13 +1271,447 @@ pub async fn get_ducklake_from_db_unchecked(
             )
             .await?
         };
+    let fork_behavior = ducklake.fork_behavior;
     let ducklake = DucklakeWithConnData {
         catalog_resource,
         catalog: ducklake.catalog,
         storage: ducklake.storage,
         extra_args: ducklake.extra_args,
+        fork_defer: None,
     };
-    Ok(ducklake)
+    Ok((ducklake, fork_behavior))
+}
+
+/// The fork's directory segment under `__wm_forks/`: mangled + hashed into ONE path component
+/// (same recipe and stability requirement as [`fork_ducklake_metadata_schema`]). Fork/dev
+/// workspace ids are only git-branch-safe and may contain `/` (e.g. `wm-fork-a/b`) — used
+/// raw, such an id would nest inside the sibling `wm-fork-a`'s prefix and be swept by ITS
+/// cleanup. The hash keeps distinct ids distinct after mangling.
+pub fn fork_data_dir_segment(fork_w_id: &str) -> String {
+    use sha2::{Digest, Sha256};
+    let hash = hex::encode(&Sha256::digest(fork_w_id.as_bytes())[..4]);
+    format!("{}_{hash}", mangle_identifier(fork_w_id, 40))
+}
+
+/// The fork namespace's data path within the same bucket: a bucket-root
+/// `__wm_forks/<fork segment>/` prefix wrapping the lake's own path, NOT a sub-path under it —
+/// the parent lake's maintenance (snapshot expiry / `ducklake_delete_orphaned_files`) scans
+/// everything under the parent's DATA_PATH and would treat live fork files nested there as
+/// orphans and delete them.
+pub fn fork_data_path(base_path: &str, fork_w_id: &str) -> String {
+    let segment = fork_data_dir_segment(fork_w_id);
+    let base = base_path.trim_matches('/');
+    if base.is_empty() {
+        format!("{FORK_DUCKLAKE_DATA_DIR}/{segment}")
+    } else {
+        format!("{FORK_DUCKLAKE_DATA_DIR}/{segment}/{base}")
+    }
+}
+
+/// Redirect a fork workspace's lake to its fork-scoped namespace (same catalog DB, fork
+/// metadata schema + data sub-path) and assemble the read-defer context over its ancestors.
+async fn fork_scoped_ducklake(
+    name: &str,
+    w_id: &str,
+    mut base: DucklakeWithConnData,
+    chain: Vec<String>,
+    db: &DB,
+) -> Result<DucklakeWithConnData> {
+    if base.catalog.resource_type == DucklakeCatalogResourceType::Mysql {
+        return Err(Error::BadRequest(format!(
+            "ducklake {name}: mysql-catalog lakes are not supported in fork workspaces — \
+             running against the shared catalog would write the parent workspace's data"
+        )));
+    }
+    let metadata_schema = fork_ducklake_metadata_schema(w_id, name);
+    let fork_path = fork_data_path(&base.storage.path, w_id);
+    let catalog_identity = ducklake_catalog_identity(&base.catalog);
+    register_fork_ducklake_namespace(
+        db,
+        w_id,
+        name,
+        &metadata_schema,
+        &catalog_identity,
+        base.storage.storage.as_deref(),
+        &fork_path,
+    )
+    .await?;
+
+    // Ancestor namespaces, nearest-first, each from its own settings so a fork-side settings
+    // edit can't silently repoint what "parent" means. All-or-nothing: a broken link anywhere
+    // in the chain disables defer entirely (a defer view over a missing ancestor attach fails
+    // at bind time and would kill unrelated jobs), but write isolation still applies.
+    let mut ancestors = Vec::with_capacity(chain.len());
+    for (i, ancestor_id) in chain.iter().enumerate() {
+        match ducklake_conn_data(name, ancestor_id, db).await {
+            Ok((mut a, ancestor_behavior)) => {
+                // A fork ancestor lives in its own namespace UNLESS its lake is `Shared` —
+                // then it never redirected and its data sits at its config's default
+                // location, exactly like a root workspace. Chain position alone can't tell
+                // the two apart: an orphaned `wm-fork-*` ancestor (its own parent deleted,
+                // `parent_workspace_id` SET NULL) ends the chain like a root but its data
+                // lives in ITS fork namespace — key on the prefix too, as in resolution.
+                let is_isolated_fork = (i + 1 < chain.len()
+                    || ancestor_id.starts_with(WM_FORK_PREFIX))
+                    && ancestor_behavior != Some(DucklakeForkBehavior::Shared);
+                let metadata_schema = if is_isolated_fork {
+                    a.storage.path = fork_data_path(&a.storage.path, ancestor_id);
+                    Some(fork_ducklake_metadata_schema(ancestor_id, name))
+                } else {
+                    // Root / shared ancestors live in their config's OWN catalog namespace —
+                    // which may be a non-default schema when one catalog database hosts
+                    // several lakes (`extra_args METADATA_SCHEMA '…'`). Preserve it, or the
+                    // read-only attach would bind the wrong (or a nonexistent) lake.
+                    a.extra_args
+                        .as_deref()
+                        .and_then(extract_metadata_schema_arg)
+                };
+                let extra_args = a
+                    .extra_args
+                    .as_deref()
+                    .map(strip_fork_reserved_attach_args)
+                    .filter(|s| !s.is_empty());
+                ancestors.push(DucklakeAncestorAttach {
+                    workspace_id: ancestor_id.clone(),
+                    alias: fork_ducklake_ancestor_alias(name, ancestor_id),
+                    catalog: a.catalog,
+                    catalog_resource: a.catalog_resource,
+                    storage: a.storage,
+                    metadata_schema,
+                    extra_args,
+                });
+            }
+            Err(e) => {
+                tracing::warn!(
+                    "fork {w_id}: ducklake {name} not resolvable in ancestor {ancestor_id} \
+                     ({e:#}); read-defer disabled, fork namespace still isolated"
+                );
+                ancestors.clear();
+                break;
+            }
+        }
+    }
+    // Drop fork ancestors whose namespace was never bootstrapped (e.g. a fresh intermediate
+    // fork that never attached this lake): their READ_ONLY attach would fail the whole job
+    // ("DuckLake does not exist" + creation disabled), and a nonexistent namespace can't own
+    // tables or be referenced by any persisted view. Checked against the fork's catalog DB —
+    // must happen BEFORE defer discovery so `ancestor_idx` values index the filtered list.
+    let (existing_schemas, fork_views, fork_tables) =
+        inspect_fork_catalog(&base, &metadata_schema, &ancestors, db).await?;
+    ancestors.retain(|a| {
+        a.metadata_schema
+            .as_ref()
+            .map_or(true, |s| existing_schemas.contains(s))
+    });
+    let defer_tables = if ancestors.is_empty() {
+        vec![]
+    } else {
+        // Discovery walks the WHOLE chain: a table only a grandparent materialized has no
+        // physical copy in the direct parent (it defers too), so its view must target the
+        // nearest ancestor that owns one.
+        let ancestor_ids: Vec<String> = ancestors.iter().map(|a| a.workspace_id.clone()).collect();
+        let mut tables =
+            crate::materialization::list_fork_defer_tables(db, &ancestor_ids, w_id, name).await?;
+        // Catalog truth beats recorded status: any table live in the fork namespace is
+        // fork-owned, whatever its materialized_partition row says (failed-after-commit,
+        // raw SQL) — a defer view over it would silently yield to it.
+        tables.retain(|t| !fork_tables.contains(&t.table));
+        tables
+    };
+
+    base.storage.path = fork_path;
+    base.extra_args = Some(match base.extra_args.take() {
+        Some(e) => {
+            let sanitized = strip_fork_reserved_attach_args(&e);
+            if sanitized.is_empty() {
+                format!("METADATA_SCHEMA '{metadata_schema}'")
+            } else {
+                format!("{sanitized}, METADATA_SCHEMA '{metadata_schema}'")
+            }
+        }
+        None => format!("METADATA_SCHEMA '{metadata_schema}'"),
+    });
+    base.fork_defer = Some(DucklakeForkDefer { ancestors, defer_tables, fork_views });
+    Ok(base)
+}
+
+/// One round trip to the fork's catalog DB for both namespace introspections: which fork
+/// ancestors' metadata schemas actually exist (a fresh intermediate fork may never have
+/// bootstrapped its namespace), and the views currently live in THIS fork's namespace
+/// (straight from DuckLake's `ducklake_view` metadata — missing metadata tables read as "no
+/// views", correct since nothing can exist there). Each ancestor's schema is checked in the
+/// ancestor's OWN catalog database — a fork whose catalog drifted away from an ancestor's
+/// must not misread that ancestor's (existing, elsewhere) namespace as missing. Ancestors
+/// whose catalog is unreachable read as missing — the safe direction: their defer is skipped
+/// (loud absent-table reads) rather than emitting a READ_ONLY attach that would fail every
+/// job in this fork.
+async fn inspect_fork_catalog(
+    base: &DucklakeWithConnData,
+    metadata_schema: &str,
+    ancestors: &[DucklakeAncestorAttach],
+    db: &DB,
+) -> Result<(
+    std::collections::HashSet<String>,
+    Vec<String>,
+    std::collections::HashSet<String>,
+)> {
+    // Ancestor fork-schemas grouped by which catalog database they live in.
+    let mut groups: std::collections::HashMap<String, (serde_json::Value, Vec<String>)> =
+        std::collections::HashMap::new();
+    for a in ancestors {
+        if let Some(ms) = &a.metadata_schema {
+            groups
+                .entry(ducklake_catalog_identity(&a.catalog))
+                .or_insert_with(|| (a.catalog_resource.clone(), vec![]))
+                .1
+                .push(ms.clone());
+        }
+    }
+
+    async fn query_schemas(
+        client: &tokio_postgres::Client,
+        schemas: Vec<String>,
+    ) -> std::result::Result<Vec<String>, tokio_postgres::Error> {
+        client
+            .query(
+                "SELECT schema_name::text FROM information_schema.schemata
+                 WHERE schema_name = ANY($1)",
+                &[&schemas],
+            )
+            .await
+            .map(|rows| rows.iter().map(|r| r.get::<_, String>(0)).collect())
+    }
+
+    let mut existing_schemas: std::collections::HashSet<String> = Default::default();
+
+    // The fork's own catalog: same-catalog ancestor schemas + this fork's live views.
+    let pg: crate::PgDatabase =
+        serde_json::from_value(base.catalog_resource.clone()).map_err(|e| {
+            Error::internal_err(format!("ducklake catalog resource is not postgres: {e}"))
+        })?;
+    let (client, connection) = pg.connect(Some(db)).await?;
+    let join_handle = tokio::spawn(async move { connection.await });
+    let same_catalog = groups.remove(&ducklake_catalog_identity(&base.catalog));
+    let same_catalog_res = match same_catalog {
+        Some((_, schemas)) => query_schemas(&client, schemas).await.map(Some),
+        None => Ok(None),
+    };
+    // Identifier-quoted schema: the name is server-derived (mangled + hashed) but quote anyway.
+    let q = format!(
+        r#"SELECT CASE WHEN s.schema_name = 'main' THEN v.view_name
+                       ELSE s.schema_name || '.' || v.view_name END AS name
+           FROM "{ms}".ducklake_view v
+           JOIN "{ms}".ducklake_schema s ON s.schema_id = v.schema_id AND s.end_snapshot IS NULL
+           WHERE v.end_snapshot IS NULL"#,
+        ms = metadata_schema.replace('"', "\"\"")
+    );
+    let view_rows = client.query(&q, &[]).await;
+    // Live TABLES in the fork's namespace, same name shape as the views — the defer list is
+    // filtered against them: `CREATE VIEW IF NOT EXISTS` silently yields to an existing
+    // table, so emitting a defer view over one would leave reads on the fork table while
+    // claiming they defer (recorded status can't tell — a committed write whose data tests
+    // failed, or a table left by raw SQL, has no `materialized` row).
+    let qt = format!(
+        r#"SELECT CASE WHEN s.schema_name = 'main' THEN t.table_name
+                       ELSE s.schema_name || '.' || t.table_name END AS name
+           FROM "{ms}".ducklake_table t
+           JOIN "{ms}".ducklake_schema s ON s.schema_id = t.schema_id AND s.end_snapshot IS NULL
+           WHERE t.end_snapshot IS NULL"#,
+        ms = metadata_schema.replace('"', "\"\"")
+    );
+    let table_rows = client.query(&qt, &[]).await;
+    drop(client);
+    let _ = join_handle.await;
+
+    existing_schemas.extend(
+        same_catalog_res
+            .map_err(|e| {
+                Error::internal_err(format!("checking fork ducklake ancestor schemas: {e}"))
+            })?
+            .unwrap_or_default(),
+    );
+    let fork_views = match view_rows {
+        Ok(rows) => rows.iter().map(|r| r.get::<_, String>(0)).collect(),
+        // 42P01 undefined_table / 3F000 invalid_schema_name: namespace not bootstrapped yet.
+        Err(e)
+            if e.code().map_or(false, |c| {
+                c == &tokio_postgres::error::SqlState::UNDEFINED_TABLE
+                    || c == &tokio_postgres::error::SqlState::INVALID_SCHEMA_NAME
+            }) =>
+        {
+            vec![]
+        }
+        Err(e) => {
+            return Err(Error::internal_err(format!(
+                "listing fork ducklake views in {metadata_schema}: {e}"
+            )))
+        }
+    };
+    let fork_tables = match table_rows {
+        Ok(rows) => rows.iter().map(|r| r.get::<_, String>(0)).collect(),
+        Err(e)
+            if e.code().map_or(false, |c| {
+                c == &tokio_postgres::error::SqlState::UNDEFINED_TABLE
+                    || c == &tokio_postgres::error::SqlState::INVALID_SCHEMA_NAME
+            }) =>
+        {
+            Default::default()
+        }
+        Err(e) => {
+            return Err(Error::internal_err(format!(
+                "listing fork ducklake tables in {metadata_schema}: {e}"
+            )))
+        }
+    };
+
+    // Ancestors living in OTHER catalog databases (this fork's catalog drifted after forking):
+    // one connection per distinct catalog, best-effort — an unreachable ancestor catalog only
+    // disables that ancestor's defer.
+    for (identity, (resource, schemas)) in groups {
+        let checked = async {
+            let pg: crate::PgDatabase = serde_json::from_value(resource)
+                .map_err(|e| Error::internal_err(format!("not a postgres resource: {e}")))?;
+            let (client, connection) = pg.connect(Some(db)).await?;
+            let join_handle = tokio::spawn(async move { connection.await });
+            let res = query_schemas(&client, schemas).await;
+            drop(client);
+            let _ = join_handle.await;
+            res.map_err(|e| Error::internal_err(format!("{e}")))
+        }
+        .await;
+        match checked {
+            Ok(found) => existing_schemas.extend(found),
+            Err(e) => {
+                tracing::warn!(
+                    "fork ancestor catalog `{identity}` unreachable while checking ducklake \
+                     namespaces ({e:#}); its ancestors' defer is disabled for this resolution"
+                );
+            }
+        }
+    }
+    Ok((existing_schemas, fork_views, fork_tables))
+}
+
+/// Canonical identity of a lake's catalog database (`<resource_type>:<resource_path>`) — used
+/// for the cleanup registry and for grouping ancestors by which catalog their namespace lives
+/// in. Identifies the database *pointer*, not its (live-resolved) credentials.
+pub fn ducklake_catalog_identity(catalog: &DucklakeCatalog) -> String {
+    format!(
+        "{}:{}",
+        catalog.resource_type.as_ref(),
+        catalog.resource_path
+    )
+}
+
+/// Record that a fork attached this lake at this physical location, so fork deletion knows
+/// exactly which pg metadata schema and which storage prefixes to clean up. One row per
+/// (lake, storage, data path) EVER attached — if the fork's lake settings drift, later
+/// attaches add rows rather than replace them, so cleanup covers every prefix the fork wrote.
+/// The once-cache is keyed on the full location for the same reason. Re-registering an
+/// existing row resets its `schema_dropped` cleanup phase: attaching recreates the metadata
+/// schema, so a stale "already dropped" marker would make the eventual cleanup skip a live
+/// schema.
+async fn register_fork_ducklake_namespace(
+    db: &DB,
+    w_id: &str,
+    name: &str,
+    metadata_schema: &str,
+    catalog: &str,
+    storage: Option<&str>,
+    data_path: &str,
+) -> Result<()> {
+    // '' = default storage (the column is part of the PK, which cannot hold NULL).
+    let storage = storage.unwrap_or("");
+    // Resolve the logical storage name to its identity NOW: cleanup must delete from the
+    // storage that was active when the data was written, not whatever the name points at by
+    // deletion time. '' = unresolvable (no LFS configured — the write itself will fail at the
+    // proxy, so nothing lands anywhere).
+    let storage_ref = fork_storage_ref(db, w_id, storage)
+        .await
+        .unwrap_or_default();
+    let location = format!("{name}\0{catalog}\0{storage}\0{storage_ref}\0{data_path}");
+    let now = chrono::Utc::now().timestamp();
+    if FORK_DUCKLAKE_REGISTERED
+        .get(w_id)
+        .is_some_and(|(locations, exp)| exp > now && locations.contains(&location))
+    {
+        return Ok(());
+    }
+    sqlx::query!(
+        "INSERT INTO fork_ducklake_namespace
+           (workspace_id, ducklake_name, metadata_schema, catalog, storage, storage_ref, data_path)
+         VALUES ($1, $2, $3, $4, $5, $6, $7)
+         ON CONFLICT (workspace_id, ducklake_name, catalog, storage, storage_ref, data_path)
+         DO UPDATE SET schema_dropped = false",
+        w_id,
+        name,
+        metadata_schema,
+        catalog,
+        storage,
+        &storage_ref,
+        data_path,
+    )
+    .execute(db)
+    .await
+    .map_err(|e| Error::internal_err(format!("registering fork ducklake namespace: {e:#}")))?;
+    let mut locations = FORK_DUCKLAKE_REGISTERED
+        .get(w_id)
+        .filter(|(_, exp)| *exp > now)
+        .map(|(locations, _)| locations)
+        .unwrap_or_default();
+    locations.insert(location);
+    FORK_DUCKLAKE_REGISTERED.insert(w_id.to_string(), (locations, now + 60));
+    Ok(())
+}
+
+/// Canonical identity of a workspace storage (`<lfs type>:<resource path or root path>`) as
+/// configured RIGHT NOW — recorded in the fork namespace registry so cleanup targets the
+/// storage the data was actually written to. `storage` = '' for the primary storage, else a
+/// `secondary_storage` name. Returns None when no matching storage is configured.
+async fn fork_storage_ref(db: &DB, w_id: &str, storage: &str) -> Option<String> {
+    let lfs_json = sqlx::query_scalar!(
+        "SELECT large_file_storage FROM workspace_settings WHERE workspace_id = $1",
+        w_id
+    )
+    .fetch_optional(db)
+    .await
+    .ok()
+    .flatten()
+    .flatten()?;
+    let entry = if storage.is_empty() || storage == "_default_" {
+        lfs_json.clone()
+    } else {
+        lfs_json.get("secondary_storage")?.get(storage)?.clone()
+    };
+    lfs_entry_storage_ref(&entry)
+}
+
+/// The pure part of [`fork_storage_ref`]: one `LargeFileStorage` JSON entry → its canonical
+/// `<type>:<path>` descriptor. The `$res:` prefix on resource paths is normalized away (stored
+/// configs are inconsistent about it); cleanup re-adds it when resolving.
+pub fn lfs_entry_storage_ref(entry: &serde_json::Value) -> Option<String> {
+    let typ = entry.get("type")?.as_str()?;
+    let path_field = match typ {
+        "S3Storage" | "S3AwsOidc" => "s3_resource_path",
+        "AzureBlobStorage" | "AzureWorkloadIdentity" => "azure_blob_resource_path",
+        "GoogleCloudStorage" => "gcs_resource_path",
+        "FilesystemStorage" => "root_path",
+        _ => return None,
+    };
+    let path = entry.get(path_field)?.as_str()?;
+    let path = path.strip_prefix("$res:").unwrap_or(path);
+    Some(format!("{typ}:{path}"))
+}
+
+/// Resolve a `$res:`/`$var:` reference tree to its concrete value (recursively, secrets
+/// decrypted). No permission checks — trusted server-side callers only; never echo the result
+/// to a user.
+pub async fn transform_json_value_unchecked(
+    value: &serde_json::Value,
+    w_id: &str,
+    db: &DB,
+) -> Result<serde_json::Value> {
+    transform_json_unchecked(value, w_id, db).await
 }
 
 // This does not check for any permission. Should never be displayed to a user.
@@ -1072,4 +1857,182 @@ mod tests {
         let long_id = format!("wm-fork-{}", "a".repeat(43));
         assert!(validate_fork_workspace_id(&long_id).is_err());
     }
+
+    #[test]
+    fn test_fork_ducklake_metadata_schema_shape() {
+        let s = fork_ducklake_metadata_schema("wm-fork-my-feature-42", "main");
+        assert!(s.starts_with(FORK_DUCKLAKE_SCHEMA_PREFIX), "{s}");
+        assert!(s.len() <= 63, "pg schema name limit: {s}");
+        assert!(
+            s.chars().all(|c| c.is_ascii_alphanumeric() || c == '_'),
+            "{s}"
+        );
+        // Deterministic (persisted view SQL / registry rows depend on it).
+        assert_eq!(
+            s,
+            fork_ducklake_metadata_schema("wm-fork-my-feature-42", "main")
+        );
+    }
+
+    #[test]
+    fn test_fork_ducklake_metadata_schema_injective_after_mangling() {
+        // `-` and `_` mangle to the same char; the hash suffix must keep them distinct.
+        let a = fork_ducklake_metadata_schema("wm-fork-a-b", "main");
+        let b = fork_ducklake_metadata_schema("wm-fork-a_b", "main");
+        assert_ne!(a, b);
+        // Lake-scoped: two lakes of one workspace may share a catalog database, so their fork
+        // namespaces must be distinct schemas.
+        assert_ne!(
+            fork_ducklake_metadata_schema("wm-fork-a-b", "lake_a"),
+            fork_ducklake_metadata_schema("wm-fork-a-b", "lake_b")
+        );
+        // Long ids truncate to the same mangled prefix; hash must still differ.
+        let long_a = fork_ducklake_metadata_schema(&format!("wm-fork-{}x", "a".repeat(40)), "main");
+        let long_b = fork_ducklake_metadata_schema(&format!("wm-fork-{}y", "a".repeat(40)), "main");
+        assert_ne!(long_a, long_b);
+        let long_lake =
+            fork_ducklake_metadata_schema(&format!("wm-fork-{}", "a".repeat(42)), &"l".repeat(40));
+        assert!(long_a.len() <= 63 && long_b.len() <= 63 && long_lake.len() <= 63);
+    }
+
+    #[test]
+    fn test_fork_ducklake_ancestor_alias_valid_identifier() {
+        let a = fork_ducklake_ancestor_alias("analytics", "wm-fork-dev-1");
+        assert!(a.starts_with("__wm_dl_"), "{a}");
+        assert!(
+            a.chars().all(|c| c.is_ascii_alphanumeric() || c == '_'),
+            "{a}"
+        );
+        // Distinct per lake for the same ancestor (a script can attach several lakes).
+        assert_ne!(a, fork_ducklake_ancestor_alias("staging", "wm-fork-dev-1"));
+        assert_ne!(
+            a,
+            fork_ducklake_ancestor_alias("analytics", "wm-fork-dev-2")
+        );
+    }
+
+    #[test]
+    fn test_extract_metadata_schema_arg() {
+        assert_eq!(
+            extract_metadata_schema_arg("METADATA_SCHEMA 'lake_b_ns', ENCRYPTED true"),
+            Some("lake_b_ns".to_string())
+        );
+        assert_eq!(
+            extract_metadata_schema_arg("metadata_schema bare_ident"),
+            Some("bare_ident".to_string())
+        );
+        // Last occurrence wins (DuckDB duplicate-option semantics).
+        assert_eq!(
+            extract_metadata_schema_arg("METADATA_SCHEMA 'a', METADATA_SCHEMA 'b'"),
+            Some("b".to_string())
+        );
+        assert_eq!(extract_metadata_schema_arg("ENCRYPTED true"), None);
+    }
+
+    #[test]
+    fn test_fork_data_path_prefix_isolation() {
+        // Fork/dev ids are git-branch-safe and may contain `/`: `wm-fork-a/b` is a valid id.
+        // Its data prefix must NOT nest inside `wm-fork-a`'s, or deleting `wm-fork-a` would
+        // sweep the sibling's files via the object-store prefix listing.
+        assert!(validate_fork_workspace_id("wm-fork-a/b").is_ok());
+        let a = fork_data_path("lake", "wm-fork-a");
+        let ab = fork_data_path("lake", "wm-fork-a/b");
+        assert!(
+            !format!("{ab}/").starts_with(&format!(
+                "{FORK_DUCKLAKE_DATA_DIR}/{}/",
+                fork_data_dir_segment("wm-fork-a")
+            )),
+            "{ab} nests under {a}'s cleanup prefix"
+        );
+        // Single path component: the segment itself contains no separator.
+        assert!(!fork_data_dir_segment("wm-fork-a/b").contains('/'));
+        // Injective after mangling (`/` and `_` both mangle to `_`).
+        assert_ne!(
+            fork_data_dir_segment("wm-fork-a/b"),
+            fork_data_dir_segment("wm-fork-a_b")
+        );
+        // Deterministic (registry rows + cleanup guard recompute it).
+        assert_eq!(a, fork_data_path("lake", "wm-fork-a"));
+        // Empty base path still yields a well-formed prefix.
+        assert_eq!(
+            fork_data_path("", "wm-fork-a"),
+            format!(
+                "{FORK_DUCKLAKE_DATA_DIR}/{}",
+                fork_data_dir_segment("wm-fork-a")
+            )
+        );
+    }
+
+    #[test]
+    fn test_lfs_entry_storage_ref() {
+        assert_eq!(
+            lfs_entry_storage_ref(&serde_json::json!({
+                "type": "S3Storage", "s3_resource_path": "$res:u/admin/minio"
+            })),
+            Some("S3Storage:u/admin/minio".to_string())
+        );
+        // The `$res:` prefix is optional in stored configs; normalized either way.
+        assert_eq!(
+            lfs_entry_storage_ref(&serde_json::json!({
+                "type": "AzureBlobStorage", "azure_blob_resource_path": "u/admin/az"
+            })),
+            Some("AzureBlobStorage:u/admin/az".to_string())
+        );
+        assert_eq!(
+            lfs_entry_storage_ref(&serde_json::json!({
+                "type": "FilesystemStorage", "root_path": "/data/lfs"
+            })),
+            Some("FilesystemStorage:/data/lfs".to_string())
+        );
+        assert_eq!(
+            lfs_entry_storage_ref(&serde_json::json!({"type": "SomethingNew"})),
+            None
+        );
+        assert_eq!(lfs_entry_storage_ref(&serde_json::json!({})), None);
+    }
+
+    #[test]
+    fn test_strip_fork_reserved_attach_args() {
+        // Reserved options removed wherever they appear, others preserved.
+        assert_eq!(
+            strip_fork_reserved_attach_args("METADATA_SCHEMA 'main', ENCRYPTED true"),
+            "ENCRYPTED true"
+        );
+        assert_eq!(
+            strip_fork_reserved_attach_args(
+                "ENCRYPTED true, DATA_PATH 's3://b/prod', OVERRIDE_DATA_PATH FALSE"
+            ),
+            "ENCRYPTED true"
+        );
+        // Case-insensitive, and quoted values may contain commas/spaces.
+        assert_eq!(
+            strip_fork_reserved_attach_args("data_path 's3://b/x, y', SNAPSHOT_VERSION 3"),
+            "SNAPSHOT_VERSION 3"
+        );
+        assert_eq!(strip_fork_reserved_attach_args(""), "");
+        assert_eq!(
+            strip_fork_reserved_attach_args("METADATA_SCHEMA 'wm_fork_evil'"),
+            ""
+        );
+    }
+
+    #[test]
+    fn test_datatable_not_found_error_no_datatables() {
+        let msg = datatable_not_found_error("main", None).to_string();
+        assert!(msg.contains("'main' not found"), "{msg}");
+        assert!(msg.contains("No data table is configured"), "{msg}");
+        // Always signposts the settings tab so the message is actionable.
+        assert!(msg.contains("tab=windmill_data_tables"), "{msg}");
+    }
+
+    #[test]
+    fn test_datatable_not_found_error_lists_available() {
+        let configured = serde_json::json!({ "analytics": {}, "staging": {} });
+        let msg = datatable_not_found_error("main", Some(&configured)).to_string();
+        assert!(msg.contains("'main' not found"), "{msg}");
+        // Surface configured names to catch typos.
+        assert!(msg.contains("analytics"), "{msg}");
+        assert!(msg.contains("staging"), "{msg}");
+        assert!(msg.contains("tab=windmill_data_tables"), "{msg}");
+    }
 }
diff --git a/backend/windmill-duckdb-ffi-internal/.gitignore b/backend/windmill-duckdb-ffi-internal/.gitignore
new file mode 100644
index 0000000000..ea8c4bf7f3
--- /dev/null
+++ b/backend/windmill-duckdb-ffi-internal/.gitignore
@@ -0,0 +1 @@
+/target
diff --git a/backend/windmill-duckdb-ffi-internal/build_dev.sh b/backend/windmill-duckdb-ffi-internal/build_dev.sh
index d4ae2b7583..f3ce520c68 100755
--- a/backend/windmill-duckdb-ffi-internal/build_dev.sh
+++ b/backend/windmill-duckdb-ffi-internal/build_dev.sh
@@ -1,3 +1,40 @@
+#!/usr/bin/env bash
+set -euo pipefail
+cd "$(dirname "$0")"
+
+# The `duckdb` "bundled" feature compiles the whole DuckDB C++ library from
+# source (~minutes) and dominates this crate's build. The crate changes very
+# rarely, so by default build into a per-user cache shared across worktrees and
+# keyed by the dependency lock: a fresh worktree reuses the already-compiled
+# DuckDB instead of rebuilding it, and distinct DuckDB versions don't collide.
+# Override the cache root with WINDMILL_DUCKDB_FFI_TARGET.
+#
+# If you are actively editing this crate in a worktree, uncommitted changes to
+# its source switch to an isolated per-worktree ./target so your incremental
+# builds neither disturb nor are disturbed by the shared cache.
+
+src_dirty="$(git status --porcelain -- src Cargo.toml Cargo.lock build.rs 2>/dev/null || true)"
+
+if [ -n "$src_dirty" ]; then
+  export CARGO_TARGET_DIR="$PWD/target"
+  echo "duckdb-ffi: local crate changes detected -> isolated target $CARGO_TARGET_DIR"
+else
+  cache_root="${WINDMILL_DUCKDB_FFI_TARGET:-${XDG_CACHE_HOME:-$HOME/.cache}/windmill/duckdb-ffi-target}"
+  if command -v sha256sum >/dev/null 2>&1; then hash_cmd=sha256sum; else hash_cmd="shasum -a 256"; fi
+  key="$(cat Cargo.lock build.rs | $hash_cmd | cut -c1-16)"
+  export CARGO_TARGET_DIR="$cache_root/$key"
+  echo "duckdb-ffi: shared cache $CARGO_TARGET_DIR"
+  # The cache key covers only the dependency inputs (Cargo.lock + build.rs), so
+  # the expensive bundled-DuckDB build is shared even when this crate's own
+  # source differs between checkouts. But the shared dir's uplifted cdylib is a
+  # single fixed-name artifact written by whichever worktree built last. Touch
+  # our sources so cargo re-links THIS checkout's cdylib and re-uplifts it
+  # before we copy — the copied artifact then always matches this worktree,
+  # never a sibling's. The bundled dependency is a separate crate and stays
+  # cached, so this only costs a ~1s relink.
+  find src -type f -exec touch {} +
+fi
+
 CARGO_NET_GIT_FETCH_WITH_CLI=true cargo build --release -p windmill_duckdb_ffi_internal
 mkdir -p ../target/debug/
-cp target/release/libwindmill_duckdb_ffi_internal.* ../target/debug/
+cp "$CARGO_TARGET_DIR/release/"libwindmill_duckdb_ffi_internal.* ../target/debug/
diff --git a/backend/windmill-duckdb-ffi-internal/src/lib.rs b/backend/windmill-duckdb-ffi-internal/src/lib.rs
index 054f892220..25347098f2 100644
--- a/backend/windmill-duckdb-ffi-internal/src/lib.rs
+++ b/backend/windmill-duckdb-ffi-internal/src/lib.rs
@@ -794,6 +794,155 @@ mod temporal_json_tests {
         assert_eq!(json_of(3), serde_json::json!("2026-07-01"));
         assert_eq!(json_of(4), serde_json::json!("10:30:00"));
     }
+
+    // The data-test sample probe shape emitted by
+    // `windmill-parser::sql_materialize::build_data_test_checks`: one scan
+    // yielding the violating-row count plus a bounded `to_json` sample of the
+    // rows as a VARCHAR. These tests gate that design against the *bundled*
+    // engine (json extension availability, row-as-struct alias reference,
+    // NULL degrade on zero rows / oversized samples, exotic column types).
+    fn sample_probe_sql(rows_query: &str, max_len: usize) -> String {
+        format!(
+            "SELECT v, CASE WHEN strlen(s_raw) <= {max_len} THEN s_raw END AS s \
+             FROM (SELECT count(*) AS v, \
+                   to_json(list(_wm_v ORDER BY _wm_rn) FILTER (WHERE _wm_rn <= 20))::VARCHAR AS s_raw \
+                   FROM (SELECT _wm_v, row_number() OVER () AS _wm_rn FROM ({rows_query}) _wm_v))"
+        )
+    }
+
+    fn run_sample_probe(
+        conn: &duckdb::Connection,
+        rows_query: &str,
+        max_len: usize,
+    ) -> (i64, Option<String>) {
+        let mut stmt = conn
+            .prepare(&sample_probe_sql(rows_query, max_len))
+            .unwrap();
+        let mut rows = stmt.query([]).unwrap();
+        let row = rows.next().unwrap().unwrap();
+        (row.get(0).unwrap(), row.get(1).unwrap())
+    }
+
+    #[test]
+    fn data_test_sample_probe_counts_and_samples() {
+        let conn = duckdb::Connection::open_in_memory().unwrap();
+        conn.execute_batch(
+            "CREATE TABLE t (id INT, name VARCHAR); \
+             INSERT INTO t VALUES (1, 'a'), (2, NULL), (3, NULL);",
+        )
+        .unwrap();
+        let (v, s) = run_sample_probe(&conn, "SELECT * FROM t WHERE name IS NULL", 51200);
+        assert_eq!(v, 2);
+        let parsed: serde_json::Value = serde_json::from_str(&s.unwrap()).unwrap();
+        assert_eq!(
+            parsed,
+            serde_json::json!([{"id": 2, "name": null}, {"id": 3, "name": null}])
+        );
+    }
+
+    #[test]
+    fn data_test_sample_probe_zero_rows_yields_null_sample() {
+        let conn = duckdb::Connection::open_in_memory().unwrap();
+        conn.execute_batch("CREATE TABLE t (id INT); INSERT INTO t VALUES (1);")
+            .unwrap();
+        let (v, s) = run_sample_probe(&conn, "SELECT * FROM t WHERE id IS NULL", 51200);
+        assert_eq!(v, 0);
+        assert!(s.is_none());
+    }
+
+    #[test]
+    fn data_test_sample_probe_caps_at_20_rows_but_counts_all() {
+        let conn = duckdb::Connection::open_in_memory().unwrap();
+        conn.execute_batch("CREATE TABLE t AS SELECT range AS id FROM range(50);")
+            .unwrap();
+        let (v, s) = run_sample_probe(&conn, "SELECT * FROM t", 51200);
+        assert_eq!(v, 50);
+        let parsed: serde_json::Value = serde_json::from_str(&s.unwrap()).unwrap();
+        assert_eq!(parsed.as_array().unwrap().len(), 20);
+    }
+
+    #[test]
+    fn data_test_sample_probe_oversized_sample_degrades_to_null() {
+        let conn = duckdb::Connection::open_in_memory().unwrap();
+        conn.execute_batch("CREATE TABLE t AS SELECT repeat('x', 1000) AS big FROM range(5);")
+            .unwrap();
+        let (v, s) = run_sample_probe(&conn, "SELECT * FROM t", 100);
+        assert_eq!(v, 5);
+        assert!(s.is_none());
+    }
+
+    #[test]
+    fn data_test_sample_probe_codegen_row_query_shapes() {
+        // The exact rows-query shapes emitted by `build_data_test_checks`:
+        // unique's `{value, count}` grain and the star-EXCLUDE forms used on
+        // partitioned targets (plain and `_wm_src.`-qualified).
+        let conn = duckdb::Connection::open_in_memory().unwrap();
+        conn.execute_batch(
+            "CREATE TABLE t (id INT, name VARCHAR, _wm_partition VARCHAR); \
+             INSERT INTO t VALUES (1, 'a', 'p'), (1, 'b', 'p'), (2, NULL, 'p');",
+        )
+        .unwrap();
+        let (v, s) = run_sample_probe(
+            &conn,
+            "SELECT \"id\" AS \"value\", count(*) AS \"count\" FROM t \
+             WHERE \"id\" IS NOT NULL GROUP BY \"id\" HAVING count(*) > 1",
+            51200,
+        );
+        assert_eq!(v, 1);
+        let parsed: serde_json::Value = serde_json::from_str(&s.unwrap()).unwrap();
+        assert_eq!(parsed, serde_json::json!([{"value": 1, "count": 2}]));
+
+        let (v, s) = run_sample_probe(
+            &conn,
+            "SELECT * EXCLUDE (\"_wm_partition\") FROM t WHERE name IS NULL",
+            51200,
+        );
+        assert_eq!(v, 1);
+        assert_eq!(
+            serde_json::from_str::<serde_json::Value>(&s.unwrap()).unwrap(),
+            serde_json::json!([{"id": 2, "name": null}])
+        );
+
+        let (v, s) = run_sample_probe(
+            &conn,
+            "SELECT _wm_src.* EXCLUDE (\"_wm_partition\") FROM t _wm_src WHERE _wm_src.name IS NULL",
+            51200,
+        );
+        assert_eq!(v, 1);
+        assert_eq!(
+            serde_json::from_str::<serde_json::Value>(&s.unwrap()).unwrap(),
+            serde_json::json!([{"id": 2, "name": null}])
+        );
+    }
+
+    #[test]
+    fn data_test_sample_probe_survives_exotic_types() {
+        let conn = duckdb::Connection::open_in_memory().unwrap();
+        conn.execute_batch(
+            "CREATE TABLE t AS SELECT \
+                INTERVAL 3 DAY AS iv, \
+                12345678901234567890123456789::HUGEINT AS hi, \
+                '\\xDE\\xAD'::BLOB AS bl, \
+                [1, 2, 3] AS li, \
+                {'a': 1, 'b': 'x'} AS st, \
+                TIMESTAMPTZ '2026-07-01 23:13:42+00' AS tstz, \
+                DECIMAL '12.34' AS dec;",
+        )
+        .unwrap();
+        let (v, s) = run_sample_probe(&conn, "SELECT * FROM t", 51200);
+        assert_eq!(v, 1);
+        let parsed: serde_json::Value = serde_json::from_str(&s.unwrap()).unwrap();
+        let row = &parsed.as_array().unwrap()[0];
+        // Exact renderings are DuckDB's to_json choices — the gate is only
+        // that every type serializes without error and parses back as JSON.
+        assert!(row.get("iv").is_some());
+        assert!(row.get("hi").is_some());
+        assert!(row.get("bl").is_some());
+        assert_eq!(row["li"], serde_json::json!([1, 2, 3]));
+        assert_eq!(row["st"], serde_json::json!({"a": 1, "b": "x"}));
+        assert!(row.get("tstz").is_some());
+        assert!(row.get("dec").is_some());
+    }
 }
 
 fn json_value_to_duckdb_value(
diff --git a/backend/windmill-queue/src/ducklake_maintenance_oss.rs b/backend/windmill-queue/src/ducklake_maintenance_oss.rs
new file mode 100644
index 0000000000..ab6e035847
--- /dev/null
+++ b/backend/windmill-queue/src/ducklake_maintenance_oss.rs
@@ -0,0 +1,96 @@
+//! OSS fallback: scheduled ducklake maintenance (snapshot expiry, adjacent-file
+//! compaction, orphaned-file cleanup via managed per-lake schedules) is an
+//! enterprise feature; the implementation lives in windmill-ee-private
+//! (see `ducklake_maintenance_ee`). In the public build the entry points report
+//! that the enterprise edition is required.
+
+use std::collections::HashMap;
+
+use sqlx::{Postgres, Transaction};
+use windmill_common::{
+    error::{Error, Result},
+    jobs::JobPayload,
+    schedule::Schedule,
+    workspaces::Ducklake,
+    DB,
+};
+
+/// Reconcile the managed `f/ducklake_maintenance/<lake>` schedule rows with
+/// the ducklake settings, inside the caller's transaction.
+///
+/// Not an authorization boundary: it mutates schedule rows for `w_id` on
+/// behalf of `edited_by`/`email`, so the caller MUST already have enforced
+/// workspace-admin on `w_id` and that the identity is the authenticated
+/// caller's (as `edit_ducklake_config` does via `require_admin`).
+// Only newly-enabled maintenance is rejected: a config that already had it
+// enabled (e.g. an enterprise license lapsed) must not make every unrelated
+// ducklake settings save fail, and the admin must be able to save it off.
+pub async fn sync_ducklake_maintenance_schedules<'c>(
+    _db: &DB,
+    mut tx: Transaction<'c, Postgres>,
+    w_id: &str,
+    ducklakes: &HashMap<String, Ducklake>,
+    previous: &HashMap<String, Ducklake>,
+    _edited_by: &str,
+    _email: &str,
+) -> Result<Transaction<'c, Postgres>> {
+    let enabled = |dl: &Ducklake| -> bool { dl.maintenance.as_ref().is_some_and(|m| m.enabled) };
+    if ducklakes
+        .iter()
+        .any(|(name, dl)| enabled(dl) && !previous.get(name).is_some_and(|prev| enabled(prev)))
+    {
+        return Err(Error::BadRequest(
+            "Ducklake scheduled maintenance is only available in the enterprise edition"
+                .to_string(),
+        ));
+    }
+
+    // Saving maintenance off (e.g. after an enterprise license lapsed) must
+    // remove the managed row AND its already-queued occurrence here too —
+    // otherwise a maintenance job pushed under the enterprise edition still
+    // runs once after the admin disabled it. Like the enterprise
+    // implementation, the removed set is derived from config, never from the
+    // path prefix.
+    let removed = previous
+        .iter()
+        .filter(|(name, dl)| enabled(dl) && !ducklakes.get(*name).is_some_and(|cur| enabled(cur)))
+        .map(|(name, _)| windmill_common::workspaces::ducklake_maintenance_schedule_path(name))
+        .collect::<Vec<_>>();
+    for path in removed.iter() {
+        crate::schedule::clear_schedule(&mut tx, path, w_id).await?;
+    }
+    sqlx::query!(
+        "DELETE FROM schedule WHERE workspace_id = $1 AND path = ANY($2)",
+        w_id,
+        &removed
+    )
+    .execute(&mut *tx)
+    .await?;
+
+    Ok(tx)
+}
+
+/// Build the job payload for one occurrence of a managed maintenance schedule
+/// (`push_scheduled_job` calls this for reserved-prefix schedule paths).
+/// Returns `(payload, tag, timeout, on_behalf_of_email, created_by)`.
+///
+/// Always `Ok(None)` in the public build: the caller falls through to normal
+/// script resolution, so a pre-existing user schedule under a real
+/// `ducklake_maintenance` folder keeps running, while a managed row left over
+/// from an enterprise period fails script resolution with NotFound and is
+/// auto-disabled with `schedule.error` recorded by the post-completion
+/// scheduler.
+pub async fn build_maintenance_schedule_payload<'c>(
+    _tx: &mut Transaction<'c, Postgres>,
+    _schedule: &Schedule,
+) -> Result<
+    Option<(
+        JobPayload,
+        Option<String>,
+        Option<i32>,
+        Option<String>,
+        String,
+    )>,
+> {
+    Ok(None)
+}
diff --git a/backend/windmill-queue/src/freshness_watchdog_oss.rs b/backend/windmill-queue/src/freshness_watchdog_oss.rs
new file mode 100644
index 0000000000..319fb25f62
--- /dev/null
+++ b/backend/windmill-queue/src/freshness_watchdog_oss.rs
@@ -0,0 +1,9 @@
+//! OSS fallback for the pipeline freshness watchdog. The active backstop —
+//! re-running a `// freshness`-annotated producer whose output aged past its
+//! window — is an enterprise feature (see `freshness_watchdog_ee`). In the
+//! public build the tick is a no-op; CE keeps the passive fresh/stale badge
+//! on the asset graph.
+
+use windmill_common::DB;
+
+pub async fn tick(_db: &DB) {}
diff --git a/backend/windmill-queue/src/lib.rs b/backend/windmill-queue/src/lib.rs
index 6f689c7026..8d8534c926 100644
--- a/backend/windmill-queue/src/lib.rs
+++ b/backend/windmill-queue/src/lib.rs
@@ -14,6 +14,20 @@ pub mod cascade_oss;
 pub use cascade_ee as cascade;
 #[cfg(not(feature = "private"))]
 pub use cascade_oss as cascade;
+#[cfg(feature = "private")]
+pub mod ducklake_maintenance_ee;
+pub mod ducklake_maintenance_oss;
+#[cfg(feature = "private")]
+pub use ducklake_maintenance_ee as ducklake_maintenance;
+#[cfg(not(feature = "private"))]
+pub use ducklake_maintenance_oss as ducklake_maintenance;
+#[cfg(feature = "private")]
+pub mod freshness_watchdog_ee;
+pub mod freshness_watchdog_oss;
+#[cfg(feature = "private")]
+pub use freshness_watchdog_ee as freshness_watchdog;
+#[cfg(not(feature = "private"))]
+pub use freshness_watchdog_oss as freshness_watchdog;
 pub mod jobs;
 #[cfg(feature = "private")]
 pub mod jobs_ee;
diff --git a/backend/windmill-queue/src/schedule.rs b/backend/windmill-queue/src/schedule.rs
index 8816eeae25..2b5aef96a5 100644
--- a/backend/windmill-queue/src/schedule.rs
+++ b/backend/windmill-queue/src/schedule.rs
@@ -227,11 +227,30 @@ pub async fn push_scheduled_job<'c>(
         }
     }
 
+    // Managed ducklake maintenance schedule (enterprise): the runnable is a
+    // generated DuckDB script, not a deployed one — built in the EE module.
+    // None (CE build, or no enabled maintenance config for the path's lake)
+    // falls through to normal script resolution, so a user schedule that
+    // pre-dates the reserved prefix keeps running its script and a stale
+    // managed row fails resolution with NotFound (auto-disabling it with
+    // schedule.error recorded).
+    let maintenance_payload =
+        if windmill_common::workspaces::lake_from_ducklake_maintenance_path(&schedule.path)
+            .is_some()
+        {
+            crate::ducklake_maintenance::build_maintenance_schedule_payload(&mut tx, schedule)
+                .await?
+        } else {
+            None
+        };
+
     // If schedule handler is defined, wrap the scheduled job in a synthetic flow
     // with the handler as the first step (with stop_after_if to skip if handler returns false)
-    let (payload, tag, timeout, on_behalf_of_email, created_by) = if let Some(handler_path) =
-        &schedule.dynamic_skip
+    let (payload, tag, timeout, on_behalf_of_email, created_by) = if let Some(maintenance_payload) =
+        maintenance_payload
     {
+        maintenance_payload
+    } else if let Some(handler_path) = &schedule.dynamic_skip {
         // Build skip handler args
         let mut skip_handler_args = HashMap::<String, Box<serde_json::value::RawValue>>::new();
         skip_handler_args.insert(
diff --git a/backend/windmill-queue/tests/schedule_push.rs b/backend/windmill-queue/tests/schedule_push.rs
index 70a53763e0..e11ced23bc 100644
--- a/backend/windmill-queue/tests/schedule_push.rs
+++ b/backend/windmill-queue/tests/schedule_push.rs
@@ -1592,4 +1592,174 @@ mod schedule_push {
 
         Ok(())
     }
+
+    // -----------------------------------------------------------------------
+    // push_scheduled_job: reserved ducklake-maintenance prefix
+    // -----------------------------------------------------------------------
+
+    // A schedule that pre-dates the reserved prefix (a user schedule under a
+    // real `ducklake_maintenance` folder) must fall through to normal script
+    // resolution when its path's lake has no enabled maintenance config —
+    // never be hijacked into the maintenance payload builder and auto-disabled.
+    #[sqlx::test(migrations = "../migrations", fixtures("base", "schedule_push"))]
+    async fn test_push_reserved_prefix_no_config_falls_through_to_script(
+        db: Pool<Postgres>,
+    ) -> anyhow::Result<()> {
+        let schedule = make_schedule(|s| {
+            s.path = "f/ducklake_maintenance/legacy".to_string();
+        });
+        let authed = make_authed();
+
+        let tx = db.begin().await?;
+        let tx = push_scheduled_job(&db, tx, &schedule, Some(&authed), None).await?;
+        tx.commit().await?;
+
+        assert_eq!(count_queued_jobs(&db).await, 1);
+        let (ws, path, trigger, _) = get_queued_job(&db).await.unwrap();
+        assert_eq!(ws, "test-workspace");
+        assert_eq!(
+            path.as_deref(),
+            Some("f/system/test_script"),
+            "must resolve the schedule's script_path, not the maintenance builder"
+        );
+        assert_eq!(trigger.as_deref(), Some("f/ducklake_maintenance/legacy"));
+        Ok(())
+    }
+
+    // With maintenance enabled for the path's lake, the occurrence is a
+    // raw-code duckdb job (kind preview, runnable_path = schedule path,
+    // duckdb tag pinned) — enterprise builds only.
+    #[cfg(feature = "private")]
+    #[sqlx::test(migrations = "../migrations", fixtures("base", "schedule_push"))]
+    async fn test_push_reserved_prefix_with_config_builds_maintenance_job(
+        db: Pool<Postgres>,
+    ) -> anyhow::Result<()> {
+        sqlx::query(
+            r#"UPDATE workspace_settings SET ducklake = '{"ducklakes": {"legacy": {
+                "catalog": {"resource_type": "postgresql", "resource_path": "u/test/pg"},
+                "storage": {"path": "legacy"},
+                "maintenance": {"enabled": true, "retention_days": 3}
+            }}}'::jsonb WHERE workspace_id = 'test-workspace'"#,
+        )
+        .execute(&db)
+        .await?;
+
+        let schedule = make_schedule(|s| {
+            s.path = "f/ducklake_maintenance/legacy".to_string();
+            s.script_path = "f/ducklake_maintenance/legacy".to_string();
+            s.tag = Some("duckdb".to_string());
+        });
+        let authed = make_authed();
+
+        let tx = db.begin().await?;
+        let tx = push_scheduled_job(&db, tx, &schedule, Some(&authed), None).await?;
+        tx.commit().await?;
+
+        assert_eq!(count_queued_jobs(&db).await, 1);
+        let (kind, path, tag, raw_code) =
+            sqlx::query_as::<_, (String, Option<String>, String, Option<String>)>(
+                "SELECT j.kind::text, j.runnable_path, j.tag, j.raw_code
+             FROM v2_job j JOIN v2_job_queue q ON j.id = q.id LIMIT 1",
+            )
+            .fetch_one(&db)
+            .await?;
+        assert_eq!(kind, "preview");
+        assert_eq!(path.as_deref(), Some("f/ducklake_maintenance/legacy"));
+        assert_eq!(tag, "duckdb");
+        let raw_code = raw_code.expect("maintenance job must carry generated SQL");
+        assert!(raw_code.contains("ducklake_expire_snapshots"));
+        assert!(raw_code.contains("INTERVAL '3 days'"));
+        Ok(())
+    }
+
+    // Saving maintenance off must remove the managed row AND its queued
+    // occurrence in BOTH builds: the enterprise sync reconciles, and the
+    // public stub must not leave a job pushed under the enterprise edition
+    // to run after the admin disabled maintenance (EE-to-CE downgrade).
+    #[sqlx::test(migrations = "../migrations", fixtures("base", "schedule_push"))]
+    async fn test_sync_disable_clears_managed_row_and_queued_occurrence(
+        db: Pool<Postgres>,
+    ) -> anyhow::Result<()> {
+        use std::collections::HashMap;
+        use windmill_common::workspaces::{
+            Ducklake, DucklakeCatalog, DucklakeCatalogResourceType, DucklakeMaintenance,
+            DucklakeStorage,
+        };
+        use windmill_queue::ducklake_maintenance::sync_ducklake_maintenance_schedules;
+
+        fn lake(maintenance_enabled: bool) -> Ducklake {
+            Ducklake {
+                catalog: DucklakeCatalog {
+                    resource_type: DucklakeCatalogResourceType::Postgresql,
+                    resource_path: "u/test/pg".to_string(),
+                },
+                storage: DucklakeStorage { storage: None, path: "legacy".to_string() },
+                extra_args: None,
+                fork_behavior: None,
+                maintenance: Some(DucklakeMaintenance {
+                    enabled: maintenance_enabled,
+                    schedule: None,
+                    retention_days: None,
+                    compaction: None,
+                    orphan_cleanup: None,
+                }),
+            }
+        }
+
+        // a managed row with a queued occurrence (queued via fall-through: no
+        // lake config exists yet, so the push resolves the script path)
+        let schedule = make_schedule(|s| {
+            s.path = "f/ducklake_maintenance/legacy".to_string();
+        });
+        sqlx::query(
+            "INSERT INTO schedule (workspace_id, path, schedule, timezone, edited_by, script_path,
+                is_flow, enabled, email, permissioned_as, cron_version)
+             VALUES ($1, $2, $3, 'UTC', $4, $5, false, true, $6, $7, 'v2')",
+        )
+        .bind(&schedule.workspace_id)
+        .bind(&schedule.path)
+        .bind(&schedule.schedule)
+        .bind(&schedule.edited_by)
+        .bind(&schedule.script_path)
+        .bind(&schedule.email)
+        .bind(&schedule.permissioned_as)
+        .execute(&db)
+        .await?;
+        let authed = make_authed();
+        let tx = db.begin().await?;
+        let tx = push_scheduled_job(&db, tx, &schedule, Some(&authed), None).await?;
+        tx.commit().await?;
+        assert_eq!(count_queued_jobs(&db).await, 1);
+
+        // maintenance saved off
+        let previous = HashMap::from([("legacy".to_string(), lake(true))]);
+        let current = HashMap::from([("legacy".to_string(), lake(false))]);
+        let tx = db.begin().await?;
+        let tx = sync_ducklake_maintenance_schedules(
+            &db,
+            tx,
+            &schedule.workspace_id,
+            &current,
+            &previous,
+            "test-user",
+            "test@windmill.dev",
+        )
+        .await?;
+        tx.commit().await?;
+
+        assert_eq!(
+            count_queued_jobs(&db).await,
+            0,
+            "queued occurrence must be cleared when maintenance is saved off"
+        );
+        let row_exists: bool = sqlx::query_scalar(
+            "SELECT EXISTS(SELECT 1 FROM schedule WHERE workspace_id = $1 AND path = $2)",
+        )
+        .bind(&schedule.workspace_id)
+        .bind(&schedule.path)
+        .fetch_one(&db)
+        .await?;
+        assert!(!row_exists, "managed schedule row must be deleted");
+        Ok(())
+    }
 }
diff --git a/backend/windmill-types/src/jobs.rs b/backend/windmill-types/src/jobs.rs
index 448e6f4d01..f9372b949d 100644
--- a/backend/windmill-types/src/jobs.rs
+++ b/backend/windmill-types/src/jobs.rs
@@ -46,6 +46,9 @@ pub enum JobTriggerKind {
     // A run dispatched because an upstream pipeline script wrote an asset
     // this runnable subscribes to via `// on s3://...` annotations.
     Asset,
+    // A run pushed by the pipeline freshness watchdog (EE) because the
+    // script's `// freshness` window elapsed without a successful run.
+    Freshness,
 }
 
 impl std::fmt::Display for JobTriggerKind {
@@ -68,6 +71,7 @@ impl std::fmt::Display for JobTriggerKind {
             JobTriggerKind::Github => "github",
             JobTriggerKind::CiTest => "ci_test",
             JobTriggerKind::Asset => "asset",
+            JobTriggerKind::Freshness => "freshness",
         };
         write!(f, "{}", kind)
     }
diff --git a/backend/windmill-worker/loader.bun.windows.js b/backend/windmill-worker/loader.bun.windows.js
index e89b70c26c..a877266662 100644
--- a/backend/windmill-worker/loader.bun.windows.js
+++ b/backend/windmill-worker/loader.bun.windows.js
@@ -10,7 +10,7 @@ const p = {
   name: "windmill-relative-resolver",
   async setup(build) {
     const { readFileSync } = await import("fs");
-    const { resolve } = await import("node:path");
+    const { resolve, dirname } = await import("node:path");
 
     const base_internal_url = "BASE_INTERNAL_URL".replace(
       "localhost",
@@ -26,13 +26,27 @@ const p = {
     // Normalize path to forward slashes to match Bun's resolver output on Windows
     const cdirFwd = cdir.replace(/\\/g, "/");
     const cdirPosix = cdirFwd.replace(/^[a-zA-Z]:/, "");
+    // Match either an already-normalized `.ts` specifier OR an *extensionless*
+    // windmill relative/workspace import (`./`, `../`, `f/`, `/f/`, `u/`, `/u/`).
+    // The extensionless branch is essential on Windows: the `main.ts` onLoad that
+    // would rewrite `./mid` → `./mid.ts` only fires when its path filter matches
+    // bun's resolver output, and the 8.3 short-name (`RUNNER~1`) vs canonical-path
+    // mismatch makes that unreliable — so bare imports must be resolvable here
+    // directly rather than depending on the rewrite. The `(?!.*\.[A-Za-z0-9]+$)`
+    // guard keeps extension-bearing relative imports (a package's internal
+    // `./foo.js`/`./x.json` requires) OUT of this resolver so they fall through
+    // to bun's default resolver — a windmill script import is always `.ts` or
+    // extensionless. Bare npm specifiers (no `./` prefix, not `f/`/`u/`) never
+    // match either branch.
     const filterResolve = new RegExp(
-      `^(?!\\.\/main\\.ts)(?!\\.\/_wm_)(?!${cdirFwd}\/main\\.ts)(?!${cdirFwd}\/_wm_)(?!${cdirPosix}\/main\\.ts)(?!${cdirPosix}\/_wm_)(?!(?:/private)?${cdirNoPrivate}\/wrapper\\.mjs).*\\.ts$`
+      `^(?!\\.\/main\\.ts)(?!\\.\/_wm_)(?!${cdirFwd}\/main\\.ts)(?!${cdirFwd}\/_wm_)(?!${cdirPosix}\/main\\.ts)(?!${cdirPosix}\/_wm_)(?!(?:/private)?${cdirNoPrivate}\/wrapper\\.mjs)(?:.*\\.ts|(?:\\.\\.?\/|\/?f\/|\/?u\/)(?!.*\\.[A-Za-z0-9]+$).*)$`
     );
 
-    let cdirNodeModules = `${cdirFwd}/node_modules/`;
-
-    const filterLoad = new RegExp(`^${cdir}\/main\\.ts$`);
+    // Match the entry main.ts against bun's forward-slash resolver output on
+    // Windows — raw `cdir` carries backslashes that corrupt the regex, so the
+    // onLoad below would never fire and extensionless relative imports in
+    // main.ts would slip past filterResolve unrewritten.
+    const filterLoad = new RegExp(`^(?:${cdirFwd}|${cdirPosix})\/main\\.ts$`);
     const transpiler = new Bun.Transpiler({
       loader: "ts",
     });
@@ -117,16 +131,35 @@ const p = {
     // Resolve windmill script imports from the file namespace (e.g. from main.ts)
     build.onResolve({ filter: filterResolve }, (args) => {
       const importerFwd = args.importer?.replace(/\\/g, "/") ?? "";
-      if (importerFwd.startsWith(cdirNodeModules)) {
+      // Let bun natively resolve any import originating INSIDE a dependency, so a
+      // package's own relative requires (`./string.js`, extensionless `./foo`)
+      // are never sent to the windmill resolver. Match `/node_modules/` anywhere
+      // rather than a `cdir`-anchored prefix: on Windows `cdir` (canonical, e.g.
+      // `runneradmin`) and the importer path (8.3 short name, e.g. `RUNNER~1`)
+      // disagree, so a prefix check silently fails and dependency imports 404.
+      if (importerFwd.includes("/node_modules/")) {
         return undefined;
       }
-      // Check if the import resolves to a local module file (written by write_module_files)
+      // Check if the import resolves to a local module file (written by
+      // write_module_files, which can nest files in subdirectories). Resolve
+      // candidates against the importer's own directory — not the job root — so
+      // a subdir module importing a sibling (`dir/a.ts` → `./b`) finds
+      // `dir/b.ts` rather than a phantom `job_dir/b.ts`. For imports from
+      // `main.ts` the importer dir IS the job root, so behavior is unchanged.
+      // Module files carry a `.ts` extension, so also try the `.ts` variant of
+      // a bare relative import before falling through to the remote resolver.
       if (args.path.startsWith(".")) {
-        const cwdPath = resolve(cdir, args.path);
-        try {
-          readFileSync(cwdPath);
-          return { path: cwdPath };
-        } catch {}
+        const importerDir = args.importer ? dirname(args.importer) : cdir;
+        const candidates = args.path.endsWith(".ts")
+          ? [args.path]
+          : [args.path, args.path + ".ts"];
+        for (const candidate of candidates) {
+          const cwdPath = resolve(importerDir, candidate);
+          try {
+            readFileSync(cwdPath);
+            return { path: cwdPath };
+          } catch {}
+        }
       }
       const isMainTs =
         args.importer == "./main.ts" || importerFwd.endsWith("/main.ts");
diff --git a/backend/windmill-worker/src/ai_executor.rs b/backend/windmill-worker/src/ai_executor.rs
index cc346f98d4..3bde5e56bb 100644
--- a/backend/windmill-worker/src/ai_executor.rs
+++ b/backend/windmill-worker/src/ai_executor.rs
@@ -869,6 +869,7 @@ pub async fn run_agent(
                         tool_defs.as_deref(),
                         args.provider.get_model(),
                         args.temperature,
+                        args.provider.get_reasoning_effort(),
                         args.max_completion_tokens,
                         api_key,
                         region,
@@ -895,6 +896,7 @@ pub async fn run_agent(
                 tools: tool_defs.as_deref(),
                 model: args.provider.get_model(),
                 temperature: args.temperature,
+                reasoning_effort: args.provider.get_reasoning_effort(),
                 max_tokens: args.max_completion_tokens,
                 output_schema: args.output_schema.as_ref(),
                 output_type,
diff --git a/backend/windmill-worker/src/duckdb_executor.rs b/backend/windmill-worker/src/duckdb_executor.rs
index 09e3158200..051aa77488 100644
--- a/backend/windmill-worker/src/duckdb_executor.rs
+++ b/backend/windmill-worker/src/duckdb_executor.rs
@@ -11,15 +11,15 @@ use serde_json::{json, Value};
 use uuid::Uuid;
 use windmill_common::error::{to_anyhow, Error, Result};
 use windmill_common::utils::sanitize_string_from_password;
-use windmill_common::worker::{get_memory, Connection, SqlResultCollectionStrategy};
+use windmill_common::worker::{get_memory, to_raw_value, Connection, SqlResultCollectionStrategy};
 use windmill_common::workspaces::{
     get_datatable_resource_from_db_unchecked, get_ducklake_from_db_unchecked,
-    DucklakeCatalogResourceType,
+    strip_fork_reserved_attach_args, DucklakeCatalogResourceType,
 };
 use windmill_common::PgDatabase;
 use windmill_object_store::S3_PROXY_LAST_ERRORS_CACHE;
 use windmill_parser_sql::{parse_duckdb_sig, parse_sql_blocks};
-use windmill_queue::{CanceledBy, MiniPulledJob};
+use windmill_queue::{append_logs, CanceledBy, MiniPulledJob};
 use windmill_types::s3::S3Object;
 
 use crate::agent_workers::{get_datatable_resource_from_agent_http, get_ducklake_from_agent_http};
@@ -44,6 +44,27 @@ struct MaterializeExec {
     // (e.g. an FFI serialization change drops the column), we fail loud rather
     // than silently pass declared-but-unverified tests.
     n_data_tests: usize,
+    // `on_schema_change=warn` (default) on a positional persist-and-mutate write:
+    // the summary carries a `schema_drift` column the worker logs + returns.
+    on_schema_change: windmill_parser::asset_parser::OnSchemaChange,
+    // `on_schema_change=sync`: the pre-pass probe (setup + target ATTACH + the
+    // SELECT's/table's column reads) whose result drives the injected ALTER DDL.
+    // `None` for every other mode / non-persist-and-mutate strategy.
+    sync_prepass: Option<SyncPrepass>,
+}
+
+// Inputs for the `on_schema_change=sync` pre-pass: a probe query read against
+// the live session and the target table it migrates. The worker runs the probe
+// (same interpolation + ATTACH transform as the main query), diffs the SELECT's
+// columns against the table's, and splices `ALTER TABLE … ADD/DROP COLUMN` DDL
+// into the plan at the [`SYNC_ALTER_SENTINEL`] slot before the write.
+struct SyncPrepass {
+    // Setup + synthetic target ATTACH + the two column reads. Carries `$args`/
+    // `{partition}` verbatim (the worker interpolates it like the main query).
+    probe_query: String,
+    // Target table within `_wm_target` (e.g. `orders` or `schema.orders`), used
+    // to build the quoted `ALTER TABLE _wm_target.<table>` statements.
+    target_table: String,
 }
 
 // Fetch and validate a custom data-test script's body. v1 custom tests are
@@ -148,11 +169,14 @@ fn build_materialized_query(
         .target_path
         .split_once('/')
         .unwrap_or((m.target_path.as_str(), ""));
-    let meta = MaterializeExec {
+    let mut meta = MaterializeExec {
         asset_kind: windmill_common::assets::AssetKind::Ducklake,
         asset_path: m.target_path.clone(),
         partition: partition.clone(),
         n_data_tests: ann.data_tests.len(),
+        on_schema_change: m.on_schema_change,
+        // Set below once the strategy is known (managed persist-and-mutate only).
+        sync_prepass: None,
     };
 
     // `{partition}` → escaped SQL literal substitution, applied to the managed
@@ -195,19 +219,18 @@ fn build_materialized_query(
     for s in plan.setup.iter_mut() {
         *s = substitute(s);
     }
+    // Deploy (`create_script_internal`) already rejects the invalid SCD2 combos,
+    // but preview/test runs reach the executor without a deploy — re-check so a
+    // bad combo fails with the same clear message instead of a raw DuckDB error.
+    m.validate(partitioned).map_err(Error::ExecutionErr)?;
     let strategy = if m.scd2 {
-        // SCD2 needs a natural key to identify an entity across versions, and its
-        // diff/close/open shape has no partition-scoped form in v1.
+        // SCD2 needs a natural key to identify an entity across versions (checked
+        // by `validate` above, which guarantees a non-empty key here).
         let key = m.unique_key.clone().ok_or_else(|| {
             Error::ExecutionErr(
                 "materialize scd2: requires a natural key — add `key=<col>`".to_string(),
             )
         })?;
-        if partitioned {
-            return Err(Error::ExecutionErr(
-                "materialize scd2: `// partitioned` is not supported with scd2 in v1".to_string(),
-            ));
-        }
         MaterializeStrategy::Scd2 { key, track: m.track.clone(), close_deleted: m.close_deleted }
     } else if m.append {
         MaterializeStrategy::Append
@@ -242,7 +265,37 @@ fn build_materialized_query(
         }
     }
 
-    let blocks = build_wrap_blocks(
+    let cg_probe = windmill_parser::sql_materialize::MaterializeCodegen {
+        target_qualified: "",
+        select_sql: "",
+        partition_col: "_wm_partition",
+        partition_value_sql: "",
+        partitioned,
+        strategy: strategy.clone(),
+        on_schema_change: m.on_schema_change,
+    };
+    // `sync` needs a host round-trip: a pre-pass probe reads the SELECT's and the
+    // table's columns so the ALTER DDL can be computed, then spliced into the
+    // plan at the sentinel slot. Build the probe query here (setup + target
+    // ATTACH + the two column reads) while we still have the substituted SELECT +
+    // setup; the executor runs it through the same interpolation/ATTACH transform
+    // as the main query. Only for the positional persist-and-mutate strategies
+    // (scd2 / whole-table replace emit no sentinel).
+    if m.on_schema_change == windmill_parser::asset_parser::OnSchemaChange::Sync
+        && cg_probe.is_persist_and_mutate()
+    {
+        meta.sync_prepass = Some(SyncPrepass {
+            probe_query: build_sync_probe_query(
+                &plan.setup,
+                &synthetic_attach,
+                &plan.output,
+                table,
+            ),
+            target_table: table.to_string(),
+        });
+    }
+
+    let mat_plan = build_wrap_blocks(
         &plan,
         &synthetic_attach,
         table,
@@ -251,13 +304,204 @@ fn build_materialized_query(
         &pval,
         partitioned,
         strategy,
+        m.on_schema_change,
         &resolved,
     )
     .map_err(Error::ExecutionErr)?;
+    // Enterprise seam: assembles the plan into the final statement list —
+    // verbatim on the public build (commit-then-test), restructured into
+    // write-audit-publish (guarded transaction, rollback on violation) on EE.
+    let blocks =
+        windmill_common::pipeline_advanced::finalize_materialize_query(mat_plan, &m.target_path);
 
     Ok(Some((Some(blocks.join("\n")), meta)))
 }
 
+// Build the `on_schema_change=sync` pre-pass probe: the substituted setup + the
+// synthetic target ATTACH, then two column reads unioned — the SELECT's columns
+// (via `DESCRIBE`) tagged `sel`, and the target table's (via information_schema,
+// which yields zero rows when the table doesn't exist yet, so a first
+// materialize is a no-drift skip rather than an error) tagged `tbl`. The managed
+// `_wm_partition` column is filtered out of the table side. Carries
+// `$args`/`{partition}` verbatim; the caller interpolates + ATTACH-transforms it
+// like the main query so the DESCRIBE binds run-time args.
+fn build_sync_probe_query(
+    setup: &[String],
+    synthetic_attach: &str,
+    select_sql: &str,
+    table: &str,
+) -> String {
+    let (schema, tname) = match table.split_once('.') {
+        Some((s, t)) => (Some(s), t),
+        None => (None, table),
+    };
+    let esc = |s: &str| s.replace('\'', "''");
+    let schema_filter = schema
+        .map(|s| format!(" AND table_schema = '{}'", esc(s)))
+        .unwrap_or_default();
+    let mut out = String::new();
+    let mut push_stmt = |s: &str| {
+        let t = s.trim_end();
+        if t.is_empty() {
+            return;
+        }
+        out.push_str(t);
+        if !t.ends_with(';') {
+            out.push(';');
+        }
+        out.push('\n');
+    };
+    for s in setup {
+        push_stmt(s);
+    }
+    push_stmt(synthetic_attach);
+    // Read the target's columns from `information_schema.columns` scoped to the
+    // attached target catalog via `table_catalog` (DuckDB's catalog-qualified
+    // `<db>.information_schema` does NOT exist; the unqualified view spans
+    // attached catalogs and distinguishes them by `table_catalog`). It yields
+    // zero rows for a not-yet-created table — a no-drift skip, not an error
+    // (unlike `pragma_table_info`/`DESCRIBE`).
+    out.push_str(&format!(
+        "SELECT 'sel' AS _wm_which, column_name AS _wm_name, column_type AS _wm_type \
+         FROM (DESCRIBE SELECT * FROM ({select_sql})) \
+         UNION ALL \
+         SELECT 'tbl' AS _wm_which, column_name AS _wm_name, data_type AS _wm_type \
+         FROM information_schema.columns \
+         WHERE table_catalog = '{alias}' AND table_name = '{tname}'{schema_filter} \
+         AND column_name <> '_wm_partition';",
+        alias = windmill_parser::sql_materialize::TARGET_ALIAS,
+        tname = esc(tname),
+    ));
+    out
+}
+
+// Run the sync pre-pass probe (already interpolated + ATTACH-transformed by the
+// caller) and turn its column diff into the `ALTER TABLE … ADD/DROP COLUMN` DDL
+// to splice at the sentinel. Empty string when the table is fresh (no rows) or
+// the SELECT already matches. The probe failing is fatal (no silent fallback).
+async fn compute_sync_alter_ddl(
+    probe_blocks: Vec<String>,
+    job_args: Vec<Arg>,
+    target_table: String,
+    token: String,
+    base_internal_url: String,
+    w_id: String,
+    job_dir: String,
+) -> Result<String> {
+    let n = probe_blocks.len();
+    let (result, _) = tokio::task::spawn_blocking(move || {
+        run_duckdb_ffi_safe(
+            probe_blocks.iter().map(String::as_str),
+            n,
+            job_args,
+            &token,
+            &base_internal_url,
+            &w_id,
+            &job_dir,
+            SqlResultCollectionStrategy::LastStatementAllRows,
+        )
+    })
+    .await
+    .map_err(|e| Error::from(to_anyhow(e)))
+    .and_then(|r| r)
+    .map_err(|e| {
+        Error::ExecutionErr(format!(
+            "on_schema_change=sync: the schema pre-pass probe failed ({e}); refusing to write"
+        ))
+    })?;
+
+    let (added, removed) = parse_sync_drift(&result)?;
+    let tq = format!(
+        "{}.{}",
+        windmill_parser::sql_materialize::TARGET_ALIAS,
+        quote_qualified_table(&target_table)
+    );
+    let mut stmts = Vec::new();
+    for (name, typ) in &added {
+        if typ.is_empty() {
+            return Err(Error::ExecutionErr(format!(
+                "on_schema_change=sync: could not resolve a type for new column `{name}`"
+            )));
+        }
+        // `typ` is DuckDB's own DESCRIBE type name (e.g. BIGINT, VARCHAR,
+        // DECIMAL(10,2)) — a valid type expression, injected verbatim.
+        stmts.push(format!(
+            "ALTER TABLE {tq} ADD COLUMN \"{}\" {typ};",
+            name.replace('"', "\"\"")
+        ));
+    }
+    for name in &removed {
+        stmts.push(format!(
+            "ALTER TABLE {tq} DROP COLUMN \"{}\";",
+            name.replace('"', "\"\"")
+        ));
+    }
+    Ok(stmts.join("\n"))
+}
+
+// Parse the sync probe result rows (`_wm_which`/`_wm_name`/`_wm_type`) into the
+// column diff: `added` = SELECT columns (with their types) absent from the
+// table, `removed` = table columns absent from the SELECT. `_wm_partition` and
+// empty names are ignored. An empty table side means the table doesn't exist
+// yet — a no-op first materialize, so both lists are empty.
+fn parse_sync_drift(result: &RawValue) -> Result<(Vec<(String, String)>, Vec<String>)> {
+    let root: Value = serde_json::from_str(result.get()).map_err(|e| {
+        Error::ExecutionErr(format!("on_schema_change=sync: bad probe result json: {e}"))
+    })?;
+    // The FFI may surface the rows as an array, a single object, or a JSON
+    // string — normalize to a list of row objects.
+    let owned;
+    let rows: Vec<&Value> = match &root {
+        Value::Array(a) => a.iter().collect(),
+        Value::Object(_) => vec![&root],
+        Value::String(s) => {
+            owned = serde_json::from_str::<Value>(s).unwrap_or(Value::Null);
+            match &owned {
+                Value::Array(a) => a.iter().collect(),
+                Value::Object(_) => vec![&owned],
+                _ => vec![],
+            }
+        }
+        _ => vec![],
+    };
+    let mut sel: Vec<(String, String)> = Vec::new();
+    let mut tbl: std::collections::HashSet<String> = std::collections::HashSet::new();
+    for row in rows {
+        let Some(o) = row.as_object() else { continue };
+        let name = o
+            .get("_wm_name")
+            .and_then(|v| v.as_str())
+            .unwrap_or("")
+            .to_string();
+        if name.is_empty() || name == "_wm_partition" {
+            continue;
+        }
+        let typ = o
+            .get("_wm_type")
+            .and_then(|v| v.as_str())
+            .unwrap_or("")
+            .to_string();
+        match o.get("_wm_which").and_then(|v| v.as_str()).unwrap_or("") {
+            "sel" => sel.push((name, typ)),
+            "tbl" => {
+                tbl.insert(name);
+            }
+            _ => {}
+        }
+    }
+    if tbl.is_empty() {
+        return Ok((Vec::new(), Vec::new()));
+    }
+    let sel_names: std::collections::HashSet<&String> = sel.iter().map(|(n, _)| n).collect();
+    let added = sel
+        .iter()
+        .filter(|(n, _)| !tbl.contains(n))
+        .cloned()
+        .collect();
+    let removed = tbl.into_iter().filter(|n| !sel_names.contains(n)).collect();
+    Ok((added, removed))
+}
+
 // Fetch the deployed body of every `// data_test <path>` custom test declared in
 // `query`, keyed by path, so the sync `build_materialized_query` can splice them
 // in. The DB read is the only part of materialize codegen that needs a
@@ -768,10 +1012,14 @@ fn extract_i64(result: &RawValue, field: &str) -> Option<i64> {
 }
 
 // One data test's outcome as carried by the materialize summary's `data_tests`
-// column: its display name and how many rows violated it (0 = pass).
+// column: its display name, how many rows violated it (0 = pass), and an
+// optional bounded sample of the violating rows. The sample is decoration
+// only — enforcement reads `violating`, never `sample` — so a NULL, dropped
+// (over the size cap) or unparseable sample must never affect pass/fail.
 struct DataTestOutcome {
     name: String,
     violating: i64,
+    sample: Option<Value>,
 }
 
 // Pull the per-test breakdown out of the materialize summary result. The
@@ -788,7 +1036,21 @@ fn extract_data_tests(result: &RawValue) -> Vec<DataTestOutcome> {
                             .get("violating")
                             .and_then(|x| x.as_i64().or_else(|| x.as_f64().map(|f| f as i64)))
                             .unwrap_or(0);
-                        out.push(DataTestOutcome { name: name.clone(), violating });
+                        // The probe serializes the sample as a JSON *string*
+                        // (a VARCHAR through the FFI), deliberately — parse it
+                        // only here, so sampled user columns named `rows` /
+                        // `snapshot_id` stay invisible to the key-recursive
+                        // `extract_i64` scans over the summary result. Accept
+                        // a native array too (FFI JSON-column quirk); anything
+                        // else (NULL, size-capped, garbage) degrades to None.
+                        let sample = o.get("sample").and_then(|s| match s {
+                            arr @ Value::Array(_) => Some(arr.clone()),
+                            Value::String(txt) => serde_json::from_str::<Value>(txt)
+                                .ok()
+                                .filter(|v| v.is_array()),
+                            _ => None,
+                        });
+                        out.push(DataTestOutcome { name: name.clone(), violating, sample });
                     }
                 }
             }
@@ -855,6 +1117,50 @@ fn extract_schema(
     }
 }
 
+// Pull the `on_schema_change=warn` drift out of the materialize summary's
+// `schema_drift` column: a `{added: [..], removed: [..]}` struct (or NULL when
+// the SELECT matched the table). Like `output_schema`, the FFI may surface it
+// nested or as a JSON string — accept both. `None` when there is no drift.
+fn extract_schema_drift(result: &RawValue) -> Option<(Vec<String>, Vec<String>)> {
+    fn str_list(v: Option<&Value>) -> Vec<String> {
+        match v {
+            Some(Value::Array(a)) => a
+                .iter()
+                .filter_map(|x| x.as_str().map(str::to_string))
+                .collect(),
+            _ => Vec::new(),
+        }
+    }
+    fn find_field(v: &Value) -> Option<&Value> {
+        match v {
+            Value::Object(o) => o.get("schema_drift"),
+            Value::Array(a) => a.iter().find_map(find_field),
+            _ => None,
+        }
+    }
+    let root = serde_json::from_str::<Value>(result.get()).ok()?;
+    let field = find_field(&root)?;
+    let owned;
+    let obj = match field {
+        Value::Object(_) => field,
+        // FFI serialized the struct as a JSON string — parse it.
+        Value::String(s) => {
+            owned = serde_json::from_str::<Value>(s).ok()?;
+            &owned
+        }
+        // NULL / absent ⇒ no drift.
+        _ => return None,
+    };
+    let o = obj.as_object()?;
+    let added = str_list(o.get("added"));
+    let removed = str_list(o.get("removed"));
+    if added.is_empty() && removed.is_empty() {
+        None
+    } else {
+        Some((added, removed))
+    }
+}
+
 // Render the full pass/fail breakdown for a failed data-test run — every test,
 // not just the first failure, so the user sees the whole picture in one place.
 fn format_data_test_breakdown(asset_path: &str, tests: &[DataTestOutcome]) -> String {
@@ -1069,7 +1375,27 @@ pub async fn do_duckdb(
 
         let (query, _) =
             &sanitize_and_interpolate_unsafe_sql_args(query, &sig, &job_args, &reserved_variables)?;
-        let query = transform_s3_uris(query).await?;
+        let mut query = transform_s3_uris(query).await?;
+
+        // `on_schema_change=sync`: interpolate the pre-pass probe with the same
+        // sig / args / reserved vars as the main query (before `sig` is consumed
+        // and the arg map drained just below) so its `DESCRIBE` of the SELECT
+        // binds `$args`/`$partition` the same way.
+        let sync_probe_interpolated = match materialize
+            .as_ref()
+            .and_then(|(_, m)| m.sync_prepass.as_ref())
+        {
+            Some(pp) => {
+                let (interp, _) = sanitize_and_interpolate_unsafe_sql_args(
+                    &pp.probe_query,
+                    &sig,
+                    &job_args,
+                    &reserved_variables,
+                )?;
+                Some(transform_s3_uris(&interp).await?)
+            }
+            None => None,
+        };
 
         let job_args = {
             let mut m = Vec::new();
@@ -1104,6 +1430,96 @@ pub async fn do_duckdb(
             m
         };
 
+        // `on_schema_change=sync` pre-pass: run the probe (through the same
+        // ATTACH transform as the main query), diff the SELECT's columns against
+        // the table's, and splice the `ALTER TABLE … ADD/DROP COLUMN` DDL into
+        // the plan at the sentinel slot (removing the sentinel when there is no
+        // drift). Runs before the main query so the ALTERs are in place when the
+        // BY NAME insert executes.
+        if let (Some(probe_sql), Some(pp)) = (
+            &sync_probe_interpolated,
+            materialize
+                .as_ref()
+                .and_then(|(_, m)| m.sync_prepass.as_ref()),
+        ) {
+            let mut probe_blocks = vec![];
+            // Held for the whole probe (through compute_sync_alter_ddl): a
+            // `TYPE bigquery` ATTACH needs GOOGLE_APPLICATION_CREDENTIALS + the
+            // temp creds file set before DuckDB binds the extension, exactly as
+            // the main query path does — otherwise the probe DESCRIBE fails.
+            let mut probe_bigquery_credentials = None;
+            for query_block in parse_sql_blocks(probe_sql, true).iter() {
+                let query_block = remove_comments(query_block);
+                if let Some(parsed) = parse_attach_db_resource(query_block) {
+                    probe_blocks.extend(
+                        transform_attach_db_resource_query(
+                            &parsed,
+                            &job.id,
+                            client,
+                            &mut hidden_passwords,
+                        )
+                        .await?,
+                    );
+                    if parsed.db_type == "bigquery" {
+                        probe_bigquery_credentials = Some(UseBigQueryCredentialsFile::new(
+                            job.id,
+                            parsed.resource_path,
+                        )?);
+                    }
+                } else if let Some(q) = transform_attach_ducklake(
+                    &query_block,
+                    conn,
+                    &mut hidden_passwords,
+                    &job.workspace_id,
+                    materialize.as_ref().map(|(_, m)| m.asset_path.as_str()),
+                )
+                .await?
+                {
+                    probe_blocks.extend(q);
+                } else if let Some(q) = transform_attach_datatable(
+                    &query_block,
+                    conn,
+                    &mut hidden_passwords,
+                    &job.workspace_id,
+                )
+                .await?
+                {
+                    probe_blocks.extend(q);
+                } else {
+                    probe_blocks.push(query_block.to_string());
+                }
+            }
+            // The probe `DESCRIBE`s the same SELECT as the main query, so it
+            // needs the same workspace-macro / `// use` library definitions
+            // injected (post-ATTACH), or a macro-calling SELECT fails to bind
+            // here and the fatal probe makes `sync` unusable with macros.
+            let probe_blocks = inject_workspace_macros(
+                conn,
+                &job.workspace_id,
+                macro_ann.macros,
+                &macro_ann.use_libs,
+                probe_blocks,
+            )
+            .await?;
+            let alter_ddl = compute_sync_alter_ddl(
+                probe_blocks,
+                job_args.clone(),
+                pp.target_table.clone(),
+                token.clone(),
+                client.base_internal_url.clone(),
+                job.workspace_id.clone(),
+                job_dir.to_string(),
+            )
+            .await?;
+            query = query.replace(
+                windmill_parser::sql_materialize::SYNC_ALTER_SENTINEL,
+                &alter_ddl,
+            );
+            // Kept alive until the probe finished; the main query path recreates
+            // its own credentials for its own ATTACH pass below.
+            drop(probe_bigquery_credentials);
+        }
+
         let query_block_list = parse_sql_blocks(&query, true);
 
         // Replace custom ATTACH statements with the real instructions
@@ -1132,6 +1548,7 @@ pub async fn do_duckdb(
                     conn,
                     &mut hidden_passwords,
                     &job.workspace_id,
+                    materialize.as_ref().map(|(_, m)| m.asset_path.as_str()),
                 )
                 .await?
                 {
@@ -1240,6 +1657,11 @@ pub async fn do_duckdb(
             // committed (like dbt), so the slice is recorded `Failed` and the
             // cascade stops. The error lists *every* test so the user sees the
             // whole picture, not just the first failure.
+            // Under enterprise write-audit-publish an in-transaction guard
+            // (the enterprise `finalize_materialize_query` restructure) already aborted a failing run before
+            // COMMIT — that surfaces on the Err path above with the same
+            // breakdown in the error string, and nothing was published; this
+            // post-commit path then only ever sees passing counts.
             let tests = extract_data_tests(&result);
             // Captured output schema (gap #2a) — recorded only on the successful
             // path below, not on the failure paths (a failed run shouldn't
@@ -1254,6 +1676,37 @@ pub async fn do_duckdb(
             } else {
                 None
             };
+            // `on_schema_change=warn` (default): the summary carries a
+            // `schema_drift` column when the SELECT's columns diverged from the
+            // fixed table schema. The write already happened positionally (data
+            // may have landed in the wrong/old columns) — log it LOUDLY so the
+            // drift isn't silent. The drift also rides back in the job result
+            // (it's a column of the returned summary row).
+            if is_managed
+                && meta.on_schema_change == windmill_parser::asset_parser::OnSchemaChange::Warn
+            {
+                if let Some((added, removed)) = extract_schema_drift(&result) {
+                    let fmt = |cols: &[String]| {
+                        if cols.is_empty() {
+                            "(none)".to_string()
+                        } else {
+                            cols.join(", ")
+                        }
+                    };
+                    let warning = format!(
+                        "\n⚠️  SCHEMA DRIFT on {asset}: the SELECT's columns no longer match the \
+                         existing table.\n    added (in SELECT, not in table): {added}\n    removed \
+                         (in table, not in SELECT): {removed}\n    The write proceeded POSITIONALLY \
+                         against the existing table schema — data may have landed in the wrong \
+                         columns. Set `on_schema_change=fail` to block this, or \
+                         `on_schema_change=sync` to migrate the table automatically.\n",
+                        asset = meta.asset_path,
+                        added = fmt(&added),
+                        removed = fmt(&removed),
+                    );
+                    append_logs(&job.id, &job.workspace_id, warning, conn).await;
+                }
+            }
             // Defense-in-depth: codegen embedded `n_data_tests` checks, so the
             // summary row must carry that many outcomes. Recovering fewer means
             // the `data_tests` column was dropped/reshaped before we read it —
@@ -1294,7 +1747,42 @@ pub async fn do_duckdb(
                     Some(&breakdown),
                 )
                 .await;
-                return Err(Error::ExecutionErr(breakdown));
+                // Structured failure payload: the queue wraps it as
+                // `{"error": {...}}` (`WrappedError`) and result_processor
+                // derives the run description from the top-level `message`,
+                // so keep `message` at the top and add no `error` nesting of
+                // our own. Samples ride only on failed tests, only in this
+                // structured result — the message text stays counts-only.
+                let has_samples = tests.iter().any(|t| t.violating > 0 && t.sample.is_some());
+                let message = if has_samples {
+                    // Wording must not match the UI's breakdown-line parsing
+                    // (no ✓/✗, no `— N violating`), which older-result
+                    // rendering still relies on.
+                    format!(
+                        "{breakdown}\n\nSamples of the violating rows are \
+                         attached to this run's result (error.data_tests)."
+                    )
+                } else {
+                    breakdown
+                };
+                let data_tests = tests
+                    .iter()
+                    .map(|t| {
+                        let mut o = json!({ "test": t.name, "violating": t.violating });
+                        if t.violating > 0 {
+                            if let Some(s) = &t.sample {
+                                o["sample"] = s.clone();
+                            }
+                        }
+                        o
+                    })
+                    .collect::<Vec<_>>();
+                return Err(Error::ExecutionRawError(to_raw_value(&json!({
+                    "message": message,
+                    "name": "ExecutionErr",
+                    "step_id": job.flow_step_id,
+                    "data_tests": data_tests,
+                }))));
             }
             record_mat(
                 conn,
@@ -1337,14 +1825,46 @@ pub async fn do_duckdb(
     match result {
         Ok(result) => Ok(result),
         Err(e) => {
-            // Passwords might appear in the error message
-            let mut err_str = e.to_string();
-            for pwd in hidden_passwords.lock().unwrap().iter() {
-                if let Some(sanitized) = sanitize_string_from_password(&err_str, &pwd.clone()) {
-                    err_str = sanitized;
+            // Passwords might appear in the error message — and, for the
+            // structured data-test failure, in sampled row data read from an
+            // attached database — so every outgoing error is sanitized here.
+            let sanitize = |mut s: String| {
+                for pwd in hidden_passwords.lock().unwrap().iter() {
+                    if let Some(sanitized) = sanitize_string_from_password(&s, &pwd.clone()) {
+                        s = sanitized;
+                    }
                 }
+                s
+            };
+            match e {
+                // The structured payload must keep its variant: flattening it
+                // to a string (the arm below) would strip the data-test
+                // samples result_processor places verbatim into the failed
+                // job's result. Sanitize its string *leaves*, not the
+                // serialized text: a secret containing `"` or `\` is
+                // JSON-escaped in the text, so a plain-substring pass would
+                // miss it — and samples carry raw row data from attached
+                // databases.
+                Error::ExecutionRawError(raw) => {
+                    fn walk(v: &mut Value, f: &dyn Fn(String) -> String) {
+                        match v {
+                            Value::String(s) => *s = f(std::mem::take(s)),
+                            Value::Array(a) => a.iter_mut().for_each(|x| walk(x, f)),
+                            Value::Object(o) => o.values_mut().for_each(|x| walk(x, f)),
+                            _ => {}
+                        }
+                    }
+                    Err(match serde_json::from_str::<Value>(raw.get()) {
+                        Ok(mut v) => {
+                            walk(&mut v, &sanitize);
+                            Error::ExecutionRawError(to_raw_value(&v))
+                        }
+                        // Not valid JSON (shouldn't happen) — redact as text.
+                        Err(_) => Error::ExecutionErr(sanitize(raw.get().to_string())),
+                    })
+                }
+                e => Err(Error::ExecutionErr(sanitize(e.to_string()))),
             }
-            Err(Error::ExecutionErr(err_str))
         }
     }
 }
@@ -1483,6 +2003,15 @@ fn cgroup_bytes_to_duckdb_memory_limit(bytes: i64) -> Option<String> {
 }
 
 // Read backend/windmill-duckdb-ffi-internal/README_DEV.md for details about why we use FFI
+// The FFI returns errors as `ERROR <json-encoded-message>` (the message is
+// serde_json::to_string'd). Decode the JSON string back so multi-line errors
+// render with real newlines, not escaped `\n` inside wrapping quotes; fall back
+// to the raw slice if it is somehow not a JSON string.
+fn decode_ffi_error(result_str: &str) -> String {
+    let raw = result_str.strip_prefix("ERROR ").unwrap_or(result_str);
+    serde_json::from_str::<String>(raw).unwrap_or_else(|_| raw.to_string())
+}
+
 fn run_duckdb_ffi_safe<'a>(
     query_block_list: impl Iterator<Item = &'a str>,
     query_block_list_count: usize,
@@ -1548,7 +2077,7 @@ fn run_duckdb_ffi_safe<'a>(
     };
 
     if result_str.starts_with("ERROR") {
-        Err(Error::ExecutionErr(result_str[6..].to_string()))
+        Err(Error::ExecutionErr(decode_ffi_error(&result_str)))
     } else {
         let result = if collection_strategy == SqlResultCollectionStrategy::AllStatementsAllRows {
             // Avoid parsing JSON
@@ -1612,7 +2141,7 @@ fn prepare_duckdb_ffi_safe<'a>(
     };
 
     if result_str.starts_with("ERROR") {
-        Err(Error::ExecutionErr(result_str[6..].to_string()))
+        Err(Error::ExecutionErr(decode_ffi_error(&result_str)))
     } else {
         Ok(serde_json::value::RawValue::from_string(result_str).map_err(to_anyhow)?)
     }
@@ -1763,6 +2292,7 @@ async fn transform_attach_ducklake(
     conn: &Connection,
     hidden_passwords: &mut Arc<Mutex<Vec<String>>>,
     w_id: &str,
+    materialize_target: Option<&str>,
 ) -> Result<Option<Vec<String>>> {
     lazy_static::lazy_static! {
         static ref RE: regex::Regex = regex::Regex::new(r"(?i)ATTACH\s*'ducklake(://[^':]+)?'\s*AS\s+([^ ;]+)\s*(\([^)]*\))?").unwrap();
@@ -1772,15 +2302,28 @@ async fn transform_attach_ducklake(
     };
     let name = cap.get(1).map(|m| &m.as_str()[3..]).unwrap_or("main");
     let alias_name = cap.get(2).map(|m| m.as_str()).unwrap_or("");
-    let extra_args = cap
+    let user_extra_args = cap
         .get(3)
-        .map(|m| format!(", {}", &m.as_str()[1..m.as_str().len() - 1]))
-        .unwrap_or("".to_string());
+        .map(|m| m.as_str()[1..m.as_str().len() - 1].to_string())
+        .unwrap_or_default();
 
     let ducklake = match conn {
         Connection::Http(client) => get_ducklake_from_agent_http(client, name, w_id).await?,
         Connection::Sql(db) => get_ducklake_from_db_unchecked(name, w_id, db).await?,
     };
+    // In a fork, METADATA_SCHEMA / DATA_PATH / OVERRIDE_DATA_PATH are owned by the fork
+    // resolution (DuckDB silently keeps the last occurrence of a duplicated option, so a
+    // user-supplied one would escape the fork namespace back to the parent's).
+    let user_extra_args = if ducklake.fork_defer.is_some() {
+        strip_fork_reserved_attach_args(&user_extra_args)
+    } else {
+        user_extra_args
+    };
+    let extra_args = if user_extra_args.is_empty() {
+        String::new()
+    } else {
+        format!(", {}", user_extra_args)
+    };
     let db_type = match ducklake.catalog.resource_type {
         DucklakeCatalogResourceType::Instance => "postgres",
         _ => ducklake.catalog.resource_type.as_ref(),
@@ -1826,17 +2369,170 @@ async fn transform_attach_ducklake(
     } else {
         format!(", AUTOMATIC_MIGRATION TRUE{extra_args}")
     };
+    // In a fork, re-emit the fork-owned DATA_PATH as the LAST option: DuckDB keeps the last
+    // occurrence of a duplicated option, so this wins over anything the arg stripping might
+    // not recognize (e.g. a dollar-quoted literal), regardless of literal syntax. The
+    // METADATA_SCHEMA injected by the fork resolution is already last within `extra_args`.
+    let extra_args = if ducklake.fork_defer.is_some() {
+        format!("{extra_args}, DATA_PATH 's3://{storage}/{data_path}'")
+    } else {
+        extra_args
+    };
 
     let attach_str = format!(
         "ATTACH 'ducklake:{db_type}:{db_conn_str}' AS {alias_name} (DATA_PATH 's3://{storage}/{data_path}'{extra_args});",
     );
 
     let install_db_ext_str = get_attach_db_install_str(db_type)?;
-    Ok(Some(vec![
+    let mut statements = vec![
         "INSTALL ducklake;".to_string(),
         install_db_ext_str.to_string(),
         attach_str,
-    ]))
+    ];
+    if let Some(defer) = ducklake.fork_defer.as_ref() {
+        statements.extend(fork_defer_statements(
+            name,
+            alias_name,
+            defer,
+            materialize_target,
+            hidden_passwords,
+        )?);
+    }
+    Ok(Some(statements))
+}
+
+// Double-quote a possibly schema-qualified table reference, each dotted segment
+// independently (local copy of sql_materialize's private helper).
+fn quote_qualified_table(name: &str) -> String {
+    name.split('.')
+        .map(|id| format!("\"{}\"", id.replace('"', "\"\"")))
+        .collect::<Vec<_>>()
+        .join(".")
+}
+
+// `schema.table` → `schema.table_current`: the SCD2 companion view lives next to its table.
+fn current_companion(table: &str) -> String {
+    match table.rsplit_once('.') {
+        Some((s, t)) => format!("{s}.{t}_current"),
+        None => format!("{table}_current"),
+    }
+}
+
+/// Statements appended after a fork workspace's lake ATTACH: read-only attaches of the
+/// ancestor namespaces plus `CREATE VIEW IF NOT EXISTS` defer views over the direct parent for
+/// every table the fork has not materialized. When this job's managed materialize targets one
+/// of the deferred tables, its defer view is dropped instead of created — the write must hit a
+/// real fork table (`CREATE [OR REPLACE] TABLE` refuses to replace a view).
+fn fork_defer_statements(
+    lake_name: &str,
+    alias_name: &str,
+    defer: &windmill_common::workspaces::DucklakeForkDefer,
+    materialize_target: Option<&str>,
+    hidden_passwords: &mut Arc<Mutex<Vec<String>>>,
+) -> Result<Vec<String>> {
+    let mut stmts = vec![];
+    if defer.ancestors.is_empty() {
+        // Defer unavailable (an ancestor no longer defines this lake); the fork namespace
+        // still isolates writes.
+        return Ok(stmts);
+    }
+    for a in &defer.ancestors {
+        if let Some(pwd) = a.catalog_resource.get("password").and_then(|p| p.as_str()) {
+            hidden_passwords.lock().unwrap().push(pwd.to_string());
+        }
+        let db_type = match a.catalog.resource_type {
+            DucklakeCatalogResourceType::Instance => "postgres",
+            _ => a.catalog.resource_type.as_ref(),
+        };
+        stmts.push(get_attach_db_install_str(db_type)?.to_string());
+        let conn_str =
+            format_attach_db_conn_str(a.catalog_resource.clone(), db_type)?.replace('\'', "''");
+        let storage = a
+            .storage
+            .storage
+            .as_deref()
+            .unwrap_or(DEFAULT_STORAGE)
+            .replace('\'', "''");
+        let data_path = a.storage.path.replace('\'', "''");
+        let metadata_schema = a
+            .metadata_schema
+            .as_ref()
+            .map(|s| format!(", METADATA_SCHEMA '{}'", s.replace('\'', "''")))
+            .unwrap_or_default();
+        // The ancestor config's own non-reserved args (e.g. `ENCRYPTED true`) — an
+        // option-dependent lake wouldn't attach without them. Emitted FIRST: DuckDB keeps the
+        // last occurrence of a duplicated option, so the fork-owned DATA_PATH / READ_ONLY /
+        // METADATA_SCHEMA after them always win.
+        let extra_args = a
+            .extra_args
+            .as_ref()
+            .map(|e| format!("{e}, "))
+            .unwrap_or_default();
+        // READ_ONLY: a fork job must never write an ancestor namespace. No AUTOMATIC_MIGRATION
+        // / CREATE_IF_NOT_EXISTS: an ancestor lake that would need creating or migrating fails
+        // loudly rather than being mutated from a fork. IF NOT EXISTS: several ATTACH blocks in
+        // one script (e.g. the user's + the materialize synthetic one) emit the same ancestors.
+        stmts.push(format!(
+            "ATTACH IF NOT EXISTS 'ducklake:{db_type}:{conn_str}' AS {} ({extra_args}DATA_PATH 's3://{storage}/{data_path}', OVERRIDE_DATA_PATH TRUE, READ_ONLY{metadata_schema});",
+            a.alias
+        ));
+    }
+    let parent_alias = &defer.ancestors[0].alias;
+    let target_table = materialize_target.and_then(|ap| {
+        let (l, t) = ap.split_once('/')?;
+        (l == lake_name).then_some(t)
+    });
+    let mut created_schemas = std::collections::HashSet::new();
+    for dt in &defer.defer_tables {
+        if Some(dt.table.as_str()) == target_table {
+            continue;
+        }
+        // Each view targets the NEAREST ancestor that physically owns the table (a direct
+        // parent that itself defers has no copy to bind against). Out-of-range index (never
+        // produced by the resolver, but the field crosses the agent wire) falls back to the
+        // direct parent rather than panicking.
+        let owner_alias = defer
+            .ancestors
+            .get(dt.ancestor_idx as usize)
+            .map(|a| a.alias.as_str())
+            .unwrap_or(parent_alias);
+        if let Some((schema, _)) = dt.table.rsplit_once('.') {
+            if created_schemas.insert(schema) {
+                stmts.push(format!(
+                    "CREATE SCHEMA IF NOT EXISTS {alias_name}.{};",
+                    quote_qualified_table(schema)
+                ));
+            }
+        }
+        let q = quote_qualified_table(&dt.table);
+        stmts.push(format!(
+            "CREATE VIEW IF NOT EXISTS {alias_name}.{q} AS SELECT * FROM {owner_alias}.{q};"
+        ));
+        if dt.with_current_view {
+            let qc = quote_qualified_table(&current_companion(&dt.table));
+            stmts.push(format!(
+                "CREATE VIEW IF NOT EXISTS {alias_name}.{qc} AS SELECT * FROM {owner_alias}.{qc};"
+            ));
+        }
+    }
+    if let Some(t) = target_table {
+        // View→table transition: replace the target's defer view(s) with the real table this
+        // job writes (`CREATE [OR REPLACE] TABLE` refuses to replace a view). Keyed on the
+        // catalog's ACTUAL live views — not on recorded materialization status, which after a
+        // failed run can't tell a defer view from a real table, and a mismatched DROP VIEW
+        // would wedge the asset. `_current` is dropped too when it is a view — SCD2 codegen
+        // recreates it with `IF NOT EXISTS`, which would otherwise silently keep a view over
+        // the parent.
+        for name in [t.to_string(), current_companion(t)] {
+            if defer.fork_views.iter().any(|v| v == &name) {
+                stmts.push(format!(
+                    "DROP VIEW IF EXISTS {alias_name}.{};",
+                    quote_qualified_table(&name)
+                ));
+            }
+        }
+    }
+    Ok(stmts)
 }
 
 async fn transform_attach_datatable(
@@ -1941,6 +2637,223 @@ pub struct Arg {
 mod tests {
     use super::*;
 
+    #[test]
+    fn decode_ffi_error_unescapes_multiline_and_strips_quotes() {
+        // Mirror the FFI: JSON-encode the raw DuckDB message, prefix "ERROR ".
+        let raw_msg = "Invalid Input Error: data tests failed on main/raw_orders \
+             (1/3 failed) — write rolled back, previous version left live:\n  \
+             ✓ not_null(order_id)\n  ✗ accepted_values(status) — 12 violating row(s)";
+        let ffi = format!("ERROR {}", serde_json::to_string(raw_msg).unwrap());
+        let decoded = decode_ffi_error(&ffi);
+        assert_eq!(decoded, raw_msg);
+        // real newlines, no literal `\n`, no wrapping quotes
+        assert!(decoded.contains('\n') && !decoded.contains("\\n"));
+        assert!(!decoded.starts_with('"'));
+        // single-line error with inner quotes round-trips unescaped
+        let single = format!(
+            "ERROR {}",
+            serde_json::to_string("Binder Error: column \"x\" not found").unwrap()
+        );
+        assert_eq!(
+            decode_ffi_error(&single),
+            "Binder Error: column \"x\" not found"
+        );
+        // non-JSON payload falls back to the raw slice
+        assert_eq!(decode_ffi_error("ERROR not json"), "not json");
+    }
+
+    fn test_ancestor(wid: &str) -> windmill_common::workspaces::DucklakeAncestorAttach {
+        windmill_common::workspaces::DucklakeAncestorAttach {
+            workspace_id: wid.to_string(),
+            alias: format!("__wm_dl_lake_{}_abcd1234", wid.replace('-', "_")),
+            catalog: windmill_common::workspaces::DucklakeCatalog {
+                resource_type: windmill_common::workspaces::DucklakeCatalogResourceType::Instance,
+                resource_path: "cat_db".to_string(),
+            },
+            catalog_resource: serde_json::json!({
+                "host": "h", "dbname": "cat_db", "user": "u", "password": "pw"
+            }),
+            storage: windmill_common::workspaces::DucklakeStorage {
+                storage: None,
+                path: "lake".to_string(),
+            },
+            metadata_schema: None,
+            extra_args: None,
+        }
+    }
+
+    fn test_fork_defer_chain(
+        ancestor_wids: Vec<&str>,
+        defer_tables: Vec<(&str, bool, u32)>,
+        fork_views: Vec<&str>,
+    ) -> windmill_common::workspaces::DucklakeForkDefer {
+        windmill_common::workspaces::DucklakeForkDefer {
+            ancestors: ancestor_wids.into_iter().map(test_ancestor).collect(),
+            defer_tables: defer_tables
+                .into_iter()
+                .map(
+                    |(t, cur, idx)| windmill_common::materialization::ForkDeferTable {
+                        table: t.to_string(),
+                        with_current_view: cur,
+                        ancestor_idx: idx,
+                    },
+                )
+                .collect(),
+            fork_views: fork_views.into_iter().map(str::to_string).collect(),
+        }
+    }
+
+    fn test_fork_defer(
+        defer_tables: Vec<(&str, bool)>,
+        fork_views: Vec<&str>,
+    ) -> windmill_common::workspaces::DucklakeForkDefer {
+        test_fork_defer_chain(
+            vec!["parent-ws"],
+            defer_tables.into_iter().map(|(t, c)| (t, c, 0)).collect(),
+            fork_views,
+        )
+    }
+
+    #[test]
+    fn test_fork_defer_statements_ancestor_extra_args() {
+        // The ancestor config's own args (e.g. ENCRYPTED) must ride on its read-only attach —
+        // BEFORE the fork-owned options, so DuckDB's last-occurrence-wins keeps DATA_PATH /
+        // READ_ONLY / METADATA_SCHEMA authoritative even if the args tried to override them.
+        let mut defer = test_fork_defer(vec![("orders", false)], vec![]);
+        defer.ancestors[0].extra_args = Some("ENCRYPTED true".to_string());
+        let mut hp = Arc::new(Mutex::new(vec![]));
+        let stmts = fork_defer_statements("lake", "dl", &defer, None, &mut hp).unwrap();
+        let attach = stmts
+            .iter()
+            .find(|s| s.starts_with("ATTACH IF NOT EXISTS"))
+            .unwrap();
+        assert!(attach.contains("(ENCRYPTED true, DATA_PATH "), "{attach}");
+        assert!(
+            attach.find("ENCRYPTED true").unwrap() < attach.find("READ_ONLY").unwrap(),
+            "{attach}"
+        );
+    }
+
+    #[test]
+    fn test_fork_defer_statements_chained_ancestors() {
+        // fork → parent → root: `orders` was only materialized in the root (idx 1) — its view
+        // must target the ROOT alias (the parent has no physical copy); `daily` owned by the
+        // direct parent (idx 0) targets the parent alias. Out-of-range idx falls back to the
+        // direct parent instead of panicking.
+        let defer = test_fork_defer_chain(
+            vec!["parent-ws", "root-ws"],
+            vec![("orders", false, 1), ("daily", false, 0), ("oob", false, 9)],
+            vec![],
+        );
+        let mut hp = Arc::new(Mutex::new(vec![]));
+        let stmts = fork_defer_statements("lake", "dl", &defer, None, &mut hp).unwrap();
+        let joined = stmts.join("\n");
+        assert!(
+            joined.contains(
+                "CREATE VIEW IF NOT EXISTS dl.\"orders\" AS SELECT * FROM __wm_dl_lake_root_ws_abcd1234.\"orders\""
+            ),
+            "{joined}"
+        );
+        assert!(
+            joined.contains(
+                "CREATE VIEW IF NOT EXISTS dl.\"daily\" AS SELECT * FROM __wm_dl_lake_parent_ws_abcd1234.\"daily\""
+            ),
+            "{joined}"
+        );
+        assert!(
+            joined.contains(
+                "CREATE VIEW IF NOT EXISTS dl.\"oob\" AS SELECT * FROM __wm_dl_lake_parent_ws_abcd1234.\"oob\""
+            ),
+            "{joined}"
+        );
+        // Both ancestors attached read-only.
+        assert_eq!(
+            joined.matches("ATTACH IF NOT EXISTS").count(),
+            2,
+            "{joined}"
+        );
+    }
+
+    #[test]
+    fn test_fork_defer_statements_shape() {
+        let defer = test_fork_defer(vec![("orders", false), ("dim", true)], vec![]);
+        let mut hp = Arc::new(Mutex::new(vec![]));
+        let stmts = fork_defer_statements("lake", "dl", &defer, None, &mut hp).unwrap();
+        let joined = stmts.join("\n");
+        // Ancestor attach: read-only, idempotent, never auto-migrating or auto-creating.
+        assert!(joined.contains("ATTACH IF NOT EXISTS"), "{joined}");
+        assert!(joined.contains("READ_ONLY"), "{joined}");
+        assert!(!joined.contains("AUTOMATIC_MIGRATION"), "{joined}");
+        assert!(!joined.contains("CREATE_IF_NOT_EXISTS"), "{joined}");
+        // Ancestor catalog password is hidden from logs.
+        assert_eq!(hp.lock().unwrap().as_slice(), ["pw"]);
+        // Defer views over the parent alias, plus the SCD2 `_current` companion.
+        assert!(
+            joined.contains(
+                "CREATE VIEW IF NOT EXISTS dl.\"orders\" AS SELECT * FROM __wm_dl_lake_parent_ws_abcd1234.\"orders\""
+            ),
+            "{joined}"
+        );
+        assert!(joined.contains("dl.\"dim_current\""), "{joined}");
+        // No target → no transition drops.
+        assert!(!joined.contains("DROP VIEW"), "{joined}");
+    }
+
+    #[test]
+    fn test_fork_defer_statements_target_transition() {
+        // Target currently a defer view → skip its CREATE, drop the view (+ companion).
+        let defer = test_fork_defer(vec![("orders", false)], vec!["orders", "orders_current"]);
+        let mut hp = Arc::new(Mutex::new(vec![]));
+        let stmts =
+            fork_defer_statements("lake", "_wm_target", &defer, Some("lake/orders"), &mut hp)
+                .unwrap();
+        let joined = stmts.join("\n");
+        assert!(!joined.contains("CREATE VIEW"), "{joined}");
+        assert!(
+            joined.contains("DROP VIEW IF EXISTS _wm_target.\"orders\";"),
+            "{joined}"
+        );
+        assert!(
+            joined.contains("DROP VIEW IF EXISTS _wm_target.\"orders_current\";"),
+            "{joined}"
+        );
+
+        // Target already a real table (NOT in fork_views, e.g. after a failed re-run whose
+        // status can't be trusted) → no DROP VIEW, or the job would wedge on a type mismatch.
+        let defer = test_fork_defer(vec![("orders", false)], vec![]);
+        let stmts =
+            fork_defer_statements("lake", "_wm_target", &defer, Some("lake/orders"), &mut hp)
+                .unwrap();
+        assert!(!stmts.join("\n").contains("DROP VIEW"), "{stmts:?}");
+
+        // Target in a different lake → this lake's defer views are untouched.
+        let defer = test_fork_defer(vec![("orders", false)], vec!["orders"]);
+        let stmts =
+            fork_defer_statements("lake", "dl", &defer, Some("other/orders"), &mut hp).unwrap();
+        let joined = stmts.join("\n");
+        assert!(
+            joined.contains("CREATE VIEW IF NOT EXISTS dl.\"orders\""),
+            "{joined}"
+        );
+        assert!(!joined.contains("DROP VIEW"), "{joined}");
+    }
+
+    #[test]
+    fn test_fork_defer_statements_schema_qualified() {
+        let defer = test_fork_defer(vec![("staging.raw", false)], vec![]);
+        let mut hp = Arc::new(Mutex::new(vec![]));
+        let stmts = fork_defer_statements("lake", "dl", &defer, None, &mut hp).unwrap();
+        let joined = stmts.join("\n");
+        assert!(
+            joined.contains("CREATE SCHEMA IF NOT EXISTS dl.\"staging\";"),
+            "{joined}"
+        );
+        assert!(
+            joined.contains("CREATE VIEW IF NOT EXISTS dl.\"staging\".\"raw\""),
+            "{joined}"
+        );
+    }
+
     fn mrow(name: &str, params: &str, body: &str, is_table: bool, provider: &str) -> MacroRow {
         MacroRow {
             name: name.to_string(),
@@ -2498,6 +3411,168 @@ mod tests {
         );
     }
 
+    // The rewritten SQL is the plan assembled by
+    // `pipeline_advanced::finalize_materialize_query`, so what it contains is
+    // build-dependent: the public assembly runs the plan verbatim (tests only
+    // in the post-commit summary breakdown), the enterprise assembly adds the
+    // in-transaction write-audit-publish guard (whose shape/placement is
+    // tested next to its implementation in windmill-common's
+    // `pipeline_advanced_ee`).
+    #[test]
+    fn materialize_rewrite_carries_data_test_summary() {
+        let script = "-- materialize ducklake://main/orders\n\
+                      -- data_test not_null id\n\
+                      SELECT id FROM dl.src";
+        let (rewritten, meta) =
+            build_materialized_query(script, None, &std::collections::HashMap::new())
+                .expect("materialize builds")
+                .expect("materialize present");
+        let rewritten = rewritten.expect("managed mode rewrites the query");
+        assert!(rewritten.contains("AS data_tests"));
+        assert_eq!(meta.n_data_tests, 1);
+        #[cfg(not(feature = "private"))]
+        assert!(
+            !rewritten.contains("error("),
+            "public assembly is commit-then-test (no guard)"
+        );
+        #[cfg(all(feature = "private", feature = "enterprise"))]
+        assert!(
+            rewritten.contains("error("),
+            "enterprise assembly places the WAP guard"
+        );
+    }
+
+    // on_schema_change=fail on a persist-and-mutate strategy (merge) emits the
+    // drift guard inside the write, and no sync artifacts.
+    #[test]
+    fn materialize_fail_emits_drift_guard() {
+        let script = "-- materialize ducklake://main/dim key=id on_schema_change=fail\n\
+                      SELECT id, name FROM dl.src";
+        let (rewritten, meta) =
+            build_materialized_query(script, None, &std::collections::HashMap::new())
+                .expect("materialize builds")
+                .expect("materialize present");
+        let rewritten = rewritten.expect("managed mode rewrites the query");
+        assert!(
+            rewritten.contains("CAST(error(") && rewritten.contains("on_schema_change=fail"),
+            "fail emits the drift guard: {rewritten}"
+        );
+        assert!(!rewritten.contains("BY NAME"), "fail writes positionally");
+        assert!(meta.sync_prepass.is_none(), "fail needs no pre-pass probe");
+    }
+
+    // on_schema_change=sync writes BY NAME, emits the ALTER sentinel, and builds
+    // the pre-pass probe (DESCRIBE of the SELECT + information_schema read).
+    #[test]
+    fn materialize_sync_by_name_and_prepass() {
+        let script = "-- materialize ducklake://main/dim key=id on_schema_change=sync\n\
+                      SELECT id, name FROM dl.src";
+        let (rewritten, meta) =
+            build_materialized_query(script, None, &std::collections::HashMap::new())
+                .expect("materialize builds")
+                .expect("materialize present");
+        let rewritten = rewritten.expect("managed mode rewrites the query");
+        assert!(
+            rewritten.contains("INSERT INTO _wm_target.dim BY NAME"),
+            "sync insert is name-mapped: {rewritten}"
+        );
+        assert!(
+            rewritten.contains(windmill_parser::sql_materialize::SYNC_ALTER_SENTINEL),
+            "sync emits the ALTER injection sentinel"
+        );
+        let pp = meta.sync_prepass.expect("sync builds a pre-pass probe");
+        assert_eq!(pp.target_table, "dim");
+        assert!(pp
+            .probe_query
+            .contains("DESCRIBE SELECT * FROM (SELECT id, name FROM dl.src)"));
+        assert!(pp.probe_query.contains("FROM information_schema.columns"));
+        assert!(pp
+            .probe_query
+            .contains("table_catalog = '_wm_target' AND table_name = 'dim'"));
+        assert!(pp
+            .probe_query
+            .contains("ATTACH 'ducklake://main' AS _wm_target;"));
+    }
+
+    // on_schema_change=warn (default) on a persist-and-mutate strategy folds the
+    // drift into the summary; no guard, no sync artifacts.
+    #[test]
+    fn materialize_warn_summary_carries_schema_drift() {
+        let script = "-- materialize ducklake://main/dim key=id\n\
+                      SELECT id, name FROM dl.src";
+        let (rewritten, meta) =
+            build_materialized_query(script, None, &std::collections::HashMap::new())
+                .expect("materialize builds")
+                .expect("materialize present");
+        let rewritten = rewritten.expect("managed mode rewrites the query");
+        assert!(
+            rewritten.contains("AS schema_drift"),
+            "warn folds drift into the summary: {rewritten}"
+        );
+        // No schema-drift *fail* guard in warn mode (the keyed merge still emits
+        // its own duplicate-source-key guard, which is a different `error(...)`).
+        assert!(!rewritten.contains("on_schema_change=fail blocked"));
+        assert!(rewritten.contains("keyed merge on `id` blocked"));
+        assert!(!rewritten.contains("BY NAME"));
+        assert!(meta.sync_prepass.is_none());
+    }
+
+    // Whole-table replace (unpartitioned, no key/append) is not persist-and-
+    // mutate: even with on_schema_change=fail there is no guard / sentinel — the
+    // CREATE OR REPLACE already rebuilds the schema each run.
+    #[test]
+    fn materialize_whole_table_replace_ignores_guardrail() {
+        let script = "-- materialize ducklake://main/t on_schema_change=fail\n\
+                      SELECT a, b FROM dl.src";
+        let (rewritten, meta) =
+            build_materialized_query(script, None, &std::collections::HashMap::new())
+                .expect("materialize builds")
+                .expect("materialize present");
+        let rewritten = rewritten.expect("managed mode rewrites the query");
+        assert!(rewritten.contains("CREATE OR REPLACE TABLE _wm_target.t"));
+        assert!(!rewritten.contains("on_schema_change=fail"));
+        assert!(!rewritten.contains(windmill_parser::sql_materialize::SYNC_ALTER_SENTINEL));
+        assert!(meta.sync_prepass.is_none());
+    }
+
+    #[test]
+    fn extract_schema_drift_parses_struct_and_string_and_null() {
+        // nested struct form
+        let r = raw(
+            r#"{"materialized":"ducklake://main/dim","schema_drift":{"added":["c"],"removed":["b"]}}"#,
+        );
+        let (added, removed) = extract_schema_drift(&r).expect("drift present");
+        assert_eq!(added, vec!["c".to_string()]);
+        assert_eq!(removed, vec!["b".to_string()]);
+        // FFI string-encoded form
+        let r = raw(r#"{"schema_drift":"{\"added\":[\"x\"],\"removed\":[]}"}"#);
+        let (added, removed) = extract_schema_drift(&r).expect("drift present");
+        assert_eq!(added, vec!["x".to_string()]);
+        assert!(removed.is_empty());
+        // NULL / both-empty ⇒ no drift
+        assert!(extract_schema_drift(&raw(r#"{"schema_drift":null}"#)).is_none());
+        assert!(
+            extract_schema_drift(&raw(r#"{"schema_drift":{"added":[],"removed":[]}}"#)).is_none()
+        );
+        assert!(extract_schema_drift(&raw(r#"{"rows":3}"#)).is_none());
+    }
+
+    #[test]
+    fn parse_sync_drift_computes_added_removed_and_skips_fresh_table() {
+        // table (a, b) vs SELECT (a, c): add c, drop b; _wm_partition ignored
+        let r = raw(r#"[{"_wm_which":"sel","_wm_name":"a","_wm_type":"BIGINT"},
+                {"_wm_which":"sel","_wm_name":"c","_wm_type":"VARCHAR"},
+                {"_wm_which":"tbl","_wm_name":"a","_wm_type":"BIGINT"},
+                {"_wm_which":"tbl","_wm_name":"b","_wm_type":"BIGINT"}]"#);
+        let (added, removed) = parse_sync_drift(&r).unwrap();
+        assert_eq!(added, vec![("c".to_string(), "VARCHAR".to_string())]);
+        assert_eq!(removed, vec!["b".to_string()]);
+        // no `tbl` rows ⇒ table doesn't exist yet ⇒ no migration
+        let r = raw(r#"[{"_wm_which":"sel","_wm_name":"a","_wm_type":"BIGINT"}]"#);
+        let (added, removed) = parse_sync_drift(&r).unwrap();
+        assert!(added.is_empty() && removed.is_empty());
+    }
+
     // Tests for parse_attach_db_resource function
     #[test]
     fn test_parse_attach_db_resource_postgres_res_prefix() {
@@ -2867,15 +3942,22 @@ mod tests {
         // `data_tests` array (how the FFI serialises the list-of-struct).
         let r = raw(
             r#"[{"rows":3,"snapshot_id":17,"materialized":"ducklake://a/b",
-                "data_tests":[{"test":"unique(order_id)","violating":0},
-                              {"test":"accepted_values(status)","violating":2}]}]"#,
+                "data_tests":[{"test":"unique(order_id)","violating":0,"sample":null},
+                              {"test":"accepted_values(status)","violating":2,
+                               "sample":"[{\"id\":1,\"status\":\"bad\"}]"}]}]"#,
         );
         let out = extract_data_tests(&r);
         assert_eq!(out.len(), 2);
         assert_eq!(out[0].name, "unique(order_id)");
         assert_eq!(out[0].violating, 0);
+        assert!(out[0].sample.is_none());
         assert_eq!(out[1].name, "accepted_values(status)");
         assert_eq!(out[1].violating, 2);
+        // The probe emits the sample as a JSON string; it parses to rows here.
+        assert_eq!(
+            out[1].sample,
+            Some(serde_json::json!([{"id": 1, "status": "bad"}]))
+        );
     }
 
     #[test]
@@ -2886,10 +3968,30 @@ mod tests {
         assert_eq!(out.len(), 1);
         assert_eq!(out[0].name, "not_null(x)");
         assert_eq!(out[0].violating, 1);
+        assert!(out[0].sample.is_none());
         // Absent column (no tests) -> empty, no panic.
         assert!(extract_data_tests(&raw(r#"[{"rows":3}]"#)).is_empty());
     }
 
+    #[test]
+    fn extract_data_tests_sample_degrades_to_none_never_flips_outcome() {
+        // sample is optional by contract: native array accepted; non-array
+        // JSON, garbage text, and absence all degrade to None without
+        // touching `violating`.
+        let r = raw(r#"[{"data_tests":[
+                {"test":"a","violating":1,"sample":[{"id":9}]},
+                {"test":"b","violating":2,"sample":"{\"not\":\"an array\"}"},
+                {"test":"c","violating":3,"sample":"not json at all"},
+                {"test":"d","violating":4}]}]"#);
+        let out = extract_data_tests(&r);
+        assert_eq!(out.len(), 4);
+        assert_eq!(out[0].sample, Some(serde_json::json!([{"id": 9}])));
+        for (i, t) in out.iter().enumerate().skip(1) {
+            assert!(t.sample.is_none(), "test {} should have no sample", t.name);
+            assert_eq!(t.violating, i as i64 + 1);
+        }
+    }
+
     #[test]
     fn extract_schema_parses_nested_and_string_encoded() {
         // Real shape: the summary row carries a nested `output_schema`
@@ -2918,9 +4020,15 @@ mod tests {
     #[test]
     fn format_data_test_breakdown_lists_all_with_marks() {
         let tests = vec![
-            DataTestOutcome { name: "unique(order_id)".into(), violating: 1 },
-            DataTestOutcome { name: "not_null(user_id)".into(), violating: 0 },
-            DataTestOutcome { name: "accepted_values(status)".into(), violating: 2 },
+            DataTestOutcome { name: "unique(order_id)".into(), violating: 1, sample: None },
+            DataTestOutcome { name: "not_null(user_id)".into(), violating: 0, sample: None },
+            DataTestOutcome {
+                name: "accepted_values(status)".into(),
+                violating: 2,
+                // The breakdown is counts-only by design — samples never
+                // appear in the error text.
+                sample: Some(serde_json::json!([{"status": "bad"}])),
+            },
         ];
         let msg = format_data_test_breakdown("analytics/orders", &tests);
         assert_eq!(
diff --git a/benchmarks/lib.ts b/benchmarks/lib.ts
index 4b342d93bd..71ec4f546e 100644
--- a/benchmarks/lib.ts
+++ b/benchmarks/lib.ts
@@ -2,7 +2,7 @@ import { sleep } from "https://deno.land/x/sleep@v1.2.1/mod.ts";
 import * as windmill from "https://deno.land/x/windmill@v1.174.0/mod.ts";
 import * as api from "https://deno.land/x/windmill@v1.174.0/windmill-api/index.ts";
 
-export const VERSION = "v1.747.0";
+export const VERSION = "v1.749.0";
 
 export async function login(email: string, password: string): Promise<string> {
   return await windmill.UserService.login({
diff --git a/cli/build-npm.ts b/cli/build-npm.ts
index 5c9353dd21..1dbc9261de 100644
--- a/cli/build-npm.ts
+++ b/cli/build-npm.ts
@@ -4,24 +4,20 @@ import { join } from "node:path";
 
 const outDir = "./npm";
 
-// Parser npm packages — used as externals and added to generated package.json
-const parserPackages = [
-  "windmill-parser-wasm-py", "windmill-parser-wasm-ts",
-  "windmill-parser-wasm-regex", "windmill-parser-wasm-go",
-  "windmill-parser-wasm-php", "windmill-parser-wasm-rust",
-  "windmill-parser-wasm-yaml", "windmill-parser-wasm-csharp",
-  "windmill-parser-wasm-nu", "windmill-parser-wasm-java",
-  "windmill-parser-wasm-ruby",
-  "windmill-parser-wasm-py-imports",
-];
-const parserExternals = parserPackages.flatMap(p => ["--external", p]);
-
 // Forward parser specs from the dev package.json so the published CLI pins
-// to the same versions devs install/test against. Falls back to "*" if not
-// listed locally.
+// to the same versions devs install/test against.
 const cliDeps: Record<string, string> =
   JSON.parse(readFileSync("./package.json", "utf-8")).dependencies ?? {};
 
+// Parser packages: bundle externals + published dependencies. Derived from
+// package.json (not hand-listed) — a parser missing from this set ships a CLI
+// whose loadParser() silently falls back. package.json itself is kept in sync
+// with loadParser() call sites by test/parser_packages_unit.test.ts.
+const parserPackages = Object.keys(cliDeps).filter((p) =>
+  p.startsWith("windmill-parser-wasm")
+);
+const parserExternals = parserPackages.flatMap(p => ["--external", p]);
+
 // Clean output directory
 rmSync(outDir, { recursive: true, force: true });
 
diff --git a/cli/bun.lock b/cli/bun.lock
index 50bcc48222..a745acbcba 100644
--- a/cli/bun.lock
+++ b/cli/bun.lock
@@ -19,7 +19,7 @@
         "pg-gateway": "0.3.0-beta.4",
         "svelte": "^5.45.2",
         "tar-stream": "^3.1.7",
-        "windmill-parser-wasm-asset": "1.740.0",
+        "windmill-parser-wasm-asset": "1.749.0",
         "windmill-parser-wasm-csharp": "1.510.1",
         "windmill-parser-wasm-go": "1.510.1",
         "windmill-parser-wasm-java": "1.510.1",
@@ -27,6 +27,7 @@
         "windmill-parser-wasm-php": "1.647.1",
         "windmill-parser-wasm-py": "1.693.1",
         "windmill-parser-wasm-py-imports": "1.693.1",
+        "windmill-parser-wasm-r": "1.668.1",
         "windmill-parser-wasm-regex": "1.692.0",
         "windmill-parser-wasm-ruby": "1.526.1",
         "windmill-parser-wasm-rust": "1.647.1",
@@ -289,7 +290,7 @@
 
     "utility-types": ["utility-types@3.11.0", "", {}, "sha512-6Z7Ma2aVEWisaL6TvBCy7P8rm2LQoPv6dJ7ecIaIixHcwfbJ0x7mWdbcwlIM5IGQxPZSFYeqRCqlOOeKoJYMkw=="],
 
-    "windmill-parser-wasm-asset": ["windmill-parser-wasm-asset@1.740.0", "", {}, "sha512-Dgn5sQ93vJpqTQkv9iAy25+bqH2bUnIMdCfERb2Tia0Ql9T6iHbQhi4yzH9FbGW4Drv9GP46Qyetphqvp8vFOw=="],
+    "windmill-parser-wasm-asset": ["windmill-parser-wasm-asset@1.749.0", "", {}, "sha512-gj8g9sWQ0tXKfXso7xJxR56sS8Loe/RsnFy+0af5R8siZeCag9ikquGbQ8d8kOqIK2U8eCNA0LqsU/xAFDJIOg=="],
 
     "windmill-parser-wasm-csharp": ["windmill-parser-wasm-csharp@1.510.1", "", {}, "sha512-qm09YmnbeYHLwYn1jUnObVzPhYO9NZKMlIO7nlo7zPJBXqksgG5fK/KCtwGw9rChrnz+DsvM9wP5FhrwRLMtwQ=="],
 
@@ -305,6 +306,8 @@
 
     "windmill-parser-wasm-py-imports": ["windmill-parser-wasm-py-imports@1.693.1", "", {}, "sha512-FC0KbREe2G/sa/9kYIR930wmWw+VL6PvEIqg12J3dsJes3A+0x5JIUPT/jeD+c24DrG0ko/Ub7yDnYs56Bem7g=="],
 
+    "windmill-parser-wasm-r": ["windmill-parser-wasm-r@1.668.1", "", {}, "sha512-5YNeUibxpNBvYrxCgQcz1PxGhTFx2CyEpg2udtIhq7bx0d4gF/KDZVupMeQmAObmrEtTSFGUWNRJ4zXSWNrSpQ=="],
+
     "windmill-parser-wasm-regex": ["windmill-parser-wasm-regex@1.692.0", "", {}, "sha512-BHGTxrinZJ9ef6hFxbKiBqBEr5uqgG/QySOgMA5r1LswO9n/8fyGswr8JcPT2kGaoeoweV6/RQ+RHVaOhosnKw=="],
 
     "windmill-parser-wasm-ruby": ["windmill-parser-wasm-ruby@1.526.1", "", {}, "sha512-rMBQA8s21wmL2kA5ztRs/ZgVA3ckxe9/NLjxl3iQPL0CX6DlvfaUH0O+AnhpXXDMyBs1Y1SZIhcnbnvsHZ3R8g=="],
diff --git a/cli/package-lock.json b/cli/package-lock.json
index 949b44e948..a9d72696b2 100644
--- a/cli/package-lock.json
+++ b/cli/package-lock.json
@@ -20,7 +20,7 @@
         "pg-gateway": "0.3.0-beta.4",
         "svelte": "^5.45.2",
         "tar-stream": "^3.1.7",
-        "windmill-parser-wasm-asset": "1.740.0",
+        "windmill-parser-wasm-asset": "1.749.0",
         "windmill-parser-wasm-csharp": "1.510.1",
         "windmill-parser-wasm-go": "1.510.1",
         "windmill-parser-wasm-java": "1.510.1",
@@ -28,6 +28,7 @@
         "windmill-parser-wasm-php": "1.647.1",
         "windmill-parser-wasm-py": "1.693.1",
         "windmill-parser-wasm-py-imports": "1.693.1",
+        "windmill-parser-wasm-r": "1.668.1",
         "windmill-parser-wasm-regex": "1.692.0",
         "windmill-parser-wasm-ruby": "1.526.1",
         "windmill-parser-wasm-rust": "1.647.1",
@@ -1411,9 +1412,9 @@
       }
     },
     "node_modules/windmill-parser-wasm-asset": {
-      "version": "1.740.0",
-      "resolved": "https://registry.npmjs.org/windmill-parser-wasm-asset/-/windmill-parser-wasm-asset-1.740.0.tgz",
-      "integrity": "sha512-Dgn5sQ93vJpqTQkv9iAy25+bqH2bUnIMdCfERb2Tia0Ql9T6iHbQhi4yzH9FbGW4Drv9GP46Qyetphqvp8vFOw=="
+      "version": "1.749.0",
+      "resolved": "https://registry.npmjs.org/windmill-parser-wasm-asset/-/windmill-parser-wasm-asset-1.749.0.tgz",
+      "integrity": "sha512-gj8g9sWQ0tXKfXso7xJxR56sS8Loe/RsnFy+0af5R8siZeCag9ikquGbQ8d8kOqIK2U8eCNA0LqsU/xAFDJIOg=="
     },
     "node_modules/windmill-parser-wasm-csharp": {
       "version": "1.510.1",
@@ -1450,6 +1451,11 @@
       "resolved": "https://registry.npmjs.org/windmill-parser-wasm-py-imports/-/windmill-parser-wasm-py-imports-1.693.1.tgz",
       "integrity": "sha512-FC0KbREe2G/sa/9kYIR930wmWw+VL6PvEIqg12J3dsJes3A+0x5JIUPT/jeD+c24DrG0ko/Ub7yDnYs56Bem7g=="
     },
+    "node_modules/windmill-parser-wasm-r": {
+      "version": "1.668.1",
+      "resolved": "https://registry.npmjs.org/windmill-parser-wasm-r/-/windmill-parser-wasm-r-1.668.1.tgz",
+      "integrity": "sha512-5YNeUibxpNBvYrxCgQcz1PxGhTFx2CyEpg2udtIhq7bx0d4gF/KDZVupMeQmAObmrEtTSFGUWNRJ4zXSWNrSpQ=="
+    },
     "node_modules/windmill-parser-wasm-regex": {
       "version": "1.692.0",
       "resolved": "https://registry.npmjs.org/windmill-parser-wasm-regex/-/windmill-parser-wasm-regex-1.692.0.tgz",
diff --git a/cli/package.json b/cli/package.json
index 1cf937d95e..589bc52271 100644
--- a/cli/package.json
+++ b/cli/package.json
@@ -28,7 +28,7 @@
     "pg-gateway": "0.3.0-beta.4",
     "svelte": "^5.45.2",
     "tar-stream": "^3.1.7",
-    "windmill-parser-wasm-asset": "1.740.0",
+    "windmill-parser-wasm-asset": "1.749.0",
     "windmill-parser-wasm-csharp": "1.510.1",
     "windmill-parser-wasm-go": "1.510.1",
     "windmill-parser-wasm-java": "1.510.1",
@@ -36,6 +36,7 @@
     "windmill-parser-wasm-php": "1.647.1",
     "windmill-parser-wasm-py": "1.693.1",
     "windmill-parser-wasm-py-imports": "1.693.1",
+    "windmill-parser-wasm-r": "1.668.1",
     "windmill-parser-wasm-regex": "1.692.0",
     "windmill-parser-wasm-ruby": "1.526.1",
     "windmill-parser-wasm-rust": "1.647.1",
diff --git a/cli/src/commands/init/init.ts b/cli/src/commands/init/init.ts
index f1a10d7cc9..fc6e70c5b2 100644
--- a/cli/src/commands/init/init.ts
+++ b/cli/src/commands/init/init.ts
@@ -251,7 +251,7 @@ async function initAction(opts: InitOptions) {
     );
   }
 
-  // Generate resource type namespace (only if a workspace was bound)
+  // Generate resource type namespace (needs a bound workspace)
   if (didBindWorkspace && boundProfile) {
     try {
       // Cache the bound profile so resolveWorkspace doesn't re-resolve and prompt again
@@ -266,9 +266,51 @@ async function initAction(opts: InitOptions) {
       );
     }
   } else {
-    log.info(
-      colors.gray("Skipped resource type namespace generation (no workspace bound). Run 'wmill workspace bind' then 'wmill init' to generate it.")
+    // generateRTNamespace resolves a workspace; its non-interactive
+    // multiple-workspaces path process.exit(-1)s (uncatchable), aborting init.
+    // So generate only for a single resolvable workspace (baseUrl + matching
+    // profile), passed via __secret_workspace to skip resolution; else skip.
+    const { readConfigFile, getWorkspaceNames, getEffectiveWorkspaceId } =
+      await import("../../core/conf.ts");
+    const config = await readConfigFile({ warnIfMissing: false });
+    const resolvable = getWorkspaceNames(config.workspaces).filter(
+      (n) => !!(config.workspaces as any)?.[n]?.baseUrl
     );
+    let boundProfileForGen: Workspace | undefined;
+    if (resolvable.length === 1) {
+      const name = resolvable[0];
+      const entry = (config.workspaces as any)[name];
+      let normalizedBaseUrl: string | undefined;
+      try {
+        normalizedBaseUrl = new URL(entry.baseUrl).toString();
+      } catch {
+        normalizedBaseUrl = undefined;
+      }
+      if (normalizedBaseUrl) {
+        const workspaceId = getEffectiveWorkspaceId(name, entry);
+        const profiles = await allWorkspaces(opts.configDir);
+        boundProfileForGen = profiles.find(
+          (p) => p.remote === normalizedBaseUrl && p.workspaceId === workspaceId
+        );
+      }
+    }
+    if (boundProfileForGen) {
+      try {
+        const rtOpts = { ...opts } as GlobalOptions;
+        (rtOpts as any).__secret_workspace = boundProfileForGen;
+        await generateRTNamespace(rtOpts);
+      } catch (error) {
+        log.warn(
+          `Could not pull resource types and generate TypeScript namespace: ${
+            error instanceof Error ? error.message : error
+          }`
+        );
+      }
+    } else {
+      log.info(
+        colors.gray("Skipped resource type namespace generation (no workspace bound). Run 'wmill workspace bind' then 'wmill init' to generate it.")
+      );
+    }
   }
 }
 
diff --git a/cli/src/commands/init/template.ts b/cli/src/commands/init/template.ts
index 210aae5aca..b0c83d7039 100644
--- a/cli/src/commands/init/template.ts
+++ b/cli/src/commands/init/template.ts
@@ -180,8 +180,12 @@ export const CONFIG_REFERENCE: ConfigOption[] = [
     additionalProperties: WORKSPACE_CONFIG_SCHEMA,
     section: "Workspace bindings",
     sectionNote: "Map workspace names to Windmill instances and override settings per workspace.\nThe key is a human-friendly workspace name. gitBranch and workspaceId default to the key name.",
-    templateValue: "\n  {{BRANCH}}: {}",
+    // Empty ` {}`, not a live `<name>: {}` stub: a stub has no baseUrl yet
+    // counts as a configured workspace, breaking auto-selection and making a
+    // later `workspace bind` ambiguous. The example stays commented.
+    templateValue: " {}",
     example: [
+      "  # {{BRANCH}}:",
       "{{BASEURL_LINE}}",
       "{{WORKSPACE_ID_LINE}}",
       "    # gitBranch: main                        # git branch (defaults to workspace name)",
diff --git a/cli/src/commands/pipeline/boundedCascade.ts b/cli/src/commands/pipeline/boundedCascade.ts
index 9c7edb9cea..69166726c5 100644
--- a/cli/src/commands/pipeline/boundedCascade.ts
+++ b/cli/src/commands/pipeline/boundedCascade.ts
@@ -19,6 +19,9 @@ export type BCGraph = {
     // `// partitioned <kind>` on the script (daily/hourly/weekly/monthly/dynamic).
     // Emitted by both the deployed graph endpoint and the local builder.
     partition_kind?: string;
+    // `// macros` library: non-empty on a workspace macro library (deployed
+    // graph only). Definition-only — never a runnable cascade step.
+    macros?: { name: string }[];
   }[];
   assets: { kind: string; path: string }[];
   edges: {
@@ -38,6 +41,18 @@ export type BCGraph = {
       }
     | { trigger_kind: string; runnable_kind: string; runnable_path: string }
   )[];
+  // `// data_test` ordering edges (HD-1): the referenced asset's producer must
+  // materialize before the tested script runs. Fed into the lineage DAG so a
+  // bounded/cold cascade orders the referenced dimension first. Optional — the
+  // deployed graph omits it when empty, and older local graphs never emit it.
+  test_edges?: {
+    producer_kind: string;
+    producer_path: string;
+    runnable_kind: string;
+    runnable_path: string;
+    asset_kind: string;
+    asset_path: string;
+  }[];
 };
 
 export const SCRIPT_PREFIX = "script:";
@@ -71,7 +86,12 @@ export function assetUriToNodeId(uri: string): string | undefined {
   if (!m) return undefined;
   const prefix = m[1].toLowerCase();
   const kind = prefix === "s3" ? "s3object" : prefix;
-  return `${kind}:${m[2]}`;
+  // Mirror Rust `parse_asset_syntax`: strip all leading slashes from S3 keys so a
+  // `--to s3:///exports/x` token resolves to the canonical graph node
+  // `s3object:exports/x` (default storage), same as `s3://exports/x`, and a
+  // canonical key never starts with `/`.
+  const path = kind === "s3object" ? m[2].replace(/^\/+/, "") : m[2];
+  return `${kind}:${path}`;
 }
 
 export type LineageDag = {
@@ -110,6 +130,14 @@ export function buildLineageDag(g: BCGraph): LineageDag {
     const at = t as Extract<BCGraph["triggers"][number], { trigger_kind: "asset" }>;
     addEdge(dag, assetNodeId(at.asset_kind, at.asset_path), scriptNodeId(at.runnable_path));
   }
+  // Data-test ordering edges: route through the referenced asset node so the
+  // existing producer → asset write edge extends into producer → asset → testing
+  // script (mirrors frontend boundedCascade.ts) — the tested script runs after
+  // the referenced dimension materializes.
+  for (const t of g.test_edges ?? []) {
+    if (t.runnable_kind !== "script") continue;
+    addEdge(dag, assetNodeId(t.asset_kind, t.asset_path), scriptNodeId(t.runnable_path));
+  }
   return dag;
 }
 
@@ -212,6 +240,32 @@ export function validStarts(g: BCGraph): Set<string> {
   return out;
 }
 
+/**
+ * Script node ids eligible as an EXPLICIT bounded-run start from *anywhere* in
+ * the DAG (dbt's `--select model+`): every script that can run with empty args —
+ * i.e. all scripts except non-autorun-trigger ones (kafka/mqtt/…/webhook/
+ * data_upload, which fan out per event or need caller-supplied input). Unlike
+ * `validStarts` (schedule/manual roots only), this INCLUDES mid-DAG asset
+ * subscribers and pure readers, so `--from <mid-model>` runs that node plus its
+ * transitive downstream WITHOUT re-running upstream. Roots stay a subset of this
+ * set. A non-autorun handler still qualifies once it's `--upload`-bound (handled
+ * by the caller, which unions in the bound node ids).
+ */
+export function validFromStarts(g: BCGraph): Set<string> {
+  const nonAutorun = nonAutorunTriggerScripts(g);
+  // Seed with the schedule/manual roots: `validStarts` lets a schedule identity
+  // win over a secondary non-autorun trigger (a `// on schedule` + `// on
+  // data_upload` script IS a scheduled root), so a root must stay `--from`-
+  // eligible even though it's also in `nonAutorunTriggerScripts`.
+  const out = new Set<string>(validStarts(g));
+  for (const r of g.runnables ?? []) {
+    if (r.usage_kind !== "script") continue;
+    const id = scriptNodeId(r.path);
+    if (!nonAutorun.has(id)) out.add(id);
+  }
+  return out;
+}
+
 /**
  * Script node ids that carry a trigger requiring caller-supplied input or
  * per-event fanout (kafka/mqtt/nats/postgres/sqs/gcp/email/webhook/data_upload).
diff --git a/cli/src/commands/pipeline/docs.ts b/cli/src/commands/pipeline/docs.ts
index b360c8b802..abee64cbf3 100644
--- a/cli/src/commands/pipeline/docs.ts
+++ b/cli/src/commands/pipeline/docs.ts
@@ -43,7 +43,7 @@ async function fetchDeployedGraph(
 }
 
 // Render the pipeline graph as a markdown document.
-function generatePipelineMarkdown(
+export function generatePipelineMarkdown(
   folder: string,
   graph: AssetGraph,
   datatableSchemas: any[],
@@ -73,7 +73,26 @@ function generatePipelineMarkdown(
     }
   }
 
-  const scripts = graph.runnables.filter((r) => r.usage_kind === "script").map((r) => r.path).sort();
+  // `// macros` libraries are definition-only nodes (not runnable pipeline
+  // steps), so they get their own section below and are excluded from the
+  // per-script listing + the script count.
+  const macroLibs = graph.runnables
+    .filter((r) => r.usage_kind === "script" && (r.macros?.length ?? 0) > 0)
+    .sort((a, b) => a.path.localeCompare(b.path));
+  const macroLibPaths = new Set(macroLibs.map((r) => r.path));
+  const macroConsumersByLib = new Map<string, { consumer: string; names: string[]; viaUse?: boolean }[]>();
+  for (const me of graph.macro_edges ?? []) {
+    (macroConsumersByLib.get(me.lib_path) ?? macroConsumersByLib.set(me.lib_path, []).get(me.lib_path)!).push({
+      consumer: me.consumer_path,
+      names: me.macro_names,
+      viaUse: me.via_use,
+    });
+  }
+
+  const scripts = graph.runnables
+    .filter((r) => r.usage_kind === "script" && !macroLibPaths.has(r.path))
+    .map((r) => r.path)
+    .sort();
 
   let md = `# Pipeline \`f/${folder}\`
 
@@ -85,7 +104,7 @@ produces data by reading/writing assets in its body (\`datatable://\`,
 \`ducklake://\`, \`s3://\`, \`volume://\`). The cascade runs a producer, then every
 downstream subscriber, in topological order.
 
-- **${scripts.length}** script${scripts.length === 1 ? "" : "s"} · **${graph.assets.length}** asset${graph.assets.length === 1 ? "" : "s"}
+- **${scripts.length}** script${scripts.length === 1 ? "" : "s"} · **${graph.assets.length}** asset${graph.assets.length === 1 ? "" : "s"}${macroLibs.length > 0 ? ` · **${macroLibs.length}** macro librar${macroLibs.length === 1 ? "y" : "ies"}` : ""}
 
 ## Scripts
 
@@ -107,6 +126,30 @@ downstream subscriber, in topological order.
     md += `\n`;
   }
 
+  // Macro libraries: `// macros` scripts whose macros are injected into consuming
+  // DuckDB scripts at run time. List each library's signatures and its callers so
+  // an agent discovers the reuse layer instead of re-inlining the logic.
+  if (macroLibs.length > 0) {
+    md += `## Macro libraries\n\n`;
+    md += `\`// macros\` DuckDB libraries. Their \`CREATE MACRO\` definitions are injected as\nTEMP macros into consuming scripts at run time — call a macro by name, or force the\nwhole library in with \`// use <lib-path>\` (needed for macros only reached via dynamic SQL).\n\n`;
+    for (const lib of macroLibs) {
+      md += `### \`${lib.path}\`\n\n`;
+      for (const m of lib.macros ?? []) {
+        md += `- \`${m.name}(${m.params ?? ""})\`${m.is_table ? " → TABLE" : ""}\n`;
+      }
+      const consumers = [...(macroConsumersByLib.get(lib.path) ?? [])].sort((a, b) =>
+        a.consumer.localeCompare(b.consumer),
+      );
+      if (consumers.length > 0) {
+        md += `- **Used by:**\n`;
+        for (const c of consumers) {
+          md += `  - \`${c.consumer}\` (${c.viaUse ? "via \`// use\`" : `calls ${c.names.map((n) => `\`${n}\``).join(", ")}`})\n`;
+        }
+      }
+      md += `\n`;
+    }
+  }
+
   // Datatable schemas, restricted to datatables this pipeline references.
   const referencedDatatables = new Set(
     graph.assets.filter((a) => a.kind === "datatable").map((a) => a.path.split("/")[0]),
diff --git a/cli/src/commands/pipeline/duckdbMacros.ts b/cli/src/commands/pipeline/duckdbMacros.ts
new file mode 100644
index 0000000000..be505874d7
--- /dev/null
+++ b/cli/src/commands/pipeline/duckdbMacros.ts
@@ -0,0 +1,261 @@
+// Faithful TS port of the lexical rules in
+// `backend/parsers/windmill-parser/src/duckdb_macros.rs` — keep the two in
+// lockstep. Deliberately lexical, not an AST parse: over-matching a call only
+// draws a spurious edge, never a wrong run. A macro reached only through dynamic
+// SQL (`query('…')`) is invisible to call detection here as on the server —
+// `// use <lib>` forces the whole-library edge instead.
+
+export type ParsedMacro = {
+  // Lowercased bare identifier (DuckDB identifiers are case-insensitive unquoted;
+  // qualified / quoted names are rejected, matching the backend).
+  name: string;
+  // Verbatim text inside the parameter parens (may be empty).
+  params: string;
+  isTable: boolean;
+};
+
+// Case-insensitive whole-word prefix strip (whitespace-bounded). Returns the
+// remainder with leading whitespace trimmed, or null when `s` does not start with
+// `kw` as a whole word. `kw` must be lowercase. Mirrors `strip_kw`.
+function stripKw(s: string, kw: string): string | null {
+  if (s.length < kw.length) return null;
+  if (s.slice(0, kw.length).toLowerCase() !== kw) return null;
+  const after = s.slice(kw.length);
+  if (after.length === 0 || /^\s/.test(after)) return after.replace(/^\s+/, "");
+  return null;
+}
+
+function isIdent(s: string): boolean {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(s);
+}
+
+// Split a script body into `;`-terminated statements with line comments
+// (`--`, `//`), block comments (`/* */`), and quoted spans stripped/preserved as
+// in the SQL executor. Char-wise (not byte-wise) so multi-byte text survives.
+// Mirrors `split_statements`.
+export function splitStatements(sql: string): string[] {
+  const out: string[] = [];
+  let cur = "";
+  const chars = [...sql];
+  let i = 0;
+  const n = chars.length;
+  while (i < n) {
+    const c = chars[i];
+    // line comment: `--` (SQL) or `//` (Windmill annotation prefix)
+    if (
+      (c === "-" && i + 1 < n && chars[i + 1] === "-") ||
+      (c === "/" && i + 1 < n && chars[i + 1] === "/")
+    ) {
+      while (i < n && chars[i] !== "\n") i += 1;
+      continue;
+    }
+    // block comment
+    if (c === "/" && i + 1 < n && chars[i + 1] === "*") {
+      i += 2;
+      while (i + 1 < n && !(chars[i] === "*" && chars[i + 1] === "/")) i += 1;
+      i += 2;
+      continue;
+    }
+    // single-quoted string ('' escapes an embedded quote)
+    if (c === "'") {
+      cur += c;
+      i += 1;
+      while (i < n) {
+        cur += chars[i];
+        if (chars[i] === "'") {
+          if (i + 1 < n && chars[i + 1] === "'") {
+            cur += "'";
+            i += 2;
+            continue;
+          }
+          i += 1;
+          break;
+        }
+        i += 1;
+      }
+      continue;
+    }
+    // double-quoted identifier
+    if (c === '"') {
+      cur += c;
+      i += 1;
+      while (i < n) {
+        cur += chars[i];
+        if (chars[i] === '"') {
+          i += 1;
+          break;
+        }
+        i += 1;
+      }
+      continue;
+    }
+    if (c === ";") {
+      const t = cur.trim();
+      if (t !== "") out.push(t);
+      cur = "";
+      i += 1;
+      continue;
+    }
+    cur += c;
+    i += 1;
+  }
+  const t = cur.trim();
+  if (t !== "") out.push(t);
+  return out;
+}
+
+// Parse one comment-free, `;`-less statement as a CREATE MACRO. Returns null when
+// the statement is not a well-formed macro definition (unlike the backend, which
+// distinguishes "not macro-shaped" from "malformed" to surface deploy errors —
+// the local graph is lenient and simply skips anything it can't read). Mirrors
+// `parse_create_macro` for the shape it accepts.
+export function parseCreateMacro(stmt: string): ParsedMacro | null {
+  let rest = stripKw(stmt.trim(), "create");
+  if (rest === null) return null;
+  const afterOr = stripKw(rest, "or");
+  if (afterOr !== null) {
+    const afterReplace = stripKw(afterOr, "replace");
+    if (afterReplace === null) return null; // CREATE OR <not replace>
+    rest = afterReplace;
+  }
+  const afterTemp = stripKw(rest, "temp") ?? stripKw(rest, "temporary");
+  if (afterTemp !== null) rest = afterTemp;
+  // `FUNCTION` is DuckDB's alias for `MACRO`.
+  const afterMacro = stripKw(rest, "macro") ?? stripKw(rest, "function");
+  if (afterMacro === null) return null;
+  rest = afterMacro;
+
+  const nameEndMatch = rest.match(/[\s(]/);
+  const nameEnd = nameEndMatch ? nameEndMatch.index! : rest.length;
+  const rawName = rest.slice(0, nameEnd);
+  if (rawName === "" || rawName.includes(".") || rawName.includes('"') || !isIdent(rawName)) {
+    return null;
+  }
+  const name = rawName.toLowerCase();
+
+  rest = rest.slice(nameEnd).replace(/^\s+/, "");
+  if (!rest.startsWith("(")) return null;
+  // Balanced-paren scan for the verbatim param list; skip quoted spans (a default
+  // value may contain a paren).
+  const pchars = [...rest];
+  let depth = 0;
+  let j = 0;
+  let close = -1;
+  while (j < pchars.length) {
+    const ch = pchars[j];
+    if (ch === "(") depth += 1;
+    else if (ch === ")") {
+      depth -= 1;
+      if (depth === 0) {
+        close = j;
+        break;
+      }
+    } else if (ch === "'" || ch === '"') {
+      const q = ch;
+      j += 1;
+      while (j < pchars.length && pchars[j] !== q) j += 1;
+    }
+    j += 1;
+  }
+  if (close === -1) return null; // unbalanced
+  const params = pchars.slice(1, close).join("").trim();
+
+  const afterParams = pchars.slice(close + 1).join("").replace(/^\s+/, "");
+  let body = stripKw(afterParams, "as");
+  if (body === null) return null;
+  let isTable = false;
+  const afterTable = stripKw(body, "table");
+  if (afterTable !== null) {
+    body = afterTable;
+    isTable = true;
+  }
+  const trimmedBody = body.replace(/;+\s*$/, "").trim();
+  if (trimmedBody === "") return null; // empty body
+  return { name, params, isTable };
+}
+
+// All well-formed macro definitions in a `// macros` library body, in source
+// order. Non-macro statements (setup: ATTACH/INSTALL/… ) are skipped.
+export function parseMacroLibrary(sql: string): ParsedMacro[] {
+  const out: ParsedMacro[] = [];
+  for (const stmt of splitStatements(sql)) {
+    const m = parseCreateMacro(stmt);
+    if (m) out.push(m);
+  }
+  return out;
+}
+
+// Names from `names` that `sql` calls: an identifier token immediately followed
+// by `(` (after optional whitespace), not `.`-qualified, outside strings and
+// comments. Lexical (over-matching only adds an unused edge). Mirrors
+// `detect_macro_calls`.
+export function detectMacroCalls(sql: string, names: Set<string>): Set<string> {
+  const found = new Set<string>();
+  if (names.size === 0) return found;
+  for (const stmt of splitStatements(sql)) {
+    const chars = [...stmt];
+    const n = chars.length;
+    let i = 0;
+    let prev: string | undefined = undefined;
+    while (i < n) {
+      const c = chars[i];
+      if (c === "'" || c === '"') {
+        const q = c;
+        i += 1;
+        while (i < n && chars[i] !== q) i += 1;
+        i += 1;
+        prev = q;
+        continue;
+      }
+      const isIdentStart = /[A-Za-z_]/.test(c);
+      const prevBlocks = prev !== undefined && /[.A-Za-z0-9_]/.test(prev);
+      if (isIdentStart && !prevBlocks) {
+        const start = i;
+        while (i < n && /[A-Za-z0-9_]/.test(chars[i])) i += 1;
+        const word = chars.slice(start, i).join("").toLowerCase();
+        let k = i;
+        while (k < n && /\s/.test(chars[k])) k += 1;
+        if (k < n && chars[k] === "(" && names.has(word)) found.add(word);
+        prev = chars[i - 1];
+        continue;
+      }
+      prev = c;
+      i += 1;
+    }
+  }
+  return found;
+}
+
+// Scan the LEADING comment header for the `// macros` marker and `// use <lib>`
+// annotations, independent of the wasm parser (which drops both). Faithful mirror
+// of the canonical `parse_pipeline_annotations` (asset_parser.rs): each line's
+// prefix is stripped as `//`, `--`, or `#` REGARDLESS of language (a DuckDB
+// library may legitimately head its annotations with `// macros`), scanning stops
+// at the first non-comment line, the marker must stand alone on its line, and a
+// `// use` target is a single whitespace-free token containing `/`.
+export function parseMacroAnnotations(
+  content: string,
+): { macros: boolean; useLibs: string[] } {
+  let macros = false;
+  const useLibs: string[] = [];
+  for (const raw of content.split("\n")) {
+    const line = raw.replace(/^\s+/, "");
+    if (line === "") continue;
+    let rest: string;
+    if (line.startsWith("//") || line.startsWith("--")) rest = line.slice(2);
+    else if (line.startsWith("#")) rest = line.slice(1);
+    else break; // first line of actual code ends the annotation header
+    rest = rest.replace(/^\s+/, "");
+    // marker: `macros` as the only content on the line (rejects `macros_v2`,
+    // `macros are below`)
+    if (/^macros\s*$/.test(rest)) {
+      macros = true;
+      continue;
+    }
+    // `use <lib>`: a single whitespace-free path token (must contain `/`, so
+    // prose like `use this to …` is dropped)
+    const u = rest.match(/^use\s+(\S+)\s*$/);
+    if (u && u[1].includes("/") && !useLibs.includes(u[1])) useLibs.push(u[1]);
+  }
+  return { macros, useLibs };
+}
diff --git a/cli/src/commands/pipeline/localGraph.ts b/cli/src/commands/pipeline/localGraph.ts
index 9d40a0e4b7..3c531c4aa9 100644
--- a/cli/src/commands/pipeline/localGraph.ts
+++ b/cli/src/commands/pipeline/localGraph.ts
@@ -15,9 +15,16 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import process from "node:process";
 import { loadParser } from "../../utils/metadata.ts";
+import * as log from "../../core/log.ts";
 import { exts, removeExtensionToPath } from "../script/script.ts";
 import { inferContentTypeFromFilePath } from "../../utils/script_common.ts";
 import { getWmillYamlPath } from "../../core/conf.ts";
+import {
+  detectMacroCalls,
+  parseMacroAnnotations,
+  parseMacroLibrary,
+  type ParsedMacro,
+} from "./duckdbMacros.ts";
 
 // Resolve the workspace root (the directory containing wmill.yaml) for reading
 // local files, falling back to the current directory.
@@ -44,9 +51,18 @@ export type GraphRunnable = {
   column_lineage?: unknown[];
   // `// materialize <asset>` target + strategy — the script's declared output,
   // so the UI anchors column lineage / the materialize badge to it (the producer
-  // write-edge is emitted separately).
+  // write-edge is emitted separately). `scd2` also identifies the producer of a
+  // `<dim>_current` view for the editor's schema-contract fallback.
   materialize_target?: { kind: string; path: string };
-  materialize_strategy?: "replace" | "append" | "merge";
+  materialize_strategy?: "replace" | "append" | "merge" | "scd2";
+  // `on_schema_change=ignore` — producer's opt-out from downstream
+  // schema-contract warnings; only present when set (default `warn` is absent),
+  // mirroring the deployed graph node.
+  materialize_on_schema_change?: string;
+  // `// macros` library: the macros it defines. Derived locally by
+  // `buildMacroEdges` (the wasm asset parser emits neither the marker nor the
+  // registry). Non-empty ⇒ definition-only node.
+  macros?: { name: string; params?: string; is_table?: boolean }[];
 };
 export type GraphEdge = {
   runnable_kind: string;
@@ -55,6 +71,23 @@ export type GraphEdge = {
   asset_path: string;
   access_type?: "r" | "w" | "rw";
 };
+// Ordering-only "must-run-after" edge (HD-1): a `// data_test relationships`
+// (or, best-effort, a custom `// data_test <script>` whose body reads an
+// in-pipeline asset) needs the referenced asset's producer to materialize before
+// the tested script runs — a dependency otherwise absent from the DAG, so a cold
+// cascade could run the tested script first and hard-fail. Synthesized locally
+// from the parsed `data_tests` + write edges; mirrors the deployed graph's
+// `test_edges` (backend `asset_graph`) so `--local` orders a cold cascade the
+// same way. Only emitted when the referenced asset has an in-pipeline producer;
+// an external table (no producer) adds no edge. NOT a data-consumption edge.
+export type GraphTestEdge = {
+  producer_kind: string;
+  producer_path: string;
+  runnable_kind: string;
+  runnable_path: string;
+  asset_kind: string;
+  asset_path: string;
+};
 export type GraphTrigger =
   | {
       trigger_kind: "asset";
@@ -72,9 +105,25 @@ export type GraphTrigger =
     };
 export type AssetGraph = {
   runnables: GraphRunnable[];
-  assets: { kind: string; path: string }[];
+  // `derived_from` is the base `<dim>` path when this node is the SCD2
+  // `<dim>_current` companion view of a managed `// materialize … history`
+  // producer — lets the canvas mark it as a derived "current view". Absent
+  // otherwise. Lockstep with backend `GraphAssetNode`.
+  assets: { kind: string; path: string; derived_from?: string }[];
   edges: GraphEdge[];
   triggers: GraphTrigger[];
+  // ƒ edges from a `// macros` library to the scripts calling its macros
+  // (present on both the deployed graph and the locally-derived one).
+  macro_edges?: {
+    lib_path: string;
+    consumer_path: string;
+    macro_names: string[];
+    via_use?: boolean;
+  }[];
+  // `// data_test` ordering edges (HD-1); present on both the deployed graph and
+  // this local one. Absent when empty (matches the deployed graph's
+  // `skip_serializing_if = Vec::is_empty`).
+  test_edges?: GraphTestEdge[];
 };
 
 export type LocalScript = {
@@ -90,7 +139,25 @@ export type LocalScript = {
 // `ParseAssetsOutput`). `triggers` is internally tagged on `kind`
 // (`#[serde(tag = "kind", rename_all = "lowercase")]`): asset triggers carry
 // `asset_kind` + `path`; native triggers are bare `{ kind }`.
-type ParseAssetsRaw = {
+// One parsed `// data_test` entry (serialized Rust `DataTest`, tagged on `type`).
+// A proper discriminated union over the five built-ins so a `dt.type` switch
+// narrows; only `relationships` / `custom` carry a cross-asset ref that the
+// local test-edge synthesis reads. Kept structurally identical to the wasm
+// output and the deployed graph's `data_tests`.
+export type ParsedDataTest =
+  | { type: "unique"; column: string }
+  | { type: "not_null"; column: string }
+  | { type: "accepted_values"; column: string; values: string[] }
+  | {
+      type: "relationships";
+      column: string;
+      to_kind: string;
+      to_path: string;
+      to_column: string;
+    }
+  | { type: "custom"; path: string };
+
+export type ParseAssetsRaw = {
   assets?: {
     kind: string;
     path: string;
@@ -110,6 +177,9 @@ type ParseAssetsRaw = {
     manual?: boolean;
     append?: boolean;
     unique_key?: string;
+    scd2?: boolean;
+    // "ignore" when set; the default `warn` is skipped in serialization.
+    on_schema_change?: string;
   };
   // `// tag <worker-tag>` — the worker tag the deployed pipeline routes to.
   tag?: string;
@@ -117,7 +187,7 @@ type ParseAssetsRaw = {
   partition?: { kind: string };
   freshness?: { duration: string };
   retry?: { count: number; delay?: string };
-  data_tests?: unknown[];
+  data_tests?: ParsedDataTest[];
   column_lineage?: unknown[];
 };
 
@@ -229,7 +299,13 @@ function fallbackParse(content: string, language: string): ParseAssetsRaw {
     if (uri) {
       const prefix = uri[1].toLowerCase();
       const kind = prefix === "s3" ? "s3object" : prefix;
-      out.triggers!.push({ kind: "asset", asset_kind: kind, path: uri[2] });
+      // Mirror Rust `parse_asset_syntax`: strip all leading slashes from S3 keys
+      // so `s3:///key` (default storage) and `s3://key` / DuckDB canonicalize
+      // to the same node id (and a canonical key never starts with `/`) —
+      // otherwise a go/bash fallback consumer's `// on s3:///x` would not
+      // connect to a wasm-inferred `x` producer.
+      const path = kind === "s3object" ? uri[2].replace(/^\/+/, "") : uri[2];
+      out.triggers!.push({ kind: "asset", asset_kind: kind, path });
     } else if (NATIVE_KINDS.has(firstTok) && rest === firstTok) {
       // A native marker (`// on data_upload`) must stand alone: the canonical
       // parser rejects a marker line with trailing content (`// on data_upload
@@ -312,10 +388,11 @@ function parseVolumeAnnotations(
 }
 
 // Infer a single script's assets + pipeline annotations. Returns the raw
-// `ParseAssetsOutput` (incl. `materialize`, which the wasm asset parser emits as
-// of windmill-parser-wasm-asset 1.740.0 — kept in lockstep with the frontend's
-// pin so the local graph mirrors the deployed one), plus `volume:` annotation
-// assets the wasm doesn't surface (merged in below, like the frontend/backend).
+// `ParseAssetsOutput` (incl. `materialize` with its `scd2` flag, which the wasm
+// asset parser emits as of windmill-parser-wasm-asset 1.749.0 — kept in lockstep
+// with the frontend's pin so the local graph mirrors the deployed one), plus
+// `volume:` annotation assets the wasm doesn't surface (merged in below, like
+// the frontend/backend).
 // wasm parse errors degrade to the annotation fallback so a syntactically-broken
 // script still shows as a pipeline node if it's annotated.
 export async function inferScriptAssets(
@@ -331,6 +408,11 @@ export async function inferScriptAssets(
   return out;
 }
 
+// Warn once when the wasm asset parser can't load: the annotation-only
+// fallback silently drops all inferred read/write edges, so a packaging or
+// install problem would otherwise masquerade as a parsing limitation.
+let warnedAssetParserUnavailable = false;
+
 async function inferScriptAssetsBody(
   content: string,
   language: string,
@@ -341,7 +423,15 @@ async function inferScriptAssetsBody(
   try {
     const mod = await loadParser(ASSET_WASM_PKG);
     raw = mod[fn](content) as string;
-  } catch {
+  } catch (e) {
+    if (!warnedAssetParserUnavailable) {
+      warnedAssetParserUnavailable = true;
+      log.warnStderr(
+        `warning: ${ASSET_WASM_PKG} failed to load (${
+          e instanceof Error ? e.message : e
+        }) — falling back to annotation-only parsing; inferred read/write edges (materialize targets, COPY TO, writeS3File) will be missing from the local graph`,
+      );
+    }
     return fallbackParse(content, language);
   }
   if (raw.startsWith("err:")) return fallbackParse(content, language);
@@ -413,31 +503,82 @@ export async function buildLocalPipelineGraph(args: {
   const folderDir = path.join(args.root, "f", folderClean);
   const all = await collectScripts(folderDir, args.root, args.defaultTs);
 
+  // `// macros` DuckDB libraries across the whole workspace (a pipeline may use a
+  // shared library outside its folder).
+  const libMacros = collectMacroLibraries(args.root);
+
   const runnables: GraphRunnable[] = [];
   const edges: GraphEdge[] = [];
   const triggers: GraphTrigger[] = [];
-  const assetSet = new Map<string, { kind: string; path: string }>();
+  const assetSet = new Map<
+    string,
+    { kind: string; path: string; derived_from?: string }
+  >();
+  // `<kind>:<current-path>` → base `<dim>` path, for scd2 `_current` companion
+  // views. Applied to the final asset nodes so a consumer's `// on …_current`
+  // trigger (processed after the producer) can't clobber the derived marker.
+  const derivedFromByKey = new Map<string, string>();
   const pipelineScripts: LocalScript[] = [];
+  // For HD-1 test edges: a pipeline member's parsed `// data_test`s, and the
+  // assets each script READS (any script, so a custom test resolves against a
+  // non-member test script's reads — best-effort, mirroring the backend, which
+  // resolves custom tests against every deployed runnable's asset usages).
+  const dataTestsByPath = new Map<string, ParsedDataTest[]>();
+  const readsByRunnable = new Map<string, { kind: string; path: string }[]>();
 
   for (const s of all) {
     const out = await inferScriptAssets(s.content, s.language);
+    const reads = (out.assets ?? [])
+      .filter(
+        (a) =>
+          a.access_type == null ||
+          a.access_type === "r" ||
+          a.access_type === "rw",
+      )
+      .map((a) => ({ kind: a.kind, path: a.path }));
+    if (reads.length > 0) readsByRunnable.set(s.path, reads);
+    // A `// macros` library is a pipeline-member node carrying its macro
+    // signatures — whether or not any consumer uses it — matching the deployed
+    // graph, which marks every macro library `auto_kind='pipeline'`. It is
+    // definition-only (no assets/triggers, never run), so we add just the node;
+    // it is NOT a previewable script (excluded from `pipelineScripts`).
+    const macroLibDefs = libMacros.get(s.path);
+    if (macroLibDefs) {
+      runnables.push({
+        path: s.path,
+        usage_kind: "script",
+        in_pipeline: true,
+        ...(out.tag ? { tag: out.tag } : {}),
+        macros: macroLibDefs.map((m) => ({
+          name: m.name,
+          params: m.params,
+          is_table: m.isTable,
+        })),
+      });
+      continue;
+    }
     if (!out.in_pipeline) continue; // not a pipeline member
+    if (out.data_tests && out.data_tests.length > 0) {
+      dataTestsByPath.set(s.path, out.data_tests);
+    }
     const retry = normalizeRetry(out.retry);
     const nativeTriggers = recoverHeaderNativeTriggers(s.content, s.language);
     // Carry the parsed `// tag` so previews route to the same worker the
     // deployed pipeline would (both `pipeline run --local` and `/pipeline_dev`).
     pipelineScripts.push(out.tag ? { ...s, tag: out.tag } : s);
     const mat = out.materialize;
-    // Managed-materialize write strategy, derived like the deployed graph
-    // (append → append; key=<col> → merge; else replace). Manual mode has no
-    // managed strategy.
+    // Managed-materialize write strategy, derived like the deployed graph —
+    // precedence mirrors the runtime: scd2 (`history`) > append > merge
+    // (key=<col>) > replace. Manual mode has no managed strategy.
     const materialize_strategy =
       mat && !mat.manual
-        ? mat.append
-          ? "append"
-          : mat.unique_key
-            ? "merge"
-            : "replace"
+        ? mat.scd2
+          ? "scd2"
+          : mat.append
+            ? "append"
+            : mat.unique_key
+              ? "merge"
+              : "replace"
         : undefined;
     runnables.push({
       path: s.path,
@@ -453,6 +594,9 @@ export async function buildLocalPipelineGraph(args: {
         : {}),
       ...(mat ? { materialize_target: { kind: mat.target_kind, path: mat.target_path } } : {}),
       ...(materialize_strategy ? { materialize_strategy } : {}),
+      ...(mat?.on_schema_change === "ignore"
+        ? { materialize_on_schema_change: "ignore" }
+        : {}),
     });
 
     for (const a of out.assets ?? []) {
@@ -469,27 +613,44 @@ export async function buildLocalPipelineGraph(args: {
     // SQL body, so body-inference misses it. Translate the parsed materialize
     // target into the producer's write edge here (mirrors frontend
     // resolveGraph.ts) so the materialized asset connects to its `// on`
-    // consumers; dedup against any body write.
+    // consumers; dedup against any body write. A managed scd2 materialize also
+    // produces the `<dim>_current` companion view — register it as a second
+    // write (mirrors the deploy path) so a consumer reading only the view links
+    // back to this producer instead of orphaning.
     if (mat) {
-      assetSet.set(`${mat.target_kind}:${mat.target_path}`, {
-        kind: mat.target_kind,
-        path: mat.target_path,
-      });
-      const hasWrite = edges.some(
-        (e) =>
-          e.runnable_path === s.path &&
-          e.asset_kind === mat.target_kind &&
-          e.asset_path === mat.target_path &&
-          (e.access_type === "w" || e.access_type === "rw"),
-      );
-      if (!hasWrite) {
-        edges.push({
-          runnable_kind: "script",
-          runnable_path: s.path,
-          asset_kind: mat.target_kind,
-          asset_path: mat.target_path,
-          access_type: "w",
+      const matWrites: { path: string; derived_from?: string }[] = [
+        { path: mat.target_path },
+      ];
+      if (mat.scd2 && !mat.manual) {
+        const currentPath = `${mat.target_path}_current`;
+        matWrites.push({ path: currentPath, derived_from: mat.target_path });
+        derivedFromByKey.set(
+          `${mat.target_kind}:${currentPath}`,
+          mat.target_path,
+        );
+      }
+      for (const w of matWrites) {
+        assetSet.set(`${mat.target_kind}:${w.path}`, {
+          kind: mat.target_kind,
+          path: w.path,
+          ...(w.derived_from ? { derived_from: w.derived_from } : {}),
         });
+        const hasWrite = edges.some(
+          (e) =>
+            e.runnable_path === s.path &&
+            e.asset_kind === mat.target_kind &&
+            e.asset_path === w.path &&
+            (e.access_type === "w" || e.access_type === "rw"),
+        );
+        if (!hasWrite) {
+          edges.push({
+            runnable_kind: "script",
+            runnable_path: s.path,
+            asset_kind: mat.target_kind,
+            asset_path: w.path,
+            access_type: "w",
+          });
+        }
       }
     }
     const existingNativeTriggers = new Set<string>();
@@ -526,13 +687,249 @@ export async function buildLocalPipelineGraph(args: {
     }
   }
 
+  const macroEdges = buildMacroEdges(all, libMacros, runnables);
+
+  const testEdges = buildTestEdges(dataTestsByPath, readsByRunnable, edges);
+
+  const assets = [...assetSet.entries()].map(([key, a]) => {
+    const derived_from = a.derived_from ?? derivedFromByKey.get(key);
+    return derived_from ? { ...a, derived_from } : a;
+  });
+
   return {
     graph: {
       runnables,
-      assets: [...assetSet.values()],
+      assets,
       edges,
       triggers,
+      ...(macroEdges.length > 0 ? { macro_edges: macroEdges } : {}),
+      ...(testEdges.length > 0 ? { test_edges: testEdges } : {}),
     },
     scripts: pipelineScripts,
   };
 }
+
+// Synthesize HD-1 ordering edges from parsed `// data_test`s. Ports backend
+// `asset_graph` (windmill-api-assets): resolve each test's referenced asset(s)
+// to their in-pipeline producer(s) via the write edges, and add an ordering-only
+// producer → tested-script edge. A `relationships` test references its `to_path`
+// asset directly; a `custom` test references the tested/other script's parsed
+// reads (best-effort). Self-edges (a script testing its own output) and assets
+// with no in-pipeline producer are dropped, exactly like the backend.
+function buildTestEdges(
+  dataTestsByPath: Map<string, ParsedDataTest[]>,
+  readsByRunnable: Map<string, { kind: string; path: string }[]>,
+  edges: GraphEdge[],
+): GraphTestEdge[] {
+  const producersByAsset = new Map<string, { kind: string; path: string }[]>();
+  for (const e of edges) {
+    if (e.access_type !== "w" && e.access_type !== "rw") continue;
+    // `\u0000` as the (kind, path) separator: it can't occur in an asset path,
+    // so no packed key can collide.
+    const key = `${e.asset_kind}\u0000${e.asset_path}`;
+    (producersByAsset.get(key) ?? producersByAsset.set(key, []).get(key)!).push({
+      kind: e.runnable_kind,
+      path: e.runnable_path,
+    });
+  }
+
+  const out: GraphTestEdge[] = [];
+  // Dedup on (producer, tested_script, asset) so repeated tests / producers
+  // referencing the same asset yield one edge (mirrors the backend's set).
+  const seen = new Set<string>();
+  for (const [memberPath, dts] of dataTestsByPath) {
+    for (const dt of dts) {
+      let referenced: { kind: string; path: string }[] = [];
+      if (dt.type === "relationships") {
+        referenced = [{ kind: dt.to_kind, path: dt.to_path }];
+      } else if (dt.type === "custom") {
+        // The custom test script's own parsed reads. Reading the member's OWN
+        // output resolves to the member as producer and is dropped below.
+        referenced = readsByRunnable.get(dt.path) ?? [];
+      }
+      for (const ref of referenced) {
+        const producers = producersByAsset.get(`${ref.kind}\u0000${ref.path}`);
+        if (!producers) continue; // external table (no producer) ⇒ no edge
+        for (const p of producers) {
+          // Skip a self-edge: the tested script produces the asset it tests.
+          if (p.kind === "script" && p.path === memberPath) continue;
+          const key = [p.path, memberPath, ref.kind, ref.path].join("\u0000");
+          if (seen.has(key)) continue;
+          seen.add(key);
+          out.push({
+            producer_kind: p.kind,
+            producer_path: p.path,
+            runnable_kind: "script",
+            runnable_path: memberPath,
+            asset_kind: ref.kind,
+            asset_path: ref.path,
+          });
+        }
+      }
+    }
+  }
+  // Deterministic order for stable `--json` output (the deployed graph iterates
+  // an unordered map; the local one sorts so snapshots don't churn).
+  out.sort(
+    (a, b) =>
+      a.producer_path.localeCompare(b.producer_path) ||
+      a.runnable_path.localeCompare(b.runnable_path) ||
+      a.asset_kind.localeCompare(b.asset_kind) ||
+      a.asset_path.localeCompare(b.asset_path),
+  );
+  return out;
+}
+
+// Every `// macros` DuckDB library in the workspace, keyed by its windmill path,
+// mapped to its parsed macro definitions. Walks the whole `f/` tree (not just the
+// pipeline folder) because the deployed graph resolves consumers against the
+// workspace-wide macro registry — a pipeline may `// use` / call a shared library
+// living outside its own folder. Only `*.duckdb.sql` files are read (macros are
+// DuckDB-only), so the extra walk stays cheap.
+function collectMacroLibraries(root: string): Map<string, ParsedMacro[]> {
+  const out = new Map<string, ParsedMacro[]>();
+  const walk = (dir: string) => {
+    let entries: fs.Dirent[];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (e.name.startsWith(".") || e.name === "node_modules") continue;
+      const abs = path.join(dir, e.name);
+      if (e.isDirectory()) {
+        walk(abs);
+        continue;
+      }
+      if (!e.isFile() || !e.name.endsWith(".duckdb.sql")) continue;
+      let content: string;
+      try {
+        content = fs.readFileSync(abs, "utf-8");
+      } catch {
+        continue;
+      }
+      if (!parseMacroAnnotations(content).macros) continue;
+      const relFromRoot = path.relative(root, abs).replaceAll("\\", "/");
+      out.set(removeExtensionToPath(relFromRoot), parseMacroLibrary(content));
+    }
+  };
+  walk(path.join(root, "f"));
+  return out;
+}
+
+// Derive lib→consumer edges (lexical calls + `// use`). In-folder libraries are
+// already member nodes; this adds any out-of-folder provider referenced by an
+// in-folder consumer. Mirrors the deployed `asset_graph`: libraries resolve
+// workspace-wide, consumers are folder-scoped.
+function buildMacroEdges(
+  all: LocalScript[],
+  libMacros: Map<string, ParsedMacro[]>,
+  runnables: GraphRunnable[],
+): NonNullable<AssetGraph["macro_edges"]> {
+  if (libMacros.size === 0) return [];
+  const useLibsByScript = new Map<string, string[]>();
+  for (const s of all) {
+    if (s.language !== "duckdb") continue;
+    const { useLibs } = parseMacroAnnotations(s.content);
+    if (useLibs.length > 0) useLibsByScript.set(s.path, useLibs);
+  }
+
+  // Macro name → providing library. Names are workspace-unique (the deploy path
+  // enforces this); on a local collision, last-writer-wins, harmlessly.
+  const providerByName = new Map<string, string>();
+  for (const [lib, macros] of libMacros) {
+    for (const m of macros) providerByName.set(m.name, lib);
+  }
+  const allMacroNames = new Set(providerByName.keys());
+
+  // Aggregate per (lib, consumer): the set of called macro names and whether the
+  // edge came (also) from a whole-library `// use`. Consumers are folder-scoped
+  // (`all` is this folder's scripts).
+  const pipelinePaths = new Set(runnables.map((r) => r.path));
+  type EdgeAgg = { names: Set<string>; viaUse: boolean };
+  // lib_path → consumer_path → aggregate. Nested (not a packed single-string key)
+  // so no separator can ever collide with a path.
+  const edgeMap = new Map<string, Map<string, EdgeAgg>>();
+  const aggFor = (lib: string, consumer: string): EdgeAgg => {
+    let byConsumer = edgeMap.get(lib);
+    if (!byConsumer) {
+      byConsumer = new Map();
+      edgeMap.set(lib, byConsumer);
+    }
+    let agg = byConsumer.get(consumer);
+    if (!agg) {
+      agg = { names: new Set(), viaUse: false };
+      byConsumer.set(consumer, agg);
+    }
+    return agg;
+  };
+  for (const s of all) {
+    if (s.language !== "duckdb") continue;
+    // Lexical call edges: the deploy path records `macro_usage` for EVERY DuckDB
+    // script in the folder (not only pipeline members) — including a macro
+    // library that calls another library's macros — so a lib→lib edge and its
+    // upstream provider node survive. Mirror that: any folder DuckDB script is a
+    // candidate consumer here.
+    for (const name of detectMacroCalls(s.content, allMacroNames)) {
+      const lib = providerByName.get(name)!;
+      if (lib === s.path) continue; // a library calling its own macro is not an edge
+      aggFor(lib, s.path).names.add(name);
+    }
+    // `// use` whole-library edges: the deployed graph re-parses these only from
+    // pipeline members (`annotations_by_path`), so scope them the same way.
+    if (!pipelinePaths.has(s.path)) continue;
+    for (const lib of useLibsByScript.get(s.path) ?? []) {
+      const macros = libMacros.get(lib);
+      // An out-of-tree / unknown `// use` target can't be resolved locally.
+      if (!macros || lib === s.path) continue;
+      const agg = aggFor(lib, s.path);
+      agg.viaUse = true;
+      for (const m of macros) agg.names.add(m.name);
+    }
+  }
+
+  const edges = [...edgeMap.entries()]
+    .flatMap(([lib_path, byConsumer]) =>
+      [...byConsumer.entries()].map(([consumer_path, agg]) => ({
+        lib_path,
+        consumer_path,
+        macro_names: [...agg.names].sort(),
+        // `via_use` is always present (the deployed `MacroEdge` serializes it
+        // unconditionally) so `--json` matches byte-for-byte.
+        via_use: agg.viaUse,
+      })),
+    )
+    .sort((a, b) =>
+      a.lib_path.localeCompare(b.lib_path) ||
+      a.consumer_path.localeCompare(b.consumer_path),
+    );
+
+  // In-folder libraries are already member nodes (added above with `in_pipeline`
+  // + macros). An OUT-OF-folder library referenced by an in-folder consumer is
+  // added here as a non-member provider node (no `in_pipeline`), matching the
+  // deployed graph, which folder-scopes membership but pulls the out-of-folder
+  // provider in as the edge's endpoint.
+  const libPaths = new Set<string>(edges.map((e) => e.lib_path));
+  for (const lib of libPaths) {
+    if (runnables.some((r) => r.path === lib)) continue;
+    const macros = (libMacros.get(lib) ?? []).map((m) => ({
+      name: m.name,
+      params: m.params,
+      is_table: m.isTable,
+    }));
+    runnables.push({ path: lib, usage_kind: "script", macros });
+  }
+  // Force every edge's CONSUMER endpoint into the node set too, like the deployed
+  // builder, so no edge dangles at a missing runnable. Members and libraries are
+  // already nodes; only a non-member DuckDB helper (calls a macro but isn't
+  // `// pipeline` and isn't itself a library) needs a bare node here.
+  for (const consumer of new Set(edges.map((e) => e.consumer_path))) {
+    if (!runnables.some((r) => r.path === consumer)) {
+      runnables.push({ path: consumer, usage_kind: "script" });
+    }
+  }
+  runnables.sort((a, b) => a.path.localeCompare(b.path));
+
+  return edges;
+}
diff --git a/cli/src/commands/pipeline/pipeline.ts b/cli/src/commands/pipeline/pipeline.ts
index 1d11799956..0738283fba 100644
--- a/cli/src/commands/pipeline/pipeline.ts
+++ b/cli/src/commands/pipeline/pipeline.ts
@@ -20,6 +20,7 @@ import {
   scriptsOf,
   topoOrder,
   validStarts,
+  validFromStarts,
 } from "./boundedCascade.ts";
 import {
   type AssetGraph,
@@ -302,6 +303,26 @@ async function renderGraph(
     return out.length > 0 ? " " + out.join(" ") : "";
   }
 
+  // `// macros` libraries: badge the node with the macros it defines and list
+  // its consumers as ƒ edges. Populated on both the deployed graph and the local
+  // graph (localGraph.ts derives `macros`/`macro_edges` from the working tree,
+  // since the wasm asset parser emits neither).
+  const macrosByLib = new Map(
+    graph.runnables
+      .filter((r) => (r.macros?.length ?? 0) > 0)
+      .map((r) => [r.path, r.macros!]),
+  );
+  const macroConsumersByLib = new Map<
+    string,
+    { consumer: string; names: string[] }[]
+  >();
+  for (const me of graph.macro_edges ?? []) {
+    pushTo(macroConsumersByLib, me.lib_path, {
+      consumer: me.consumer_path,
+      names: me.macro_names,
+    });
+  }
+
   const printed = new Set<string>();
   const lines: string[] = [];
 
@@ -317,8 +338,22 @@ async function renderGraph(
       return;
     }
     printed.add(script);
-    lines.push(`${prefix}${colors.bold(shortName(script))}${triggerBadges(script)}${alsoOn}`);
+    const libMacros = macrosByLib.get(script);
+    const macroBadge = libMacros
+      ? " " +
+        colors.magenta(`[ƒ macros: ${libMacros.map((m) => m.name).join(", ")}]`)
+      : "";
+    lines.push(`${prefix}${colors.bold(shortName(script))}${macroBadge}${triggerBadges(script)}${alsoOn}`);
     const childPrefix = prefix.replace(/├─ $/, "│  ").replace(/└─ $/, "   ");
+    const macroConsumers = [...(macroConsumersByLib.get(script) ?? [])].sort(
+      (a, b) => a.consumer.localeCompare(b.consumer),
+    );
+    macroConsumers.forEach(({ consumer, names }, i) => {
+      const branch = i === macroConsumers.length - 1 ? "└─ƒ " : "├─ƒ ";
+      lines.push(
+        `${childPrefix}${branch}${shortName(consumer)} ${colors.dim(`(uses ${names.join(", ")})`)}`,
+      );
+    });
     const writes = [...(writesByScript.get(script) ?? [])].sort();
     writes.forEach((uri, i) => {
       const lastAsset = i === writes.length - 1;
@@ -368,7 +403,10 @@ async function renderGraph(
 
 // Poll a launched job to a terminal state. Modest fixed cadence; capped so a
 // wedged job can't hang the CLI forever.
-async function waitJob(workspace: string, id: string): Promise<boolean> {
+async function waitJob(
+  workspace: string,
+  id: string,
+): Promise<{ ok: boolean; result?: unknown }> {
   const MAX_RETRIES = 6000; // ~10min at 100ms
   for (let i = 0; i < MAX_RETRIES; i++) {
     try {
@@ -380,7 +418,7 @@ async function waitJob(workspace: string, id: string): Promise<boolean> {
       // A completed job without an explicit `success: true` is a failure
       // (mirrors the frontend `waitJobTerminal`): the cascade only advances on
       // a confirmed success.
-      if (r.completed) return r.success === true;
+      if (r.completed) return { ok: r.success === true, result: r.result };
     } catch {
       // transient — retry
     }
@@ -389,13 +427,35 @@ async function waitJob(workspace: string, id: string): Promise<boolean> {
   throw new Error(`Timed out waiting for job ${id}`);
 }
 
-// Bounded-cascade run: start at a schedule / manual root, fan downstream, but
-// stop at the `--to` end node(s). Scripts run in topological order; each is
-// launched with `_wmill_skip_asset_dispatch` so the CLI owns the whole closure
-// (the backend dispatcher never double-fires the deployed part). With no
-// `--to`, runs the full read-aware downstream of `--from` (every descendant in
-// the lineage DAG, pure readers included — broader than the canvas cascade,
-// which dispatches subscribers only).
+// Render a failed job's `{error: {name, message}}` result for the terminal, so
+// the user sees WHY the cascade stopped without opening the UI. Result shapes
+// vary (structured data-test payloads, plain strings), so fall back to raw
+// JSON when the canonical error shape is absent.
+function formatJobFailure(result: unknown): string | undefined {
+  if (result == null) return undefined;
+  const err = (result as any)?.error;
+  if (err && typeof err === "object") {
+    const name = typeof err.name === "string" ? err.name : undefined;
+    const message = typeof err.message === "string" ? err.message : undefined;
+    if (message) return name ? `${name}: ${message}` : message;
+  }
+  if (typeof result === "string") return result;
+  try {
+    return JSON.stringify(result, null, 2);
+  } catch {
+    return undefined;
+  }
+}
+
+// Bounded-cascade run: start at `--from` — a schedule/manual root OR any mid-DAG
+// model (asset subscriber / pure reader) — fan downstream, but stop at the
+// `--to` end node(s). A mid-DAG start runs that node plus its transitive
+// downstream and never re-runs upstream (dbt `--select model+`). Scripts run in
+// topological order; each is launched with `_wmill_skip_asset_dispatch` so the
+// CLI owns the whole closure (the backend dispatcher never double-fires the
+// deployed part). With no `--to`, runs the full read-aware downstream of
+// `--from` (every descendant in the lineage DAG, pure readers included — broader
+// than the canvas cascade, which dispatches subscribers only).
 // Resolve one `--upload` binding to the run-arg it injects: pick the target
 // S3Object parameter (explicit `:param`, else the script's sole S3Object arg)
 // and turn the source into an object key — an `s3://` source is used as-is, a
@@ -531,19 +591,25 @@ async function run(
     // Resolve relative imports from local (not-yet-deployed) content so a script
     // that imports a sibling workspace lib previews against local edits. Same
     // trick as `wmill dev` / `wmill app dev`; degrades to undefined gracefully.
-    try {
-      const codebases = await listSyncCodebases(merged);
-      const { buildPreviewTempScriptRefs } = await import(
-        "../generate-metadata/generate-metadata.ts"
-      );
-      tempScriptRefs = await buildPreviewTempScriptRefs(
-        workspace,
-        merged,
-        codebases,
-        { kind: "all" },
-      );
-    } catch {
-      // best-effort: relative imports fall back to deployed versions
+    // Skipped for `--dry-run`: it locks/uploads scripts as a side effect (it
+    // regenerates `*.script.yaml` / `*.script.lock` / `wmill-lock.yaml`), and a
+    // plan preview must stay READ-ONLY — the refs are only consumed when a
+    // preview job actually runs below, which dry-run never reaches.
+    if (!opts.dryRun) {
+      try {
+        const codebases = await listSyncCodebases(merged);
+        const { buildPreviewTempScriptRefs } = await import(
+          "../generate-metadata/generate-metadata.ts"
+        );
+        tempScriptRefs = await buildPreviewTempScriptRefs(
+          workspace,
+          merged,
+          codebases,
+          { kind: "all" },
+        );
+      } catch {
+        // best-effort: relative imports fall back to deployed versions
+      }
     }
   } else {
     graph = await apiGet<BCGraph>(
@@ -603,9 +669,50 @@ async function run(
     merged[b.param] = b.value;
   }
 
-  // Resolve the start: explicit --from (must be a valid start) or the folder's
-  // sole valid start. `--upload`-bound scripts join the valid starts.
-  const starts = new Set([...validStarts(graph), ...boundNodeIds]);
+  // `// macros` libraries are definition-only: their macros are injected into
+  // consuming DuckDB scripts at run time, so "running" one is a no-op preview.
+  // They are excluded from starts and from every selection below (they'd
+  // otherwise read as manual roots, since nothing triggers them).
+  const macroLibPaths = new Set(
+    graph.runnables
+      .filter((r) => r.usage_kind === "script" && (r.macros?.length ?? 0) > 0)
+      .map((r) => r.path),
+  );
+  // Non-runnable graph nodes: the macro libraries above, plus (under `--local`)
+  // any script node with no local file. The local graph surfaces macro-consumer
+  // nodes for lineage display — a DuckDB script that calls a macro but isn't a
+  // `// pipeline` member (so has no previewable content). They must never enter
+  // the run: as a manual root they'd be scheduled, and a preview would fail with
+  // no local content to send.
+  const notRunnablePaths = new Set<string>(macroLibPaths);
+  if (opts.local && localScripts) {
+    for (const r of graph.runnables) {
+      if (r.usage_kind === "script" && !localScripts.has(r.path)) {
+        notRunnablePaths.add(r.path);
+      }
+    }
+  }
+
+  // Resolve the start. Two eligibility sets:
+  //   `starts`       — schedule/manual roots (+ `--upload`-bound handlers). The
+  //                    fan-in candidates for an IMPLICIT start (`runAll`, or the
+  //                    folder's sole root).
+  //   `fromEligible` — every autorun-able script, roots AND mid-DAG models
+  //                    (asset subscribers, pure readers). An EXPLICIT `--from`
+  //                    may name any of these: `--from <mid-model>` runs that node
+  //                    plus its transitive downstream, without re-running upstream
+  //                    (dbt `--select model+`). Non-autorun handlers stay out
+  //                    unless `--upload`-bound.
+  const starts = new Set(
+    [...validStarts(graph), ...boundNodeIds].filter(
+      (id) => !notRunnablePaths.has(scriptPathOf(id)),
+    ),
+  );
+  const fromEligible = new Set(
+    [...validFromStarts(graph), ...boundNodeIds].filter(
+      (id) => !notRunnablePaths.has(scriptPathOf(id)),
+    ),
+  );
   // `runAll` = no `--from` on a multi-root pipeline (fan-in): run the whole
   // pipeline in topological order rather than forcing a single start, the way
   // `dbt run` (no `--select`) runs the entire project. `--to` still needs an
@@ -627,9 +734,27 @@ async function run(
       }
       throw new Error(`--from '${opts.from}' matched no script in f/${f}.`);
     }
-    if (!starts.has(resolved)) {
+    if (macroLibPaths.has(scriptPathOf(resolved))) {
       throw new Error(
-        `--from '${opts.from}' is not a valid bounded-run start. Starts must be schedule-triggered or manual roots; row-backed event triggers (kafka/mqtt/nats/postgres/sqs/gcp/email) fan out per-event and can't be bounded.`,
+        `--from '${opts.from}' is a \`// macros\` library — definition-only, injected into consuming scripts at run time, never a runnable step.`,
+      );
+    }
+    // A `--local` display-only node (a non-`// pipeline` DuckDB script surfaced
+    // only because it calls a macro) has no previewable content — reject it
+    // clearly rather than admitting it and silently producing an empty plan.
+    if (notRunnablePaths.has(scriptPathOf(resolved))) {
+      throw new Error(
+        `--from '${opts.from}' isn't a \`// pipeline\` script — it appears in the local graph only as a macro consumer (lineage). Mark it \`// pipeline\` to run it.`,
+      );
+    }
+    if (!resolved.startsWith("script:")) {
+      throw new Error(
+        `--from '${opts.from}' is an asset, not a runnable — start a run from a script (assets are produced, not run).`,
+      );
+    }
+    if (!fromEligible.has(resolved)) {
+      throw new Error(
+        `--from '${opts.from}' can't start a run: row-backed event triggers (kafka/mqtt/nats/postgres/sqs/gcp/email) and input-only entrypoints (webhook/data_upload) fan out per-event or need caller-supplied input — bind it with --upload to run it.`,
       );
     }
     start = resolved;
@@ -687,8 +812,12 @@ async function run(
   // barriers: a valid start (a schedule/manual root, or an `--upload`-bound
   // handler) runs with its own input even if it ALSO carries a non-autorun
   // trigger — cutting it would drop a legitimately-scheduled root and its chain.
+  // An explicit mid-DAG `--from` is likewise protected: the user named it as the
+  // start, so it runs even if it also carries a non-autorun trigger.
   const barriers = new Set(
-    [...nonAutorunTriggerScripts(graph)].filter((id) => !starts.has(id)),
+    [...nonAutorunTriggerScripts(graph)].filter(
+      (id) => !starts.has(id) && id !== start,
+    ),
   );
   let selectedScripts: Set<string>;
   let reachableEnds: string[] = [];
@@ -729,6 +858,11 @@ async function run(
     }
   }
 
+  // Selections can still pull a non-runnable node in via graph reachability (e.g.
+  // whole-pipeline mode collects every root's closure) — drop macro libraries and
+  // local-only display nodes before ordering so they never run.
+  for (const p of notRunnablePaths) selectedScripts.delete(p);
+
   const { order, cyclic } = topoOrder(graph, selectedScripts);
   if (cyclic.length > 0) {
     log.warn(`Skipping ${cyclic.length} script(s) on a dependency cycle: ${cyclic.sort().join(", ")}`);
@@ -877,9 +1011,15 @@ async function run(
         requestBody: nodeArgs,
       });
     }
-    const ok = await waitJob(workspace.workspaceId, id);
+    const { ok, result } = await waitJob(workspace.workspaceId, id);
     if (!ok) {
-      throw new Error(`Bounded run failed at ${nodePath} (job ${id}).`);
+      const detail = formatJobFailure(result);
+      const runUrl = `${workspace.remote}run/${id}?workspace=${workspace.workspaceId}`;
+      throw new Error(
+        `Bounded run failed at ${nodePath} (job ${id}).` +
+          (detail ? `\n${detail}` : "") +
+          `\nFull logs: ${runUrl}`,
+      );
     }
     if (!opts.json) log.info(colors.green(`  ✓ ${nodePath}`));
   }
@@ -908,12 +1048,12 @@ const command = new Command()
   .action(show as any)
   .command(
     "run",
-    "run a bounded cascade: from a schedule/manual root, fan downstream up to the --to end node(s)",
+    "run a cascade: from --from (a root OR any mid-DAG model), fan downstream up to the --to end node(s)",
   )
   .arguments("<folder:string>")
   .option(
     "--from <script:string>",
-    "Start script (short name or path). Defaults to the folder's sole schedule/manual root.",
+    "Start script (short name or path). May be any node, including a mid-DAG model — that node plus its transitive downstream runs, upstream is NOT re-run (dbt `--select model+`). Defaults to the folder's sole schedule/manual root.",
   )
   .option(
     "--to <node:string>",
diff --git a/cli/src/commands/sync/sync.ts b/cli/src/commands/sync/sync.ts
index 19516d84d5..65ce10eaad 100644
--- a/cli/src/commands/sync/sync.ts
+++ b/cli/src/commands/sync/sync.ts
@@ -48,6 +48,7 @@ import { handleFile } from "../script/script.ts";
 import {
   deepEqual,
   fetchRemoteVersion,
+  getHeaders,
   isFileResource,
   isFilesetResource,
   isRawAppFile,
@@ -3580,6 +3581,61 @@ function removeSuffix(str: string, suffix: string) {
 const SYNC_PUSH_DESTRUCTIVE_WARNING =
   "`wmill sync push` is destructive: applying it deploys these changes to the remote workspace and overwrites or deletes remote items that differ from or are absent locally — this is not automatically reversible. If you are an AI agent, do NOT run `wmill sync push` (without --dry-run) until the user has explicitly confirmed this deploy, unless your custom instructions explicitly allow bypassing that confirmation.";
 
+// A script pushed without a local lock queues a server-side dependency job; if
+// that job fails the script deploys broken (no lock/assets) with no CLI signal.
+// One-shot (no polling): report this push's already-failed + still-running
+// dependency jobs.
+async function checkServerLockJobs(
+  workspaceId: string,
+  sinceIso: string,
+  changedPaths: string[],
+): Promise<{ pending: number; failed: { path: string; error?: string }[] }> {
+  // A dependency job's script_path has no file extension; changed paths do.
+  const belongsToPush = (scriptPath?: string) =>
+    !!scriptPath &&
+    changedPaths.some(
+      (p) => p === scriptPath || p.startsWith(scriptPath + "."),
+    );
+  // Raw fetch: the checked-in generated client predates the `created_after` /
+  // `success` filters on the job list routes (see the `apiGet` note in
+  // pipeline.ts).
+  const listJobs = async (path: string): Promise<unknown[]> => {
+    const { OpenAPI } = await import("../../../gen/index.ts");
+    const resp = await fetch(`${OpenAPI.BASE}${path}`, {
+      headers: { ...getHeaders(), Authorization: `Bearer ${OpenAPI.TOKEN}` },
+    });
+    if (!resp.ok) throw new Error(`GET ${path} -> ${resp.status}`);
+    return (await resp.json()) as unknown[];
+  };
+  try {
+    const since = encodeURIComponent(sinceIso);
+    const [queued, completed] = await Promise.all([
+      listJobs(
+        `/w/${workspaceId}/jobs/queue/list?job_kinds=dependencies&created_after=${since}`,
+      ),
+      listJobs(
+        `/w/${workspaceId}/jobs/completed/list?job_kinds=dependencies&created_after=${since}&success=false`,
+      ),
+    ]);
+    const pending = (queued as { script_path?: string }[]).filter((j) =>
+      belongsToPush(j.script_path),
+    ).length;
+    const failed = (
+      completed as { script_path?: string; result?: unknown }[]
+    )
+      .filter((j) => belongsToPush(j.script_path))
+      .map((j) => ({
+        path: j.script_path!,
+        error: (j.result as { error?: { message?: string } } | undefined)
+          ?.error?.message,
+      }));
+    return { pending, failed };
+  } catch {
+    // Advisory only: a failed check must not fail an otherwise-complete push.
+    return { pending: 0, failed: [] };
+  }
+}
+
 export async function push(
   opts: GlobalOptions & SyncOptions & { repository?: string; branch?: string; acceptOverridingPermissionedAsWithSelf?: boolean },
 ) {
@@ -4224,6 +4280,7 @@ export async function push(
     }
 
     const start = performance.now();
+    const pushStartedAt = new Date().toISOString();
     log.info(colors.gray(`Applying changes to files ...`));
 
     let stateful = opts.stateful;
@@ -5004,9 +5061,30 @@ export async function push(
         `Failed to run new datatable migrations: ${e?.body ?? e?.message ?? e}`,
       );
     }
+    const lockJobs = await checkServerLockJobs(
+      workspace.workspaceId,
+      pushStartedAt,
+      changes.map((c) => c.path.replaceAll(SEP, "/")),
+    );
+    if (!opts.jsonOutput) {
+      for (const f of lockJobs.failed) {
+        log.warn(
+          `⚠ server-side lock generation FAILED for ${f.path} — the deployed script is broken until it locks.` +
+            (f.error ? `\n  ${f.error.split("\n")[0]}` : ""),
+        );
+      }
+      if (lockJobs.pending > 0) {
+        log.info(
+          colors.gray(
+            `${lockJobs.pending} server-side lock job(s) still running — locks (and inferred assets) land when they finish; check the Runs page if a script stays broken.`,
+          ),
+        );
+      }
+    }
     if (opts.jsonOutput) {
       const result = {
         success: true,
+        lock_jobs: lockJobs,
         message: `All ${changes.length} changes pushed to the remote workspace ${workspace.workspaceId} named ${workspace.name}`,
         changes: changes.map((change) => ({
           type: change.name,
diff --git a/cli/src/commands/workspace/workspace.ts b/cli/src/commands/workspace/workspace.ts
index 1e6030a44f..7d6bb2c87e 100644
--- a/cli/src/commands/workspace/workspace.ts
+++ b/cli/src/commands/workspace/workspace.ts
@@ -669,6 +669,26 @@ async function bind(
     }
     (config.workspaces as any)[wsName] = entry;
 
+    // Drop empty `{}` placeholder entries (older `wmill init` scaffolded one):
+    // they resolve to nothing (no baseUrl) yet count as configured workspaces,
+    // so leaving one beside the real binding makes every later command demand
+    // --workspace to disambiguate.
+    for (const [name, e] of Object.entries(
+      config.workspaces as Record<string, unknown>
+    )) {
+      if (
+        name !== wsName &&
+        !!e &&
+        typeof e === "object" &&
+        Object.keys(e).length === 0
+      ) {
+        delete (config.workspaces as any)[name];
+        log.info(
+          colors.gray(`Removed empty placeholder workspace entry '${name}'`)
+        );
+      }
+    }
+
     log.info(
       colors.green(
         `✓ Bound workspace '${wsName}'` +
diff --git a/cli/src/core/constants.ts b/cli/src/core/constants.ts
index 9e2110814d..f016b94c24 100644
--- a/cli/src/core/constants.ts
+++ b/cli/src/core/constants.ts
@@ -10,4 +10,4 @@ export const WM_FORK_PREFIX = "wm-fork";
 // (e.g. utils.ts) can read it without importing main.ts and creating a circular
 // dependency (main → workspace → utils → main) that triggers a TDZ.
 // Re-exported from main.ts for backwards compatibility.
-export const VERSION = "1.747.0";
+export const VERSION = "1.749.0";
diff --git a/cli/src/guidance/skills.gen.ts b/cli/src/guidance/skills.gen.ts
index 3fee79df92..240755bce3 100644
--- a/cli/src/guidance/skills.gen.ts
+++ b/cli/src/guidance/skills.gen.ts
@@ -1000,13 +1000,6 @@ async requestInteractiveSlackApproval({ slackResourcePath, channelId, message, a
  */
 async requestInteractiveTeamsApproval({ teamName, channelName, message, approver, defaultArgsJson, dynamicEnumsJson, }: TeamsApprovalOptions): Promise<void>
 
-/**
- * Parse an S3 object from URI string or record format
- * @param s3Object - S3 object as URI string (s3://storage/key) or record
- * @returns S3 object record with storage and s3 key
- */
-parseS3Object(s3Object: S3Object): S3ObjectRecord
-
 setWorkflowCtx(ctx: WorkflowCtx | null): void
 
 async sleep(seconds: number): Promise<void>
@@ -1076,6 +1069,17 @@ async parallel<T, R>(items: T[], fn: (item: T) => PromiseLike<R> | R, options?:
  */
 async commitKafkaOffsets(triggerPath: string, topic: string, partition: number, offset: number,): Promise<void>
 
+/**
+ * Parse an S3 object from URI string or record format
+ * @param s3Object - S3 object as URI string (\`s3://storage/key\`, \`s3:///key\`
+ *   for the default storage) or record. Any other string throws rather than
+ *   falling back to an auto-generated key: an auto key is requested by
+ *   omitting the object, and a fallback would silently misplace the upload
+ *   on any typo.
+ * @returns S3 object record with storage and s3 key
+ */
+parseS3Object(s3Object: S3Object): S3ObjectRecord
+
 /**
  * Create a SQL template function for PostgreSQL/datatable queries
  * @param name - Database/datatable name (default: "main")
@@ -1760,13 +1764,6 @@ async requestInteractiveSlackApproval({ slackResourcePath, channelId, message, a
  */
 async requestInteractiveTeamsApproval({ teamName, channelName, message, approver, defaultArgsJson, dynamicEnumsJson, }: TeamsApprovalOptions): Promise<void>
 
-/**
- * Parse an S3 object from URI string or record format
- * @param s3Object - S3 object as URI string (s3://storage/key) or record
- * @returns S3 object record with storage and s3 key
- */
-parseS3Object(s3Object: S3Object): S3ObjectRecord
-
 setWorkflowCtx(ctx: WorkflowCtx | null): void
 
 async sleep(seconds: number): Promise<void>
@@ -1836,6 +1833,17 @@ async parallel<T, R>(items: T[], fn: (item: T) => PromiseLike<R> | R, options?:
  */
 async commitKafkaOffsets(triggerPath: string, topic: string, partition: number, offset: number,): Promise<void>
 
+/**
+ * Parse an S3 object from URI string or record format
+ * @param s3Object - S3 object as URI string (\`s3://storage/key\`, \`s3:///key\`
+ *   for the default storage) or record. Any other string throws rather than
+ *   falling back to an auto-generated key: an auto key is requested by
+ *   omitting the object, and a fallback would silently misplace the upload
+ *   on any typo.
+ * @returns S3 object record with storage and s3 key
+ */
+parseS3Object(s3Object: S3Object): S3ObjectRecord
+
 /**
  * Create a SQL template function for PostgreSQL/datatable queries
  * @param name - Database/datatable name (default: "main")
@@ -2612,13 +2620,6 @@ async requestInteractiveSlackApproval({ slackResourcePath, channelId, message, a
  */
 async requestInteractiveTeamsApproval({ teamName, channelName, message, approver, defaultArgsJson, dynamicEnumsJson, }: TeamsApprovalOptions): Promise<void>
 
-/**
- * Parse an S3 object from URI string or record format
- * @param s3Object - S3 object as URI string (s3://storage/key) or record
- * @returns S3 object record with storage and s3 key
- */
-parseS3Object(s3Object: S3Object): S3ObjectRecord
-
 setWorkflowCtx(ctx: WorkflowCtx | null): void
 
 async sleep(seconds: number): Promise<void>
@@ -2688,6 +2689,17 @@ async parallel<T, R>(items: T[], fn: (item: T) => PromiseLike<R> | R, options?:
  */
 async commitKafkaOffsets(triggerPath: string, topic: string, partition: number, offset: number,): Promise<void>
 
+/**
+ * Parse an S3 object from URI string or record format
+ * @param s3Object - S3 object as URI string (\`s3://storage/key\`, \`s3:///key\`
+ *   for the default storage) or record. Any other string throws rather than
+ *   falling back to an auto-generated key: an auto key is requested by
+ *   omitting the object, and a fallback would silently misplace the upload
+ *   on any typo.
+ * @returns S3 object record with storage and s3 key
+ */
+parseS3Object(s3Object: S3Object): S3ObjectRecord
+
 /**
  * Create a SQL template function for PostgreSQL/datatable queries
  * @param name - Database/datatable name (default: "main")
@@ -4367,7 +4379,11 @@ def get_state_path() -> str
 # Parse resource syntax from string.
 def parse_resource_syntax(s: str) -> Optional[str]
 
-# Parse S3 object from string or S3Object format.
+# Parse S3 object from a \`s3://<storage>/<key>\` URI string (\`s3:///<key>\`
+# for the default storage) or S3Object format. Any other string raises
+# rather than falling back to an auto-generated key: an auto key is
+# requested by omitting the object, and a fallback would silently misplace
+# the upload on any typo.
 def parse_s3_object(s3_object: S3Object | str) -> S3Object
 
 # Parse variable syntax from string.
@@ -5291,7 +5307,7 @@ Reference a specific resource using \`$res:\` prefix:
 
 ## OpenFlow Schema
 
-{"OpenFlow":{"type":"object","description":"Top-level flow definition containing metadata, configuration, and the flow structure","properties":{"summary":{"type":"string","description":"Short description of what this flow does"},"description":{"type":"string","description":"Detailed documentation for this flow"},"value":{"$ref":"#/components/schemas/FlowValue"},"schema":{"type":"object","description":"JSON Schema for flow inputs. Use this to define input parameters, their types, defaults, and validation. For resource inputs, set type to 'object' and format to 'resource-<type>' (e.g., 'resource-stripe')"},"on_behalf_of_email":{"type":"string","description":"The flow will be run with the permissions of the user with this email."}},"required":["summary","value"]},"FlowValue":{"type":"object","description":"The flow structure containing modules and optional preprocessor/failure handlers","properties":{"modules":{"type":"array","description":"Array of steps that execute in sequence. Each step can be a script, subflow, loop, or branch","items":{"$ref":"#/components/schemas/FlowModule"}},"failure_module":{"description":"Special module that executes when the flow fails. Receives error object with message, name, stack, and step_id. Must have id 'failure'. Only supports script/rawscript types","$ref":"#/components/schemas/FlowModule"},"preprocessor_module":{"description":"Special module that runs before the first step on external triggers. Must have id 'preprocessor'. Only supports script/rawscript types. Cannot reference other step results","$ref":"#/components/schemas/FlowModule"},"same_worker":{"type":"boolean","description":"If true, all steps run on the same worker for better performance"},"preserve_step_tags":{"type":"boolean","description":"If true and the flow runs on a custom worker tag, steps that declare their own non-empty tag run on it instead of inheriting the flow tag. Steps without their own tag still inherit the flow tag."},"concurrent_limit":{"type":"number","description":"Maximum number of concurrent executions of this flow"},"concurrency_key":{"type":"string","description":"Expression to group concurrent executions (e.g., by user ID)"},"concurrency_time_window_s":{"type":"number","description":"Time window in seconds for concurrent_limit"},"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce flow executions"},"debounce_key":{"type":"string","description":"Expression to group debounced executions"},"debounce_args_to_accumulate":{"type":"array","description":"Arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds that a job can be debounced"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of times a job can be debounced"},"skip_expr":{"type":"string","description":"JavaScript expression to conditionally skip the entire flow"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for flow results"},"cache_ignore_s3_path":{"type":"boolean"},"delete_after_secs":{"type":"integer","description":"If set, delete the flow job's args, result and logs after this many seconds following job completion"},"flow_env":{"type":"object","description":"Environment variables available to all steps. Values can be strings, JSON values, or special references: '$var:path' (workspace variable) or '$res:path' (resource).","additionalProperties":{}},"priority":{"type":"number","description":"Execution priority (higher numbers run first)"},"early_return":{"type":"string","description":"JavaScript expression to return early from the flow"},"chat_input_enabled":{"type":"boolean","description":"Whether this flow accepts chat-style input"},"notes":{"type":"array","description":"Sticky notes attached to the flow","items":{"$ref":"#/components/schemas/FlowNote"}},"groups":{"type":"array","description":"Semantic groups of modules for organizational purposes","items":{"$ref":"#/components/schemas/FlowGroup"}}},"required":["modules"]},"Retry":{"type":"object","description":"Retry configuration for failed module executions","properties":{"constant":{"type":"object","description":"Retry with constant delay between attempts","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"seconds":{"type":"integer","description":"Seconds to wait between retries"}}},"exponential":{"type":"object","description":"Retry with exponential backoff (delay doubles each time)","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"multiplier":{"type":"integer","description":"Multiplier for exponential backoff"},"seconds":{"type":"integer","minimum":1,"description":"Initial delay in seconds"},"random_factor":{"type":"integer","minimum":0,"maximum":100,"description":"Random jitter percentage (0-100) to avoid thundering herd"}}},"retry_if":{"$ref":"#/components/schemas/RetryIf"}}},"FlowNote":{"type":"object","description":"A sticky note attached to a flow for documentation and annotation","properties":{"id":{"type":"string","description":"Unique identifier for the note"},"text":{"type":"string","description":"Content of the note"},"position":{"type":"object","description":"Position of the note in the flow editor","properties":{"x":{"type":"number","description":"X coordinate"},"y":{"type":"number","description":"Y coordinate"}},"required":["x","y"]},"size":{"type":"object","description":"Size of the note in the flow editor","properties":{"width":{"type":"number","description":"Width in pixels"},"height":{"type":"number","description":"Height in pixels"}},"required":["width","height"]},"color":{"type":"string","description":"Color of the note (e.g., \\"yellow\\", \\"#ffff00\\")"},"type":{"type":"string","enum":["free","group"],"description":"Type of note - 'free' for standalone notes, 'group' for notes that group other nodes"},"locked":{"type":"boolean","default":false,"description":"Whether the note is locked and cannot be edited or moved"},"contained_node_ids":{"type":"array","items":{"type":"string"},"description":"For group notes, the IDs of nodes contained within this group"}},"required":["id","text","color","type"]},"FlowGroup":{"type":"object","description":"A semantic group of flow modules for organizational purposes. Does not affect execution \\u2014 modules remain in their original position in the flow. Groups provide naming and collapsibility in the editor. Members are computed dynamically from all nodes on paths between start_id and end_id.","properties":{"summary":{"type":"string","description":"Display name for this group"},"note":{"type":"string","description":"Markdown note shown below the group header"},"autocollapse":{"type":"boolean","default":false,"description":"If true, this group is collapsed by default in the flow editor. UI hint only."},"start_id":{"type":"string","description":"ID of the first flow module in this group (topological entry point)"},"end_id":{"type":"string","description":"ID of the last flow module in this group (topological exit point)"},"color":{"type":"string","description":"Color for the group in the flow editor"}},"required":["start_id","end_id"]},"RetryIf":{"type":"object","description":"Conditional retry based on error or result","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to retry. Has access to 'result' and 'error' variables"}},"required":["expr"]},"StopAfterIf":{"type":"object","description":"Early termination condition for a module","properties":{"skip_if_stopped":{"type":"boolean","description":"If true, following steps are skipped when this condition triggers"},"expr":{"type":"string","description":"JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"},"error_message":{"type":"string","nullable":true,"description":"Custom error message when stopping with an error. Mutually exclusive with skip_if_stopped. If set to a non-empty string, the flow stops with this error. If empty string, a default error message is used. If null or omitted, no error is raised."},"error_include_result":{"type":"boolean","description":"When stopping with an error (error_message set), embed the stopping step's own result inside the raised error object (as error.result) instead of discarding it. The top-level result stays { error }. Defaults to false."}},"required":["expr"]},"FlowModule":{"type":"object","description":"A single step in a flow. Can be a script, subflow, loop, or branch","properties":{"id":{"type":"string","description":"Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)"},"value":{"$ref":"#/components/schemas/FlowModuleValue"},"stop_after_if":{"description":"Early termination condition evaluated after this step completes","$ref":"#/components/schemas/StopAfterIf"},"stop_after_all_iters_if":{"description":"For loops only - early termination condition evaluated after all iterations complete","$ref":"#/components/schemas/StopAfterIf"},"skip_if":{"type":"object","description":"Conditionally skip this step based on previous results or flow inputs","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to skip. Can use 'flow_input' or 'results.<step_id>'"}},"required":["expr"]},"sleep":{"description":"Delay before executing this step (in seconds or as expression)","$ref":"#/components/schemas/InputTransform"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for this step's results"},"cache_ignore_s3_path":{"type":"boolean"},"timeout":{"description":"Maximum execution time in seconds (static value or expression)","$ref":"#/components/schemas/InputTransform"},"delete_after_secs":{"type":"integer","description":"If set, delete the step's args, result and logs after this many seconds following job completion"},"summary":{"type":"string","description":"Short description of what this step does"},"mock":{"type":"object","description":"Mock configuration for testing without executing the actual step","properties":{"enabled":{"type":"boolean","description":"If true, return mock value instead of executing"},"return_value":{"description":"Value to return when mocked"}}},"suspend":{"type":"object","description":"Configuration for approval/resume steps that wait for user input","properties":{"required_events":{"type":"integer","description":"Number of approvals required before continuing"},"timeout":{"type":"integer","description":"Timeout in seconds before auto-continuing or canceling"},"resume_form":{"type":"object","description":"Form schema for collecting input when resuming","properties":{"schema":{"type":"object","description":"JSON Schema for the resume form"}}},"user_auth_required":{"type":"boolean","description":"If true, only authenticated users can approve"},"user_groups_required":{"description":"Expression or list of groups that can approve","$ref":"#/components/schemas/InputTransform"},"self_approval_disabled":{"type":"boolean","description":"If true, the user who started the flow cannot approve"},"hide_cancel":{"type":"boolean","description":"If true, hide the cancel button on the approval form"},"continue_on_disapprove_timeout":{"type":"boolean","description":"If true, continue flow on timeout instead of canceling"}}},"priority":{"type":"number","description":"Execution priority for this step (higher numbers run first)"},"continue_on_error":{"type":"boolean","description":"If true, flow continues even if this step fails"},"retry":{"description":"Retry configuration if this step fails","$ref":"#/components/schemas/Retry"},"debouncing":{"description":"Debounce configuration for this step (EE only)","type":"object","properties":{"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce this step's executions across flow runs"},"debounce_key":{"type":"string","description":"Expression to group debounced executions. Supports $workspace and $args[name]. Default: $workspace/flow/<flow_path>-<step_id>"},"debounce_args_to_accumulate":{"type":"array","description":"Array-type arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds before forced execution"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of debounces before forced execution"}}}},"required":["value","id"]},"InputTransform":{"description":"Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs","oneOf":[{"$ref":"#/components/schemas/StaticTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"StaticTransform":{"type":"object","description":"Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'","properties":{"value":{"description":"The static value. For resources, use format '$res:path/to/resource'"},"type":{"type":"string","enum":["static"]}},"required":["type"]},"JavascriptTransform":{"type":"object","description":"JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside loops, use 'flow_input.iter.value' for the current iteration value","properties":{"expr":{"type":"string","description":"JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"},"type":{"type":"string","enum":["javascript"]}},"required":["expr","type"]},"AiTransform":{"type":"object","description":"Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.","properties":{"type":{"type":"string","enum":["ai"]}},"required":["type"]},"AIProviderKind":{"type":"string","description":"Supported AI provider types","enum":["openai","azure_openai","azure_foundry","anthropic","mistral","deepseek","googleai","groq","openrouter","togetherai","customai","aws_bedrock"]},"ProviderConfig":{"type":"object","description":"Complete AI provider configuration with resource reference and model selection","properties":{"kind":{"$ref":"#/components/schemas/AIProviderKind"},"resource":{"type":"string","description":"Resource reference in format '$res:{resource_path}' pointing to provider credentials"},"model":{"type":"string","description":"Model identifier (e.g., 'gpt-4', 'claude-3-opus-20240229', 'gemini-pro')"}},"required":["kind","resource","model"]},"StaticProviderTransform":{"type":"object","description":"Static provider configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/ProviderConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"ProviderTransform":{"description":"Provider configuration - can be static (ProviderConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticProviderTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticProviderTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"MemoryOff":{"type":"object","description":"No conversation memory/context","properties":{"kind":{"type":"string","enum":["off"]}},"required":["kind"]},"MemoryAuto":{"type":"object","description":"Automatic context management","properties":{"kind":{"type":"string","enum":["auto"]},"context_length":{"type":"integer","description":"Maximum number of messages to retain in context"},"memory_id":{"type":"string","description":"Identifier for persistent memory across agent invocations"}},"required":["kind"]},"MemoryMessage":{"type":"object","description":"A single message in conversation history","properties":{"role":{"type":"string","enum":["user","assistant","system"]},"content":{"type":"string"}},"required":["role","content"]},"MemoryManual":{"type":"object","description":"Explicit message history","properties":{"kind":{"type":"string","enum":["manual"]},"messages":{"type":"array","items":{"$ref":"#/components/schemas/MemoryMessage"}}},"required":["kind","messages"]},"MemoryConfig":{"description":"Conversation memory configuration","oneOf":[{"$ref":"#/components/schemas/MemoryOff"},{"$ref":"#/components/schemas/MemoryAuto"},{"$ref":"#/components/schemas/MemoryManual"}],"discriminator":{"propertyName":"kind","mapping":{"off":"#/components/schemas/MemoryOff","auto":"#/components/schemas/MemoryAuto","manual":"#/components/schemas/MemoryManual"}}},"StaticMemoryTransform":{"type":"object","description":"Static memory configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/MemoryConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"MemoryTransform":{"description":"Memory configuration - can be static (MemoryConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticMemoryTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticMemoryTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"FlowModuleValue":{"description":"The actual implementation of a flow step. Can be a script (inline or referenced), subflow, loop, branch, or special module type","oneOf":[{"$ref":"#/components/schemas/RawScript"},{"$ref":"#/components/schemas/PathScript"},{"$ref":"#/components/schemas/PathFlow"},{"$ref":"#/components/schemas/ForloopFlow"},{"$ref":"#/components/schemas/WhileloopFlow"},{"$ref":"#/components/schemas/BranchOne"},{"$ref":"#/components/schemas/BranchAll"},{"$ref":"#/components/schemas/Identity"},{"$ref":"#/components/schemas/AiAgent"}],"discriminator":{"propertyName":"type","mapping":{"rawscript":"#/components/schemas/RawScript","script":"#/components/schemas/PathScript","flow":"#/components/schemas/PathFlow","forloopflow":"#/components/schemas/ForloopFlow","whileloopflow":"#/components/schemas/WhileloopFlow","branchone":"#/components/schemas/BranchOne","branchall":"#/components/schemas/BranchAll","identity":"#/components/schemas/Identity","aiagent":"#/components/schemas/AiAgent"}}},"RawScript":{"type":"object","description":"Inline script with code defined directly in the flow. Use 'bun' as default language if unspecified. The script receives arguments from input_transforms","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"content":{"type":"string","description":"The script source code. Should export a 'main' function"},"language":{"type":"string","description":"Programming language for this script","enum":["deno","bun","python3","go","bash","powershell","postgresql","mysql","bigquery","snowflake","mssql","oracledb","graphql","nativets","php","rust","ansible","csharp","nu","java","ruby","rlang","duckdb"]},"path":{"type":"string","description":"Optional path for saving this script"},"lock":{"type":"string","description":"Lock file content for dependencies"},"type":{"type":"string","enum":["rawscript"]},"tag":{"type":"string","description":"Worker group tag for execution routing"},"concurrent_limit":{"type":"number","description":"Maximum concurrent executions of this script"},"concurrency_time_window_s":{"type":"number","description":"Time window for concurrent_limit"},"custom_concurrency_key":{"type":"string","description":"Custom key for grouping concurrent executions"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"},"assets":{"type":"array","description":"External resources this script accesses (S3 objects, resources, etc.)","items":{"type":"object","required":["path","kind"],"properties":{"path":{"type":"string","description":"Path to the asset"},"kind":{"type":"string","description":"Type of asset","enum":["s3object","resource","ducklake","datatable","volume"]},"access_type":{"type":"string","nullable":true,"description":"Access level for this asset","enum":["r","w","rw"]},"alt_access_type":{"type":"string","nullable":true,"description":"Alternative access level","enum":["r","w","rw"]}}}}},"required":["type","content","language","input_transforms"]},"PathScript":{"type":"object","description":"Reference to an existing script by path. Use this when calling a previously saved script instead of writing inline code","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the script in the workspace (e.g., 'f/scripts/send_email')"},"hash":{"type":"string","description":"Optional specific version hash of the script to use"},"type":{"type":"string","enum":["script"]},"tag_override":{"type":"string","description":"Override the script's default worker group tag"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"}},"required":["type","path","input_transforms"]},"PathFlow":{"type":"object","description":"Reference to an existing flow by path. Use this to call another flow as a subflow","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the subflow's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the flow in the workspace (e.g., 'f/flows/process_user')"},"type":{"type":"string","enum":["flow"]}},"required":["type","path","input_transforms"]},"ForloopFlow":{"type":"object","description":"Executes nested modules in a loop over an iterator. Inside the loop, use 'flow_input.iter.value' to access the current iteration value, and 'flow_input.iter.index' for the index. Supports parallel execution for better performance on I/O-bound operations","properties":{"modules":{"type":"array","description":"Steps to execute for each iteration. These can reference the iteration value via 'flow_input.iter.value'","items":{"$ref":"#/components/schemas/FlowModule"}},"iterator":{"description":"JavaScript expression that returns an array to iterate over. Can reference 'results.step_id' or 'flow_input'","$ref":"#/components/schemas/InputTransform"},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["forloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (faster for I/O-bound operations). Use with parallelism to control concurrency"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true. Limits resource usage. Can be static number or expression","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","iterator","skip_failures","type"]},"WhileloopFlow":{"type":"object","description":"Executes nested modules repeatedly while a condition is true. The loop checks the condition after each iteration. Use stop_after_if on modules to control loop termination","properties":{"modules":{"type":"array","description":"Steps to execute in each iteration. Use stop_after_if to control when the loop ends","items":{"$ref":"#/components/schemas/FlowModule"}},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["whileloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (use with caution in while loops)"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","skip_failures","type"]},"BranchOne":{"type":"object","description":"Conditional branching where only the first matching branch executes. Branches are evaluated in order, and the first one with a true expression runs. If no branches match, the default branch executes","properties":{"branches":{"type":"array","description":"Array of branches to evaluate in order. The first branch with expr evaluating to true executes","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch condition"},"expr":{"type":"string","description":"JavaScript expression that returns boolean. Can use 'results.step_id' or 'flow_input'. First true expr wins"},"modules":{"type":"array","description":"Steps to execute if this branch's expr is true","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules","expr"]}},"default":{"type":"array","description":"Steps to execute if no branch expressions match","items":{"$ref":"#/components/schemas/FlowModule"}},"type":{"type":"string","enum":["branchone"]}},"required":["branches","default","type"]},"BranchAll":{"type":"object","description":"Parallel branching where all branches execute simultaneously. Unlike BranchOne, all branches run regardless of conditions. Useful for executing independent tasks concurrently","properties":{"branches":{"type":"array","description":"Array of branches that all execute (either in parallel or sequentially)","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch's purpose"},"skip_failure":{"type":"boolean","description":"If true, failure in this branch doesn't fail the entire flow"},"modules":{"type":"array","description":"Steps to execute in this branch","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules"]}},"type":{"type":"string","enum":["branchall"]},"parallel":{"type":"boolean","description":"If true, all branches execute concurrently. If false, they execute sequentially"}},"required":["branches","type"]},"AgentTool":{"type":"object","description":"A tool available to an AI agent. Can be a flow module or an external MCP (Model Context Protocol) tool","properties":{"id":{"type":"string","description":"Unique identifier for this tool. Cannot contain spaces - use underscores instead (e.g., 'get_user_data' not 'get user data')"},"summary":{"type":"string","description":"Short description of what this tool does (shown to the AI)"},"value":{"$ref":"#/components/schemas/ToolValue"}},"required":["id","value"]},"ToolValue":{"description":"The implementation of a tool. Can be a flow module (script/flow) or an MCP tool reference","oneOf":[{"$ref":"#/components/schemas/FlowModuleTool"},{"$ref":"#/components/schemas/McpToolValue"},{"$ref":"#/components/schemas/WebsearchToolValue"}],"discriminator":{"propertyName":"tool_type","mapping":{"flowmodule":"#/components/schemas/FlowModuleTool","mcp":"#/components/schemas/McpToolValue","websearch":"#/components/schemas/WebsearchToolValue"}}},"FlowModuleTool":{"description":"A tool implemented as a flow module (script, flow, etc.). The AI can call this like any other flow module","allOf":[{"type":"object","properties":{"tool_type":{"type":"string","enum":["flowmodule"]}},"required":["tool_type"]},{"$ref":"#/components/schemas/FlowModuleValue"}]},"WebsearchToolValue":{"type":"object","description":"A tool implemented as a websearch tool. The AI can call this like any other websearch tool","properties":{"tool_type":{"type":"string","enum":["websearch"]}},"required":["tool_type"]},"McpToolValue":{"type":"object","description":"Reference to an external MCP (Model Context Protocol) tool. The AI can call tools from MCP servers","properties":{"tool_type":{"type":"string","enum":["mcp"]},"resource_path":{"type":"string","description":"Path to the MCP resource/server configuration"},"include_tools":{"type":"array","description":"Whitelist of specific tools to include from this MCP server","items":{"type":"string"}},"exclude_tools":{"type":"array","description":"Blacklist of tools to exclude from this MCP server","items":{"type":"string"}}},"required":["tool_type","resource_path"]},"AiAgent":{"type":"object","description":"AI agent step that can use tools to accomplish tasks. The agent receives inputs and can call any of its configured tools to complete the task","properties":{"input_transforms":{"type":"object","description":"Input parameters for the AI agent mapped to their values","properties":{"provider":{"$ref":"#/components/schemas/ProviderTransform"},"output_type":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Output format type.\\nValid values: 'text' (default) - plain text response, 'image' - image generation\\n"},"user_message":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"The user's prompt/message to the AI agent. Supports variable interpolation with flow.input syntax."},"system_prompt":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"System instructions that guide the AI's behavior, persona, and response style. Optional."},"streaming":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Boolean. If true, stream the AI response incrementally.\\nStreaming events include: token_delta, tool_call, tool_call_arguments, tool_execution, tool_result\\n"},"memory":{"$ref":"#/components/schemas/MemoryTransform"},"output_schema":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"JSON Schema object defining structured output format. Used when you need the AI to return data in a specific shape.\\nSupports standard JSON Schema properties: type, properties, required, items, enum, pattern, minLength, maxLength, minimum, maximum, etc.\\nExample: { type: 'object', properties: { name: { type: 'string' }, age: { type: 'integer' } }, required: ['name'] }\\n"},"user_attachments":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Array of file references (images or PDFs) for the AI agent.\\nFormat: Array<{ bucket: string, key: string }> - S3 object references\\nExample: [{ bucket: 'my-bucket', key: 'documents/report.pdf' }]\\n"},"max_completion_tokens":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Integer. Maximum number of tokens the AI will generate in its response.\\nRange: 1 to 4,294,967,295. Typical values: 256-4096 for most use cases.\\n"},"temperature":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Float. Controls randomness/creativity of responses.\\nRange: 0.0 to 2.0 (provider-dependent)\\n- 0.0 = deterministic, focused responses\\n- 0.7 = balanced (common default)\\n- 1.0+ = more creative/random\\n"},"max_iterations":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Number. Limits how many times the agent can loop through reasoning and tool use.\\nRange: 1-1000.\\n"}},"required":["provider","user_message","output_type"]},"tools":{"type":"array","description":"Array of tools the agent can use. The agent decides which tools to call based on the task","items":{"$ref":"#/components/schemas/AgentTool"}},"type":{"type":"string","enum":["aiagent"]},"tag":{"type":"string","description":"Worker group tag for execution routing. If not set, the AI agent step runs on the flow's tag (default \`flow\`)"},"omit_output_from_conversation":{"type":"boolean","default":false,"description":"If true, this AI agent step does not persist its assistant or tool messages to the flow conversation when chat mode is enabled."},"parallel":{"type":"boolean","description":"If true, the agent can execute multiple tool calls in parallel"}},"required":["tools","type","input_transforms"]},"Identity":{"type":"object","description":"Pass-through module that returns its input unchanged. Useful for flow structure or as a placeholder","properties":{"type":{"type":"string","enum":["identity"]},"flow":{"type":"boolean","description":"If true, marks this as a flow identity (special handling)"}},"required":["type"]},"FlowStatus":{"type":"object","properties":{"step":{"type":"integer"},"modules":{"type":"array","items":{"$ref":"#/components/schemas/FlowStatusModule"}},"user_states":{"additionalProperties":true},"preprocessor_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"}]},"failure_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"},{"type":"object","properties":{"parent_module":{"type":"string"}}}]},"retry":{"type":"object","properties":{"fail_count":{"type":"integer"},"failed_jobs":{"type":"array","items":{"type":"string","format":"uuid"}}}}},"required":["step","modules","failure_module"]},"FlowStatusModule":{"type":"object","properties":{"type":{"type":"string","enum":["WaitingForPriorSteps","WaitingForEvents","WaitingForExecutor","InProgress","Success","Failure"]},"id":{"type":"string"},"job":{"type":"string","format":"uuid"},"count":{"type":"integer"},"progress":{"type":"integer"},"iterator":{"type":"object","properties":{"index":{"type":"integer"},"itered":{"type":"array","items":{}},"itered_len":{"type":"integer"},"args":{}}},"flow_jobs":{"type":"array","items":{"type":"string"}},"flow_jobs_success":{"type":"array","items":{"type":"boolean"}},"flow_jobs_duration":{"type":"object","properties":{"started_at":{"type":"array","items":{"type":"string"}},"duration_ms":{"type":"array","items":{"type":"integer"}}}},"branch_chosen":{"type":"object","properties":{"type":{"type":"string","enum":["branch","default"]},"branch":{"type":"integer"}},"required":["type"]},"branchall":{"type":"object","properties":{"branch":{"type":"integer"},"len":{"type":"integer"}},"required":["branch","len"]},"approvers":{"type":"array","items":{"type":"object","properties":{"resume_id":{"type":"integer"},"approver":{"type":"string"}},"required":["resume_id","approver"]}},"failed_retries":{"type":"array","items":{"type":"string","format":"uuid"}},"skipped":{"type":"boolean"},"agent_actions":{"type":"array","items":{"type":"object","oneOf":[{"type":"object","properties":{"job_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"type":{"type":"string","enum":["tool_call"]},"module_id":{"type":"string"}},"required":["job_id","function_name","type","module_id"]},{"type":"object","properties":{"call_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"resource_path":{"type":"string"},"type":{"type":"string","enum":["mcp_tool_call"]},"arguments":{"type":"object"}},"required":["call_id","function_name","resource_path","type"]},{"type":"object","properties":{"type":{"type":"string","enum":["web_search"]}},"required":["type"]},{"type":"object","properties":{"type":{"type":"string","enum":["message"]}},"required":["content","type"]}]}},"agent_actions_success":{"type":"array","items":{"type":"boolean"}}},"required":["type"]}}`,
+{"OpenFlow":{"type":"object","description":"Top-level flow definition containing metadata, configuration, and the flow structure","properties":{"summary":{"type":"string","description":"Short description of what this flow does"},"description":{"type":"string","description":"Detailed documentation for this flow"},"value":{"$ref":"#/components/schemas/FlowValue"},"schema":{"type":"object","description":"JSON Schema for flow inputs. Use this to define input parameters, their types, defaults, and validation. For resource inputs, set type to 'object' and format to 'resource-<type>' (e.g., 'resource-stripe')"},"on_behalf_of_email":{"type":"string","description":"The flow will be run with the permissions of the user with this email."}},"required":["summary","value"]},"FlowValue":{"type":"object","description":"The flow structure containing modules and optional preprocessor/failure handlers","properties":{"modules":{"type":"array","description":"Array of steps that execute in sequence. Each step can be a script, subflow, loop, or branch","items":{"$ref":"#/components/schemas/FlowModule"}},"failure_module":{"description":"Special module that executes when the flow fails. Receives error object with message, name, stack, and step_id. Must have id 'failure'. Only supports script/rawscript types","$ref":"#/components/schemas/FlowModule"},"preprocessor_module":{"description":"Special module that runs before the first step on external triggers. Must have id 'preprocessor'. Only supports script/rawscript types. Cannot reference other step results","$ref":"#/components/schemas/FlowModule"},"same_worker":{"type":"boolean","description":"If true, all steps run on the same worker for better performance"},"preserve_step_tags":{"type":"boolean","description":"If true and the flow runs on a custom worker tag, steps that declare their own non-empty tag run on it instead of inheriting the flow tag. Steps without their own tag still inherit the flow tag."},"concurrent_limit":{"type":"number","description":"Maximum number of concurrent executions of this flow"},"concurrency_key":{"type":"string","description":"Expression to group concurrent executions (e.g., by user ID)"},"concurrency_time_window_s":{"type":"number","description":"Time window in seconds for concurrent_limit"},"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce flow executions"},"debounce_key":{"type":"string","description":"Expression to group debounced executions"},"debounce_args_to_accumulate":{"type":"array","description":"Arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds that a job can be debounced"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of times a job can be debounced"},"skip_expr":{"type":"string","description":"JavaScript expression to conditionally skip the entire flow"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for flow results"},"cache_ignore_s3_path":{"type":"boolean"},"delete_after_secs":{"type":"integer","description":"If set, delete the flow job's args, result and logs after this many seconds following job completion"},"flow_env":{"type":"object","description":"Environment variables available to all steps. Values can be strings, JSON values, or special references: '$var:path' (workspace variable) or '$res:path' (resource).","additionalProperties":{}},"priority":{"type":"number","description":"Execution priority (higher numbers run first)"},"early_return":{"type":"string","description":"JavaScript expression to return early from the flow"},"chat_input_enabled":{"type":"boolean","description":"Whether this flow accepts chat-style input"},"notes":{"type":"array","description":"Sticky notes attached to the flow","items":{"$ref":"#/components/schemas/FlowNote"}},"groups":{"type":"array","description":"Semantic groups of modules for organizational purposes","items":{"$ref":"#/components/schemas/FlowGroup"}}},"required":["modules"]},"Retry":{"type":"object","description":"Retry configuration for failed module executions","properties":{"constant":{"type":"object","description":"Retry with constant delay between attempts","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"seconds":{"type":"integer","description":"Seconds to wait between retries"}}},"exponential":{"type":"object","description":"Retry with exponential backoff (delay doubles each time)","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"multiplier":{"type":"integer","description":"Multiplier for exponential backoff"},"seconds":{"type":"integer","minimum":1,"description":"Initial delay in seconds"},"random_factor":{"type":"integer","minimum":0,"maximum":100,"description":"Random jitter percentage (0-100) to avoid thundering herd"}}},"retry_if":{"$ref":"#/components/schemas/RetryIf"}}},"FlowNote":{"type":"object","description":"A sticky note attached to a flow for documentation and annotation","properties":{"id":{"type":"string","description":"Unique identifier for the note"},"text":{"type":"string","description":"Content of the note"},"position":{"type":"object","description":"Position of the note in the flow editor","properties":{"x":{"type":"number","description":"X coordinate"},"y":{"type":"number","description":"Y coordinate"}},"required":["x","y"]},"size":{"type":"object","description":"Size of the note in the flow editor","properties":{"width":{"type":"number","description":"Width in pixels"},"height":{"type":"number","description":"Height in pixels"}},"required":["width","height"]},"color":{"type":"string","description":"Color of the note (e.g., \\"yellow\\", \\"#ffff00\\")"},"type":{"type":"string","enum":["free","group"],"description":"Type of note - 'free' for standalone notes, 'group' for notes that group other nodes"},"locked":{"type":"boolean","default":false,"description":"Whether the note is locked and cannot be edited or moved"},"contained_node_ids":{"type":"array","items":{"type":"string"},"description":"For group notes, the IDs of nodes contained within this group"}},"required":["id","text","color","type"]},"FlowGroup":{"type":"object","description":"A semantic group of flow modules for organizational purposes. Does not affect execution \\u2014 modules remain in their original position in the flow. Groups provide naming and collapsibility in the editor. Members are computed dynamically from all nodes on paths between start_id and end_id.","properties":{"summary":{"type":"string","description":"Display name for this group"},"note":{"type":"string","description":"Markdown note shown below the group header"},"autocollapse":{"type":"boolean","default":false,"description":"If true, this group is collapsed by default in the flow editor. UI hint only."},"start_id":{"type":"string","description":"ID of the first flow module in this group (topological entry point)"},"end_id":{"type":"string","description":"ID of the last flow module in this group (topological exit point)"},"color":{"type":"string","description":"Color for the group in the flow editor"}},"required":["start_id","end_id"]},"RetryIf":{"type":"object","description":"Conditional retry based on error or result","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to retry. Has access to 'result' and 'error' variables"}},"required":["expr"]},"StopAfterIf":{"type":"object","description":"Early termination condition for a module","properties":{"skip_if_stopped":{"type":"boolean","description":"If true, following steps are skipped when this condition triggers"},"expr":{"type":"string","description":"JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"},"error_message":{"type":"string","nullable":true,"description":"Custom error message when stopping with an error. Mutually exclusive with skip_if_stopped. If set to a non-empty string, the flow stops with this error. If empty string, a default error message is used. If null or omitted, no error is raised."},"error_include_result":{"type":"boolean","description":"When stopping with an error (error_message set), embed the stopping step's own result inside the raised error object (as error.result) instead of discarding it. The top-level result stays { error }. Defaults to false."}},"required":["expr"]},"FlowModule":{"type":"object","description":"A single step in a flow. Can be a script, subflow, loop, or branch","properties":{"id":{"type":"string","description":"Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)"},"value":{"$ref":"#/components/schemas/FlowModuleValue"},"stop_after_if":{"description":"Early termination condition evaluated after this step completes","$ref":"#/components/schemas/StopAfterIf"},"stop_after_all_iters_if":{"description":"For loops only - early termination condition evaluated after all iterations complete","$ref":"#/components/schemas/StopAfterIf"},"skip_if":{"type":"object","description":"Conditionally skip this step based on previous results or flow inputs","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to skip. Can use 'flow_input' or 'results.<step_id>'"}},"required":["expr"]},"sleep":{"description":"Delay before executing this step (in seconds or as expression)","$ref":"#/components/schemas/InputTransform"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for this step's results"},"cache_ignore_s3_path":{"type":"boolean"},"timeout":{"description":"Maximum execution time in seconds (static value or expression)","$ref":"#/components/schemas/InputTransform"},"delete_after_secs":{"type":"integer","description":"If set, delete the step's args, result and logs after this many seconds following job completion"},"summary":{"type":"string","description":"Short description of what this step does"},"mock":{"type":"object","description":"Mock configuration for testing without executing the actual step","properties":{"enabled":{"type":"boolean","description":"If true, return mock value instead of executing"},"return_value":{"description":"Value to return when mocked"}}},"suspend":{"type":"object","description":"Configuration for approval/resume steps that wait for user input","properties":{"required_events":{"type":"integer","description":"Number of approvals required before continuing"},"timeout":{"type":"integer","description":"Timeout in seconds before auto-continuing or canceling"},"resume_form":{"type":"object","description":"Form schema for collecting input when resuming","properties":{"schema":{"type":"object","description":"JSON Schema for the resume form"}}},"user_auth_required":{"type":"boolean","description":"If true, only authenticated users can approve"},"user_groups_required":{"description":"Expression or list of groups that can approve","$ref":"#/components/schemas/InputTransform"},"self_approval_disabled":{"type":"boolean","description":"If true, the user who started the flow cannot approve"},"hide_cancel":{"type":"boolean","description":"If true, hide the cancel button on the approval form"},"continue_on_disapprove_timeout":{"type":"boolean","description":"If true, continue flow on timeout instead of canceling"}}},"priority":{"type":"number","description":"Execution priority for this step (higher numbers run first)"},"continue_on_error":{"type":"boolean","description":"If true, flow continues even if this step fails"},"retry":{"description":"Retry configuration if this step fails","$ref":"#/components/schemas/Retry"},"debouncing":{"description":"Debounce configuration for this step (EE only)","type":"object","properties":{"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce this step's executions across flow runs"},"debounce_key":{"type":"string","description":"Expression to group debounced executions. Supports $workspace and $args[name]. Default: $workspace/flow/<flow_path>-<step_id>"},"debounce_args_to_accumulate":{"type":"array","description":"Array-type arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds before forced execution"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of debounces before forced execution"}}}},"required":["value","id"]},"InputTransform":{"description":"Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs","oneOf":[{"$ref":"#/components/schemas/StaticTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"StaticTransform":{"type":"object","description":"Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'","properties":{"value":{"description":"The static value. For resources, use format '$res:path/to/resource'"},"type":{"type":"string","enum":["static"]}},"required":["type"]},"JavascriptTransform":{"type":"object","description":"JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside loops, use 'flow_input.iter.value' for the current iteration value","properties":{"expr":{"type":"string","description":"JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"},"type":{"type":"string","enum":["javascript"]}},"required":["expr","type"]},"AiTransform":{"type":"object","description":"Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.","properties":{"type":{"type":"string","enum":["ai"]}},"required":["type"]},"AIProviderKind":{"type":"string","description":"Supported AI provider types","enum":["openai","azure_openai","azure_foundry","anthropic","mistral","deepseek","googleai","groq","openrouter","togetherai","customai","aws_bedrock"]},"ProviderConfig":{"type":"object","description":"Complete AI provider configuration with resource reference and model selection","properties":{"kind":{"$ref":"#/components/schemas/AIProviderKind"},"resource":{"type":"string","description":"Resource reference in format '$res:{resource_path}' pointing to provider credentials"},"model":{"type":"string","description":"Model identifier (e.g., 'gpt-4', 'claude-3-opus-20240229', 'gemini-pro')"},"reasoning_effort":{"type":"string","description":"Provider-native reasoning effort token (e.g. 'low', 'high', 'none') for models that support extended thinking. Optional; unset leaves the provider default."}},"required":["kind","resource","model"]},"StaticProviderTransform":{"type":"object","description":"Static provider configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/ProviderConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"ProviderTransform":{"description":"Provider configuration - can be static (ProviderConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticProviderTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticProviderTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"MemoryOff":{"type":"object","description":"No conversation memory/context","properties":{"kind":{"type":"string","enum":["off"]}},"required":["kind"]},"MemoryAuto":{"type":"object","description":"Automatic context management","properties":{"kind":{"type":"string","enum":["auto"]},"context_length":{"type":"integer","description":"Maximum number of messages to retain in context"},"memory_id":{"type":"string","description":"Identifier for persistent memory across agent invocations"}},"required":["kind"]},"MemoryMessage":{"type":"object","description":"A single message in conversation history","properties":{"role":{"type":"string","enum":["user","assistant","system"]},"content":{"type":"string"}},"required":["role","content"]},"MemoryManual":{"type":"object","description":"Explicit message history","properties":{"kind":{"type":"string","enum":["manual"]},"messages":{"type":"array","items":{"$ref":"#/components/schemas/MemoryMessage"}}},"required":["kind","messages"]},"MemoryConfig":{"description":"Conversation memory configuration","oneOf":[{"$ref":"#/components/schemas/MemoryOff"},{"$ref":"#/components/schemas/MemoryAuto"},{"$ref":"#/components/schemas/MemoryManual"}],"discriminator":{"propertyName":"kind","mapping":{"off":"#/components/schemas/MemoryOff","auto":"#/components/schemas/MemoryAuto","manual":"#/components/schemas/MemoryManual"}}},"StaticMemoryTransform":{"type":"object","description":"Static memory configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/MemoryConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"MemoryTransform":{"description":"Memory configuration - can be static (MemoryConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticMemoryTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticMemoryTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"FlowModuleValue":{"description":"The actual implementation of a flow step. Can be a script (inline or referenced), subflow, loop, branch, or special module type","oneOf":[{"$ref":"#/components/schemas/RawScript"},{"$ref":"#/components/schemas/PathScript"},{"$ref":"#/components/schemas/PathFlow"},{"$ref":"#/components/schemas/ForloopFlow"},{"$ref":"#/components/schemas/WhileloopFlow"},{"$ref":"#/components/schemas/BranchOne"},{"$ref":"#/components/schemas/BranchAll"},{"$ref":"#/components/schemas/Identity"},{"$ref":"#/components/schemas/AiAgent"}],"discriminator":{"propertyName":"type","mapping":{"rawscript":"#/components/schemas/RawScript","script":"#/components/schemas/PathScript","flow":"#/components/schemas/PathFlow","forloopflow":"#/components/schemas/ForloopFlow","whileloopflow":"#/components/schemas/WhileloopFlow","branchone":"#/components/schemas/BranchOne","branchall":"#/components/schemas/BranchAll","identity":"#/components/schemas/Identity","aiagent":"#/components/schemas/AiAgent"}}},"RawScript":{"type":"object","description":"Inline script with code defined directly in the flow. Use 'bun' as default language if unspecified. The script receives arguments from input_transforms","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"content":{"type":"string","description":"The script source code. Should export a 'main' function"},"language":{"type":"string","description":"Programming language for this script","enum":["deno","bun","python3","go","bash","powershell","postgresql","mysql","bigquery","snowflake","mssql","oracledb","graphql","nativets","php","rust","ansible","csharp","nu","java","ruby","rlang","duckdb"]},"path":{"type":"string","description":"Optional path for saving this script"},"lock":{"type":"string","description":"Lock file content for dependencies"},"type":{"type":"string","enum":["rawscript"]},"tag":{"type":"string","description":"Worker group tag for execution routing"},"concurrent_limit":{"type":"number","description":"Maximum concurrent executions of this script"},"concurrency_time_window_s":{"type":"number","description":"Time window for concurrent_limit"},"custom_concurrency_key":{"type":"string","description":"Custom key for grouping concurrent executions"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"},"assets":{"type":"array","description":"External resources this script accesses (S3 objects, resources, etc.)","items":{"type":"object","required":["path","kind"],"properties":{"path":{"type":"string","description":"Path to the asset"},"kind":{"type":"string","description":"Type of asset","enum":["s3object","resource","ducklake","datatable","volume"]},"access_type":{"type":"string","nullable":true,"description":"Access level for this asset","enum":["r","w","rw"]},"alt_access_type":{"type":"string","nullable":true,"description":"Alternative access level","enum":["r","w","rw"]}}}}},"required":["type","content","language","input_transforms"]},"PathScript":{"type":"object","description":"Reference to an existing script by path. Use this when calling a previously saved script instead of writing inline code","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the script in the workspace (e.g., 'f/scripts/send_email')"},"hash":{"type":"string","description":"Optional specific version hash of the script to use"},"type":{"type":"string","enum":["script"]},"tag_override":{"type":"string","description":"Override the script's default worker group tag"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"}},"required":["type","path","input_transforms"]},"PathFlow":{"type":"object","description":"Reference to an existing flow by path. Use this to call another flow as a subflow","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the subflow's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the flow in the workspace (e.g., 'f/flows/process_user')"},"type":{"type":"string","enum":["flow"]}},"required":["type","path","input_transforms"]},"ForloopFlow":{"type":"object","description":"Executes nested modules in a loop over an iterator. Inside the loop, use 'flow_input.iter.value' to access the current iteration value, and 'flow_input.iter.index' for the index. Supports parallel execution for better performance on I/O-bound operations","properties":{"modules":{"type":"array","description":"Steps to execute for each iteration. These can reference the iteration value via 'flow_input.iter.value'","items":{"$ref":"#/components/schemas/FlowModule"}},"iterator":{"description":"JavaScript expression that returns an array to iterate over. Can reference 'results.step_id' or 'flow_input'","$ref":"#/components/schemas/InputTransform"},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["forloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (faster for I/O-bound operations). Use with parallelism to control concurrency"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true. Limits resource usage. Can be static number or expression","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","iterator","skip_failures","type"]},"WhileloopFlow":{"type":"object","description":"Executes nested modules repeatedly while a condition is true. The loop checks the condition after each iteration. Use stop_after_if on modules to control loop termination","properties":{"modules":{"type":"array","description":"Steps to execute in each iteration. Use stop_after_if to control when the loop ends","items":{"$ref":"#/components/schemas/FlowModule"}},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["whileloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (use with caution in while loops)"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","skip_failures","type"]},"BranchOne":{"type":"object","description":"Conditional branching where only the first matching branch executes. Branches are evaluated in order, and the first one with a true expression runs. If no branches match, the default branch executes","properties":{"branches":{"type":"array","description":"Array of branches to evaluate in order. The first branch with expr evaluating to true executes","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch condition"},"expr":{"type":"string","description":"JavaScript expression that returns boolean. Can use 'results.step_id' or 'flow_input'. First true expr wins"},"modules":{"type":"array","description":"Steps to execute if this branch's expr is true","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules","expr"]}},"default":{"type":"array","description":"Steps to execute if no branch expressions match","items":{"$ref":"#/components/schemas/FlowModule"}},"type":{"type":"string","enum":["branchone"]}},"required":["branches","default","type"]},"BranchAll":{"type":"object","description":"Parallel branching where all branches execute simultaneously. Unlike BranchOne, all branches run regardless of conditions. Useful for executing independent tasks concurrently","properties":{"branches":{"type":"array","description":"Array of branches that all execute (either in parallel or sequentially)","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch's purpose"},"skip_failure":{"type":"boolean","description":"If true, failure in this branch doesn't fail the entire flow"},"modules":{"type":"array","description":"Steps to execute in this branch","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules"]}},"type":{"type":"string","enum":["branchall"]},"parallel":{"type":"boolean","description":"If true, all branches execute concurrently. If false, they execute sequentially"}},"required":["branches","type"]},"AgentTool":{"type":"object","description":"A tool available to an AI agent. Can be a flow module or an external MCP (Model Context Protocol) tool","properties":{"id":{"type":"string","description":"Unique identifier for this tool. Cannot contain spaces - use underscores instead (e.g., 'get_user_data' not 'get user data')"},"summary":{"type":"string","description":"Short description of what this tool does (shown to the AI)"},"value":{"$ref":"#/components/schemas/ToolValue"}},"required":["id","value"]},"ToolValue":{"description":"The implementation of a tool. Can be a flow module (script/flow) or an MCP tool reference","oneOf":[{"$ref":"#/components/schemas/FlowModuleTool"},{"$ref":"#/components/schemas/McpToolValue"},{"$ref":"#/components/schemas/WebsearchToolValue"}],"discriminator":{"propertyName":"tool_type","mapping":{"flowmodule":"#/components/schemas/FlowModuleTool","mcp":"#/components/schemas/McpToolValue","websearch":"#/components/schemas/WebsearchToolValue"}}},"FlowModuleTool":{"description":"A tool implemented as a flow module (script, flow, etc.). The AI can call this like any other flow module","allOf":[{"type":"object","properties":{"tool_type":{"type":"string","enum":["flowmodule"]}},"required":["tool_type"]},{"$ref":"#/components/schemas/FlowModuleValue"}]},"WebsearchToolValue":{"type":"object","description":"A tool implemented as a websearch tool. The AI can call this like any other websearch tool","properties":{"tool_type":{"type":"string","enum":["websearch"]}},"required":["tool_type"]},"McpToolValue":{"type":"object","description":"Reference to an external MCP (Model Context Protocol) tool. The AI can call tools from MCP servers","properties":{"tool_type":{"type":"string","enum":["mcp"]},"resource_path":{"type":"string","description":"Path to the MCP resource/server configuration"},"include_tools":{"type":"array","description":"Whitelist of specific tools to include from this MCP server","items":{"type":"string"}},"exclude_tools":{"type":"array","description":"Blacklist of tools to exclude from this MCP server","items":{"type":"string"}}},"required":["tool_type","resource_path"]},"AiAgent":{"type":"object","description":"AI agent step that can use tools to accomplish tasks. The agent receives inputs and can call any of its configured tools to complete the task","properties":{"input_transforms":{"type":"object","description":"Input parameters for the AI agent mapped to their values","properties":{"provider":{"$ref":"#/components/schemas/ProviderTransform"},"output_type":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Output format type.\\nValid values: 'text' (default) - plain text response, 'image' - image generation\\n"},"user_message":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"The user's prompt/message to the AI agent. Supports variable interpolation with flow.input syntax."},"system_prompt":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"System instructions that guide the AI's behavior, persona, and response style. Optional."},"streaming":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Boolean. If true, stream the AI response incrementally.\\nStreaming events include: token_delta, reasoning_token_delta, tool_call, tool_call_arguments, tool_execution, tool_result\\n"},"memory":{"$ref":"#/components/schemas/MemoryTransform"},"output_schema":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"JSON Schema object defining structured output format. Used when you need the AI to return data in a specific shape.\\nSupports standard JSON Schema properties: type, properties, required, items, enum, pattern, minLength, maxLength, minimum, maximum, etc.\\nExample: { type: 'object', properties: { name: { type: 'string' }, age: { type: 'integer' } }, required: ['name'] }\\n"},"user_attachments":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Array of file references (images or PDFs) for the AI agent.\\nFormat: Array<{ bucket: string, key: string }> - S3 object references\\nExample: [{ bucket: 'my-bucket', key: 'documents/report.pdf' }]\\n"},"max_completion_tokens":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Integer. Maximum number of tokens the AI will generate in its response.\\nRange: 1 to 4,294,967,295. Typical values: 256-4096 for most use cases.\\n"},"temperature":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Float. Controls randomness/creativity of responses.\\nRange: 0.0 to 2.0 (provider-dependent)\\n- 0.0 = deterministic, focused responses\\n- 0.7 = balanced (common default)\\n- 1.0+ = more creative/random\\n"},"max_iterations":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Number. Limits how many times the agent can loop through reasoning and tool use.\\nRange: 1-1000.\\n"}},"required":["provider","user_message","output_type"]},"tools":{"type":"array","description":"Array of tools the agent can use. The agent decides which tools to call based on the task","items":{"$ref":"#/components/schemas/AgentTool"}},"type":{"type":"string","enum":["aiagent"]},"tag":{"type":"string","description":"Worker group tag for execution routing. If not set, the AI agent step runs on the flow's tag (default \`flow\`)"},"omit_output_from_conversation":{"type":"boolean","default":false,"description":"If true, this AI agent step does not persist its assistant or tool messages to the flow conversation when chat mode is enabled."},"parallel":{"type":"boolean","description":"If true, the agent can execute multiple tool calls in parallel"}},"required":["tools","type","input_transforms"]},"Identity":{"type":"object","description":"Pass-through module that returns its input unchanged. Useful for flow structure or as a placeholder","properties":{"type":{"type":"string","enum":["identity"]},"flow":{"type":"boolean","description":"If true, marks this as a flow identity (special handling)"}},"required":["type"]},"FlowStatus":{"type":"object","properties":{"step":{"type":"integer"},"modules":{"type":"array","items":{"$ref":"#/components/schemas/FlowStatusModule"}},"user_states":{"additionalProperties":true},"preprocessor_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"}]},"failure_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"},{"type":"object","properties":{"parent_module":{"type":"string"}}}]},"retry":{"type":"object","properties":{"fail_count":{"type":"integer"},"failed_jobs":{"type":"array","items":{"type":"string","format":"uuid"}}}}},"required":["step","modules","failure_module"]},"FlowStatusModule":{"type":"object","properties":{"type":{"type":"string","enum":["WaitingForPriorSteps","WaitingForEvents","WaitingForExecutor","InProgress","Success","Failure"]},"id":{"type":"string"},"job":{"type":"string","format":"uuid"},"count":{"type":"integer"},"progress":{"type":"integer"},"iterator":{"type":"object","properties":{"index":{"type":"integer"},"itered":{"type":"array","items":{}},"itered_len":{"type":"integer"},"args":{}}},"flow_jobs":{"type":"array","items":{"type":"string"}},"flow_jobs_success":{"type":"array","items":{"type":"boolean"}},"flow_jobs_duration":{"type":"object","properties":{"started_at":{"type":"array","items":{"type":"string"}},"duration_ms":{"type":"array","items":{"type":"integer"}}}},"branch_chosen":{"type":"object","properties":{"type":{"type":"string","enum":["branch","default"]},"branch":{"type":"integer"}},"required":["type"]},"branchall":{"type":"object","properties":{"branch":{"type":"integer"},"len":{"type":"integer"}},"required":["branch","len"]},"approvers":{"type":"array","items":{"type":"object","properties":{"resume_id":{"type":"integer"},"approver":{"type":"string"}},"required":["resume_id","approver"]}},"failed_retries":{"type":"array","items":{"type":"string","format":"uuid"}},"skipped":{"type":"boolean"},"agent_actions":{"type":"array","items":{"type":"object","oneOf":[{"type":"object","properties":{"job_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"type":{"type":"string","enum":["tool_call"]},"module_id":{"type":"string"}},"required":["job_id","function_name","type","module_id"]},{"type":"object","properties":{"call_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"resource_path":{"type":"string"},"type":{"type":"string","enum":["mcp_tool_call"]},"arguments":{"type":"object"}},"required":["call_id","function_name","resource_path","type"]},{"type":"object","properties":{"type":{"type":"string","enum":["web_search"]}},"required":["type"]},{"type":"object","properties":{"type":{"type":"string","enum":["message"]}},"required":["content","type"]}]}},"agent_actions_success":{"type":"array","items":{"type":"boolean"}}},"required":["type"]}}`,
   "raw-app": `---
 name: raw-app
 description: MUST use when creating raw apps.
@@ -6924,8 +6940,8 @@ inspect asset-driven pipelines (scripts marked \`// pipeline\`, wired by \`// on
 - \`pipeline show <folder:string>\` - render a pipeline folder's DAG (sources, lineage, subscriptions) in the terminal
   - \`--json\` - Output the raw asset graph as JSON
   - \`--local\` - Build the graph from local working-tree files (// pipeline scripts) instead of the deployed workspace — no deploy needed.
-- \`pipeline run <folder:string>\` - run a bounded cascade: from a schedule/manual root, fan downstream up to the --to end node(s)
-  - \`--from <script:string>\` - Start script (short name or path). Defaults to the folder's sole schedule/manual root.
+- \`pipeline run <folder:string>\` - run a cascade: from --from (a root OR any mid-DAG model), fan downstream up to the --to end node(s)
+  - \`--from <script:string>\` - Start script (short name or path). May be any node, including a mid-DAG model — that node plus its transitive downstream runs, upstream is NOT re-run (dbt \`--select model+\`). Defaults to the folder's sole schedule/manual root.
   - \`--to <node:string>\` - End node(s) to stop at — script names/paths or asset URIs (e.g. datatable://main/staged). Repeatable or comma-separated. Omit to run the full downstream.
   - \`--dry-run\` - Print the topological run plan without executing.
   - \`--json\` - Output the plan as JSON (for piping to jq).
diff --git a/cli/src/utils/upgrade.ts b/cli/src/utils/upgrade.ts
index 44ab0741fd..e72a2a2a93 100644
--- a/cli/src/utils/upgrade.ts
+++ b/cli/src/utils/upgrade.ts
@@ -57,6 +57,64 @@ export class NpmProvider extends Provider {
   async hasRequiredPermissions(): Promise<boolean> {
     return true;
   }
+
+  // Cliffy's default runtime runs `npm install --silent`, so a failed upgrade
+  // throws with an empty message. Override to run npm without --silent and put
+  // the captured output + recovery hint in the error, so failures are actionable.
+  override async upgrade({
+    name,
+    to,
+    main,
+    verbose,
+  }: {
+    name: string;
+    to: string;
+    main?: string;
+    verbose?: boolean;
+  }): Promise<void> {
+    const specifier = this.getSpecifier(name, to, main).replace(/^npm:/, "");
+    const args = ["install", "--global", "--force", specifier];
+    this.logger?.log(`$ npm ${args.join(" ")}`);
+    const { spawn } = await import("node:child_process");
+    const HINT =
+      "If this is a permissions error, retry with sudo, or reinstall with: npm uninstall -g windmill-cli && npm install -g windmill-cli";
+    // `shell: true` so `npm` resolves on Windows (npm.cmd) — same spawn
+    // pattern as commands/app/bundle.ts.
+    const proc = spawn("npm", args, {
+      stdio: [null, "pipe", "pipe"],
+      shell: true,
+    });
+    const output: string[] = [];
+    proc.stdout?.on("data", (d) => {
+      output.push(String(d));
+      if (verbose) process.stdout.write(d);
+    });
+    proc.stderr?.on("data", (d) => {
+      output.push(String(d));
+      if (verbose) process.stderr.write(d);
+    });
+    // `error` fires when npm can't be spawned at all; without a listener that
+    // is an uncaught exception, crashing before any hint prints. `close`
+    // resolves null when npm died from a signal — a failure too.
+    const exitCode: number | null = await new Promise<number | null>(
+      (resolve, reject) => {
+        proc.on("error", reject);
+        proc.on("close", resolve);
+      }
+    ).catch((e) => {
+      throw new Error(
+        `failed to run npm: ${e instanceof Error ? e.message : e}\n\n${HINT}`
+      );
+    });
+    if (exitCode !== 0) {
+      const detail = output.join("").trim();
+      throw new Error(
+        `npm exited with ${
+          exitCode === null ? "a signal" : `code ${exitCode}`
+        }${detail ? `:\n${detail}` : ""}\n\n${HINT}`
+      );
+    }
+  }
 }
 
 type NpmApiPackageMetadata = {
diff --git a/cli/test/duckdb_macros_unit.test.ts b/cli/test/duckdb_macros_unit.test.ts
new file mode 100644
index 0000000000..9ad1fec568
--- /dev/null
+++ b/cli/test/duckdb_macros_unit.test.ts
@@ -0,0 +1,87 @@
+import { expect, test } from "bun:test";
+
+import {
+  detectMacroCalls,
+  parseCreateMacro,
+  parseMacroAnnotations,
+  parseMacroLibrary,
+  splitStatements,
+} from "../src/commands/pipeline/duckdbMacros.ts";
+
+// These mirror the accepted-shape cases of the backend parser
+// (backend/parsers/windmill-parser/src/duckdb_macros.rs) so the local graph
+// derives the same macro registry the server records at deploy.
+
+test("parseCreateMacro: scalar, OR REPLACE / TEMP / TABLE, FUNCTION alias", () => {
+  expect(parseCreateMacro("CREATE MACRO surrogate_key(a, b) AS md5(concat_ws('||', a, b))")).toEqual(
+    { name: "surrogate_key", params: "a, b", isTable: false },
+  );
+  expect(parseCreateMacro("CREATE OR REPLACE TEMP MACRO top_n(t_max) AS TABLE SELECT * FROM t")).toEqual(
+    { name: "top_n", params: "t_max", isTable: true },
+  );
+  // FUNCTION is DuckDB's alias for MACRO; name lowercased
+  expect(parseCreateMacro("create function Dbl(a) as a * 2")).toEqual(
+    { name: "dbl", params: "a", isTable: false },
+  );
+});
+
+test("parseCreateMacro: default params + nested/string parens in the param list", () => {
+  expect(
+    parseCreateMacro("CREATE MACRO safe_div(a, b, fallback := (0)) AS CASE WHEN b = 0 THEN fallback ELSE a / b END")?.params,
+  ).toBe("a, b, fallback := (0)");
+  expect(parseCreateMacro("CREATE MACRO f(sep := '(') AS concat(sep, 'x')")?.params).toBe("sep := '('");
+});
+
+test("parseCreateMacro: rejects non-macro, qualified/quoted names, missing params/body", () => {
+  expect(parseCreateMacro("SELECT 1")).toBeNull();
+  expect(parseCreateMacro("CREATE TABLE t(x int)")).toBeNull();
+  expect(parseCreateMacro("CREATE MACRO lake.m(a) AS a")).toBeNull();
+  expect(parseCreateMacro('CREATE MACRO "weird name"(a) AS a')).toBeNull();
+  expect(parseCreateMacro("CREATE MACRO m AS 1")).toBeNull(); // no params
+  expect(parseCreateMacro("CREATE MACRO m(a) AS")).toBeNull(); // empty body
+  expect(parseCreateMacro("CREATE OR MACRO m(a) AS a")).toBeNull(); // OR without REPLACE
+});
+
+test("splitStatements strips comments/strings and parseMacroLibrary skips setup", () => {
+  const lib = `-- macros
+ATTACH 'x.duckdb' AS ext;
+CREATE MACRO m1(a) AS a; -- inline comment ; not a split
+CREATE MACRO m2(b) AS b + 1;`;
+  expect(splitStatements("SELECT 1; -- c ; still\nSELECT ';' AS x;").length).toBe(2);
+  expect(parseMacroLibrary(lib).map((m) => m.name)).toEqual(["m1", "m2"]);
+});
+
+test("detectMacroCalls: word-boundary, case-insensitive, skips qualified/strings/comments", () => {
+  const ns = new Set(["dbl", "avg_x"]);
+  const found = detectMacroCalls("SELECT DBL(1), my_dbl(2), avg_x (3) FROM t", ns);
+  expect([...found].sort()).toEqual(["avg_x", "dbl"]);
+  expect(detectMacroCalls("SELECT lake.dbl(1)", new Set(["dbl"])).size).toBe(0);
+  expect(detectMacroCalls("SELECT 'dbl(1)'", new Set(["dbl"])).size).toBe(0);
+  expect(detectMacroCalls("-- dbl(1)\nSELECT 1", new Set(["dbl"])).size).toBe(0);
+  expect(detectMacroCalls("SELECT dbl FROM t", new Set(["dbl"])).size).toBe(0); // no call parens
+});
+
+test("parseMacroAnnotations: leading-header only, marker stands alone, `// use` needs a path token", () => {
+  expect(parseMacroAnnotations("-- macros\nCREATE MACRO m(a) AS a;")).toEqual({
+    macros: true,
+    useLibs: [],
+  });
+  // marker with trailing prose is not the macros marker
+  expect(parseMacroAnnotations("-- macros are below\nSELECT 1;").macros).toBe(false);
+  // `// use` accumulates path-shaped tokens, dedups, and stops at the body
+  expect(
+    parseMacroAnnotations("-- pipeline\n-- use f/lib/a\n-- use f/lib/a\n-- use notapath\nSELECT 1;").useLibs,
+  ).toEqual(["f/lib/a"]);
+  // an annotation after code is ignored (leading header only)
+  expect(parseMacroAnnotations("SELECT 1;\n-- use f/lib/a").useLibs).toEqual([]);
+});
+
+test("parseMacroAnnotations accepts `//`, `--`, and `#` prefixes (backend parity, any language)", () => {
+  // The canonical backend parser strips `//`/`--`/`#` regardless of language, so
+  // a DuckDB library headed with `// macros` (not `-- macros`) must be detected.
+  expect(parseMacroAnnotations("// macros\nCREATE MACRO m(a) AS a;").macros).toBe(true);
+  expect(parseMacroAnnotations("# macros\nSELECT 1;").macros).toBe(true);
+  expect(parseMacroAnnotations("// use f/lib/a\nSELECT 1;").useLibs).toEqual(["f/lib/a"]);
+  // mixed prefixes in one header both register
+  expect(parseMacroAnnotations("// pipeline\n-- use f/lib/a\nSELECT 1;").useLibs).toEqual(["f/lib/a"]);
+});
diff --git a/cli/test/init_template_unit.test.ts b/cli/test/init_template_unit.test.ts
index e7d69c2184..227fc271a2 100644
--- a/cli/test/init_template_unit.test.ts
+++ b/cli/test/init_template_unit.test.ts
@@ -25,25 +25,46 @@ describe("generateCommentedTemplate", () => {
     expect(typeof config).toBe("object");
   });
 
-  test("uses provided branch name in workspaces", () => {
-    const config = parse(generateCommentedTemplate("my-feature"));
-    expect(config.workspaces["my-feature"]).toBeDefined();
+  // Without bindings, `workspaces` must stay EMPTY (a live `<branch>: {}`
+  // placeholder is unresolvable — no baseUrl — yet counts as a configured
+  // workspace, breaking auto-selection and making a later bind ambiguous).
+  // The branch name only appears in the commented example.
+  test("uses provided branch name in the commented workspaces example only", () => {
+    const yaml = generateCommentedTemplate("my-feature");
+    const config = parse(yaml);
+    expect(config.workspaces).toEqual({});
+    expect(yaml).toContain("# my-feature:");
   });
 
   test("defaults to 'main' when no branch name given", () => {
-    const config = parse(generateCommentedTemplate());
-    expect(config.workspaces["main"]).toBeDefined();
+    const yaml = generateCommentedTemplate();
+    const config = parse(yaml);
+    expect(config.workspaces).toEqual({});
+    expect(yaml).toContain("# main:");
   });
 
   test("quotes branch names with YAML-special characters", () => {
     const specialBranches = ["fix: something", "feat/my branch", "release#1"];
     for (const branch of specialBranches) {
       const yaml = generateCommentedTemplate(branch);
+      // Still valid YAML with an empty workspaces map; the (quoted) branch
+      // name only appears in comments.
       const config = parse(yaml);
-      expect(config.workspaces[branch]).toBeDefined();
+      expect(config.workspaces).toEqual({});
+      expect(yaml).toContain(branch);
     }
   });
 
+  test("renders live workspaces entries when bindings are provided", () => {
+    const yaml = generateCommentedTemplate("main", undefined, [
+      { name: "prod", baseUrl: "https://app.windmill.dev/", workspaceId: "prod-ws" },
+    ]);
+    const config = parse(yaml);
+    expect(config.workspaces["prod"]).toBeDefined();
+    expect(config.workspaces["prod"].baseUrl).toBe("https://app.windmill.dev/");
+    expect(config.workspaces["prod"].workspaceId).toBe("prod-ws");
+  });
+
   test("contains yaml-language-server schema directive", () => {
     const yaml = generateCommentedTemplate("main");
     expect(yaml.startsWith("# yaml-language-server: $schema=wmill.schema.json")).toBe(true);
diff --git a/cli/test/parser_packages_unit.test.ts b/cli/test/parser_packages_unit.test.ts
new file mode 100644
index 0000000000..4270a4996e
--- /dev/null
+++ b/cli/test/parser_packages_unit.test.ts
@@ -0,0 +1,40 @@
+import { expect, test } from "bun:test";
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+// build-npm.ts derives the published CLI's parser dependencies from
+// package.json, so a parser package that src/ loads but package.json omits
+// ships a CLI where loadParser() throws and callers silently degrade.
+
+const cliRoot = join(import.meta.dir, "..");
+
+function collectSourceFiles(dir: string, out: string[] = []): string[] {
+  for (const entry of readdirSync(dir)) {
+    const p = join(dir, entry);
+    if (statSync(p).isDirectory()) collectSourceFiles(p, out);
+    else if (p.endsWith(".ts")) out.push(p);
+  }
+  return out;
+}
+
+test("every windmill-parser-wasm-* package referenced in src/ is a declared dependency", () => {
+  const deps: Record<string, string> =
+    JSON.parse(readFileSync(join(cliRoot, "package.json"), "utf-8"))
+      .dependencies ?? {};
+
+  const referenced = new Set<string>();
+  for (const file of collectSourceFiles(join(cliRoot, "src"))) {
+    for (const m of readFileSync(file, "utf-8").matchAll(
+      /"(windmill-parser-wasm-[a-z-]+)"/g,
+    )) {
+      referenced.add(m[1]);
+    }
+  }
+
+  // Sanity: the scan must see the known call sites, else the regex went stale.
+  expect(referenced.has("windmill-parser-wasm-ts")).toBe(true);
+  expect(referenced.has("windmill-parser-wasm-asset")).toBe(true);
+
+  const missing = [...referenced].filter((p) => !(p in deps)).sort();
+  expect(missing).toEqual([]);
+});
diff --git a/cli/test/pipeline_bounded_cascade_unit.test.ts b/cli/test/pipeline_bounded_cascade_unit.test.ts
index 271d231839..06781e0c6a 100644
--- a/cli/test/pipeline_bounded_cascade_unit.test.ts
+++ b/cli/test/pipeline_bounded_cascade_unit.test.ts
@@ -15,6 +15,7 @@ import {
   scriptsOf,
   topoOrder,
   validStarts,
+  validFromStarts,
   nonAutorunTriggerScripts,
   reachableCutting,
   isScriptNode,
@@ -154,6 +155,58 @@ test("a scheduled root with a secondary data_upload trigger stays a start and is
   expect(sel.has("consumer")).toBe(true); // …and its downstream isn't cut off
 });
 
+test("validFromStarts: mid-DAG models are eligible starts, event/upload/webhook are not", () => {
+  // a(root) → x → sub → y → reader ; k=kafka, upl=data_upload, hook=webhook.
+  const g = graph({
+    scripts: ["a", "sub", "reader", "k", "upl", "hook"],
+    writes: [["a", "x"], ["sub", "y"]],
+    reads: [["reader", "y"]],
+    subs: [["sub", "x"]],
+    native: [["kafka", "k"], ["data_upload", "upl"], ["webhook", "hook"]],
+  });
+  const from = validFromStarts(g);
+  expect(from.has(sn("a"))).toBe(true); // root
+  expect(from.has(sn("sub"))).toBe(true); // mid-DAG subscriber — NOT a validStart
+  expect(from.has(sn("reader"))).toBe(true); // pure reader
+  expect(validStarts(g).has(sn("sub"))).toBe(false); // old root-only gate rejected it
+  // Non-autorun handlers stay out (they need caller input / fan out per event).
+  expect(from.has(sn("k"))).toBe(false);
+  expect(from.has(sn("upl"))).toBe(false);
+  expect(from.has(sn("hook"))).toBe(false);
+});
+
+test("validFromStarts keeps a scheduled root that also carries a non-autorun trigger", () => {
+  // Regression: `--from sched_upload` must be accepted just like the implicit
+  // start. `sched_upload` is a scheduled root AND a data_upload handler — schedule
+  // wins in validStarts, so it stays --from-eligible despite being a nonAutorun
+  // handler (else explicit --from throws where the implicit start succeeds).
+  const g = graph({
+    scripts: ["sched_upload", "consumer"],
+    writes: [["sched_upload", "x"]],
+    subs: [["consumer", "x"]],
+    native: [["schedule", "sched_upload"], ["data_upload", "sched_upload"]],
+  });
+  expect(validStarts(g).has(sn("sched_upload"))).toBe(true);
+  expect(nonAutorunTriggerScripts(g).has(sn("sched_upload"))).toBe(true);
+  expect(validFromStarts(g).has(sn("sched_upload"))).toBe(true); // union with roots
+});
+
+test("a mid-DAG start runs itself + downstream, never upstream", () => {
+  // Starting at `sub`, the unbounded downstream is {sub, reader}; `a`/`x` upstream
+  // are never pulled in (dbt `--select sub+`).
+  const g = graph({
+    scripts: ["a", "sub", "reader"],
+    writes: [["a", "x"], ["sub", "y"]],
+    reads: [["reader", "y"]],
+    subs: [["sub", "x"]],
+  });
+  const dag = buildLineageDag(g);
+  const downstream = new Set([sn("sub"), ...descendants(dag, sn("sub"))]);
+  expect(sorted(scriptsOf(downstream))).toEqual(["reader", "sub"]);
+  expect(downstream.has(sn("a"))).toBe(false);
+  expect(downstream.has("datatable:x")).toBe(false);
+});
+
 test("nonAutorunTriggerScripts: event + upload/webhook handlers, incl. subscribers (descendants)", () => {
   const g = graph({
     scripts: ["a", "evt", "upl"],
@@ -203,6 +256,18 @@ test("assetUriToNodeId maps s3 → s3object, others verbatim", () => {
   expect(assetUriToNodeId("nope")).toBe(undefined);
 });
 
+test("assetUriToNodeId strips leading slashes from S3 keys (canonical node)", () => {
+  // Mirror of Rust `parse_asset_syntax`: `--to s3:///exports/x` must resolve to
+  // the same canonical node as the graph's `s3object:exports/x`.
+  expect(assetUriToNodeId("s3:///exports/x")).toBe("s3object:exports/x");
+  expect(assetUriToNodeId("s3:///exports/x")).toBe(assetUriToNodeId("s3://exports/x"));
+  // All leading slashes stripped so a canonical key never starts with `/`
+  // (the quad-slash `S3Object(s3="/x")` form collapses to `x`).
+  expect(assetUriToNodeId("s3:////x")).toBe("s3object:x");
+  // Hive-partition keys and non-S3 kinds are untouched.
+  expect(assetUriToNodeId("s3:///t/y=2024/f.parquet")).toBe("s3object:t/y=2024/f.parquet");
+});
+
 test("resolveToken: short name, full path, and asset URI", () => {
   const g = graph({ scripts: ["f/p/stage"], writes: [["f/p/stage", "main/staged"]] });
   g.assets = [{ kind: "datatable", path: "main/staged" }];
diff --git a/cli/test/pipeline_local_graph_unit.test.ts b/cli/test/pipeline_local_graph_unit.test.ts
index 1368e14504..9b0c88ea11 100644
--- a/cli/test/pipeline_local_graph_unit.test.ts
+++ b/cli/test/pipeline_local_graph_unit.test.ts
@@ -143,6 +143,153 @@ test("`// materialize <asset>` producer connects to its `// on` consumer", async
   );
 });
 
+test("HD-1: `// data_test relationships` adds a producer → tested-script ordering edge", async () => {
+  // Mirror of the deployed graph's `test_edges` (backend `asset_graph`): the
+  // referenced dimension's in-pipeline producer must materialize before the
+  // tested script runs, so a cold cascade orders it first. The wasm emits the
+  // parsed `relationships` test; the local builder resolves its producer.
+  await withFolder(
+    {
+      "dim_customers.duckdb.sql":
+        `-- pipeline\n-- materialize ducklake://main/dim_customers\nSELECT 1 AS id;\n`,
+      "fct_orders_daily.duckdb.sql":
+        `-- pipeline\n-- on ducklake://main/orders\n-- data_test relationships customer_id -> ducklake://main/dim_customers.id\nSELECT customer_id FROM main.orders;\n`,
+    },
+    async (root, folder) => {
+      const { graph } = await buildLocalPipelineGraph({ root, folder, defaultTs: "bun" });
+      expect(graph.test_edges).toEqual([
+        {
+          producer_kind: "script",
+          producer_path: "f/mypipe/dim_customers",
+          runnable_kind: "script",
+          runnable_path: "f/mypipe/fct_orders_daily",
+          asset_kind: "ducklake",
+          asset_path: "main/dim_customers",
+        },
+      ]);
+    },
+  );
+});
+
+test("HD-1: a relationships ref to an asset with no in-pipeline producer adds no edge", async () => {
+  // No producer (external / not-yet-in-pipeline table) ⇒ no ordering edge — the
+  // runtime error stands, exactly like the backend (`test_edges` stays empty and
+  // is omitted from the graph).
+  await withFolder(
+    {
+      "fct.duckdb.sql":
+        `-- pipeline\n-- on ducklake://main/orders\n-- data_test relationships customer_id -> ducklake://main/external_dim.id\nSELECT customer_id FROM main.orders;\n`,
+    },
+    async (root, folder) => {
+      const { graph } = await buildLocalPipelineGraph({ root, folder, defaultTs: "bun" });
+      expect(graph.test_edges).toBeUndefined();
+    },
+  );
+});
+
+test("HD-1: a self-test (relationships on the script's own materialize output) is dropped", async () => {
+  // The tested script produces the very asset it references — the backend's
+  // self-edge guard drops it, and so must the local builder (no self-ordering).
+  await withFolder(
+    {
+      "dim.duckdb.sql":
+        `-- pipeline\n-- materialize ducklake://main/dim\n-- data_test relationships id -> ducklake://main/dim.id\nSELECT 1 AS id;\n`,
+    },
+    async (root, folder) => {
+      const { graph } = await buildLocalPipelineGraph({ root, folder, defaultTs: "bun" });
+      expect(graph.test_edges).toBeUndefined();
+    },
+  );
+});
+
+test("HD-1: a custom `// data_test <script>` whose body reads an in-pipeline asset orders it (best-effort)", async () => {
+  // Escape-hatch test: the tested member declares `// data_test f/mypipe/test_dim`;
+  // that script reads `s3://demo/dim.parquet`, which a pipeline member produces.
+  // The producer must run before the tested script, so the custom test resolves
+  // to a producer → tested-script edge through the shared asset (mirrors the
+  // backend resolving custom tests against the script's parsed reads).
+  await withFolder(
+    {
+      // producer writes the S3 asset the custom test reads
+      "export_dim.duckdb.sql":
+        `-- pipeline\nCOPY (SELECT 1 AS id) TO 's3://demo/dim.parquet';\n`,
+      // the escape-hatch test script (NOT a pipeline member) reads that asset
+      "test_dim.duckdb.sql":
+        `SELECT * FROM read_parquet('s3://demo/dim.parquet') WHERE id IS NULL;\n`,
+      // the tested member points at the custom test
+      "fct.duckdb.sql":
+        `-- pipeline\n-- on ducklake://main/orders\n-- data_test f/mypipe/test_dim\nSELECT 1 AS id;\n`,
+    },
+    async (root, folder) => {
+      const { graph } = await buildLocalPipelineGraph({ root, folder, defaultTs: "bun" });
+      expect(graph.test_edges).toEqual([
+        {
+          producer_kind: "script",
+          producer_path: "f/mypipe/export_dim",
+          runnable_kind: "script",
+          runnable_path: "f/mypipe/fct",
+          asset_kind: "s3object",
+          asset_path: "demo/dim.parquet",
+        },
+      ]);
+    },
+  );
+});
+
+test("HD-2: an scd2 `history` producer writes both `<dim>` and `<dim>_current` so a `_current` reader resolves to it", async () => {
+  // Managed `// materialize … history` (scd2) also produces a `<dim>_current`
+  // companion view (backend `MaterializeSpec::write_targets`). The wasm asset
+  // parser emits the `scd2` flag; the local builder must add the second write
+  // edge and mark the view `derived_from` its base dimension so a consumer
+  // reading only the view links back to the producer instead of orphaning.
+  await withFolder(
+    {
+      "dim.duckdb.sql":
+        `-- pipeline\n-- materialize ducklake://main/dim_customers key=id history\nSELECT 1 AS id;\n`,
+      // a consumer reading ONLY the `_current` companion view
+      "consume.duckdb.sql":
+        `-- pipeline\n-- on ducklake://main/dim_customers_current\nSELECT * FROM main.dim_customers_current;\n`,
+    },
+    async (root, folder) => {
+      const { graph } = await buildLocalPipelineGraph({
+        root,
+        folder,
+        defaultTs: "bun",
+      });
+
+      // the producer carries BOTH write edges (base dim + `_current` companion)
+      const writes = graph.edges
+        .filter(
+          (e) =>
+            e.runnable_path === "f/mypipe/dim" && e.access_type === "w",
+        )
+        .map((e) => e.asset_path)
+        .sort();
+      expect(writes).toEqual(["main/dim_customers", "main/dim_customers_current"]);
+
+      // the strategy is derived as scd2 on the producer node
+      expect(
+        graph.runnables.find((r) => r.path === "f/mypipe/dim")?.materialize_strategy,
+      ).toBe("scd2");
+
+      // the `_current` asset is marked as derived from its base dimension, so the
+      // canvas renders it as a companion view rather than an orphan table
+      expect(graph.assets).toContainEqual({
+        kind: "ducklake",
+        path: "main/dim_customers_current",
+        derived_from: "main/dim_customers",
+      });
+
+      // the `_current` reader's `// on` trigger points at the same node the
+      // producer now writes — no orphaned read
+      const at = graph.triggers.find(
+        (t) => t.trigger_kind === "asset" && t.runnable_path === "f/mypipe/consume",
+      ) as Extract<(typeof graph.triggers)[number], { trigger_kind: "asset" }> | undefined;
+      expect(at?.asset_path).toBe("main/dim_customers_current");
+    },
+  );
+});
+
 test("a bare `.sql` (ambiguous dialect) is skipped, not a build-aborting crash", async () => {
   // `inferContentTypeFromFilePath` throws on a dialect-less `.sql`; one such file
   // must not abort the whole graph build (it also wedged `pipeline dev` at start).
@@ -214,6 +361,32 @@ test("go/bash fallback: leading-header `// on` only, options stripped, no body p
   );
 });
 
+test("go/bash fallback: `// on s3:///key` canonicalizes to the slashless key", async () => {
+  // Mirror of the Rust/wasm `parse_asset_syntax` S3 strip: a fallback consumer's
+  // triple-slash default-storage trigger must resolve to the bare key `exports/x`
+  // — the same identity a wasm-inferred SDK/DuckDB producer uses — or the local
+  // graph shows a disconnected `/exports/x` node. Explicit storage is untouched.
+  await withFolder(
+    {
+      "triple.go": `// pipeline\n// on s3:///exports/x\npackage inner\nfunc main() {}\n`,
+      "bare.go": `// pipeline\n// on s3://exports/x\npackage inner\nfunc main() {}\n`,
+      "storage.go": `// pipeline\n// on s3://mybucket/exports/x\npackage inner\nfunc main() {}\n`,
+    },
+    async (root, folder) => {
+      const { graph } = await buildLocalPipelineGraph({ root, folder, defaultTs: "bun" });
+      const pathFor = (p: string) =>
+        graph.triggers.find(
+          (t) => t.trigger_kind === "asset" && t.runnable_path === p
+        ) as Extract<(typeof graph.triggers)[number], { trigger_kind: "asset" }> | undefined;
+      // triple-slash and bare both canonicalize to `exports/x` → same node
+      expect(pathFor("f/mypipe/triple")?.asset_path).toBe("exports/x");
+      expect(pathFor("f/mypipe/bare")?.asset_path).toBe("exports/x");
+      // explicit storage keeps its `storage/key` path (no leading slash to strip)
+      expect(pathFor("f/mypipe/storage")?.asset_path).toBe("mybucket/exports/x");
+    },
+  );
+});
+
 test("go/bash fallback: a native marker with trailing content is rejected (parity)", async () => {
   // The canonical parser rejects a marker line with trailing content, so the
   // fallback must too — else a `// on data_upload f/foo` / `# on kafka topic`
@@ -286,6 +459,300 @@ test("`# volume:` producer connects to its `# on volume://` consumer", async ()
   );
 });
 
+test("`// macros` library: node with signatures + call-detected consumer edge, counted", async () => {
+  // The wasm asset parser drops `// macros`/`// use`; the CLI-side lexical scan
+  // must surface the library node, its macro signatures, and the caller edge so
+  // `--local` reaches parity with the deployed graph.
+  await withFolder(
+    {
+      "macros_finance.duckdb.sql":
+        `-- macros\nCREATE MACRO net_revenue(gross, refunds) AS gross - refunds;\nCREATE OR REPLACE MACRO safe_div(a, b) AS TABLE SELECT a / b;\n`,
+      "fct.duckdb.sql":
+        `-- pipeline\n-- on datatable://main/orders\nSELECT net_revenue(gross, refunds) AS rev FROM main.orders;\n`,
+    },
+    async (root, folder) => {
+      const { graph } = await buildLocalPipelineGraph({ root, folder, defaultTs: "bun" });
+
+      // the library is a node carrying its macro signatures
+      const lib = graph.runnables.find((r) => r.path === "f/mypipe/macros_finance");
+      expect(lib?.macros).toEqual([
+        { name: "net_revenue", params: "gross, refunds", is_table: false },
+        { name: "safe_div", params: "a, b", is_table: true },
+      ]);
+
+      // library counts toward the script total (2 scripts, not just the 1 pipeline member)
+      expect(graph.runnables.map((r) => r.path).sort()).toEqual([
+        "f/mypipe/fct",
+        "f/mypipe/macros_finance",
+      ]);
+
+      // the caller edge names only the macro actually called (safe_div is not)
+      expect(graph.macro_edges).toEqual([
+        {
+          lib_path: "f/mypipe/macros_finance",
+          consumer_path: "f/mypipe/fct",
+          macro_names: ["net_revenue"],
+          via_use: false,
+        },
+      ]);
+    },
+  );
+});
+
+test("`// use <lib>` forces a whole-library edge even with no lexical call", async () => {
+  // Dynamic-SQL callers annotate `// use`; the edge lists every macro and is
+  // flagged via_use (mirrors the deployed graph).
+  await withFolder(
+    {
+      "stats.duckdb.sql":
+        `-- macros\nCREATE MACRO zscore(x, m, s) AS (x - m) / s;\n`,
+      "report.duckdb.sql":
+        `-- pipeline\n-- on datatable://main/metrics\n-- use f/mypipe/stats\nSELECT query('SELECT zscore(v, 0, 1) FROM main.metrics');\n`,
+    },
+    async (root, folder) => {
+      const { graph } = await buildLocalPipelineGraph({ root, folder, defaultTs: "bun" });
+      expect(graph.macro_edges).toEqual([
+        {
+          lib_path: "f/mypipe/stats",
+          consumer_path: "f/mypipe/report",
+          macro_names: ["zscore"],
+          via_use: true,
+        },
+      ]);
+      // the library still becomes a node
+      expect(graph.runnables.some((r) => r.path === "f/mypipe/stats")).toBe(true);
+    },
+  );
+});
+
+test("an UNUSED in-folder `// macros` library is still a member node (deployed parity)", async () => {
+  // The deployed graph marks every macro library `auto_kind='pipeline'`, so an
+  // in-folder library is a member node (in_pipeline, with signatures) whether or
+  // not a consumer uses it. It is still excluded from runs (via `macros`).
+  await withFolder(
+    {
+      "unused.duckdb.sql": `-- macros\nCREATE MACRO helper(a) AS a + 1;\n`,
+      "solo.duckdb.sql": `-- pipeline\nSELECT 1;\n`,
+    },
+    async (root, folder) => {
+      const { graph, scripts } = await buildLocalPipelineGraph({ root, folder, defaultTs: "bun" });
+      const lib = graph.runnables.find((r) => r.path === "f/mypipe/unused");
+      expect(lib?.in_pipeline).toBe(true);
+      expect(lib?.macros).toEqual([{ name: "helper", params: "a", is_table: false }]);
+      expect(graph.macro_edges).toBeUndefined();
+      // but it is not a previewable/runnable script — only `solo` is
+      expect(scripts.map((s) => s.path)).toEqual(["f/mypipe/solo"]);
+    },
+  );
+});
+
+test("a shared macro library OUTSIDE the pipeline folder is resolved (workspace-wide)", async () => {
+  // The deployed graph loads the macro registry workspace-wide and only
+  // folder-scopes consumers, so a pipeline in `f/mypipe` can use a shared library
+  // in `f/shared`. Local discovery must walk the whole `f/` tree, not just the
+  // folder, or the edge/node/docs are missing (parity gap).
+  const root = mkdtempSync(join(tmpdir(), "wm-pl-"));
+  writeFileSync(join(root, "wmill.yaml"), "defaultTs: bun\n");
+  mkdirSync(join(root, "f", "shared"), { recursive: true });
+  mkdirSync(join(root, "f", "mypipe"), { recursive: true });
+  writeFileSync(
+    join(root, "f", "shared", "stats.duckdb.sql"),
+    `-- macros\nCREATE MACRO zscore(x, m, s) AS (x - m) / s;\n`,
+  );
+  // one consumer calls the shared macro lexically, another pulls it via `// use`
+  writeFileSync(
+    join(root, "f", "mypipe", "fct.duckdb.sql"),
+    `-- pipeline\n-- on datatable://main/metrics\nSELECT zscore(v, 0, 1) FROM main.metrics;\n`,
+  );
+  writeFileSync(
+    join(root, "f", "mypipe", "dyn.duckdb.sql"),
+    `-- pipeline\n-- on datatable://main/metrics\n-- use f/shared/stats\nSELECT query('SELECT zscore(v, 0, 1)');\n`,
+  );
+  try {
+    const { graph } = await buildLocalPipelineGraph({ root, folder: "mypipe", defaultTs: "bun" });
+    expect(graph.macro_edges).toEqual([
+      {
+        lib_path: "f/shared/stats",
+        consumer_path: "f/mypipe/dyn",
+        macro_names: ["zscore"],
+        via_use: true,
+      },
+      {
+        lib_path: "f/shared/stats",
+        consumer_path: "f/mypipe/fct",
+        macro_names: ["zscore"],
+        via_use: false,
+      },
+    ]);
+    // the out-of-folder library is surfaced as a node with its signatures
+    expect(graph.runnables.find((r) => r.path === "f/shared/stats")?.macros).toEqual([
+      { name: "zscore", params: "x, m, s", is_table: false },
+    ]);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("macro library that CONSUMES another library gets a lib→lib edge (both nodes surface)", async () => {
+  // The deploy path records macro_usage for any DuckDB script, including a macro
+  // library calling another library's macros. A `base → derived` edge must exist
+  // (and `base`, an in-folder library, is a member node not just an edge stub).
+  await withFolder(
+    {
+      "base.duckdb.sql": `-- macros\nCREATE MACRO base_add(a, b) AS a + b;\n`,
+      // derived is a `// macros` library (NOT `// pipeline`) whose body calls base_add
+      "derived.duckdb.sql":
+        `-- macros\nCREATE MACRO derived_sum(a, b) AS base_add(a, b) * 2;\n`,
+      // the pipeline consumer calls derived_sum
+      "report.duckdb.sql":
+        `-- pipeline\n-- on datatable://main/t\nSELECT derived_sum(x, y) FROM main.t;\n`,
+    },
+    async (root, folder) => {
+      const { graph } = await buildLocalPipelineGraph({ root, folder, defaultTs: "bun" });
+      expect(graph.macro_edges).toEqual([
+        // base → derived: the intermediate library is itself a consumer
+        {
+          lib_path: "f/mypipe/base",
+          consumer_path: "f/mypipe/derived",
+          macro_names: ["base_add"],
+          via_use: false,
+        },
+        // derived → report: the pipeline consumer
+        {
+          lib_path: "f/mypipe/derived",
+          consumer_path: "f/mypipe/report",
+          macro_names: ["derived_sum"],
+          via_use: false,
+        },
+      ]);
+      // both libraries surface as nodes with their signatures (base does NOT
+      // disappear just because it is only reached transitively)
+      expect(graph.runnables.find((r) => r.path === "f/mypipe/base")?.macros).toEqual([
+        { name: "base_add", params: "a, b", is_table: false },
+      ]);
+      expect(graph.runnables.find((r) => r.path === "f/mypipe/derived")?.macros).toEqual([
+        { name: "derived_sum", params: "a, b", is_table: false },
+      ]);
+      // both intermediate libraries are members (in_pipeline), like the deployed graph
+      expect(graph.runnables.find((r) => r.path === "f/mypipe/base")?.in_pipeline).toBe(true);
+      expect(graph.runnables.find((r) => r.path === "f/mypipe/derived")?.in_pipeline).toBe(true);
+    },
+  );
+});
+
+test("macro library reaching another only via dynamic SQL gets a `// use` lib→lib edge", async () => {
+  // A library that calls another's macro only inside a `query('…')` string is
+  // invisible to lexical detection; `// use` forces the lib→lib edge. Exercises
+  // the case where the CONSUMER is itself a `// macros` library.
+  await withFolder(
+    {
+      "base.duckdb.sql": `-- macros\nCREATE MACRO base_add(a, b) AS a + b;\n`,
+      "derived.duckdb.sql":
+        `-- macros\n-- use f/mypipe/base\nCREATE MACRO wrap(a, b) AS query('SELECT base_add(1, 2)');\n`,
+      "report.duckdb.sql":
+        `-- pipeline\n-- on datatable://main/t\nSELECT wrap(x, y) FROM main.t;\n`,
+    },
+    async (root, folder) => {
+      const { graph } = await buildLocalPipelineGraph({ root, folder, defaultTs: "bun" });
+      expect(graph.macro_edges).toEqual([
+        // base → derived comes from `// use` (via_use), NOT a lexical call
+        {
+          lib_path: "f/mypipe/base",
+          consumer_path: "f/mypipe/derived",
+          macro_names: ["base_add"],
+          via_use: true,
+        },
+        {
+          lib_path: "f/mypipe/derived",
+          consumer_path: "f/mypipe/report",
+          macro_names: ["wrap"],
+          via_use: false,
+        },
+      ]);
+    },
+  );
+});
+
+test("a `// macros` (slash-prefix) DuckDB library is detected (backend prefix parity)", async () => {
+  // A `.duckdb.sql` library may head its annotation with `// macros` (the backend
+  // accepts `//`/`--`/`#` for any language); the local scan must too.
+  await withFolder(
+    {
+      "lib.duckdb.sql": `// macros\nCREATE MACRO dbl(a) AS a * 2;\n`,
+      "use_it.duckdb.sql": `-- pipeline\n-- on datatable://main/t\nSELECT dbl(x) FROM main.t;\n`,
+    },
+    async (root, folder) => {
+      const { graph } = await buildLocalPipelineGraph({ root, folder, defaultTs: "bun" });
+      expect(graph.macro_edges).toEqual([
+        {
+          lib_path: "f/mypipe/lib",
+          consumer_path: "f/mypipe/use_it",
+          macro_names: ["dbl"],
+          via_use: false,
+        },
+      ]);
+      expect(graph.runnables.find((r) => r.path === "f/mypipe/lib")?.macros).toEqual([
+        { name: "dbl", params: "a", is_table: false },
+      ]);
+    },
+  );
+});
+
+test("a non-pipeline DuckDB macro consumer is a display-only node, never a run step", async () => {
+  // A `.duckdb.sql` helper that calls a macro but isn't `// pipeline` surfaces as
+  // a graph node (lineage parity) but is NOT a runnable pipeline script: it must
+  // be absent from `scripts` (the previewable set `run --local` selects from), so
+  // it can never be scheduled or fail a preview for lack of local content.
+  await withFolder(
+    {
+      "lib.duckdb.sql": `-- macros\nCREATE MACRO dbl(a) AS a * 2;\n`,
+      "helper.duckdb.sql": `-- on ducklake://main/src\nSELECT dbl(x) FROM main.src;\n`,
+      "root.duckdb.sql": `-- pipeline\n-- materialize ducklake://main/out\nSELECT dbl(1) AS v;\n`,
+    },
+    async (root, folder) => {
+      const { graph, scripts } = await buildLocalPipelineGraph({ root, folder, defaultTs: "bun" });
+
+      // the helper IS a node (macro consumer, for lineage display) …
+      const helper = graph.runnables.find((r) => r.path === "f/mypipe/helper");
+      expect(helper).toBeDefined();
+      // … but not a pipeline member (no local file to preview) and carries no macros
+      expect(helper?.in_pipeline).toBeFalsy();
+      expect(helper?.macros).toBeUndefined();
+      // the previewable set (what `run --local` can schedule) is ONLY the member
+      expect(scripts.map((s) => s.path)).toEqual(["f/mypipe/root"]);
+      // and the macro edge still connects lib → helper for the lineage view
+      expect(graph.macro_edges).toContainEqual({
+        lib_path: "f/mypipe/lib",
+        consumer_path: "f/mypipe/helper",
+        macro_names: ["dbl"],
+        via_use: false,
+      });
+    },
+  );
+});
+
+test("`// pipeline` on a macros library is redundant — it's a library node either way", async () => {
+  // The backend marks a macro library `auto_kind='pipeline'` regardless of the
+  // `// pipeline` marker, so a `-- pipeline -- macros` script behaves exactly like
+  // a plain `-- macros` one: a member library node (in_pipeline + signatures),
+  // excluded from runs (via `macros`) and from the previewable `scripts` set.
+  await withFolder(
+    {
+      "lib.duckdb.sql": `-- pipeline\n-- macros\nCREATE MACRO dbl(a) AS a * 2;\n`,
+      "root.duckdb.sql": `-- pipeline\n-- materialize ducklake://main/out\nSELECT 1 AS v;\n`,
+    },
+    async (root, folder) => {
+      const { graph, scripts } = await buildLocalPipelineGraph({ root, folder, defaultTs: "bun" });
+      const lib = graph.runnables.find((r) => r.path === "f/mypipe/lib");
+      expect(lib?.in_pipeline).toBe(true);
+      expect(lib?.macros).toEqual([{ name: "dbl", params: "a", is_table: false }]);
+      // unused here → no edges, but still a node; not previewable/runnable
+      expect(graph.macro_edges).toBeUndefined();
+      expect(scripts.map((s) => s.path)).toEqual(["f/mypipe/root"]);
+    },
+  );
+});
+
 test("`#`-comment languages (ruby) use the `#` annotation fallback (no wasm parser)", async () => {
   await withFolder(
     { "ingest.rb": `# pipeline\n# on s3://demo/raw.csv\nputs "hi"\n` },
@@ -300,3 +767,35 @@ test("`#`-comment languages (ruby) use the `#` annotation fallback (no wasm pars
     },
   );
 });
+
+test("pipeline docs renders a `Macro libraries` section (call + `// use`)", async () => {
+  const { generatePipelineMarkdown } = await import(
+    "../src/commands/pipeline/docs.ts"
+  );
+  await withFolder(
+    {
+      "macros_finance.duckdb.sql":
+        `-- macros\nCREATE MACRO net_revenue(gross, refunds) AS gross - refunds;\nCREATE MACRO safe_div(a, b) AS TABLE SELECT a / b;\n`,
+      "fct.duckdb.sql":
+        `-- pipeline\n-- on datatable://main/orders\nSELECT net_revenue(gross, refunds) FROM main.orders;\n`,
+      "report.duckdb.sql":
+        `-- pipeline\n-- on datatable://main/orders\n-- use f/mypipe/macros_finance\nSELECT query('SELECT safe_div(1, 2)');\n`,
+    },
+    async (root, folder) => {
+      const { graph } = await buildLocalPipelineGraph({ root, folder, defaultTs: "bun" });
+      const md = generatePipelineMarkdown(folder, graph, [], true);
+
+      // count line mentions the library; two pipeline scripts, one library
+      expect(md).toContain("**2** scripts · **1** asset · **1** macro library");
+      // dedicated section with signatures (TABLE marker) and callers
+      expect(md).toContain("## Macro libraries");
+      expect(md).toContain("### `f/mypipe/macros_finance`");
+      expect(md).toContain("- `net_revenue(gross, refunds)`");
+      expect(md).toContain("- `safe_div(a, b)` → TABLE");
+      expect(md).toContain("`f/mypipe/fct` (calls `net_revenue`)");
+      expect(md).toContain("`f/mypipe/report` (via `// use`)");
+      // the library is NOT double-listed under `## Scripts`
+      expect(md).not.toContain("### `f/mypipe/macros_finance`\n\n- **");
+    },
+  );
+});
diff --git a/docs/ducklake-materialization.md b/docs/ducklake-materialization.md
index 4481d7555b..50e7c21de0 100644
--- a/docs/ducklake-materialization.md
+++ b/docs/ducklake-materialization.md
@@ -2,7 +2,10 @@
 
 Design sketch for "managed, versioned, incremental" assets built on the
 DuckLake substrate. This is a companion to [`pipelines-vs-dbt.md`](./pipelines-vs-dbt.md)
-and extends its **Path C (hybrid, partition-first)** recommendation. The new
+and extends its **Path C (hybrid, partition-first)** recommendation. For the
+extract-load side that feeds these materializations, see §"Ingestion (EL)"
+at the end of this doc (user-facing guide: windmilldocs
+`core_concepts/63_pipelines` → "Ingestion (EL)"). The new
 contribution here is leveraging DuckLake's snapshot/time-travel layer, which
 the earlier doc's incremental deep-dive did not use. The annotation grammar is
 reconciled with that doc — `// partitioned` + `// unique_key` + `// append`
@@ -49,6 +52,8 @@ stays separate because it is cross-cutting (cascade + scheduling + materialize).
 // materialize ducklake://analytics/orders_daily append       → managed, append
 // materialize ducklake://analytics/dim_customer key=id history → managed, SCD type 2 history
 // materialize manual ducklake://analytics/orders_daily       → track-only escape hatch
+// materialize ducklake://analytics/raw_events on_schema_change=ignore
+//                                  → managed, downstream contract warnings muted
 ```
 
 - **managed (default)** — the script is *setup + one trailing `SELECT`*; Windmill
@@ -57,9 +62,18 @@ stays separate because it is cross-cutting (cascade + scheduling + materialize).
   error pointing to the `wmll.ducklake` helpers).
 - **`manual`** — escape hatch: the script writes its own DDL; Windmill only
   records state (no snapshot capture, no idempotency guarantee). Rare; explicit.
-- **`key=<col>`** → MERGE (dedup within slice, SCD type 1 — overwrites history);
-  **`append`** → INSERT-only; neither → DELETE-by-partition + INSERT (replace).
-  `append` wins over `key` if both are given (deploy warning).
+- **`key=<col>`** → MERGE (upsert-by-key within the slice, SCD type 1 —
+  overwrites history); **`append`** → INSERT-only; neither → DELETE-by-partition
+  + INSERT (replace). `append` wins over `key` if both are given (deploy warning).
+  - **Source must have unique keys.** The merge is delete-by-key + insert-all: it
+    reconciles the incoming rows against the *target* (rows whose key is in the
+    SELECT are replaced), but it does **not** deduplicate the *source*. Two
+    incoming rows sharing a key would therefore both land under that key, silently
+    breaking the "one row per key" contract. The managed write guards against this
+    — the run **fails** with a clear error when the SELECT returns more than one
+    row for a non-NULL key (`NULL` keys are exempt, matching the insert-only path).
+    Deduplicate in the SELECT (e.g. `QUALIFY row_number() OVER (PARTITION BY <key>
+    ORDER BY <recency-col> DESC) = 1`) or use `append` if duplicates are intended.
 - **`key=<col> history [track=<c1,c2,…>] [deletes=close]`** → upgrades the keyed
   merge to managed SCD **type 2** history (the leading keyword `scd2` is an alias).
   The SELECT is the *current snapshot* (one row per `key`), and the runtime adds
@@ -68,7 +82,9 @@ stays separate because it is cross-cutting (cascade + scheduling + materialize).
   history. Diff → close-old (`UPDATE`) → open-new (`INSERT`) in one transaction;
   the effective timestamp is the transaction clock (`now()`), so a run is
   self-consistent. v1 is **non-partitioned only** (`// partitioned` + history is
-  rejected). Unlike `manual`, it is managed, so `// data_test` and schema capture
+  rejected **at deploy**), and it **requires `key=`** (also rejected at deploy).
+  Both misconfigurations fail fast at save with a clear message instead of on the
+  first run. Unlike `manual`, it is managed, so `// data_test` and schema capture
   work.
   - **Deletes.** By default a key that disappears from the snapshot stays current
     (soft delete — dbt's `hard_deletes=ignore`). `deletes=close` opts into
@@ -322,18 +338,73 @@ The reusable shape, in three layers, each a clean extension seam:
    match arm + its sub-parser; the `Custom` arm is the open fallback. A sibling
    family reuses this head-keyword dispatch rather than adding a parallel list.
 2. **Compile** (`sql_materialize.rs::build_data_test_checks`). Each test becomes
-   a **check**: `(name, violating-row-count query)`. Built-ins differ only in
-   their count query; `Custom` supplies its own (the user's SELECT of violating
-   rows). Referenced assets (relationships) emit an `ATTACH` resolved by the
-   same transform pass as the user's own.
+   a **check**: `(name, probe)`, where the probe is a one-row query counting
+   *and sampling* the test's violating rows in a single scan. Built-ins differ
+   only in their violating-rows query; `Custom` supplies its own (the user's
+   SELECT of violating rows). Referenced assets (relationships) emit an
+   `ATTACH` resolved by the same transform pass as the user's own.
 3. **Execute** (`duckdb_executor.rs`). The materialize summary query embeds
-   every check's count in one `data_tests` list-of-struct column (computed in a
-   CTE, since DuckDB rejects subqueries inside struct literals), so **all tests
-   run in a single pass** against the freshly-materialized slice — no
-   abort-on-first. The worker reads the breakdown from the result and decides
-   pass/fail: any violation **fails the run** (record `Failed`, propagate up the
-   cascade) with an error listing *every* test (✓/✗ + counts); a clean run
-   returns the per-test summary so the UI can render a checklist.
+   every check's outcome in one `data_tests` list-of-struct column (probes are
+   lifted into one-row CTEs and cross-joined, since DuckDB rejects subqueries
+   inside struct literals), so **all tests run in a single pass** against the
+   freshly-materialized slice — no abort-on-first. The worker reads the
+   breakdown from the result and decides pass/fail: any violation **fails the
+   run** (record `Failed`, propagate up the cascade) with an error listing
+   *every* test (✓/✗ + counts); a clean run returns the per-test summary so
+   the UI can render a checklist.
+
+### Violating-row samples
+
+Each check's probe also captures a bounded **sample of its violating rows**
+(≤20 rows, ≤50KB serialized per test — over-cap samples are *dropped*, never
+truncated, since truncated JSON fails parsing after paying the bytes). The
+sample is **optional by contract** at every layer: enforcement reads only the
+count; NULL / dropped / unparseable samples degrade to "no sample" and can
+never flip pass/fail. Where they surface:
+
+- **Failed run**: the worker returns a structured error payload
+  (`Error::ExecutionRawError`), so the failed job's result carries
+  `error.data_tests: [{test, violating, sample?}]` with samples on failed
+  tests only. The error *message* stays counts-only, plus a pointer at the
+  payload — so run descriptions and `materialized_partition.error` carry no
+  row data. The full payload is the job *result*, and follows every failed
+  job's result wherever that already goes: the worker's failed-job log line
+  (`add_completed_job_error`) and, on EE, the args of configured
+  global/workspace error handlers — the same pre-existing paths that carry
+  e.g. a failed process's own `result.json`. A handler that formats only
+  `error.message` (the common alert shape) stays counts-only; one that wants
+  the offending rows can read `error.data_tests`. The duckdb executor's
+  password-sanitize catch-all must special-case `ExecutionRawError` —
+  flattening it to a string would silently strip the payload.
+- **UI**: `DataTestsResult.svelte` renders a per-failed-test expandable
+  `AutoDataTable`; `DisplayResult.svelte` prefers the structured payload and
+  falls back to text-parsing the breakdown for results predating it.
+- **Enterprise (write-audit-publish)**: samples only exist on the
+  commit-then-test path. Under the EE in-transaction guard a violation aborts
+  pre-commit and the slice rolls back, so the violating rows cease to exist —
+  WAP failures are counts-only by construction (the guard's in-SQL ✓/✗
+  message), and the guard projects only the probe's count column
+  (`pipeline_advanced_ee.rs::data_test_guard_sql`).
+
+Sample mechanics worth knowing:
+
+- The sample rides as a **JSON string** (`to_json(...)::VARCHAR`) through the
+  summary row, deliberately: expanded rows would be visible to the executor's
+  key-recursive `extract_i64(result, "rows"/"snapshot_id")` scans, which a
+  user column of the same name could corrupt. It is parsed only inside
+  `extract_data_tests`.
+- No `ORDER BY` on the violating rows — *which* rows land in the sample is
+  nondeterministic (labelled "sample" in the UI for that reason).
+- `unique` samples `{value, count}` pairs at its count's grain (number of
+  duplicated *values*), so count and sample can't contradict each other.
+- On partitioned targets the synthetic `_wm_partition` column is `EXCLUDE`d
+  from samples (same rule as schema capture).
+- A custom body joining with `SELECT *` can yield duplicate column names —
+  duplicate JSON keys keep the last value; harmless but visible.
+- The probe shape is gated by in-memory tests against the bundled engine in
+  `windmill-duckdb-ffi-internal` (json extension availability, zero-row NULL
+  degrade, exotic types) — a sample-expr runtime error would fail the summary
+  read after the write committed, so keep those green when touching the shape.
 
 A new annotation family that produces post-materialize checks (or, for
 column-lineage, post-materialize *metadata reads*) plugs into the same three
@@ -341,6 +412,40 @@ seams: add a parsed variant, emit its check/reader SQL into the summary, read
 it back in the worker. Nothing about the closed set of *today's* keywords is
 load-bearing.
 
+### Cascade ordering (`test_edges`)
+
+A `relationships` test — and, best-effort, a custom test whose body reads a
+pipeline asset — needs the *referenced* asset to exist at test time, but it is
+**not** a data-consumption `// on`/read of that asset, so it contributes no
+lineage edge. Without an ordering constraint, a cold cascade can run the tested
+script before the referenced dimension is materialized and hard-fail
+(`Catalog Error: Table … does not exist`).
+
+`asset_graph` (`windmill-api-assets/src/lib.rs`) closes this by resolving the
+referenced asset's in-pipeline **producer** (from the write edges it already
+builds) and emitting an ordering-only `test_edges` entry
+`producer → testing_script`. It is:
+
+- **Only emitted when a producer exists in the graph.** An external table (no
+  in-pipeline producer) adds no edge — the missing dependency is real and the
+  runtime error is the correct signal. Self-edges (a script relationship-testing
+  its own output) are dropped.
+- **Rendered distinctly** — amber dashed "test needs" link on the canvas, apart
+  from lineage (blue/gray solid) and triggers (gray) — because the tested script
+  does not ingest the asset's rows.
+- **Fed into the cascade topo-sort** via `buildLineageDag`
+  (`AssetGraph/boundedCascade.ts`), routed *through* the referenced asset node
+  (`asset → testing_script`) so the existing `producer → asset` write edge
+  extends into `producer → asset → testing_script` and the two-hop
+  `buildLineageDownstreamMap` invariant holds. Bounded and full-pipeline runs
+  (`computeInducedSchedule`) then order the producer first.
+
+Scope caveat: this orders *within a single client-driven cascade* (dev run /
+bounded run / full-pipeline run). It does not change the production reactive
+asset-dispatch of two independently-scheduled roots — there, `relationships`
+targets on a disjoint root should still be co-scheduled or bound with an
+explicit `// on <dim>` if a hard ordering is required.
+
 ### Scoping decisions (v1)
 
 - **Partition scope.** When `// partitioned`, built-in checks are scoped to the
@@ -352,10 +457,22 @@ load-bearing.
   repeats the natural key across closed versions, so an unscoped
   `unique(<key>)` would fail the run on the second change of any key. Custom
   tests see the raw history and scope themselves.
-- **Commit-then-test.** Like dbt, the write commits before tests run; a failed
-  test fails the *run* (and records `Failed`, so downstream cascade stops) but
-  does not roll back the committed snapshot. Time-travel still lets you inspect
-  exactly what failed.
+- **Commit-then-test (public) / write-audit-publish (enterprise).** In the
+  public build, like dbt, the write commits before tests run; a failed test
+  fails the *run* (and records `Failed`, so downstream cascade stops) but does
+  not roll back the committed snapshot — time-travel still lets you inspect
+  exactly what failed. Enterprise upgrades this to write-audit-publish: the
+  same checks also run *inside* the write transaction as a guard statement
+  that raises on any violation, aborting the run before `COMMIT` — a failing
+  slice is never published, readers keep the previous version, and no snapshot
+  is created (even a *first* run of a new asset rolls back to "no table").
+  The whole mechanism lives in the enterprise repo:
+  `sql_materialize::build_wrap_blocks` produces a typed statement plan
+  (`MaterializePlan` — statements plus structural kinds and the compiled
+  checks), and `pipeline_advanced::finalize_materialize_query` assembles it —
+  verbatim on the public build, restructured into the guarded transaction on
+  EE. The public build thus carries only plan metadata, not the
+  write-audit-publish transform itself.
 - **Custom = DuckDB SQL, server worker.** The escape hatch fetches the deployed
   script's content (a single DuckDB `SELECT`/CTE returning the violating rows —
   it's embedded as a subquery, so a multi-statement body is rejected with a
@@ -366,6 +483,35 @@ load-bearing.
 - **Managed only.** `// materialize manual` + `// data_test` is rejected with a
   clear error (we can't know the manual script's target alias / partition col).
 
+## Schema contracts (save-time, gap #2b)
+
+The captured schema (#2a) is read back as a *contract*: at save/deploy time,
+every consumer's asset references — body-read/written columns, `// column`
+lineage sources, `// data_test relationships` refs — are diffed against the
+latest `materialized_asset_schema` version of each referenced ducklake asset,
+and mismatches surface as **warnings** (deploy never blocks; dbt's
+`on_schema_change=fail` is deliberately absent in v1). The diff lives in
+`windmill_common::schema_contracts` (endpoint:
+`POST /w/{ws}/scripts/check_schema_contracts`, called by the UI right after a
+save) and is mirrored 1:1 by the editor (`schemaContracts.ts`): live Monaco
+warning squiggles from the WASM buffer parse, plus column-name completion for
+annotation refs fed by the same captured schemas.
+
+Comparison rules worth knowing: column names are case-insensitive (DuckDB
+unquoted-identifier semantics); `_wm_partition` is whitelisted (it's excluded
+from capture); `{partition}` tokens are stripped before lookup; a
+`<dim>_current` reference falls back to the scd2 base table's capture; a
+relationships join across two captured assets also flags a captured-type
+*difference* (the runtime probe coerces, so it's "differs", not "will fail").
+An asset with no capture (never materialized, `manual` mode, any
+`datatable://`) produces no warnings.
+
+The producer opts a deliberately unstable schema out with
+`// materialize … on_schema_change=ignore` — consumers then get a single
+informational "suppressed" note instead of per-column warnings. On `manual`
+materialize the option is inert (nothing is captured) and deploy logs a
+warning saying so.
+
 ## Scoping decision: DuckLake vs DataTable
 
 **Make DuckLake the materialization/versioning substrate; keep DataTable as the
@@ -422,3 +568,38 @@ forces"; DuckLake-specific:
    rejects anything else at deploy with a clear error pointing to
    `// materialize manual`. The classifier (`sql_materialize.rs`) is the single
    source of truth.
+
+## Ingestion (EL): the sanctioned entry-node shape
+
+Design constraints for how external data enters the lake — the user-facing
+how-to (extract-engine choice, cursor recipes, schema-drift handling, worked
+examples) lives in windmilldocs `core_concepts/63_pipelines` → "Ingestion
+(EL)"; this section records only what future feature work must not break.
+
+- **`// materialize` is DuckDB-only** (deploy-rejected elsewhere, managed and
+  `manual` alike — `windmill-api-scripts/src/scripts.rs`), and the SDK
+  materialize helpers (`upsert_partition` / `upsertPartition`) build their SQL
+  inside the SDK, so the asset parsers cannot see the write. A polyglot node
+  that "writes the lake directly" therefore deploys with **no output edge** —
+  breaking lineage, cascade scheduling, and the backfill UI's producer lookup.
+- **The sanctioned polyglot shape is two scripts**: an entry node that lands
+  the raw batch as an object in workspace storage (`write_s3_file` — a
+  parser-visible write), and a DuckDB loader (`-- on s3:///<key>` +
+  `-- materialize`) that the asset dispatcher re-runs per batch. The landing
+  object is the seam; splitting E from L also keeps row work vectorized and
+  gives the load the full engine treatment (strategies, snapshots, partition
+  grid, `// data_test`).
+- **One string spelling: `s3:///<key>`.** SDK string params are strictly
+  `s3://…` URIs with a non-empty key; anything else raises (clients >
+  1.746.0 — older clients silently upload such strings to an auto-generated
+  `windmill_uploads/…` name, so keep URIs in code that must run on them).
+  The same URI is what
+  `// on` annotations and DuckDB SQL take, and all forms (URI, `{s3}` object,
+  `S3Object(s3=…)`) canonicalize to path `/<key>`. The asset parsers record
+  **no asset** for a bare-string SDK argument (the call can only error at
+  run time) — keep `parse_s3_object` (py client), `parseS3Object`
+  (ts client, `s3Types.ts`) and both `s3_object_arg_path` parsers in lockstep
+  when touching any of them.
+- DuckDB workers load no ICU extension: bare `TIMESTAMPTZ - INTERVAL`
+  arithmetic binder-errors. Incremental-pull SQL casts both sides
+  (`updated_at::TIMESTAMP > now()::TIMESTAMP - INTERVAL 7 DAY`).
diff --git a/docs/enterprise.md b/docs/enterprise.md
index 5ab869a651..229585ad25 100644
--- a/docs/enterprise.md
+++ b/docs/enterprise.md
@@ -47,3 +47,19 @@ cargo check --features enterprise,private
 # EE code that also requires license validation
 cargo check --features enterprise,private,license
 ```
+
+## Troubleshooting
+
+**`E0583: file not found for module <x>_ee` on `cargo check --features enterprise,private`**:
+the EE worktree is behind the OSS code it must satisfy. Fast-forward it to EE
+`origin/main` — EE worktrees are shallow clones, so run `git fetch --unshallow origin`
+first or the merge fails with "refusing to merge unrelated histories". After the
+fast-forward, any `*_ee.rs` file that is *new* since the worktree was created still
+needs its OSS symlink made by hand (worktree setup only links files that existed then).
+The EE repo has no `backend/` prefix — crates sit at its root. Use an absolute target
+(a relative one would resolve against the link's directory, not your cwd):
+
+```bash
+# from the windmill repo root
+ln -s ~/windmill-ee-private/<crate>/src/<x>_ee.rs backend/<crate>/src/<x>_ee.rs
+```
diff --git a/docs/pipeline-env-isolation.md b/docs/pipeline-env-isolation.md
new file mode 100644
index 0000000000..2b6b87ba68
--- /dev/null
+++ b/docs/pipeline-env-isolation.md
@@ -0,0 +1,219 @@
+# Fork data environments for pipeline materialization ("dev data")
+
+Status: **implemented** (branch `pipeline-env-isolation`). Companion to
+[`ducklake-materialization.md`](./ducklake-materialization.md).
+
+## The problem
+
+Workspace forks fork the CODE, but `// materialize ducklake://<lake>/<table>` targets are
+absolute pointers into shared physical storage. A fork clones `workspace_settings.ducklake`
+verbatim, so `transform_attach_ducklake` resolved a fork's `ducklake://main` to the **parent's
+catalog database and S3 data path** — deploying or running a materializing pipeline inside a
+fork wrote the production tables. dbt answers this with target schemas + `--defer`; datatables
+already have a fork answer (`forked_datatables` → `wm_fork_*` databases + a drop endpoint);
+ducklake had none. `wmill pipeline run --local` only covers preview runs, and previews still
+resolve targets against the real workspace.
+
+## The design
+
+Everything hangs off two DuckLake ATTACH capabilities (verified in a spike, DuckDB 1.5.4 +
+current ducklake extension): `METADATA_SCHEMA` (the catalog's metadata tables live in a chosen
+pg schema of the same catalog DB — auto-created on first attach; default is `public`) and
+`READ_ONLY`, plus catalog-stored views that may reference other attached catalogs and rebind
+per session.
+
+### Fork-time choice: isolated (default) vs shared, per lake
+
+The fork-creation dialog offers a per-lake data-environment choice (the section renders only
+when the parent workspace has lakes configured, mirroring the datatable section):
+
+- **Isolated** (default — also what unlisted lakes and API callers that omit the field get) —
+  the full behavior described below.
+- **Shared** — explicit opt-out: the fork reads and writes the parent's lake directly through
+  its cloned config, like a non-fork workspace (e.g. a fork meant to run prod-equivalent
+  backfills). Stamped as `fork_behavior: "shared"` on the lake entry in the fork's own
+  `workspace_settings.ducklake` at creation (`shared_ducklakes` on the create-fork request);
+  the resolver, the graph indicator, and (trivially — nothing registers) cleanup all key off
+  it. Shared also lifts the mysql-catalog restriction, since nothing needs namespacing.
+
+Absent-field-means-isolated keeps every pre-existing fork and API caller on the safe path.
+Sharing is a per-fork-creation choice, never inherited: the settings clone copies the source's
+config verbatim, so fork creation strips any cloned `fork_behavior` stamps before applying its
+own `shared_ducklakes` list — a fork of a shared fork defaults back to isolated. A
+shared fork ancestor in a fork chain resolves like a root (its data lives at its config's
+default location). Flipping a fork's lake to `shared` later (settings edit) orphans any
+namespace it already materialized until fork deletion cleans it — the registry row survives
+the flip.
+
+### Write redirect — one seam, no grammar changes
+
+`get_ducklake_from_db_unchecked` (windmill-common/src/workspaces.rs) is fork-aware: when the
+resolved workspace has a `parent_workspace_id` (throwaway `wm-fork-*` fork or standing dev
+workspace), the returned `DucklakeWithConnData` is namespaced **in its existing fields**:
+
+- `extra_args` += `METADATA_SCHEMA 'wm_fork_<mangled wid>_<mangled lake>_<hash8>'` —
+  injective, ≤63 chars, stable across releases (persisted state depends on it), and
+  **lake-scoped**: two lakes of one workspace may share a catalog database, and a
+  per-workspace schema would merge their namespaces in the fork;
+- `storage.path` = `__wm_forks/<fork segment>/<original path>` — the segment is the
+  mangled+hashed workspace id collapsed to ONE path component (fork ids are only
+  git-branch-safe and may contain `/`; used raw, `wm-fork-a/b` would nest inside sibling
+  `wm-fork-a`'s cleanup prefix) — a **bucket-root prefix**, not a
+  sub-path of the parent's DATA_PATH, because lake maintenance
+  (`ducklake_delete_orphaned_files`, snapshot expiry) scans everything under the parent's path
+  and would delete live fork files nested there.
+
+Folding the redirect into existing fields means the EE agent-worker endpoint (which just
+serializes this struct) needs **no changes**, and an agent worker running an older binary still
+writes the fork namespace — it only misses the defer views (reads fail loudly; never a prod
+write). Every ducklake access funnels through the same ATTACH transform — the managed
+materialize's synthetic `_wm_target` attach, `materialize manual`, raw user SQL, and all UI
+preview / History / backfill surfaces (they are `WM_INTERNAL_DB_*` marker preview jobs) — so a
+fork cannot reach the parent namespace through the managed path at all.
+
+Hardening: in fork mode, user- and settings-supplied `METADATA_SCHEMA` / `DATA_PATH` /
+`OVERRIDE_DATA_PATH` ATTACH options are stripped before injection (DuckDB silently keeps the
+*last* occurrence of a duplicated option, so a duplicate would escape the namespace).
+MySQL-catalog lakes error loudly in forks (no pg schemas to namespace with) rather than ever
+writing the shared catalog.
+
+### Read-defer — iterate on one node without rebuilding upstream
+
+In a fork, `transform_attach_ducklake` additionally emits:
+
+1. `ATTACH IF NOT EXISTS … AS __wm_dl_<lake>_<ancestor>_<hash> ([<ancestor's own args>, ]
+   DATA_PATH <ancestor's>, OVERRIDE_DATA_PATH TRUE, READ_ONLY[, METADATA_SCHEMA
+   <ancestor's>])` per fork-chain ancestor, resolved from the **ancestor's own settings**
+   (fork-side settings drift can't repoint what "parent" means). The ancestor config's
+   non-reserved `extra_args` (e.g. `ENCRYPTED true`) ride along — FIRST, so the fork-owned
+   options win under DuckDB's last-occurrence-wins. No
+   `AUTOMATIC_MIGRATION`/`CREATE_IF_NOT_EXISTS` — a fork job must never mutate an ancestor
+   lake. `READ_ONLY` makes prod writes *physically impossible* through ducklake, including in
+   `materialize manual` and raw SQL. Fork ancestors whose namespace was never bootstrapped are
+   skipped, with existence checked in each ancestor's OWN catalog database (a fork whose
+   catalog drifted away from an ancestor's must not misread that ancestor's namespace as
+   missing); an unreachable ancestor catalog only disables that ancestor's defer.
+2. `CREATE VIEW IF NOT EXISTS <alias>.<table> AS SELECT * FROM <owning ancestor
+   alias>.<table>` for every **deferred table**: (`materialized_partition` rows with
+   `status = 'materialized'` anywhere in the ancestor chain) MINUS (the fork's own rows). Each
+   view targets the NEAREST ancestor that physically owns the table
+   (`ForkDeferTable.ancestor_idx`): in a `fork → parent → root` chain where only the root
+   materialized a table, the parent has no copy (it defers too), so a view over the parent
+   would not bind. SCD2 owners (detected by the `is_current` column in the owning ancestor's
+   latest captured `materialized_asset_schema`) also get the `<table>_current` companion view.
+   So a consumer reading `dl.orders` transparently reads the nearest owning ancestor's current
+   data until the fork materializes `orders` itself.
+3. When the running job's managed materialize targets a table that currently exists **as a
+   view** in the fork namespace, the view (and its `_current` companion) is dropped after the
+   target attach — the first fork materialize replaces the defer view with a real fork table
+   (`CREATE [OR REPLACE] TABLE` refuses to replace a view — verified — so without the drop the
+   transition fails; with it, `sql_materialize.rs` codegen needs no fork awareness at all).
+   The is-it-a-view decision keys on the catalog's ACTUAL live views (`ducklake_view`, read at
+   resolution time into `fork_defer.fork_views`), **not** on recorded materialization status:
+   after a failed run the status cannot distinguish a defer view from a real table, and a
+   mismatched `DROP VIEW` (or skipped drop) would wedge the asset on every retry — found live
+   in e2e when a storage failure flipped a fork asset's status to `Failed`.
+
+The graph shows the state per ducklake asset in a fork: an amber ↗ chip = *deferred* (some ancestor in the chain
+owns the table),
+an emerald fork chip = *fork-materialized* (`fork_materialization` on the `/assets/graph`
+response, computed from fork + parent `materialized_partition`; the parent's rows are read on
+the plain pool since fork membership doesn't imply parent membership). The details pane shows
+the equivalent banner.
+
+### Lifecycle & cleanup
+
+A sidecar registry `fork_ducklake_namespace(workspace_id, ducklake_name,
+metadata_schema, catalog, storage, storage_ref, data_path)` is upserted (behind a TTL'd in-process cache, keyed
+per workspace and invalidated whenever a workspace's registry rows are cleaned up — a same-id fork recreated
+within the TTL must re-register or its namespace would be orphaned at its own deletion) on fork
+resolution, **one row per physical location ever attached** — its PK includes
+`(catalog, storage, storage_ref, data_path)`, so if the fork's lake settings drift, later attaches add rows rather
+than replace them and cleanup covers every location the fork wrote, not just the first — connecting to the
+REGISTERED catalog identity and deleting files from the REGISTERED storage identity
+(`storage_ref`, resolved from the logical storage name at attach time), never whatever the
+fork's settings point at by deletion time. Explicit
+`GRANT`s ship in the same migration; the registry is not cloned into sub-forks.
+
+The registry has deliberately **no FK to `workspace`**: rows are the durable cleanup ledger and
+outlive the workspace row when physical cleanup fails after the delete commits (unreachable
+catalog, storage outage) — each row is deleted only after its schema + data cleanup succeed.
+Fork **creation** retries any leftover rows for the reused id and refuses to proceed while a
+metadata schema still cannot be dropped, so a recreated same-id fork can never silently
+reattach stale tables. Data-file leftovers alone don't block: a deleted fork's `$res:` storage
+resource is gone forever, but once the schema is dropped the files are inert — the surviving
+row keeps them tracked and the next successful cleanup of the same prefix (typically the
+recreated fork's own deletion, with live credentials) sweeps them.
+
+Retries after the fork is gone get two aids: the row's `schema_dropped` phase flag (set when
+the schema dropped but data cleanup failed; retries then skip the schema phase and need no
+catalog credentials — registration resets it on re-attach, which recreates the schema), and
+`$res:` fallback resolution against the workspace being forked (the deleted fork's resources
+were clones of a parent's, so the new parent is the natural credential donor).
+
+`POST /w/{fork}/workspaces/drop_forked_ducklake_namespaces` (same permissions as
+`delete_workspace` via a shared gate: fork owner or superadmin, plus parent-prod-admin when the
+fork is an attached dev workspace) drops each registered pg metadata schema
+(`DROP SCHEMA … CASCADE` on the catalog connection, hard-guarded on the `wm_fork_` prefix) and
+deletes the `__wm_forks/<fork segment>/…` objects in the workspace storage (hard-guarded on that
+prefix; `parquet` feature). The fork-deletion UI calls it next to
+`drop_forked_datatable_databases`, for the fork and for deleted child forks. Registry rows are
+deleted per-lake only after both cleanups succeed, so a partial failure is retryable.
+
+## Semantics & caveats (by design)
+
+- **Orphaned forks stay isolated.** `parent_workspace_id` is `ON DELETE SET NULL`, so a
+  `wm-fork-*` workspace can outlive its parent. Its ancestor chain is then empty, but its cloned
+  config still points at the shared lake — so fork resolution keys on the `wm-fork-` prefix as
+  well as the chain (mirroring `workspace_is_fork`). An orphaned fork gets the write redirect,
+  registration and cleanup but no defer views; pre-orphaning defer views fail loudly at bind and
+  flip to real tables on first materialize. The same rule applies to a fork's *ancestors*: a
+  last-in-chain `wm-fork-*` ancestor is an orphaned fork (not a root) and its READ_ONLY attach
+  targets its fork namespace, not its cloned base config. Prefix-less dev workspaces cannot be
+  orphaned (deleting their prod is blocked while attached).
+- **Defer is live, not snapshot-pinned.** A deferred read sees the parent's *current* table —
+  the same trade dbt `--defer` makes. Snapshot-pinned defer could later ride on the recorded
+  `snapshot_id`s.
+- **Defer granularity is per-table.** Materializing one partition in the fork makes the fork's
+  table authoritative for *all* partitions (the rest are empty until backfilled in the fork).
+- **Incremental strategies start empty in a fork.** `merge`/`append`/SCD2 create a fresh table
+  on first fork run — no parent rows are inherited, and fork SCD2 history diverges from the
+  parent's. Copy-on-fork seeding would be a follow-up opt-in.
+- **Only tracked tables defer.** A parent table with no `materialized_partition` row (raw SQL
+  writes outside `// materialize`) or whose latest run `Failed` is not deferred — defer views
+  bind at CREATE against the parent catalog, and a view on a missing table would fail every
+  unrelated fork job. Such tables read as absent in the fork.
+- **Transient race.** Between a fork materialize's commit and its state recording, a concurrent
+  fork job may still emit `CREATE VIEW IF NOT EXISTS` for that table — which silently yields to
+  an existing table (verified), so the race is a no-op.
+- **Accident prevention, not a security boundary.** A fork holds the parent's cloned
+  credentials by design; a determined fork user can still `ATTACH 'postgres:…'` with the cloned
+  catalog resource or `COPY TO 's3://…'` directly. The isolation guarantees are scoped to the
+  managed ducklake path (where they are physical: READ_ONLY parent attach + separate metadata
+  schema + separate data prefix).
+- **Fork chains** compose: each ancestor namespace is attached under a deterministic alias, and
+  a parent's own defer views (referencing *its* parent's alias) rebind correctly in the
+  grandchild's session because the whole chain is attached.
+- **Datatables are out of scope** — the existing `forked_datatables` chooser at fork creation
+  covers them (`keep_original` remains their default, which shares the parent DB; picking
+  `schema_only` there is the datatable analog of this feature).
+
+## Key files
+
+- `backend/windmill-common/src/workspaces.rs` — fork resolution (`fork_scoped_ducklake`),
+  `fork_ancestor_chain`, naming (`fork_ducklake_metadata_schema`,
+  `fork_ducklake_ancestor_alias`, `fork_data_path`), option stripping, registry.
+- `backend/windmill-common/src/materialization.rs` — `list_fork_defer_tables`.
+- `backend/windmill-worker/src/duckdb_executor.rs` — `fork_defer_statements` (ancestor
+  attaches, defer views, target transition), user-arg stripping.
+- `backend/windmill-api-assets/src/lib.rs` — `fork_materialization` on the graph.
+- `backend/windmill-api-workspaces/src/workspaces_extra.rs` —
+  `drop_forked_ducklake_namespaces`.
+- `backend/windmill-api-workspaces/src/workspaces.rs` — `clone_asset_usages_and_triggers`:
+  `asset` + `script_trigger` rows are deploy-derived and were never cloned into forks, so a
+  fork's pipeline graph had no asset nodes/edges and its dispatch cascade never fired (fixed
+  here because this feature is unusable without it).
+- `backend/migrations/20260703170745_fork_ducklake_namespace.*` — registry + GRANTs.
+- Frontend: `AssetGraph/{types.ts,AssetNode.svelte,AssetGraphCanvas.svelte,
+  AssetGraphDetailsPane.svelte}`, `pipeline/[folder]/+page.svelte`,
+  `sidebar/SidebarContent.svelte` (fork-delete wiring).
diff --git a/docs/pipeline-local-dev.md b/docs/pipeline-local-dev.md
index 8b394d0eda..6ee6a59a14 100644
--- a/docs/pipeline-local-dev.md
+++ b/docs/pipeline-local-dev.md
@@ -84,14 +84,22 @@ makes the client own the whole cascade so the backend dispatcher never double-fi
 `inferScriptAssets` mirrors `frontend/src/lib/infer.ts:inferAssets`: ts (bun/deno/nativets),
 python3, and SQL dialects all get wasm inference (SQL dialects route to `parse_assets_sql`; its
 comment-header annotation scan is dialect-independent). `go`/`bash` have no wasm asset parser, so
-they fall back to a minimal `// pipeline` + `// on` scan (annotation-only). Note inferred asset
-**paths must match exactly** to connect nodes: DuckDB `read_csv('s3://x')` / `COPY ... TO 's3://x'`
-and `// on s3://x` all yield path `x` (no leading slash), whereas the SDK object forms — TS
-`writeS3File({s3:"x"})` and python `write_s3_file(S3Object(s3="x"))` (or the equivalent dict
-literal), both resolved as `s3://<storage>/<key>` with empty default storage — yield `/x`, matching
-the `// on s3:///x` (triple-slash) annotation form. So an all-DuckDB example connects cleanly, and
-SDK writes connect to `s3:///…` annotations; mixing SDK-write with the no-slash annotation form
-needs care.
+they fall back to a minimal `// pipeline` + `// on` scan (annotation-only). Inferred asset paths
+must match to connect nodes, and all S3 URI forms canonicalize to one key: `parse_asset_syntax`
+(shared by the native and wasm parsers) strips leading slashes from S3 paths, so the SDK
+object forms — TS `writeS3File({s3:"x"})` and python `write_s3_file(S3Object(s3="x"))`, which
+resolve to `s3:///x` (empty default storage) — the triple-slash annotation `// on s3:///x`, DuckDB
+`read_csv('s3://x')` / `COPY ... TO 's3://x'`, and `// on s3://x` all yield path `x`. A TS/Python
+writer and a DuckDB reader of the same object therefore connect regardless of which URI form each
+side uses. (Only leading slashes are stripped — so a canonical key never starts with `/`, which
+keeps the identity stable through `// on` trigger-ref reconstruction — while Hive-partition keys
+like `s3://bucket/y=2024/f.parquet` and the explicit-storage form `s3://storage/key` keep their
+`bucket/…` / `storage/key` paths.) Tradeoff of collapsing to one canonical key: the explicit-storage
+form `s3://storage/key` and the default-storage nested-key form `s3:///storage/key` now alias to
+the same node `storage/key`, even though they name different objects (a bucket `storage` vs. an
+object under the `storage/` prefix in default storage). This only collides when a storage config is
+named to match a default-storage prefix — unlikely, and acceptable for a best-effort lineage graph
+that already doesn't split the first segment as a storage name.
 
 ## How to test
 
@@ -151,11 +159,12 @@ http://localhost:3000/pipeline_dev?workspace=<WS>&wm_token=<TOK>&folder=demo_pip
    `startProxyServer` for embedders that need a localhost origin (e.g. Claude Code preview).
 5. **`pipeline dev` editing**: the dev page is view+run only (editing stays in the user's editor).
    If in-browser editing with file round-trip is wanted, mirror flow-dev's `handleFlowRoundTrip`.
-6. **Asset-path normalization**: partially done — the python parser now resolves the
+6. **Asset-path normalization**: done — the python parser resolves the
    `S3Object(s3=…, storage=…?)` constructor / dict-literal forms to the same canonical path as the
-   TS `{s3, storage}` object form (see Language coverage), so SDK writes and reads connect across
-   ts/python. Still open: the SDK-form leading-slash (`/x`) vs bare-URI no-slash (`x`, DuckDB and
-   `// on s3://x`) mismatch silently breaks lineage across those two conventions.
+   TS `{s3, storage}` object form, and `parse_asset_syntax` now strips leading slashes from
+   S3 keys so the SDK-form `s3:///x` (`/x`) and the bare-URI no-slash form (`x`, DuckDB and
+   `// on s3://x`) canonicalize to one key (see Language coverage). SDK writes and DuckDB reads of
+   the same object connect regardless of URI convention.
 
 ## Plan reference
 
diff --git a/docs/pipelines-vs-dbt.md b/docs/pipelines-vs-dbt.md
index c073c88b8c..d00a78aa7f 100644
--- a/docs/pipelines-vs-dbt.md
+++ b/docs/pipelines-vs-dbt.md
@@ -51,7 +51,7 @@ Asset-centric, polyglot, annotation-driven, event-aware:
 | Column lineage | No | **Shipped** (`// column`); docs site still TODO |
 | Snapshots / SCD2 | Yes (`key=… history`) | Managed strategy |
 | Selective execution grammar | No | UI/CLI surface |
-| Schema contracts | No, but design metadata model | TODO with design work |
+| Schema contracts | No, but design metadata model | **Shipped** (capture #2a + save-time check #2b) |
 | Packages / community / macros | No | **Shipped** (`// macros` workspace macro libraries) |
 | Semantic layer / metrics | No | Large additive scope |
 
@@ -75,6 +75,12 @@ the annotation→verifier pattern that column-lineage will reuse. The keyword is
 `data_test`, not `test`, to stay clear of the unrelated `// test:` CI-test
 annotation.
 
+Enterprise goes one step *beyond* dbt here: write-audit-publish. dbt commits
+the model then tests it, so a failing test leaves the bad table live for BI
+readers; the enterprise build runs the same probes inside the write
+transaction and rolls back on violation, so a failing slice is never
+published (see `ducklake-materialization.md` §"Scoping decisions").
+
 ### 2. Incremental materializations
 
 See [Incremental deep-dive](#incremental-deep-dive) below.
@@ -131,7 +137,9 @@ schema capture, and each run (re)creates a `<dim>_current` view; consumers get
 effective-dated joins via native `ASOF JOIN … >= valid_from`. Deletes follow dbt:
 soft by default (absent keys stay current), or `deletes=close` for
 `hard_deletes=close`. v1 is non-partitioned; partitioned history is a follow-up.
-See `ducklake-materialization.md`.
+Both misconfigurations — `history` without `key=`, and `history` + `//
+partitioned` — are rejected **at deploy** (fail-fast at save, not on the first
+run). See `ducklake-materialization.md`.
 
 ### 5. Selective execution grammar
 
@@ -140,21 +148,43 @@ Today: `requestRunCascadeSignal` in the canvas, `// tag` annotation parsed.
 Graph + tags + last-run state has all the inputs. UI/CLI surface, not
 abstraction work.
 
-### 6. Schema contracts
+### 6. Schema contracts — **shipped**
 
 dbt: `contract: enforced` + `columns: [{name, data_type}]`. Compile-time
 check that model output matches the declaration.
 
-Today: `// on datatable://users/active` is a string. Rename a column
-upstream → downstream breaks at runtime, silently.
+**Shipped**, capture-then-validate (no declaration to maintain): the schema a
+managed `// materialize` run captures post-DESCRIBE into the versioned
+`materialized_asset_schema` sidecar (#2a) *is* the contract, and every
+consumer save/deploy is validated against the latest capture. Three surfaces,
+same diff (`windmill_common::schema_contracts`, mirrored 1:1 in
+`schemaContracts.ts`):
 
-This is the item where the current asset abstraction is thinnest.
-To do contracts well: capture output schemas after a run (substrate-specific
-DESCRIBE), persist them as asset metadata, validate consumer references at
-save time. The asset-as-typed-node model accommodates it — but **where**
-schemas live (asset row, sidecar?), **when** they're captured (post-run?
-edit-time?), and **how** versioning works are non-trivial design choices.
-Worth doing intentionally now while the asset surface is still young.
+- **Save-time (authoritative)**: `POST /w/{ws}/scripts/check_schema_contracts`
+  runs on the deployed content right after a save and returns **warnings —
+  never errors**. A deliberate upstream reshape must not fail every consumer
+  save; that's why dbt's `on_schema_change=fail` is deliberately not offered
+  in v1 (a CI/CLI gate can layer it on later without touching the grammar).
+- **Editor flycheck**: the WASM parse that already runs on the open buffer
+  feeds the same diff, surfacing mismatches as live Monaco warning squiggles
+  anchored to the offending read / `// column` / `// data_test` line.
+- **Autocompletion**: annotation refs (`// column out <-
+  ducklake://lake/orders.`, `// data_test relationships … ->`) complete
+  column names from the captured schema — the broken ref never gets typed.
+
+What's checked (ducklake-only — the only substrate with capture in v1;
+datatable refs have no captured schema and stay silent): body-read/written
+columns missing from the capture, `// column` lineage sources, and
+`// data_test relationships` refs — including a captured-type *difference* on
+the join columns when both sides are captured (phrased "differs", since the
+runtime probe's IN-subquery still coerces). Column names compare
+case-insensitively (DuckDB unquoted-identifier semantics); the managed
+`_wm_partition` column is whitelisted; a `<dim>_current` scd2 view falls back
+to its base table's capture (identical columns by construction).
+
+The producer-side escape hatch is `// materialize … on_schema_change=ignore`:
+it declares the schema deliberately unstable and collapses downstream
+warnings for that asset into a single informational note. Default is `warn`.
 
 ### 7. Packages / community / macros — **shipped** (macro libraries)
 
@@ -406,6 +436,13 @@ DELETE-by-partition + INSERT works only if you reprocess from a
 source-of-truth source. If you're consuming amendments and need dedup
 *within* the slice, you need MERGE on `order_id`, not DELETE on partition.
 
+Note the boundary: the keyed merge reconciles the incoming rows against the
+*target* (delete-by-key + insert), but it does not deduplicate the *source*.
+"Latest version per `order_id`" is still your SELECT's job — pick one row per
+key (e.g. `QUALIFY row_number() OVER (PARTITION BY order_id ORDER BY updated_at
+DESC) = 1`). A source that still has two rows for one key is rejected at run
+time rather than double-written (see `ducklake-materialization.md`).
+
 This is what dbt's `unique_key` does. Orthogonal to partitioning:
 `partitioned` answers "which slice?"; `unique_key` answers "how do I dedup
 inside the slice?"
diff --git a/docs/validation.md b/docs/validation.md
index ba775d01cf..3bfd1325ce 100644
--- a/docs/validation.md
+++ b/docs/validation.md
@@ -10,6 +10,7 @@ After making changes, run the appropriate checks and fix all errors before consi
 | Enterprise code (`*_ee.rs`) | `cargo check --features enterprise,private` | Also do EE PR workflow (see `docs/enterprise.md`) |
 | Enterprise + license-gated code | `cargo check --features enterprise,private,license` | When the feature requires a valid license key |
 | Kafka trigger code | `cargo check --features kafka` | |
+| DuckDB executor code | `cargo check -p windmill-worker --features duckdb` | `duckdb_executor.rs` (and its `#[cfg(test)]` tests) only compile with this flag — a plain check/test silently skips them |
 | Native trigger code | `cargo check --features native_trigger` | |
 | Parquet code | `cargo check --features parquet` | |
 | Multiple gated modules | `cargo check --features enterprise,parquet` | Combine only the flags you need |
diff --git a/frontend/package-lock.json b/frontend/package-lock.json
index c85b88bf9c..ee189c34b9 100644
--- a/frontend/package-lock.json
+++ b/frontend/package-lock.json
@@ -1,12 +1,12 @@
 {
 	"name": "@windmill-labs/components",
-	"version": "1.747.0",
+	"version": "1.749.0",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "@windmill-labs/components",
-			"version": "1.747.0",
+			"version": "1.749.0",
 			"hasInstallScript": true,
 			"license": "AGPL-3.0",
 			"dependencies": {
@@ -79,7 +79,7 @@
 				"vscode-languageclient": "~9.0.1",
 				"vscode-uri": "~3.1.0",
 				"vscode-ws-jsonrpc": "~3.5.0",
-				"windmill-parser-wasm-asset": "1.740.0",
+				"windmill-parser-wasm-asset": "1.749.0",
 				"windmill-parser-wasm-csharp": "1.510.1",
 				"windmill-parser-wasm-go": "1.510.1",
 				"windmill-parser-wasm-java": "1.510.1",
@@ -14260,9 +14260,9 @@
 			}
 		},
 		"node_modules/windmill-parser-wasm-asset": {
-			"version": "1.740.0",
-			"resolved": "https://registry.npmjs.org/windmill-parser-wasm-asset/-/windmill-parser-wasm-asset-1.740.0.tgz",
-			"integrity": "sha512-Dgn5sQ93vJpqTQkv9iAy25+bqH2bUnIMdCfERb2Tia0Ql9T6iHbQhi4yzH9FbGW4Drv9GP46Qyetphqvp8vFOw=="
+			"version": "1.749.0",
+			"resolved": "https://registry.npmjs.org/windmill-parser-wasm-asset/-/windmill-parser-wasm-asset-1.749.0.tgz",
+			"integrity": "sha512-gj8g9sWQ0tXKfXso7xJxR56sS8Loe/RsnFy+0af5R8siZeCag9ikquGbQ8d8kOqIK2U8eCNA0LqsU/xAFDJIOg=="
 		},
 		"node_modules/windmill-parser-wasm-csharp": {
 			"version": "1.510.1",
diff --git a/frontend/package.json b/frontend/package.json
index a862ecb654..c3dd30dda2 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -1,6 +1,6 @@
 {
 	"name": "@windmill-labs/components",
-	"version": "1.747.0",
+	"version": "1.749.0",
 	"scripts": {
 		"dev": "vite dev",
 		"dev:ui-builder": "mv static/ui_builder static/ui_builder.dev-disabled 2>/dev/null || true ; trap 'mv static/ui_builder.dev-disabled static/ui_builder 2>/dev/null || true' EXIT ; vite dev",
@@ -154,7 +154,7 @@
 		"vscode-languageclient": "~9.0.1",
 		"vscode-uri": "~3.1.0",
 		"vscode-ws-jsonrpc": "~3.5.0",
-		"windmill-parser-wasm-asset": "1.740.0",
+		"windmill-parser-wasm-asset": "1.749.0",
 		"windmill-parser-wasm-csharp": "1.510.1",
 		"windmill-parser-wasm-go": "1.510.1",
 		"windmill-parser-wasm-java": "1.510.1",
diff --git a/frontend/src/lib/components/AIProviderPicker.svelte b/frontend/src/lib/components/AIProviderPicker.svelte
index f6f2a4f43c..4392a2d513 100644
--- a/frontend/src/lib/components/AIProviderPicker.svelte
+++ b/frontend/src/lib/components/AIProviderPicker.svelte
@@ -11,6 +11,7 @@
 	import ToggleButtonMore from './common/toggleButton-v2/ToggleButtonMore.svelte'
 	import Toggle from './Toggle.svelte'
 	import { saveConfig, removeConfig, isSameAsStoredConfig } from './aiProviderStorage'
+	import AIReasoningEffortPicker from './AIReasoningEffortPicker.svelte'
 
 	interface Props {
 		value: ProviderConfig | undefined
@@ -106,6 +107,8 @@
 			value.kind = selectedProvider
 			value.resource = ''
 			value.model = ''
+			// Reasoning effort is model-specific; reset it with the model.
+			value.reasoning_effort = undefined
 		}
 	}
 
@@ -225,6 +228,18 @@
 			/>
 		</div>
 
+		<!-- Reasoning Effort (shown once a model is selected) -->
+		{#if value?.model}
+			<div class="flex flex-col gap-1">
+				<p class="text-xs font-normal text-primary">reasoning effort</p>
+				<AIReasoningEffortPicker
+					bind:value={() => value?.reasoning_effort, (v) => value && (value.reasoning_effort = v)}
+					providerConfig={value}
+					{disabled}
+				/>
+			</div>
+		{/if}
+
 		<!-- Use as Default Checkbox -->
 		<div class="flex justify-end pt-1">
 			<Toggle
diff --git a/frontend/src/lib/components/AIReasoningEffortPicker.svelte b/frontend/src/lib/components/AIReasoningEffortPicker.svelte
new file mode 100644
index 0000000000..3ebf94c9bf
--- /dev/null
+++ b/frontend/src/lib/components/AIReasoningEffortPicker.svelte
@@ -0,0 +1,106 @@
+<script lang="ts">
+	import { Brain, ChevronDown } from 'lucide-svelte'
+	import DropdownV2 from './DropdownV2.svelte'
+	import Button from './common/button/Button.svelte'
+	import type { Item } from '$lib/utils'
+	import type { AIProvider } from '$lib/gen'
+	import { getReasoningCapability, explicitOffToken } from './copilot/reasoningRegistry'
+
+	interface Props {
+		// The provider-native reasoning token sent to the model (e.g. `high`,
+		// `none`), or undefined to leave the provider default untouched.
+		value: string | undefined
+		// The selected provider config; only `kind` and `model` are read.
+		providerConfig: { kind?: AIProvider; model?: string } | string | undefined
+		disabled?: boolean
+	}
+
+	let { value = $bindable(), providerConfig, disabled = false }: Props = $props()
+
+	let provider = $derived(
+		typeof providerConfig === 'object'
+			? (providerConfig?.kind as AIProvider | undefined)
+			: undefined
+	)
+	let model = $derived(typeof providerConfig === 'object' ? providerConfig?.model : undefined)
+
+	let capability = $derived(
+		provider && model
+			? getReasoningCapability(provider, model)
+			: { supported: false, levels: [], canDisable: false }
+	)
+
+	// The token that turns reasoning off on a model that reasons by default
+	// (e.g. Gemini/OpenAI 'none'). Undefined means omission already disables it,
+	// so leaving the effort unset is itself off.
+	let offToken = $derived(provider && model ? explicitOffToken(provider, model) : undefined)
+
+	// When the model reasons only on request (Anthropic/Bedrock), an unset effort
+	// already means off, so the default choice is labelled "off". Models that
+	// reason by default keep a distinct "Model default" plus an explicit off.
+	let offViaOmission = $derived(capability.canDisable && offToken === undefined)
+
+	// Label shown on the trigger for the current selection.
+	let currentLabel = $derived(
+		!value ? (offViaOmission ? 'off' : 'Model default') : value === offToken ? 'off' : value
+	)
+
+	let items = $derived.by((): Item[] => {
+		const opts: Item[] = [
+			{
+				displayName: offViaOmission ? 'off' : 'Model default',
+				selected: !value,
+				action: () => (value = undefined)
+			}
+		]
+		if (capability.canDisable && offToken !== undefined) {
+			opts.push({
+				displayName: 'off',
+				selected: value === offToken,
+				action: () => (value = offToken)
+			})
+		}
+		for (const level of capability.levels) {
+			opts.push({ displayName: level, selected: value === level, action: () => (value = level) })
+		}
+		return opts
+	})
+
+	// Clear a stale selection once the model no longer accepts it — either it
+	// can't reason at all, or the token isn't a valid level/off for this model
+	// (e.g. carrying `xhigh` from Opus onto a model that tops out at `high`).
+	// Sending an unsupported token would be rejected by the provider.
+	$effect(() => {
+		if (!provider || !model || value === undefined) return
+		// Valid values are exactly the selectable options: the levels, plus the
+		// explicit off token only when this model can actually disable reasoning.
+		const valid =
+			capability.supported &&
+			(capability.levels.includes(value) ||
+				(capability.canDisable && offToken !== undefined && value === offToken))
+		if (!valid) value = undefined
+	})
+</script>
+
+{#if !provider || !model}
+	<div class="text-xs text-tertiary">Select a model to configure reasoning effort.</div>
+{:else if !capability.supported}
+	<div class="text-xs text-tertiary">The selected model does not support reasoning effort.</div>
+{:else}
+	<DropdownV2 {items} {disabled} placement="bottom-start" fixedHeight={false} class="justify-start">
+		{#snippet buttonReplacement()}
+			<Button
+				nonCaptureEvent
+				{disabled}
+				unifiedSize="xs"
+				variant="default"
+				startIcon={{ icon: Brain }}
+				endIcon={{ icon: ChevronDown }}
+				btnClasses="w-full justify-between font-normal text-secondary"
+				title="Reasoning effort"
+			>
+				<span class="truncate">{currentLabel}</span>
+			</Button>
+		{/snippet}
+	</DropdownV2>
+{/if}
diff --git a/frontend/src/lib/components/CompareDrafts.svelte b/frontend/src/lib/components/CompareDrafts.svelte
index 867268cd1a..2614adf445 100644
--- a/frontend/src/lib/components/CompareDrafts.svelte
+++ b/frontend/src/lib/components/CompareDrafts.svelte
@@ -14,7 +14,13 @@
 	import { editUrlFor } from './sessions/forkEditUrl'
 	import { AppService, FlowService, ScriptService, type WorkspaceItemDiff } from '$lib/gen'
 	import { sendUserToast } from '$lib/toast'
-	import { getDraftDiffValues, deployDraft, discardDraft } from '$lib/utils_draft_deploy'
+	import {
+		getDraftDiffValues,
+		deployDraft,
+		discardDraft,
+		draftBaseIsStale
+	} from '$lib/utils_draft_deploy'
+	import { checkDeployPermission, type DeployPermission } from '$lib/utils_workspace_deploy'
 	import { type DraftItem, useWorkspaceDrafts } from '$lib/workspaceDrafts.svelte'
 	import type { Kind as LayoutKind } from '$lib/utils_deployable'
 	import { userStore } from '$lib/stores'
@@ -35,6 +41,15 @@
 		deployCount?: number
 		updateCount?: number
 		draftCount?: number
+		/** When set (reached via a session's Review button), preselect only the
+		 * rows this chat modified — `${UserDraftItemKind}:${path}` keys, matching
+		 * Row.key. Undefined → preselect all deployable rows (the default). All rows
+		 * are still shown either way. */
+		chatMask?: Set<string>
+		/** False while the (async) chatMask is still loading. The select-all default
+		 * waits for this so it doesn't race the mask and select everything. Defaults
+		 * to true for callers that don't pass a mask. */
+		chatMaskReady?: boolean
 		/** Selecting deploy_to/update asks the page to swap to CompareWorkspaces. */
 		onModeSelected?: (v: CompareMode) => void
 		/** Fired after a deploy/discard so the page can refresh the *fork*
@@ -52,6 +67,8 @@
 		deployCount = 0,
 		updateCount = 0,
 		draftCount = 0,
+		chatMask,
+		chatMaskReady = true,
 		onModeSelected,
 		onChanged
 	}: Props = $props()
@@ -216,27 +233,11 @@
 							path: item.path,
 							getDraft: true
 						}))) as any
-			// A draft is stale when the version it forked from no longer matches the
-			// current deployed head: a newer version was deployed after the draft began.
-			// Scripts compare `parent_hash` vs the deployed `hash`; flows the pinned
-			// `version_id` vs the deployed head `version_id`; apps the pinned
-			// `parent_version` vs the deployed head (`versions[last]`).
 			const draftBlob = r.draft as any
-			const appHead = Array.isArray(r.versions) ? r.versions[r.versions.length - 1] : undefined
-			const stale =
-				item.draftKind === 'script'
-					? !!r.hash && !!draftBlob?.parent_hash && draftBlob.parent_hash !== r.hash
-					: item.draftKind === 'flow'
-						? r.version_id != null &&
-							draftBlob?.version_id != null &&
-							draftBlob.version_id !== r.version_id
-						: appHead != null &&
-							draftBlob?.parent_version != null &&
-							draftBlob.parent_version !== appHead
 			summaryCache[item.key] = {
 				deployed: r.summary,
 				draft: draftBlob?.summary,
-				stale,
+				stale: draftBaseIsStale(item.draftKind, r),
 				loading: false
 			}
 		} catch (error) {
@@ -263,6 +264,21 @@
 
 	let selectedItems = $state<string[]>([])
 	let deploying = $state(false)
+
+	// Whether the user may deploy drafts into this workspace — fills the
+	// `RestrictDeployToDeployers` (+ operator) gap via the shared util, same as the
+	// fork compare page and the session review drawer. Fail-open while resolving.
+	let deployPerm = $state<DeployPermission>({ ok: true })
+	$effect(() => {
+		const ws = currentWorkspaceId
+		// Reset to fail-open on workspace change, and drop a stale resolution —
+		// otherwise the previous workspace's verdict lingers (or lands last) and
+		// gates the wrong workspace.
+		deployPerm = { ok: true }
+		void checkDeployPermission(ws).then((p) => {
+			if (ws === currentWorkspaceId) deployPerm = p
+		})
+	})
 	// Select all on the first non-empty load (deploy-all is the common intent);
 	// only once, so a refetch after a deploy doesn't re-select the leftovers.
 	let hasAutoSelected = $state(false)
@@ -286,8 +302,13 @@
 	})
 
 	$effect(() => {
-		if (!hasAutoSelected && visibleItems.length > 0) {
-			selectedItems = visibleItems.filter(isSelectable).map((i) => i.key)
+		if (!hasAutoSelected && chatMaskReady && visibleItems.length > 0) {
+			// Default intent is deploy-all; when reached from a session's Review
+			// (chatMask set), preselect only that chat's items instead.
+			const selectable = visibleItems.filter(isSelectable)
+			selectedItems = (chatMask ? selectable.filter((i) => chatMask.has(i.key)) : selectable).map(
+				(i) => i.key
+			)
 			hasAutoSelected = true
 		}
 	})
@@ -695,15 +716,19 @@
 			{/snippet}
 
 			{#snippet footer()}
-				<div class="flex items-center justify-end">
+				<div class="flex flex-col items-end gap-2">
 					<Button
 						variant="accent"
-						disabled={selectedCount === 0 || deploying}
+						disabled={selectedCount === 0 || deploying || !deployPerm.ok}
+						title={!deployPerm.ok ? deployPerm.reason : undefined}
 						loading={deploying}
 						onClick={deploySelected}
 					>
 						Deploy {selectedCount} draft{selectedCount !== 1 ? 's' : ''}
 					</Button>
+					{#if !deployPerm.ok}
+						<span class="text-xs text-yellow-600">{deployPerm.reason}</span>
+					{/if}
 				</div>
 			{/snippet}
 		</WorkspaceDeployLayout>
diff --git a/frontend/src/lib/components/CompareWorkspaces.svelte b/frontend/src/lib/components/CompareWorkspaces.svelte
index 8fbef7703c..a2453add27 100644
--- a/frontend/src/lib/components/CompareWorkspaces.svelte
+++ b/frontend/src/lib/components/CompareWorkspaces.svelte
@@ -37,10 +37,12 @@
 
 	import type { Kind } from '$lib/utils_deployable'
 	import {
+		checkDeployPermission,
 		deployItem,
 		deleteItemInWorkspace,
 		getItemValue,
 		getOnBehalfOf,
+		type DeployPermission,
 		type DeployResult
 	} from '$lib/utils_workspace_deploy'
 	import { isTriggerOrScheduleKind } from 'windmill-utils-internal'
@@ -58,6 +60,7 @@
 	import { base } from '$lib/base'
 	import CompareModeToggle, { type CompareMode } from './CompareModeToggle.svelte'
 	import { editUrlFor } from './sessions/forkEditUrl'
+	import { diffInMask } from './sessions/modifiedItemsMask'
 	import DatatableSchemaDiff from './DatatableSchemaDiff.svelte'
 
 	interface Props {
@@ -77,6 +80,14 @@
 		 * out of the default selection — deploying/updating moves the deployed
 		 * version, not the draft. The page derives this from the fork drafts. */
 		draftKeys?: Set<string>
+		/** When set (reached via a session's Review button), preselect only the
+		 * diffs this chat caused (matched via diffInMask). The deploy_to default
+		 * narrows to these; the update direction (parent→fork) preselects nothing,
+		 * since it's never chat-caused. All rows are still shown. */
+		chatMask?: Set<string>
+		/** False while the (async) chatMask is still loading. The select-all default
+		 * waits for this so it doesn't race the mask. Defaults to true. */
+		chatMaskReady?: boolean
 		/** Selecting `draft` asks the page to swap us out for CompareDrafts;
 		 * deploy_to/update are handled internally but reported so the page can
 		 * remember the direction. */
@@ -95,6 +106,8 @@
 		updateCount = 0,
 		draftCount = 0,
 		draftKeys = new Set<string>(),
+		chatMask,
+		chatMaskReady = true,
 		onModeSelected,
 		onChanged
 	}: Props = $props()
@@ -803,11 +816,19 @@
 		// to parent" flow. The user picks them à la carte by clicking the row.
 		// Items with a pending draft are also left out by default: the deployed
 		// version (not the draft) is what moves, so we make the user opt in.
+		// The update direction (parent→fork) is never something the chat caused, so
+		// when scoped to a chat's items (chatMask set) preselect nothing there.
+		if (chatMask && !mergeIntoParent) {
+			selectedItems = []
+			return
+		}
 		const filtered = selectableDiffs.filter((d) => !isTriggerOrScheduleKind(d.kind) && !hasDraft(d))
 		const conflictSafe = mergeIntoParent
 			? filtered
 			: filtered.filter((d) => !(d.ahead > 0 && d.behind > 0))
-		selectedItems = conflictSafe
+		// When reached from a session's Review, narrow the default to this chat's items.
+		const scoped = chatMask ? conflictSafe.filter((d) => diffInMask(d, chatMask)) : conflictSafe
+		selectedItems = scoped
 			.map((d) => getItemKey(d))
 			.filter((k) => !(deploymentStatus[k]?.status == 'deployed'))
 	}
@@ -849,6 +870,21 @@
 		fetchPermissions()
 	})
 
+	// Can the user actually deploy into the target workspace? Fills the frontend
+	// gap for the `RestrictDeployToDeployers` rule (+ operator), shared with the
+	// session review drawer via the same checkDeployPermission util. Cached per
+	// workspace; `deployPerm` tracks whichever side the current direction targets.
+	let deployPerms = $state<Record<string, DeployPermission>>({})
+	const deployPermFetched = new Set<string>()
+	$effect(() => {
+		for (const ws of [currentWorkspaceId, parentWorkspaceId]) {
+			if (!ws || deployPermFetched.has(ws)) continue
+			deployPermFetched.add(ws)
+			void checkDeployPermission(ws).then((p) => (deployPerms = { ...deployPerms, [ws]: p }))
+		}
+	})
+	let deployPerm = $derived(deployPerms[deployTargetWorkspace] ?? { ok: true })
+
 	// Fetch summaries and on_behalf_of_email when comparison data loads
 	$effect(() => {
 		if (comparison?.diffs) {
@@ -859,7 +895,7 @@
 
 	// Auto-select items on initial load
 	$effect(() => {
-		if (comparison?.diffs && !hasAutoSelected && selectableDiffs.length > 0) {
+		if (comparison?.diffs && !hasAutoSelected && chatMaskReady && selectableDiffs.length > 0) {
 			selectDefault()
 			hasAutoSelected = true
 		}
@@ -1424,7 +1460,9 @@
 											deploying ||
 											(hasBehindChanges && !allowBehindChangesOverride) ||
 											(mergeIntoParent && !canDeployToParent) ||
+											!deployPerm.ok ||
 											hasUnselectedOnBehalfOf}
+										title={!deployPerm.ok ? deployPerm.reason : undefined}
 										loading={deploying}
 										on:click={requestDeploy}
 									>
@@ -1435,6 +1473,9 @@
 										{/if}
 									</Button>
 								</div>
+								{#if !deployPerm.ok}
+									<span class="text-xs text-yellow-600">{deployPerm.reason}</span>
+								{/if}
 								{#if !(mergeIntoParent && !canDeployToParent) && hasUnselectedOnBehalfOf}
 									<span class="text-xs text-yellow-600">
 										You must set the "on behalf of" user for all items before deploying
diff --git a/frontend/src/lib/components/DataTestsResult.svelte b/frontend/src/lib/components/DataTestsResult.svelte
index cba28f3a82..385af187df 100644
--- a/frontend/src/lib/components/DataTestsResult.svelte
+++ b/frontend/src/lib/components/DataTestsResult.svelte
@@ -1,15 +1,22 @@
 <script lang="ts">
 	// Renders the per-test breakdown a managed `// materialize` run attaches to
-	// its result as `data_tests: [{ test, violating }]`. Shown above the raw
-	// result so "which tests ran, and which passed/failed" is clear at a glance.
-	// (On a failed run the job result is the error message — which already lists
-	// every test — so this success-path checklist and that error text together
-	// cover both outcomes.)
-	import { CheckCircle2, FlaskConical, XCircle } from 'lucide-svelte'
+	// its result as `data_tests: [{ test, violating, sample? }]`. Shown above
+	// the raw result so "which tests ran, and which passed/failed" is clear at
+	// a glance. A failed test may carry `sample` — a bounded, unordered sample
+	// of its violating rows — rendered as an expandable table. The sample is
+	// optional by contract: its absence only means no rows to show.
+	import { CheckCircle2, ChevronDown, ChevronRight, FlaskConical, XCircle } from 'lucide-svelte'
+	import { Button } from '$lib/components/common'
+	import AutoDataTable from '$lib/components/table/AutoDataTable.svelte'
+	import { SvelteSet } from 'svelte/reactivity'
 
-	let { tests }: { tests: Array<{ test: string; violating: number }> } = $props()
+	let {
+		tests
+	}: { tests: Array<{ test: string; violating: number; sample?: Record<string, any>[] }> } =
+		$props()
 
 	let failed = $derived(tests.filter((t) => t.violating > 0).length)
+	let expanded = new SvelteSet<string>()
 </script>
 
 <div
@@ -32,18 +39,40 @@
 	</div>
 	<ul class="divide-y divide-border">
 		{#each tests as t (t.test)}
-			<li class="flex items-center gap-1.5 px-2 py-1 font-mono">
-				{#if t.violating > 0}
-					<XCircle size={13} class="shrink-0 text-red-600 dark:text-red-400" />
-					<span class="sr-only">failed:</span>
-					<span class="text-primary">{t.test}</span>
-					<span class="text-red-600 dark:text-red-400"
-						>— {t.violating} violating row{t.violating === 1 ? '' : 's'}</span
-					>
-				{:else}
-					<CheckCircle2 size={13} class="shrink-0 text-emerald-600 dark:text-emerald-400" />
-					<span class="sr-only">passed:</span>
-					<span class="text-secondary">{t.test}</span>
+			<li class="px-2 py-1">
+				<div class="flex items-center gap-1.5 font-mono">
+					{#if t.violating > 0}
+						<XCircle size={13} class="shrink-0 text-red-600 dark:text-red-400" />
+						<span class="sr-only">failed:</span>
+						<span class="text-primary">{t.test}</span>
+						<span class="text-red-600 dark:text-red-400"
+							>— {t.violating} violating row{t.violating === 1 ? '' : 's'}</span
+						>
+						{#if t.sample && t.sample.length > 0}
+							<Button
+								variant="subtle"
+								unifiedSize="sm"
+								startIcon={{ icon: expanded.has(t.test) ? ChevronDown : ChevronRight }}
+								onclick={() => {
+									if (!expanded.delete(t.test)) expanded.add(t.test)
+								}}
+							>
+								{expanded.has(t.test) ? 'hide sample' : `view sample (${t.sample.length})`}
+							</Button>
+						{/if}
+					{:else}
+						<CheckCircle2 size={13} class="shrink-0 text-emerald-600 dark:text-emerald-400" />
+						<span class="sr-only">passed:</span>
+						<span class="text-secondary">{t.test}</span>
+					{/if}
+				</div>
+				{#if t.violating > 0 && t.sample && t.sample.length > 0 && expanded.has(t.test)}
+					<div class="mt-1 mb-1">
+						<div class="text-2xs text-tertiary mb-1">
+							sample of the violating rows ({t.sample.length} of {t.violating}, unordered)
+						</div>
+						<AutoDataTable objects={t.sample} />
+					</div>
 				{/if}
 			</li>
 		{/each}
diff --git a/frontend/src/lib/components/DisplayResult.svelte b/frontend/src/lib/components/DisplayResult.svelte
index cbd81086a9..efb1dd2da1 100644
--- a/frontend/src/lib/components/DisplayResult.svelte
+++ b/frontend/src/lib/components/DisplayResult.svelte
@@ -574,24 +574,53 @@
 	// formats are produced by this repo's worker (see duckdb_executor.rs); the
 	// derivation is inert (undefined) for every other DisplayResult use.
 	let dataTests = $derived.by(() => {
+		// Both structured shapes carry `[{ test, violating, sample? }]`; the
+		// sample (bounded violating-row rows) may arrive as a JSON string (the
+		// worker keeps it string-typed through the summary row) and is optional
+		// by contract — anything malformed degrades to no sample, never to a
+		// dropped checklist.
+		const normalize = (
+			dt: any
+		): Array<{ test: string; violating: number; sample?: Record<string, any>[] }> | undefined => {
+			if (typeof dt === 'string') {
+				try {
+					dt = JSON.parse(dt)
+				} catch {
+					return undefined
+				}
+			}
+			if (
+				!Array.isArray(dt) ||
+				dt.length === 0 ||
+				!dt.every((x) => x && typeof x.test === 'string' && typeof x.violating === 'number')
+			) {
+				return undefined
+			}
+			return dt.map((x) => {
+				let sample = x.sample
+				if (typeof sample === 'string') {
+					try {
+						sample = JSON.parse(sample)
+					} catch {
+						sample = undefined
+					}
+				}
+				if (!Array.isArray(sample) || !sample.every((r) => r && typeof r === 'object')) {
+					sample = undefined
+				}
+				return { test: x.test, violating: x.violating, sample }
+			})
+		}
 		// Success: structured column on the summary row.
 		const row = Array.isArray(result) ? (result as any)?.[0] : (result as any)
-		let dt = row?.data_tests
-		if (typeof dt === 'string') {
-			try {
-				dt = JSON.parse(dt)
-			} catch {
-				dt = undefined
-			}
-		}
-		if (
-			Array.isArray(dt) &&
-			dt.length > 0 &&
-			dt.every((x) => x && typeof x.test === 'string' && typeof x.violating === 'number')
-		) {
-			return dt as Array<{ test: string; violating: number }>
-		}
-		// Failure: parse the worker's breakdown out of the error message.
+		const fromRow = normalize(row?.data_tests)
+		if (fromRow) return fromRow
+		// Failure: the worker attaches the same structured breakdown (plus
+		// per-failed-test samples) to the error payload.
+		const fromError = normalize((result as any)?.error?.data_tests)
+		if (fromError) return fromError
+		// Failure fallback for results predating the structured error payload:
+		// parse the worker's breakdown out of the error message.
 		const msg = (result as any)?.error?.message
 		if (typeof msg === 'string' && msg.includes('data tests failed on')) {
 			const out: Array<{ test: string; violating: number }> = []
diff --git a/frontend/src/lib/components/DraftBadge.svelte b/frontend/src/lib/components/DraftBadge.svelte
index 75cc6cec0b..1527feef73 100644
--- a/frontend/src/lib/components/DraftBadge.svelte
+++ b/frontend/src/lib/components/DraftBadge.svelte
@@ -38,6 +38,10 @@
 		/** Offer "Load" alongside "View Diff" on other users' rows. The deploy /
 		 * review page sets this false: loading into a fresh editor is moot there. */
 		allowFork?: boolean
+		/** Compact variant: render only the avatar circles (no "Draft" pill text),
+		 * slightly smaller — for tight spots like the diff-tree sidebar. The hover
+		 * popover is unchanged. */
+		iconOnly?: boolean
 	}
 
 	let {
@@ -49,7 +53,8 @@
 		itemKind = undefined,
 		path = undefined,
 		onMigrated = undefined,
-		allowFork = true
+		allowFork = true,
+		iconOnly = false
 	}: Props = $props()
 
 	// Authed user lands first; everyone else keeps the backend's ordering.
@@ -193,6 +198,30 @@
 	}
 </script>
 
+{#snippet circleStack()}
+	<!-- `-space-x-1` overlaps the circles; the indigo ring tint makes the overlap read intentional. -->
+	<span class="flex -space-x-1">
+		{#each visibleUsers as u, i (i)}
+			<span
+				class="inline-flex h-3 w-3 items-center justify-center rounded-full text-[8px] font-semibold text-white ring-1 ring-indigo-100 dark:ring-indigo-700/40 {colorFor(
+					u
+				)}"
+				title={u.username === currentUsername ? `${fullLabel(u)} (you)` : fullLabel(u)}
+			>
+				{initials(u)}
+			</span>
+		{/each}
+		{#if overflowCount > 0}
+			<span
+				class="inline-flex h-3 w-3 items-center justify-center rounded-full bg-gray-500 text-[8px] font-semibold text-white ring-1 ring-indigo-100 dark:ring-indigo-700/40"
+				title="{overflowCount} more"
+			>
+				+{overflowCount}
+			</span>
+		{/if}
+	</span>
+{/snippet}
+
 {#if showBadge}
 	<!-- inline-flex/items-center so the trigger button hugs the badge and lines up
 	     with sibling badges (a plain button is taller, dropping the pill ~2px). -->
@@ -204,32 +233,23 @@
 		bind:isOpen={popoverOpen}
 	>
 		{#snippet trigger()}
-			<Badge small color="indigo">
-				{#if orderedUsers.length > 0}
-					<!-- `-space-x-1` overlaps the circles; the indigo ring tint makes the overlap read intentional. -->
-					<span class="flex -space-x-1">
-						{#each visibleUsers as u, i (i)}
-							<span
-								class="inline-flex h-3.5 w-3.5 items-center justify-center rounded-full text-[8px] font-semibold text-white ring-1 ring-indigo-100 dark:ring-indigo-700/40 {colorFor(
-									u
-								)}"
-								title={u.username === currentUsername ? `${fullLabel(u)} (you)` : fullLabel(u)}
-							>
-								{initials(u)}
-							</span>
-						{/each}
-						{#if overflowCount > 0}
-							<span
-								class="inline-flex h-3.5 w-3.5 items-center justify-center rounded-full bg-gray-500 text-[8px] font-semibold text-white ring-1 ring-indigo-100 dark:ring-indigo-700/40"
-								title="{overflowCount} more"
-							>
-								+{overflowCount}
-							</span>
-						{/if}
-					</span>
-				{/if}
-				{draft_only ? 'Draft only' : 'Draft'}
-			</Badge>
+			{#if iconOnly}
+				<!-- Compact "has a draft" marker for tight spots like the diff-tree
+				     sidebar: a small indigo pencil + the author avatar(s). -->
+				<span class="inline-flex items-center gap-0.5" title={draft_only ? 'Draft only' : 'Draft'}>
+					<Pencil class="h-3 w-3 shrink-0 text-indigo-500 dark:text-indigo-400" />
+					{#if orderedUsers.length > 0}
+						{@render circleStack()}
+					{/if}
+				</span>
+			{:else}
+				<Badge small color="indigo" class="px-1 py-0 gap-0.5">
+					{#if orderedUsers.length > 0}
+						{@render circleStack()}
+					{/if}
+					{draft_only ? 'Draft only' : 'Draft'}
+				</Badge>
+			{/if}
 		{/snippet}
 		{#snippet content()}
 			<div class="flex flex-col gap-2 min-w-[16rem] text-xs p-4 pb-1">
diff --git a/frontend/src/lib/components/Editor.svelte b/frontend/src/lib/components/Editor.svelte
index 2054dc8cf1..8563190a89 100644
--- a/frontend/src/lib/components/Editor.svelte
+++ b/frontend/src/lib/components/Editor.svelte
@@ -92,6 +92,11 @@
 		listWorkspaceMacrosCached,
 		macroDefinitionSql
 	} from '$lib/components/assets/workspaceMacros'
+	import {
+		fetchLatestSchema,
+		normalizeAssetPath,
+		type ContractMarker
+	} from '$lib/components/assets/AssetGraph/schemaContracts'
 	import * as htmllang from '$lib/svelteMonarch'
 	import { conf, language } from '$lib/vueMonarch'
 
@@ -163,6 +168,11 @@
 		preparedAssetsSqlQueries?: InferAssetsSqlQueryDetails[] | undefined
 		// To execute preview scripts with the right worker group
 		customTag?: string
+		// Live schema-contract diagnostics (pipelines gap #2b): owner-scoped
+		// warning markers computed by the caller (ScriptEditor's contract
+		// mirror) from the buffer's asset refs vs captured producer schemas.
+		// Warning severity only — contracts never block; empty clears.
+		schemaContractMarkers?: ContractMarker[]
 	}
 
 	let {
@@ -195,7 +205,8 @@
 		enablePreprocessorSnippet = false,
 		rawAppRunnableKey = undefined,
 		preparedAssetsSqlQueries,
-		customTag
+		customTag,
+		schemaContractMarkers = []
 	}: Props = $props()
 
 	$effect.pre(() => {
@@ -706,6 +717,53 @@
 		})
 	}
 
+	let schemaContractCompletor: IDisposable | undefined = undefined
+
+	// Column-name completion for pipeline annotation refs (`// column out <-
+	// ducklake://lake/orders.|`, `// data_test relationships col ->
+	// ducklake://lake/customers.|`): suggests the referenced asset's *captured*
+	// columns (with types) so a broken ref never gets typed — the prevention
+	// side of the schema-contract check. Only fires on annotation comment lines
+	// with a ducklake URI right before the cursor's `.`; schemas come from the
+	// short-TTL contract cache, so per-keystroke cost is a map lookup.
+	function addSchemaContractCompletions() {
+		schemaContractCompletor?.dispose()
+		schemaContractCompletor = languages.registerCompletionItemProvider(lang, {
+			triggerCharacters: ['.'],
+			provideCompletionItems: async function (model, position) {
+				// Read the store per request, not at registration — the provider
+				// outlives a workspace switch.
+				const workspace = $workspaceStore
+				if (!workspace) return { suggestions: [] }
+				const before = model.getLineContent(position.lineNumber).slice(0, position.column - 1)
+				if (!/^\s*(\/\/|--|#)\s*(column|data_test|on|materialize)\b/.test(before)) {
+					return { suggestions: [] }
+				}
+				const uri = before.match(/ducklake:\/\/([\w/.{}-]+?)\.$/)
+				if (!uri) return { suggestions: [] }
+				const schema = await fetchLatestSchema(workspace, normalizeAssetPath(uri[1]))
+				if (!schema) return { suggestions: [] }
+				const word = model.getWordUntilPosition(position)
+				const range = {
+					startLineNumber: position.lineNumber,
+					endLineNumber: position.lineNumber,
+					startColumn: word.startColumn,
+					endColumn: word.endColumn
+				}
+				return {
+					suggestions: schema.columns.map((c) => ({
+						label: c.name,
+						kind: languages.CompletionItemKind.Field,
+						detail: `${c.type} · captured schema v${schema.version}`,
+						insertText: c.name,
+						range,
+						sortText: 'a' + c.name
+					}))
+				}
+			}
+		})
+	}
+
 	let sqlSchemaCompletor: IDisposable | undefined = undefined
 
 	async function updateSchema(newSchemaRes: string | undefined) {
@@ -1916,6 +1974,7 @@
 		sqlTypeCompletor && sqlTypeCompletor.dispose()
 		resultCollectionCompletor && resultCollectionCompletor.dispose()
 		workspaceMacroCompletor && workspaceMacroCompletor.dispose()
+		schemaContractCompletor && schemaContractCompletor.dispose()
 		preprocessorCompletor && preprocessorCompletor.dispose()
 		timeoutModel && clearTimeout(timeoutModel)
 		changeChainStart = undefined
@@ -1999,6 +2058,36 @@
 			: workspaceMacroCompletor?.dispose()
 	})
 
+	// Pipeline annotation grammar is language-agnostic (`//` / `--` / `#`
+	// comment headers), so contract-ref completions register for every script
+	// language that can be a pipeline member. The provider line-gates itself,
+	// so it is inert outside annotation lines.
+	$effect(() => {
+		initialized && ['duckdb', 'python3', 'bun', 'deno', 'nativets'].includes(scriptLang ?? '')
+			? untrack(() => addSchemaContractCompletions())
+			: schemaContractCompletor?.dispose()
+	})
+
+	// Schema-contract markers arrive as a prop because the mirror can finish
+	// computing before Monaco initializes on mount — reacting to `initialized`
+	// re-applies the pending set once the model exists. The ever-set latch
+	// keeps unrelated editors from calling setModelMarkers with [] forever.
+	let contractMarkersEverSet = false
+	$effect(() => {
+		const ms = schemaContractMarkers
+		if (!initialized || (ms.length === 0 && !contractMarkersEverSet)) return
+		contractMarkersEverSet = true
+		untrack(() => {
+			const model = editor?.getModel()
+			if (!model) return
+			meditor.setModelMarkers(
+				model,
+				'schema-contracts',
+				ms.map((m) => ({ ...m, severity: MarkerSeverity.Warning }))
+			)
+		})
+	})
+
 	$effect(() => {
 		initialized && canHavePreprocessor(lang) && enablePreprocessorSnippet
 			? untrack(() => addPreprocessorCompletions(lang))
diff --git a/frontend/src/lib/components/ScriptBuilder.svelte b/frontend/src/lib/components/ScriptBuilder.svelte
index fbfa4f1c1b..7d639b2c75 100644
--- a/frontend/src/lib/components/ScriptBuilder.svelte
+++ b/frontend/src/lib/components/ScriptBuilder.svelte
@@ -41,6 +41,7 @@
 	} from '$lib/utils'
 	import Path from './Path.svelte'
 	import { invalidateWorkspacePaths } from './PathNameAutocomplete.svelte'
+	import { notifyContractWarnings } from './assets/AssetGraph/schemaContracts'
 	import ScriptEditor from './ScriptEditor.svelte'
 	import { Alert, Button, Drawer, SecondsInput, Tab, TabContent, Tabs } from './common'
 	import LanguageIcon from './common/languageIcons/LanguageIcon.svelte'
@@ -654,6 +655,11 @@
 			// cache so it shows up immediately instead of after the 60s TTL.
 			invalidateWorkspacePaths($workspaceStore!)
 
+			// Authoritative save-time schema-contract check (pipelines gap #2b):
+			// warn-only, post-commit so a self-produced target resolves to the
+			// content just deployed. Fire-and-forget — must never gate the deploy.
+			notifyContractWarnings($workspaceStore!, script.language, script.content)
+
 			if (!initialPath) {
 				await CaptureService.moveCapturesAndConfigs({
 					workspace: $workspaceStore!,
diff --git a/frontend/src/lib/components/ScriptEditor.svelte b/frontend/src/lib/components/ScriptEditor.svelte
index 575c303b06..8ff211f1c2 100644
--- a/frontend/src/lib/components/ScriptEditor.svelte
+++ b/frontend/src/lib/components/ScriptEditor.svelte
@@ -105,6 +105,11 @@
 	import { canHavePreprocessor } from '$lib/script_helpers'
 	import { assetEq, type AssetWithAltAccessType } from './assets/lib'
 	import type { ColumnLineage } from './assets/AssetGraph/parsePipelineAnnotations'
+	import {
+		computeContractMarkers,
+		type ContractMarker,
+		type SchemaContractGraphContext
+	} from './assets/AssetGraph/schemaContracts'
 	import { editor as meditor } from 'monaco-editor'
 	import type { ReviewChangesOpts } from './copilot/chat/monaco-adapter'
 	import GitRepoViewer from './GitRepoViewer.svelte'
@@ -202,6 +207,11 @@
 		// regular /scripts/edit route keeps its current open-by-default UX;
 		// the session preview opts in to save vertical real estate.
 		initialTestPanelCollapsed?: boolean
+		// Producer-side facts for the live schema-contract diagnostics
+		// (`on_schema_change=ignore` suppression + scd2 `_current` fallback),
+		// built by the pipeline page from the resolved graph. Absent outside the
+		// pipeline editor — the check still runs, just without suppression.
+		schemaContractContext?: SchemaContractGraphContext
 	}
 
 	let {
@@ -242,7 +252,8 @@
 		previewLayout = 'right',
 		onTestStateChange,
 		onTestJob,
-		initialTestPanelCollapsed = false
+		initialTestPanelCollapsed = false,
+		schemaContractContext = undefined
 	}: Props = $props()
 
 	$effect(() => {
@@ -614,6 +625,35 @@
 		}
 	)
 
+	// Live schema-contract diagnostics (pipelines gap #2b): diff the buffer's
+	// asset refs against the captured producer schemas and surface mismatches
+	// as Monaco warning squiggles — the as-you-type mirror of the authoritative
+	// save-time check. The result is a prop on Editor (not an imperative call)
+	// because this can resolve before Monaco initializes on mount. Sequenced so
+	// a slow schema fetch can't overwrite the markers of a newer keystroke.
+	let contractMarkers: ContractMarker[] = $state([])
+	let contractCheckSeq = 0
+	watch([() => inferAssetsRes.current, () => schemaContractContext], () => {
+		const res = inferAssetsRes.current
+		const workspace = $workspaceStore
+		const seq = ++contractCheckSeq
+		if (!workspace || !res || res.status === 'error') {
+			contractMarkers = []
+			return
+		}
+		const bufferCode = code
+		computeContractMarkers(
+			workspace,
+			bufferCode,
+			(res.assets ?? []) as AssetWithAltAccessType[],
+			schemaContractContext
+		)
+			.then((markers) => {
+				if (seq === contractCheckSeq) contractMarkers = markers
+			})
+			.catch((e) => console.error('schema-contract diagnostics failed', e))
+	})
+
 	watch([() => code, () => lang], () => {
 		if (lang !== 'ansible') return
 		inferAnsibleExecutionMode(code).then((v) => {
@@ -2612,6 +2652,7 @@
 			bind:code={editorCode}
 			bind:websocketAlive
 			bind:this={editor}
+			schemaContractMarkers={contractMarkers}
 			{yContent}
 			awareness={wsProvider?.awareness}
 			on:change={(e) => {
diff --git a/frontend/src/lib/components/aiProviderStorage.ts b/frontend/src/lib/components/aiProviderStorage.ts
index ce6af230bb..7f6d705d3a 100644
--- a/frontend/src/lib/components/aiProviderStorage.ts
+++ b/frontend/src/lib/components/aiProviderStorage.ts
@@ -50,6 +50,7 @@ export function isSameAsStoredConfig(config: ProviderConfig | undefined): boolea
 		storedConfig !== undefined &&
 		storedConfig.kind === config?.kind &&
 		storedConfig.resource === config?.resource &&
-		storedConfig.model === config?.model
+		storedConfig.model === config?.model &&
+		storedConfig.reasoning_effort === config?.reasoning_effort
 	)
 }
diff --git a/frontend/src/lib/components/assets/AssetGraph/ActivityHistogram.svelte b/frontend/src/lib/components/assets/AssetGraph/ActivityHistogram.svelte
index fcfd95a5d3..cd9548de59 100644
--- a/frontend/src/lib/components/assets/AssetGraph/ActivityHistogram.svelte
+++ b/frontend/src/lib/components/assets/AssetGraph/ActivityHistogram.svelte
@@ -147,9 +147,10 @@
 			></div>
 		{/if}
 	</div>
-	<!-- Always-on window axis: the period the bars span. -->
+	<!-- Always-on window axis: the period the bars span. The `from` prefix keeps
+	     the left edge from reading as a date header for the run list below it. -->
 	<div class="flex justify-between text-3xs text-tertiary tabular-nums mt-0.5">
-		<span>{fmtTime(from)}</span>
+		<span>from {fmtTime(from)}</span>
 		<span>now</span>
 	</div>
 </div>
diff --git a/frontend/src/lib/components/assets/AssetGraph/AssetGraphCanvas.svelte b/frontend/src/lib/components/assets/AssetGraph/AssetGraphCanvas.svelte
index 1c5cf2dde6..6f8460fa10 100644
--- a/frontend/src/lib/components/assets/AssetGraph/AssetGraphCanvas.svelte
+++ b/frontend/src/lib/components/assets/AssetGraph/AssetGraphCanvas.svelte
@@ -142,8 +142,8 @@
 		// editor passes it, so the asset-graph page is unaffected. The page
 		// clears it once the pan has had time to settle.
 		panToNodeId?: string | undefined
-		// Script paths eligible to *start* a bounded-cascade run (schedule
-		// roots + manual roots — see boundedCascade.validStarts). When a path is
+		// Script paths eligible to *start* a bounded-cascade run — roots AND
+		// mid-DAG models (see boundedCascade.validFromStarts). When a path is
 		// in this set and `onStartBoundedRun` is wired, its node's cascade menu
 		// gains a "Run downstream up to…" entry.
 		validStartPaths?: ReadonlySet<string>
@@ -222,6 +222,7 @@
 			| 'add-anchor'
 			| 'data-test'
 			| 'macro'
+			| 'test-dependency'
 		unsaved?: boolean
 		// Edge from a missing-trigger placeholder — styled red dashed to
 		// signal "this script declared `// on kafka` but no trigger row
@@ -322,19 +323,59 @@
 		// own adjacency (boundedCascade.buildLineageDownstreamMap).
 		const hasLineageDownstream = new Set<string>(buildLineageDownstreamMap(g).keys())
 
+		// Producers that declare `// data_test` checks, keyed by runnable id — the
+		// asset node uses this (plus the producer's run state) to render the
+		// data-test outcome badge. Tests only assert on ducklake `// materialize`
+		// targets (v1), so guard status is a ducklake-only concept below.
+		const producerHasTests = new Set<string>()
+		// Producer → its declared `// materialize` target, so a multi-output
+		// producer's guard badge lands only on the table its tests assert on —
+		// not on its other ducklake outputs. Mirrors the write-edge badge anchor.
+		const guardMaterializeTarget = new Map<
+			string,
+			NonNullable<AssetGraphResponse['runnables'][number]['materialize_target']>
+		>()
+		for (const r of g.runnables) {
+			if (r.data_tests && r.data_tests.length > 0) producerHasTests.add(`${r.usage_kind}:${r.path}`)
+			if (r.materialize_target)
+				guardMaterializeTarget.set(`${r.usage_kind}:${r.path}`, r.materialize_target)
+		}
+
 		for (const a of g.assets) {
 			const assetId = `asset:${a.kind}:${a.path}`
+			// Guard/outcome badge inputs: is a producer of this (ducklake) asset
+			// test-guarded, and did that guarded producer's latest run fail?
+			let dataTestGuarded = false
+			let producerFailed = false
+			if (a.kind === 'ducklake') {
+				for (const p of producersByAsset.get(`${a.kind}:${a.path}`) ?? []) {
+					const rid = `${p.kind}:${p.path}`
+					if (!producerHasTests.has(rid)) continue
+					// Tests assert on the producer's `// materialize` target; when the
+					// producer declares one, only that table is guarded (a multi-output
+					// producer must not badge its other ducklake writes). No declared
+					// target → single-output producer, so its lone ducklake write is it.
+					const mt = guardMaterializeTarget.get(rid)
+					if (mt && !(mt.kind === a.kind && mt.path === a.path)) continue
+					dataTestGuarded = true
+					if (runStates?.get(rid)?.status === 'failure') producerFailed = true
+				}
+			}
 			nodes.push({
 				id: assetId,
 				type: 'asset',
 				data: {
 					asset_kind: a.kind,
 					path: a.path,
+					fork_materialization: a.fork_materialization,
+					derived_from: a.derived_from,
 					onAddScript: onAddScriptForAsset,
 					pathPrefix,
 					defaultPathSuffix,
 					producers: producersByAsset.get(`${a.kind}:${a.path}`) ?? [],
-					onRunProducer
+					onRunProducer,
+					dataTestGuarded,
+					producerFailed
 				}
 			})
 		}
@@ -401,6 +442,7 @@
 					in_pipeline: r.in_pipeline ?? false,
 					partition_kind: r.partition_kind,
 					freshness: r.freshness,
+					last_success_at: r.last_success_at,
 					tag: r.tag,
 					retry: r.retry,
 					macros: r.macros,
@@ -521,6 +563,22 @@
 			})
 		}
 
+		// Data-test ordering edges (producer → tested script): the referenced
+		// asset must be materialized before the test runs, so the cascade orders
+		// the producer first. Rendered as a dashed "must run after" link, distinct
+		// from data flow — the tested script doesn't consume the asset's rows.
+		for (const te of g.test_edges ?? []) {
+			const producerId = `${te.producer_kind}:${te.producer_path}`
+			const testedId = `${te.runnable_kind}:${te.runnable_path}`
+			if (!runnableNodeIds.has(producerId) || !runnableNodeIds.has(testedId)) continue
+			edges.push({
+				id: `testdep:${producerId}->${testedId}`,
+				source: producerId,
+				target: testedId,
+				kind: 'test-dependency'
+			})
+		}
+
 		// Non-asset triggers (schedule + native) are rendered as source nodes
 		// above the pipeline script. Real (non-missing) nodes are
 		// deduplicated per (kind, ref) tuple so a single schedule shared
@@ -949,6 +1007,16 @@
 						label = e.via_use ? 'uses lib' : 'macros'
 						labelStyle = 'fill: rgb(139 92 246); font-size: 10px; font-weight: 600;'
 						break
+					case 'test-dependency':
+						// Producer → tested script: amber dashed ordering link. Not
+						// data flow (blue/gray) nor execution trigger (gray "triggers")
+						// — it only says "the test needs this asset to exist first".
+						style = 'stroke: rgb(217 119 6); stroke-width: 1.25px;'
+						strokeDasharray = '5 3'
+						markerColor = 'rgb(217 119 6)'
+						label = 'test needs'
+						labelStyle = 'fill: rgb(217 119 6); font-size: 10px; font-weight: 600;'
+						break
 					default:
 						style = ''
 				}
diff --git a/frontend/src/lib/components/assets/AssetGraph/AssetGraphDetailsPane.svelte b/frontend/src/lib/components/assets/AssetGraph/AssetGraphDetailsPane.svelte
index 1abe21f76d..095169e3b7 100644
--- a/frontend/src/lib/components/assets/AssetGraph/AssetGraphDetailsPane.svelte
+++ b/frontend/src/lib/components/assets/AssetGraph/AssetGraphDetailsPane.svelte
@@ -1,5 +1,5 @@
 <script lang="ts">
-	import { ScriptService, type Script } from '$lib/gen'
+	import { ScriptService, type Script, type ScriptLang } from '$lib/gen'
 	import { resource } from 'runed'
 	import { base } from '$lib/base'
 	import Button from '$lib/components/common/button/Button.svelte'
@@ -8,9 +8,11 @@
 	import { formatAssetKind, type AssetWithAltAccessType } from '$lib/components/assets/lib'
 	import {
 		AlertTriangle,
+		ArrowUpRight,
 		Code2,
 		ExternalLink,
 		GitBranch,
+		GitFork,
 		Loader2,
 		PanelRightClose,
 		Save,
@@ -38,6 +40,7 @@
 	import S3FilePreview from '$lib/components/S3FilePreview.svelte'
 	import DataTablePreview from './DataTablePreview.svelte'
 	import DucklakeAssetPanel from './DucklakeAssetPanel.svelte'
+	import { notifyContractWarnings, type SchemaContractGraphContext } from './schemaContracts'
 	import AssetRunsPanel from './AssetRunsPanel.svelte'
 	import { Pane, Splitpanes } from 'svelte-splitpanes'
 	import { fade } from 'svelte/transition'
@@ -146,6 +149,15 @@
 		// `replace` producer). Forwarded to the Schema tab: version history when
 		// true, a single fixed-schema view when false. Defaults to true (unknown).
 		schemaCanEvolve?: boolean
+		// Fork workspaces: data-environment state of the selected ducklake asset
+		// ('fork' = materialized here, 'deferred' = reads the parent's current
+		// data). Pulled from the graph node by the parent page, like
+		// `schemaCanEvolve`. Undefined outside forks.
+		selectionForkMaterialization?: 'fork' | 'deferred'
+		// Producer-side facts for the editor's live schema-contract diagnostics
+		// (ignore suppression + scd2 `_current` fallback), built by the page from
+		// the resolved graph and forwarded to ScriptEditor.
+		schemaContractContext?: SchemaContractGraphContext
 		// Bumped by the parent after dispatching a run so the runs panel
 		// re-fetches the listing immediately (rather than waiting on its
 		// background poll tick).
@@ -254,6 +266,8 @@
 		selectionProducers = [],
 		selectionColumnGraph,
 		schemaCanEvolve = true,
+		selectionForkMaterialization = undefined,
+		schemaContractContext = undefined,
 		runsRefreshKey,
 		runsPendingJobId,
 		onRunCompleted,
@@ -664,6 +678,9 @@
 			// same parent").
 			if (typeof newHash === 'string' && newHash) script.hash = newHash
 			sendUserToast(`Saved ${script.path}`)
+			// Authoritative save-time schema-contract check (pipelines gap #2b):
+			// warn-only, post-commit. Fire-and-forget — must never gate the save.
+			notifyContractWarnings(workspace, script.language as ScriptLang, script.content)
 			if (isDraft) {
 				onDraftSaved?.(script.path)
 			} else {
@@ -1056,6 +1073,31 @@
 								     selected snapshot / tab instead of carrying state across. -->
 								{#key selection.path}
 									<div class="flex flex-col h-full overflow-auto">
+										{#if selectionForkMaterialization === 'deferred'}
+											<!-- Fork data environment: this asset has no fork copy yet;
+											     jobs here read the PARENT's live table through a defer
+											     view. Partition grid / history below reflect the (empty)
+											     fork namespace, hence the explicit callout. -->
+											<div
+												class="shrink-0 flex items-center gap-2 px-3 py-1.5 text-2xs bg-amber-50 dark:bg-amber-950/40 border-b border-amber-200 dark:border-amber-900/60 text-amber-700 dark:text-amber-300"
+											>
+												<ArrowUpRight size={12} class="shrink-0" />
+												<span class="truncate">
+													Deferred to parent workspace — reads its current data (not
+													snapshot-pinned). Materialize this node in the fork to iterate on it.
+												</span>
+											</div>
+										{:else if selectionForkMaterialization === 'fork'}
+											<div
+												class="shrink-0 flex items-center gap-2 px-3 py-1.5 text-2xs bg-emerald-50 dark:bg-emerald-950/40 border-b border-emerald-200 dark:border-emerald-900/60 text-emerald-700 dark:text-emerald-300"
+											>
+												<GitFork size={12} class="shrink-0" />
+												<span class="truncate">
+													Materialized in this fork — reads and writes use the fork's isolated
+													namespace; the parent workspace's table is untouched.
+												</span>
+											</div>
+										{/if}
 										{#if selectionColumnGraph && assetColumnNodes(selectionColumnGraph, selection.asset_kind, selection.path).length > 0}
 											<div class="border-b shrink-0">
 												<ColumnLineageTrace
@@ -1155,6 +1197,7 @@
 							showCaptures={false}
 							noSyncFromGithub
 							requireValidAssets
+							{schemaContractContext}
 							lang={script.language}
 							path={script.path}
 							tag={script.tag}
diff --git a/frontend/src/lib/components/assets/AssetGraph/AssetNode.svelte b/frontend/src/lib/components/assets/AssetGraph/AssetNode.svelte
index b5cba208e1..762bdbc0fc 100644
--- a/frontend/src/lib/components/assets/AssetGraph/AssetNode.svelte
+++ b/frontend/src/lib/components/assets/AssetGraph/AssetNode.svelte
@@ -5,9 +5,19 @@
 	import { formatShortAssetPath, type AssetKind } from '$lib/components/assets/lib'
 	import { NODE } from '$lib/components/graph/util'
 	import PipelineInsertMenu, { type PipelineInsertPick } from './PipelineInsertMenu.svelte'
-	import { Code2, Play, Loader2, Plus } from 'lucide-svelte'
+	import {
+		ArrowUpRight,
+		Code2,
+		GitFork,
+		History,
+		Play,
+		Loader2,
+		Plus,
+		ShieldCheck,
+		ShieldAlert
+	} from 'lucide-svelte'
 	import type { ScriptLang } from '$lib/gen'
-	import { workspaceStore } from '$lib/stores'
+	import { enterpriseLicense, workspaceStore } from '$lib/stores'
 	import { sendUserToast } from '$lib/utils'
 	import { PIPELINE_LANGUAGES } from './pipelineLanguages'
 	import type { PipelineOutputKind } from './pipelineTemplates'
@@ -26,6 +36,14 @@
 		data: {
 			asset_kind: AssetKind
 			path: string
+			// Fork workspaces: 'fork' = materialized in this fork, 'deferred' =
+			// reads fall back to the parent workspace's current data.
+			fork_materialization?: 'fork' | 'deferred'
+			// Set on an SCD2 `<dim>_current` companion view: the base `<dim>` path
+			// its producer materializes with `// materialize … history`. Drives the
+			// "current view of <dim>" marker so it reads as a derived node, not an
+			// unrelated table.
+			derived_from?: string
 			onAddScript?: (
 				asset: { kind: AssetKind; path: string },
 				language: ScriptLang,
@@ -47,6 +65,15 @@
 			// cached draft content). Without this callback, the play button
 			// is hidden — runs only make sense in editor contexts.
 			onRunProducer?: (producer: AssetProducer) => Promise<string | undefined>
+			// True when a producer materializing this asset declares `// data_test`
+			// checks — the asset's write is guarded. Drives the data-test outcome
+			// badge, whose meaning differs by edition (EE rolls a failing write
+			// back; CE publishes it anyway).
+			dataTestGuarded?: boolean
+			// True when the latest observed run of a producer materializing this
+			// asset failed. Escalates the guard badge from "protected" to a
+			// failed-run outcome (rolled-back on EE, published-anyway on CE).
+			producerFailed?: boolean
 		}
 		// SvelteFlow injects this on the node component when the user clicks
 		// the node. Combined with our own `hovered` state to drive the
@@ -101,6 +128,37 @@
 	}
 
 	let showAdd = $derived(data.onAddScript != undefined)
+
+	// Data-test outcome badge. Only guarded assets show it. The write's fate on a
+	// failing test differs by edition — surface which one applies so a shared
+	// parent/fork table name can't hide a silently-published bad version.
+	let isEE = $derived(!!$enterpriseLicense)
+	let showGuardBadge = $derived(data.dataTestGuarded === true)
+	let guardFailed = $derived(data.producerFailed === true)
+	let GuardIcon = $derived(isEE ? ShieldCheck : ShieldAlert)
+	// Filled + colored when the last run failed (the actionable state); a quiet
+	// ring at rest so the badge doesn't shout on every healthy guarded asset.
+	let guardClass = $derived(
+		guardFailed
+			? isEE
+				? 'bg-amber-500 text-white border-amber-600'
+				: 'bg-red-500 text-white border-red-600'
+			: isEE
+				? 'bg-surface-secondary text-emerald-600 dark:text-emerald-400 border-emerald-500/60'
+				: 'bg-surface-secondary text-amber-600 dark:text-amber-400 border-amber-500/60'
+	)
+	// Failed copy speaks to the edition's write policy, not the failure cause:
+	// `producerFailed` is a generic job failure (could be a runtime/worker error,
+	// not a data-test violation), so we don't assert "failed its data tests".
+	let guardTitle = $derived(
+		guardFailed
+			? isEE
+				? 'Last run failed — Enterprise rolls a failed materialize back, so the previous version is left live.'
+				: 'Last run failed — Community Edition does not roll a failed materialize back (Enterprise does), so a failing write may be left live. Verify the table.'
+			: isEE
+				? 'Guarded by data tests: a failing write is rolled back, keeping the previous version live.'
+				: 'Guarded by data tests, but Community Edition does not block on failure — a failing write is still published. Rollback is Enterprise-only.'
+	)
 </script>
 
 <!-- onmouseenter/leave on the wrapper (not the inner card) so the run
@@ -134,7 +192,55 @@
 		<span class="flex-1 min-w-0 pr-1 py-0.5 text-2xs font-mono text-emphasis truncate">
 			{formatShortAssetPath(asset)}
 		</span>
+		<!-- Fork data-environment chip: in a fork every asset shares its parent's
+		     name, so the env it resolves to must read at a glance. Labeled + tinted
+		     (amber "parent" = deferred read of the parent's current table via a
+		     view; emerald "fork" = the fork's own materialized copy) rather than a
+		     bare icon, which was too easy to miss. The title carries the detail. -->
+		{#if data.fork_materialization === 'deferred'}
+			<span
+				class="shrink-0 mr-1.5 flex items-center gap-0.5 rounded px-1 py-px text-3xs font-semibold uppercase tracking-wide bg-amber-100 dark:bg-amber-900/40 text-amber-700 dark:text-amber-300 border border-amber-300 dark:border-amber-700"
+				title="Deferred to parent workspace: reads the parent's current data. Materialize it in this fork to iterate on it."
+			>
+				<ArrowUpRight size={10} />
+				parent
+			</span>
+		{:else if data.fork_materialization === 'fork'}
+			<span
+				class="shrink-0 mr-1.5 flex items-center gap-0.5 rounded px-1 py-px text-3xs font-semibold uppercase tracking-wide bg-emerald-100 dark:bg-emerald-900/40 text-emerald-700 dark:text-emerald-300 border border-emerald-300 dark:border-emerald-700"
+				title="Materialized in this fork: reads and writes use the fork's isolated copy."
+			>
+				<GitFork size={10} />
+				fork
+			</span>
+		{/if}
+		<!-- SCD2 companion marker: this node is the `<dim>_current` "latest row
+		     per key" view its producer maintains alongside the base dimension.
+		     Icon-only (the pill already truncates); the title names the base. -->
+		{#if data.derived_from}
+			<span
+				class="shrink-0 mr-1.5 text-violet-600 dark:text-violet-400"
+				title={`SCD2 current view of ${data.derived_from}: latest row per key, maintained by the same producer as the base dimension.`}
+			>
+				<History size={12} />
+			</span>
+		{/if}
 	</div>
+	{#if showGuardBadge}
+		<!-- Data-test outcome badge. Floats off the TOP-RIGHT corner (opposite the
+		     left-edge run button and the bottom + inserter) so it never collides
+		     with the other node affordances. Shield = guarded; its fill escalates to
+		     amber/red when the last run failed, encoding the edition's write policy. -->
+		<div
+			class={twMerge(
+				'absolute -top-2 -right-2 z-10 rounded-full w-5 h-5 grid place-items-center border shadow-sm',
+				guardClass
+			)}
+			title={guardTitle}
+		>
+			<GuardIcon size={12} strokeWidth={2.25} />
+		</div>
+	{/if}
 	{#if showActions}
 		<!-- Run button revealed on hover/select. Floats off the LEFT edge —
 		     visually closer to the upstream producer it triggers (which lays
diff --git a/frontend/src/lib/components/assets/AssetGraph/PartitionArgControl.svelte b/frontend/src/lib/components/assets/AssetGraph/PartitionArgControl.svelte
new file mode 100644
index 0000000000..dac1ecdb02
--- /dev/null
+++ b/frontend/src/lib/components/assets/AssetGraph/PartitionArgControl.svelte
@@ -0,0 +1,250 @@
+<script lang="ts">
+	import { resource } from 'runed'
+	import { AssetService, type AssetKind, type MaterializedPartition } from '$lib/gen'
+	import TextInput from '$lib/components/text_input/TextInput.svelte'
+	import { CalendarClock, CircleCheck, CircleDashed, TriangleAlert } from 'lucide-svelte'
+	import type { PartitionSpec } from './parsePipelineAnnotations'
+	import { untrack } from 'svelte'
+	import {
+		bucketFromInputValue,
+		defaultBucket,
+		inputValueFromBucket,
+		isBeforeStart,
+		partitionInputType,
+		partitionMetadataError,
+		recentBuckets,
+		recentWindow,
+		startBucketOf,
+		usesCalendarPicker
+	} from './partitionBuckets'
+
+	interface Props {
+		// The partition cadence parsed from the script's `// partitioned` header.
+		spec: PartitionSpec
+		// Bound to `args.partition`. `$bindable()` without a default per the
+		// AGENTS.md ban on `$bindable(default)` for optional props.
+		value?: string | undefined
+		workspace: string
+		// The `// materialize` ducklake target, if any — enables the
+		// "already materialized / recently missing" hints against this
+		// producer's own output.
+		materializeTarget?: { kind: AssetKind; path: string }
+		// Partitioned ducklake inputs (`// on ducklake://…`) — enables the
+		// "no upstream data for this bucket yet" hint.
+		upstreamAssets?: { kind: AssetKind; path: string }[]
+	}
+
+	let {
+		value = $bindable(),
+		spec,
+		workspace,
+		materializeTarget,
+		upstreamAssets = []
+	}: Props = $props()
+
+	const inputType = $derived(partitionInputType(spec))
+	const calendarPicker = $derived(usesCalendarPicker(spec))
+	// Non-undefined when the `// partitioned` metadata is unusable (bad tz/start).
+	const metadataError = $derived(partitionMetadataError(spec))
+
+	// Seed the default bucket on (re)mount. The run form is keyed on the schema
+	// AND the partition spec (PipelineScriptView), so a real change to either
+	// remounts this and reseeds — an identical re-resolve keeps the user's
+	// in-progress pick. `defaultBucket` honours the `start=` anchor (never seeds
+	// a pre-start bucket the worker would take verbatim). We deliberately do NOT
+	// auto-seed when the metadata is invalid (bad tz/start): the worker takes an
+	// explicit `partition` arg verbatim, so seeding one would bypass the
+	// backend's own tz/start validation — leave it empty and let the backend
+	// surface the error. Dynamic / custom-format specs also stay empty (free
+	// text). `untrack` so this fires once per mount, not on every `value` edit.
+	$effect(() => {
+		untrack(() => {
+			value = calendarPicker && !metadataError ? defaultBucket(spec, new Date()) : undefined
+		})
+	})
+
+	// Whether the producer hasn't reached its `start=` anchor yet — explains why
+	// the default bucket is the start rather than today.
+	let beforeStart = $derived(calendarPicker && !metadataError && isBeforeStart(spec, new Date()))
+
+	// The native <input> string mirrors `value`; hourly carries an extra minute
+	// component that the canonical bucket drops.
+	let inputValue = $derived(value ? inputValueFromBucket(spec, value) : '')
+	function onNativeInput(raw: string) {
+		value = raw ? bucketFromInputValue(spec, raw) : ''
+	}
+
+	function listPartitions(kind: AssetKind, path: string) {
+		// Only ducklake assets carry materialized-partition rows.
+		if (kind !== 'ducklake' || !path) return Promise.resolve([] as MaterializedPartition[])
+		return AssetService.listAssetPartitions({ workspace, path }).catch(
+			() => [] as MaterializedPartition[]
+		)
+	}
+
+	// This producer's own materialized partitions — powers the selected-bucket
+	// status and the recently-missing list.
+	let ownPartitions = resource(
+		[() => workspace, () => materializeTarget?.kind, () => materializeTarget?.path],
+		async ([ws, kind, path]) => {
+			if (!ws || !kind || !path) return [] as MaterializedPartition[]
+			return listPartitions(kind, path)
+		}
+	)
+	let materializedSet = $derived(
+		new Set(
+			(ownPartitions.current ?? [])
+				.filter((p) => p.status === 'materialized')
+				.map((p) => p.partition)
+		)
+	)
+
+	let selectedMaterialized = $derived(!!value && materializedSet.has(value))
+
+	// Recently-missing buckets: the last N cadence buckets not yet materialized.
+	// Pre-`start=` buckets are dropped — they never materialize on their own, so
+	// offering them as run chips would let a click launch a pre-start partition.
+	let recentlyMissing = $derived.by(() => {
+		if (!materializeTarget || materializeTarget.kind !== 'ducklake' || !calendarPicker) return []
+		if (metadataError || ownPartitions.loading) return []
+		const startBucket = startBucketOf(spec)
+		return recentBuckets(spec, new Date(), recentWindow(spec.kind)).filter(
+			(b) => !materializedSet.has(b) && (!startBucket || b >= startBucket)
+		)
+	})
+
+	// Upstream ducklake inputs, one materialized-set PER input (not unioned).
+	// A per-input `tracked` flag (has ≥1 non-empty partition) distinguishes a
+	// partitioned input from a whole-table one, so a non-partitioned upstream
+	// (single whole-table row) never false-alarms as "no data for this bucket".
+	let ducklakeUpstreams = $derived(upstreamAssets.filter((a) => a.kind === 'ducklake'))
+	let upstream = resource(
+		[() => workspace, () => ducklakeUpstreams.map((a) => a.path).join('\n')],
+		async ([ws, joined]) => {
+			const paths = joined ? joined.split('\n') : []
+			if (!ws || paths.length === 0) return [] as { tracked: boolean; materialized: Set<string> }[]
+			return await Promise.all(
+				paths.map(async (p) => {
+					const rows = await listPartitions('ducklake', p)
+					return {
+						tracked: rows.some((r) => r.partition !== ''),
+						materialized: new Set(
+							rows.filter((r) => r.status === 'materialized').map((r) => r.partition)
+						)
+					}
+				})
+			)
+		}
+	)
+	// Warn when ANY partition-tracked upstream is missing the selected bucket —
+	// checked per-input so a fan-in where one input has the bucket doesn't mask
+	// another that lacks it. Never fires while loading or for untracked inputs.
+	let upstreamMissing = $derived(
+		!!value &&
+			calendarPicker &&
+			!upstream.loading &&
+			(upstream.current ?? []).some((u) => u.tracked && !u.materialized.has(value!))
+	)
+
+	const MAX_MISSING_CHIPS = 8
+</script>
+
+<div class="flex flex-col gap-1.5">
+	<span class="text-xs font-semibold text-emphasis inline-flex items-center gap-1.5">
+		<CalendarClock size={13} class="text-fuchsia-600 dark:text-fuchsia-400" />
+		Partition
+		<span class="text-3xs font-medium text-tertiary px-1 py-0.5 rounded bg-surface-secondary">
+			{spec.kind}
+		</span>
+	</span>
+
+	{#if calendarPicker}
+		<input
+			type={inputType}
+			class="app-editor-input !w-full text-xs"
+			value={inputValue}
+			onchange={(e) => onNativeInput(e.currentTarget.value)}
+		/>
+		{#if metadataError}
+			<span class="text-3xs inline-flex items-start gap-1 text-amber-700 dark:text-amber-400">
+				<TriangleAlert size={12} class="mt-0.5 shrink-0" />
+				<span>
+					The <span class="font-mono">// partitioned</span> header has {metadataError} — fix it in the
+					script; no default is filled in.
+				</span>
+			</span>
+		{:else if beforeStart}
+			<span class="text-3xs text-tertiary">
+				Partitioning starts <span class="font-mono">{spec.start}</span> — defaulted to the first partition.
+			</span>
+		{/if}
+	{:else}
+		<TextInput
+			bind:value={() => value ?? '', (v) => (value = v)}
+			size="sm"
+			inputProps={{
+				placeholder: spec.kind === 'dynamic' ? 'Partition key value' : 'Partition bucket'
+			}}
+		/>
+		<span class="text-3xs text-tertiary">
+			{#if spec.kind === 'dynamic'}
+				Dynamic partition — leave blank to let the run resolve it from the payload.
+			{:else}
+				Custom partition format — enter the bucket exactly as the producer renders it.
+			{/if}
+		</span>
+	{/if}
+
+	<!-- Selected-bucket status against this producer's own materialized set. -->
+	{#if calendarPicker && materializeTarget?.kind === 'ducklake' && value}
+		{#if selectedMaterialized}
+			<span class="text-3xs inline-flex items-center gap-1 text-green-700 dark:text-green-400">
+				<CircleCheck size={12} />
+				<span class="font-mono">{value}</span> is already materialized — running replaces it.
+			</span>
+		{:else}
+			<span class="text-3xs inline-flex items-center gap-1 text-tertiary">
+				<CircleDashed size={12} />
+				<span class="font-mono">{value}</span> not materialized yet — running creates it.
+			</span>
+		{/if}
+	{/if}
+
+	<!-- No upstream data for the selected bucket. -->
+	{#if upstreamMissing}
+		<span class="text-3xs inline-flex items-start gap-1 text-amber-700 dark:text-amber-400">
+			<TriangleAlert size={12} class="mt-0.5 shrink-0" />
+			<span>
+				No upstream data for <span class="font-mono">{value}</span> yet — this run may materialize an
+				empty partition.
+			</span>
+		</span>
+	{/if}
+
+	<!-- Recently-missing buckets, a compact "what's not filled in" hint. -->
+	{#if recentlyMissing.length > 0}
+		<div class="flex flex-col gap-1">
+			<span class="text-3xs text-tertiary">
+				{recentlyMissing.length} of the last {recentWindow(spec.kind)}
+				{spec.kind} partitions are not materialized:
+			</span>
+			<div class="flex flex-wrap gap-1">
+				{#each recentlyMissing.slice(0, MAX_MISSING_CHIPS) as b (b)}
+					<button
+						type="button"
+						class="px-1.5 py-0.5 rounded text-3xs font-mono bg-amber-100 text-amber-800 dark:bg-amber-900/40 dark:text-amber-300 hover:ring-1 hover:ring-amber-400"
+						title="Set the partition to {b}"
+						onclick={() => (value = b)}
+					>
+						{b}
+					</button>
+				{/each}
+				{#if recentlyMissing.length > MAX_MISSING_CHIPS}
+					<span class="text-3xs text-tertiary self-center">
+						+{recentlyMissing.length - MAX_MISSING_CHIPS} more
+					</span>
+				{/if}
+			</div>
+		</div>
+	{/if}
+</div>
diff --git a/frontend/src/lib/components/assets/AssetGraph/PipelineGraphEditor.svelte b/frontend/src/lib/components/assets/AssetGraph/PipelineGraphEditor.svelte
index 8dca18bd8e..6e6a694e82 100644
--- a/frontend/src/lib/components/assets/AssetGraph/PipelineGraphEditor.svelte
+++ b/frontend/src/lib/components/assets/AssetGraph/PipelineGraphEditor.svelte
@@ -22,6 +22,7 @@
 	import type { RunnableRunState, PipelineEvent } from './activeRunnables.svelte'
 	import type { PipelineOutputKind } from './pipelineTemplates'
 	import type { PipelineEditorState } from './pipelineEditorState.svelte'
+	import type { SchemaContractGraphContext } from './schemaContracts'
 
 	type RunProducer = { kind: 'script' | 'flow'; path: string; unsaved?: boolean; cascade?: boolean }
 
@@ -73,6 +74,8 @@
 		selectionProducers = [],
 		selectionColumnGraph,
 		schemaCanEvolve = true,
+		selectionForkMaterialization = undefined,
+		schemaContractContext = undefined,
 		downstreamSubscribers = 0,
 		onStartBoundedRunForOpen,
 		canBoundedRunOpenScript = false,
@@ -170,6 +173,11 @@
 		/** Transitive column-lineage trace for a selected ducklake asset (route page). */
 		selectionColumnGraph?: ColumnLineageGraph
 		schemaCanEvolve?: boolean
+		/** Fork workspaces: data-environment state of the selected ducklake asset (route page). */
+		selectionForkMaterialization?: 'fork' | 'deferred'
+		/** Producer-side facts for the editor's live schema-contract diagnostics
+		 * (ignore suppression + scd2 `_current` fallback), from the route page. */
+		schemaContractContext?: SchemaContractGraphContext
 		downstreamSubscribers?: number
 		onStartBoundedRunForOpen?: (path: string) => void
 		canBoundedRunOpenScript?: boolean
@@ -486,6 +494,8 @@
 						selectionProducers={activeDraft ? [] : selectionProducers}
 						{selectionColumnGraph}
 						{schemaCanEvolve}
+						{selectionForkMaterialization}
+						{schemaContractContext}
 						{runsRefreshKey}
 						{runsPendingJobId}
 						{activeRunnable}
diff --git a/frontend/src/lib/components/assets/AssetGraph/PipelineRunForm.svelte b/frontend/src/lib/components/assets/AssetGraph/PipelineRunForm.svelte
index fc5e7ad945..4384f125ba 100644
--- a/frontend/src/lib/components/assets/AssetGraph/PipelineRunForm.svelte
+++ b/frontend/src/lib/components/assets/AssetGraph/PipelineRunForm.svelte
@@ -1,6 +1,9 @@
 <script lang="ts">
 	import SchemaForm from '$lib/components/SchemaForm.svelte'
 	import { emptySchema } from '$lib/utils'
+	import type { AssetKind } from '$lib/gen'
+	import type { PartitionSpec } from './parsePipelineAnnotations'
+	import PartitionArgControl from './PartitionArgControl.svelte'
 
 	interface Props {
 		// The script's schema to render inputs for. SchemaForm normalizes/mutates
@@ -8,9 +11,40 @@
 		schema: any
 		args: Record<string, any>
 		isValid: boolean
+		// When the script is `// partitioned`, the bare `partition` string arg is
+		// pulled out of the SchemaForm and rendered by PartitionArgControl (a
+		// cadence-appropriate date picker + missing/upstream hints) instead.
+		partitionSpec?: PartitionSpec
+		workspace?: string
+		materializeTarget?: { kind: AssetKind; path: string }
+		upstreamAssets?: { kind: AssetKind; path: string }[]
 	}
 
-	let { schema, args = $bindable(), isValid = $bindable() }: Props = $props()
+	let {
+		schema,
+		args = $bindable(),
+		isValid = $bindable(),
+		partitionSpec,
+		workspace = '',
+		materializeTarget,
+		upstreamAssets = []
+	}: Props = $props()
+
+	// Drop the `partition` property from the schema clone so SchemaForm doesn't
+	// also render it as a bare string — PartitionArgControl owns `args.partition`.
+	function stripPartition(s: any): any {
+		if (!s || typeof s !== 'object') return s
+		if (s.properties && 'partition' in s.properties) {
+			delete s.properties.partition
+		}
+		if (Array.isArray(s.order)) {
+			s.order = s.order.filter((k: string) => k !== 'partition')
+		}
+		if (Array.isArray(s.required)) {
+			s.required = s.required.filter((k: string) => k !== 'partition')
+		}
+		return s
+	}
 
 	// Mutable clone SchemaForm can normalize without touching the parent's script.
 	// Seeded ONCE per mount — the parent remounts this via `{#key <schema content>}`
@@ -18,7 +52,22 @@
 	// $effect, and an unchanged re-resolve (a WS bundle with the same schema) keeps
 	// in-progress input.
 	// svelte-ignore state_referenced_locally
-	let formSchema = $state<any>(structuredClone($state.snapshot(schema) ?? emptySchema()))
+	let formSchema = $state<any>(
+		partitionSpec
+			? stripPartition(structuredClone($state.snapshot(schema) ?? emptySchema()))
+			: structuredClone($state.snapshot(schema) ?? emptySchema())
+	)
 </script>
 
-<SchemaForm bind:schema={formSchema} bind:args bind:isValid compact />
+<div class="flex flex-col gap-2">
+	{#if partitionSpec}
+		<PartitionArgControl
+			spec={partitionSpec}
+			bind:value={() => args.partition, (v) => (args.partition = v)}
+			{workspace}
+			{materializeTarget}
+			{upstreamAssets}
+		/>
+	{/if}
+	<SchemaForm bind:schema={formSchema} bind:args bind:isValid compact />
+</div>
diff --git a/frontend/src/lib/components/assets/AssetGraph/PipelineScriptView.svelte b/frontend/src/lib/components/assets/AssetGraph/PipelineScriptView.svelte
index cadd3c6a94..18564c6edd 100644
--- a/frontend/src/lib/components/assets/AssetGraph/PipelineScriptView.svelte
+++ b/frontend/src/lib/components/assets/AssetGraph/PipelineScriptView.svelte
@@ -1,11 +1,13 @@
 <script lang="ts">
-	import type { Script } from '$lib/gen'
-	import { Loader2, Play, Upload, Zap } from 'lucide-svelte'
+	import type { AssetKind, Script } from '$lib/gen'
+	import { CalendarClock, Loader2, Play, Upload, Zap } from 'lucide-svelte'
 	import Button from '$lib/components/common/button/Button.svelte'
 	import HighlightCode from '$lib/components/HighlightCode.svelte'
 	import PipelineRunForm from './PipelineRunForm.svelte'
 	import AssetRunsPanel from './AssetRunsPanel.svelte'
 	import { Pane, Splitpanes } from 'svelte-splitpanes'
+	import { workspaceStore } from '$lib/stores'
+	import { parsePipelineAnnotations } from './parsePipelineAnnotations'
 
 	interface Props {
 		script: Script
@@ -52,20 +54,60 @@
 	// and the script actually has subscribers to fan out to.
 	let hasCascade = $derived(!!onRunCascade && downstreamCount > 0)
 
+	// Parse the pipeline header for the partition cadence + materialize target +
+	// ducklake inputs, so a partitioned producer's run form swaps the bare
+	// `partition` string for a cadence-aware date picker with missing/upstream
+	// hints (see PartitionArgControl).
+	let annotations = $derived(parsePipelineAnnotations(script.content ?? ''))
+	let partitionSpec = $derived(annotations.partition)
+	let materializeTarget = $derived<{ kind: AssetKind; path: string } | undefined>(
+		annotations.materialize
+			? { kind: annotations.materialize.targetKind, path: annotations.materialize.targetPath }
+			: undefined
+	)
+	let upstreamAssets = $derived(
+		annotations.triggerAssets.map((a) => ({ kind: a.kind, path: a.path }))
+	)
+
+	// Whether the script declares any inputs — a run then needs the SchemaForm
+	// to collect them, so the form must render even for a plain (non-upload,
+	// non-partitioned) script rather than firing with empty args.
+	let hasInputs = $derived(Object.keys(script.schema?.properties ?? {}).length > 0)
+	// The run form appears for data-upload entry points (S3 picker), for any
+	// partitioned producer (materialize a single partition — available in OSS,
+	// and the picker is where the user chooses which one), and whenever the
+	// script takes inputs the run needs.
+	let showRunForm = $derived(canRun || !!partitionSpec || hasInputs)
+	// A partitioned producer that isn't a data-upload entry is materializing a
+	// partition rather than uploading data — reflect that in the header.
+	let partitionOnly = $derived(!canRun && !!partitionSpec)
+	// `isValid` is only meaningful while a form is mounted to vouch for it; with
+	// no form the run fires with `{}`, which is always valid. Deriving this rather
+	// than reading `isValid` directly avoids a stuck-disabled Run button when a
+	// required-input form leaves `isValid=false` behind as it unmounts on a
+	// same-path re-resolve to an input-less script (we're keyed on script.path).
+	let runValid = $derived(showRunForm ? isValid : true)
+
 	// The details pane keys this component on script.path only, so a same-path
 	// re-resolve (in /pipeline_dev the selected node re-resolves on every WS
 	// bundle) does NOT remount us. `PipelineRunForm` owns the SchemaForm clone and
-	// is keyed on the serialized schema below, so a local edit that adds/removes
-	// args reseeds the run form while an unchanged re-resolve keeps in-progress
-	// input (else the form could run against a stale schema with missing inputs).
-	let schemaKey = $derived(JSON.stringify(script.schema ?? null))
+	// is keyed on the serialized schema + partition spec below: a local edit that
+	// adds/removes args OR changes the `// partitioned` header (which the schema
+	// alone wouldn't capture) reseeds the run form and re-strips the `partition`
+	// field, while an unchanged re-resolve keeps in-progress input (else the form
+	// could run against a stale schema/spec — e.g. keep a pre-`start=` bucket).
+	let schemaKey = $derived(
+		JSON.stringify(script.schema ?? null) + '|' + JSON.stringify(partitionSpec ?? null)
+	)
 
 	async function run(cascade = false) {
 		const dispatch = cascade ? onRunCascade : onRun
 		if (!dispatch || running) return
 		running = true
 		try {
-			await dispatch(script.path, $state.snapshot(args))
+			// No form rendered ⇒ no inputs to collect: run with {} rather than args a
+			// prior (input-carrying) resolve of this same path left behind unmounted.
+			await dispatch(script.path, showRunForm ? $state.snapshot(args) : {})
 		} finally {
 			running = false
 		}
@@ -83,47 +125,67 @@
 	<Splitpanes horizontal class="!h-full">
 		<Pane size={55} minSize={20}>
 			<div class="flex flex-col h-full overflow-auto">
-				{#if canRun}
-					<div class="shrink-0 flex flex-col gap-2 p-3 border-b" data-run-form>
-						<div class="flex items-center justify-between gap-2">
-							<span class="text-xs font-semibold text-emphasis inline-flex items-center gap-1.5">
+				<!-- Run affordance is always the first thing in the node panel so
+				     it's discoverable the moment a script is selected — never
+				     buried below the source. The parameter form renders under it
+				     only when the run actually needs inputs (upload/partition/args). -->
+				<div class="shrink-0 flex flex-col gap-2 p-3 border-b" data-run-form>
+					<div class="flex items-center justify-between gap-2">
+						<span class="text-xs font-semibold text-emphasis inline-flex items-center gap-1.5">
+							{#if partitionOnly}
+								<CalendarClock size={13} class="text-fuchsia-600 dark:text-fuchsia-400" />
+								Materialize a partition
+							{:else if canRun}
 								<Upload size={13} class="text-fuchsia-600 dark:text-fuchsia-400" />
 								Run pipeline
-							</span>
-							<div class="flex items-center gap-1.5">
-								{#if hasCascade}
-									<Button
-										variant="accent-secondary"
-										unifiedSize="sm"
-										startIcon={{ icon: running ? Loader2 : Zap }}
-										onclick={() => run(true)}
-										disabled={isDraft || running || !isValid}
-										title={`Run this script with these inputs, then run its ${downstreamCount} downstream pipeline script${downstreamCount === 1 ? '' : 's'} in order`}
-									>
-										Run + downstream
-									</Button>
-								{/if}
+							{:else}
+								<Play size={13} class="text-fuchsia-600 dark:text-fuchsia-400" />
+								Run this step
+							{/if}
+						</span>
+						<div class="flex items-center gap-1.5">
+							{#if hasCascade}
 								<Button
-									variant="accent"
+									variant="accent-secondary"
 									unifiedSize="sm"
-									startIcon={{ icon: running ? Loader2 : Play }}
-									onclick={() => run(false)}
-									disabled={isDraft || running || !isValid || !onRun}
-									title={isDraft
-										? 'Deploy this draft to run it for real'
-										: hasCascade
-											? 'Run just this step — downstream scripts are not triggered'
-											: 'Run the deployed script — downstream pipeline scripts cascade for real'}
+									startIcon={{ icon: running ? Loader2 : Zap }}
+									onclick={() => run(true)}
+									disabled={isDraft || running || !runValid}
+									title={`Run this script with these inputs, then run its ${downstreamCount} downstream pipeline script${downstreamCount === 1 ? '' : 's'} in order`}
 								>
-									{running ? 'Starting…' : 'Run'}
+									Run + downstream
 								</Button>
-							</div>
+							{/if}
+							<Button
+								variant="accent"
+								unifiedSize="sm"
+								startIcon={{ icon: running ? Loader2 : Play }}
+								onclick={() => run(false)}
+								disabled={isDraft || running || !runValid || !onRun}
+								title={isDraft
+									? 'Deploy this draft to run it for real'
+									: hasCascade
+										? 'Run just this step — downstream scripts are not triggered'
+										: 'Run the deployed script — downstream pipeline scripts cascade for real'}
+							>
+								{running ? 'Starting…' : 'Run'}
+							</Button>
 						</div>
-						{#key schemaKey}
-							<PipelineRunForm schema={script.schema} bind:args bind:isValid />
-						{/key}
 					</div>
-				{/if}
+					{#if showRunForm}
+						{#key schemaKey}
+							<PipelineRunForm
+								schema={script.schema}
+								bind:args
+								bind:isValid
+								{partitionSpec}
+								workspace={$workspaceStore ?? ''}
+								{materializeTarget}
+								{upstreamAssets}
+							/>
+						{/key}
+					{/if}
+				</div>
 				<div class="flex-1 min-h-0 overflow-auto text-xs p-3">
 					<HighlightCode code={script.content ?? ''} language={script.language} />
 				</div>
diff --git a/frontend/src/lib/components/assets/AssetGraph/PipelineSetupSignpost.svelte b/frontend/src/lib/components/assets/AssetGraph/PipelineSetupSignpost.svelte
new file mode 100644
index 0000000000..751ecbbdc8
--- /dev/null
+++ b/frontend/src/lib/components/assets/AssetGraph/PipelineSetupSignpost.svelte
@@ -0,0 +1,120 @@
+<script lang="ts">
+	import { resource } from 'runed'
+	import { WorkspaceService } from '$lib/gen'
+	import { base } from '$lib/base'
+	import { CircleCheck, CircleAlert, Database, HardDrive, ArrowRight } from 'lucide-svelte'
+
+	interface Props {
+		workspace: string
+	}
+	let { workspace }: Props = $props()
+
+	// A pipeline can't materialize anything until the workspace has (a) object
+	// storage for the parquet files and (b) at least one DuckLake catalog. A
+	// brand-new user has no signal these are prerequisites — this first-run
+	// checklist surfaces them and links straight to the settings that fix them.
+	//
+	// Both probes fail SAFE: an errored settings read (e.g. non-admin) resolves
+	// to `undefined`, and an undefined state never renders a red "missing" —
+	// the signpost only asserts "not configured" when it positively knows so.
+	let storage = resource([() => workspace], async ([ws]) => {
+		if (!ws) return undefined
+		try {
+			const s = await WorkspaceService.getSettings({ workspace: ws })
+			return !!s.large_file_storage
+		} catch {
+			return undefined
+		}
+	})
+	let ducklakes = resource([() => workspace], async ([ws]) => {
+		if (!ws) return undefined
+		try {
+			return (await WorkspaceService.listDucklakes({ workspace: ws })).length > 0
+		} catch {
+			return undefined
+		}
+	})
+
+	// Only surface the signpost once we have a definite "not configured" for at
+	// least one prerequisite — never while loading, and never on an errored
+	// probe (which would nag a user who can't act on it anyway).
+	let storageMissing = $derived(storage.current === false)
+	let ducklakeMissing = $derived(ducklakes.current === false)
+	let show = $derived(storageMissing || ducklakeMissing)
+
+	type Step = {
+		done: boolean | undefined
+		icon: typeof Database
+		title: string
+		description: string
+		href: string
+		cta: string
+	}
+	let steps = $derived<Step[]>([
+		{
+			done: storage.current,
+			icon: HardDrive,
+			title: 'Workspace object storage',
+			description:
+				'Materialized partitions and DuckLake data files are written to S3 / object storage.',
+			href: `${base}/workspace_settings?tab=windmill_lfs`,
+			cta: 'Configure object storage'
+		},
+		{
+			done: ducklakes.current,
+			icon: Database,
+			title: 'A DuckLake catalog',
+			description:
+				'DuckLake is the table format pipelines materialize into — add at least one catalog.',
+			href: `${base}/workspace_settings?tab=ducklake`,
+			cta: 'Configure DuckLake'
+		}
+	])
+</script>
+
+{#if show}
+	<div
+		class="flex flex-col gap-3 rounded-lg border border-amber-300 dark:border-amber-900/60 bg-amber-50 dark:bg-amber-950/30 p-4"
+	>
+		<div class="flex items-start gap-2">
+			<CircleAlert size={18} class="text-amber-600 dark:text-amber-400 mt-0.5 shrink-0" />
+			<div class="flex flex-col gap-0.5">
+				<h3 class="text-sm font-semibold text-emphasis">Finish setting up pipelines</h3>
+				<p class="text-xs text-tertiary">
+					Pipelines materialize data into DuckLake tables backed by object storage. Configure the
+					following before your first pipeline can run.
+				</p>
+			</div>
+		</div>
+
+		<ul class="flex flex-col gap-2">
+			{#each steps as step (step.title)}
+				{@const Icon = step.icon}
+				<li class="flex items-center gap-3 rounded-md border bg-surface px-3 py-2">
+					{#if step.done === true}
+						<CircleCheck size={16} class="text-green-600 dark:text-green-400 shrink-0" />
+					{:else if step.done === false}
+						<CircleAlert size={16} class="text-amber-600 dark:text-amber-400 shrink-0" />
+					{:else}
+						<Icon size={16} class="text-tertiary shrink-0" />
+					{/if}
+					<div class="flex flex-col min-w-0 flex-1">
+						<span class="text-xs font-semibold text-primary">{step.title}</span>
+						<span class="text-2xs text-tertiary">{step.description}</span>
+					</div>
+					{#if step.done !== true}
+						<a
+							href={step.href}
+							class="shrink-0 inline-flex items-center gap-1 text-xs text-blue-500 hover:underline whitespace-nowrap"
+						>
+							{step.cta}
+							<ArrowRight size={12} />
+						</a>
+					{:else}
+						<span class="shrink-0 text-2xs text-green-700 dark:text-green-400">Configured</span>
+					{/if}
+				</li>
+			{/each}
+		</ul>
+	</div>
+{/if}
diff --git a/frontend/src/lib/components/assets/AssetGraph/RunnableNode.svelte b/frontend/src/lib/components/assets/AssetGraph/RunnableNode.svelte
index 8b5e90170c..4cb65ee8f3 100644
--- a/frontend/src/lib/components/assets/AssetGraph/RunnableNode.svelte
+++ b/frontend/src/lib/components/assets/AssetGraph/RunnableNode.svelte
@@ -22,12 +22,13 @@
 	import { preventDefault, stopPropagation } from 'svelte/legacy'
 	import type { GraphUsageKind } from './types'
 	import type { RunnableRunState } from './activeRunnables.svelte'
+	import { parseDurationSecs } from './parsePipelineAnnotations'
 	import { NODE } from '$lib/components/graph/util'
 	import DropdownV2 from '$lib/components/DropdownV2.svelte'
 	import Popover from '$lib/components/meltComponents/Popover.svelte'
 	import type { Item } from '$lib/utils'
 	import { workspaceStore } from '$lib/stores'
-	import { sendUserToast } from '$lib/utils'
+	import { sendUserToast, msToReadableTimeShort } from '$lib/utils'
 
 	interface Props {
 		data: {
@@ -36,6 +37,9 @@
 			in_pipeline?: boolean
 			partition_kind?: 'daily' | 'hourly' | 'weekly' | 'monthly' | 'dynamic'
 			freshness?: string
+			// Completion time (ISO) of the newest successful run visible to
+			// the caller. With `freshness`, drives the fresh/stale chip state.
+			last_success_at?: string
 			tag?: string
 			retry?: { count: number; delay?: string }
 			// Macros this script provides (deployed/drafted `// macros` library).
@@ -122,6 +126,44 @@
 		}
 	}
 
+	// Freshness verdict: newest successful run (server `last_success_at`,
+	// or a newer one the session poll observed) vs the `// freshness`
+	// window. No verdict (undefined) for drafts — no run history — and for
+	// unparseable windows; the chip then stays neutral like the other
+	// annotation chips.
+	let freshnessWindowS = $derived(data.freshness ? parseDurationSecs(data.freshness) : undefined)
+	// Ticks so a node crosses fresh→stale while the canvas stays open (the
+	// graph payload is static between refetches). Armed only when a verdict
+	// is rendered.
+	let nowMs = $state(Date.now())
+	$effect(() => {
+		if (freshnessWindowS === undefined || data.unsaved) return
+		const id = setInterval(() => (nowMs = Date.now()), 30_000)
+		return () => clearInterval(id)
+	})
+	let lastSuccessMs = $derived.by(() => {
+		const server = data.last_success_at ? new Date(data.last_success_at).getTime() : undefined
+		const polled = data.runState?.lastSuccessAt
+			? new Date(data.runState.lastSuccessAt).getTime()
+			: undefined
+		if (server === undefined) return polled
+		return polled === undefined ? server : Math.max(server, polled)
+	})
+	let freshnessState = $derived.by((): 'fresh' | 'stale' | undefined => {
+		if (freshnessWindowS === undefined || data.unsaved) return undefined
+		if (lastSuccessMs === undefined) return 'stale'
+		return nowMs - lastSuccessMs <= freshnessWindowS * 1000 ? 'fresh' : 'stale'
+	})
+	let freshnessTooltip = $derived.by(() => {
+		const base = `// freshness ${data.freshness}`
+		if (freshnessState === undefined) return base
+		if (lastSuccessMs === undefined) return `${base} — stale: no successful run yet`
+		const ago = msToReadableTimeShort(Math.max(0, nowMs - lastSuccessMs))
+		return freshnessState === 'fresh'
+			? `${base} — fresh: last successful run ${ago} ago`
+			: `${base} — stale: last successful run ${ago} ago`
+	})
+
 	// Cascade + bounded-run options live on the Run button's caret popover
 	// (whenever there's a cascade OR a bounded-run start — see `hasCaret`
 	// below), so the kebab menu stays focused on lifecycle actions only.
@@ -164,8 +206,8 @@
 		</span>
 		<!-- Annotation chips share one neutral treatment — the icon carries
 		     the meaning (colors are reserved for feedback, per the brand
-		     guidelines). Only the run-state chip below keeps semantic
-		     colors. -->
+		     guidelines). Only the freshness chip (when it has a verdict)
+		     and the run-state chip below use semantic colors. -->
 		{#if data.partition_kind}
 			<div
 				class="shrink-0 flex items-center gap-0.5 px-1 py-0.5 mr-1 rounded-sm bg-surface-secondary text-secondary"
@@ -175,10 +217,22 @@
 				<span class="text-3xs leading-none">{data.partition_kind}</span>
 			</div>
 		{/if}
+		<!-- Freshness is the one annotation chip that carries feedback (a
+		     fresh/stale verdict against real run history), so like the
+		     run-state chip it uses semantic colors: emerald = within window,
+		     amber = stale. Neutral when there's no verdict (drafts, bad
+		     window value). -->
 		{#if data.freshness}
 			<div
-				class="shrink-0 flex items-center gap-0.5 px-1 py-0.5 mr-1 rounded-sm bg-surface-secondary text-secondary"
-				title={`// freshness ${data.freshness}`}
+				class={twMerge(
+					'shrink-0 flex items-center gap-0.5 px-1 py-0.5 mr-1 rounded-sm',
+					freshnessState === 'fresh'
+						? 'bg-emerald-100 dark:bg-emerald-900/40 text-emerald-700 dark:text-emerald-300'
+						: freshnessState === 'stale'
+							? 'bg-amber-100 dark:bg-amber-900/40 text-amber-700 dark:text-amber-300'
+							: 'bg-surface-secondary text-secondary'
+				)}
+				title={freshnessTooltip}
 			>
 				<Timer size={10} />
 				<span class="text-3xs leading-none">{data.freshness}</span>
@@ -356,10 +410,10 @@
 								>
 									<Target size={14} class="mt-0.5 shrink-0 text-secondary" />
 									<div class="flex flex-col min-w-0">
-										<span class="font-medium">Run downstream up to…</span>
+										<span class="font-medium">Run + downstream…</span>
 										<span class="text-2xs text-secondary">
-											Pick end node(s) on the graph, then run only the cascade between this script
-											and them.
+											Run this script and everything downstream. Or pick end node(s) on the graph to
+											bound the cascade between this script and them.
 										</span>
 									</div>
 								</button>
diff --git a/frontend/src/lib/components/assets/AssetGraph/TriggerNode.svelte b/frontend/src/lib/components/assets/AssetGraph/TriggerNode.svelte
index caf7d90482..b888ae226a 100644
--- a/frontend/src/lib/components/assets/AssetGraph/TriggerNode.svelte
+++ b/frontend/src/lib/components/assets/AssetGraph/TriggerNode.svelte
@@ -183,7 +183,7 @@
 		...(data.onStartBoundedRun
 			? [
 					{
-						displayName: 'Run downstream up to…',
+						displayName: 'Run + downstream…',
 						icon: Target,
 						action: () => data.onStartBoundedRun?.()
 					}
diff --git a/frontend/src/lib/components/assets/AssetGraph/activeRunnables.svelte.ts b/frontend/src/lib/components/assets/AssetGraph/activeRunnables.svelte.ts
index 917e21766a..f6682804c7 100644
--- a/frontend/src/lib/components/assets/AssetGraph/activeRunnables.svelte.ts
+++ b/frontend/src/lib/components/assets/AssetGraph/activeRunnables.svelte.ts
@@ -1,8 +1,15 @@
 import { JobService } from '$lib/gen'
 
 export type RunStatus = 'running' | 'success' | 'failure'
-/** Per-runnable badge state: latest run status + runs observed this session. */
-export type RunnableRunState = { status: RunStatus; runs: number }
+/**
+ * Per-runnable badge state: latest run status + runs observed this session.
+ * `lastSuccessAt` is the completion time (start + duration when the listing
+ * carries it, else start as a conservative lower bound) of the newest
+ * successful run seen by the poll — lets the freshness chip go green right
+ * after an in-session run, ahead of the next graph refetch (whose
+ * `last_success_at` would carry it).
+ */
+export type RunnableRunState = { status: RunStatus; runs: number; lastSuccessAt?: string }
 
 export type EventStatus = 'queued' | 'running' | 'success' | 'failure'
 /** One folder activity-log row (a job observed by the poll). */
@@ -14,6 +21,12 @@ export type PipelineEvent = {
 	/** What started it, as far as the job listing reveals. */
 	source: 'schedule' | 'run'
 	at: string
+	/**
+	 * Completion time (start + duration) for completed rows. The freshness
+	 * chip compares against completion — `at` is the start time and would
+	 * read a long run as older than its output actually is.
+	 */
+	completedAt?: string
 	/**
 	 * Queued jobs: when the job is due to start. A future value means a
 	 * scheduled run waiting for its cron tick, not pipeline activity.
@@ -45,7 +58,8 @@ function statesEq(a: Map<string, RunnableRunState>, b: Map<string, RunnableRunSt
 	if (a.size !== b.size) return false
 	for (const [k, v] of a) {
 		const w = b.get(k)
-		if (!w || w.status !== v.status || w.runs !== v.runs) return false
+		if (!w || w.status !== v.status || w.runs !== v.runs || w.lastSuccessAt !== v.lastSuccessAt)
+			return false
 	}
 	return true
 }
@@ -128,7 +142,7 @@ export function useActiveRunnableIds(
 	// keeps showing the last status while idle; only `dispose()` clears them.
 	const completedHistory = new Map<
 		string,
-		{ runs: number; lastStatus: RunStatus; lastTs: string }
+		{ runs: number; lastStatus: RunStatus; lastTs: string; lastSuccessTs?: string }
 	>()
 	const countedJobIds = new Set<string>()
 	// Job ids we've observed in-flight at least once. The catch-up pulse is
@@ -241,10 +255,25 @@ export function useActiveRunnableIds(
 						const prev = completedHistory.get(id)
 						const status: RunStatus = (j as any).success === true ? 'success' : 'failure'
 						const ts = startedTs ?? new Date(pollStartedMs).toISOString()
+						// Freshness compares against COMPLETION time (that's
+						// when the output materialized — the server-side
+						// last_success_at is completed_at too). The listing
+						// only carries started_at, so add duration_ms; when
+						// absent, the start is a conservative lower bound
+						// (errs stale, never false-fresh).
+						const durationMs = (j as any).duration_ms
+						const doneTs =
+							typeof durationMs === 'number' && startedTs
+								? new Date(new Date(startedTs).getTime() + durationMs).toISOString()
+								: ts
 						completedHistory.set(id, {
 							runs: (prev?.runs ?? 0) + 1,
 							lastStatus: !prev || ts >= prev.lastTs ? status : prev.lastStatus,
-							lastTs: !prev || ts >= prev.lastTs ? ts : prev.lastTs
+							lastTs: !prev || ts >= prev.lastTs ? ts : prev.lastTs,
+							lastSuccessTs:
+								status === 'success' && (!prev?.lastSuccessTs || doneTs >= prev.lastSuccessTs)
+									? doneTs
+									: prev?.lastSuccessTs
 						})
 					}
 				}
@@ -267,6 +296,10 @@ export function useActiveRunnableIds(
 								: 'failure',
 						source: (j as any).schedule_path ? 'schedule' : 'run',
 						at: startedTs ?? new Date(pollStartedMs).toISOString(),
+						completedAt:
+							!isQueued && typeof (j as any).duration_ms === 'number' && startedTs
+								? new Date(new Date(startedTs).getTime() + (j as any).duration_ms).toISOString()
+								: undefined,
 						scheduledFor: isQueued ? ((j as any).scheduled_for as string | undefined) : undefined
 					})
 				}
@@ -289,7 +322,11 @@ export function useActiveRunnableIds(
 		// previous badge state until a worker picks the job up.
 		const snap = new Map<string, RunnableRunState>()
 		for (const [id, h] of completedHistory) {
-			snap.set(id, { status: runningThisTick.has(id) ? 'running' : h.lastStatus, runs: h.runs })
+			snap.set(id, {
+				status: runningThisTick.has(id) ? 'running' : h.lastStatus,
+				runs: h.runs,
+				lastSuccessAt: h.lastSuccessTs
+			})
 		}
 		for (const id of runningThisTick) {
 			if (!snap.has(id)) snap.set(id, { status: 'running', runs: 0 })
diff --git a/frontend/src/lib/components/assets/AssetGraph/boundedCascade.test.ts b/frontend/src/lib/components/assets/AssetGraph/boundedCascade.test.ts
index fa735682b7..e4692de6b8 100644
--- a/frontend/src/lib/components/assets/AssetGraph/boundedCascade.test.ts
+++ b/frontend/src/lib/components/assets/AssetGraph/boundedCascade.test.ts
@@ -7,24 +7,29 @@ import {
 	buildLineageDag,
 	buildLineageDownstreamMap,
 	descendants,
+	nonAutorunTriggerScripts,
+	reachableCutting,
 	scriptNodeId,
 	scriptsOf,
-	validStarts
+	validStarts,
+	validFromStarts
 } from './boundedCascade'
 import { computeInducedSchedule } from './graphTraversal'
 
 type W = [script: string, asset: string] // producer write edge (datatable)
 type R = [script: string, asset: string] // pure-read edge (datatable)
 type S = [script: string, asset: string] // `// on <asset>` subscription
+type T = [producer: string, tested: string, asset: string] // `// data_test` ordering edge
 
 function graph(opts: {
 	scripts?: string[]
 	writes?: W[]
 	reads?: R[]
 	subs?: S[]
+	tests?: T[]
 	native?: Array<[kind: NativeTriggerKind, script: string]>
 }): AssetGraphResponse {
-	const { scripts = [], writes = [], reads = [], subs = [], native = [] } = opts
+	const { scripts = [], writes = [], reads = [], subs = [], tests = [], native = [] } = opts
 	const triggers: AssetGraphTrigger[] = [
 		...subs.map(
 			([s, a]) =>
@@ -60,7 +65,15 @@ function graph(opts: {
 				access_type: 'r' as const
 			}))
 		],
-		triggers
+		triggers,
+		test_edges: tests.map(([producer, tested, a]) => ({
+			producer_kind: 'script' as const,
+			producer_path: producer,
+			runnable_kind: 'script' as const,
+			runnable_path: tested,
+			asset_kind: 'datatable' as const,
+			asset_path: a
+		}))
 	}
 }
 
@@ -95,6 +108,22 @@ describe('buildLineageDag', () => {
 		expect([...(dag.down.get(sn('u')) ?? [])]).toEqual([asset('x')])
 		expect(dag.up.get(sn('u'))).toBeUndefined() // asset is not upstream of its own writer
 	})
+
+	it('routes a data_test ordering edge through the referenced asset', () => {
+		// prod writes x; tested has a `// data_test` against x (prod → tested edge).
+		// The DAG must place x (and thus prod) upstream of tested so a cascade
+		// materializes x first.
+		const g = graph({
+			scripts: ['prod', 'tested'],
+			writes: [['prod', 'x']],
+			tests: [['prod', 'tested', 'x']]
+		})
+		const dag = buildLineageDag(g)
+		// asset x → tested (routed through the asset, not a direct prod → tested hop)
+		expect([...(dag.down.get(asset('x')) ?? [])]).toEqual([sn('tested')])
+		// prod → x → tested makes prod an ancestor of tested.
+		expect(ancestors(dag, sn('tested'))).toEqual(new Set([asset('x'), sn('prod')]))
+	})
 })
 
 describe('ancestors / descendants', () => {
@@ -247,6 +276,165 @@ describe('validStarts', () => {
 	})
 })
 
+describe('validFromStarts (mid-DAG selective execution)', () => {
+	// a → x → sub (subscriber) → y → reader (pure read). `k` is event-triggered.
+	const g = () =>
+		graph({
+			scripts: ['a', 'sub', 'reader', 'k'],
+			writes: [
+				['a', 'x'],
+				['sub', 'y']
+			],
+			reads: [['reader', 'y']],
+			subs: [['sub', 'x']],
+			native: [['kafka', 'k']]
+		})
+
+	it('includes mid-DAG subscribers and pure readers, not just roots', () => {
+		const from = validFromStarts(g())
+		expect(from.has(sn('a'))).toBe(true) // root
+		expect(from.has(sn('sub'))).toBe(true) // mid-DAG subscriber — NOT a validStart
+		expect(from.has(sn('reader'))).toBe(true) // pure reader
+		// The old root-only gate would have rejected the mid-DAG nodes.
+		expect(validStarts(g()).has(sn('sub'))).toBe(false)
+	})
+
+	it('excludes event-triggered scripts (no run-now gesture)', () => {
+		expect(validFromStarts(g()).has(sn('k'))).toBe(false)
+	})
+
+	it('excludes webhook/data_upload mid-DAG subscribers (need caller input)', () => {
+		// a → x → upload_mid (subscribes x AND `// on data_upload`) → y → consumer.
+		// upload_mid must NOT be an eligible start (empty-arg run has no S3Object),
+		// and must be a barrier so `consumer` isn't run with a skipped producer.
+		const g2 = graph({
+			scripts: ['a', 'upload_mid', 'hook_mid', 'consumer'],
+			writes: [
+				['a', 'x'],
+				['upload_mid', 'y']
+			],
+			subs: [
+				['upload_mid', 'x'],
+				['hook_mid', 'x'],
+				['consumer', 'y']
+			],
+			native: [
+				['data_upload', 'upload_mid'],
+				['webhook', 'hook_mid']
+			]
+		})
+		const from = validFromStarts(g2)
+		expect(from.has(sn('upload_mid'))).toBe(false)
+		expect(from.has(sn('hook_mid'))).toBe(false)
+		expect(from.has(sn('a'))).toBe(true) // the plain root is still eligible
+		// and they're barriers, so running downstream from `a` cuts them + consumer.
+		const bars = nonAutorunTriggerScripts(g2)
+		expect(bars.has(sn('upload_mid'))).toBe(true)
+		expect(bars.has(sn('hook_mid'))).toBe(true)
+		expect(scriptsOf(reachableCutting(buildLineageDag(g2), [sn('a')], bars)).sort()).toEqual(['a'])
+	})
+
+	it('keeps a scheduled root that also carries an event trigger', () => {
+		// schedule wins over the secondary kafka trigger in validStarts, so the
+		// scheduled root stays --from-eligible (regression guard).
+		const g2 = graph({
+			scripts: ['sched_evt', 'consumer'],
+			writes: [['sched_evt', 'x']],
+			subs: [['consumer', 'x']],
+			native: [
+				['schedule', 'sched_evt'],
+				['kafka', 'sched_evt']
+			]
+		})
+		expect(validStarts(g2).has(sn('sched_evt'))).toBe(true)
+		expect(nonAutorunTriggerScripts(g2).has(sn('sched_evt'))).toBe(true)
+		expect(validFromStarts(g2).has(sn('sched_evt'))).toBe(true) // union with roots
+	})
+
+	it('runs a mid-DAG start plus its downstream WITHOUT re-running upstream', () => {
+		// Starting at `sub`, the unbounded downstream is {sub, y, reader} — `a`/`x`
+		// upstream are never pulled in (dbt `--select sub+`).
+		const dag = buildLineageDag(g())
+		const downstream = new Set([sn('sub'), ...descendants(dag, sn('sub'))])
+		expect(scriptsOf(downstream).sort()).toEqual(['reader', 'sub'])
+		expect(downstream.has(sn('a'))).toBe(false)
+		expect(downstream.has(asset('x'))).toBe(false)
+	})
+})
+
+describe('reachableCutting (barrier cut for "Run + downstream")', () => {
+	// a → x → k(kafka, also reads x) → z → consumer. Starting at `a` and running
+	// downstream must cut the event handler `k` AND `consumer` (only reachable
+	// through it) — else they'd launch with empty args. Mirrors the CLI cut.
+	const g = () =>
+		graph({
+			scripts: ['a', 'k', 'consumer'],
+			writes: [
+				['a', 'x'],
+				['k', 'z']
+			],
+			reads: [['k', 'x']],
+			subs: [['consumer', 'z']],
+			native: [['kafka', 'k']]
+		})
+
+	it('detects event-triggered scripts as barriers', () => {
+		expect(nonAutorunTriggerScripts(g()).has(sn('k'))).toBe(true)
+		expect(nonAutorunTriggerScripts(g()).has(sn('a'))).toBe(false)
+	})
+
+	it('cuts an event descendant and its event-only downstream from a run set', () => {
+		const dag = buildLineageDag(g())
+		const barriers = nonAutorunTriggerScripts(g())
+		const runNodes = reachableCutting(dag, [sn('a')], barriers)
+		expect(scriptsOf(runNodes).sort()).toEqual(['a']) // k + consumer cut
+		expect(runNodes.has(sn('k'))).toBe(false)
+		expect(runNodes.has(sn('consumer'))).toBe(false)
+	})
+
+	it('protects an explicit start even if it carries an event trigger', () => {
+		const dag = buildLineageDag(g())
+		// start = k itself (user named it); it runs, and so does its downstream.
+		const barriers = new Set([...nonAutorunTriggerScripts(g())].filter((id) => id !== sn('k')))
+		const runNodes = reachableCutting(dag, [sn('k')], barriers)
+		expect(scriptsOf(runNodes).sort()).toEqual(['consumer', 'k'])
+	})
+
+	it('keeps a scheduled event root (and its downstream) reachable from an upstream start', () => {
+		// a → x → sched_evt(schedule + kafka) → y → consumer. Running downstream
+		// from `a`, sched_evt is a scheduled root so it must NOT be a barrier even
+		// though it carries an event trigger — matching the CLI, which excludes all
+		// valid roots (`starts`), not just the picked start. Mirror of the page's
+		// barrier construction: nonAutorunTriggerScripts minus validStarts minus start.
+		const g2 = graph({
+			scripts: ['a', 'sched_evt', 'consumer'],
+			writes: [
+				['a', 'x'],
+				['sched_evt', 'y']
+			],
+			subs: [
+				['sched_evt', 'x'],
+				['consumer', 'y']
+			],
+			native: [
+				['schedule', 'sched_evt'],
+				['kafka', 'sched_evt']
+			]
+		})
+		const dag = buildLineageDag(g2)
+		const roots = validStarts(g2)
+		const barriers = new Set(
+			[...nonAutorunTriggerScripts(g2)].filter((id) => !roots.has(id) && id !== sn('a'))
+		)
+		const runNodes = reachableCutting(dag, [sn('a')], barriers)
+		expect(scriptsOf(runNodes).sort()).toEqual(['a', 'consumer', 'sched_evt'])
+		// Without the validStarts exclusion, sched_evt (a kafka handler) would be a
+		// barrier and `consumer` would be dropped — the bug this guards.
+		const naiveBarriers = new Set([...nonAutorunTriggerScripts(g2)].filter((id) => id !== sn('a')))
+		expect(scriptsOf(reachableCutting(dag, [sn('a')], naiveBarriers)).sort()).toEqual(['a'])
+	})
+})
+
 describe('buildLineageDownstreamMap (read-aware scheduling)', () => {
 	// a writes x; c only *reads* x (no `// on x`). c must still run after a.
 	const g = graph({
@@ -271,6 +459,47 @@ describe('buildLineageDownstreamMap (read-aware scheduling)', () => {
 		expect(readAware.indegree.get('c')).toBe(1)
 		expect(readAware.nodes).toEqual(['a', 'c'])
 	})
+
+	it('orders a disjoint-root producer before a data_test that references it', () => {
+		// Two disjoint roots (the HD-1 repro): `dim` produces the dimension
+		// `dimc`; `fct` produces `fcto` and has a `// data_test relationships`
+		// against `dimc`. Without the test edge they are unordered and a cold
+		// cascade can run `fct` first ("table dimc does not exist"). The test
+		// edge must place `dim` strictly before `fct`.
+		const g = graph({
+			scripts: ['dim', 'fct'],
+			writes: [
+				['dim', 'dimc'],
+				['fct', 'fcto']
+			],
+			tests: [['dim', 'fct', 'dimc']]
+		})
+		const selected = new Set(['dim', 'fct'])
+		const map = buildLineageDownstreamMap(g)
+		expect([...(map.get('dim') ?? [])]).toEqual(['fct'])
+		const schedule = computeInducedSchedule(g, selected, map)
+		expect(schedule.roots).toEqual(['dim'])
+		expect(schedule.indegree.get('fct')).toBe(1)
+		expect(schedule.nodes).toEqual(['dim', 'fct'])
+		expect(schedule.cyclic).toEqual([])
+	})
+
+	it('adds no ordering when the referenced asset has no in-pipeline producer', () => {
+		// `fct` tests against an external `ext` table nothing produces — the
+		// backend emits no test edge, so the frontend sees none and `fct` stays
+		// an independent root (the runtime error stands, as designed).
+		const g = graph({
+			scripts: ['dim', 'fct'],
+			writes: [['fct', 'fcto']],
+			tests: [] // no producer for `ext` ⇒ backend omitted the edge
+		})
+		const schedule = computeInducedSchedule(
+			g,
+			new Set(['dim', 'fct']),
+			buildLineageDownstreamMap(g)
+		)
+		expect(schedule.roots.sort()).toEqual(['dim', 'fct'])
+	})
 })
 
 describe('assetUriToNodeId', () => {
@@ -280,4 +509,15 @@ describe('assetUriToNodeId', () => {
 		expect(assetUriToNodeId('ducklake://lake/t')).toBe('ducklake:lake/t')
 		expect(assetUriToNodeId('not-a-uri')).toBeUndefined()
 	})
+	it('strips leading slashes from S3 keys so s3:/// and s3:// share a node', () => {
+		// Mirror of Rust `parse_asset_syntax`: `--to s3:///exports/x` must resolve
+		// to the same canonical node as the graph's `s3object:exports/x`.
+		expect(assetUriToNodeId('s3:///exports/x')).toBe('s3object:exports/x')
+		expect(assetUriToNodeId('s3:///exports/x')).toBe(assetUriToNodeId('s3://exports/x'))
+		// All leading slashes are stripped so a canonical key never starts with
+		// `/` (the quad-slash `S3Object(s3="/x")` form collapses to `x`).
+		expect(assetUriToNodeId('s3:////x')).toBe('s3object:x')
+		// Hive-partition keys and non-S3 kinds are untouched.
+		expect(assetUriToNodeId('s3:///t/y=2024/f.parquet')).toBe('s3object:t/y=2024/f.parquet')
+	})
 })
diff --git a/frontend/src/lib/components/assets/AssetGraph/boundedCascade.ts b/frontend/src/lib/components/assets/AssetGraph/boundedCascade.ts
index 44a26d9c71..6fcabbe71f 100644
--- a/frontend/src/lib/components/assets/AssetGraph/boundedCascade.ts
+++ b/frontend/src/lib/components/assets/AssetGraph/boundedCascade.ts
@@ -38,14 +38,16 @@ export function assetUriToNodeId(uri: string): string | undefined {
 	// `s3` is the URI prefix for the `s3object` asset kind (mirrors the CLI
 	// `assetUri` and the canvas). All other kinds use their name verbatim.
 	const kind = prefix === 's3' ? 's3object' : prefix
-	return `${kind}:${m[2]}`
+	// Mirror Rust `parse_asset_syntax`: strip all leading slashes from S3 keys so
+	// `s3:///key` (default storage) and `s3://key` resolve to the same node id
+	// and a canonical key never starts with `/`.
+	const path = kind === 's3object' ? m[2].replace(/^\/+/, '') : m[2]
+	return `${kind}:${path}`
 }
 
 // Native trigger kinds that fan out *per event*: a single event always flows
 // through the whole reactive downstream, so "run up to X now" is not a
 // meaningful gesture and these are never offered as bounded-run starts.
-// `webhook`/`data_upload` have no trigger row in `/assets/graph`, so a root
-// whose only entry is one of those reads as a *manual* root below.
 const EVENT_TRIGGER_KINDS: ReadonlySet<string> = new Set<NativeTriggerKind>([
 	'kafka',
 	'mqtt',
@@ -56,6 +58,20 @@ const EVENT_TRIGGER_KINDS: ReadonlySet<string> = new Set<NativeTriggerKind>([
 	'email'
 ])
 
+// Trigger kinds a cascade must NOT auto-run: the per-event kinds above PLUS the
+// input-only entrypoints `webhook`/`data_upload`, which need caller-supplied
+// input (a request body / an uploaded S3Object) and would run the wrong thing
+// with empty args. Mirror of the CLI `NON_AUTORUN_TRIGGER_KINDS`. When the
+// deployed `/assets/graph` omits a `webhook`/`data_upload` row (it has none for
+// them), such a script simply reads as a manual root here — but whenever the
+// marker IS visible (editor overlay / draft), it's excluded from bounded-run
+// starts and cut as a barrier, exactly as the CLI does.
+const NON_AUTORUN_TRIGGER_KINDS: ReadonlySet<string> = new Set<string>([
+	...EVENT_TRIGGER_KINDS,
+	'webhook',
+	'data_upload'
+])
+
 export type LineageDag = {
 	/** upstream node id → set of direct downstream node ids. */
 	down: Map<string, Set<string>>
@@ -70,10 +86,17 @@ export type LineageDag = {
  *   - producer script → asset   (write / rw edges)
  *   - asset → reader script      (pure-read edges — a data dependency)
  *   - asset → subscriber script  (`// on <asset>` triggers)
+ *   - asset → testing script     (`// data_test` ordering edges)
  *
  * An `rw` edge is treated as production only (script → asset); emitting the
  * reverse asset → script too would make every upsert a 2-cycle through its own
  * asset.
+ *
+ * `test_edges` are modeled through the referenced asset (asset → testing
+ * script), NOT as a direct producer → testing-script hop: the producer already
+ * has a write edge to that asset, so this yields producer → asset → testing
+ * script and keeps the two-hop (script → asset → script) invariant that
+ * `buildLineageDownstreamMap` relies on.
  */
 export function buildLineageDag(g: AssetGraphResponse): LineageDag {
 	const down = new Map<string, Set<string>>()
@@ -107,6 +130,13 @@ export function buildLineageDag(g: AssetGraphResponse): LineageDag {
 		if (t.trigger_kind !== 'asset' || t.runnable_kind !== 'script') continue
 		addEdge(assetKey(t), scriptNodeId(t.runnable_path))
 	}
+	// Data-test ordering edges: the referenced asset must exist before the
+	// tested script runs. Routed through the asset node so the existing
+	// producer → asset write edge extends into producer → asset → testing script.
+	for (const t of g.test_edges ?? []) {
+		if (t.runnable_kind !== 'script') continue
+		addEdge(assetKey(t), scriptNodeId(t.runnable_path))
+	}
 
 	return { down, up, nodes }
 }
@@ -138,6 +168,37 @@ export function ancestors(dag: LineageDag, n: string): Set<string> {
 	return closure(dag.up, n)
 }
 
+/**
+ * Nodes reachable from `starts` over the lineage DAG, treating `barriers` as cut
+ * points: a barrier node is neither included NOR traversed through, so a node
+ * reachable ONLY via a barrier is excluded while one also reachable via another
+ * path stays. Mirror of the CLI `reachableCutting`. Used to keep event handlers
+ * (and their event-only downstream) out of a cascade run — running such a
+ * consumer whose producer was skipped would feed it missing/stale inputs.
+ */
+export function reachableCutting(
+	dag: LineageDag,
+	starts: Iterable<string>,
+	barriers: Set<string>
+): Set<string> {
+	const seen = new Set<string>()
+	const queue: string[] = []
+	for (const s of starts) {
+		if (barriers.has(s) || seen.has(s)) continue
+		seen.add(s)
+		queue.push(s)
+	}
+	while (queue.length > 0) {
+		const n = queue.shift()!
+		for (const next of dag.down.get(n) ?? []) {
+			if (barriers.has(next) || seen.has(next)) continue
+			seen.add(next)
+			queue.push(next)
+		}
+	}
+	return seen
+}
+
 export type BoundedResult = {
 	/** Path-between node set (scripts + assets), always including `start`. */
 	nodes: Set<string>
@@ -201,6 +262,56 @@ export function validStarts(g: AssetGraphResponse): Set<string> {
 	return out
 }
 
+/**
+ * Script node ids eligible as an EXPLICIT bounded-run start from *anywhere* in
+ * the DAG (dbt's `--select model+`): every script that can run with empty args —
+ * i.e. all scripts except event-triggered ones (kafka/mqtt/nats/postgres/sqs/
+ * gcp/email fan out per event and have no "run now" gesture). Unlike
+ * `validStarts` (schedule/manual roots only), this INCLUDES mid-DAG asset
+ * subscribers and pure readers, so "Run + downstream" can begin at any model —
+ * that node plus its transitive downstream runs, upstream is never re-run.
+ * (`webhook`/`data_upload` have no trigger row here — same as `validStarts` they
+ * read as manual roots and are already included.)
+ */
+export function validFromStarts(g: AssetGraphResponse): Set<string> {
+	const nonAutorunScripts = new Set<string>()
+	for (const t of g.triggers ?? []) {
+		if (t.runnable_kind !== 'script') continue
+		if (NON_AUTORUN_TRIGGER_KINDS.has(t.trigger_kind)) nonAutorunScripts.add(t.runnable_path)
+	}
+	// Seed with schedule/manual roots: `validStarts` lets a schedule identity win
+	// over a secondary non-autorun trigger, so a scheduled root that also carries
+	// e.g. a `// on kafka` stays `--from`-eligible. The mid-DAG loop then adds only
+	// scripts that can run with empty args — a `webhook`/`data_upload` subscriber
+	// is NOT added (it needs caller-supplied input).
+	const out = new Set<string>(validStarts(g))
+	for (const r of g.runnables ?? []) {
+		if (r.usage_kind !== 'script') continue
+		if (!nonAutorunScripts.has(r.path)) out.add(scriptNodeId(r.path))
+	}
+	return out
+}
+
+/**
+ * Script node ids carrying a non-autorun trigger (event kinds kafka/mqtt/…/email
+ * PLUS input-only webhook/data_upload) — they fan out per event or need
+ * caller-supplied input, so a cascade must cut them (as `barriers` for
+ * `reachableCutting`) even when they're a lineage descendant of the start.
+ * Mirror of the CLI `nonAutorunTriggerScripts`. Only detects what the graph
+ * surfaces: the deployed `/assets/graph` omits `webhook`/`data_upload` rows, so
+ * such a handler is only cut when its marker is visible (editor overlay / draft)
+ * — the same limitation as `validStarts`; the CLI closes it via graph enrichment.
+ */
+export function nonAutorunTriggerScripts(g: AssetGraphResponse): Set<string> {
+	const out = new Set<string>()
+	for (const t of g.triggers ?? []) {
+		if (t.runnable_kind === 'script' && NON_AUTORUN_TRIGGER_KINDS.has(t.trigger_kind)) {
+			out.add(scriptNodeId(t.runnable_path))
+		}
+	}
+	return out
+}
+
 /** Project a node-id set to the script paths it contains (run targets). */
 export function scriptsOf(nodes: Iterable<string>): string[] {
 	const out: string[] = []
diff --git a/frontend/src/lib/components/assets/AssetGraph/cascadeOrchestrator.test.ts b/frontend/src/lib/components/assets/AssetGraph/cascadeOrchestrator.test.ts
index 92d7a977fe..3a0fd4fbd3 100644
--- a/frontend/src/lib/components/assets/AssetGraph/cascadeOrchestrator.test.ts
+++ b/frontend/src/lib/components/assets/AssetGraph/cascadeOrchestrator.test.ts
@@ -201,7 +201,48 @@ describe('runSelection', () => {
 		expect(r.launched.indexOf('c')).toBeGreaterThan(r.launched.indexOf('b'))
 	})
 
-	it('stops scheduling after a failure', async () => {
+	it('skips a failed node’s descendants but keeps independent branches running', async () => {
+		// Two independent chains: a → b and c → d. `a` fails; `b` (its descendant)
+		// must be skipped, but `d` depends only on the successful `c`, so it must
+		// still run — a failure must not stall unrelated branches.
+		const sched = schedule(
+			[
+				['a', 'b'],
+				['c', 'd']
+			],
+			['a', 'b', 'c', 'd'],
+			['a', 'c']
+		)
+		const r = fakeRunner({ a: 'failure' })
+		const res = await runSelection({ schedule: sched, ...r })
+		expect(res.ok).toBe(false)
+		expect(res.statuses.get('a')?.status).toBe('failure')
+		expect(res.statuses.get('b')?.status).toBe('skipped')
+		expect(res.statuses.get('c')?.status).toBe('success')
+		expect(res.statuses.get('d')?.status).toBe('success')
+		expect(r.launched).toContain('d')
+		expect(r.launched).not.toContain('b')
+	})
+
+	it('skips a join node when any one of its upstreams fails', async () => {
+		// {a, b} → c. `a` fails; `c` needs both, so it must be skipped even though
+		// `b` succeeds — a poisoned lineage isn’t rescued by a sibling success.
+		const sched = schedule(
+			[
+				['a', 'c'],
+				['b', 'c']
+			],
+			['a', 'b', 'c'],
+			['a', 'b']
+		)
+		const r = fakeRunner({ a: 'failure' })
+		const res = await runSelection({ schedule: sched, ...r })
+		expect(res.ok).toBe(false)
+		expect(res.statuses.get('c')?.status).toBe('skipped')
+		expect(r.launched).not.toContain('c')
+	})
+
+	it('stops scheduling a failed node’s chain', async () => {
 		const sched = schedule([['a', 'b']], ['a', 'b'], ['a'])
 		const r = fakeRunner({ a: 'failure' })
 		const res = await runSelection({ schedule: sched, ...r })
diff --git a/frontend/src/lib/components/assets/AssetGraph/cascadeOrchestrator.ts b/frontend/src/lib/components/assets/AssetGraph/cascadeOrchestrator.ts
index 16d357af00..424f1581ec 100644
--- a/frontend/src/lib/components/assets/AssetGraph/cascadeOrchestrator.ts
+++ b/frontend/src/lib/components/assets/AssetGraph/cascadeOrchestrator.ts
@@ -128,8 +128,9 @@ export type SelectionRunOptions = {
  * Execute an arbitrary selected set of scripts (e.g. a bounded-cascade
  * selection) in topological order. Unlike `runCascade` there is no single
  * privileged root — every `schedule.roots` entry is seeded at once and a node
- * runs as soon as its in-set upstreams all succeed. Failure stops *scheduling*
- * (in-flight jobs finish); everything not yet started ends 'skipped'.
+ * runs as soon as its in-set upstreams all succeed. A failure abandons only
+ * that node's lineage (its transitive descendants end 'skipped'); INDEPENDENT
+ * branches keep running. In-flight jobs always finish.
  */
 export async function runSelection(opts: SelectionRunOptions): Promise<CascadeRunResult> {
 	const { schedule, launch, waitTerminal, onUpdate } = opts
@@ -137,10 +138,29 @@ export async function runSelection(opts: SelectionRunOptions): Promise<CascadeRu
 	for (const n of schedule.nodes) statuses.set(n, { status: 'pending' })
 	const remaining = new Map(schedule.indegree)
 	let failed = false
+	// Nodes a failed prerequisite has made unrunnable — the transitive descendants
+	// of every failure. Gating scheduling on this (rather than a single global
+	// fail-fast flag) is what lets independent branches finish: only the lineage
+	// below a failure is skipped, not every node that happens to become ready
+	// afterwards. Poisoned nodes are never scheduled, so they end 'skipped' below.
+	const poisoned = new Set<string>()
 	const inFlight = new Set<Promise<void>>()
 
 	const emit = () => onUpdate?.(new Map(statuses))
 
+	function poison(path: string) {
+		const stack = [path]
+		while (stack.length > 0) {
+			const n = stack.pop()!
+			for (const s of schedule.edges.get(n) ?? []) {
+				if (!poisoned.has(s)) {
+					poisoned.add(s)
+					stack.push(s)
+				}
+			}
+		}
+	}
+
 	function schedule_(path: string) {
 		const p = runNode(path).finally(() => inFlight.delete(p))
 		inFlight.add(p)
@@ -159,6 +179,7 @@ export async function runSelection(opts: SelectionRunOptions): Promise<CascadeRu
 			emit()
 			if (term === 'failure') {
 				failed = true
+				poison(path)
 				return
 			}
 		} catch (e) {
@@ -169,12 +190,13 @@ export async function runSelection(opts: SelectionRunOptions): Promise<CascadeRu
 			})
 			emit()
 			failed = true
+			poison(path)
 			return
 		}
 		for (const s of schedule.edges.get(path) ?? []) {
 			const d = (remaining.get(s) ?? 0) - 1
 			remaining.set(s, d)
-			if (d === 0 && !failed) schedule_(s)
+			if (d === 0 && !poisoned.has(s)) schedule_(s)
 		}
 	}
 
diff --git a/frontend/src/lib/components/assets/AssetGraph/parsePipelineAnnotations.parity.test.ts b/frontend/src/lib/components/assets/AssetGraph/parsePipelineAnnotations.parity.test.ts
index 077377ec2a..0ad56c81f9 100644
--- a/frontend/src/lib/components/assets/AssetGraph/parsePipelineAnnotations.parity.test.ts
+++ b/frontend/src/lib/components/assets/AssetGraph/parsePipelineAnnotations.parity.test.ts
@@ -72,6 +72,8 @@ type Fixture = {
 			scd2?: boolean
 			track?: string[]
 			close_deleted?: boolean
+			// "warn" | "ignore"; absent === "warn" (the default)
+			on_schema_change?: string
 		} | null
 		// Snake_case form matching the Rust `DataTest` serde output, so the one
 		// corpus drives both sides. The TS parser emits this shape verbatim
@@ -180,6 +182,9 @@ describe('parsePipelineAnnotations matches the shared Rust fixture corpus', () =
 				expect(got.materialize?.closeDeleted ?? false, 'materialize close_deleted').toBe(
 					f.expected.materialize.close_deleted ?? false
 				)
+				expect(got.materialize?.onSchemaChange ?? 'warn', 'materialize on_schema_change').toBe(
+					f.expected.materialize.on_schema_change ?? 'warn'
+				)
 			}
 
 			expect(got.dataTests, 'data tests').toEqual(f.expected.data_tests ?? [])
diff --git a/frontend/src/lib/components/assets/AssetGraph/parsePipelineAnnotations.test.ts b/frontend/src/lib/components/assets/AssetGraph/parsePipelineAnnotations.test.ts
index 315c7526f3..e9e23525ec 100644
--- a/frontend/src/lib/components/assets/AssetGraph/parsePipelineAnnotations.test.ts
+++ b/frontend/src/lib/components/assets/AssetGraph/parsePipelineAnnotations.test.ts
@@ -1,6 +1,7 @@
 import { describe, expect, it } from 'vitest'
 import {
 	mergeColumnLineage,
+	parseDurationSecs,
 	parsePipelineAnnotations,
 	type ColumnLineage
 } from './parsePipelineAnnotations'
@@ -188,3 +189,40 @@ describe('mergeColumnLineage', () => {
 		expect(mergeColumnLineage([], annotated)).toEqual(annotated)
 	})
 })
+
+// Mirror of the Rust `parse_duration_secs` tests (windmill-common assets.rs)
+// — the freshness chip's staleness verdict depends on identical parsing.
+describe('parseDurationSecs', () => {
+	it('parses suffixed durations', () => {
+		expect(parseDurationSecs('30s')).toBe(30)
+		expect(parseDurationSecs('5m')).toBe(300)
+		expect(parseDurationSecs('2h')).toBe(7200)
+		expect(parseDurationSecs('1d')).toBe(86400)
+	})
+
+	it('bare integer means seconds', () => {
+		expect(parseDurationSecs('45')).toBe(45)
+	})
+
+	it('tolerates surrounding whitespace', () => {
+		expect(parseDurationSecs(' 5 m ')).toBe(300)
+	})
+
+	it('accepts an explicit plus sign (Rust i64 parsing does)', () => {
+		expect(parseDurationSecs('+5m')).toBe(300)
+		expect(parseDurationSecs('+45')).toBe(45)
+	})
+
+	it('rejects malformed / non-positive input', () => {
+		expect(parseDurationSecs('')).toBeUndefined()
+		expect(parseDurationSecs('h')).toBeUndefined()
+		expect(parseDurationSecs('1.5h')).toBeUndefined()
+		expect(parseDurationSecs('-5m')).toBeUndefined()
+		expect(parseDurationSecs('0')).toBeUndefined()
+		expect(parseDurationSecs('fast')).toBeUndefined()
+	})
+
+	it('rejects values beyond i32 seconds (mirrors backend cap)', () => {
+		expect(parseDurationSecs('999999999d')).toBeUndefined()
+	})
+})
diff --git a/frontend/src/lib/components/assets/AssetGraph/parsePipelineAnnotations.ts b/frontend/src/lib/components/assets/AssetGraph/parsePipelineAnnotations.ts
index f33a03fff5..47eea81246 100644
--- a/frontend/src/lib/components/assets/AssetGraph/parsePipelineAnnotations.ts
+++ b/frontend/src/lib/components/assets/AssetGraph/parsePipelineAnnotations.ts
@@ -67,6 +67,28 @@ export type FreshnessSpec = {
 	duration: string
 }
 
+// Mirrors backend `parse_duration_secs` (windmill-common assets.rs): a bare
+// integer means seconds, otherwise `<n>` with an `s`/`m`/`h`/`d` suffix
+// (e.g. `30s`, `5m`, `2h`, `1d`). Returns undefined for malformed or
+// non-positive input so a typo'd `// freshness` window fails safe (the chip
+// stays neutral instead of guessing a staleness verdict).
+export function parseDurationSecs(s: string): number | undefined {
+	const t = s.trim()
+	if (!t) return undefined
+	const last = t[t.length - 1]
+	const mult =
+		last === 's' ? 1 : last === 'm' ? 60 : last === 'h' ? 3600 : last === 'd' ? 86400 : undefined
+	const num = (mult !== undefined ? t.slice(0, -1) : t).trim()
+	// `+?`: Rust's i64 parsing accepts an explicit plus sign (`+5m`), so the
+	// mirror must too — divergence here would leave the chip neutral for a
+	// window the deploy path and watchdog honor.
+	if (mult === undefined && !/^\+?\d+$/.test(t)) return undefined
+	if (!/^\+?\d+$/.test(num)) return undefined
+	const secs = Number(num) * (mult ?? 1)
+	if (!Number.isSafeInteger(secs) || secs <= 0 || secs > 2147483647) return undefined
+	return secs
+}
+
 // `// retry <count> [<delay>]` — see backend RetrySpec. Delay is kept as the
 // raw duration string and resolved to seconds at deploy.
 export type RetrySpec = {
@@ -95,6 +117,20 @@ export type MaterializeSpec = {
 	track?: string[]
 	// SCD2 hard-delete-close (`deletes=close`): close absent keys; absent === false
 	closeDeleted?: boolean
+	// `on_schema_change=ignore` opts the produced asset out of downstream
+	// schema-contract warnings (save-time metadata only). Default `warn`;
+	// `fail` is deliberately unrecognized in v1 (saves never hard-block).
+	onSchemaChange?: 'warn' | 'ignore'
+}
+
+// The `<targetPath>_current` SCD2 companion view this managed materialize also
+// produces, or `undefined` when it isn't a managed scd2 target. Mirrors Rust
+// `MaterializeSpec::scd2_current_target`: managed scd2 creates the base table
+// *and* the `_current` view each run; `manual` mode owns its own DDL and creates
+// no companion. The graph surfaces register it as a second write of the producer
+// so a read of the view links back instead of orphaning.
+export function scd2CurrentTargetPath(m: MaterializeSpec): string | undefined {
+	return m.scd2 && !m.manual ? `${m.targetPath}_current` : undefined
 }
 
 // `// data_test <kind> …` — a data-quality assertion run against the
@@ -221,7 +257,18 @@ function parseKvOpts(s: string): Map<string, string> {
 function parseAssetSyntax(s: string): PipelineTriggerAsset | undefined {
 	for (const [prefix, kind] of ASSET_PREFIXES) {
 		if (s.startsWith(prefix)) {
-			return { kind, path: s.slice(prefix.length) }
+			let path = s.slice(prefix.length)
+			// Mirror the Rust `parse_asset_syntax` S3 canonicalization: strip all
+			// leading slashes so the SDK object form (`s3:///key`, default
+			// storage) and DuckDB / `// on s3://key` share one asset path, and a
+			// canonical key never starts with `/` (so ref reconstruction
+			// round-trips). Without this the live graph preview would show
+			// disconnected `/key` and `key` nodes. S3-only; leading slashes only,
+			// so Hive-partition keys are untouched.
+			if (kind === 's3object') {
+				path = path.replace(/^\/+/, '')
+			}
+			return { kind, path }
 		}
 	}
 	return undefined
@@ -242,7 +289,8 @@ function parseAssetSyntaxDefault(s: string): PipelineTriggerAsset | undefined {
 // managed mode; a leading `scd2` word is an alias for the `history` flag; the
 // next token is the target asset URI (default-syntax shorthands enabled); the
 // remainder are strategy options (`append` flag, `key=<col>`, `history` flag,
-// `track=<c1,c2,…>`, `deletes=close`). Missing/empty target → undefined (dropped).
+// `track=<c1,c2,…>`, `deletes=close`, `on_schema_change=ignore`). Missing/empty
+// target → undefined (dropped).
 function parseMaterializeSpec(s: string): MaterializeSpec | undefined {
 	// One optional leading mode keyword: `manual` (track-only) or `scd2` (an alias
 	// for the `history` flag below).
@@ -282,6 +330,9 @@ function parseMaterializeSpec(s: string): MaterializeSpec | undefined {
 	// `deletes=close` (scd2 only) opts into hard-delete-close; any other value
 	// (or absence) keeps the soft-delete default.
 	const closeDeleted = opts.get('deletes') === 'close'
+	// `on_schema_change=ignore` suppresses downstream contract warnings; any
+	// other value (or absence) keeps the `warn` default, fail-safe like `deletes=`.
+	const onSchemaChange = opts.get('on_schema_change') === 'ignore' ? 'ignore' : 'warn'
 	return {
 		targetKind: asset.kind,
 		targetPath: asset.path,
@@ -290,7 +341,8 @@ function parseMaterializeSpec(s: string): MaterializeSpec | undefined {
 		uniqueKey,
 		scd2,
 		track,
-		closeDeleted
+		closeDeleted,
+		onSchemaChange
 	}
 }
 
diff --git a/frontend/src/lib/components/assets/AssetGraph/partitionBuckets.test.ts b/frontend/src/lib/components/assets/AssetGraph/partitionBuckets.test.ts
new file mode 100644
index 0000000000..a8a47af259
--- /dev/null
+++ b/frontend/src/lib/components/assets/AssetGraph/partitionBuckets.test.ts
@@ -0,0 +1,161 @@
+import { describe, expect, it } from 'vitest'
+import {
+	bucketFor,
+	bucketFromInputValue,
+	defaultBucket,
+	inputValueFromBucket,
+	isBeforeStart,
+	isValidStart,
+	isValidTimeZone,
+	partitionInputType,
+	partitionMetadataError,
+	recentBuckets,
+	startBucketOf,
+	usesCalendarPicker
+} from './partitionBuckets'
+import type { PartitionSpec } from './parsePipelineAnnotations'
+
+const spec = (kind: PartitionSpec['kind'], extra: Partial<PartitionSpec> = {}): PartitionSpec =>
+	({ kind, ...extra }) as PartitionSpec
+
+// A fixed UTC instant: 2026-07-05 14:37Z (a Sunday — ISO week 27 of 2026).
+// Explicit UTC so the assertions are independent of the test runner's TZ, and
+// they exercise the same UTC default the backend uses when `spec.tz` is absent.
+const at = new Date(Date.UTC(2026, 6, 5, 14, 37, 0))
+
+describe('bucketFor mirrors backend default_format (UTC)', () => {
+	it('daily -> %Y-%m-%d', () => {
+		expect(bucketFor(spec('daily'), at)).toBe('2026-07-05')
+	})
+	it('hourly -> %Y-%m-%dT%H', () => {
+		expect(bucketFor(spec('hourly'), at)).toBe('2026-07-05T14')
+	})
+	it('monthly -> %Y-%m', () => {
+		expect(bucketFor(spec('monthly'), at)).toBe('2026-07')
+	})
+	it('weekly -> ISO %G-W%V', () => {
+		expect(bucketFor(spec('weekly'), at)).toBe('2026-W27')
+	})
+})
+
+describe('bucketFor honours spec.tz', () => {
+	// 2026-07-05 02:30Z is still 2026-07-04 in America/New_York (UTC-4 in July).
+	const nearMidnight = new Date(Date.UTC(2026, 6, 5, 2, 30, 0))
+	it('shifts the day boundary by the producer tz', () => {
+		expect(bucketFor(spec('daily'), nearMidnight)).toBe('2026-07-05') // UTC default
+		expect(bucketFor(spec('daily', { tz: 'America/New_York' }), nearMidnight)).toBe('2026-07-04')
+	})
+	it('shifts the hour bucket by the producer tz', () => {
+		// 02:30Z -> 22 (previous day) in New York.
+		expect(bucketFor(spec('hourly', { tz: 'America/New_York' }), nearMidnight)).toBe(
+			'2026-07-04T22'
+		)
+	})
+})
+
+describe('defaultBucket honours the start= anchor', () => {
+	// `at` is 2026-07-05.
+	it('seeds the current bucket when at or after start', () => {
+		expect(defaultBucket(spec('daily'), at)).toBe('2026-07-05')
+		expect(defaultBucket(spec('daily', { start: '2026-01-01' }), at)).toBe('2026-07-05')
+		expect(defaultBucket(spec('daily', { start: '2026-07-05' }), at)).toBe('2026-07-05') // == start, not before
+	})
+	it('seeds the start bucket (never a pre-start one) when before start', () => {
+		expect(defaultBucket(spec('daily', { start: '2026-08-01' }), at)).toBe('2026-08-01')
+		expect(defaultBucket(spec('monthly', { start: '2026-08-01' }), at)).toBe('2026-08')
+		expect(defaultBucket(spec('hourly', { start: '2026-08-01' }), at)).toBe('2026-08-01T00')
+	})
+	it('isBeforeStart mirrors the backend date comparison', () => {
+		expect(isBeforeStart(spec('daily', { start: '2026-08-01' }), at)).toBe(true)
+		expect(isBeforeStart(spec('daily', { start: '2026-07-05' }), at)).toBe(false)
+		expect(isBeforeStart(spec('daily'), at)).toBe(false)
+	})
+	it('startBucketOf renders the anchor in the cadence, undefined when unset', () => {
+		expect(startBucketOf(spec('daily', { start: '2026-08-01' }))).toBe('2026-08-01')
+		expect(startBucketOf(spec('monthly', { start: '2026-08-15' }))).toBe('2026-08')
+		expect(startBucketOf(spec('hourly', { start: '2026-08-01' }))).toBe('2026-08-01T00')
+		expect(startBucketOf(spec('daily'))).toBeUndefined()
+	})
+})
+
+describe('malformed metadata fails safe (parity with backend validation)', () => {
+	it('isValidTimeZone rejects garbage, accepts real zones and absence', () => {
+		expect(isValidTimeZone(undefined)).toBe(true)
+		expect(isValidTimeZone('UTC')).toBe(true)
+		expect(isValidTimeZone('America/New_York')).toBe(true)
+		expect(isValidTimeZone('Not/AZone')).toBe(false)
+		expect(isValidTimeZone('garbage')).toBe(false)
+	})
+	it('isValidStart rejects malformed and JS-normalized dates', () => {
+		expect(isValidStart(undefined)).toBe(true)
+		expect(isValidStart('2026-08-01')).toBe(true)
+		expect(isValidStart('2026-02-31')).toBe(false) // JS would roll to Mar 3
+		expect(isValidStart('2026-13-01')).toBe(false)
+		expect(isValidStart('08/01/2026')).toBe(false)
+	})
+	it('partitionMetadataError reports the first problem, else undefined', () => {
+		expect(partitionMetadataError(spec('daily'))).toBeUndefined()
+		expect(
+			partitionMetadataError(spec('daily', { tz: 'America/New_York', start: '2026-08-01' }))
+		).toBeUndefined()
+		expect(partitionMetadataError(spec('daily', { tz: 'Not/AZone' }))).toContain('timezone')
+		expect(partitionMetadataError(spec('daily', { start: '2026-02-31' }))).toContain('start date')
+	})
+	it('bucketFor never throws on an invalid tz (falls back to UTC)', () => {
+		expect(bucketFor(spec('daily', { tz: 'Not/AZone' }), at)).toBe('2026-07-05')
+	})
+	it('an invalid start is treated as no anchor (isBeforeStart/startBucketOf)', () => {
+		expect(isBeforeStart(spec('daily', { start: '2026-02-31' }), at)).toBe(false)
+		expect(startBucketOf(spec('daily', { start: '2026-02-31' }))).toBeUndefined()
+	})
+})
+
+describe('partitionInputType', () => {
+	it('maps each calendar kind to its native input', () => {
+		expect(partitionInputType(spec('daily'))).toBe('date')
+		expect(partitionInputType(spec('hourly'))).toBe('datetime-local')
+		expect(partitionInputType(spec('weekly'))).toBe('week')
+		expect(partitionInputType(spec('monthly'))).toBe('month')
+	})
+	it('falls back to text for dynamic and custom-format specs', () => {
+		expect(partitionInputType(spec('dynamic', { key: '$.tenant' }))).toBe('text')
+		expect(partitionInputType(spec('daily', { format: '%Y/%m/%d' }))).toBe('text')
+		expect(usesCalendarPicker(spec('dynamic', { key: '$.tenant' }))).toBe(false)
+		expect(usesCalendarPicker(spec('daily', { format: '%Y/%m/%d' }))).toBe(false)
+	})
+})
+
+describe('native input <-> bucket round-trip', () => {
+	it('hourly truncates the datetime-local minutes and restores :00', () => {
+		expect(bucketFromInputValue(spec('hourly'), '2026-07-05T14:37')).toBe('2026-07-05T14')
+		expect(inputValueFromBucket(spec('hourly'), '2026-07-05T14')).toBe('2026-07-05T14:00')
+	})
+	it('non-hourly kinds pass through unchanged', () => {
+		expect(bucketFromInputValue(spec('daily'), '2026-07-05')).toBe('2026-07-05')
+		expect(inputValueFromBucket(spec('weekly'), '2026-W27')).toBe('2026-W27')
+	})
+	it('empty stays empty', () => {
+		expect(bucketFromInputValue(spec('hourly'), '')).toBe('')
+		expect(inputValueFromBucket(spec('daily'), '')).toBe('')
+	})
+})
+
+describe('recentBuckets (UTC)', () => {
+	it('walks back day by day, most recent first', () => {
+		expect(recentBuckets(spec('daily'), at, 3)).toEqual(['2026-07-05', '2026-07-04', '2026-07-03'])
+	})
+	it('walks back hour by hour', () => {
+		expect(recentBuckets(spec('hourly'), at, 3)).toEqual([
+			'2026-07-05T14',
+			'2026-07-05T13',
+			'2026-07-05T12'
+		])
+	})
+	it('walks back month by month across a year boundary without day roll-over', () => {
+		const jan31 = new Date(Date.UTC(2026, 0, 31, 0, 0, 0))
+		expect(recentBuckets(spec('monthly'), jan31, 3)).toEqual(['2026-01', '2025-12', '2025-11'])
+	})
+	it('walks back week by week', () => {
+		expect(recentBuckets(spec('weekly'), at, 3)).toEqual(['2026-W27', '2026-W26', '2026-W25'])
+	})
+})
diff --git a/frontend/src/lib/components/assets/AssetGraph/partitionBuckets.ts b/frontend/src/lib/components/assets/AssetGraph/partitionBuckets.ts
new file mode 100644
index 0000000000..401ef82cae
--- /dev/null
+++ b/frontend/src/lib/components/assets/AssetGraph/partitionBuckets.ts
@@ -0,0 +1,261 @@
+// Client-side partition-bucket math for the run form's partition picker.
+// Produces the same canonical bucket strings the backend renders in
+// `windmill-common/src/partition_ee.rs` (`resolve_time_partition` /
+// `default_format`): the instant is localized to the spec's timezone
+// (`spec.tz`, defaulting to UTC — NOT the browser's zone) and then formatted.
+// Getting the zone right matters — a browser in a non-UTC zone would otherwise
+// seed a default bucket, and compare against materialized rows, off by a
+// day/hour near every boundary and always for an explicit `tz=` spec.
+//
+//   daily   %Y-%m-%d      -> 2026-07-05
+//   hourly  %Y-%m-%dT%H   -> 2026-07-05T14
+//   weekly  %G-W%V (ISO)  -> 2026-W27
+//   monthly %Y-%m         -> 2026-07
+//
+// Pure module (no Svelte runes) so the mapping is unit-testable.
+
+import type { PartitionSpec } from './parsePipelineAnnotations'
+
+export type PartitionInputType = 'date' | 'month' | 'week' | 'datetime-local' | 'text'
+
+// A spec carrying a custom strftime `format` can't be reproduced by the native
+// date pickers (arbitrary strftime), and `dynamic` partitions are a free-form
+// key extracted from the payload — both fall back to a plain text input.
+export function usesCalendarPicker(spec: PartitionSpec): boolean {
+	return spec.kind !== 'dynamic' && !spec.format
+}
+
+export function partitionInputType(spec: PartitionSpec): PartitionInputType {
+	if (!usesCalendarPicker(spec)) return 'text'
+	switch (spec.kind) {
+		case 'monthly':
+			return 'month'
+		case 'weekly':
+			return 'week'
+		case 'hourly':
+			return 'datetime-local'
+		default:
+			return 'date'
+	}
+}
+
+function pad(n: number): string {
+	return String(n).padStart(2, '0')
+}
+
+const ZONED_PARTS_OPTS: Intl.DateTimeFormatOptions = {
+	year: 'numeric',
+	month: '2-digit',
+	day: '2-digit',
+	hour: '2-digit',
+	minute: '2-digit',
+	second: '2-digit',
+	hourCycle: 'h23'
+}
+
+// Re-express `at` as a Date whose UTC fields equal the wall-clock in `tz`, so
+// all downstream field reads / calendar arithmetic can use the UTC getters and
+// stay in the producer's zone. `hourCycle: 'h23'` keeps hours 00–23. A
+// malformed `tz` (rejected by `Intl`) falls back to UTC rather than throwing —
+// the backend validates `tz=` and is the source of truth for the error; the
+// picker must never crash the graph view (`partitionMetadataError` gates
+// auto-seeding so a bogus bucket isn't silently sent).
+function zonedAsUtc(at: Date, tz: string): Date {
+	let parts: Intl.DateTimeFormatPart[]
+	try {
+		parts = new Intl.DateTimeFormat('en-US', { ...ZONED_PARTS_OPTS, timeZone: tz }).formatToParts(
+			at
+		)
+	} catch {
+		parts = new Intl.DateTimeFormat('en-US', {
+			...ZONED_PARTS_OPTS,
+			timeZone: 'UTC'
+		}).formatToParts(at)
+	}
+	const g = (t: string) => Number(parts.find((p) => p.type === t)?.value)
+	return new Date(
+		Date.UTC(g('year'), g('month') - 1, g('day'), g('hour'), g('minute'), g('second'))
+	)
+}
+
+// `tz=` is valid iff `Intl` accepts it (absent === UTC === valid).
+export function isValidTimeZone(tz?: string): boolean {
+	if (!tz) return true
+	try {
+		new Intl.DateTimeFormat('en-US', { timeZone: tz })
+		return true
+	} catch {
+		return false
+	}
+}
+
+// `start=` is valid iff it's a real `YYYY-MM-DD` calendar date. The round-trip
+// check rejects dates JS would silently normalize (e.g. `2026-02-31` → Mar 3),
+// which the backend's `NaiveDate::parse_from_str` also rejects.
+export function isValidStart(start?: string): boolean {
+	if (!start) return true
+	const m = start.match(/^(\d{4})-(\d{2})-(\d{2})$/)
+	if (!m) return false
+	const y = Number(m[1])
+	const mo = Number(m[2])
+	const d = Number(m[3])
+	const dt = new Date(Date.UTC(y, mo - 1, d))
+	return dt.getUTCFullYear() === y && dt.getUTCMonth() === mo - 1 && dt.getUTCDate() === d
+}
+
+// A human-readable reason the `// partitioned` metadata is unusable, or
+// undefined when it's sound. Mirrors the backend's `tz=` / `start=` validation
+// so the picker can refuse to auto-seed a bucket the backend would reject.
+export function partitionMetadataError(spec: PartitionSpec): string | undefined {
+	if (!isValidTimeZone(spec.tz)) return `invalid timezone "${spec.tz}"`
+	if (!isValidStart(spec.start)) return `invalid start date "${spec.start}" (want YYYY-MM-DD)`
+	return undefined
+}
+
+// ISO 8601 week-numbering year + week (chrono's %G / %V) of a UTC-substituted
+// date. Standard "nearest Thursday" algorithm, all in UTC.
+function isoWeekOf(d: Date): { isoYear: number; week: number } {
+	const date = new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()))
+	const dayNum = (date.getUTCDay() + 6) % 7 // Mon=0 … Sun=6
+	date.setUTCDate(date.getUTCDate() - dayNum + 3) // Thursday of this week
+	const isoYear = date.getUTCFullYear()
+	const firstThursday = new Date(Date.UTC(isoYear, 0, 4))
+	const fdNum = (firstThursday.getUTCDay() + 6) % 7
+	firstThursday.setUTCDate(firstThursday.getUTCDate() - fdNum + 3)
+	const week = 1 + Math.round((date.getTime() - firstThursday.getTime()) / (7 * 86400000))
+	return { isoYear, week }
+}
+
+// Render a UTC-substituted date into its canonical bucket for the cadence.
+function fmtBucket(kind: PartitionSpec['kind'], d: Date): string {
+	const y = d.getUTCFullYear()
+	const m = d.getUTCMonth() + 1
+	const day = d.getUTCDate()
+	const h = d.getUTCHours()
+	switch (kind) {
+		case 'hourly':
+			return `${y}-${pad(m)}-${pad(day)}T${pad(h)}`
+		case 'monthly':
+			return `${y}-${pad(m)}`
+		case 'weekly': {
+			const { isoYear, week } = isoWeekOf(d)
+			return `${isoYear}-W${pad(week)}`
+		}
+		default:
+			return `${y}-${pad(m)}-${pad(day)}`
+	}
+}
+
+export function bucketFor(spec: PartitionSpec, at: Date): string {
+	return fmtBucket(spec.kind, zonedAsUtc(at, spec.tz ?? 'UTC'))
+}
+
+// The zoned start date (`spec.start`, `YYYY-MM-DD`) as a UTC-substituted Date at
+// 00:00, or undefined if unset/malformed. `start` is a plain date in the
+// producer's tz — the backend parses it as a NaiveDate and compares by date.
+function startDate(spec: PartitionSpec): Date | undefined {
+	if (!spec.start || !isValidStart(spec.start)) return undefined
+	const m = spec.start.match(/^(\d{4})-(\d{2})-(\d{2})$/)!
+	return new Date(Date.UTC(Number(m[1]), Number(m[2]) - 1, Number(m[3])))
+}
+
+// True when `at` (localized to the producer tz) falls on a date before the
+// `start=` anchor — exactly the backend's `local.date_naive() < start_date`
+// check (`resolve_time_partition`), which resolves such an instant to no
+// partition.
+export function isBeforeStart(spec: PartitionSpec, at: Date): boolean {
+	const start = startDate(spec)
+	if (!start) return false
+	const zoned = zonedAsUtc(at, spec.tz ?? 'UTC')
+	const zonedDate = Date.UTC(zoned.getUTCFullYear(), zoned.getUTCMonth(), zoned.getUTCDate())
+	return zonedDate < start.getTime()
+}
+
+// The canonical bucket of the `start=` anchor (its date at 00:00), or undefined
+// if unset. Buckets sort lexicographically within a cadence, so callers can
+// compare against it to drop pre-start buckets.
+export function startBucketOf(spec: PartitionSpec): string | undefined {
+	const start = startDate(spec)
+	return start ? fmtBucket(spec.kind, start) : undefined
+}
+
+// The bucket to pre-fill the picker with. Normally the current bucket (matching
+// the backend's "absent partition arg -> current bucket" resolution), but when
+// the current instant is before the `start=` anchor the backend would resolve
+// to NO partition — so default to the first valid bucket (the start) rather
+// than a pre-start one the worker would take verbatim and materialize early.
+export function defaultBucket(spec: PartitionSpec, at: Date): string {
+	if (isBeforeStart(spec, at)) {
+		const start = startDate(spec)
+		if (start) return fmtBucket(spec.kind, start)
+	}
+	return bucketFor(spec, at)
+}
+
+// Native input value -> canonical bucket. Only hourly differs: datetime-local
+// carries a minute component the hourly bucket drops. The picked wall-clock is
+// taken verbatim as the bucket (the user picks in the producer's frame), so no
+// timezone conversion happens here.
+export function bucketFromInputValue(spec: PartitionSpec, inputValue: string): string {
+	if (!inputValue) return ''
+	if (spec.kind === 'hourly') {
+		const m = inputValue.match(/^(\d{4}-\d{2}-\d{2}T\d{2})/)
+		return m ? m[1] : inputValue
+	}
+	return inputValue
+}
+
+// Canonical bucket -> native input value. Only hourly differs: datetime-local
+// needs a minute component the bucket omits.
+export function inputValueFromBucket(spec: PartitionSpec, bucket: string): string {
+	if (!bucket) return ''
+	if (spec.kind === 'hourly') {
+		return /T\d{2}$/.test(bucket) ? `${bucket}:00` : bucket
+	}
+	return bucket
+}
+
+// The last `count` buckets ending at (and including) `now`, most-recent first,
+// localized to `spec.tz`. Arithmetic walks calendar units in the zoned frame,
+// so it's exact across DST (no ±1 drift). Undefined for non-calendar specs
+// (the caller guards on `usesCalendarPicker`).
+export function recentBuckets(spec: PartitionSpec, now: Date, count: number): string[] {
+	const base = zonedAsUtc(now, spec.tz ?? 'UTC')
+	const out: string[] = []
+	for (let i = 0; i < count; i++) {
+		const d = new Date(base)
+		switch (spec.kind) {
+			case 'hourly':
+				d.setUTCHours(d.getUTCHours() - i)
+				break
+			case 'weekly':
+				d.setUTCDate(d.getUTCDate() - 7 * i)
+				break
+			case 'monthly':
+				// Normalize to the 1st first so subtracting months can't roll over
+				// a short target month (e.g. Mar 31 − 1mo → Mar 3).
+				d.setUTCDate(1)
+				d.setUTCMonth(d.getUTCMonth() - i)
+				break
+			default:
+				d.setUTCDate(d.getUTCDate() - i)
+		}
+		out.push(fmtBucket(spec.kind, d))
+	}
+	return out
+}
+
+// How many recent buckets the "missing partitions" hint scans, per kind — a
+// window that reads as "recent" for each cadence without flooding the hint.
+export function recentWindow(kind: PartitionSpec['kind']): number {
+	switch (kind) {
+		case 'hourly':
+			return 24
+		case 'weekly':
+			return 8
+		case 'monthly':
+			return 6
+		default:
+			return 14
+	}
+}
diff --git a/frontend/src/lib/components/assets/AssetGraph/pipelineHistory.svelte.ts b/frontend/src/lib/components/assets/AssetGraph/pipelineHistory.svelte.ts
index 50ad3e1d6e..d654085179 100644
--- a/frontend/src/lib/components/assets/AssetGraph/pipelineHistory.svelte.ts
+++ b/frontend/src/lib/components/assets/AssetGraph/pipelineHistory.svelte.ts
@@ -80,7 +80,15 @@ export function usePipelineHistory(
 						kind: j.job_kind.startsWith('flow') ? 'flow' : 'script',
 						status: j.success ? 'success' : 'failure',
 						source: j.schedule_path ? 'schedule' : 'run',
-						at: j.started_at ?? j.created_at
+						at: j.started_at ?? j.created_at,
+						// Same completion-time derivation as the live poll —
+						// the freshness chip compares against completion, and
+						// `at` (start) would read a long run as older than its
+						// output actually is.
+						completedAt:
+							j.started_at != undefined
+								? new Date(new Date(j.started_at).getTime() + j.duration_ms).toISOString()
+								: undefined
 					})
 				}
 				sawFullPage = rows.length === PER_PAGE
diff --git a/frontend/src/lib/components/assets/AssetGraph/pipelineTemplates.dataTest.test.ts b/frontend/src/lib/components/assets/AssetGraph/pipelineTemplates.dataTest.test.ts
new file mode 100644
index 0000000000..2acdf2abfb
--- /dev/null
+++ b/frontend/src/lib/components/assets/AssetGraph/pipelineTemplates.dataTest.test.ts
@@ -0,0 +1,56 @@
+import { describe, expect, it } from 'vitest'
+import {
+	autoOutputAsset,
+	compatibleOutputKinds,
+	generatePipelineDraft,
+	PIPELINE_OUTPUT_KINDS
+} from './pipelineTemplates'
+
+// The `data_test` output kind scaffolds a *custom* (singular) data test: a
+// standalone DuckDB script referenced from a materialize script's
+// `-- data_test <path>` line. It must be a single SELECT that reads the
+// freshly-materialized target through the internal `_wm_target` schema — the
+// two rules the backend's self-teaching errors enforce.
+describe('data_test scaffold', () => {
+	it('is a DuckDB-only output kind exposed in the picker', () => {
+		expect(compatibleOutputKinds('duckdb')).toContain('data_test')
+		expect(compatibleOutputKinds('python3')).not.toContain('data_test')
+		expect(PIPELINE_OUTPUT_KINDS.map((k) => k.id)).toContain('data_test')
+	})
+
+	it('produces no output asset (it asserts against an existing target)', () => {
+		expect(autoOutputAsset('data_test', 'folder', 'duckdb')).toBeUndefined()
+	})
+
+	it('scaffolds a single SELECT against `_wm_target.<table>`', () => {
+		const src = generatePipelineDraft({
+			language: 'duckdb',
+			outputKind: 'data_test',
+			triggers: []
+		})
+		// starter body is a single SELECT against the internal target alias.
+		expect(src).toContain('SELECT * FROM _wm_target.your_table WHERE your_condition;')
+		// exactly one SQL statement (single SELECT) — count statement lines, not
+		// the word "SELECT" that also appears in the guidance comment.
+		const stmtLines = src.split('\n').filter((l) => /^\s*SELECT\b/i.test(l))
+		expect(stmtLines).toHaveLength(1)
+		// no `-- materialize <uri>` output annotation — a data test declares no
+		// asset (the word still appears in the guidance comment, which is fine).
+		expect(src).not.toMatch(/^--\s*materialize\s/m)
+		// teaches how to wire it up + the offending-rows convention.
+		expect(src).toContain('-- data_test <this-script-path>')
+		expect(src).toContain('offending rows')
+	})
+
+	it('seeds the table name from an upstream ducklake asset when present', () => {
+		const src = generatePipelineDraft({
+			language: 'duckdb',
+			outputKind: 'data_test',
+			input: { kind: 'ducklake', path: 'analytics/orders' },
+			triggers: []
+		})
+		expect(src).toContain('SELECT * FROM _wm_target.orders WHERE your_condition;')
+		// no ATTACH of the input — the runtime attaches the target as `_wm_target`.
+		expect(src).not.toContain('ATTACH')
+	})
+})
diff --git a/frontend/src/lib/components/assets/AssetGraph/pipelineTemplates.test.ts b/frontend/src/lib/components/assets/AssetGraph/pipelineTemplates.test.ts
new file mode 100644
index 0000000000..262d36e6cf
--- /dev/null
+++ b/frontend/src/lib/components/assets/AssetGraph/pipelineTemplates.test.ts
@@ -0,0 +1,60 @@
+import { describe, expect, it } from 'vitest'
+import type { ScriptLang } from '$lib/gen'
+import {
+	autoOutputAsset,
+	generatePipelineDraft,
+	type PipelineOutputKind
+} from './pipelineTemplates'
+
+// The seeded draft asset (`autoOutputAsset`, stored as `outputAssets` and used
+// by resolveGraph for inactive-draft node identity) must match the asset
+// identity the deploy-time / wasm parser infers from the generated body. The
+// parser canonicalizes any S3 URI by stripping the `s3://` prefix and all
+// leading slashes (see backend `parse_asset_syntax`); if the seed carried a
+// leading slash while the body wrote `s3:///key`, the preview would render a
+// duplicate `/key` node and a phantom post-deploy drift. This pins the two in
+// lockstep so that class of drift can't regress.
+
+// Mirror of the parser's S3 canonicalization for a raw `s3://…` URI.
+function canonicalS3Key(uri: string): string {
+	const rest = uri.replace(/^s3:\/\//, '')
+	return rest.replace(/^\/+/, '')
+}
+
+const S3_KINDS: PipelineOutputKind[] = ['s3_parquet', 's3_object']
+const LANGS: ScriptLang[] = ['bun', 'python3', 'duckdb']
+
+describe('pipelineTemplates S3 seed/body parity', () => {
+	for (const language of LANGS) {
+		for (const outputKind of S3_KINDS) {
+			it(`${language} ${outputKind}: seeded asset path matches the body's S3 write URI`, () => {
+				const output = autoOutputAsset(outputKind, 'demo', language)
+				expect(output).toBeDefined()
+				const asset = output!
+
+				// The seed must be a canonical slashless key so it matches the
+				// identity the parser infers from the generated body.
+				expect(asset.kind).toBe('s3object')
+				expect(asset.path.startsWith('/')).toBe(false)
+
+				const body = generatePipelineDraft({
+					language,
+					outputKind,
+					output: asset,
+					triggers: []
+				})
+
+				// Every S3 URI the generated body emits must canonicalize back to
+				// the seeded asset path — the write target especially.
+				const uris = body.match(/s3:\/\/[^'"`)\s]+/g) ?? []
+				expect(uris.length).toBeGreaterThan(0)
+				for (const uri of uris) {
+					// Runtime form must stay triple-slash (default storage); a bare
+					// `s3://key` would target a named storage `key` at run time.
+					expect(uri.startsWith('s3:///')).toBe(true)
+					expect(canonicalS3Key(uri)).toBe(asset.path)
+				}
+			})
+		}
+	}
+})
diff --git a/frontend/src/lib/components/assets/AssetGraph/pipelineTemplates.ts b/frontend/src/lib/components/assets/AssetGraph/pipelineTemplates.ts
index 63a90ef099..04d4232dd0 100644
--- a/frontend/src/lib/components/assets/AssetGraph/pipelineTemplates.ts
+++ b/frontend/src/lib/components/assets/AssetGraph/pipelineTemplates.ts
@@ -17,6 +17,7 @@ export type PipelineOutputKind =
 	| 'datatable'
 	| 'ducklake'
 	| 'materialize'
+	| 'data_test'
 	| 's3_parquet'
 	| 's3_object'
 	| 'macros'
@@ -37,6 +38,11 @@ export const PIPELINE_OUTPUT_KINDS: PipelineOutputKindMeta[] = [
 		label: 'Materialized table',
 		description: 'Managed DuckLake table — idempotent, versioned, tracked'
 	},
+	{
+		id: 'data_test',
+		label: 'Data test',
+		description: 'Custom assertion — a single SELECT returning offending rows (empty = pass)'
+	},
 	{
 		id: 'datatable',
 		label: 'Data table',
@@ -83,7 +89,16 @@ const LANG_COMPATIBILITY: Record<ScriptLang, PipelineOutputKind[]> = {
 	// single SELECT. The Python/TS `wmll.ducklake` helper currently takes a SQL
 	// SELECT (not in-memory rows), so a polyglot managed materialize is a
 	// separate follow-up — those langs keep the `ducklake` raw-write kind.
-	duckdb: ['materialize', 'datatable', 'ducklake', 's3_parquet', 's3_object', 'macros', 'none'],
+	duckdb: [
+		'materialize',
+		'data_test',
+		'datatable',
+		'ducklake',
+		's3_parquet',
+		's3_object',
+		'macros',
+		'none'
+	],
 	postgresql: ['datatable', 'none'],
 	mysql: ['none'],
 	mssql: ['none'],
@@ -160,16 +175,16 @@ export function autoOutputAsset(
 		case 'ducklake':
 		case 'materialize':
 			return { kind: 'ducklake', path: `main/${adj}_${pick(TABLE_NOUNS)}_${slug}` }
-		// s3 paths carry the canonical leading slash of a default-storage
-		// object (`s3:///<key>` parses to path `/<key>`). The deploy-time
-		// parser stores writes in that form — a slashless seeded path would
-		// never match it, and the post-deploy drift check would report the
-		// output as lost (it isn't; the key differs by one '/'). Bodies that
-		// take a bare key (`{ s3: ... }`) strip the slash via `s3Key`.
+		// s3 outputs use the canonical slashless key. `parse_asset_syntax`
+		// normalizes `s3:///<key>` (default storage) and `s3://<key>` to the
+		// bare `<key>`, so the seeded draft asset must be slashless to match the
+		// deploy-time inferred identity — otherwise the post-deploy drift check
+		// would flag the output as a phantom `/`-prefixed node. The generated
+		// bodies still emit the `s3:///<key>` default-storage URI for runtime I/O.
 		case 's3_parquet':
 			return {
 				kind: 's3object',
-				path: `/pipelines/${folder}/${adj}_${pick(DATASET_NOUNS)}_${slug}.parquet`
+				path: `pipelines/${folder}/${adj}_${pick(DATASET_NOUNS)}_${slug}.parquet`
 			}
 		case 's3_object': {
 			// duckdb's natural output for a generic blob is CSV (one COPY TO
@@ -179,12 +194,14 @@ export function autoOutputAsset(
 			const ext = language === 'duckdb' ? 'csv' : 'json'
 			return {
 				kind: 's3object',
-				path: `/pipelines/${folder}/${adj}_${pick(FILE_NOUNS)}_${slug}.${ext}`
+				path: `pipelines/${folder}/${adj}_${pick(FILE_NOUNS)}_${slug}.${ext}`
 			}
 		}
 		// A macro library produces no asset — its "output" is the registry
-		// entries the deploy records.
+		// entries the deploy records. A custom data test produces no asset
+		// either — it asserts against an existing materialized target.
 		case 'macros':
+		case 'data_test':
 		case 'none':
 			return undefined
 	}
@@ -205,10 +222,11 @@ export function assetUri(asset: { kind: AssetKind; path: string }): string {
 	return `${ASSET_URI_PREFIX[asset.kind]}${asset.path}`
 }
 
-// Bare object key for the SDK's `{ s3: <key> }` forms: the canonical asset
-// path of a default-storage object has a leading slash, the key must not.
+// Bare object key for the SDK's `{ s3: <key> }` / `s3:///<key>` forms. Asset
+// paths are already canonical slashless keys; strip stray leading slashes
+// defensively so the emitted key never starts with '/'.
 function s3Key(path: string): string {
-	return path.replace(/^\//, '')
+	return path.replace(/^\/+/, '')
 }
 
 // Splits a datatable asset path (`<db>/<table>` or `<db>/<schema>.<table>`)
@@ -316,6 +334,17 @@ export type TemplateContext = {
 function header(ctx: TemplateContext): string {
 	const { language, triggers, output, outputKind } = ctx
 	const p = commentPrefix(language)
+	// A custom data test is a standalone script, not a graph node that produces
+	// an asset — so it gets no `// pipeline` / output annotation. Instead, tell
+	// the author how to wire it up (the `data_test` reference) and the two rules
+	// that aren't obvious: single SELECT, returning the offending rows.
+	if (outputKind === 'data_test') {
+		return [
+			`${p} Custom data test — reference it from a materialize script with \`${p} data_test <this-script-path>\`.`,
+			`${p} It must be a single SELECT returning the offending rows; the run fails if any row comes back.`,
+			''
+		].join('\n')
+	}
 	const lines = triggers.map((t) => {
 		switch (t.kind) {
 			case 'asset':
@@ -391,8 +420,11 @@ function bodyTs(ctx: TemplateContext): string {
 		if (!input) return ''
 		switch (input.kind) {
 			case 's3object':
+				// `s3:///<key>` URI — one spelling shared with the `// on
+				// s3:///…` annotation form (the object literal `{ s3: <key> }`
+				// is equivalent).
 				return [
-					`  const buf = await wmill.loadS3File({ s3: ${JSON.stringify(s3Key(input.path))} })`,
+					`  const buf = await wmill.loadS3File(${JSON.stringify(`s3:///${s3Key(input.path)}`)})`,
 					`  const rows = JSON.parse(new TextDecoder().decode(buf))`,
 					``
 				].join('\n')
@@ -418,9 +450,10 @@ function bodyTs(ctx: TemplateContext): string {
 		switch (outputKind) {
 			case 's3_parquet':
 			case 's3_object':
+				// `s3:///<key>` URI — see the loadS3File note above.
 				return [
 					`  const payload = new TextEncoder().encode(JSON.stringify(rows))`,
-					`  await wmill.writeS3File({ s3: ${JSON.stringify(s3Key(output.path))} }, payload)`
+					`  await wmill.writeS3File(${JSON.stringify(`s3:///${s3Key(output.path)}`)}, payload)`
 				].join('\n')
 			case 'datatable': {
 				const dbName = output.path.split('/')[0] ?? 'main'
@@ -474,8 +507,11 @@ function bodyPython(ctx: TemplateContext): string {
 		if (!input) return ''
 		switch (input.kind) {
 			case 's3object':
+				// `s3:///<key>` URI — SDK string params must be s3:// URIs
+				// (bare keys are rejected), and this form matches the
+				// `# on s3:///…` annotation spelling.
 				return [
-					`    buf = wmill.load_s3_file(${JSON.stringify(s3Key(input.path))})`,
+					`    buf = wmill.load_s3_file(${JSON.stringify(`s3:///${s3Key(input.path)}`)})`,
 					`    import json; rows = json.loads(buf.decode("utf-8"))`
 				].join('\n')
 			case 'datatable':
@@ -498,9 +534,10 @@ function bodyPython(ctx: TemplateContext): string {
 		switch (outputKind) {
 			case 's3_parquet':
 			case 's3_object':
+				// `s3:///<key>` URI — see the load_s3_file note above.
 				return [
 					`    import json`,
-					`    wmill.write_s3_file(${JSON.stringify(s3Key(output.path))}, json.dumps(rows).encode("utf-8"))`
+					`    wmill.write_s3_file(${JSON.stringify(`s3:///${s3Key(output.path)}`)}, json.dumps(rows).encode("utf-8"))`
 				].join('\n')
 			case 'datatable': {
 				const dbName = output.path.split('/')[0] ?? 'main'
@@ -536,6 +573,22 @@ function bodyPython(ctx: TemplateContext): string {
 function bodyDuckdb(ctx: TemplateContext): string {
 	const { input, output, outputKind } = ctx
 	const dataUpload = isDataUpload(ctx.triggers)
+	if (outputKind === 'data_test') {
+		// Standalone custom data test: it reads ONLY the freshly-materialized
+		// target, which the runtime attaches under the internal `_wm_target`
+		// schema — so it emits no ATTACH / input load of its own. When the test
+		// was created off a ducklake asset, seed its table name; otherwise a
+		// clear placeholder. This exact shape (single SELECT vs `_wm_target`) is
+		// what the backend's self-teaching errors ask for.
+		const testTable = input?.kind === 'ducklake' ? catalogTableRef(input.path) : 'your_table'
+		return [
+			'',
+			`-- Return the rows that VIOLATE your assertion; an empty result means the test passes.`,
+			`-- \`_wm_target\` is the freshly-materialized target, attached by the runtime.`,
+			`SELECT * FROM _wm_target.${testTable} WHERE your_condition;`,
+			''
+		].join('\n')
+	}
 	const lines: string[] = []
 	if (dataUpload) {
 		// `(s3object)` param declaration → the run form renders the S3 picker
@@ -584,7 +637,7 @@ function bodyDuckdb(ctx: TemplateContext): string {
 		if (!input) return null
 		switch (input.kind) {
 			case 's3object':
-				return `read_parquet('s3://${input.path}')`
+				return `read_parquet('s3:///${input.path}')`
 			case 'datatable':
 				// `pg` is the attached Postgres catalog (see ATTACH above).
 				// Use a 2-part `pg.<table>` ref so the asset parser maps it
@@ -607,7 +660,7 @@ function bodyDuckdb(ctx: TemplateContext): string {
 					`COPY (`,
 					`  SELECT *`,
 					`  FROM ${fromExpr}`,
-					`) TO 's3://${output.path}' (FORMAT 'parquet');`
+					`) TO 's3:///${output.path}' (FORMAT 'parquet');`
 				)
 			}
 			break
@@ -618,7 +671,7 @@ function bodyDuckdb(ctx: TemplateContext): string {
 					`COPY (`,
 					`  SELECT *`,
 					`  FROM ${fromExpr}`,
-					`) TO 's3://${output.path}' (FORMAT 'csv', HEADER);`
+					`) TO 's3:///${output.path}' (FORMAT 'csv', HEADER);`
 				)
 			}
 			break
diff --git a/frontend/src/lib/components/assets/AssetGraph/resolveGraph.test.ts b/frontend/src/lib/components/assets/AssetGraph/resolveGraph.test.ts
index 3c98d57602..2216d37b0f 100644
--- a/frontend/src/lib/components/assets/AssetGraph/resolveGraph.test.ts
+++ b/frontend/src/lib/components/assets/AssetGraph/resolveGraph.test.ts
@@ -99,6 +99,50 @@ describe('resolveGraph', () => {
 		})
 	})
 
+	it('scd2 materialize draft: writes both the base dim and its _current companion view', () => {
+		const drafts = new Map([
+			[
+				'f/x/dim',
+				{
+					script: {
+						content: '-- materialize ducklake://main/dim_customers key=id history\nselect 1'
+					}
+				}
+			]
+		])
+		const r = resolveGraph(input({ drafts }))
+		// Base dimension: a plain write output node.
+		expect(r.assets).toContainEqual({ kind: 'ducklake', path: 'main/dim_customers' })
+		// Companion `_current` view: same producer, marked derived from the base.
+		expect(r.assets).toContainEqual({
+			kind: 'ducklake',
+			path: 'main/dim_customers_current',
+			derived_from: 'main/dim_customers'
+		})
+		for (const path of ['main/dim_customers', 'main/dim_customers_current']) {
+			expect(r.edges).toContainEqual({
+				runnable_path: 'f/x/dim',
+				runnable_kind: 'script',
+				asset_kind: 'ducklake',
+				asset_path: path,
+				access_type: 'w',
+				unsaved: true
+			})
+		}
+	})
+
+	it('non-scd2 materialize draft: writes only the base dim, no _current companion', () => {
+		const drafts = new Map([
+			[
+				'f/x/dim',
+				{ script: { content: '-- materialize ducklake://main/dim_customers key=id\nselect 1' } }
+			]
+		])
+		const r = resolveGraph(input({ drafts }))
+		expect(r.assets).toContainEqual({ kind: 'ducklake', path: 'main/dim_customers' })
+		expect(r.assets.some((a) => a.path === 'main/dim_customers_current')).toBe(false)
+	})
+
 	it('active draft: live body writes are authoritative over the snapshot', () => {
 		const drafts = new Map([
 			[
@@ -341,6 +385,55 @@ describe('resolveGraph', () => {
 		expect(r.edges.some((e) => e.asset_path === 'main/out' && e.access_type === 'w')).toBe(true)
 	})
 
+	it('editing a saved scd2 producer keeps both the base and _current persisted write edges', () => {
+		// Deploy persists a write to both `main/dim` and `main/dim_current`.
+		// Opening the producer for editing must not judge the companion `_current`
+		// write stale — otherwise a consumer of only the view orphans mid-edit.
+		const base = baseGraph({
+			runnables: [{ path: 'f/x/dim', usage_kind: 'script' }],
+			edges: [
+				{
+					runnable_path: 'f/x/dim',
+					runnable_kind: 'script',
+					asset_kind: 'ducklake',
+					asset_path: 'main/dim_customers',
+					access_type: 'w'
+				},
+				{
+					runnable_path: 'f/x/dim',
+					runnable_kind: 'script',
+					asset_kind: 'ducklake',
+					asset_path: 'main/dim_customers_current',
+					access_type: 'w'
+				}
+			]
+		})
+		const r = resolveGraph(
+			input({
+				base,
+				liveAnnotations: {
+					scriptPath: 'f/x/dim',
+					annotations: ann({
+						materialize: {
+							targetKind: 'ducklake',
+							targetPath: 'main/dim_customers',
+							uniqueKey: 'id',
+							scd2: true
+						}
+					})
+				},
+				liveBodyAssets: { scriptPath: 'f/x/dim', assets: [] }
+			})
+		)
+		for (const path of ['main/dim_customers', 'main/dim_customers_current']) {
+			expect(
+				r.edges.some(
+					(e) => e.runnable_path === 'f/x/dim' && e.asset_path === path && e.access_type === 'w'
+				)
+			).toBe(true)
+		}
+	})
+
 	it('selecting a saved script unchanged drops nothing (no stale removal)', () => {
 		const base = baseGraph({
 			runnables: [{ path: 'f/x/prod', usage_kind: 'script' }],
diff --git a/frontend/src/lib/components/assets/AssetGraph/resolveGraph.ts b/frontend/src/lib/components/assets/AssetGraph/resolveGraph.ts
index 849849c555..328535ef87 100644
--- a/frontend/src/lib/components/assets/AssetGraph/resolveGraph.ts
+++ b/frontend/src/lib/components/assets/AssetGraph/resolveGraph.ts
@@ -2,6 +2,7 @@ import type { AssetGraphMacroEdge, AssetGraphResponse, NativeTriggerKind } from
 import {
 	mergeColumnLineage,
 	parsePipelineAnnotations,
+	scd2CurrentTargetPath,
 	type ColumnLineage,
 	type PipelineAnnotations
 } from './parsePipelineAnnotations'
@@ -265,9 +266,16 @@ function makeContext(input: ResolveGraphInput): ResolveContext {
 			// lives in an annotation (not the SQL body), so neither triggerAssets
 			// (inputs) nor the body-inferred assets cover it. Without this its
 			// persisted write-edge is judged stale and dropped the moment the
-			// script is selected/edited — leaving the output asset unlinked.
+			// script is selected/edited — leaving the output asset unlinked. A
+			// managed scd2 producer persists a second write to the `<dim>_current`
+			// companion view, so keep that too or a consumer of only the view
+			// orphans while the producer is open for editing.
 			const m = liveAnnotations.annotations.materialize
-			if (m) liveRefKeys.add(`${m.targetKind}:${m.targetPath}`)
+			if (m) {
+				liveRefKeys.add(`${m.targetKind}:${m.targetPath}`)
+				const currentPath = scd2CurrentTargetPath(m)
+				if (currentPath) liveRefKeys.add(`${m.targetKind}:${currentPath}`)
+			}
 		}
 		for (const a of liveBodyAssets.assets) liveRefKeys.add(`${a.kind}:${a.path}`)
 	}
@@ -373,7 +381,7 @@ function seedDraftOverlays(acc: Accumulator, input: ResolveGraphInput) {
 		//      creation/last edit, or the seeded output for a fresh draft
 		//      whose body doesn't yet write anything inferable).
 		const liveForThisDraft = liveBodyAssets.scriptPath === path
-		const writeOuts: Array<{ kind: AssetKind; path: string }> = []
+		const writeOuts: Array<{ kind: AssetKind; path: string; derivedFrom?: string }> = []
 		if (liveForThisDraft) {
 			writeOuts.push(...extractWrites(liveBodyAssets.assets))
 		} else if (d.outputAssets) {
@@ -382,16 +390,35 @@ function seedDraftOverlays(acc: Accumulator, input: ResolveGraphInput) {
 		// `// materialize <asset>` declares a write output via annotation, not
 		// the SQL body, so the body-inference tiers above miss it. Add it from
 		// the live-parsed annotations so an edited materialize script keeps its
-		// output edge (the loop below dedups against existing assets/edges).
+		// output edge (the loop below dedups against existing assets/edges). A
+		// managed scd2 materialize also produces the `<dim>_current` companion
+		// view — add it too (mirrors the deploy path) so a draft consuming only
+		// the view links back to this producer instead of orphaning.
 		if (parsed.materialize) {
 			writeOuts.push({
 				kind: parsed.materialize.targetKind,
 				path: parsed.materialize.targetPath
 			})
+			const currentPath = scd2CurrentTargetPath(parsed.materialize)
+			if (currentPath) {
+				writeOuts.push({
+					kind: parsed.materialize.targetKind,
+					path: currentPath,
+					derivedFrom: parsed.materialize.targetPath
+				})
+			}
 		}
 		for (const out of writeOuts) {
-			const hasAsset = assets.some((a) => a.kind === out.kind && a.path === out.path)
-			if (!hasAsset) assets.push({ kind: out.kind, path: out.path })
+			const existing = assets.find((a) => a.kind === out.kind && a.path === out.path)
+			if (!existing) {
+				assets.push({
+					kind: out.kind,
+					path: out.path,
+					...(out.derivedFrom ? { derived_from: out.derivedFrom } : {})
+				})
+			} else if (out.derivedFrom && existing.derived_from == undefined) {
+				existing.derived_from = out.derivedFrom
+			}
 			// Dedup against edges already in the overlay (this draft's base
 			// edges were dropped above, so this only guards against duplicate
 			// writeOuts entries — not against the persisted version).
diff --git a/frontend/src/lib/components/assets/AssetGraph/schemaContracts.test.ts b/frontend/src/lib/components/assets/AssetGraph/schemaContracts.test.ts
new file mode 100644
index 0000000000..9247b23d9b
--- /dev/null
+++ b/frontend/src/lib/components/assets/AssetGraph/schemaContracts.test.ts
@@ -0,0 +1,276 @@
+import { describe, expect, it } from 'vitest'
+import {
+	buildSchemaContractContext,
+	diffSchemaContracts,
+	mapWarningsToMarkers,
+	normalizeAssetPath,
+	referencedDucklakePaths,
+	type CapturedSchemaLite
+} from './schemaContracts'
+import { parsePipelineAnnotations } from './parsePipelineAnnotations'
+import type { AssetWithAltAccessType } from '../lib'
+
+// Mirrors backend/windmill-common/src/schema_contracts.rs unit tests — the two
+// diffs must apply the same rules or the editor previews a different verdict
+// than the save-time check returns.
+
+function schema(cols: [string, string][], version = 2): CapturedSchemaLite {
+	return {
+		columns: cols.map(([name, type]) => ({ name, type })),
+		version,
+		capturedAt: '2026-01-01T00:00:00Z'
+	}
+}
+
+function readAsset(path: string, cols: string[]): AssetWithAltAccessType {
+	return {
+		path,
+		kind: 'ducklake',
+		access_type: 'r',
+		columns: Object.fromEntries(cols.map((c) => [c, 'r' as const]))
+	}
+}
+
+const NO_ANN = { columnLineage: [], dataTests: [] }
+
+describe('diffSchemaContracts', () => {
+	it('warns on a missing read column, matching case-insensitively', () => {
+		const schemas = new Map([
+			[
+				'lake/orders',
+				schema([
+					['Order_ID', 'BIGINT'],
+					['amount_usd', 'DOUBLE']
+				])
+			]
+		])
+		const w = diffSchemaContracts({
+			...NO_ANN,
+			assets: [readAsset('lake/orders', ['order_id', 'amount'])],
+			schemas,
+			ignored: new Set()
+		})
+		expect(w).toHaveLength(1)
+		expect(w[0].kind).toBe('missing_column')
+		expect(w[0].column).toBe('amount')
+		expect(w[0].schema_version).toBe(2)
+	})
+
+	it('skips unknown-column assets, "*" and reserved columns', () => {
+		const schemas = new Map([['lake/orders', schema([['id', 'BIGINT']])]])
+		const noColumns: AssetWithAltAccessType = {
+			path: 'lake/orders',
+			kind: 'ducklake',
+			access_type: 'r'
+		}
+		expect(
+			diffSchemaContracts({ ...NO_ANN, assets: [noColumns], schemas, ignored: new Set() })
+		).toEqual([])
+		expect(
+			diffSchemaContracts({
+				...NO_ANN,
+				assets: [readAsset('lake/orders', ['*', '_wm_partition', 'id'])],
+				schemas,
+				ignored: new Set()
+			})
+		).toEqual([])
+	})
+
+	it('is silent for assets without a captured schema', () => {
+		expect(
+			diffSchemaContracts({
+				...NO_ANN,
+				assets: [readAsset('lake/unknown', ['whatever'])],
+				schemas: new Map(),
+				ignored: new Set()
+			})
+		).toEqual([])
+	})
+
+	it('normalizes the {partition} token before lookup', () => {
+		const schemas = new Map([['lake/orders', schema([['id', 'BIGINT']])]])
+		const w = diffSchemaContracts({
+			...NO_ANN,
+			assets: [readAsset('lake/orders/{partition}', ['gone'])],
+			schemas,
+			ignored: new Set()
+		})
+		expect(w).toHaveLength(1)
+		expect(w[0].asset_path).toBe('lake/orders')
+	})
+
+	it('warns on broken // column lineage refs', () => {
+		const ann = parsePipelineAnnotations(
+			'// column total <- ducklake://lake/orders.amount\nSELECT 1;'
+		)
+		const schemas = new Map([['lake/orders', schema([['id', 'BIGINT']])]])
+		const w = diffSchemaContracts({
+			assets: [],
+			columnLineage: ann.columnLineage,
+			dataTests: [],
+			schemas,
+			ignored: new Set()
+		})
+		expect(w).toHaveLength(1)
+		expect(w[0].kind).toBe('missing_lineage_source')
+	})
+
+	it('flags missing relationship columns and captured-type differences', () => {
+		const ann = parsePipelineAnnotations(
+			'// materialize ducklake://lake/orders\n' +
+				'// data_test relationships customer_id -> ducklake://lake/customers.id\n' +
+				'// data_test relationships customer_id -> ducklake://lake/customers.uuid\n' +
+				'SELECT 1;'
+		)
+		const schemas = new Map([
+			['lake/customers', schema([['id', 'VARCHAR']])],
+			['lake/orders', schema([['customer_id', 'BIGINT']])]
+		])
+		const w = diffSchemaContracts({
+			assets: [],
+			columnLineage: ann.columnLineage,
+			dataTests: ann.dataTests,
+			materialize: ann.materialize,
+			schemas,
+			ignored: new Set()
+		})
+		expect(w).toHaveLength(2)
+		expect(
+			w.some(
+				(x) =>
+					x.kind === 'relationship_type_mismatch' &&
+					x.expected_type === 'BIGINT' &&
+					x.found_type === 'VARCHAR'
+			)
+		).toBe(true)
+		expect(w.some((x) => x.kind === 'missing_relationship_column' && x.column === 'uuid')).toBe(
+			true
+		)
+	})
+
+	it('suppresses ignored assets down to one informational note', () => {
+		const schemas = new Map([['lake/orders', schema([['id', 'BIGINT']])]])
+		const ignored = new Set(['lake/orders'])
+		const w = diffSchemaContracts({
+			...NO_ANN,
+			assets: [readAsset('lake/orders', ['a', 'b'])],
+			schemas,
+			ignored
+		})
+		expect(w).toHaveLength(1)
+		expect(w[0].kind).toBe('suppressed')
+		expect(
+			diffSchemaContracts({
+				...NO_ANN,
+				assets: [readAsset('lake/orders', ['id'])],
+				schemas,
+				ignored
+			})
+		).toEqual([])
+	})
+})
+
+describe('referencedDucklakePaths', () => {
+	it('collects paths from reads, lineage, relationships and materialize', () => {
+		const ann = parsePipelineAnnotations(
+			'// materialize ducklake://lake/out\n' +
+				'// column total <- ducklake://lake/a.amount\n' +
+				'// data_test relationships k -> ducklake://lake/b.id\n' +
+				'SELECT 1;'
+		)
+		const refs = referencedDucklakePaths({
+			assets: [readAsset('lake/c/{partition}', ['x'])],
+			columnLineage: ann.columnLineage,
+			dataTests: ann.dataTests,
+			materialize: ann.materialize
+		})
+		expect(refs.sort()).toEqual(['lake/a', 'lake/b', 'lake/c', 'lake/out'])
+	})
+})
+
+describe('buildSchemaContractContext', () => {
+	it('derives ignored assets and scd2 _current bases from graph runnables', () => {
+		const ctx = buildSchemaContractContext([
+			{
+				materialize_target: { kind: 'ducklake', path: 'lake/dim' },
+				materialize_strategy: 'scd2',
+				materialize_on_schema_change: 'ignore'
+			},
+			{
+				materialize_target: { kind: 'ducklake', path: 'lake/orders' },
+				materialize_strategy: 'replace'
+			},
+			// non-ducklake and absent targets are ignored
+			{ materialize_target: { kind: 's3object', path: 'x/y' }, materialize_strategy: 'scd2' },
+			{}
+		])
+		expect(ctx.ignoredAssets).toEqual(['lake/dim', 'lake/dim_current'])
+		expect(ctx.scd2CurrentBases).toEqual({ 'lake/dim_current': 'lake/dim' })
+	})
+
+	it('ignores _current only for scd2 producers (backend spec.scd2 gate)', () => {
+		const ctx = buildSchemaContractContext([
+			{
+				materialize_target: { kind: 'ducklake', path: 'lake/t' },
+				materialize_strategy: 'replace',
+				materialize_on_schema_change: 'ignore'
+			}
+		])
+		// a non-scd2 producer's `<base>_current` is an unrelated asset — it must
+		// keep warning, exactly like the server-side check
+		expect(ctx.ignoredAssets).toEqual(['lake/t'])
+		expect(ctx.scd2CurrentBases).toEqual({})
+	})
+})
+
+describe('mapWarningsToMarkers', () => {
+	it('anchors annotation warnings to their lines and body reads to the identifier', () => {
+		const code =
+			'-- pipeline\n' +
+			'-- on ducklake://lake/orders\n' +
+			'-- column total <- ducklake://lake/orders.amount\n' +
+			'-- data_test relationships k -> ducklake://lake/customers.uuid\n' +
+			'SELECT amount FROM dl.orders;'
+		const markers = mapWarningsToMarkers(code, [
+			{
+				kind: 'missing_lineage_source',
+				asset_path: 'lake/orders',
+				column: 'amount',
+				message: 'm1'
+			},
+			{
+				kind: 'missing_relationship_column',
+				asset_path: 'lake/customers',
+				column: 'uuid',
+				message: 'm2'
+			},
+			{ kind: 'missing_column', asset_path: 'lake/orders', column: 'amount', message: 'm3' },
+			{ kind: 'suppressed', asset_path: 'lake/orders', message: 'hidden' }
+		])
+		expect(markers).toHaveLength(3)
+		expect(markers[0].startLineNumber).toBe(3)
+		expect(markers[1].startLineNumber).toBe(4)
+		// body-read warning anchors to the first occurrence of the identifier,
+		// which is the annotation line mentioning `amount` (line 3)
+		expect(markers[2].startLineNumber).toBe(3)
+		// token range is tight around the identifier, not the whole line
+		const line3 = '-- column total <- ducklake://lake/orders.amount'
+		expect(markers[2].startColumn).toBe(line3.indexOf('amount') + 1)
+	})
+
+	it('falls back to the line mentioning the asset path', () => {
+		const code = '# pipeline\n# on ducklake://lake/orders\nprint(1)'
+		const markers = mapWarningsToMarkers(code, [
+			{ kind: 'missing_column', asset_path: 'lake/orders', column: 'zzz', message: 'm' }
+		])
+		expect(markers[0].startLineNumber).toBe(2)
+	})
+})
+
+describe('normalizeAssetPath', () => {
+	it('strips the partition token and trailing slashes', () => {
+		expect(normalizeAssetPath('lake/orders/{partition}')).toBe('lake/orders')
+		expect(normalizeAssetPath('lake/orders_{partition}')).toBe('lake/orders_')
+		expect(normalizeAssetPath('lake/orders/')).toBe('lake/orders')
+	})
+})
diff --git a/frontend/src/lib/components/assets/AssetGraph/schemaContracts.ts b/frontend/src/lib/components/assets/AssetGraph/schemaContracts.ts
new file mode 100644
index 0000000000..4a1de04e13
--- /dev/null
+++ b/frontend/src/lib/components/assets/AssetGraph/schemaContracts.ts
@@ -0,0 +1,440 @@
+// Client-side mirror of the save-time schema-contract check (pipelines gap
+// #2b, backend/windmill-common/src/schema_contracts.rs). The backend endpoint
+// (`checkSchemaContracts`) is the authoritative check run on save; this mirror
+// drives the *live* editor surface (Monaco warning markers + completions) from
+// the WASM parse that already runs on the open buffer, so the two must apply
+// the same rules: ducklake-only, case-insensitive column names, `columns`
+// absent ⇒ skip, `_wm_partition` whitelisted, `{partition}` token stripped,
+// annotation-declared lineage only, asset without captured schema ⇒ silent.
+
+import { AssetService, ScriptService, type ContractWarning, type ScriptLang } from '$lib/gen'
+import { sendUserToast } from '$lib/toast'
+import type { AssetWithAltAccessType } from '../lib'
+import {
+	parsePipelineAnnotations,
+	type ColumnLineage,
+	type DataTest,
+	type MaterializeSpec
+} from './parsePipelineAnnotations'
+
+// Columns the materialize engine manages; excluded from the captured schema on
+// purpose, so reads of them must not warn.
+const RESERVED_COLUMNS = ['_wm_partition']
+
+const PARTITION_TOKEN = '{partition}'
+
+export type CapturedSchemaLite = {
+	columns: { name: string; type: string }[]
+	version: number
+	capturedAt: string
+}
+
+// Strip the `{partition}` token a declared URI may carry so lookups hit the
+// captured path (mirrors `normalize_asset_path`).
+export function normalizeAssetPath(path: string): string {
+	return path
+		.replaceAll('/' + PARTITION_TOKEN, '')
+		.replaceAll(PARTITION_TOKEN, '')
+		.replace(/\/+$/, '')
+}
+
+function isReserved(name: string): boolean {
+	return RESERVED_COLUMNS.some((r) => r.toLowerCase() === name.toLowerCase())
+}
+
+function findColumn(
+	schema: CapturedSchemaLite,
+	name: string
+): { name: string; type: string } | undefined {
+	const lower = name.toLowerCase()
+	return schema.columns.find((c) => c.name.toLowerCase() === lower)
+}
+
+export type SchemaContractInputs = {
+	// Per-asset column reads/writes from the WASM parse (entries without a
+	// `columns` map are skipped — wildcard/unknown access).
+	assets: AssetWithAltAccessType[]
+	// Annotation-declared `// column` lineage ONLY (not merged AST-inferred
+	// lineage — redundant with body reads and alias-attribution can misfire).
+	columnLineage: ColumnLineage[]
+	dataTests: DataTest[]
+	materialize?: MaterializeSpec
+	// Latest captured schema per normalized ducklake path (after any
+	// `_current` → base-table fallback the caller resolved).
+	schemas: Map<string, CapturedSchemaLite>
+	// Normalized paths whose producer declares `on_schema_change=ignore`.
+	ignored: Set<string>
+}
+
+// Mirrors backend `diff_contract` — same warning kinds and suppression
+// semantics, minus the human message wording (the editor renders its own).
+export function diffSchemaContracts(input: SchemaContractInputs): ContractWarning[] {
+	const { assets, columnLineage, dataTests, materialize, schemas, ignored } = input
+	const warnings: ContractWarning[] = []
+
+	// W1 — body-read/written columns missing from the captured schema.
+	for (const a of assets) {
+		if (a.kind !== 'ducklake' || a.columns == undefined) continue
+		const path = normalizeAssetPath(a.path)
+		const schema = schemas.get(path)
+		if (!schema) continue
+		for (const col of Object.keys(a.columns)) {
+			if (col === '*' || isReserved(col)) continue
+			if (!findColumn(schema, col)) {
+				warnings.push({
+					kind: 'missing_column',
+					asset_path: path,
+					column: col,
+					schema_version: schema.version,
+					captured_at: schema.capturedAt,
+					message: `column \`${col}\` of ducklake://${path} is not in its captured schema (v${schema.version}, columns: ${schema.columns.map((c) => c.name).join(', ')})`
+				})
+			}
+		}
+	}
+
+	// W2 — `// column` lineage source refs.
+	for (const cl of columnLineage) {
+		for (const input of cl.inputs) {
+			if (input.from_kind !== 'ducklake' || isReserved(input.from_column)) continue
+			const path = normalizeAssetPath(input.from_path)
+			const schema = schemas.get(path)
+			if (!schema) continue
+			if (!findColumn(schema, input.from_column)) {
+				warnings.push({
+					kind: 'missing_lineage_source',
+					asset_path: path,
+					column: input.from_column,
+					schema_version: schema.version,
+					captured_at: schema.capturedAt,
+					message: `\`// column ${cl.column}\` reads \`${input.from_column}\` from ducklake://${path}, which is not in its captured schema (v${schema.version})`
+				})
+			}
+		}
+	}
+
+	// W3 — relationships refs: missing column, and captured-type difference
+	// when the consumer's own materialize target has a capture. Types still
+	// coerce at run time, so a difference is "differs", never "will fail".
+	const ownSchema =
+		materialize?.targetKind === 'ducklake'
+			? schemas.get(normalizeAssetPath(materialize.targetPath))
+			: undefined
+	for (const dt of dataTests) {
+		if (dt.type !== 'relationships' || dt.to_kind !== 'ducklake') continue
+		const path = normalizeAssetPath(dt.to_path)
+		const schema = schemas.get(path)
+		if (!schema) continue
+		const refCol = findColumn(schema, dt.to_column)
+		if (!refCol) {
+			warnings.push({
+				kind: 'missing_relationship_column',
+				asset_path: path,
+				column: dt.to_column,
+				schema_version: schema.version,
+				captured_at: schema.capturedAt,
+				message: `\`// data_test relationships ${dt.column}\` references ducklake://${path}.${dt.to_column}, which is not in its captured schema (v${schema.version})`
+			})
+		} else {
+			const ownCol = ownSchema && findColumn(ownSchema, dt.column)
+			if (ownCol && ownCol.type.toLowerCase() !== refCol.type.toLowerCase()) {
+				warnings.push({
+					kind: 'relationship_type_mismatch',
+					asset_path: path,
+					column: dt.to_column,
+					expected_type: ownCol.type,
+					found_type: refCol.type,
+					schema_version: schema.version,
+					captured_at: schema.capturedAt,
+					message: `\`// data_test relationships ${dt.column}\` joins \`${dt.column}\` (${ownCol.type}) to ducklake://${path}.${dt.to_column} (${refCol.type}) — captured types differ`
+				})
+			}
+		}
+	}
+
+	// W4 — producer `on_schema_change=ignore`: drop the asset's warnings,
+	// leaving one informational entry per suppressed asset.
+	if (ignored.size > 0) {
+		const suppressed: string[] = []
+		const kept = warnings.filter((w) => {
+			if (ignored.has(w.asset_path)) {
+				if (!suppressed.includes(w.asset_path)) suppressed.push(w.asset_path)
+				return false
+			}
+			return true
+		})
+		warnings.length = 0
+		warnings.push(...kept)
+		for (const path of suppressed) {
+			warnings.push({
+				kind: 'suppressed',
+				asset_path: path,
+				message: `schema mismatches on ducklake://${path} suppressed by its producer's \`on_schema_change=ignore\``
+			})
+		}
+	}
+
+	return warnings
+}
+
+// The ducklake paths a buffer references in ways the contract check inspects —
+// what the editor needs captured schemas for.
+export function referencedDucklakePaths(
+	input: Pick<SchemaContractInputs, 'assets' | 'columnLineage' | 'dataTests' | 'materialize'>
+): string[] {
+	const paths = new Set<string>()
+	for (const a of input.assets) {
+		if (a.kind === 'ducklake' && a.columns != undefined) paths.add(normalizeAssetPath(a.path))
+	}
+	for (const cl of input.columnLineage) {
+		for (const i of cl.inputs) {
+			if (i.from_kind === 'ducklake') paths.add(normalizeAssetPath(i.from_path))
+		}
+	}
+	for (const dt of input.dataTests) {
+		if (dt.type === 'relationships' && dt.to_kind === 'ducklake')
+			paths.add(normalizeAssetPath(dt.to_path))
+	}
+	if (input.materialize?.targetKind === 'ducklake')
+		paths.add(normalizeAssetPath(input.materialize.targetPath))
+	return [...paths]
+}
+
+// --- Captured-schema cache ------------------------------------------------
+
+// Short-TTL cache so per-keystroke recomputes and completion requests don't
+// re-fetch. Captured schemas only change when a producer materializes, so a
+// briefly stale hit is fine — the authoritative save-time check re-reads.
+const SCHEMA_TTL_MS = 30_000
+const schemaCache = new Map<string, { at: number; value: CapturedSchemaLite | undefined }>()
+
+export async function fetchLatestSchema(
+	workspace: string,
+	path: string
+): Promise<CapturedSchemaLite | undefined> {
+	const key = `${workspace}:${path}`
+	const hit = schemaCache.get(key)
+	if (hit && Date.now() - hit.at < SCHEMA_TTL_MS) return hit.value
+	let value: CapturedSchemaLite | undefined = undefined
+	try {
+		const versions = await AssetService.listAssetSchemas({ workspace, path })
+		const latest = versions[0]
+		if (latest) {
+			value = {
+				columns: latest.columns,
+				version: latest.version,
+				capturedAt: latest.captured_at
+			}
+		}
+	} catch (e) {
+		console.error('failed to fetch captured asset schema', path, e)
+	}
+	schemaCache.set(key, { at: Date.now(), value })
+	return value
+}
+
+// Resolve the schema map for a set of referenced paths, applying the scd2
+// `<dim>_current` → base-table fallback when the graph identifies the view's
+// producer as a managed scd2 materializer (the view is `SELECT * … WHERE
+// is_current`, so columns are identical).
+export async function fetchSchemasForPaths(
+	workspace: string,
+	paths: string[],
+	scd2CurrentBase?: (path: string) => string | undefined
+): Promise<Map<string, CapturedSchemaLite>> {
+	const out = new Map<string, CapturedSchemaLite>()
+	await Promise.all(
+		paths.map(async (p) => {
+			let schema = await fetchLatestSchema(workspace, p)
+			if (!schema && p.endsWith('_current')) {
+				const base = scd2CurrentBase?.(p)
+				if (base) schema = await fetchLatestSchema(workspace, base)
+			}
+			if (schema) out.set(p, schema)
+		})
+	)
+	return out
+}
+
+// --- Pipeline-graph context ---------------------------------------------------
+
+// Producer-side facts the contract mirror needs but cannot derive from the
+// open buffer: which assets are muted (`on_schema_change=ignore`) and which
+// `<dim>_current` views map to an scd2 base table. Built by the pipeline page
+// from the resolved graph; absent outside the pipeline editor (standalone
+// script editor), where suppression simply doesn't apply client-side — the
+// save-time server check remains authoritative either way.
+export type SchemaContractGraphContext = {
+	// Normalized asset paths whose producer declares `on_schema_change=ignore`.
+	ignoredAssets: string[]
+	// `<base>_current` → base for managed scd2 producers in the graph.
+	scd2CurrentBases: Record<string, string>
+}
+
+export function buildSchemaContractContext(
+	runnables: Pick<
+		import('./types').AssetGraphRunnableNode,
+		'materialize_target' | 'materialize_strategy' | 'materialize_on_schema_change'
+	>[]
+): SchemaContractGraphContext {
+	const ignoredAssets: string[] = []
+	const scd2CurrentBases: Record<string, string> = {}
+	for (const r of runnables) {
+		const t = r.materialize_target
+		if (!t || t.kind !== 'ducklake') continue
+		const base = normalizeAssetPath(t.path)
+		if (r.materialize_on_schema_change === 'ignore') {
+			ignoredAssets.push(base)
+			// The `_current` companion is the producer's own view only for scd2 —
+			// mirroring the backend's `spec.scd2` gate; for any other strategy a
+			// `<base>_current` ref is an unrelated asset that must keep warning.
+			if (r.materialize_strategy === 'scd2') {
+				ignoredAssets.push(`${base}_current`)
+			}
+		}
+		if (r.materialize_strategy === 'scd2') {
+			scd2CurrentBases[`${base}_current`] = base
+		}
+	}
+	return { ignoredAssets, scd2CurrentBases }
+}
+
+// --- Save-time surface ------------------------------------------------------
+
+// Run the authoritative backend check for just-deployed content and toast the
+// result. Never throws — a failed check must not taint a successful deploy.
+export async function notifyContractWarnings(
+	workspace: string,
+	language: ScriptLang,
+	content: string
+): Promise<void> {
+	// Every checkable ref carries the `ducklake` token (URIs and the bare
+	// default-syntax shorthand alike) — skip the round-trip for the vast
+	// majority of saves that can't produce a warning.
+	if (!content.includes('ducklake')) return
+	try {
+		const { warnings } = await ScriptService.checkSchemaContracts({
+			workspace,
+			requestBody: { language, content }
+		})
+		const real = warnings.filter((w) => w.kind !== 'suppressed')
+		if (real.length === 0) return
+		sendUserToast(
+			`Schema contract: ${real.length} warning${real.length > 1 ? 's' : ''}`,
+			'warning',
+			[],
+			real.map((w) => `• ${w.message}`).join('\n'),
+			10000
+		)
+	} catch (e) {
+		console.error('schema-contract check failed', e)
+	}
+}
+
+// End-to-end live-editor check: parse the buffer's annotations, resolve the
+// captured schemas for everything it references, diff, and anchor the result
+// to source positions. Cheap per keystroke — the annotation parse is a line
+// scan and schema fetches hit the short-TTL cache.
+export async function computeContractMarkers(
+	workspace: string,
+	code: string,
+	assets: AssetWithAltAccessType[],
+	context?: SchemaContractGraphContext
+): Promise<ContractMarker[]> {
+	const ann = parsePipelineAnnotations(code)
+	const inputs = {
+		assets,
+		// Annotation-declared lineage only — body-inferred lineage is redundant
+		// with the body-read check and its alias attribution can misfire.
+		columnLineage: ann.columnLineage,
+		dataTests: ann.dataTests,
+		materialize: ann.materialize
+	}
+	const refs = referencedDucklakePaths(inputs)
+	if (refs.length === 0) return []
+	const schemas = await fetchSchemasForPaths(
+		workspace,
+		refs,
+		context ? (p) => context.scd2CurrentBases[p] : undefined
+	)
+	if (schemas.size === 0) return []
+	const warnings = diffSchemaContracts({
+		...inputs,
+		schemas,
+		ignored: new Set(context?.ignoredAssets ?? [])
+	})
+	return mapWarningsToMarkers(code, warnings)
+}
+
+// --- Editor marker mapping ---------------------------------------------------
+
+export type ContractMarker = {
+	message: string
+	startLineNumber: number
+	startColumn: number
+	endLineNumber: number
+	endColumn: number
+}
+
+// Best-effort source anchoring: annotation-family warnings anchor to their
+// annotation line; body-read warnings anchor to the first occurrence of the
+// column identifier; fallback is the `// on`/first line mentioning the asset.
+export function mapWarningsToMarkers(code: string, warnings: ContractWarning[]): ContractMarker[] {
+	const lines = code.split('\n')
+
+	function lineMatching(pred: (line: string) => boolean): number | undefined {
+		const idx = lines.findIndex(pred)
+		return idx >= 0 ? idx + 1 : undefined
+	}
+
+	function tokenRange(
+		lineNumber: number,
+		token: string
+	): { startColumn: number; endColumn: number } {
+		const line = lines[lineNumber - 1] ?? ''
+		const idx = line.toLowerCase().indexOf(token.toLowerCase())
+		if (idx < 0) return { startColumn: 1, endColumn: line.length + 1 }
+		return { startColumn: idx + 1, endColumn: idx + 1 + token.length }
+	}
+
+	return warnings
+		.filter((w) => w.kind !== 'suppressed')
+		.map((w) => {
+			let lineNumber: number | undefined
+			let token: string | undefined = w.column ?? undefined
+			switch (w.kind) {
+				case 'missing_lineage_source':
+					lineNumber = lineMatching(
+						(l) => /^\s*(\/\/|--|#)\s*column\s/.test(l) && !!w.column && l.includes(w.column)
+					)
+					break
+				case 'missing_relationship_column':
+				case 'relationship_type_mismatch':
+					lineNumber = lineMatching(
+						(l) =>
+							/^\s*(\/\/|--|#)\s*data_test\s+relationships\s/.test(l) && l.includes(w.asset_path)
+					)
+					break
+				case 'missing_column': {
+					// first body occurrence of the column identifier
+					const re = new RegExp(`\\b${w.column?.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'i')
+					lineNumber = w.column ? lineMatching((l) => re.test(l)) : undefined
+					break
+				}
+			}
+			if (lineNumber == undefined) {
+				// fallback: the `// on …` (or any) line mentioning the asset path
+				lineNumber = lineMatching((l) => l.includes(w.asset_path)) ?? 1
+				token = w.asset_path
+			}
+			const range = token
+				? tokenRange(lineNumber, token)
+				: { startColumn: 1, endColumn: (lines[lineNumber - 1]?.length ?? 0) + 1 }
+			return {
+				message: w.message,
+				startLineNumber: lineNumber,
+				endLineNumber: lineNumber,
+				...range
+			}
+		})
+}
diff --git a/frontend/src/lib/components/assets/AssetGraph/types.ts b/frontend/src/lib/components/assets/AssetGraph/types.ts
index 0db259a389..0e055abca2 100644
--- a/frontend/src/lib/components/assets/AssetGraph/types.ts
+++ b/frontend/src/lib/components/assets/AssetGraph/types.ts
@@ -6,6 +6,16 @@ export type GraphUsageKind = 'script' | 'flow'
 export interface AssetGraphAssetNode {
 	kind: AssetKind
 	path: string
+	// Fork workspaces only: 'fork' when this ducklake asset was materialized in
+	// the fork itself, 'deferred' when reads fall back to the parent workspace's
+	// current table via a defer view. Absent outside forks / for other kinds /
+	// when never materialized anywhere. Lockstep with Rust `GraphAssetNode`.
+	fork_materialization?: 'fork' | 'deferred'
+	// Base dimension path this node is the SCD2 `<dim>_current` companion view of
+	// (its producer declares `// materialize … history` on `<dim>`). Set only on
+	// the `_current` node; lets the canvas mark it as a derived "current view"
+	// rather than an unrelated table. Lockstep with Rust `GraphAssetNode`.
+	derived_from?: string
 }
 
 export interface AssetGraphRunnableNode {
@@ -22,6 +32,11 @@ export interface AssetGraphRunnableNode {
 	// Raw `// freshness <duration>` value, e.g. "1h", "30m". Surfaced for
 	// the badge; the runtime parses it as needed.
 	freshness?: string
+	// Completion time (ISO) of the newest successful run of this pipeline
+	// member visible to the caller. The freshness chip compares it against
+	// the `// freshness` window to render fresh/stale. Absent = no
+	// successful run found (or none visible under job RLS).
+	last_success_at?: string
 	// `// tag <name>` worker-tag override. Surfaced for the badge so users
 	// can see which worker pool will pick this script up at a glance.
 	tag?: string
@@ -44,8 +59,15 @@ export interface AssetGraphRunnableNode {
 	// Managed `// materialize` write strategy. Absent for non-materializing or
 	// `manual` scripts. Used (with `partition_kind`) to decide whether a
 	// produced asset's schema can evolve: only whole-table `replace` can, since
-	// `append`/`merge`/partitioned writes INSERT into a fixed-schema table.
-	materialize_strategy?: 'replace' | 'append' | 'merge'
+	// `append`/`merge`/`scd2`/partitioned writes INSERT into a fixed-schema
+	// table. `scd2` also identifies the producer of a `<dim>_current` companion
+	// view for the schema-contract `_current` → base-table fallback.
+	materialize_strategy?: 'replace' | 'append' | 'merge' | 'scd2'
+	// `on_schema_change=ignore` on the managed materialize — the producer's
+	// opt-out from downstream schema-contract warnings. Only present when set
+	// to `ignore` (default `warn` is absent). Threaded into the editor's
+	// contract mirror so it suppresses the same warnings the server check does.
+	materialize_on_schema_change?: string
 	// Macros this script provides to the workspace registry (deployed
 	// `// macros` library). Non-empty marks the node as a macro library;
 	// drives the "defines N macros" badge and the details-pane signature
@@ -130,12 +152,29 @@ export interface AssetGraphMacroEdge {
 	unsaved?: boolean
 }
 
+// Ordering-only "must-run-after" edge: `runnable_path`'s `// data_test`
+// (a `relationships` ref, or a custom test reading a pipeline asset) needs
+// `asset` materialized before the tested script runs — but the tested script
+// doesn't consume the asset's rows, so this is NOT a lineage edge. Resolved
+// server-side to the referenced asset's in-pipeline producer; fed into the
+// cascade topo-sort (buildLineageDag) so a cold cascade orders the referenced
+// dimension first, and rendered dashed on the canvas (like macro edges).
+export interface AssetGraphTestEdge {
+	producer_kind: GraphUsageKind
+	producer_path: string
+	runnable_kind: GraphUsageKind
+	runnable_path: string
+	asset_kind: AssetKind
+	asset_path: string
+}
+
 export interface AssetGraphResponse {
 	assets: AssetGraphAssetNode[]
 	runnables: AssetGraphRunnableNode[]
 	edges: AssetGraphEdge[]
 	triggers: AssetGraphTrigger[]
 	macro_edges?: AssetGraphMacroEdge[]
+	test_edges?: AssetGraphTestEdge[]
 }
 
 export type AssetGraphNodeData =
diff --git a/frontend/src/lib/components/common/badge/Badge.svelte b/frontend/src/lib/components/common/badge/Badge.svelte
index cf7a7cad66..c57d41029c 100644
--- a/frontend/src/lib/components/common/badge/Badge.svelte
+++ b/frontend/src/lib/components/common/badge/Badge.svelte
@@ -90,7 +90,7 @@
 
 	const hovers: Partial<Record<BadgeColor, string>> = {
 		gray: 'hover:bg-surface-hover',
-		blue: 'hover:bg-blue-200 dark:hover:bg-blue-700/40',
+		blue: 'hover:bg-blue-100 dark:hover:bg-blue-700/60',
 		red: 'hover:bg-red-200 dark:hover:bg-red-500/25',
 		green: 'hover:bg-green-200 dark:hover:bg-green-500/25',
 		yellow: 'hover:bg-yellow-200 dark:hover:bg-yellow-500/25',
diff --git a/frontend/src/lib/components/copilot/chat/AIChatManager.svelte.ts b/frontend/src/lib/components/copilot/chat/AIChatManager.svelte.ts
index 5f5835bd13..c67bcd17b5 100644
--- a/frontend/src/lib/components/copilot/chat/AIChatManager.svelte.ts
+++ b/frontend/src/lib/components/copilot/chat/AIChatManager.svelte.ts
@@ -44,6 +44,9 @@ import {
 	buildSummaryMessageContent
 } from './compactionPrompt'
 import { dfs } from '$lib/components/flows/previousResults'
+import { SvelteSet } from 'svelte/reactivity'
+import type { UserDraftItemKind } from '$lib/gen'
+import { maskKey } from '$lib/components/sessions/modifiedItemsMask'
 import { getStringError } from './utils'
 import { type PasteAttachment } from './pasteTokens'
 import { chatDraft, expanded } from './chatDraft'
@@ -343,6 +346,75 @@ export class AIChatManager {
 	// session rather than the UI-active one — keeps backgrounded sessions isolated.
 	sessionId: string | undefined = undefined
 
+	// Fired whenever the active chat id changes away from the one the consumer
+	// knows (a "/clear" rotation or a history switch). Session runtimes wire this
+	// to keep the session record's chatId aligned — the compare-page handoff
+	// (`from_session`) reads it, and a stale id would preselect the previous
+	// chat's items. Set here (not imported) to avoid a copilot→sessions cycle.
+	onChatRotated: ((chatId: string) => void) | undefined = undefined
+
+	// Workspace items the CURRENT chat modified via AI tool calls, as
+	// `${UserDraftItemKind}:${storagePath}` keys (see modifiedItemsMask.ts).
+	// undefined = untracked: the global side-panel chat (never initialised) and
+	// loaded legacy chats with no stored mask, both of which fall back to the
+	// show-all bar. A SvelteSet (even empty) = tracked. Reactive so the session
+	// bar updates as tools record mid-turn.
+	modifiedItems = $state<SvelteSet<string> | undefined>(undefined)
+
+	// Start tracking for a brand-new session chat (empty = "tracked, nothing yet").
+	initModifiedItemsTracking() {
+		this.modifiedItems = new SvelteSet()
+	}
+
+	// Record an item an AI tool call created/edited/deleted. No-op when untracked
+	// (the global singleton never initialises the set), so it stays unaffected.
+	recordModifiedItem(itemKind: UserDraftItemKind, storagePath: string) {
+		this.modifiedItems?.add(maskKey(itemKind, storagePath))
+	}
+
+	// Un-record an item whose chat-made change was discarded — without this the
+	// still-existing deployed item would keep reading as this chat's "Deployed"
+	// edit. Persisted immediately: unlike recordModifiedItem (whose persistence
+	// rides on the turn's saveChat), a discard can fire from the review dock
+	// outside any turn, and waiting would resurrect the entry on reload.
+	async removeModifiedItem(itemKind: UserDraftItemKind, storagePath: string) {
+		if (!this.modifiedItems?.delete(maskKey(itemKind, storagePath))) return
+		await this.#persistModifiedItems()
+	}
+
+	// Move a mask entry to the path a draft actually deployed to. A draft-only
+	// flow/app parks at a synthetic `draft_{uuid}` storage path and deploys to
+	// its chosen path — without the move, the existence check at the synthetic
+	// path fails after reload and the deployed row vanishes from the dock.
+	async renameModifiedItem(itemKind: UserDraftItemKind, fromPath: string, toPath: string) {
+		if (fromPath === toPath) return
+		if (!this.modifiedItems?.delete(maskKey(itemKind, fromPath))) return
+		this.modifiedItems.add(maskKey(itemKind, toPath))
+		await this.#persistModifiedItems()
+	}
+
+	// Serialized, snapshot-at-write-time persistence: two rapid dock actions
+	// would otherwise race their saveChat writes, and the earlier (staler)
+	// snapshot could land last — dropping the later mutation until the next
+	// turn-end save.
+	#maskPersistQueue: Promise<void> = Promise.resolve()
+	#persistModifiedItems(): Promise<void> {
+		this.#maskPersistQueue = this.#maskPersistQueue.then(() =>
+			this.historyManager
+				.saveChat(
+					this.displayMessages,
+					this.messages,
+					this.contextUsage,
+					this.modifiedItems ? [...this.modifiedItems] : undefined
+				)
+				// Swallow (and log) a failed write so it can't wedge the queue as a
+				// rejected link — the next persist snapshots the full current set, so
+				// a lost write self-heals on the next mutation or turn-end save.
+				.catch((e) => console.error('Failed to persist modified-items mask', e))
+		)
+		return this.#maskPersistQueue
+	}
+
 	// Workspace AI skills (name + description) advertised in the GLOBAL system
 	// prompt and surfaced as slash commands in session chat. Loaded
 	// asynchronously when entering GLOBAL mode; the system message is rebuilt
@@ -659,7 +731,12 @@ export class AIChatManager {
 			)
 			switch (result) {
 				case 'ok':
-					await this.historyManager.saveChat(this.displayMessages, this.messages, this.contextUsage)
+					await this.historyManager.saveChat(
+						this.displayMessages,
+						this.messages,
+						this.contextUsage,
+						this.modifiedItems ? [...this.modifiedItems] : undefined
+					)
 					sendUserToast('Conversation compacted.')
 					break
 				case 'empty':
@@ -1636,7 +1713,12 @@ export class AIChatManager {
 			const projectedContextTokens = this.contextTokens + this.estimateMessagesTokens([userMessage])
 
 			this.messages.push(userMessage)
-			await this.historyManager.saveChat(this.displayMessages, this.messages, this.contextUsage)
+			await this.historyManager.saveChat(
+				this.displayMessages,
+				this.messages,
+				this.contextUsage,
+				this.modifiedItems ? [...this.modifiedItems] : undefined
+			)
 
 			this.currentReply = ''
 			this.currentReasoning = ''
@@ -1672,7 +1754,12 @@ export class AIChatManager {
 							this.contextUsage = Math.max(0, this.contextUsage - freed)
 						}
 					}
-					await this.historyManager.saveChat(this.displayMessages, this.messages, this.contextUsage)
+					await this.historyManager.saveChat(
+						this.displayMessages,
+						this.messages,
+						this.contextUsage,
+						this.modifiedItems ? [...this.modifiedItems] : undefined
+					)
 				}
 			}
 			// Rollback anchors for restoreUnsentTurn: captured after compaction so
@@ -1758,7 +1845,10 @@ export class AIChatManager {
 					},
 					requestConfirmation: this.requestConfirmation,
 					shouldAutoAcceptToolConfirmations: () => this.autoAcceptToolConfirmationsActive,
-					requestUserQuestion: this.requestUserQuestion
+					requestUserQuestion: this.requestUserQuestion,
+					onItemModified: (kind, path) => this.recordModifiedItem(kind, path),
+					onItemDeployed: (kind, from, to) => void this.renameModifiedItem(kind, from, to),
+					onItemDiscarded: (kind, path) => void this.removeModifiedItem(kind, path)
 				}
 			}
 
@@ -1794,7 +1884,12 @@ export class AIChatManager {
 				this.contextUsage = result?.lastIterationUsage
 					? result.lastIterationUsage.prompt + result.lastIterationUsage.completion
 					: undefined
-				await this.historyManager.saveChat(this.displayMessages, this.messages, this.contextUsage)
+				await this.historyManager.saveChat(
+					this.displayMessages,
+					this.messages,
+					this.contextUsage,
+					this.modifiedItems ? [...this.modifiedItems] : undefined
+				)
 				// Still counts as the saved first turn — skipping the hook here would
 				// permanently miss it (the next turn isn't "first" anymore).
 				if (isFirstUserTurn && this.afterFirstTurnSaved) {
@@ -1824,7 +1919,12 @@ export class AIChatManager {
 					// user message on reload. Remove it instead.
 					this.historyManager.deletePastChat(this.historyManager.getCurrentChatId())
 				} else {
-					await this.historyManager.saveChat(this.displayMessages, this.messages, this.contextUsage)
+					await this.historyManager.saveChat(
+						this.displayMessages,
+						this.messages,
+						this.contextUsage,
+						this.modifiedItems ? [...this.modifiedItems] : undefined
+					)
 				}
 				if (!wasAborted) {
 					sendUserToast('The model returned no response — your message was restored to the input.')
@@ -1843,7 +1943,12 @@ export class AIChatManager {
 				if (this.autoAcceptEditsActive) {
 					this.acceptPendingFlowEdits()
 				}
-				await this.historyManager.saveChat(this.displayMessages, this.messages, this.contextUsage)
+				await this.historyManager.saveChat(
+					this.displayMessages,
+					this.messages,
+					this.contextUsage,
+					this.modifiedItems ? [...this.modifiedItems] : undefined
+				)
 				// Only this branch is a clean send: the queued-message flush below
 				// auto-sends the next message after it (set after saveChat so a
 				// persistence failure falls through to the restore path instead).
@@ -1867,7 +1972,12 @@ export class AIChatManager {
 				// compaction on the next send instead of failing the same way again.
 				this.contextUsage = undefined
 				try {
-					await this.historyManager.saveChat(this.displayMessages, this.messages, this.contextUsage)
+					await this.historyManager.saveChat(
+						this.displayMessages,
+						this.messages,
+						this.contextUsage,
+						this.modifiedItems ? [...this.modifiedItems] : undefined
+					)
 				} catch (saveErr) {
 					console.error('Failed to persist partial chat after error', saveErr)
 				}
@@ -1996,15 +2106,25 @@ export class AIChatManager {
 		// Drop any message queued in this conversation so it can't auto-send into
 		// the fresh chat or linger as a card across the switch.
 		this.queuedMessage = ''
-		await this.historyManager.save(this.displayMessages, this.messages, this.contextUsage)
+		await this.historyManager.save(
+			this.displayMessages,
+			this.messages,
+			this.contextUsage,
+			this.modifiedItems ? [...this.modifiedItems] : undefined
+		)
 		this.displayMessages = []
 		this.messages = []
 		this.contextUsage = undefined
+		// The mask belongs to the conversation just saved — the fresh chat starts
+		// its own (empty) tracking; carrying entries over would claim the previous
+		// conversation's edits for the new one. Untracked chats stay untracked.
+		if (this.modifiedItems) this.modifiedItems = new SvelteSet()
 		// In an AI session, linked files are session-scoped: they persist across conversations
 		// (cleared only when the session is deleted). The ephemeral global side-panel chat has no
 		// session, so "New chat" must clear them — otherwise the next, unrelated conversation
 		// would still get the previous file roster and could read/search it.
 		if (!this.isSessionChat) this.attachedFiles.clear()
+		this.onChatRotated?.(this.historyManager.getCurrentChatId())
 	}
 
 	loadPastChat = async (id: string) => {
@@ -2019,7 +2139,16 @@ export class AIChatManager {
 			this.displayMessages = chat.displayMessages
 			this.messages = chat.actualMessages
 			this.contextUsage = normalizeContextUsage(chat.contextUsage)
+			// Seed the modified-items mask from the stored chat. A stored array
+			// (even empty) → tracked; a legacy chat with no field stays untracked
+			// (undefined) so the session bar falls back to showing all drafts. The
+			// global side-panel chat never tracks, so leave it untouched there.
+			if (this.isSessionChat) {
+				const stored = this.historyManager.getModifiedItems(id)
+				this.modifiedItems = stored !== undefined ? new SvelteSet(stored) : undefined
+			}
 			this.#automaticScroll = true
+			this.onChatRotated?.(id)
 		}
 	}
 
diff --git a/frontend/src/lib/components/copilot/chat/AIChatManager.test.ts b/frontend/src/lib/components/copilot/chat/AIChatManager.test.ts
index d23cbf96a1..a415377a7b 100644
--- a/frontend/src/lib/components/copilot/chat/AIChatManager.test.ts
+++ b/frontend/src/lib/components/copilot/chat/AIChatManager.test.ts
@@ -693,7 +693,9 @@ describe('AIChatManager context compaction', () => {
 		expect(manager.messages[0]).toMatchObject({ role: 'user', content: 'c'.repeat(400) })
 		// Mid-turn, the report is debited by the freed estimate (visible in the
 		// compaction-time save) so a rolled-back turn keeps a consistent value
-		expect(saveChat).toHaveBeenCalledWith(expect.anything(), expect.anything(), 650_000)
+		// 4th arg: the modified-items mask rides on every save (undefined here —
+		// this bare manager never initialised tracking).
+		expect(saveChat).toHaveBeenCalledWith(expect.anything(), expect.anything(), 650_000, undefined)
 		// At commit, the no-report turn clears the stored value; the readable
 		// number falls back to estimating the now-tiny compacted history
 		expect(manager.contextUsage).toBeUndefined()
diff --git a/frontend/src/lib/components/copilot/chat/HistoryManager.svelte.ts b/frontend/src/lib/components/copilot/chat/HistoryManager.svelte.ts
index 9173e4c441..0db0751293 100644
--- a/frontend/src/lib/components/copilot/chat/HistoryManager.svelte.ts
+++ b/frontend/src/lib/components/copilot/chat/HistoryManager.svelte.ts
@@ -25,6 +25,12 @@ interface ChatSchema extends IDBSchema {
 			// New writes store the plain reported token count; chats persisted by
 			// earlier versions may still hold the legacy anchor object.
 			contextUsage?: PersistedContextUsage
+			// Workspace items this chat modified via AI tool calls, as
+			// `${UserDraftItemKind}:${storagePath}` keys. Persisted out-of-band from
+			// the message arrays so it survives compaction. Absent (undefined) on
+			// chats predating this feature → consumers fall back to showing all
+			// workspace drafts; a defined array (even empty) means "tracked".
+			modifiedItems?: string[]
 		}
 	}
 }
@@ -80,6 +86,29 @@ export function __resetLegacyChatClaimForTesting(): void {
 	legacyChatClaim = undefined
 }
 
+// Read a chat's modified-items mask by chatId WITHOUT mounting an AIChatManager,
+// for the standalone /forks/compare route. Returns undefined for a legacy chat
+// (no field) so the page falls back to selecting all items; a defined array
+// (even empty) narrows the preselection. Opens a throwaway user-scoped handle;
+// the `get` is O(1) on the `id` keyPath.
+export async function readChatModifiedItems(chatId: string): Promise<string[] | undefined> {
+	const dbh = userScopedDb<ChatSchema>(DB_NAME, {
+		version: 1,
+		upgrade: createChatStore,
+		migrate: migrateLegacyChatDb
+	})
+	try {
+		const db = await dbh.whenReady()
+		const chat = await db?.get('chats', chatId)
+		return chat?.modifiedItems
+	} catch (err) {
+		console.error('Could not read chat modified items', err)
+		return undefined
+	} finally {
+		dbh.close()
+	}
+}
+
 export default class HistoryManager {
 	// Per-instance handle to the shared per-user DB lifecycle. There is one
 	// HistoryManager per AIChatManager (the singleton + one per session runtime),
@@ -100,6 +129,7 @@ export default class HistoryManager {
 			lastModified: number
 			sessionId?: string
 			contextUsage?: PersistedContextUsage
+			modifiedItems?: string[]
 		}
 	> = $state({})
 
@@ -173,10 +203,15 @@ export default class HistoryManager {
 		return Object.values(this.savedChats)
 	}
 
+	getModifiedItems(id: string): string[] | undefined {
+		return this.savedChats[id]?.modifiedItems
+	}
+
 	async saveChat(
 		displayMessages: DisplayMessage[],
 		messages: ChatCompletionMessageParam[],
-		contextUsage?: number
+		contextUsage?: number,
+		modifiedItems?: string[]
 	) {
 		if (displayMessages.length > 0) {
 			// Compaction replaces the original first message with a summary boundary.
@@ -203,7 +238,18 @@ export default class HistoryManager {
 				id: this.currentChatId,
 				lastModified: Date.now(),
 				...(this.sessionId ? { sessionId: this.sessionId } : {}),
-				...(contextUsage !== undefined ? { contextUsage } : {})
+				...(contextUsage !== undefined ? { contextUsage } : {}),
+				// Only persist when the caller passes a defined array. Loaded legacy
+				// chats keep their accumulator undefined, so we never retroactively
+				// stamp them with [] (which would flip them to the filtered view).
+				// But since `put` replaces the whole record, a caller that omits the
+				// argument must not ERASE a tracked chat's stored mask — fall back to
+				// the previously saved field.
+				...(modifiedItems !== undefined
+					? { modifiedItems }
+					: this.savedChats[this.currentChatId]?.modifiedItems !== undefined
+						? { modifiedItems: this.savedChats[this.currentChatId].modifiedItems }
+						: {})
 			}
 			this.savedChats = {
 				...this.savedChats,
@@ -218,9 +264,10 @@ export default class HistoryManager {
 	async save(
 		displayMessages: DisplayMessage[],
 		messages: ChatCompletionMessageParam[],
-		contextUsage?: number
+		contextUsage?: number,
+		modifiedItems?: string[]
 	) {
-		await this.saveChat(displayMessages, messages, contextUsage)
+		await this.saveChat(displayMessages, messages, contextUsage, modifiedItems)
 		this.currentChatId = createLongHash()
 	}
 
diff --git a/frontend/src/lib/components/copilot/chat/HistoryManager.test.ts b/frontend/src/lib/components/copilot/chat/HistoryManager.test.ts
index 38fb7ecf0d..540dfaf72e 100644
--- a/frontend/src/lib/components/copilot/chat/HistoryManager.test.ts
+++ b/frontend/src/lib/components/copilot/chat/HistoryManager.test.ts
@@ -141,3 +141,30 @@ describe('HistoryManager title across compaction', () => {
 		expect(hm.getAllSavedChats().find((c) => c.id === id)?.title).toBe('original first question')
 	})
 })
+
+describe('HistoryManager modified-items mask persistence', () => {
+	const msgs = [{ role: 'user', content: 'hello', index: 0 }] as DisplayMessage[]
+
+	it('a save without the argument preserves a previously stored mask', async () => {
+		const hm = new HistoryManager()
+		await hm.init()
+		const id = hm.getCurrentChatId()
+
+		await hm.saveChat(msgs, [] as ChatCompletionMessageParam[], undefined, ['script:u/a/x'])
+		expect(hm.getModifiedItems(id)).toEqual(['script:u/a/x'])
+
+		// e.g. manual compaction re-saving the transcript: the whole record is
+		// rewritten, but the tracked mask must survive.
+		await hm.saveChat(msgs, [] as ChatCompletionMessageParam[])
+		expect(hm.getModifiedItems(id)).toEqual(['script:u/a/x'])
+	})
+
+	it('never retroactively stamps an untracked chat', async () => {
+		const hm = new HistoryManager()
+		await hm.init()
+		const id = hm.getCurrentChatId()
+
+		await hm.saveChat(msgs, [] as ChatCompletionMessageParam[])
+		expect(hm.getModifiedItems(id)).toBeUndefined()
+	})
+})
diff --git a/frontend/src/lib/components/copilot/chat/global/core.ts b/frontend/src/lib/components/copilot/chat/global/core.ts
index 90dcb655f4..24045280d0 100644
--- a/frontend/src/lib/components/copilot/chat/global/core.ts
+++ b/frontend/src/lib/components/copilot/chat/global/core.ts
@@ -114,6 +114,7 @@ import {
 	getEphemeralSecretVariableDraftValue,
 	getGlobalDraft,
 	getGlobalDraftStoragePath,
+	itemKindFor,
 	listGlobalDrafts,
 	persistGlobalDraft,
 	readGlobalDraftValue,
@@ -2779,6 +2780,7 @@ function finishAppDraftWrite(
 ): string {
 	const failure = draftWriteFailure(result, ctx)
 	if (failure) return failure
+	ctx.toolCallbacks.onItemModified?.(result.itemKind, result.storagePath)
 	const { content, message } = onSaved()
 	ctx.toolCallbacks.setToolStatus(ctx.toolId, { content, result: 'Saved as draft' })
 	return JSON.stringify({ success: true, message }, null, 2)
@@ -2791,6 +2793,7 @@ function finishDraftWrite(
 ): string {
 	const failure = draftWriteFailure(result, ctx)
 	if (failure) return failure
+	ctx.toolCallbacks.onItemModified?.(result.itemKind, result.storagePath)
 	const stored = result.item
 	const verb = existed ? 'Updated' : 'Created'
 	// Don't echo the flow value back: the model just sent it in the write call,
@@ -3898,6 +3901,16 @@ async function discardLocalDraft(
 
 	await deleteGlobalDraft(workspace, type, path, triggerKind)
 
+	// The chat's touch on the item is undone — drop it from the mask so a
+	// pre-existing deployed item doesn't keep reading as this chat's edit.
+	const discardedKind = itemKindFor(type, triggerKind)
+	if (discardedKind) {
+		toolCallbacks.onItemDiscarded?.(
+			discardedKind,
+			getGlobalDraftStoragePath(workspace, type, path, triggerKind)
+		)
+	}
+
 	toolCallbacks.setToolStatus(toolId, {
 		content: `Discarded ${type} "${path}" draft`,
 		result: 'Draft discarded'
@@ -4237,6 +4250,9 @@ async function deployDraft(
 	})
 
 	let actions: ToolDisplayAction[] | undefined
+	// Where the deploy actually lands — the app branch can resolve a different
+	// target from the draft's own path fields; the mask rename below must track it.
+	let deployedPath = path
 
 	if (type === 'script' || type === 'flow') {
 		// Promote the full persisted draft via the shared deploy module — the same
@@ -4429,6 +4445,7 @@ async function deployDraft(
 						throw e
 					}
 				}
+				deployedPath = targetPath
 				if (await AppService.existsApp({ workspace, path: targetPath })) {
 					// Omit custom_path on update for now. The backend preserves it when absent, while
 					// sending it requires admin privileges; this chat deploy path does not yet mirror
@@ -4478,6 +4495,18 @@ async function deployDraft(
 
 	await deleteGlobalDraft(workspace, type, path, triggerKind, { preserveLiveDraft: true })
 
+	// Move the chat's mask entry to the deployed path: a draft-only item's
+	// synthetic storage key never exists deployed, so the entry would otherwise
+	// stop matching anything after the draft is gone.
+	const deployedKind = itemKindFor(type, triggerKind)
+	if (deployedKind) {
+		toolCallbacks.onItemDeployed?.(
+			deployedKind,
+			getGlobalDraftStoragePath(workspace, type, path, triggerKind),
+			deployedPath
+		)
+	}
+
 	// Reload the session preview if it's open on the deployed item. Map the
 	// deploy type to the preview kind — a raw app deploys under 'app' but the
 	// preview addresses it as 'raw_app'; non-previewable types map to undefined.
@@ -4548,6 +4577,17 @@ async function deleteWorkspaceItem(
 
 	await deleteGlobalDraft(workspace, type, path, triggerKind)
 
+	// Record the deletion in the chat's modified-items mask. In a fork this leaves a
+	// reviewable "removed" diff vs the parent that stays scoped to this chat. Keyed
+	// by the same (itemKind, storagePath) as writes so it joins the draft/fork lists.
+	const deletedKind = itemKindFor(type, triggerKind)
+	if (deletedKind) {
+		toolCallbacks.onItemModified?.(
+			deletedKind,
+			getGlobalDraftStoragePath(workspace, type, path, triggerKind)
+		)
+	}
+
 	toolCallbacks.setToolStatus(toolId, {
 		content: `Deleted ${type} "${path}"`,
 		result: 'Deleted'
diff --git a/frontend/src/lib/components/copilot/chat/global/userDraftAdapter.ts b/frontend/src/lib/components/copilot/chat/global/userDraftAdapter.ts
index 87ca767904..2717d41608 100644
--- a/frontend/src/lib/components/copilot/chat/global/userDraftAdapter.ts
+++ b/frontend/src/lib/components/copilot/chat/global/userDraftAdapter.ts
@@ -108,7 +108,7 @@ function clearEphemeralSecretVariableDraftValues(workspace: string): void {
 	secretVariableDraftValues.delete(workspace)
 }
 
-function itemKindFor(
+export function itemKindFor(
 	type: WorkspaceItemType,
 	triggerKind?: TriggerKind
 ): UserDraftItemKind | undefined {
@@ -377,10 +377,25 @@ export async function readGlobalDraftValue<V>(
 	return (await fetchBackendDraftValue(workspace, itemKind, storagePath)) as V | undefined
 }
 
+// `itemKind` + `storagePath` are the canonical identity of the persisted draft
+// (NOT item.path, which is the friendly display path). Callers use them to record
+// the chat's modified-items mask.
 export type DraftPersistResult =
-	| { status: 'saved'; item: WorkspaceItem }
-	| { status: 'conflict'; item: WorkspaceItem; serverTimestamp?: string }
-	| { status: 'error'; item: WorkspaceItem; message: string }
+	| { status: 'saved'; item: WorkspaceItem; itemKind: UserDraftItemKind; storagePath: string }
+	| {
+			status: 'conflict'
+			item: WorkspaceItem
+			itemKind: UserDraftItemKind
+			storagePath: string
+			serverTimestamp?: string
+	  }
+	| {
+			status: 'error'
+			item: WorkspaceItem
+			itemKind: UserDraftItemKind
+			storagePath: string
+			message: string
+	  }
 
 // Persist a built draft value. `UserDraft.seed` reflects it into an open editor's
 // cell WITHOUT a double-POST (no-ops if no cell; its seedNextWrite suppresses the
@@ -417,14 +432,20 @@ export async function persistGlobalDraft(
 	// the chat "saved" while the DB-backed source of truth was never updated.
 	const saveState = UserDraftDbSyncer.getState({ workspace, itemKind, path: storagePath })
 	if (saveState.state === 'failed') {
-		return { status: 'error', item, message: saveState.failureMessage ?? 'Draft save failed' }
+		return {
+			status: 'error',
+			item,
+			itemKind,
+			storagePath,
+			message: saveState.failureMessage ?? 'Draft save failed'
+		}
 	}
 	const conflict = opts.force
 		? undefined
 		: UserDraftDbSyncer.getConflict({ workspace, itemKind, path: storagePath }).conflict
 	return conflict
-		? { status: 'conflict', item, serverTimestamp: conflict.serverTimestamp }
-		: { status: 'saved', item }
+		? { status: 'conflict', item, itemKind, storagePath, serverTimestamp: conflict.serverTimestamp }
+		: { status: 'saved', item, itemKind, storagePath }
 }
 
 export async function getGlobalDraft(
diff --git a/frontend/src/lib/components/copilot/chat/shared.ts b/frontend/src/lib/components/copilot/chat/shared.ts
index 7abdc75168..c454f15fe6 100644
--- a/frontend/src/lib/components/copilot/chat/shared.ts
+++ b/frontend/src/lib/components/copilot/chat/shared.ts
@@ -3,6 +3,7 @@ import type {
 	ChatCompletionMessageFunctionToolCall,
 	ChatCompletionMessageParam
 } from 'openai/resources/chat/completions.mjs'
+import type { UserDraftItemKind } from '$lib/gen'
 
 /**
  * Special module IDs used throughout the flow system
@@ -759,6 +760,15 @@ export interface ToolCallbacks {
 		toolId: string,
 		question: UserQuestionDisplay
 	) => Promise<string | undefined>
+	/** Records a workspace item the tool call created/edited/deleted, by its
+	 * canonical (itemKind, storagePath). Session chats wire this to accumulate the
+	 * chat's modified-items mask; the global side-panel chat omits it (no-op). */
+	onItemModified?: (itemKind: UserDraftItemKind, storagePath: string) => void
+	/** A tool deployed a draft: the mask entry moves from the draft's storage path
+	 * to the deployed path (they differ for synthetic draft-only storage keys). */
+	onItemDeployed?: (itemKind: UserDraftItemKind, storagePath: string, deployedPath: string) => void
+	/** A tool discarded a draft: the chat's touch on the item is undone. */
+	onItemDiscarded?: (itemKind: UserDraftItemKind, storagePath: string) => void
 }
 
 export function createToolDef(
diff --git a/frontend/src/lib/components/copilot/reasoningRegistry.ts b/frontend/src/lib/components/copilot/reasoningRegistry.ts
index 4776e64c79..519c1a4021 100644
--- a/frontend/src/lib/components/copilot/reasoningRegistry.ts
+++ b/frontend/src/lib/components/copilot/reasoningRegistry.ts
@@ -319,7 +319,7 @@ export const DEEPSEEK_OFF_SENTINEL: ReasoningEffort = 'none'
  * model that reasons *by default* — omitting the field would silently keep
  * the default-on behavior. Undefined means omission is the correct off.
  */
-function explicitOffToken(provider: AIProvider, model: string): ReasoningEffort | undefined {
+export function explicitOffToken(provider: AIProvider, model: string): ReasoningEffort | undefined {
 	switch (reasoningProviderFamily(provider, model)) {
 		case 'googleai':
 			// Gemini 2.5/3 think by default (dynamic budget / level). The backend
diff --git a/frontend/src/lib/components/sessions/DraftDiffDrawer.svelte b/frontend/src/lib/components/sessions/DraftDiffDrawer.svelte
deleted file mode 100644
index 0b529b2056..0000000000
--- a/frontend/src/lib/components/sessions/DraftDiffDrawer.svelte
+++ /dev/null
@@ -1,204 +0,0 @@
-<script lang="ts">
-	import WorkspaceDiffDrawer, { type DiffRow } from './WorkspaceDiffDrawer.svelte'
-	import { Pencil } from 'lucide-svelte'
-	import { DraftService, ScriptService, type WorkspaceItemDiff } from '$lib/gen'
-	import { userWorkspaces } from '$lib/stores'
-	import { editUrlFor as buildEditUrl } from './forkEditUrl'
-	import { getDraftDiffValues, type DraftKind } from '$lib/utils_draft_deploy'
-	import { getDraftItems } from '$lib/workspaceDrafts.svelte'
-
-	// Draft rows carry the user-draft itemKind (`trigger_schedule`, `trigger_http`…),
-	// but the shared row icon/label and the edit-link builder speak the deploy-style
-	// kinds (`schedule`, `http_trigger`…) the fork drawer and compare page use. Map
-	// to deploy-style for display, and back for the draft-value getter.
-	const DEPLOY_KIND_BY_DRAFT_KIND: Partial<Record<DraftKind, string>> = {
-		trigger_schedule: 'schedule',
-		trigger_http: 'http_trigger',
-		trigger_websocket: 'websocket_trigger',
-		trigger_kafka: 'kafka_trigger',
-		trigger_nats: 'nats_trigger',
-		trigger_postgres: 'postgres_trigger',
-		trigger_mqtt: 'mqtt_trigger',
-		trigger_sqs: 'sqs_trigger',
-		trigger_gcp: 'gcp_trigger',
-		trigger_azure: 'azure_trigger',
-		trigger_email: 'email_trigger'
-	}
-	const DRAFT_KIND_BY_DEPLOY_KIND = Object.fromEntries(
-		Object.entries(DEPLOY_KIND_BY_DRAFT_KIND).map(([d, p]) => [p, d])
-	) as Record<string, DraftKind>
-
-	// Thin wrapper: supplies the deployed ↔ draft data source (server `draft`
-	// table, same as the compare page) to the generic WorkspaceDiffDrawer.
-	// Read-only, mirroring ForkDiffDrawer; deploy/discard live on the Review page.
-	let { workspaceId }: { workspaceId: string } = $props()
-
-	let inner: WorkspaceDiffDrawer | undefined = $state(undefined)
-	let rows: DiffRow[] = $state([])
-	let loading = $state(false)
-	let error: string | undefined = $state(undefined)
-	// draft_only per item — drives the "added" rendering (empty before).
-	let draftOnlyByKey: Record<string, boolean> = $state({})
-	// Pre-resolved before/after for exploded pipeline-node rows (see below),
-	// keyed by `${kind}/${path}`. Their content lives in the bundle, not a
-	// per-item draft endpoint, so `loadValues` reads it from here instead of
-	// calling `getDraftDiffValues`.
-	let pipelineNodeValues: Record<string, { before?: unknown; after: unknown }> = $state({})
-
-	const ws = $derived($userWorkspaces.find((w) => w.id === workspaceId))
-
-	export function open() {
-		void fetchDrafts()
-		inner?.open()
-	}
-
-	type ScriptBody = { language?: string; content?: string }
-	type PipelineBundle = {
-		drafts?: Array<[string, { script?: { language?: string; content?: string; summary?: string } }]>
-	}
-
-	// Explode a `data_pipeline` bundle draft into one row per node, nested under
-	// the bundle's folder so they read as the pipeline's subitems. Each node is a
-	// script with its own draft body; the deployed body (if the node is already
-	// deployed) is the "before" so its line changes show. Returns undefined to let
-	// the caller fall back to a single bundle row if the bundle can't be read.
-	async function explodePipelineBundle(bundlePath: string): Promise<DiffRow[] | undefined> {
-		let bundle: PipelineBundle
-		try {
-			const row = (await DraftService.getOwnDraft({
-				workspace: workspaceId,
-				kind: 'data_pipeline',
-				path: bundlePath
-			})) as { value?: PipelineBundle }
-			bundle = row?.value ?? {}
-		} catch (e) {
-			console.warn('Draft diff: pipeline bundle load failed', bundlePath, e)
-			return undefined
-		}
-		const entries = Array.isArray(bundle.drafts) ? bundle.drafts : []
-		// The bundle is keyed at `f/<folder>/data_pipeline`; nodes live in `f/<folder>`.
-		const folder = bundlePath.replace(/\/data_pipeline$/, '')
-		const out: DiffRow[] = []
-		await Promise.all(
-			entries.map(async ([nodePath, d]) => {
-				const after: ScriptBody = {
-					language: d?.script?.language,
-					content: d?.script?.content ?? ''
-				}
-				let before: ScriptBody | undefined
-				try {
-					const dep = await ScriptService.getScriptByPath({
-						workspace: workspaceId,
-						path: nodePath
-					})
-					before = { language: dep.language, content: dep.content }
-				} catch {
-					// Node not deployed yet → no "before" (renders as added).
-				}
-				const rel = nodePath.startsWith(`${folder}/`) ? nodePath.slice(folder.length + 1) : nodePath
-				// Nest under the bundle folder (`…/data_pipeline/<node>`) so the nodes
-				// group as the pipeline's subitems in the tree.
-				const displayPath = `${bundlePath}/${rel}`
-				// A pipeline node shares `script/<nodePath>` with a standalone script
-				// draft at the same path, so identify the row by its distinct
-				// bundle-nested path — `path` stays the real node for the edit link.
-				const key = `pipeline:${displayPath}`
-				pipelineNodeValues[key] = { before, after }
-				out.push({
-					kind: 'script',
-					path: nodePath,
-					displayPath,
-					key,
-					summary: d?.script?.summary || undefined,
-					status: before ? 'modified' : 'added'
-				})
-			})
-		)
-		return out
-	}
-
-	async function fetchDrafts() {
-		loading = true
-		error = undefined
-		try {
-			// One source of truth (Workspace Drafts) — same list the compare page and
-			// the count use.
-			const items = await getDraftItems(workspaceId)
-			const donly: Record<string, boolean> = {}
-			pipelineNodeValues = {}
-			const out: DiffRow[] = []
-			for (const it of items) {
-				if (it.kind === 'data_pipeline') {
-					// A pipeline bundle isn't a single diffable item — explode it into its
-					// node-script subitems. An unreadable bundle is skipped (it has no
-					// single-item diff to show).
-					const nodes = await explodePipelineBundle(it.path)
-					if (nodes) out.push(...nodes)
-					continue
-				}
-				// Raw apps must surface as `raw_app` so the row's edit link points at the
-				// raw-app editor (mirrors CompareDrafts); `getDraftItems` carries the flag.
-				const baseKind = it.raw_app ? 'raw_app' : it.kind
-				const kind = DEPLOY_KIND_BY_DRAFT_KIND[baseKind] ?? baseKind
-				donly[`${kind}/${it.path}`] = it.draft_only
-				// A never-deployed app/raw_app is parked at a synthetic `…/draft_<uuid>`
-				// storage path with the user's typed name in `draft_path`; show that
-				// (matches the home list) while `path` stays the storage key for loading.
-				// `summary` comes straight from the draft row, so it shows for every kind
-				// up front instead of only after the diff value loads.
-				out.push({
-					kind,
-					path: it.path,
-					displayPath: it.draft_path ?? it.path,
-					summary: it.summary,
-					status: it.draft_only ? 'added' : 'modified'
-				})
-			}
-			rows = out
-			draftOnlyByKey = donly
-		} catch (e) {
-			console.error('Draft diff: list failed', e)
-			error = `Failed to load drafts: ${e}`
-			rows = []
-		} finally {
-			loading = false
-		}
-	}
-
-	async function loadValues(d: DiffRow): Promise<{ before: unknown; after: unknown }> {
-		// Exploded pipeline-node rows carry their content from the bundle, not a
-		// per-item draft endpoint — keyed by the row's unique `key` so a standalone
-		// script draft at the same path can't read a node's cached value.
-		const pipelineNode = d.key ? pipelineNodeValues[d.key] : undefined
-		if (pipelineNode) return { before: pipelineNode.before, after: pipelineNode.after }
-		const draftOnly = draftOnlyByKey[`${d.kind}/${d.path}`] ?? false
-		// getDraftDiffValues keys on the draft itemKind: `raw_app` must stay
-		// `raw_app` (the helper sends rawApp:true only for that exact kind, which a
-		// never-deployed raw app needs, else it hits the normal app endpoint and
-		// 404s). Only the trigger display kinds map back from their deploy-style names.
-		const kind = (DRAFT_KIND_BY_DEPLOY_KIND[d.kind] ?? d.kind) as DraftKind
-		const { deployed, draft } = await getDraftDiffValues(kind, d.path, workspaceId, draftOnly)
-		// draft_only items have never been deployed → render as "added" (empty
-		// before), matching how the fork drawer renders added items.
-		return { before: draftOnly ? undefined : deployed, after: draft }
-	}
-</script>
-
-<WorkspaceDiffDrawer
-	bind:this={inner}
-	diffs={rows}
-	{loadValues}
-	{loading}
-	{error}
-	emptyMessage="No drafts in this workspace."
-	title="Drafts"
-	reviewHref={`/forks/compare?workspace_id=${encodeURIComponent(workspaceId)}&mode=draft`}
-	editUrlFor={(d) => buildEditUrl(d as unknown as WorkspaceItemDiff, workspaceId)}
->
-	{#snippet titleExtra()}
-		<div class="flex items-center gap-2 text-xs text-secondary">
-			<Pencil class="w-3.5 h-3.5 shrink-0" />
-			<span class="font-medium truncate">{ws?.name ?? workspaceId}</span>
-		</div>
-	{/snippet}
-</WorkspaceDiffDrawer>
diff --git a/frontend/src/lib/components/sessions/ForkDiffDrawer.svelte b/frontend/src/lib/components/sessions/ForkDiffDrawer.svelte
deleted file mode 100644
index e03fc5a49c..0000000000
--- a/frontend/src/lib/components/sessions/ForkDiffDrawer.svelte
+++ /dev/null
@@ -1,125 +0,0 @@
-<script lang="ts">
-	import WorkspaceDiffDrawer, { type DiffRow } from './WorkspaceDiffDrawer.svelte'
-	import Badge from '$lib/components/common/badge/Badge.svelte'
-	import { AlertTriangle, ArrowRight, GitFork } from 'lucide-svelte'
-	import { WorkspaceService, type WorkspaceComparison, type WorkspaceItemDiff } from '$lib/gen'
-	import { getItemValue } from '$lib/utils_workspace_deploy'
-	import { userWorkspaces } from '$lib/stores'
-	import { editUrlFor as buildEditUrl } from './forkEditUrl'
-
-	// Thin wrapper: supplies the deployed-parent ↔ deployed-fork data source to
-	// the generic WorkspaceDiffDrawer. Display/behavior unchanged from before.
-	let {
-		forkWorkspaceId,
-		parentWorkspaceId
-	}: { forkWorkspaceId: string; parentWorkspaceId: string } = $props()
-
-	let inner: WorkspaceDiffDrawer | undefined = $state(undefined)
-	let comparison: WorkspaceComparison | undefined = $state(undefined)
-	let loading = $state(false)
-	let error: string | undefined = $state(undefined)
-
-	const forkWs = $derived($userWorkspaces.find((w) => w.id === forkWorkspaceId))
-	const parentWs = $derived($userWorkspaces.find((w) => w.id === parentWorkspaceId))
-
-	function statusOf(d: WorkspaceItemDiff): DiffRow['status'] {
-		if (d.exists_in_fork && !d.exists_in_source) return 'added'
-		if (!d.exists_in_fork && d.exists_in_source) return 'removed'
-		if (d.ahead > 0 && d.behind > 0) return 'conflict'
-		return 'modified'
-	}
-
-	// Keep the original diffs by key so loadValues can honor exists flags
-	// (skip the non-existent side for added/removed items).
-	let diffByKey: Record<string, WorkspaceItemDiff> = $state({})
-
-	const rows = $derived.by<DiffRow[]>(() =>
-		(comparison?.diffs ?? []).map((d) => ({
-			kind: d.kind,
-			path: d.path,
-			status: statusOf(d),
-			ahead: d.ahead,
-			behind: d.behind
-		}))
-	)
-
-	function skipNotice(c: WorkspaceComparison | undefined): string | undefined {
-		return c?.skipped_comparison
-			? 'This fork was created before change tracking was added — diffs are not available.'
-			: undefined
-	}
-	const notice = $derived(skipNotice(comparison))
-
-	export function open() {
-		void fetchComparison()
-		inner?.open()
-	}
-
-	async function fetchComparison() {
-		loading = true
-		error = undefined
-		try {
-			comparison = await WorkspaceService.compareWorkspaces({
-				workspace: parentWorkspaceId,
-				targetWorkspaceId: forkWorkspaceId
-			})
-			diffByKey = Object.fromEntries(
-				(comparison?.diffs ?? []).map((d) => [`${d.kind}/${d.path}`, d])
-			)
-		} catch (e) {
-			console.error('Fork diff: comparison failed', e)
-			error = `Failed to load comparison: ${e}`
-			comparison = undefined
-		} finally {
-			loading = false
-		}
-	}
-
-	async function loadValues(d: DiffRow): Promise<{ before: unknown; after: unknown }> {
-		const od = diffByKey[`${d.kind}/${d.path}`]
-		const existsSource = od ? od.exists_in_source !== false : true
-		const existsFork = od ? od.exists_in_fork !== false : true
-		const [before, after] = await Promise.all([
-			existsSource
-				? getItemValue(d.kind as any, d.path, parentWorkspaceId).catch(() => undefined)
-				: Promise.resolve(undefined),
-			existsFork
-				? getItemValue(d.kind as any, d.path, forkWorkspaceId).catch(() => undefined)
-				: Promise.resolve(undefined)
-		])
-		return { before, after }
-	}
-</script>
-
-<WorkspaceDiffDrawer
-	bind:this={inner}
-	diffs={rows}
-	{loadValues}
-	{loading}
-	{error}
-	{notice}
-	emptyMessage="No changes between this fork and its parent."
-	title="Fork changes"
-	reviewHref={`/forks/compare?workspace_id=${encodeURIComponent(forkWorkspaceId)}`}
-	editUrlFor={(d) => buildEditUrl(d as unknown as WorkspaceItemDiff, forkWorkspaceId)}
->
-	{#snippet titleExtra()}
-		<div class="flex items-center gap-2 text-xs text-secondary">
-			<GitFork class="w-3.5 h-3.5 shrink-0" />
-			<span class="font-medium truncate">{forkWs?.name ?? forkWorkspaceId}</span>
-			<ArrowRight class="w-3 h-3 shrink-0 text-tertiary" />
-			<span class="font-medium truncate">{parentWs?.name ?? parentWorkspaceId}</span>
-			{#if comparison}
-				<Badge color="transparent" class="ml-2">
-					{comparison.summary.total_diffs} item{comparison.summary.total_diffs !== 1 ? 's' : ''}
-				</Badge>
-				{#if comparison.summary.conflicts > 0}
-					<Badge color="orange">
-						<AlertTriangle class="w-3 h-3 inline mr-1" />
-						{comparison.summary.conflicts} conflict{comparison.summary.conflicts !== 1 ? 's' : ''}
-					</Badge>
-				{/if}
-			{/if}
-		</div>
-	{/snippet}
-</WorkspaceDiffDrawer>
diff --git a/frontend/src/lib/components/sessions/SessionChangesBar.svelte b/frontend/src/lib/components/sessions/SessionChangesBar.svelte
new file mode 100644
index 0000000000..9f59d1f320
--- /dev/null
+++ b/frontend/src/lib/components/sessions/SessionChangesBar.svelte
@@ -0,0 +1,264 @@
+<script lang="ts">
+	import {
+		Archive,
+		ExternalLink,
+		GitPullRequestClosed,
+		MoveRight,
+		Pencil,
+		Trash2
+	} from 'lucide-svelte'
+	import { Button } from '$lib/components/common'
+	import Badge from '$lib/components/common/badge/Badge.svelte'
+	import WorkspaceFamilyPicker from './WorkspaceFamilyPicker.svelte'
+	import { isPremiumStore, userStore, userWorkspaces, workspaceStore } from '$lib/stores'
+	import { canCreateFork } from '$lib/utils/editInFork'
+	import { isCloudHosted } from '$lib/cloud'
+	import { sessionState, type Session } from './sessionState.svelte'
+	import { getRuntime } from './sessionRuntime.svelte'
+	import SessionDiffDrawer from './SessionDiffDrawer.svelte'
+	import { useWorkspaceDrafts } from '$lib/workspaceDrafts.svelte'
+	import { badgeCounts, buildDeployItems } from './sessionDeployModel'
+	import { useExistingMaskKeys } from './sessionDeployModel.svelte'
+
+	// Unified session bar: surfaces what the CURRENT chat changed — pending
+	// drafts and deployed items — as one count badge per status that opens the
+	// session diff drawer.
+	let {
+		session,
+		onMove,
+		onCreateForkAndMove,
+		onArchive,
+		onDelete
+	}: {
+		session: Session
+		onMove?: (workspaceId: string) => void
+		onCreateForkAndMove?: (fork: {
+			parent_workspace_id: string
+			id: string
+			name: string
+		}) => void | Promise<void>
+		onArchive?: () => void
+		onDelete?: () => void
+	} = $props()
+
+	// Only meaningful once the session committed to a workspace (post first send).
+	const committedId = $derived(session.workspace_id)
+	const sessionWorkspace = $derived(
+		committedId ? $userWorkspaces.find((w) => w.id === committedId) : undefined
+	)
+	const parentWorkspaceId = $derived(sessionWorkspace?.parent_workspace_id ?? undefined)
+	const parentWorkspace = $derived(
+		parentWorkspaceId ? $userWorkspaces.find((w) => w.id === parentWorkspaceId) : undefined
+	)
+	const isFork = $derived(!!parentWorkspaceId)
+
+	// Same gate as the sidebar WorkspaceMenu / SessionWorkspaceBar. On cloud,
+	// forking is a premium-only feature (backend caps it per paid seat).
+	const forksAllowed = $derived(
+		(!isCloudHosted() || $isPremiumStore) &&
+			canCreateFork($userStore) &&
+			$workspaceStore !== 'admins'
+	)
+
+	const runtime = $derived(getRuntime(session.id))
+
+	// The chat's modified-items mask (`${UserDraftItemKind}:${storagePath}`).
+	// undefined = legacy/untracked chat → fall back to showing every draft.
+	// A Set (even empty) → filter to just this chat's items.
+	const mask = $derived(runtime?.manager.modifiedItems)
+
+	// Workspace Drafts (fetches on mount and on every Server-Draft invalidation);
+	// scoped to the chat's mask inside the deploy model below.
+	const drafts = useWorkspaceDrafts(() => committedId)
+
+	// The committed workspace vanished from the user's list (deleted, archived,
+	// or access revoked) — the session can't operate in it anymore.
+	const isUnavailable = $derived(!!committedId && !sessionWorkspace)
+
+	// The committed workspace is gone, so we can't read its parent to know if
+	// it was a fork — fall back to the fork-id convention for the wording.
+	const committedIsFork = $derived(committedId?.startsWith('wm-fork-') ?? false)
+
+	// Full dock refresh: re-run existence checks + draft list. Both are
+	// stale-while-revalidate — a hard reset would blank dockItems for the
+	// round-trip, hiding the bar (and unmounting the drawer) mid-deploy.
+	function refreshDock() {
+		existing.refresh()
+		drafts.refresh()
+	}
+
+	// Refresh the draft list when the AI finishes a turn (loading true → false):
+	// tool calls may have created/edited/deleted items. Deploys happen
+	// server-side, so the frontend only has this coarse signal.
+	let wasLoading = $state(false)
+	$effect(() => {
+		const isLoading = runtime?.manager.loading ?? false
+		if (wasLoading && !isLoading) refreshDock()
+		wasLoading = isLoading
+	})
+
+	// Refresh when the tab regains visibility — covers edits in another tab / by
+	// another user while we were away.
+	$effect(() => {
+		if (!committedId) return
+		function onVisibilityChange() {
+			if (document.visibilityState !== 'visible') return
+			if (sessionState.currentSessionId !== session.id) return
+			refreshDock()
+		}
+		document.addEventListener('visibilitychange', onVisibilityChange)
+		return () => document.removeEventListener('visibilitychange', onVisibilityChange)
+	})
+
+	let diffDrawer: SessionDiffDrawer | undefined = $state(undefined)
+
+	// The dock counts are computed from the same pure model over this chat's
+	// drafts; the readout mirrors the drawer's item states.
+	// Existence check for mask-only (deployed) items — without it they'd be
+	// dropped from the dock counts while the drawer (which runs the same check)
+	// still shows them as Deployed.
+	const existing = useExistingMaskKeys(() => ({
+		draftItems: drafts.items,
+		mask: committedId ? mask : undefined,
+		workspaceId: committedId ?? ''
+	}))
+	const dockItems = $derived(
+		committedId
+			? buildDeployItems({ draftItems: drafts.items, mask, existingKeys: existing.keys })
+			: []
+	)
+	const dockCounts = $derived(badgeCounts(dockItems))
+
+	// Deletion-only fork chat: the mask has entries but every one failed the
+	// (resolved) existence check — the chat's edits were deletions, which have no
+	// dock row by design. The pending fork→parent removal is still reviewable on
+	// the compare page, so the bar must keep that doorway instead of vanishing.
+	// Gated on a resolved check (undefined = still loading) so the bar doesn't
+	// flash this state while deployed rows are being confirmed, and on isFork —
+	// a non-fork deletion is immediate and final, with nothing left to review.
+	const deletionOnly = $derived(
+		isFork && (mask?.size ?? 0) > 0 && existing.keys !== undefined && dockItems.length === 0
+	)
+	const compareHref = $derived(
+		committedId
+			? `/forks/compare?workspace_id=${encodeURIComponent(committedId)}&mode=fork` +
+					(session.chatId ? `&from_session=${encodeURIComponent(session.chatId)}` : '')
+			: undefined
+	)
+
+	// One "Edits" bar for both fork and non-fork sessions, shown when this chat
+	// edited anything. The fork's identity lives in the modal (SessionDiffDrawer's
+	// title), not on the bar. Fork sessions still need the forking gate + a
+	// resolvable fork/parent pair.
+	const showBar = $derived(
+		!!committedId &&
+			(dockItems.length > 0 || deletionOnly) &&
+			(!isFork || (forksAllowed && !!sessionWorkspace && !!parentWorkspace && !!parentWorkspaceId))
+	)
+</script>
+
+{#snippet dock()}
+	<!-- One count badge per row status, same vocabulary/colors as the drawer's
+	     badges (draft/deployed) so the bar reads at a glance. -->
+	<div class="flex items-center gap-1 shrink-0">
+		{#if dockCounts.draft > 0}
+			<Badge small clickable color="indigo" onclick={() => diffDrawer?.open()}>
+				{dockCounts.draft} draft{dockCounts.draft === 1 ? '' : 's'}
+			</Badge>
+		{/if}
+		{#if dockCounts.deployed > 0}
+			<Badge small clickable color="green" onclick={() => diffDrawer?.open()}>
+				{dockCounts.deployed} deployed
+			</Badge>
+		{/if}
+		{#if deletionOnly && compareHref}
+			<!-- Deleted items have no dock row; the pending fork→parent removal is
+			     reviewed on the compare page, so keep that doorway on the bar. -->
+			<a
+				href={compareHref}
+				target="_blank"
+				rel="noopener noreferrer"
+				title="This chat's edits were deletions — review and promote them on the compare page"
+				class="inline-flex items-center gap-1 text-2xs font-medium text-accent hover:underline shrink-0"
+			>
+				Review deletions on compare page
+				<ExternalLink class="w-3 h-3" />
+			</a>
+		{/if}
+	</div>
+{/snippet}
+
+{#if committedId && isUnavailable}
+	<!-- Committed workspace is no longer in the user's list (deleted, archived,
+	     or access revoked). Surface an actionable banner: move the session
+	     to a still-valid workspace, or discard it (archive / delete). The
+	     chat input is disabled by SessionWrapper while this is shown. Shown even
+	     for an archived session — unarchiving in place can't help when the
+	     workspace is gone, so move/discard is the only real recovery path. -->
+	<div class="flex flex-col gap-2 py-2 px-3 text-xs border rounded-md bg-surface-tertiary">
+		<div class="flex flex-row items-start gap-2">
+			<GitPullRequestClosed class="w-4 h-4 shrink-0 text-tertiary mt-0.5" />
+			<div class="flex flex-col min-w-0 flex-1">
+				<span class="text-primary font-medium"
+					>The {committedIsFork ? 'fork' : 'workspace'} has been archived or deleted</span
+				>
+				<span class="text-2xs text-tertiary">
+					Move this session to another workspace, or discard it.
+					<span class="font-mono text-tertiary" title={committedId}>{committedId}</span>
+				</span>
+			</div>
+		</div>
+		<div class="flex flex-row items-center justify-end gap-1.5">
+			<WorkspaceFamilyPicker
+				onPick={(workspaceId) => onMove?.(workspaceId)}
+				onCreateFork={async (fork) => {
+					await onCreateForkAndMove?.(fork)
+				}}
+				createForkCaption="Created immediately and the session moved into it."
+			>
+				{#snippet trigger()}
+					<Button variant="default" unifiedSize="sm" startIcon={{ icon: MoveRight }}>
+						Move to workspace
+					</Button>
+				{/snippet}
+			</WorkspaceFamilyPicker>
+			<Button
+				variant="default"
+				unifiedSize="sm"
+				startIcon={{ icon: Archive }}
+				dropdownItems={[{ label: 'Delete', icon: Trash2, onClick: () => onDelete?.() }]}
+				onclick={() => onArchive?.()}
+			>
+				Archive
+			</Button>
+		</div>
+	</div>
+{:else if showBar && committedId}
+	<!-- The "Edits" bar: what the AI changed this session. Fork identity / sync
+	     status lives inside the modal, not here. -->
+	<div
+		class="flex flex-row items-center justify-between gap-2 py-2 px-3 text-xs border rounded-md bg-surface-tertiary"
+	>
+		<div class="flex items-center gap-1.5 min-w-0" title="Edited by the chat during this session">
+			<Pencil class="w-3.5 h-3.5 shrink-0 text-secondary" />
+			<span class="truncate text-secondary font-medium">Edits</span>
+		</div>
+		{@render dock()}
+	</div>
+{/if}
+
+<!-- Mounted independently of the bar: a transient dip of the dock counts to
+     zero (mid-refresh after a deploy) must not unmount an open drawer. -->
+{#if committedId && !isUnavailable}
+	<SessionDiffDrawer
+		bind:this={diffDrawer}
+		workspaceId={committedId}
+		{parentWorkspaceId}
+		chatId={session.chatId}
+		keys={mask}
+		onDataChanged={refreshDock}
+		onItemDeployed={(item) =>
+			void runtime?.manager.renameModifiedItem(item.draftKind, item.path, item.displayPath)}
+		onItemDiscarded={(item) => void runtime?.manager.removeModifiedItem(item.draftKind, item.path)}
+	/>
+{/if}
diff --git a/frontend/src/lib/components/sessions/SessionDiffDrawer.svelte b/frontend/src/lib/components/sessions/SessionDiffDrawer.svelte
new file mode 100644
index 0000000000..1a6692048c
--- /dev/null
+++ b/frontend/src/lib/components/sessions/SessionDiffDrawer.svelte
@@ -0,0 +1,107 @@
+<script lang="ts">
+	import WorkspaceDiffDrawer from './WorkspaceDiffDrawer.svelte'
+	import { ArrowRight, GitFork, Pencil } from 'lucide-svelte'
+	import { userWorkspaces } from '$lib/stores'
+	import { useSessionDeployModel } from './sessionDeployModel.svelte'
+	import type { DeployItem } from './sessionDeployModel'
+
+	// Session "Edits" drawer. Builds the deploy model over the session
+	// workspace's drafts and hands it to WorkspaceDiffDrawer, which renders the
+	// tree + scroll-through diff column. The parent workspace only informs the
+	// title identity and the compare-page link — deploys land in the session
+	// workspace itself.
+	let {
+		workspaceId,
+		parentWorkspaceId,
+		chatId,
+		keys,
+		onDataChanged,
+		onItemDeployed,
+		onItemDiscarded
+	}: {
+		workspaceId: string
+		parentWorkspaceId?: string
+		/** CHAT id (Session.chatId — the IndexedDB `chats` key, NOT the session id),
+		 *  threaded to the footer's compare-page link as `from_session`: the compare
+		 *  page resolves it via readChatModifiedItems to preselect this chat's edits. */
+		chatId?: string
+		keys?: Set<string>
+		/** Notified after a deploy/discard mutated workspace state, so the owner
+		 *  (session bar) can refresh its cached draft sources. */
+		onDataChanged?: () => void
+		/** Mask maintenance, forwarded to the deploy model (see its args' docs):
+		 *  a deploy moves the item's mask entry to its deployed path, a discard
+		 *  drops it. */
+		onItemDeployed?: (item: DeployItem) => void
+		onItemDiscarded?: (item: DeployItem) => void
+	} = $props()
+
+	const isFork = $derived(!!parentWorkspaceId)
+	const ws = $derived($userWorkspaces.find((w) => w.id === workspaceId))
+	const parentWs = $derived(
+		parentWorkspaceId ? $userWorkspaces.find((w) => w.id === parentWorkspaceId) : undefined
+	)
+
+	let inner: WorkspaceDiffDrawer | undefined = $state(undefined)
+
+	const model = useSessionDeployModel(() => ({
+		workspaceId,
+		mask: keys,
+		onDataChanged,
+		onItemDeployed,
+		onItemDiscarded
+	}))
+
+	// Editor URL for a row (every item lives in the session workspace).
+	function editUrlFor(item: DeployItem): string | undefined {
+		const ws = encodeURIComponent(workspaceId)
+		const path = item.path
+		if (item.deployKind === 'flow') return `/flows/edit/${path}?workspace=${ws}`
+		if (item.deployKind === 'script') return `/scripts/edit/${path}?workspace=${ws}`
+		if (item.deployKind === 'app') return `/apps/edit/${path}?workspace=${ws}`
+		if (item.deployKind === 'raw_app') return `/apps_raw/edit/${path}?workspace=${ws}`
+		return undefined
+	}
+
+	const title = 'Edited during session'
+
+	// Compare page = the batch/PR surface. The footer hands off THIS session's
+	// edits via `from_session`, so the compare page opens preselected.
+	const compareSessionHref = $derived(
+		`/forks/compare?workspace_id=${encodeURIComponent(workspaceId)}&mode=${isFork ? 'fork' : 'draft'}` +
+			(chatId ? `&from_session=${encodeURIComponent(chatId)}` : '')
+	)
+
+	export function open() {
+		inner?.open()
+	}
+</script>
+
+<WorkspaceDiffDrawer
+	bind:this={inner}
+	{model}
+	{title}
+	{editUrlFor}
+	{compareSessionHref}
+	workspaceLabel={ws?.name ?? workspaceId}
+>
+	{#snippet titleExtra()}
+		<div class="flex items-center gap-1.5 text-xs text-secondary min-w-0">
+			{#if isFork}
+				<GitFork class="w-3.5 h-3.5 shrink-0" />
+				<span class="font-medium truncate" title={ws?.name ?? workspaceId}>
+					{ws?.name ?? workspaceId}
+				</span>
+				<ArrowRight class="w-3 h-3 shrink-0 text-tertiary" />
+				<span class="font-medium truncate" title={parentWs?.name ?? parentWorkspaceId}>
+					{parentWs?.name ?? parentWorkspaceId}
+				</span>
+			{:else}
+				<Pencil class="w-3.5 h-3.5 shrink-0" />
+				<span class="font-medium truncate" title={ws?.name ?? workspaceId}>
+					{ws?.name ?? workspaceId}
+				</span>
+			{/if}
+		</div>
+	{/snippet}
+</WorkspaceDiffDrawer>
diff --git a/frontend/src/lib/components/sessions/SessionDraftBar.svelte b/frontend/src/lib/components/sessions/SessionDraftBar.svelte
deleted file mode 100644
index d23070151a..0000000000
--- a/frontend/src/lib/components/sessions/SessionDraftBar.svelte
+++ /dev/null
@@ -1,77 +0,0 @@
-<script lang="ts">
-	import { Pencil } from 'lucide-svelte'
-	import { Button } from '$lib/components/common'
-	import { goto } from '$lib/navigation'
-	import { sessionState, type Session } from './sessionState.svelte'
-	import { getRuntime } from './sessionRuntime.svelte'
-	import DraftDiffDrawer from './DraftDiffDrawer.svelte'
-	import SessionDiffButton from './SessionDiffButton.svelte'
-	import { useWorkspaceDrafts } from '$lib/workspaceDrafts.svelte'
-	import Tooltip from '$lib/components/meltComponents/Tooltip.svelte'
-
-	let { session }: { session: Session } = $props()
-
-	// Only meaningful once the session committed to a workspace (post first send).
-	// The Draft Count comes from the shared Workspace Drafts resource: it fetches
-	// on mount and whenever a Server-Draft mutation invalidates the workspace, so
-	// the count is fresh on every (re)open with no per-session caching.
-	const committedId = $derived(session.workspace_id)
-	const drafts = useWorkspaceDrafts(() => committedId)
-	const count = $derived(drafts.count)
-
-	// Deploys/saves from the Preview editor invalidate the workspace directly
-	// (ScriptEditorView / FlowEditorView / RawAppEditorView call
-	// invalidateWorkspaceDrafts). The chat itself can also deploy items, but
-	// those happen server-side and the frontend never sees the individual calls —
-	// so refresh on the same coarse signals the fork bar uses: the AI turn ending
-	// and the tab regaining visibility.
-	const runtime = $derived(getRuntime(session.id))
-
-	let wasLoading = $state(false)
-	$effect(() => {
-		const isLoading = runtime?.manager.loading ?? false
-		if (wasLoading && !isLoading) drafts.refresh()
-		wasLoading = isLoading
-	})
-
-	$effect(() => {
-		if (!committedId) return
-		function onVisibilityChange() {
-			if (document.visibilityState !== 'visible') return
-			if (sessionState.currentSessionId !== session.id) return
-			drafts.refresh()
-		}
-		document.addEventListener('visibilitychange', onVisibilityChange)
-		return () => document.removeEventListener('visibilitychange', onVisibilityChange)
-	})
-
-	let drawer: DraftDiffDrawer | undefined = $state(undefined)
-
-	function openReview() {
-		if (!committedId) return
-		goto(`/forks/compare?workspace_id=${encodeURIComponent(committedId)}&mode=draft`)
-	}
-</script>
-
-{#if committedId && count > 0}
-	<div
-		class="flex flex-row items-center justify-between gap-2 py-2 px-3 text-xs border rounded-md bg-surface-tertiary"
-	>
-		<div class="flex items-center gap-1.5 min-w-0">
-			<span class="inline-flex shrink-0"><Pencil class="w-3.5 h-3.5 text-secondary" /></span>
-			<Tooltip placement="top" class="truncate text-secondary">
-				{count} draft{count === 1 ? '' : 's'}
-				{#snippet text()}
-					Tracks all unsaved draft changes in this workspace — including edits made outside this
-					chat (e.g. in the editor), not only changes made by the assistant.
-				{/snippet}
-			</Tooltip>
-		</div>
-		<div class="flex items-center gap-1 shrink-0">
-			<SessionDiffButton {count} onclick={() => drawer?.open()} />
-			<Button variant="default" unifiedSize="xs" onclick={openReview}>Review</Button>
-		</div>
-	</div>
-
-	<DraftDiffDrawer bind:this={drawer} workspaceId={committedId} />
-{/if}
diff --git a/frontend/src/lib/components/sessions/SessionForkBar.svelte b/frontend/src/lib/components/sessions/SessionForkBar.svelte
deleted file mode 100644
index a0aafee456..0000000000
--- a/frontend/src/lib/components/sessions/SessionForkBar.svelte
+++ /dev/null
@@ -1,212 +0,0 @@
-<script lang="ts">
-	import {
-		Archive,
-		ArrowRight,
-		GitCompareArrows,
-		GitFork,
-		GitPullRequestArrow,
-		GitPullRequestClosed,
-		MoveRight,
-		Trash2
-	} from 'lucide-svelte'
-	import { Button } from '$lib/components/common'
-	import WorkspaceFamilyPicker from './WorkspaceFamilyPicker.svelte'
-	import { isPremiumStore, userStore, userWorkspaces, workspaceStore } from '$lib/stores'
-	import { goto } from '$lib/navigation'
-	import { canCreateFork } from '$lib/utils/editInFork'
-	import { isCloudHosted } from '$lib/cloud'
-	import { deriveForkStatus, sessionState, type Session } from './sessionState.svelte'
-	import { getRuntime } from './sessionRuntime.svelte'
-	import ForkDiffDrawer from './ForkDiffDrawer.svelte'
-	import SessionDiffButton from './SessionDiffButton.svelte'
-
-	let {
-		session,
-		onMove,
-		onCreateForkAndMove,
-		onArchive,
-		onDelete
-	}: {
-		session: Session
-		onMove?: (workspaceId: string) => void
-		onCreateForkAndMove?: (fork: {
-			parent_workspace_id: string
-			id: string
-			name: string
-		}) => void | Promise<void>
-		onArchive?: () => void
-		onDelete?: () => void
-	} = $props()
-
-	// The fork bar surfaces a committed workspace relationship — only
-	// visible after the session locked its workspace at first send. Drafts
-	// (workspace_id undefined) get nothing here.
-	const committedId = $derived(session.workspace_id)
-	const sessionWorkspace = $derived(
-		committedId ? $userWorkspaces.find((w) => w.id === committedId) : undefined
-	)
-	const parentWorkspaceId = $derived(sessionWorkspace?.parent_workspace_id ?? undefined)
-	const parentWorkspace = $derived(
-		parentWorkspaceId ? $userWorkspaces.find((w) => w.id === parentWorkspaceId) : undefined
-	)
-	const isFork = $derived(!!parentWorkspaceId)
-
-	// Same gate as the sidebar WorkspaceMenu / SessionWorkspaceBar.
-	// When forking isn't available the diff/review surface is moot. On cloud, forking is a
-	// premium-only feature (backend caps it per paid seat).
-	const forksAllowed = $derived(
-		(!isCloudHosted() || $isPremiumStore) &&
-			canCreateFork($userStore) &&
-			$workspaceStore !== 'admins'
-	)
-
-	let diffDrawer: ForkDiffDrawer | undefined = $state(undefined)
-
-	// Comparison data lives on the shared SessionRuntime resource so any
-	// future consumer (e.g. the diff drawer, a merge action) reads the
-	// same cache and can invalidate it after mutating the fork.
-	const runtime = $derived(getRuntime(session.id))
-	const comparison = $derived(runtime?.forkComparison.val)
-	const totalDiffs = $derived(comparison?.summary?.total_diffs ?? 0)
-	const forkStatus = $derived(deriveForkStatus(session, $userWorkspaces, comparison))
-	const isUnavailable = $derived(forkStatus === 'unavailable')
-
-	// The committed workspace is gone, so we can't read its parent to know if
-	// it was a fork — fall back to the fork-id convention for the wording.
-	const committedIsFork = $derived(committedId?.startsWith('wm-fork-') ?? false)
-
-	$effect(() => {
-		if (!runtime || !committedId || !parentWorkspaceId) return
-		void runtime.ensureForkComparison(parentWorkspaceId, committedId)
-	})
-
-	function refreshComparison() {
-		if (!runtime || !committedId || !parentWorkspaceId) return
-		runtime.invalidateForkComparison()
-		void runtime.ensureForkComparison(parentWorkspaceId, committedId)
-	}
-
-	// Refresh when the AI finishes a turn (loading transitions true →
-	// false). Tool calls in that turn may have created / edited / deleted
-	// fork items, so the diff count needs to reflect them immediately.
-	let wasLoading = $state(false)
-	$effect(() => {
-		const isLoading = runtime?.manager.loading ?? false
-		if (wasLoading && !isLoading) refreshComparison()
-		wasLoading = isLoading
-	})
-
-	// Refresh when the tab regains visibility — covers edits made in
-	// another tab or by another user while we were away.
-	$effect(() => {
-		if (!runtime || !committedId || !parentWorkspaceId) return
-		function onVisibilityChange() {
-			if (document.visibilityState !== 'visible') return
-			if (sessionState.currentSessionId !== session.id) return
-			refreshComparison()
-		}
-		document.addEventListener('visibilitychange', onVisibilityChange)
-		return () => document.removeEventListener('visibilitychange', onVisibilityChange)
-	})
-
-	export const refresh = refreshComparison
-
-	function openReview() {
-		if (!committedId || isUnavailable) return
-		goto(`/forks/compare?workspace_id=${encodeURIComponent(committedId)}`)
-	}
-</script>
-
-{#if committedId && isUnavailable}
-	<!-- Committed workspace is no longer in the user's list (deleted, archived,
-	     or access revoked). Surface an actionable banner: move the session
-	     to a still-valid workspace, or discard it (archive / delete). The
-	     chat input is disabled by SessionWrapper while this is shown. Shown even
-	     for an archived session — unarchiving in place can't help when the
-	     workspace is gone, so move/discard is the only real recovery path. -->
-	<div class="flex flex-col gap-2 py-2 px-3 text-xs border rounded-md bg-surface-tertiary">
-		<div class="flex flex-row items-start gap-2">
-			<GitPullRequestClosed class="w-4 h-4 shrink-0 text-tertiary mt-0.5" />
-			<div class="flex flex-col min-w-0 flex-1">
-				<span class="text-primary font-medium"
-					>The {committedIsFork ? 'fork' : 'workspace'} has been archived or deleted</span
-				>
-				<span class="text-2xs text-tertiary">
-					Move this session to another workspace, or discard it.
-					<span class="font-mono text-tertiary" title={committedId}>{committedId}</span>
-				</span>
-			</div>
-		</div>
-		<div class="flex flex-row items-center justify-end gap-1.5">
-			<WorkspaceFamilyPicker
-				onPick={(workspaceId) => onMove?.(workspaceId)}
-				onCreateFork={async (fork) => {
-					await onCreateForkAndMove?.(fork)
-				}}
-				createForkCaption="Created immediately and the session moved into it."
-			>
-				{#snippet trigger()}
-					<Button variant="default" unifiedSize="sm" startIcon={{ icon: MoveRight }}>
-						Move to workspace
-					</Button>
-				{/snippet}
-			</WorkspaceFamilyPicker>
-			<Button
-				variant="default"
-				unifiedSize="sm"
-				startIcon={{ icon: Archive }}
-				dropdownItems={[{ label: 'Delete', icon: Trash2, onClick: () => onDelete?.() }]}
-				onclick={() => onArchive?.()}
-			>
-				Archive
-			</Button>
-		</div>
-	</div>
-{:else if forksAllowed && isFork && sessionWorkspace && parentWorkspace && parentWorkspaceId && committedId}
-	{@const StatusIcon =
-		forkStatus === 'ahead'
-			? GitPullRequestArrow
-			: forkStatus === 'diverged'
-				? GitCompareArrows
-				: GitFork}
-	{@const statusColor =
-		forkStatus === 'ahead'
-			? 'text-blue-500'
-			: forkStatus === 'diverged'
-				? 'text-amber-500'
-				: 'text-secondary'}
-	{@const statusTitle =
-		forkStatus === 'ahead'
-			? 'Ahead of parent'
-			: forkStatus === 'diverged'
-				? 'Diverged from parent'
-				: forkStatus === 'in_sync'
-					? 'In sync with parent'
-					: 'Fork'}
-	<div
-		class="flex flex-row items-center justify-between gap-2 py-2 px-3 text-xs border rounded-md bg-surface-tertiary"
-	>
-		<div class="flex items-center gap-1.5 min-w-0">
-			<span title={statusTitle} class="inline-flex shrink-0">
-				<StatusIcon class="w-3.5 h-3.5 {statusColor}" />
-			</span>
-			<span class="truncate text-secondary" title={sessionWorkspace.name}>
-				{sessionWorkspace.name}
-			</span>
-			<ArrowRight class="w-3 h-3 shrink-0 text-tertiary" />
-			<span class="truncate text-secondary" title={parentWorkspace.name}>
-				{parentWorkspace.name}
-			</span>
-		</div>
-		<div class="flex items-center gap-1 shrink-0">
-			<SessionDiffButton
-				count={totalDiffs}
-				disabled={totalDiffs === 0}
-				onclick={() => diffDrawer?.open()}
-			/>
-			<Button variant="default" unifiedSize="xs" onclick={openReview}>Review</Button>
-		</div>
-	</div>
-
-	<ForkDiffDrawer bind:this={diffDrawer} forkWorkspaceId={committedId} {parentWorkspaceId} />
-{/if}
diff --git a/frontend/src/lib/components/sessions/SessionPicker.svelte b/frontend/src/lib/components/sessions/SessionPicker.svelte
index aad3de26c3..0342fd53e1 100644
--- a/frontend/src/lib/components/sessions/SessionPicker.svelte
+++ b/frontend/src/lib/components/sessions/SessionPicker.svelte
@@ -21,7 +21,6 @@
 	import { slide } from 'svelte/transition'
 	import {
 		createSession,
-		deriveForkStatus,
 		deleteSessionsForWorkspace,
 		isForkSession,
 		reconcileAfterWorkspaceChange,
@@ -53,15 +52,6 @@
 	import { sendUserToast } from '$lib/toast'
 	import { currentWorkspaceRootId, workspaceRootId } from './sessionScope.svelte'
 
-	// Look up the cached fork comparison for a session through its runtime
-	// (if any). The deriveForkStatus helper handles the "no runtime yet"
-	// and "comparison not loaded" cases by returning undefined; we render
-	// a neutral fork icon in that interim, then upgrade to the proper
-	// status icon once the comparison lands.
-	function forkStatusFor(session: Session) {
-		return deriveForkStatus(session, $userWorkspaces, getRuntime(session.id)?.forkComparison.val)
-	}
-
 	function isForkFor(session: Session): boolean {
 		return isForkSession(session, $userWorkspaces)
 	}
@@ -124,8 +114,8 @@
 	}
 
 	// Flat list passing the archive + scope filters. Grouping for display happens
-	// in `sessionGroups`; this flat view drives the runtime / fork-comparison
-	// effects, the unread total, and keyboard navigation.
+	// in `sessionGroups`; this flat view drives the runtime effect, the unread
+	// total, and keyboard navigation.
 	const visibleSessions = $derived(
 		sessionState.sessions.filter((s) => {
 			if (s.transient) return false
@@ -211,23 +201,6 @@
 		}
 	})
 
-	// Pre-fetch the fork comparison for every visible fork session so the
-	// sidebar icons reflect the right ahead/diverged state without
-	// requiring the user to click into each session. Cheap enough at
-	// typical session counts; falls back to a plain dot until the
-	// fetch lands.
-	$effect(() => {
-		if (sectionCollapsed.val) return
-		for (const session of visibleSessions) {
-			if (!session.workspace_id) continue
-			const ws = $userWorkspaces.find((w) => w.id === session.workspace_id)
-			if (!ws?.parent_workspace_id) continue
-			const rt = getRuntime(session.id)
-			if (!rt) continue
-			void rt.ensureForkComparison(ws.parent_workspace_id, session.workspace_id)
-		}
-	})
-
 	function isUnavailableFork(session: Session): boolean {
 		return !!session.workspace_id && !$userWorkspaces.find((w) => w.id === session.workspace_id)
 	}
@@ -241,10 +214,6 @@
 		if (!isUnavailableFork(session)) {
 			syncWorkspaceTo(session.workspace_id)
 		}
-		// Refresh the fork diff count — users typically click back into a
-		// session after editing items elsewhere in the SPA, where neither
-		// the visibility-change nor the AI-loading signal would fire.
-		void getRuntime(session.id)?.refreshForkComparison()
 		await goto(`/sessions?session_name=${encodeURIComponent(session.name)}`)
 		if (restoreFocus) {
 			// goto() resets focus to <body> — put it back on the active session button
@@ -436,7 +405,7 @@
 											<SessionStatusDot
 												{status}
 												isFork={isForkFor(session)}
-												forkStatus={forkStatusFor(session)}
+												unavailable={isUnavailableFork(session)}
 											/>
 											<span
 												class={twMerge(
@@ -587,7 +556,7 @@
 									<SessionStatusDot
 										{status}
 										isFork={isForkFor(session)}
-										forkStatus={forkStatusFor(session)}
+										unavailable={isUnavailableFork(session)}
 									/>
 									<!-- svelte-ignore a11y_autofocus -->
 									<input
@@ -619,7 +588,7 @@
 									<SessionStatusDot
 										{status}
 										isFork={isForkFor(session)}
-										forkStatus={forkStatusFor(session)}
+										unavailable={isUnavailableFork(session)}
 									/>
 									<span class="truncate flex-1">{session.summary ?? 'Untitled session'}</span>
 									{#if draft || unread > 0}
diff --git a/frontend/src/lib/components/sessions/SessionStatusDot.svelte b/frontend/src/lib/components/sessions/SessionStatusDot.svelte
index b47816ab19..35028c80cc 100644
--- a/frontend/src/lib/components/sessions/SessionStatusDot.svelte
+++ b/frontend/src/lib/components/sessions/SessionStatusDot.svelte
@@ -3,19 +3,16 @@
 		AlertCircle,
 		AlertTriangle,
 		Building,
-		GitCompareArrows,
 		GitFork,
-		GitPullRequestArrow,
 		GitPullRequestClosed
 	} from 'lucide-svelte'
 	import type { SessionChatStatus } from './sessionRuntime.svelte'
-	import type { ForkStatus } from './sessionState.svelte'
 
 	let {
 		status,
 		isFork,
-		forkStatus
-	}: { status: SessionChatStatus; isFork: boolean; forkStatus?: ForkStatus } = $props()
+		unavailable = false
+	}: { status: SessionChatStatus; isFork: boolean; unavailable?: boolean } = $props()
 
 	const statusTooltip: Record<SessionChatStatus, string> = {
 		idle: 'No chat activity',
@@ -26,13 +23,6 @@
 		error: 'Last message had an error'
 	}
 
-	const forkTooltip: Record<ForkStatus, string> = {
-		in_sync: 'Fork — in sync with parent',
-		ahead: 'Fork — ahead of parent',
-		diverged: 'Fork — diverged from parent',
-		unavailable: 'Fork — no longer available'
-	}
-
 	// Live chat signals take precedence over the persistent kind/fork
 	// indicator: streaming, needs-confirmation, and error are time-critical
 	// and warrant briefly hijacking the icon slot.
@@ -41,7 +31,11 @@
 	)
 
 	const persistentTitle = $derived(
-		isFork ? (forkStatus ? forkTooltip[forkStatus] : 'Fork session') : 'Root workspace session'
+		isFork
+			? unavailable
+				? 'Fork — no longer available'
+				: 'Fork session'
+			: 'Root workspace session'
 	)
 
 	const title = $derived(liveOverride ? statusTooltip[status] : persistentTitle)
@@ -59,11 +53,7 @@
 	{:else if status === 'error'}
 		<AlertTriangle class="w-3 h-3 text-red-500" />
 	{:else if isFork}
-		{#if forkStatus === 'ahead'}
-			<GitPullRequestArrow class="w-3 h-3 text-blue-500" />
-		{:else if forkStatus === 'diverged'}
-			<GitCompareArrows class="w-3 h-3 text-amber-500" />
-		{:else if forkStatus === 'unavailable'}
+		{#if unavailable}
 			<GitPullRequestClosed class="w-3 h-3 text-red-500" />
 		{:else}
 			<GitFork class="w-3 h-3 text-tertiary" />
diff --git a/frontend/src/lib/components/sessions/SessionWrapper.svelte b/frontend/src/lib/components/sessions/SessionWrapper.svelte
index c9fdb6454f..ee8cbed6e0 100644
--- a/frontend/src/lib/components/sessions/SessionWrapper.svelte
+++ b/frontend/src/lib/components/sessions/SessionWrapper.svelte
@@ -30,8 +30,7 @@
 	import RawAppEditorView from './RawAppEditorView.svelte'
 	import PipelineEditorView from './PipelineEditorView.svelte'
 	import SessionWorkspaceBar from './SessionWorkspaceBar.svelte'
-	import SessionForkBar from './SessionForkBar.svelte'
-	import SessionDraftBar from './SessionDraftBar.svelte'
+	import SessionChangesBar from './SessionChangesBar.svelte'
 	import {
 		createSession,
 		deleteSessionsForWorkspace,
@@ -235,7 +234,7 @@
 
 	// True when the session committed to a workspace that's no longer in
 	// the user's list (deleted / archived / access revoked). The chat is
-	// disabled and SessionForkBar shows a move/discard banner.
+	// disabled and SessionChangesBar shows a move/discard banner.
 	const isUnavailable = $derived(
 		!!session?.workspace_id && !$userWorkspaces.find((w) => w.id === session!.workspace_id)
 	)
@@ -274,16 +273,16 @@
 		{#if !hasFirstUserMessage}
 			<SessionWorkspaceBar {session} />
 		{/if}
-		<!-- gap-1 (4px) spaces the fork bar and draft bar when both are visible.
-		     Each bar renders a single in-flow root (or nothing); the draft drawer
-		     is position:fixed, so it doesn't count as a flex item — no stray gap
-		     when only one bar shows. -->
+		<!-- gap-1 (4px) spaces the archived banner and the changes bar when both
+		     are visible. Each renders a single in-flow root (or nothing); the diff
+		     drawer is position:fixed, so it doesn't count as a flex item — no stray
+		     gap when only one shows. -->
 		<div class="flex flex-col gap-1">
 			{#if session.archived && !isUnavailable}
 				<!-- Unarchive is only meaningful when the workspace is still live:
 				     putSession refuses to resurrect a session whose workspace is gone,
 				     and reconcile would re-archive a workspace-archived one anyway. When
-				     the workspace is unavailable the SessionForkBar below shows the
+				     the workspace is unavailable the SessionChangesBar below shows the
 				     move/discard banner instead (its actions are the real recovery path). -->
 				<div
 					class="flex flex-row items-center justify-between gap-2 py-2 px-3 text-xs border rounded-md bg-surface-tertiary"
@@ -302,14 +301,13 @@
 					</Button>
 				</div>
 			{/if}
-			<SessionForkBar
+			<SessionChangesBar
 				{session}
 				onMove={(workspaceId) => moveAndActivate(workspaceId)}
 				onCreateForkAndMove={(fork) => createForkAndMove(fork)}
 				onArchive={() => archiveAndReset()}
 				onDelete={() => (deleteConfirmOpen = true)}
 			/>
-			<SessionDraftBar {session} />
 		</div>
 	{/snippet}
 
diff --git a/frontend/src/lib/components/sessions/WorkspaceDiffDrawer.svelte b/frontend/src/lib/components/sessions/WorkspaceDiffDrawer.svelte
index e6b4e5fd2f..50c6653b0a 100644
--- a/frontend/src/lib/components/sessions/WorkspaceDiffDrawer.svelte
+++ b/frontend/src/lib/components/sessions/WorkspaceDiffDrawer.svelte
@@ -1,45 +1,19 @@
-<script lang="ts" module>
-	export type DiffStatus = 'added' | 'removed' | 'modified' | 'conflict'
-	// One changed item. `status` drives the dot/badge; `ahead`/`behind` are
-	// optional (fork-only) and only render when present.
-	export type DiffRow = {
-		kind: string
-		path: string
-		status: DiffStatus
-		ahead?: number
-		behind?: number
-		/** Human-facing path; defaults to `path`. Lets a draft parked at a
-		 * synthetic storage path (`…/draft_<uuid>`) show its friendly typed path
-		 * while keys, value-loading and edit links stay keyed on `path`. */
-		displayPath?: string
-		/** Summary supplied by the data source. Preferred over the one derived
-		 * from the loaded diff value, and shown before that value loads. */
-		summary?: string
-		/** Explicit unique row identity, overriding the default `kind/path`. For a
-		 * row whose `kind/path` isn't unique on its own (a pipeline-bundle node
-		 * shares `script/<path>` with a standalone script draft at the same path)
-		 * while `path` must stay the real edit/display target. */
-		key?: string
-	}
-</script>
-
 <script lang="ts">
-	import { buildDiffTree, type AppRootMeta, type TreeNode } from './diffTree'
+	import { buildDiffTree, folderKeyFor, type AppRootMeta, type TreeNode } from './diffTree'
 	import { Button, Drawer, DrawerContent } from '$lib/components/common'
 	import Badge from '$lib/components/common/badge/Badge.svelte'
 	import {
 		AlertTriangle,
+		Check,
+		CheckCircle2,
 		ChevronDown,
 		ChevronRight,
+		ExternalLink,
 		Folder,
-		GitMerge,
 		Loader2,
-		Minus,
-		Pencil,
-		Plus,
+		Save,
 		User
 	} from 'lucide-svelte'
-	import { goto } from '$lib/navigation'
 	import RowIcon from '$lib/components/common/table/RowIcon.svelte'
 	import WorkspaceItemRow from '$lib/components/WorkspaceItemRow.svelte'
 	import WorkspaceItemDiffViewer from '$lib/components/WorkspaceItemDiffViewer.svelte'
@@ -47,44 +21,52 @@
 		rawAppDiffToItems,
 		type RawAppish,
 		type RawAppFileItem,
-		type RawAppRunnableItem
+		type RawAppRunnableItem,
+		type RawAppSyntheticItem
 	} from '$lib/components/raw_apps/rawAppDiffUtils'
 	import SearchItems from '$lib/components/SearchItems.svelte'
 	import ToggleButtonGroup from '$lib/components/common/toggleButton-v2/ToggleButtonGroup.svelte'
 	import ToggleButton from '$lib/components/common/toggleButton-v2/ToggleButton.svelte'
 	import { DiffIcon, SquareSplitHorizontal } from 'lucide-svelte'
-	import { untrack, type Snippet } from 'svelte'
+	import { tick, untrack } from 'svelte'
+	import { fade, fly, slide } from 'svelte/transition'
+	import { cubicOut } from 'svelte/easing'
+	import type { Snippet } from 'svelte'
+	import ConfirmationModal from '$lib/components/common/confirmationModal/ConfirmationModal.svelte'
+	import { createAsyncConfirmationModal } from '$lib/components/common/confirmationModal/asyncConfirmationModal.svelte'
 	import ExternalEditLink from '../ExternalEditLink.svelte'
+	import Popover from '$lib/components/meltComponents/Popover.svelte'
+	import { actionFor, badgeOf, type DeployItem } from './sessionDeployModel'
+	import { maskKey } from './modifiedItemsMask'
+	import type { SessionDeployModel, DiffValues } from './sessionDeployModel.svelte'
 
-	// Read-only, multi-item before/after diff viewer with a file tree. The data
-	// source (fork comparison vs deployed-vs-draft) is supplied by the parent
-	// wrapper via `diffs` + `loadValues`; everything here is generic rendering.
+	// The session "Edits" surface. Reads a unified item model (the session's
+	// drafts, scoped to what this session edited) and renders a folder tree
+	// (left) plus a scroll-through diff column with per-block sticky headers
+	// (right). Deploy is granular per-item; batch/PR flows and fork→parent
+	// promotion are handed to the compare page via the footer link.
 	let {
-		diffs,
-		loadValues,
-		loading = false,
-		error = undefined,
-		notice = undefined,
-		emptyMessage = 'No changes.',
+		model,
 		title,
-		reviewHref,
-		reviewLabel = 'Review',
 		editUrlFor = undefined,
-		titleExtra
+		titleExtra,
+		compareSessionHref,
+		workspaceLabel,
+		successHoldMs = 1200
 	}: {
-		diffs: DiffRow[]
-		loadValues: (d: DiffRow) => Promise<{ before: unknown; after: unknown }>
-		loading?: boolean
-		error?: string | undefined
-		/** Replaces the diff list with an informational message (e.g. fork
-		 * created before change tracking). */
-		notice?: string | undefined
-		emptyMessage?: string
+		model: SessionDeployModel
 		title: string
-		reviewHref: string
-		reviewLabel?: string
-		editUrlFor?: (d: DiffRow) => string | undefined
+		/** Editor URL for a row (opens in the workspace the item lives in). */
+		editUrlFor?: (item: DeployItem) => string | undefined
 		titleExtra?: Snippet
+		/** Display name of the workspace deploys land in — the deployed tick's
+		 *  hover reads "Deployed in <label>". */
+		workspaceLabel?: string
+		/** How long the post-deploy check beat holds before the row flips. */
+		successHoldMs?: number
+		/** Compare page for this session's edits (footer) — preselected via
+		 *  `from_session`. Where "deploy all / request review" happens. */
+		compareSessionHref?: string
 	} = $props()
 
 	let drawer: Drawer | undefined = $state(undefined)
@@ -92,115 +74,123 @@
 	let diffStyle = $state<'sbs' | 'inline'>('sbs')
 	const inlineDiff = $derived(diffStyle === 'inline')
 
+	// The sidebar's inner right padding must ADAPT to the reserved scrollbar
+	// gutter (platform-dependent: 0 for overlay scrollbars, ~15px classic) so
+	// gutter + padding always totals the same 6px inset the left side uses.
+	// Pure CSS can't express "6px minus the gutter", hence the measurement.
+	function padRightForGutter(node: HTMLElement) {
+		const apply = () => {
+			const gutter = node.offsetWidth - node.clientWidth
+			node.style.paddingRight = `${Math.max(0, 6 - gutter)}px`
+		}
+		apply()
+		const ro = new ResizeObserver(apply)
+		ro.observe(node)
+		return { destroy: () => ro.disconnect() }
+	}
+
+	// Discard is destructive (a draft-only item disappears entirely) — confirm.
+	const discardConfirm = createAsyncConfirmationModal()
+	async function confirmDiscard(item: DeployItem) {
+		const confirmed = await discardConfirm.ask({
+			title: 'Discard draft?',
+			confirmationText: 'Discard draft',
+			children: item.draftOnly
+				? `${item.displayPath} was never deployed — discarding its draft deletes it entirely.`
+				: `The draft changes on ${item.displayPath} will be permanently discarded; the deployed version is kept.`
+		})
+		if (confirmed) void model.discardRow(item)
+	}
+
+	// Post-deploy staging (same pattern as SaveButton): on success, the row keeps
+	// rendering its pre-deploy snapshot while a green check flies in over the
+	// Deploy button; after the hold it releases, letting the collapse + badge
+	// transitions play on the real (deployed) state.
+	let staged = $state<Record<string, DeployItem>>({})
+	let stagedTimers: ReturnType<typeof setTimeout>[] = []
+	$effect(() => {
+		return () => stagedTimers.forEach(clearTimeout)
+	})
+	async function deployStaged(item: DeployItem) {
+		if (!(await model.deployRow(item))) return
+		// The deploy can re-key the row before this renders: a draft-only (or
+		// renamed) item deploys to its displayPath and the mask entry moves with
+		// it. Stage the snapshot under both keys so the re-keyed card still
+		// renders the held check beat instead of skipping straight to done.
+		const keys = [item.key, maskKey(item.draftKind, item.displayPath)]
+		const next = { ...staged }
+		for (const k of keys) next[k] = item
+		staged = next
+		stagedTimers.push(
+			setTimeout(() => {
+				const after = { ...staged }
+				for (const k of keys) delete after[k]
+				staged = after
+			}, successHoldMs)
+		)
+	}
+
 	export function open() {
-		// Reset per-item caches so an edit-then-reopen doesn't show stale
-		// expanded content. The wrapper re-fetches `diffs`, which re-triggers
-		// the eager-load effect below.
 		loadedDiffs = {}
-		summaries = {}
 		mountedRows = {}
+		folderOpen = {}
+		staged = {}
+		model.load()
 		drawer?.openDrawer()
 		setTimeout(() => searchInputEl?.focus(), 50)
 	}
 
-	// A row in the list is either a real backend diff or a synthesized raw-app
-	// item: a file/metadata leaf (`RawAppFileItem`) or a runnable rendered as a
-	// script/flow (`RawAppRunnableItem`). All are diff-shaped, so the tree /
-	// search / count / nav operate over `DisplayDiff` uniformly.
-	type DisplayDiff = DiffRow | RawAppFileItem | RawAppRunnableItem
+	// ── Badge presentation ─────────────────────────────────────────────────────
+	// One footprint for both status pills (draft / deployed) so they line up at a
+	// compact, uniform size.
+	const STATUS_BADGE_CLASS = 'px-1.5 py-0.5 gap-0.5 text-2xs'
 
-	function itemKey(d: DisplayDiff): string {
-		// Synthetic raw-app items (files/runnables) carry their composite
-		// `<appPath>/…` path and can share kind+path with a real workspace item —
-		// e.g. a runnable rendered as `script` at `<appPath>/runnables/foo` vs a real
-		// script literally at that path. Prefix synthetic items so the {#each} key,
-		// load cache, row id and nav identity never collide with a real DiffRow.
-		if ('key' in d && d.key) return d.key
-		return ('appPath' in d ? 'rawapp:' : '') + `${d.kind}/${d.path}`
+	// ── Rendered list: all session items, then text-searched (no filter tabs) ──
+	const segmentItems = $derived(model.items)
+
+	// A tree row is either a real deploy item or — once its raw app's values
+	// have loaded — a synthetic per-file/per-runnable item: the app's leaf row
+	// is replaced by its files, and the folder at the app's path becomes the app
+	// root (tagged via appRootMeta). Synthetics carry `appPath`.
+	type DisplayEntry = DeployItem | RawAppSyntheticItem
+	function isSynthetic(e: DisplayEntry): e is RawAppSyntheticItem {
+		return 'appPath' in e
+	}
+	// Synthetic keys are prefixed so they can't collide with a real item that
+	// happens to live at `<appPath>/runnables/foo`.
+	function displayKey(e: DisplayEntry): string {
+		return isSynthetic(e) ? `rawapp:${e.kind}/${e.path}` : e.key
+	}
+	function displayPathOf(e: DisplayEntry): string {
+		return e.displayPath ?? e.path
 	}
 
-	// Friendly path for display only; `path` stays the storage key everywhere
-	// keys/loads happen, so a never-deployed draft still loads from `…/draft_<uuid>`.
-	function displayPathOf(d: DisplayDiff): string {
-		return ('displayPath' in d ? d.displayPath : undefined) ?? d.path
-	}
+	// Raw-app storage path → its deploy item (owning-app lookup for synthetics).
+	const appByPath = $derived(
+		new Map(segmentItems.filter((d) => d.deployKind === 'raw_app').map((d) => [d.path, d]))
+	)
 
-	const KIND_LABELS: Record<string, string> = {
-		script: 'Script',
-		flow: 'Flow',
-		app: 'App',
-		raw_app: 'Raw app',
-		raw_app_file: 'File',
-		resource: 'Resource',
-		variable: 'Variable',
-		resource_type: 'Resource type',
-		folder: 'Folder',
-		schedule: 'Schedule',
-		http_trigger: 'HTTP route',
-		websocket_trigger: 'Websocket trigger',
-		kafka_trigger: 'Kafka trigger',
-		nats_trigger: 'NATS trigger',
-		postgres_trigger: 'Postgres trigger',
-		mqtt_trigger: 'MQTT trigger',
-		sqs_trigger: 'SQS trigger',
-		gcp_trigger: 'GCP trigger',
-		azure_trigger: 'Azure trigger',
-		email_trigger: 'Email trigger'
-	}
-
-	type LoadedDiff = {
-		state: 'loading' | 'ready' | 'error'
-		error?: string
-		before?: unknown
-		after?: unknown
-	}
-	let loadedDiffs: Record<string, LoadedDiff> = $state({})
-	let summaries: Record<string, string | undefined> = $state({})
-
-	// Lazy Monaco mount: exploding a raw app into N per-file rows would otherwise
-	// mount N DiffEditors at once. Each row's editor mounts only once its block
-	// scrolls within `MOUNT_MARGIN` of the viewport (rooted on the scroll
-	// container); `mountedRows` latches true so it never unmounts on scroll-away.
-	let mainScrollEl: HTMLElement | undefined = $state()
-	let mountedRows: Record<string, boolean> = $state({})
-	// Small look-ahead only: a large margin would catch the whole (collapsed-
-	// height) list at once, and each mount growing its block would cascade the
-	// rest into view. A modest margin mounts what's near the fold; as editors
-	// grow they push the pending blocks away, so the rest stay deferred.
-	const MOUNT_MARGIN = '200px 0px'
-	function lazyMount(node: HTMLElement, key: string) {
-		const io = new IntersectionObserver(
-			(entries) => {
-				if (entries.some((e) => e.isIntersecting)) {
-					mountedRows[key] = true
-					io.disconnect()
-				}
-			},
-			{ root: mainScrollEl ?? null, rootMargin: MOUNT_MARGIN }
-		)
-		io.observe(node)
-		return { destroy: () => io.disconnect() }
-	}
-
-	// The rendered list: each raw_app whose value has loaded is expanded into
-	// its per-file items (so files are independent rows that flow through the
-	// tree / search / count). An unloaded raw_app stays a single placeholder row
-	// until its value arrives, then expands in place.
-	const displayDiffs = $derived.by(() => {
-		const out: DisplayDiff[] = []
-		for (const d of diffs) {
-			if (d.kind === 'raw_app') {
-				const loaded = loadedDiffs[itemKey(d)]
+	const displayEntries = $derived.by(() => {
+		const out: DisplayEntry[] = []
+		for (const d of segmentItems) {
+			if (d.deployKind === 'raw_app') {
+				const loaded = loadedDiffs[d.key]
 				if (loaded?.state === 'ready') {
-					out.push(
-						...rawAppDiffToItems(
-							d.path,
-							loaded.before as RawAppish | undefined,
-							loaded.after as RawAppish | undefined,
-							displayPathOf(d)
-						)
-					)
-					continue
+					// A deployed (done) app has no changed files to diff — unwrap it
+					// into its full current contents instead (one-sided → every file
+					// listed; rows are plain so the 'added' status never shows).
+					const subs = d.done
+						? rawAppDiffToItems(
+								d.path,
+								undefined,
+								loaded.after as RawAppish | undefined,
+								d.displayPath
+							)
+						: rawAppItems(d, loaded)
+					if (subs.length > 0) {
+						out.push(...subs)
+						continue
+					}
 				}
 			}
 			out.push(d)
@@ -208,110 +198,174 @@
 		return out
 	})
 
-	async function loadDiffFor(d: DiffRow) {
-		const key = itemKey(d)
-		if (loadedDiffs[key]) return
-		loadedDiffs[key] = { state: 'loading' }
-		try {
-			const { before, after } = await loadValues(d)
-			loadedDiffs[key] = { state: 'ready', before, after }
-			const summary =
-				(after && typeof after === 'object' && (after as any).summary) ||
-				(before && typeof before === 'object' && (before as any).summary) ||
-				undefined
-			if (typeof summary === 'string' && summary.trim().length > 0) {
-				summaries[key] = summary
-			}
-		} catch (e) {
-			console.error('WorkspaceDiffDrawer: loadValues failed', d, e)
-			loadedDiffs[key] = { state: 'error', error: String(e) }
-		}
+	function searchableText(e: DisplayEntry): string {
+		if (isSynthetic(e)) return [displayPathOf(e), e.kind].join(' ')
+		return [e.displayPath, e.deployKind, e.summary ?? ''].join(' ')
 	}
+	let searchedEntries: (DisplayEntry & { marked?: string })[] | undefined = $state(undefined)
+	const searchActive = $derived(searchQuery.trim().length > 0)
+	const filteredEntries = $derived.by(() => {
+		if (!searchActive) return displayEntries
+		return (searchedEntries ?? []) as DisplayEntry[]
+	})
 
-	// Eagerly load each row (diffs render expanded). Tracks `diffs` only; the
-	// cache reads/writes are untracked so this doesn't loop on itself.
+	// File names inside unexpanded apps don't exist client-side until the app's
+	// values load — a live search loads every raw app so matches are complete.
 	$effect(() => {
-		const ds = diffs
+		if (!searchActive) return
+		const items = segmentItems
 		untrack(() => {
-			for (const d of ds) void loadDiffFor(d)
+			for (const d of items) if (d.deployKind === 'raw_app') void loadDiffFor(d)
 		})
 	})
 
-	function onDetailsToggle(d: DisplayDiff, e: Event) {
-		// Synthetic raw-app items (files + runnables) carry their content
-		// already — nothing to fetch.
-		if ('appPath' in d) return
-		const target = e.currentTarget as HTMLDetailsElement | null
-		if (target?.open) void loadDiffFor(d)
-	}
-
-	function statusBadgeColor(s: DiffStatus): 'green' | 'red' | 'orange' | 'blue' {
-		if (s === 'added') return 'green'
-		if (s === 'removed') return 'red'
-		if (s === 'conflict') return 'orange'
-		return 'blue'
-	}
-
-	const statusIcons = { added: Plus, removed: Minus, modified: Pencil, conflict: AlertTriangle }
-
-	// ── File tree ───────────────────────────────────────────────────────────
-	// Friendly app path → app metadata, for tagging the matching tree folder as a
-	// raw-app root. Keyed on `displayPathOf` so it lines up with the friendly
-	// virtual paths the synthetic file items carry.
+	// ── Tree ─────────────────────────────────────────────────────────────────
 	const appRootMeta = $derived.by(() => {
 		const m = new Map<string, AppRootMeta>()
-		for (const d of diffs) {
-			if (d.kind !== 'raw_app') continue
-			m.set(displayPathOf(d), {
-				summaryKey: itemKey(d),
-				summary: 'summary' in d ? d.summary : undefined
+		for (const it of model.items) {
+			if (it.deployKind !== 'raw_app') continue
+			m.set(it.displayPath, {
+				summaryKey: it.key,
+				summary: it.summary,
+				hasDraft: it.hasDraft,
+				draftOnly: it.draftOnly,
+				draftUsers: it.draftUsers,
+				draftItemKind: it.draftKind
 			})
 		}
 		return m
 	})
 
-	function searchableText(d: DisplayDiff): string {
-		const parts = [displayPathOf(d), KIND_LABELS[d.kind] ?? d.kind]
-		const s = summaries[itemKey(d)] ?? ('summary' in d ? d.summary : undefined)
-		if (s) parts.push(s)
-		return parts.join(' ')
-	}
-	let searchedDiffs: (DisplayDiff & { marked?: string })[] | undefined = $state(undefined)
-
-	const filteredDiffs = $derived.by(() => {
-		const q = searchQuery.trim()
-		if (!q) return displayDiffs
-		return (searchedDiffs ?? []) as DisplayDiff[]
-	})
-
 	const treeModel = $derived(
 		buildDiffTree(
-			filteredDiffs.map((d) => ({ key: itemKey(d), structurePath: displayPathOf(d), data: d })),
+			filteredEntries.map((e) => ({
+				key: displayKey(e),
+				structurePath: displayPathOf(e),
+				data: e
+			})),
 			appRootMeta
 		)
 	)
 
-	function rowId(d: DisplayDiff): string {
-		return `ws-diff-${itemKey(d)}`
+	// Content blocks follow the sidebar's order: walk the tree (all folders open,
+	// so collapsing the sidebar never hides a block) and emit each owning deploy
+	// item once, so the diff column top-to-bottom matches the tree.
+	const orderedItems = $derived.by(() => {
+		const seen = new Set<string>()
+		const out: DeployItem[] = []
+		for (const entry of treeModel.order(() => true)) {
+			if (entry.type !== 'file') continue
+			const item = isSynthetic(entry.data) ? appByPath.get(entry.data.appPath) : entry.data
+			if (item && !seen.has(item.key)) {
+				seen.add(item.key)
+				out.push(item)
+			}
+		}
+		return out
+	})
+
+	function rowId(d: DeployItem): string {
+		return `ws-diff-${d.key}`
 	}
 
-	function scrollToDiff(d: DisplayDiff) {
-		const el = document.getElementById(rowId(d)) as HTMLDetailsElement | null
-		if (!el) return
-		el.open = true
-		el.scrollIntoView({ behavior: 'smooth', block: 'start' })
+	// Keep the column's pt-3 breathing room when a click scrolls a card to the top.
+	const SCROLL_TOP_INSET = 12
+
+	// Smooth-scroll the row's card near the top (leaving the column's top inset).
+	// Native scrollIntoView lands short here because lazily-mounted diffs grow the
+	// list mid-scroll; instead we ease toward the target and re-measure it every
+	// frame, so the animation stays smooth while still landing flush once the
+	// layout settles. Bails on user scroll.
+	function scrollToDiff(d: DeployItem) {
+		const el = document.getElementById(rowId(d))
+		const container = mainScrollEl
+		if (!el || !container) return
+		let frames = 0
+		let settled = 0
+		let cancelled = false
+		const cancel = () => (cancelled = true)
+		container.addEventListener('wheel', cancel, { once: true, passive: true })
+		container.addEventListener('touchstart', cancel, { once: true, passive: true })
+		const teardown = () => {
+			container.removeEventListener('wheel', cancel)
+			container.removeEventListener('touchstart', cancel)
+		}
+		const step = () => {
+			if (cancelled) return teardown()
+			const off =
+				el.getBoundingClientRect().top - container.getBoundingClientRect().top - SCROLL_TOP_INSET
+			if (Math.abs(off) < 1) {
+				if (++settled >= 2) return teardown()
+			} else {
+				settled = 0
+				// Ease-out for the long haul; snap the final approach so it settles fast.
+				container.scrollTop += Math.abs(off) < 20 ? off : Math.round(off * 0.22)
+			}
+			if (frames++ < 120) requestAnimationFrame(step)
+			else teardown()
+		}
+		step()
 	}
 
-	// ── Keyboard nav (matches WorkspaceItemDrillPicker) ─────────────────────
+	// Transient ring pulse on the card a tree click just revealed, so the eye
+	// lands on the right block after the scroll.
+	let flashKey = $state<string | undefined>(undefined)
+	let flashTimer: ReturnType<typeof setTimeout> | undefined
+	function flashRow(key: string) {
+		flashKey = key
+		clearTimeout(flashTimer)
+		flashTimer = setTimeout(() => (flashKey = undefined), 800)
+	}
+
+	function revealDiff(d: DeployItem, key?: string) {
+		if (key) highlightedKey = key
+		flashRow(d.key)
+		scrollToDiff(d)
+	}
+
+	// A file's sub-diff anchor lives inside the app's main-panel block, which
+	// mounts lazily on scroll — force-mount it before scrolling to the anchor.
+	// A deployed app's block has no per-file sections ("no pending changes"), so
+	// fall back to the app block itself.
+	async function revealSynthetic(s: RawAppSyntheticItem, key?: string) {
+		if (key) highlightedKey = key
+		const app = appByPath.get(s.appPath)
+		if (!app) return
+		flashRow(app.key)
+		if (!mountedRows[app.key]) {
+			mountedRows[app.key] = true
+			await tick()
+		}
+		const target =
+			document.getElementById(`ws-diff-${displayKey(s)}`) ?? document.getElementById(rowId(app))
+		target?.scrollIntoView({ behavior: 'smooth', block: 'start' })
+	}
+
+	// ── Keyboard nav ─────────────────────────────────────────────────────────
 	let folderOpen: Record<string, boolean> = $state({})
+	// Folders default open, raw-app roots default collapsed; a live search
+	// forces everything open so matches inside apps are visible.
+	const appFolderKeys = $derived(new Set([...appRootMeta.keys()].map((p) => folderKeyFor(p))))
 	function isFolderOpen(key: string): boolean {
-		return folderOpen[key] ?? true
+		if (searchActive) return true
+		return folderOpen[key] ?? !appFolderKeys.has(key)
 	}
 
+	// Expand a still-unloaded raw app from its leaf row: mark the future app
+	// folder open and fetch the values; once ready, the leaf is replaced by the
+	// app root + file children. Re-expanding after a failure retries the load.
+	function expandApp(d: DeployItem) {
+		const fkey = folderKeyFor(d.displayPath)
+		folderOpen[fkey] = true
+		if (loadedDiffs[d.key]?.state === 'error') delete loadedDiffs[d.key]
+		const wasHighlighted = highlightedKey === d.key
+		void loadDiffFor(d).then(() => {
+			if (wasHighlighted) highlightedKey = fkey
+		})
+	}
 	const navEntries = $derived(treeModel.order((k) => isFolderOpen(k)))
 	const navKeys = $derived(navEntries.map((e) => e.key))
 	const entryByKey = $derived(new Map(navEntries.map((e) => [e.key, e])))
-
 	let highlightedKey: string | undefined = $state(undefined)
 	let mouseActive = $state(false)
 	let searchInputEl: HTMLInputElement | undefined = $state()
@@ -319,49 +373,46 @@
 
 	$effect(() => {
 		if (navKeys.length === 0) return
-		if (!highlightedKey || !navKeys.includes(highlightedKey)) {
-			highlightedKey = navKeys[0]
-		}
+		if (!highlightedKey || !navKeys.includes(highlightedKey)) highlightedKey = navKeys[0]
 	})
-
 	function scrollHighlightIntoView() {
 		if (!sidebarRoot || !highlightedKey) return
-		const el = sidebarRoot.querySelector<HTMLElement>(
-			`[data-nav-key="${CSS.escape(highlightedKey)}"]`
-		)
-		el?.scrollIntoView({ block: 'nearest', behavior: 'smooth' })
+		sidebarRoot
+			.querySelector<HTMLElement>(`[data-nav-key="${CSS.escape(highlightedKey)}"]`)
+			?.scrollIntoView({ block: 'nearest', behavior: 'smooth' })
 	}
-
 	function moveHighlight(delta: 1 | -1) {
 		if (navKeys.length === 0) return
 		const cur = navKeys.indexOf(highlightedKey ?? '')
-		const next = cur < 0 ? 0 : (cur + delta + navKeys.length) % navKeys.length
-		highlightedKey = navKeys[next]
+		highlightedKey = navKeys[cur < 0 ? 0 : (cur + delta + navKeys.length) % navKeys.length]
 		mouseActive = false
 		requestAnimationFrame(scrollHighlightIntoView)
 	}
-
 	function setHoverHighlight(key: string) {
 		if (mouseActive) highlightedKey = key
 	}
-
 	function activateHighlighted() {
 		if (!highlightedKey) return
 		const entry = entryByKey.get(highlightedKey)
 		if (!entry) return
 		if (entry.type === 'file') {
-			scrollToDiff(entry.data)
-		} else {
-			folderOpen[entry.key] = !isFolderOpen(entry.key)
+			if (isSynthetic(entry.data)) void revealSynthetic(entry.data)
+			else void revealDiff(entry.data)
+			return
 		}
+		// App roots activate like rows (reveal the diff); folding stays on the
+		// chevron / ArrowRight. Plain folders keep Enter-to-toggle.
+		const appItem = entry.node.app
+			? segmentItems.find((d) => d.key === entry.node.app?.summaryKey)
+			: undefined
+		if (appItem) revealDiff(appItem)
+		else folderOpen[entry.key] = !isFolderOpen(entry.key)
 	}
-
 	function selectKey(key: string) {
 		highlightedKey = key
 		mouseActive = false
 		requestAnimationFrame(scrollHighlightIntoView)
 	}
-
 	function handleSearchKeydown(e: KeyboardEvent) {
 		if (e.key === 'ArrowDown') {
 			e.preventDefault()
@@ -374,7 +425,15 @@
 			activateHighlighted()
 		} else if (e.key === 'ArrowRight') {
 			const entry = highlightedKey ? entryByKey.get(highlightedKey) : undefined
-			if (!entry || entry.type !== 'folder') return
+			if (!entry) return
+			if (entry.type === 'file') {
+				// An unloaded raw app is still a leaf — ArrowRight expands it.
+				if (!isSynthetic(entry.data) && entry.data.deployKind === 'raw_app') {
+					e.preventDefault()
+					expandApp(entry.data)
+				}
+				return
+			}
 			if (!isFolderOpen(entry.key)) {
 				e.preventDefault()
 				folderOpen[entry.key] = true
@@ -400,16 +459,153 @@
 			}
 		}
 	}
+
+	// ── Diff values (lazy Monaco mount, one resolver via the model) ──────────
+	type LoadedDiff = {
+		state: 'loading' | 'ready' | 'error'
+		error?: string
+		before?: unknown
+		after?: unknown
+	}
+	let loadedDiffs: Record<string, LoadedDiff> = $state({})
+	let mainScrollEl: HTMLElement | undefined = $state()
+	// Visible height of the scroll area, used to size the trailing spacer so the
+	// last item can always be scrolled until its header reaches the top.
+	let mainHeight = $state(0)
+	// The trailing spacer only needs to cover the gap the last item can't fill on
+	// its own: viewport − lastItemHeight (0 when the item already fills the view).
+	// Reserving the full viewport would let you scroll a whole item-height into
+	// blank space past the end. A ResizeObserver keeps it right as the row grows.
+	let lastRowHeight = $state(0)
+	$effect(() => {
+		const last = orderedItems.at(-1)
+		const el = last && mainScrollEl ? document.getElementById(rowId(last)) : undefined
+		if (!el) {
+			lastRowHeight = 0
+			return
+		}
+		lastRowHeight = el.offsetHeight
+		const ro = new ResizeObserver(() => (lastRowHeight = el.offsetHeight))
+		ro.observe(el)
+		return () => ro.disconnect()
+	})
+	const trailingSpace = $derived(Math.max(0, mainHeight - lastRowHeight))
+	let mountedRows: Record<string, boolean> = $state({})
+	const MOUNT_MARGIN = '200px 0px'
+
+	async function loadDiffFor(item: DeployItem) {
+		if (loadedDiffs[item.key]) return
+		loadedDiffs[item.key] = { state: 'loading' }
+		try {
+			const { before, after }: DiffValues = await model.loadDiffValues(item)
+			loadedDiffs[item.key] = { state: 'ready', before, after }
+		} catch (e) {
+			console.error('WorkspaceDiffDrawer: loadDiffValues failed', item, e)
+			loadedDiffs[item.key] = { state: 'error', error: String(e) }
+		}
+	}
+
+	function lazyMount(node: HTMLElement, item: DeployItem) {
+		const io = new IntersectionObserver(
+			(entries) => {
+				if (entries.some((e) => e.isIntersecting)) {
+					mountedRows[item.key] = true
+					void loadDiffFor(item)
+					io.disconnect()
+				}
+			},
+			{ root: mainScrollEl ?? null, rootMargin: MOUNT_MARGIN }
+		)
+		io.observe(node)
+		return { destroy: () => io.disconnect() }
+	}
+
+	// Raw-app blocks explode into their per-file / per-runnable sub-diffs; other
+	// kinds render one before/after viewer.
+	function rawAppItems(
+		item: DeployItem,
+		loaded: LoadedDiff
+	): (RawAppFileItem | RawAppRunnableItem)[] {
+		return rawAppDiffToItems(
+			item.path,
+			loaded.before as RawAppish | undefined,
+			loaded.after as RawAppish | undefined,
+			item.displayPath
+		)
+	}
 </script>
 
 <SearchItems
 	filter={searchQuery}
-	items={displayDiffs}
-	bind:filteredItems={searchedDiffs}
-	f={(d: DisplayDiff) => searchableText(d)}
+	items={displayEntries}
+	bind:filteredItems={searchedEntries}
+	f={(e: DisplayEntry) => searchableText(e)}
 />
 
-{#snippet renderTreeNode(node: TreeNode<DisplayDiff>, depth: number)}
+<!-- The single row badge. Everything here was edited by the AI this session,
+     so the draft badge is a plain pill — no author avatars. -->
+{#snippet rowBadge(item: DeployItem)}
+	{#if badgeOf(item) === 'draft'}
+		{#if model.staleOf(item.key)}
+			<!-- Same warning as the compare page: the deployed head moved after this
+			     draft began, so deploying it reverts the newer deploy. Warn, don't
+			     block — reviewing the diff is exactly what this surface is for. -->
+			<Popover openOnHover debounceDelay={50}>
+				{#snippet trigger()}
+					<AlertTriangle size={14} class="text-orange-500" />
+				{/snippet}
+				{#snippet content()}
+					<div class="text-xs p-3 max-w-xs text-primary">
+						Started from an older deployed version. A newer version was deployed after this draft
+						began. Review the latest deploy before deploying.
+					</div>
+				{/snippet}
+			</Popover>
+		{/if}
+		<Badge
+			color="indigo"
+			small
+			class={STATUS_BADGE_CLASS}
+			title={item.draftOnly ? 'Never deployed and is only a draft' : 'Is deployed and has a draft'}
+		>
+			{item.draftOnly ? 'Draft only' : 'Draft'}
+		</Badge>
+	{:else}
+		<!-- Deployed is the quiet terminal state — an icon-only green badge; the
+		     hover carries the words. Fades in when a row transitions on deploy. -->
+		<span in:fade={{ duration: 200 }} class="inline-flex shrink-0">
+			<Badge
+				color="green"
+				small
+				class="px-1 py-0.5"
+				title={`Deployed in ${workspaceLabel ?? 'this workspace'}`}
+			>
+				<Check class="w-3 h-3" aria-label="Deployed" />
+			</Badge>
+		</span>
+	{/if}
+{/snippet}
+
+<!-- Failure only — while deploying the button itself carries a spinner, and a
+     success flies the green check over the button (see deployStaged). -->
+{#snippet deployFailed(item: DeployItem)}
+	{@const s = model.statusOf(item.key)}
+	{#if s?.status === 'failed'}
+		<span class="inline-flex items-center gap-1" title={s.error}>
+			<Badge color="red" small>Failed</Badge>
+			<Button
+				variant="subtle"
+				unifiedSize="xs"
+				disabled={model.deploying}
+				onclick={() => deployStaged(item)}
+			>
+				Retry
+			</Button>
+		</span>
+	{/if}
+{/snippet}
+
+{#snippet renderTreeNode(node: TreeNode<DisplayEntry>, depth: number)}
 	{#if node.type === 'folder'}
 		{@const isUserScope = node.isScope && node.name.startsWith('u/')}
 		{@const fkey = node.key}
@@ -417,36 +613,62 @@
 		{@const isHl = fkey === highlightedKey}
 		<details
 			{open}
-			ontoggle={(e) => (folderOpen[fkey] = (e.currentTarget as HTMLDetailsElement).open)}
+			ontoggle={(e) => {
+				// Record real user toggles only; skip the echo fired when the `open`
+				// attribute is driven by state (search force-open, expandApp).
+				const domOpen = (e.currentTarget as HTMLDetailsElement).open
+				if (domOpen !== isFolderOpen(fkey)) folderOpen[fkey] = domOpen
+			}}
 			class="select-none"
 		>
 			{#if node.app}
-				{@const appSummary = summaries[node.app.summaryKey] ?? node.app.summary}
-				<!-- Raw-app root: expandable folder, but its header reads as a normal
-				     item row (icon + label). Single line showing the summary, falling
-				     back to the short name (the tree already places it under its scope;
-				     full path on hover). The expand chevron sits at the end of the row. -->
+				{@const appItem = segmentItems.find((it) => it.key === node.app?.summaryKey)}
+				<!-- App root: the row click reveals the app's diff like any item row;
+				     folding is chevron-only (preventDefault blocks the native toggle). -->
 				<summary
 					role="option"
 					aria-selected={isHl}
 					data-nav-key={fkey}
 					onmouseenter={() => setHoverHighlight(fkey)}
+					onclick={(e) => {
+						e.preventDefault()
+						if (appItem) revealDiff(appItem, fkey)
+					}}
 					title={node.fullPath}
-					class="flex items-center gap-1.5 px-3 py-1.5 cursor-pointer hover:bg-surface-hover list-none [&::-webkit-details-marker]:hidden tree-summary {isHl
+					class="flex items-center gap-2 pl-3 pr-1 py-2 rounded-md cursor-pointer hover:bg-surface-hover list-none [&::-webkit-details-marker]:hidden tree-summary {isHl
 						? 'bg-surface-hover'
 						: ''}"
 					style="padding-left: {depth * 12 + 8}px"
 				>
 					<RowIcon kind="raw_app" size={12} />
 					<span
-						class="flex-1 min-w-0 truncate text-xs font-normal text-primary {appSummary
+						class="flex-1 min-w-0 truncate text-xs font-normal text-primary {node.app.summary
 							? ''
 							: 'font-mono'}"
 					>
-						{appSummary ?? node.name}
+						{node.app.summary ?? node.name}
 					</span>
-					<ChevronDown class="w-3 h-3 shrink-0 text-tertiary tree-chevron-open" />
-					<ChevronRight class="w-3 h-3 shrink-0 text-tertiary tree-chevron-closed" />
+					{#if appItem}
+						{@render rowBadge(staged[appItem.key] ?? appItem)}
+					{/if}
+					<!-- Raw button (not the design-system Button) on purpose: it nests inside
+					     the <summary> whose native toggle is preventDefault'd, and needs the
+					     tree rows' compact w-5 footprint — Button's smallest size doesn't fit
+					     and its styling fights the row hover. -->
+					<button
+						type="button"
+						aria-expanded={open}
+						title={open ? 'Hide files' : 'Show files'}
+						class="w-5 h-5 flex items-center justify-center shrink-0 rounded hover:bg-surface-secondary"
+						onclick={(e) => {
+							e.preventDefault()
+							e.stopPropagation()
+							folderOpen[fkey] = !open
+						}}
+					>
+						<ChevronDown class="w-3 h-3 shrink-0 text-tertiary tree-chevron-open" />
+						<ChevronRight class="w-3 h-3 shrink-0 text-tertiary tree-chevron-closed" />
+					</button>
 				</summary>
 			{:else}
 				<summary
@@ -454,7 +676,7 @@
 					aria-selected={isHl}
 					data-nav-key={fkey}
 					onmouseenter={() => setHoverHighlight(fkey)}
-					class="flex items-center gap-1.5 px-3 py-1.5 cursor-pointer text-xs font-normal font-mono text-secondary hover:bg-surface-hover list-none [&::-webkit-details-marker]:hidden tree-summary {isHl
+					class="flex items-center gap-2 pl-3 pr-1 py-2 rounded-md cursor-pointer text-xs font-normal font-mono text-secondary hover:bg-surface-hover list-none [&::-webkit-details-marker]:hidden tree-summary {isHl
 						? 'bg-surface-hover'
 						: ''}"
 					style="padding-left: {depth * 12 + 8}px"
@@ -465,14 +687,13 @@
 						<Folder size={12} class="shrink-0 text-tertiary" />
 					{/if}
 					<span class="flex-1 min-w-0 truncate" title={node.name}>{node.name}</span>
-					<ChevronDown class="w-3 h-3 shrink-0 text-tertiary tree-chevron-open" />
-					<ChevronRight class="w-3 h-3 shrink-0 text-tertiary tree-chevron-closed" />
+					<span class="w-5 flex items-center justify-center shrink-0">
+						<ChevronDown class="w-3 h-3 shrink-0 text-tertiary tree-chevron-open" />
+						<ChevronRight class="w-3 h-3 shrink-0 text-tertiary tree-chevron-closed" />
+					</span>
 				</summary>
 			{/if}
 			<div class="relative">
-				<!-- Indent guide: a vertical rule down the left of the folder's
-				     children, at the parent chevron's midpoint (depth*12+8 + 6).
-				     Absolute so it doesn't shift the rows; clicks pass through. -->
 				<div
 					class="pointer-events-none absolute top-0 bottom-0 border-l border-light"
 					style="left: {depth * 12 + 14}px"
@@ -486,26 +707,134 @@
 	{:else}
 		{@const d = node.data}
 		{@const key = node.key}
-		<!-- Folders place their icon at the base padding (depth*12+8) — the chevron
-		     now sits at the row's end, not the front. WorkspaceItemRow adds its own
-		     12px base, so indent = depth*12-4 lines a file's icon up with sibling
-		     folder icons. Keep in sync with the folder summary. -->
-		<WorkspaceItemRow
-			kind={d.kind as any}
-			iconPath={d.path}
-			baseClass="py-1.5"
-			singleLine
-			summary={summaries[key] ?? ('summary' in d ? d.summary : undefined)}
-			secondary={node.name}
-			highlighted={key === highlightedKey}
-			navKey={key}
-			indent={depth * 12 - 4}
-			title={displayPathOf(d)}
-			onclick={() => {
-				highlightedKey = key
-				scrollToDiff(d)
-			}}
-			onmouseenter={() => setHoverHighlight(key)}
+		<!-- Indentation lives on the wrapper (outside the row's hover surface) so the
+		     highlight starts at the row content instead of bleeding across the indent.
+		     Every row ends with a w-5 slot (chevron or spacer) to keep badges aligned
+		     with the folder rows' chevrons. -->
+		<div class="flex items-stretch" style="padding-left: {depth * 12 + 4}px">
+			{#if isSynthetic(d)}
+				<WorkspaceItemRow
+					kind={d.kind as any}
+					iconPath={d.path}
+					baseClass="py-2 min-w-0 pr-1 pl-1 rounded-md"
+					singleLine
+					secondary={node.name}
+					highlighted={key === highlightedKey}
+					navKey={key}
+					indent={0}
+					title={displayPathOf(d)}
+					onclick={() => void revealSynthetic(d, key)}
+					onmouseenter={() => setHoverHighlight(key)}
+				>
+					{#snippet extras()}
+						<span class="w-5 shrink-0"></span>
+					{/snippet}
+				</WorkspaceItemRow>
+			{:else}
+				<WorkspaceItemRow
+					kind={d.deployKind as any}
+					iconPath={d.path}
+					baseClass="py-2 min-w-0 pr-1 pl-1 rounded-md"
+					singleLine
+					summary={d.summary}
+					secondary={node.name}
+					highlighted={key === highlightedKey}
+					navKey={key}
+					indent={0}
+					title={d.displayPath}
+					onclick={() => revealDiff(d, key)}
+					onmouseenter={() => setHoverHighlight(key)}
+				>
+					{#snippet extras()}
+						{@render rowBadge(staged[d.key] ?? d)}
+						{#if d.deployKind === 'raw_app'}
+							<!-- Unloaded app leaf: row click reveals the diff, the chevron
+							     loads the values and unwraps the file tree. A span (not a
+							     button/Button) because it nests inside WorkspaceItemRow's
+							     clickable row — nested interactive elements are invalid — and
+							     it stays out of the tab order: the keyboard path is ArrowRight
+							     on the highlighted row (handleSearchKeydown). -->
+							<span
+								role="button"
+								tabindex="-1"
+								title="Show files"
+								class="w-5 h-5 flex items-center justify-center shrink-0 rounded cursor-pointer hover:bg-surface-secondary"
+								onclick={(e) => {
+									e.stopPropagation()
+									expandApp(d)
+								}}
+							>
+								{#if loadedDiffs[d.key]?.state === 'loading'}
+									<Loader2 class="w-3 h-3 animate-spin text-tertiary" />
+								{:else}
+									<ChevronRight class="w-3 h-3 text-tertiary" />
+								{/if}
+							</span>
+						{:else}
+							<span class="w-5 shrink-0"></span>
+						{/if}
+					{/snippet}
+				</WorkspaceItemRow>
+			{/if}
+		</div>
+	{/if}
+{/snippet}
+
+<!-- Live (non-done) diff content only — the done state renders at the card
+     level so the two can cross-animate on deploy. -->
+{#snippet diffBlock(item: DeployItem)}
+	{@const loaded = loadedDiffs[item.key]}
+	{#if !mountedRows[item.key]}
+		<div
+			use:lazyMount={item}
+			class="flex items-center gap-2 text-2xs text-tertiary p-3 min-h-[10rem]"
+		>
+			<Loader2 class="w-3.5 h-3.5 animate-spin" />
+			Diff loads on scroll…
+		</div>
+	{:else if !loaded || loaded.state === 'loading'}
+		<div class="flex items-center gap-2 text-xs text-secondary p-3">
+			<Loader2 class="w-3.5 h-3.5 animate-spin" />
+			Loading diff…
+		</div>
+	{:else if loaded.state === 'error'}
+		<div class="text-xs text-red-600 dark:text-red-400 p-3">{loaded.error}</div>
+	{:else if item.deployKind === 'raw_app'}
+		<div class="flex flex-col">
+			{#each rawAppItems(item, loaded) as sub (displayKey(sub))}
+				<!-- Anchor target for the sidebar's per-file rows; scroll-mt clears the
+				     app block's sticky header. -->
+				<div
+					id={`ws-diff-${displayKey(sub)}`}
+					class="border-t border-light first:border-t-0 scroll-mt-10"
+				>
+					<div class="px-3 py-1.5 text-2xs text-secondary font-mono truncate" title={sub.path}>
+						{sub.path}
+					</div>
+					{#if sub.kind === 'raw_app_file'}
+						<WorkspaceItemDiffViewer
+							kind="raw_app_file"
+							rawFile={sub as RawAppFileItem}
+							{inlineDiff}
+						/>
+					{:else}
+						{@const runnable = sub as RawAppRunnableItem}
+						<WorkspaceItemDiffViewer
+							kind="script"
+							originalRaw={runnable.originalRaw}
+							currentRaw={runnable.currentRaw}
+							{inlineDiff}
+						/>
+					{/if}
+				</div>
+			{/each}
+		</div>
+	{:else}
+		<WorkspaceItemDiffViewer
+			kind={item.deployKind}
+			originalRaw={loaded.before}
+			currentRaw={loaded.after}
+			{inlineDiff}
 		/>
 	{/if}
 {/snippet}
@@ -540,178 +869,215 @@
 					/>
 				{/snippet}
 			</ToggleButtonGroup>
-			<Button
-				variant="accent"
-				unifiedSize="sm"
-				startIcon={{ icon: GitMerge }}
-				onclick={() => goto(reviewHref)}
-			>
-				{reviewLabel}
-			</Button>
 		{/snippet}
-		<div class="flex flex-row h-full min-h-0">
-			{#if diffs.length > 0}
-				<aside
-					bind:this={sidebarRoot}
-					onmousemove={() => (mouseActive = true)}
-					class="flex-none w-56 border-r border-light flex flex-col min-h-0"
-				>
-					<div class="px-3 pt-3 pb-2 shrink-0">
-						<!-- Raw input (not the design-system TextInput) on purpose: this is a
-						     bespoke filter wired to the file tree's keyboard navigation — it
-						     needs a direct element ref to focus (the `/` shortcut) and a
-						     keydown handler that hands ArrowDown/Enter off to the tree.
-						     TextInput/ClearableInput swallow/rebubble those and don't expose
-						     the element ref. -->
-						<input
-							bind:this={searchInputEl}
-							type="search"
-							bind:value={searchQuery}
-							placeholder="Filter files..."
-							onkeydown={handleSearchKeydown}
-							class="w-full text-xs px-2 py-1 rounded border border-light bg-surface focus:outline-none focus:border-accent"
-						/>
-					</div>
-					<div class="flex-1 min-h-0 overflow-y-auto pb-3 flex flex-col gap-1">
-						{#if treeModel.root.children.length > 0}
-							{#each treeModel.root.children as child}
-								{@render renderTreeNode(child, 0)}
-							{/each}
-						{:else}
-							<div class="text-2xs text-tertiary px-3 py-2">No matches</div>
-						{/if}
-					</div>
-				</aside>
-			{/if}
-			<main bind:this={mainScrollEl} class="flex-1 min-w-0 overflow-y-auto">
-				<div class="px-3 pt-3 pb-4 flex flex-col gap-3">
-					{#if loading && diffs.length === 0}
-						<div class="flex items-center gap-2 text-sm text-secondary py-8 self-center">
-							<Loader2 class="w-4 h-4 animate-spin" />
-							Loading comparison...
+		<div class="flex flex-col h-full min-h-0">
+			<div class="flex flex-row flex-1 min-h-0">
+				{#if model.items.length > 0}
+					<aside
+						bind:this={sidebarRoot}
+						onmousemove={() => (mouseActive = true)}
+						class="flex-none w-96 flex flex-col min-h-0 pt-3 px-1"
+					>
+						<!-- Both containers reserve the same stable scrollbar gutter (the input
+						     wrapper never actually scrolls), so input and tree rows share one
+						     right edge. padRightForGutter tops the gutter up to the 6px inner
+						     padding target so the visual right margin equals the left one no
+						     matter the platform's scrollbar width (0 for overlay scrollbars). -->
+						<div
+							class="pl-2 pb-1 shrink-0 overflow-y-auto"
+							style="scrollbar-gutter: stable;"
+							use:padRightForGutter
+						>
+							<!-- Raw input (not the design-system TextInput) on purpose: this is a
+							     bespoke filter wired to the file tree's keyboard navigation — it
+							     needs a direct element ref (focused on open) and a keydown handler
+							     that hands ArrowDown/Enter/ArrowLeft/Right off to the tree.
+							     TextInput/ClearableInput swallow/rebubble those and don't expose
+							     the element ref. -->
+							<input
+								bind:this={searchInputEl}
+								type="search"
+								bind:value={searchQuery}
+								placeholder="Filter files..."
+								onkeydown={handleSearchKeydown}
+								class="w-full text-xs px-2 py-1 rounded border border-light bg-surface focus:outline-none focus:border-accent"
+							/>
 						</div>
-					{:else if error}
-						<div class="text-sm text-red-600 dark:text-red-400 py-4">{error}</div>
-					{:else if notice}
-						<div class="text-sm text-secondary py-4">{notice}</div>
-					{:else if diffs.length === 0}
-						<div class="text-sm text-secondary py-4">{emptyMessage}</div>
-					{:else if filteredDiffs.length === 0}
-						<div class="text-sm text-secondary py-4">No files match "{searchQuery}".</div>
-					{:else}
-						<div class="flex flex-col gap-2">
-							{#each filteredDiffs as d (itemKey(d))}
-								{@const key = itemKey(d)}
-								{@const status = d.status}
-								{@const StatusIcon = statusIcons[status]}
-								{@const loaded = loadedDiffs[key]}
-								<!-- A synthesized raw-app item (file or runnable) links to its
-								     owning app's editor. -->
-								{@const editUrl =
-									'appPath' in d
-										? editUrlFor?.({ ...d, kind: 'raw_app', path: d.appPath })
-										: editUrlFor?.(d)}
-								{@const dpath = displayPathOf(d)}
-								<details
-									open
-									id={rowId(d)}
-									class="border border-light rounded-md bg-surface scroll-mt-2"
-									ontoggle={(e) => onDetailsToggle(d, e)}
-								>
-									<summary
-										class="sticky top-0 z-30 bg-surface flex items-center gap-2 px-3 py-2 cursor-pointer list-none [&::-webkit-details-marker]:hidden border-b border-transparent rounded-md relative before:content-[''] before:absolute before:inset-0 before:bg-surface-hover before:opacity-0 before:pointer-events-none before:transition-opacity hover:before:opacity-100"
+						<div
+							class="flex-1 min-h-0 overflow-y-auto overflow-x-hidden pl-2 pt-1.5 pb-2 flex flex-col gap-1"
+							style="scrollbar-gutter: stable;"
+							use:padRightForGutter
+						>
+							{#if treeModel.root.children.length > 0}
+								{#each treeModel.root.children as child}
+									{@render renderTreeNode(child, 0)}
+								{/each}
+							{:else}
+								<div class="text-2xs text-tertiary px-3 py-2">No matches</div>
+							{/if}
+						</div>
+					</aside>
+				{/if}
+				<main
+					bind:this={mainScrollEl}
+					bind:clientHeight={mainHeight}
+					class="flex-1 min-w-0 overflow-y-auto bg-surface"
+				>
+					<div class="pl-1 pr-3 pt-3 pb-4 flex flex-col gap-3">
+						{#if model.loading && model.items.length === 0}
+							<div class="flex items-center gap-2 text-sm text-secondary py-8 self-center">
+								<Loader2 class="w-4 h-4 animate-spin" />
+								Loading changes...
+							</div>
+						{:else if model.error}
+							<div class="text-sm text-red-600 dark:text-red-400 py-4">{model.error}</div>
+						{:else if model.items.length === 0}
+							<div class="text-sm text-secondary py-4">No changes.</div>
+						{:else if orderedItems.length === 0}
+							<div class="text-sm text-secondary py-4">No files match.</div>
+						{:else}
+							<div class="flex flex-col">
+								{#each orderedItems as d (d.key)}
+									<!-- While a deploy's success is being staged, the card renders its
+									     pre-deploy snapshot so the state flip waits for the check-mark
+									     beat instead of racing it. -->
+									{@const view = staged[d.key] ?? d}
+									{@const action = actionFor(view)}
+									{@const editUrl = editUrlFor?.(d)}
+									{@const status = model.statusOf(d.key)}
+									<div
+										id={rowId(d)}
+										class="mb-6 scroll-mt-3 rounded-md border border-light transition-shadow duration-500 {flashKey ===
+										d.key
+											? 'ring-1 ring-border-accent'
+											: 'ring-0 ring-transparent'}"
 									>
-										<ChevronDown
-											class="w-3.5 h-3.5 shrink-0 text-tertiary transition-transform chevron"
-										/>
-										<RowIcon kind={d.kind as any} path={d.path} size={14} />
-										<div class="min-w-0 flex-1">
-											{#if editUrl}
-												<ExternalEditLink
-													href={editUrl}
-													title={dpath}
-													class="text-xs text-primary font-mono truncate"
+										<div
+											class="sticky top-0 z-30 bg-surface-tertiary rounded-t-md flex items-center gap-2 px-3 py-2 border-b border-transparent"
+										>
+											<RowIcon kind={d.deployKind as any} path={d.path} size={14} />
+											<div class="min-w-0 flex-1">
+												{#if editUrl}
+													<ExternalEditLink
+														href={editUrl}
+														title={d.displayPath}
+														class="text-xs text-primary font-mono truncate"
+													>
+														<span class="truncate">{d.displayPath}</span>
+													</ExternalEditLink>
+												{:else}
+													<div
+														class="text-xs text-primary font-mono truncate"
+														title={d.displayPath}
+													>
+														{d.displayPath}
+													</div>
+												{/if}
+											</div>
+											<div class="shrink-0 flex items-center gap-2">
+												{@render rowBadge(view)}
+												{#if status?.status === 'failed'}
+													{@render deployFailed(d)}
+												{:else if action.op !== 'none'}
+													{#if action.secondary?.length}
+														<Button
+															variant="subtle"
+															unifiedSize="sm"
+															destructive
+															disabled={model.deploying || !!staged[d.key]}
+															onclick={() => confirmDiscard(d)}
+														>
+															{action.secondary[0].label}
+														</Button>
+													{/if}
+													<div class="relative overflow-hidden rounded-md">
+														<Button
+															variant="accent"
+															unifiedSize="sm"
+															disabled={model.deploying ||
+																!!staged[d.key] ||
+																!view.canWrite ||
+																!model.deployPermission.ok}
+															startIcon={status?.status === 'loading'
+																? { icon: Loader2, classes: 'animate-spin' }
+																: { icon: Save }}
+															title={!view.canWrite
+																? "You don't have write permission on this path"
+																: model.deployPermission.ok
+																	? undefined
+																	: model.deployPermission.reason}
+															onclick={() => deployStaged(d)}
+														>
+															{action.label}
+														</Button>
+														{#if staged[d.key]}
+															<!-- Success beat: green check flies in over the button
+															     (SaveButton pattern), holds, then the row flips. -->
+															<div
+																class="absolute inset-0 flex items-center justify-center bg-green-200 dark:bg-green-800 rounded-md"
+																transition:fly={{ y: -10, duration: 300 }}
+															>
+																<CheckCircle2 class="w-4 h-4 text-green-700 dark:text-green-300" />
+															</div>
+														{/if}
+													</div>
+												{/if}
+											</div>
+										</div>
+										<div class="bg-surface-tertiary rounded-b-md overflow-hidden">
+											<!-- Deploy collapses the (tall) diff into the one-line done note —
+											     slide both branches so the card height animates instead of
+											     snapping. Transitions are local: nothing plays on drawer open. -->
+											{#if view.done}
+												<div
+													transition:slide={{ duration: 300, easing: cubicOut }}
+													class="text-2xs text-tertiary p-3"
 												>
-													<span class="truncate">{dpath}</span>
-												</ExternalEditLink>
+													Deployed — no pending changes.
+												</div>
 											{:else}
-												<div class="text-xs text-primary font-mono truncate" title={dpath}>
-													{dpath}
+												<div transition:slide={{ duration: 300, easing: cubicOut }}>
+													{@render diffBlock(view)}
 												</div>
 											{/if}
 										</div>
-										<div class="shrink-0 flex items-center gap-2">
-											{#if d.ahead && d.ahead > 0}
-												<span class="text-2xs text-secondary">{d.ahead} ahead</span>
-											{/if}
-											{#if d.behind && d.behind > 0}
-												<span class="text-2xs text-secondary">{d.behind} behind</span>
-											{/if}
-											<Badge color={statusBadgeColor(status)}>
-												<StatusIcon class="w-3 h-3 inline mr-0.5" />
-												{status}
-											</Badge>
-										</div>
-									</summary>
-									<div
-										class="border-t border-light bg-surface-tertiary rounded-b-md overflow-hidden"
-									>
-										{#if !mountedRows[key]}
-											<!-- Defer the Monaco mount until this block scrolls near the
-											     viewport, so an exploded many-file app doesn't mount every
-											     editor at once. -->
-											<div
-												use:lazyMount={key}
-												class="flex items-center gap-2 text-2xs text-tertiary p-3 min-h-[10rem]"
-											>
-												<Loader2 class="w-3.5 h-3.5 animate-spin" />
-												Diff loads on scroll…
-											</div>
-										{:else if d.kind === 'raw_app_file'}
-											<!-- DiffRow.kind is a plain string, so the kind check doesn't narrow
-											     the union — assert the synthetic file item. -->
-											{@const rawFile = d as RawAppFileItem}
-											<WorkspaceItemDiffViewer kind="raw_app_file" {rawFile} {inlineDiff} />
-										{:else if 'appPath' in d}
-											<!-- Synthesized runnable: render script-style (Content + Metadata),
-											     forcing `script` so flow runnables don't hit FlowDiffViewer. -->
-											{@const runnable = d as RawAppRunnableItem}
-											<WorkspaceItemDiffViewer
-												kind="script"
-												originalRaw={runnable.originalRaw}
-												currentRaw={runnable.currentRaw}
-												{inlineDiff}
-											/>
-										{:else if !loaded || loaded.state === 'loading'}
-											<div class="flex items-center gap-2 text-xs text-secondary p-3">
-												<Loader2 class="w-3.5 h-3.5 animate-spin" />
-												Loading diff…
-											</div>
-										{:else if loaded.state === 'error'}
-											<div class="text-xs text-red-600 dark:text-red-400">{loaded.error}</div>
-										{:else if loaded.state === 'ready'}
-											<WorkspaceItemDiffViewer
-												kind={d.kind}
-												originalRaw={loaded.before}
-												currentRaw={loaded.after}
-												{inlineDiff}
-											/>
-										{/if}
 									</div>
-								</details>
-							{/each}
-						</div>
-					{/if}
-				</div></main
-			>
+								{/each}
+							</div>
+							<!-- Just enough trailing room for the last item to reach the top;
+							     without it the container bottoms out and short lists sit low. -->
+							<div aria-hidden="true" class="shrink-0" style="height: {trailingSpace}px"></div>
+						{/if}
+					</div>
+				</main>
+			</div>
+			<!-- Batch / PR (deploy all, request review, reconcile) is the compare page's
+			     job — the dock deploys per item; this footer is just the doorway there.
+			     A plain anchor (not Button href): it's a text-level navigation link, and
+			     the design-system Button renders link-hrefs with button chrome. -->
+			{#if model.items.length > 0 && compareSessionHref}
+				<div
+					class="shrink-0 border-t border-light bg-surface px-3 py-1.5 flex items-center justify-end text-xs"
+				>
+					<a
+						href={compareSessionHref}
+						target="_blank"
+						rel="noopener noreferrer"
+						class="inline-flex items-center gap-1 font-medium text-accent hover:underline shrink-0"
+					>
+						Deploy all / request review on compare page
+						<ExternalLink class="w-3 h-3" />
+					</a>
+				</div>
+			{/if}
+			<!-- Inside the drawer subtree: the drawer is portaled/elevated, so a
+			     sibling modal would stack beneath it. -->
+			<ConfirmationModal {...discardConfirm.props} />
 		</div>
 	</DrawerContent>
 </Drawer>
 
 <style>
-	details:not([open]) :global(.chevron) {
-		transform: rotate(-90deg);
-	}
 	details:not([open]) > .tree-summary :global(.tree-chevron-open) {
 		display: none;
 	}
diff --git a/frontend/src/lib/components/sessions/diffTree.test.ts b/frontend/src/lib/components/sessions/diffTree.test.ts
index e2907fbbdc..44f1cb9ca5 100644
--- a/frontend/src/lib/components/sessions/diffTree.test.ts
+++ b/frontend/src/lib/components/sessions/diffTree.test.ts
@@ -47,6 +47,43 @@ describe('buildDiffTree — structure', () => {
 		expect(t.root.children[0]).toMatchObject({ type: 'file', name: 'orphan', key: 'orphan' })
 	})
 
+	it('app roots sort as items among leaves — same position before and after unwrap', () => {
+		const apps = new Map<string, AppRootMeta>([['u/admin/beta_app', { summaryKey: 'raw_app/b' }]])
+		// Unloaded: the app is a plain leaf between alpha and zeta.
+		const before = buildDiffTree(
+			[
+				item('a', 'u/admin/alpha'),
+				item('raw_app/b', 'u/admin/beta_app'),
+				item('z', 'u/admin/zeta')
+			],
+			apps
+		)
+		const scopeBefore = before.root.children[0]
+		if (scopeBefore.type !== 'folder') throw new Error('expected scope')
+		expect(scopeBefore.children.map((c) => `${c.type}:${c.name}`)).toEqual([
+			'file:alpha',
+			'file:beta_app',
+			'file:zeta'
+		])
+		// Loaded: the leaf is replaced by the app-root folder — same position,
+		// not hoisted to the folder group.
+		const after = buildDiffTree(
+			[
+				item('a', 'u/admin/alpha'),
+				item('f', 'u/admin/beta_app/App.tsx'),
+				item('z', 'u/admin/zeta')
+			],
+			apps
+		)
+		const scopeAfter = after.root.children[0]
+		if (scopeAfter.type !== 'folder') throw new Error('expected scope')
+		expect(scopeAfter.children.map((c) => `${c.type}:${c.name}`)).toEqual([
+			'file:alpha',
+			'folder:beta_app',
+			'file:zeta'
+		])
+	})
+
 	it('tags the folder matching an app root and leaves others untagged', () => {
 		const apps = new Map<string, AppRootMeta>([
 			['u/admin/my_app', { summaryKey: 'raw_app/x', summary: 'My app' }]
diff --git a/frontend/src/lib/components/sessions/diffTree.ts b/frontend/src/lib/components/sessions/diffTree.ts
index 1ede7be628..a91d2c1d90 100644
--- a/frontend/src/lib/components/sessions/diffTree.ts
+++ b/frontend/src/lib/components/sessions/diffTree.ts
@@ -29,7 +29,14 @@ export type DiffTreeItem<T> = {
 
 /** Marks a folder as a raw app's root so the drawer renders its header as the
  * raw-app row instead of a plain folder. Keyed by the app's friendly path. */
-export type AppRootMeta = { summaryKey: string; summary?: string }
+export type AppRootMeta = {
+	summaryKey: string
+	summary?: string
+	hasDraft?: boolean
+	draftOnly?: boolean
+	draftUsers?: { username?: string | null }[]
+	draftItemKind?: import('$lib/gen').UserDraftItemKind
+}
 
 export type FolderNode<T> = {
 	type: 'folder'
@@ -57,7 +64,7 @@ export type DiffTreeModel<T> = {
 	firstChildKeyOf(folderKey: string): string | undefined
 }
 
-function folderKeyFor(fullPath: string): string {
+export function folderKeyFor(fullPath: string): string {
 	return `folder:${fullPath}`
 }
 
@@ -119,21 +126,28 @@ export function buildDiffTree<T>(
 		addFile(parent, rest[rest.length - 1], it)
 	}
 
+	// Tag the folder matching each raw app's friendly path as its app root.
+	// Must happen before sorting: app roots sort as items, not as folders.
+	for (const [fp, meta] of appMeta) {
+		const f = folderCache.get(fp)
+		if (f) f.app = meta
+	}
+
+	// Path folders group first; everything item-like — leaves AND app roots —
+	// sorts together by name, so a raw app keeps its position when expanding
+	// turns its leaf row into an app-root folder.
+	const isGrouping = (n: TreeNode<T>) => n.type === 'folder' && !n.app
 	const sortRec = (n: FolderNode<T>) => {
 		n.children.sort((a, b) => {
-			if (a.type !== b.type) return a.type === 'folder' ? -1 : 1
+			const ga = isGrouping(a) ? 0 : 1
+			const gb = isGrouping(b) ? 0 : 1
+			if (ga !== gb) return ga - gb
 			return a.name.localeCompare(b.name)
 		})
 		for (const c of n.children) if (c.type === 'folder') sortRec(c)
 	}
 	sortRec(root)
 
-	// Tag the folder matching each raw app's friendly path as its app root.
-	for (const [fp, meta] of appMeta) {
-		const f = folderCache.get(fp)
-		if (f) f.app = meta
-	}
-
 	return {
 		root,
 		order(isOpen) {
diff --git a/frontend/src/lib/components/sessions/forkDiffCache.test.ts b/frontend/src/lib/components/sessions/forkDiffCache.test.ts
index 2d38320a6a..9b5bc6d9d5 100644
--- a/frontend/src/lib/components/sessions/forkDiffCache.test.ts
+++ b/frontend/src/lib/components/sessions/forkDiffCache.test.ts
@@ -1,15 +1,15 @@
 import { describe, it, expect } from 'vitest'
 
-// Documents the cache-invalidation contract that ForkDiffDrawer.fetchComparison
-// relies on. The bug (cubic P2): per-item raw diffs (`loadedDiffs[key]`) and
-// per-item `summaries` are component-local $state that persist for the
-// drawer's lifetime. fetchComparison re-fetches the comparison on every
-// open(), but loadDiffFor short-circuits on `loadedDiffs[key]` — so an
-// edit-then-reopen would show fresh counts but the prior open's cached
-// expanded raw content. The fix clears both records at the top of
-// fetchComparison before the await. This test pins the contract from the
-// outside: nothing is allowed to read a stale per-item value across a
-// fetchComparison invocation.
+// Documents the cache-invalidation contract behind the session fork diff. The
+// bug (cubic P2): per-item raw diffs (`loadedDiffs[key]`) and per-item
+// `summaries` are component-local $state in WorkspaceDiffDrawer that persist for
+// the drawer's lifetime. The comparison is re-fetched on every open(), but
+// loadDiffFor short-circuits on `loadedDiffs[key]` — so an edit-then-reopen
+// would show fresh counts but the prior open's cached expanded raw content. The
+// fix clears both records on open() (and, for an in-place data-source swap like
+// the draft↔fork toggle, on a `resetKey` change). This test pins the contract
+// from the outside: nothing is allowed to read a stale per-item value across a
+// re-fetch.
 
 type LoadedDiff = { state: 'ready'; parentRaw: string; forkRaw: string }
 
diff --git a/frontend/src/lib/components/sessions/modifiedItemsMask.test.ts b/frontend/src/lib/components/sessions/modifiedItemsMask.test.ts
new file mode 100644
index 0000000000..b66b83b2f1
--- /dev/null
+++ b/frontend/src/lib/components/sessions/modifiedItemsMask.test.ts
@@ -0,0 +1,66 @@
+import { describe, it, expect } from 'vitest'
+import { maskKey, forkDiffKindToUserDraftKind, diffInMask } from './modifiedItemsMask'
+import type { WorkspaceItemDiff } from '$lib/gen'
+
+// The fork-diff → user-draft kind bridge must stay the inverse of
+// CompareDrafts.toLayoutKind (different taxonomies: `http_trigger` vs
+// `trigger_http`, `schedule` vs `trigger_schedule`). A drift here silently breaks
+// the chat-scoped mask join, so pin the table.
+
+describe('maskKey', () => {
+	it('joins kind and path with a colon', () => {
+		expect(maskKey('script', 'u/admin/foo')).toBe('script:u/admin/foo')
+		expect(maskKey('raw_app', 'f/bar/app')).toBe('raw_app:f/bar/app')
+	})
+})
+
+describe('forkDiffKindToUserDraftKind', () => {
+	it('maps trigger/schedule/app fork-diff kinds to their user-draft kind', () => {
+		const cases: Array<[WorkspaceItemDiff['kind'], string]> = [
+			['schedule', 'trigger_schedule'],
+			['http_trigger', 'trigger_http'],
+			['websocket_trigger', 'trigger_websocket'],
+			['kafka_trigger', 'trigger_kafka'],
+			['nats_trigger', 'trigger_nats'],
+			['postgres_trigger', 'trigger_postgres'],
+			['mqtt_trigger', 'trigger_mqtt'],
+			['sqs_trigger', 'trigger_sqs'],
+			['gcp_trigger', 'trigger_gcp'],
+			['azure_trigger', 'trigger_azure'],
+			['email_trigger', 'trigger_default_email'],
+			['app', 'raw_app']
+		]
+		for (const [forkKind, expected] of cases) {
+			expect(forkDiffKindToUserDraftKind(forkKind)).toBe(expected)
+		}
+	})
+
+	it('passes identity kinds through unchanged', () => {
+		for (const k of ['script', 'flow', 'raw_app', 'resource', 'variable'] as const) {
+			expect(forkDiffKindToUserDraftKind(k)).toBe(k)
+		}
+	})
+
+	it('returns undefined for kinds with no user-draft equivalent', () => {
+		expect(forkDiffKindToUserDraftKind('resource_type')).toBeUndefined()
+		expect(forkDiffKindToUserDraftKind('folder')).toBeUndefined()
+	})
+})
+
+describe('diffInMask', () => {
+	const diff = (kind: WorkspaceItemDiff['kind'], path: string): WorkspaceItemDiff =>
+		({ kind, path }) as WorkspaceItemDiff
+
+	it('matches a fork diff against the mask via the bridged kind', () => {
+		const mask = new Set(['trigger_http:f/foo/route', 'script:u/me/s'])
+		expect(diffInMask(diff('http_trigger', 'f/foo/route'), mask)).toBe(true)
+		expect(diffInMask(diff('script', 'u/me/s'), mask)).toBe(true)
+	})
+
+	it('does not match when path or kind differ, or kind has no equivalent', () => {
+		const mask = new Set(['trigger_http:f/foo/route'])
+		expect(diffInMask(diff('http_trigger', 'f/other/route'), mask)).toBe(false)
+		expect(diffInMask(diff('script', 'f/foo/route'), mask)).toBe(false)
+		expect(diffInMask(diff('folder', 'f/foo/route'), mask)).toBe(false)
+	})
+})
diff --git a/frontend/src/lib/components/sessions/modifiedItemsMask.ts b/frontend/src/lib/components/sessions/modifiedItemsMask.ts
new file mode 100644
index 0000000000..14ab16a653
--- /dev/null
+++ b/frontend/src/lib/components/sessions/modifiedItemsMask.ts
@@ -0,0 +1,52 @@
+import type { UserDraftItemKind, WorkspaceItemDiff } from '$lib/gen'
+
+// The "modified items mask" tracks which workspace items an AI chat touched via
+// tool calls. Each key is `${UserDraftItemKind}:${storagePath}`. UserDraftItemKind
+// is canonical because it is what `itemKindFor`/`persistGlobalDraft` emit at capture
+// time and what `DraftItem.kind` (GET /drafts/list) already uses — so the mask joins
+// directly against the draft list. The fork comparison (`compareWorkspaces`) uses a
+// DIFFERENT kind taxonomy (`http_trigger` vs `trigger_http`, `schedule` vs
+// `trigger_schedule`), so `forkDiffKindToUserDraftKind` bridges the two.
+
+export function maskKey(kind: UserDraftItemKind, path: string): string {
+	return `${kind}:${path}`
+}
+
+type ForkDiffKind = WorkspaceItemDiff['kind']
+
+// Inverse of the draft→layout naming used in CompareDrafts.toLayoutKind. Only the
+// non-identity cases need an entry; everything else falls through to identity.
+// `resource_type`/`folder` have no UserDraftItemKind (never AI-authored) → undefined.
+const FORK_DIFF_KIND_TO_USER_DRAFT_KIND: Partial<Record<ForkDiffKind, UserDraftItemKind>> = {
+	schedule: 'trigger_schedule',
+	http_trigger: 'trigger_http',
+	websocket_trigger: 'trigger_websocket',
+	kafka_trigger: 'trigger_kafka',
+	nats_trigger: 'trigger_nats',
+	postgres_trigger: 'trigger_postgres',
+	mqtt_trigger: 'trigger_mqtt',
+	sqs_trigger: 'trigger_sqs',
+	gcp_trigger: 'trigger_gcp',
+	azure_trigger: 'trigger_azure',
+	email_trigger: 'trigger_default_email',
+	app: 'raw_app'
+}
+
+const IDENTITY_FORK_DIFF_KINDS = new Set<ForkDiffKind>([
+	'script',
+	'flow',
+	'raw_app',
+	'resource',
+	'variable'
+])
+
+export function forkDiffKindToUserDraftKind(kind: ForkDiffKind): UserDraftItemKind | undefined {
+	if (IDENTITY_FORK_DIFF_KINDS.has(kind)) return kind as UserDraftItemKind
+	return FORK_DIFF_KIND_TO_USER_DRAFT_KIND[kind]
+}
+
+// True when a fork-comparison diff names an item present in the chat-modified mask.
+export function diffInMask(diff: WorkspaceItemDiff, mask: Set<string>): boolean {
+	const kind = forkDiffKindToUserDraftKind(diff.kind)
+	return kind !== undefined && mask.has(maskKey(kind, diff.path))
+}
diff --git a/frontend/src/lib/components/sessions/sessionDeployModel.svelte.ts b/frontend/src/lib/components/sessions/sessionDeployModel.svelte.ts
new file mode 100644
index 0000000000..28f0075880
--- /dev/null
+++ b/frontend/src/lib/components/sessions/sessionDeployModel.svelte.ts
@@ -0,0 +1,351 @@
+import { getDraftItems, type DraftItem } from '$lib/workspaceDrafts.svelte'
+import {
+	checkDeployPermission,
+	checkItemExists,
+	getItemValue,
+	type DeployPermission,
+	type DeployResult
+} from '$lib/utils_workspace_deploy'
+import {
+	deployDraft,
+	discardDraft,
+	fetchDraftBaseStale,
+	getDraftDiffValues
+} from '$lib/utils_draft_deploy'
+import { untrack } from 'svelte'
+import {
+	buildDeployItems,
+	deployPlanFor,
+	diffBaseFor,
+	discardPlanFor,
+	maskOnlyCandidates,
+	type DeployItem,
+	type DeployPlanEntry
+} from './sessionDeployModel'
+import { maskKey } from './modifiedItemsMask'
+
+export type DeploymentStatus = { status: 'loading' | 'failed'; error?: string }
+
+// Reactive wrapper over the pure sessionDeployModel: owns the async draft list
+// and builds the unified item list. The diff-value loader lives here too so both
+// the tree and the diff column read one resolver. The dock is granular per-item
+// deploy (deployRow/discardRow); batch flows and fork→parent promotion are the
+// compare page's concern.
+
+export interface SessionDeployModelArgs {
+	workspaceId: string
+	/** Called after a deploy/discard mutated workspace state. Lets the consumer
+	 *  refresh ITS OWN data sources — without this, the bar shows stale counts
+	 *  until the next turn end / tab refocus / reload. */
+	onDataChanged?: () => void
+	/** A draft deployed: the consumer owning the mask moves the item's entry to
+	 *  its deployed path (`displayPath` — differs from the synthetic storage
+	 *  `path` for draft-only items, which never exists deployed). */
+	onItemDeployed?: (item: DeployItem) => void
+	/** A draft was discarded: the chat's touch is undone — the consumer drops
+	 *  the item's mask entry so a pre-existing deployed item doesn't keep
+	 *  reading as this chat's "Deployed" edit. */
+	onItemDiscarded?: (item: DeployItem) => void
+	/** Chat-modified-items mask; undefined shows every draft. */
+	mask?: Set<string>
+}
+
+export interface DiffValues {
+	before: unknown
+	after: unknown
+}
+
+/** Resolves which mask-only candidates still exist in the session workspace
+ *  (deployed) vs are gone (discarded drafts / deleted items) — the
+ *  `existingKeys` input of `buildDeployItems`. Undefined while resolving, so
+ *  deployed rows only appear once confirmed. Shared by the drawer model and the
+ *  bar's dock counts. */
+export function useExistingMaskKeys(
+	getInput: () => Omit<Parameters<typeof buildDeployItems>[0], 'existingKeys'> & {
+		workspaceId: string
+	}
+) {
+	let existingKeys = $state<Set<string> | undefined>(undefined)
+	// Existence is checked once per distinct candidate set; the signature avoids
+	// re-firing while results stream back.
+	let lastCandidateSig = ''
+	// Bumped by refresh() to force a re-check even when the candidate set (the
+	// effect's other dependency) is unchanged.
+	let recheck = $state(0)
+	$effect(() => {
+		void recheck
+		const { workspaceId, ...buildInput } = getInput()
+		const cands = maskOnlyCandidates(buildInput)
+		// The workspace is part of the identity: the same candidate keys in a
+		// different workspace must re-check, not reuse the previous verdict.
+		const sig =
+			workspaceId +
+			'|' +
+			cands
+				.map((c) => c.key)
+				.sort()
+				.join(',')
+		untrack(() => {
+			if (sig === lastCandidateSig) return
+			lastCandidateSig = sig
+			if (cands.length === 0) {
+				existingKeys = new Set()
+				return
+			}
+			// A mask-only item that was deployed still exists in the session
+			// workspace; a discarded or deleted one doesn't.
+			void Promise.all(
+				cands.map((c) =>
+					checkItemExists(c.deployKind, c.path, workspaceId)
+						.then((exists) => (exists ? c.key : null))
+						.catch(() => null)
+				)
+			).then((keys) => {
+				// A slower batch for a superseded candidate set (or one voided by
+				// reset()) must not overwrite the current result.
+				if (sig !== lastCandidateSig) return
+				existingKeys = new Set(keys.filter((k): k is string => !!k))
+			})
+		})
+	})
+	return {
+		get keys() {
+			return existingKeys
+		},
+		/** Force a fresh existence check (an item may have been deleted since).
+		 *  Hard invalidate: current keys are dropped until the check resolves, so
+		 *  rows derived from them disappear meanwhile — use on a fresh surface
+		 *  (drawer open), not on a live one. */
+		reset() {
+			lastCandidateSig = ''
+			existingKeys = undefined
+		},
+		/** Re-check while keeping the current keys (stale-while-revalidate), so a
+		 *  live surface doesn't blank out during the round-trip. */
+		refresh() {
+			lastCandidateSig = ''
+			recheck++
+		}
+	}
+}
+
+export function useSessionDeployModel(getArgs: () => SessionDeployModelArgs) {
+	let draftItems = $state<DraftItem[]>([])
+	let loading = $state(false)
+	let error = $state<string | undefined>(undefined)
+
+	// Mask keys confirmed to still exist → allowed to show as terminal deployed
+	// rows (a discarded draft is a mask entry with no item, so it stays out).
+	const existing = useExistingMaskKeys(() => ({
+		draftItems,
+		mask: getArgs().mask,
+		workspaceId: getArgs().workspaceId
+	}))
+
+	// Optimistic knowledge from this model's own deploys: a deployed key exists
+	// in the session workspace before the async existence check confirms it.
+	// Without this a deployed row falls out of the list for ~1s, unmounting its
+	// card.
+	let deployedKeys = $state<ReadonlySet<string>>(new Set())
+
+	const items = $derived.by(() => {
+		const existingKeys =
+			deployedKeys.size === 0 ? existing.keys : new Set([...(existing.keys ?? []), ...deployedKeys])
+		return buildDeployItems({ draftItems, mask: getArgs().mask, existingKeys })
+	})
+
+	async function fetchDrafts() {
+		loading = true
+		error = undefined
+		try {
+			draftItems = await getDraftItems(getArgs().workspaceId)
+		} catch (e) {
+			console.error('Session deploy model: draft list failed', e)
+			error = `Failed to load drafts: ${e}`
+			draftItems = []
+		} finally {
+			loading = false
+		}
+	}
+
+	/** (Re)fetch. Called on open. */
+	function load() {
+		// Re-check existence fresh (an item may have been deleted since last open).
+		existing.reset()
+		// Drop the optimistic bridge with it: it only covers the gap until the
+		// fresh check resolves, and a stale entry would keep a since-deleted item
+		// reading as deployed forever.
+		deployedKeys = new Set()
+		// Staleness can change between opens (a deploy elsewhere moves the head).
+		staleFetched.clear()
+		staleKeys = new Set()
+		void fetchDrafts()
+	}
+
+	// ── Stale drafts (base ≠ deployed head) ──────────────────────────────────
+	// A draft forked from a version that is no longer the deployed head: someone
+	// deployed in between, so deploying the draft would silently revert them.
+	// Same detection as the compare page; surfaced as a warning, deploy stays
+	// allowed. Only own drafts on deployed script/flow/app items carry a base.
+	let staleKeys = $state<ReadonlySet<string>>(new Set())
+	const staleFetched = new Set<string>()
+	$effect(() => {
+		const list = items
+		const ws = getArgs().workspaceId
+		untrack(() => {
+			for (const it of list) {
+				if (!it.hasDraft || it.draftOnly || !it.mine) continue
+				if (!['script', 'flow', 'app', 'raw_app'].includes(it.draftKind)) continue
+				if (staleFetched.has(it.key)) continue
+				staleFetched.add(it.key)
+				void fetchDraftBaseStale(it.draftKind, it.path, ws).then((stale) => {
+					if (stale) staleKeys = new Set(staleKeys).add(it.key)
+				})
+			}
+		})
+	})
+
+	// ── Deploy permission ────────────────────────────────────────────────────
+	// Preflight the shared checkDeployPermission (operator / RestrictDeployToDeployers)
+	// for the session workspace so the button disables with a reason instead of
+	// failing on click. `ok` defaults true while resolving (fail-open).
+	let deployPerm = $state<DeployPermission>({ ok: true })
+	let deployPermFetchedFor = ''
+	$effect(() => {
+		const ws = getArgs().workspaceId
+		untrack(() => {
+			if (!ws || deployPermFetchedFor === ws) return
+			deployPermFetchedFor = ws
+			// Reset to fail-open for the new workspace and drop a stale resolution
+			// (a slower fetch for the previous workspace must not gate this one).
+			deployPerm = { ok: true }
+			void checkDeployPermission(ws).then((perm) => {
+				if (deployPermFetchedFor === ws) deployPerm = perm
+			})
+		})
+	})
+
+	// ── Deploy execution ─────────────────────────────────────────────────────
+	// Per-item transient deploy state (keyed by DeployItem.key): loading or
+	// failed. Success has no status — the row's badge flipping to Deployed is
+	// the feedback. Reassigned, not mutated.
+	let deploymentStatus = $state<Record<string, DeploymentStatus>>({})
+	let deploying = $state(false)
+
+	function setStatus(key: string, s: DeploymentStatus | undefined) {
+		const next = { ...deploymentStatus }
+		if (s) next[key] = s
+		else delete next[key]
+		deploymentStatus = next
+	}
+
+	async function runPlan(entry: DeployPlanEntry): Promise<DeployResult> {
+		const cur = getArgs().workspaceId
+		switch (entry.op) {
+			case 'deploy_draft':
+				return deployDraft(entry.draftKind, entry.path, cur, {
+					draftOnly: entry.draftOnly,
+					rawApp: entry.rawApp
+				})
+			case 'discard':
+				return discardDraft(entry.draftKind, entry.path, cur, entry.draftOnly, entry.legacy)
+		}
+	}
+
+	function refreshData() {
+		void fetchDrafts()
+		getArgs().onDataChanged?.()
+	}
+
+	/** Deploy (or discard) a single item; returns whether it succeeded. */
+	async function deployOne(item: DeployItem, discard = false): Promise<boolean> {
+		const plan = discard ? discardPlanFor(item) : deployPlanFor(item)
+		if (!plan) return false
+		// Don't attempt a deploy we know the user can't make (no write permission
+		// on the path, or blocked by the operator / deployer rule) — the UI
+		// disables it too; this is the guard behind that.
+		if (!discard && (!item.canWrite || !deployPerm.ok)) return false
+		setStatus(item.key, { status: 'loading' })
+		deploying = true
+		try {
+			const res = await runPlan(plan)
+			setStatus(item.key, res.success ? undefined : { status: 'failed', error: res.error })
+			if (res.success) {
+				if (discard) {
+					getArgs().onItemDiscarded?.(item)
+				} else {
+					// Bridge under the DEPLOYED path's key too: the mask rewrite
+					// (onItemDeployed) re-keys a synthetic-storage row to displayPath.
+					deployedKeys = new Set(deployedKeys)
+						.add(item.key)
+						.add(maskKey(item.draftKind, item.displayPath))
+					getArgs().onItemDeployed?.(item)
+				}
+			}
+			return res.success
+		} finally {
+			deploying = false
+		}
+	}
+
+	/** Returns success so the UI can stage its post-deploy animation. */
+	async function deployRow(item: DeployItem): Promise<boolean> {
+		const ok = await deployOne(item)
+		if (ok) refreshData()
+		return ok
+	}
+
+	async function discardRow(item: DeployItem) {
+		if (await deployOne(item, true)) refreshData()
+	}
+
+	// ── Diff values (one resolver for tree + column) ─────────────────────────
+	async function loadDiffValues(item: DeployItem): Promise<DiffValues> {
+		const base = diffBaseFor(item, getArgs().workspaceId)
+		if (base.kind === 'draft') {
+			const { deployed, draft } = await getDraftDiffValues(
+				base.draftKind,
+				item.path,
+				base.workspaceId,
+				base.draftOnly
+			)
+			return { before: base.draftOnly ? undefined : deployed, after: draft }
+		}
+		const v = await getItemValue(base.deployKind, base.path, base.workspaceId).catch(
+			() => undefined
+		)
+		return { before: v, after: v }
+	}
+
+	return {
+		get items() {
+			return items
+		},
+		get loading() {
+			return loading
+		},
+		get error() {
+			return error
+		},
+		load,
+		loadDiffValues,
+		get deploying() {
+			return deploying
+		},
+		statusOf(key: string): DeploymentStatus | undefined {
+			return deploymentStatus[key]
+		},
+		/** Whether a draft row's base is stale (deployed head moved since). */
+		staleOf(key: string): boolean {
+			return staleKeys.has(key)
+		},
+		/** Whether the user may deploy into the session workspace. */
+		get deployPermission(): DeployPermission {
+			return deployPerm
+		},
+		deployRow,
+		discardRow
+	}
+}
+
+export type SessionDeployModel = ReturnType<typeof useSessionDeployModel>
diff --git a/frontend/src/lib/components/sessions/sessionDeployModel.test.ts b/frontend/src/lib/components/sessions/sessionDeployModel.test.ts
new file mode 100644
index 0000000000..7fa4e3cca8
--- /dev/null
+++ b/frontend/src/lib/components/sessions/sessionDeployModel.test.ts
@@ -0,0 +1,232 @@
+import { describe, it, expect } from 'vitest'
+import type { UserDraftItemKind } from '$lib/gen'
+import type { DraftItem } from '$lib/workspaceDrafts.svelte'
+import {
+	buildDeployItems,
+	maskOnlyCandidates,
+	badgeOf,
+	actionFor,
+	diffBaseFor,
+	badgeCounts,
+	deployPlanFor,
+	discardPlanFor
+} from './sessionDeployModel'
+import { maskKey } from './modifiedItemsMask'
+
+// ── Fixtures ────────────────────────────────────────────────────────────────
+
+function draft(kind: UserDraftItemKind, path: string, over: Partial<DraftItem> = {}): DraftItem {
+	return {
+		kind,
+		path,
+		summary: undefined,
+		draft_path: undefined,
+		draft_only: false,
+		legacy_draft: false,
+		raw_app: kind === 'raw_app',
+		can_write: true,
+		draft_users: undefined,
+		mine: true,
+		...over
+	}
+}
+
+// ── buildDeployItems ─────────────────────────────────────────────────────────
+
+describe('buildDeployItems', () => {
+	it('a draft is a live (not done) row carrying the draft flags', () => {
+		const items = buildDeployItems({
+			draftItems: [draft('script', 'u/a/foo', { draft_only: true })]
+		})
+		expect(items).toHaveLength(1)
+		expect(items[0].hasDraft).toBe(true)
+		expect(items[0].done).toBe(false)
+		expect(items[0].draftOnly).toBe(true)
+		expect(items[0].key).toBe(maskKey('script', 'u/a/foo'))
+	})
+
+	it('maps the trigger taxonomy to the deploy kind (trigger_schedule → schedule)', () => {
+		const items = buildDeployItems({ draftItems: [draft('trigger_schedule', 'u/a/sched')] })
+		expect(items[0].deployKind).toBe('schedule')
+		expect(items[0].draftKind).toBe('trigger_schedule')
+	})
+
+	it('maps both email draft kinds to the email_trigger deploy kind', () => {
+		const items = buildDeployItems({
+			draftItems: [draft('trigger_email', 'u/a/em'), draft('trigger_default_email', 'u/a/dem')]
+		})
+		expect(items.map((i) => i.deployKind)).toEqual(['email_trigger', 'email_trigger'])
+	})
+
+	it('mask scopes drafts to touched items', () => {
+		const mask = new Set([maskKey('script', 'u/a/keep')])
+		const items = buildDeployItems({
+			draftItems: [draft('script', 'u/a/keep'), draft('flow', 'u/a/other')],
+			mask
+		})
+		expect(items.map((i) => i.path)).toEqual(['u/a/keep'])
+	})
+
+	it('mask-only entries that still exist surface as terminal deployed rows', () => {
+		const key = maskKey('script', 'u/a/done')
+		const items = buildDeployItems({
+			draftItems: [],
+			mask: new Set([key]),
+			existingKeys: new Set([key])
+		})
+		expect(items).toHaveLength(1)
+		expect(items[0].done).toBe(true)
+		expect(items[0].hasDraft).toBe(false)
+		expect(items[0].path).toBe('u/a/done')
+	})
+
+	it('a mask-only entry that no longer exists (discarded or deleted) is dropped', () => {
+		const key = maskKey('script', 'u/a/gone')
+		// Existence unresolved → no mask-only rows yet.
+		expect(buildDeployItems({ draftItems: [], mask: new Set([key]) })).toHaveLength(0)
+		// Existence resolved to gone → dropped.
+		expect(
+			buildDeployItems({ draftItems: [], mask: new Set([key]), existingKeys: new Set() })
+		).toHaveLength(0)
+	})
+
+	it('a draft covers its mask entry (no duplicate deployed row)', () => {
+		const key = maskKey('script', 'u/a/foo')
+		const items = buildDeployItems({
+			draftItems: [draft('script', 'u/a/foo')],
+			mask: new Set([key]),
+			existingKeys: new Set([key])
+		})
+		expect(items).toHaveLength(1)
+		expect(items[0].hasDraft).toBe(true)
+	})
+
+	it('maskOnlyCandidates returns keys not covered by a draft', () => {
+		const cands = maskOnlyCandidates({
+			draftItems: [draft('script', 'u/a/draft')],
+			mask: new Set([maskKey('script', 'u/a/draft'), maskKey('trigger_schedule', 'u/a/done')])
+		})
+		expect(cands.map((c) => c.key)).toEqual([maskKey('trigger_schedule', 'u/a/done')])
+		expect(cands[0].deployKind).toBe('schedule')
+	})
+
+	it('no mask lists every draft', () => {
+		const items = buildDeployItems({
+			draftItems: [draft('script', 'u/a/x'), draft('flow', 'u/a/y')]
+		})
+		expect(items).toHaveLength(2)
+	})
+})
+
+// ── badge ────────────────────────────────────────────────────────────────────
+
+describe('badgeOf / badgeCounts', () => {
+	it('draft row → draft; deployed row → deployed', () => {
+		const key = maskKey('script', 'u/a/done')
+		const items = buildDeployItems({
+			draftItems: [draft('script', 'u/a/d')],
+			mask: new Set([maskKey('script', 'u/a/d'), key]),
+			existingKeys: new Set([key])
+		})
+		const by = new Map(items.map((i) => [i.path, i]))
+		expect(badgeOf(by.get('u/a/d')!)).toBe('draft')
+		expect(badgeOf(by.get('u/a/done')!)).toBe('deployed')
+		expect(badgeCounts(items)).toEqual({ draft: 1, deployed: 1 })
+	})
+})
+
+// ── action ──────────────────────────────────────────────────────────────────
+
+describe('actionFor', () => {
+	it('draft → Deploy + discard secondary', () => {
+		const [item] = buildDeployItems({ draftItems: [draft('script', 'u/a/f')] })
+		const a = actionFor(item)
+		expect(a.op).toBe('deploy_draft')
+		expect(a.label).toBe('Deploy')
+		expect(a.secondary?.[0].op).toBe('discard')
+	})
+
+	it('draft-only discard is labelled "Discard draft"', () => {
+		const [item] = buildDeployItems({
+			draftItems: [draft('script', 'u/a/f', { draft_only: true })]
+		})
+		expect(actionFor(item).secondary?.[0].label).toBe('Discard draft')
+	})
+
+	it('deployed (done) → op none', () => {
+		const key = maskKey('script', 'u/a/done')
+		const [item] = buildDeployItems({
+			draftItems: [],
+			mask: new Set([key]),
+			existingKeys: new Set([key])
+		})
+		expect(actionFor(item).op).toBe('none')
+	})
+})
+
+// ── diff base ───────────────────────────────────────────────────────────────
+
+describe('diffBaseFor', () => {
+	it('draft row → deployed↔draft base', () => {
+		const [item] = buildDeployItems({
+			draftItems: [draft('script', 'u/a/f', { draft_only: true })]
+		})
+		const b = diffBaseFor(item, 'ws')
+		expect(b.kind).toBe('draft')
+		if (b.kind === 'draft') {
+			expect(b.draftKind).toBe('script')
+			expect(b.draftOnly).toBe(true)
+			expect(b.workspaceId).toBe('ws')
+		}
+	})
+
+	it('deployed row → self base in the session workspace', () => {
+		const key = maskKey('script', 'u/a/done')
+		const [item] = buildDeployItems({
+			draftItems: [],
+			mask: new Set([key]),
+			existingKeys: new Set([key])
+		})
+		const b = diffBaseFor(item, 'ws')
+		expect(b.kind).toBe('self')
+		if (b.kind === 'self') {
+			expect(b.workspaceId).toBe('ws')
+			expect(b.path).toBe('u/a/done')
+		}
+	})
+})
+
+// ── deploy plan ─────────────────────────────────────────────────────────────
+
+describe('deployPlanFor / discardPlanFor', () => {
+	it('draft → deploy_draft carrying rawApp/draftOnly', () => {
+		const [item] = buildDeployItems({
+			draftItems: [draft('raw_app', 'u/a/app', { raw_app: true, draft_only: true })]
+		})
+		const p = deployPlanFor(item)!
+		expect(p.op).toBe('deploy_draft')
+		expect(p.rawApp).toBe(true)
+		expect(p.draftOnly).toBe(true)
+	})
+
+	it('deployed (done) rows have no plan', () => {
+		const key = maskKey('script', 'u/a/done')
+		const [item] = buildDeployItems({
+			draftItems: [],
+			mask: new Set([key]),
+			existingKeys: new Set([key])
+		})
+		expect(item.done).toBe(true)
+		expect(deployPlanFor(item)).toBeUndefined()
+		expect(discardPlanFor(item)).toBeUndefined()
+	})
+
+	it('discardPlanFor carries the legacy flag', () => {
+		const [d] = buildDeployItems({
+			draftItems: [draft('script', 'u/a/f', { legacy_draft: true })]
+		})
+		const p = discardPlanFor(d)!
+		expect(p.op).toBe('discard')
+		expect(p.legacy).toBe(true)
+	})
+})
diff --git a/frontend/src/lib/components/sessions/sessionDeployModel.ts b/frontend/src/lib/components/sessions/sessionDeployModel.ts
new file mode 100644
index 0000000000..173f732132
--- /dev/null
+++ b/frontend/src/lib/components/sessions/sessionDeployModel.ts
@@ -0,0 +1,274 @@
+import type { UserDraftItemKind } from '$lib/gen'
+import type { DraftItem } from '$lib/workspaceDrafts.svelte'
+import type { Kind } from '$lib/utils_deployable'
+import { maskKey } from './modifiedItemsMask'
+
+// Unified item model for the session Review & Deploy surface. This is the pure,
+// UI-free core: every item the session touched is either a pending **draft** or
+// **deployed** in the session workspace (terminal). Deploying always lands in
+// the session's own workspace — promoting a fork's changes to its parent is the
+// compare page's concern, not modeled here.
+//
+// Kept free of Svelte runes and async so it unit-tests in the node project. The
+// reactive wrapper (data loading, deploy execution) lives in the sibling
+// `.svelte.ts` and consumes these functions.
+
+// ── Item taxonomy bridge ────────────────────────────────────────────────────
+// The draft list speaks UserDraftItemKind (`trigger_schedule`, `raw_app`); the
+// deploy utils speak the layout `Kind` (`schedule`, `raw_app`, `http_trigger`).
+// This maps draft→deploy to key deploy calls and row icons. Only non-identity
+// cases listed; everything else is identity.
+const DEPLOY_KIND_BY_DRAFT_KIND: Partial<Record<UserDraftItemKind, Kind>> = {
+	trigger_schedule: 'schedule',
+	trigger_http: 'http_trigger',
+	trigger_websocket: 'websocket_trigger',
+	trigger_kafka: 'kafka_trigger',
+	trigger_nats: 'nats_trigger',
+	trigger_postgres: 'postgres_trigger',
+	trigger_mqtt: 'mqtt_trigger',
+	trigger_sqs: 'sqs_trigger',
+	trigger_gcp: 'gcp_trigger',
+	trigger_azure: 'azure_trigger',
+	// Both email draft kinds deploy as the one email trigger kind: the editor
+	// saves per-path email-trigger drafts as `trigger_email`, the fork diff
+	// speaks `trigger_default_email`.
+	trigger_default_email: 'email_trigger',
+	trigger_email: 'email_trigger',
+	raw_app: 'raw_app'
+}
+
+function deployKindOf(draftKind: UserDraftItemKind, rawApp: boolean): Kind {
+	if (rawApp) return 'raw_app'
+	return DEPLOY_KIND_BY_DRAFT_KIND[draftKind] ?? (draftKind as unknown as Kind)
+}
+
+// ── Public types ────────────────────────────────────────────────────────────
+
+export interface DeployItem {
+	/** Canonical identity `${UserDraftItemKind}:${path}`. */
+	key: string
+	/** Layout/deploy kind (script, flow, raw_app, http_trigger, schedule…). */
+	deployKind: Kind
+	/** UserDraftItemKind for draft ops. */
+	draftKind: UserDraftItemKind
+	path: string
+	/** Friendly path for display; storage `path` stays the op/edit key. */
+	displayPath: string
+	summary?: string
+	/** Deployed with no pending draft — the terminal state. */
+	done: boolean
+	hasDraft: boolean
+	draftOnly: boolean
+	draftUsers?: { username?: string | null }[]
+	/** Own draft (deployable/discardable). */
+	mine: boolean
+	canWrite: boolean
+	/** Legacy workspace-level draft (drives discard's `legacy` flag). */
+	legacy: boolean
+	rawApp: boolean
+}
+
+export interface BuildInput {
+	draftItems: DraftItem[]
+	/** Chat-modified-items mask (`UserDraftItemKind:path`). When set, only masked
+	 *  items are included, and mask-only entries (no draft) surface as terminal
+	 *  deployed rows — but only when confirmed to still exist (see `existingKeys`). */
+	mask?: Set<string>
+	/** Mask keys confirmed to still exist in the workspace (deployed). A mask-only
+	 *  key that isn't here is treated as gone (a discarded draft or a deleted item)
+	 *  and dropped, so it doesn't masquerade as deployed. Undefined → no mask-only
+	 *  rows are emitted yet (existence still resolving). */
+	existingKeys?: Set<string>
+}
+
+// ── Build: draft list + mask-only deployed rows into unified items ──────────
+
+export function buildDeployItems(input: BuildInput): DeployItem[] {
+	const { draftItems, mask, existingKeys } = input
+	const scopedDrafts = mask
+		? draftItems.filter((it) => mask.has(maskKey(it.kind, it.path)))
+		: draftItems
+
+	const out: DeployItem[] = []
+	const seen = new Set<string>()
+
+	// 1. Pending drafts.
+	for (const it of scopedDrafts) {
+		const canonical = maskKey(it.kind, it.path)
+		if (seen.has(canonical)) continue
+		seen.add(canonical)
+		out.push({
+			key: canonical,
+			deployKind: deployKindOf(it.kind, it.raw_app),
+			draftKind: it.kind,
+			path: it.path,
+			displayPath: it.draft_path ?? it.path,
+			summary: it.summary,
+			done: false,
+			hasDraft: true,
+			draftOnly: it.draft_only,
+			draftUsers: it.draft_users,
+			mine: it.mine,
+			canWrite: it.can_write,
+			legacy: it.legacy_draft,
+			rawApp: it.raw_app
+		})
+	}
+
+	// 2. Mask-only items (touched by the chat, no pending draft) → terminal
+	//    deployed rows, but ONLY when confirmed to still exist. A discarded draft
+	//    or a deleted item leaves a mask entry with no item; without this guard it
+	//    would masquerade as deployed.
+	if (mask) {
+		for (const k of mask) {
+			if (seen.has(k)) continue
+			if (!existingKeys?.has(k)) continue
+			const sep = k.indexOf(':')
+			if (sep < 0) continue
+			const udk = k.slice(0, sep) as UserDraftItemKind
+			const path = k.slice(sep + 1)
+			seen.add(k)
+			out.push({
+				key: k,
+				deployKind: deployKindOf(udk, udk === 'raw_app'),
+				draftKind: udk,
+				path,
+				displayPath: path,
+				summary: undefined,
+				done: true,
+				hasDraft: false,
+				draftOnly: false,
+				draftUsers: undefined,
+				mine: true,
+				canWrite: true,
+				legacy: false,
+				rawApp: udk === 'raw_app'
+			})
+		}
+	}
+
+	return out
+}
+
+/** Mask keys not covered by a current draft — the candidates for a terminal
+ *  deployed row. The reactive layer existence-checks these (in the session
+ *  workspace) to tell a deployed item from a discarded/deleted one, then feeds
+ *  the survivors back as `existingKeys`. */
+export function maskOnlyCandidates(
+	input: Omit<BuildInput, 'existingKeys'>
+): { key: string; deployKind: Kind; draftKind: UserDraftItemKind; path: string }[] {
+	const { draftItems, mask } = input
+	if (!mask) return []
+	const covered = new Set<string>()
+	for (const it of draftItems) {
+		const k = maskKey(it.kind, it.path)
+		if (mask.has(k)) covered.add(k)
+	}
+	const out: { key: string; deployKind: Kind; draftKind: UserDraftItemKind; path: string }[] = []
+	for (const k of mask) {
+		if (covered.has(k)) continue
+		const sep = k.indexOf(':')
+		if (sep < 0) continue
+		const udk = k.slice(0, sep) as UserDraftItemKind
+		const path = k.slice(sep + 1)
+		out.push({ key: k, draftKind: udk, deployKind: deployKindOf(udk, udk === 'raw_app'), path })
+	}
+	return out
+}
+
+// ── Status badge ─────────────────────────────────────────────────────────────
+
+export type BadgeKind = 'draft' | 'deployed'
+
+/** The single status badge a row shows: a pending draft, or deployed (green,
+ *  terminal). Every built row is one of the two. */
+export function badgeOf(item: DeployItem): BadgeKind {
+	return item.done ? 'deployed' : 'draft'
+}
+
+/** Per-status tallies over `badgeOf` — the bar's at-a-glance readout, so its
+ *  counts always agree with the badges the drawer rows show. */
+export function badgeCounts(items: DeployItem[]): Record<BadgeKind, number> {
+	const out: Record<BadgeKind, number> = { draft: 0, deployed: 0 }
+	for (const it of items) out[badgeOf(it)]++
+	return out
+}
+
+// ── Action ──────────────────────────────────────────────────────────────────
+
+export type DeployOp = 'deploy_draft' | 'discard' | 'none'
+
+export interface DeployAction {
+	op: DeployOp
+	label: string
+	secondary?: DeployAction[]
+}
+
+/** The primary (and secondary) action for a row: a draft deploys into the
+ *  session workspace, a deployed row has nothing left to do. */
+export function actionFor(item: DeployItem): DeployAction {
+	if (item.done) return { op: 'none', label: 'Done' }
+	return {
+		op: 'deploy_draft',
+		label: 'Deploy',
+		secondary: [{ op: 'discard', label: item.draftOnly ? 'Discard draft' : 'Discard' }]
+	}
+}
+
+// ── Diff base ───────────────────────────────────────────────────────────────
+
+export type DiffBase =
+	| { kind: 'draft'; draftKind: UserDraftItemKind; workspaceId: string; draftOnly: boolean }
+	| { kind: 'self'; deployKind: Kind; path: string; workspaceId: string }
+
+/** Where a row's before/after diff values come from. A draft row diffs
+ *  deployed↔draft; a deployed row has nothing to diff but its value is still
+ *  loadable (`self`) — the sidebar unwraps a deployed raw app into its files.
+ *  The executor maps this to getDraftDiffValues / getItemValue. */
+export function diffBaseFor(item: DeployItem, workspaceId: string): DiffBase {
+	if (item.hasDraft) {
+		return { kind: 'draft', draftKind: item.draftKind, workspaceId, draftOnly: item.draftOnly }
+	}
+	return { kind: 'self', deployKind: item.deployKind, path: item.path, workspaceId }
+}
+
+// ── Deploy plan (executed by the reactive layer) ─────────────────────────────
+
+export interface DeployPlanEntry {
+	key: string
+	op: Exclude<DeployOp, 'none'>
+	draftKind: UserDraftItemKind
+	path: string
+	draftOnly: boolean
+	rawApp: boolean
+	legacy: boolean
+}
+
+/** Concrete util arguments for deploying one item's draft into the session
+ *  workspace. Returns undefined for deployed (terminal) rows. Mirrors actionFor. */
+export function deployPlanFor(item: DeployItem): DeployPlanEntry | undefined {
+	if (!item.hasDraft) return undefined
+	return {
+		key: item.key,
+		op: 'deploy_draft',
+		draftKind: item.draftKind,
+		path: item.path,
+		draftOnly: item.draftOnly,
+		rawApp: item.rawApp,
+		legacy: item.legacy
+	}
+}
+
+/** Discard plan for a draft row (secondary action). */
+export function discardPlanFor(item: DeployItem): DeployPlanEntry | undefined {
+	if (!item.hasDraft) return undefined
+	return {
+		key: item.key,
+		op: 'discard',
+		draftKind: item.draftKind,
+		path: item.path,
+		draftOnly: item.draftOnly,
+		rawApp: item.rawApp,
+		legacy: item.legacy
+	}
+}
diff --git a/frontend/src/lib/components/sessions/sessionRuntime.svelte.ts b/frontend/src/lib/components/sessions/sessionRuntime.svelte.ts
index f8a9e1045d..a1aa92cbdc 100644
--- a/frontend/src/lib/components/sessions/sessionRuntime.svelte.ts
+++ b/frontend/src/lib/components/sessions/sessionRuntime.svelte.ts
@@ -7,12 +7,10 @@ import {
 	AppService,
 	FlowService,
 	ScriptService,
-	WorkspaceService,
 	type Flow,
 	type NewScript,
 	type Script,
-	type UserDraftOverlay,
-	type WorkspaceComparison
+	type UserDraftOverlay
 } from '$lib/gen'
 
 // `get_draft=true` does NOT merge: the top-level fields stay the deployed
@@ -141,37 +139,13 @@ export interface SessionRuntime {
 	requestRuntimeLogs(limit: number): Promise<RawAppRuntimeLogEntry[] | undefined>
 	setAppRunsProvider(provider: RawAppRunsProvider | undefined): void
 	getAppRuns(): RawAppRunSummary[] | undefined
-	// Discard the local draft + refresh the fork diff + force-reload the editor,
-	// so the preview matches the deployed version. Used by editor onDeploy + the
-	// chat deploy handler.
+	// Discard the local draft + force-reload the editor, so the preview matches
+	// the deployed version. Used by editor onDeploy + the chat deploy handler.
 	syncPreviewWithDeployed(
 		workspace: string,
 		kind: 'script' | 'flow' | 'raw_app',
 		path: string
 	): void
-	// Fork comparison cache: shared between SessionForkBar (count + dropdown)
-	// and any future consumer that needs the parent ↔ fork diff list. Keyed
-	// implicitly by the (parent, fork) pair last passed to ensureForkComparison;
-	// invalidateForkComparison() forces a refresh after a known-mutating action.
-	readonly forkComparison: { val: WorkspaceComparison | undefined }
-	readonly loadingForkComparison: boolean
-	ensureForkComparison(parent: string, fork: string): Promise<void>
-	invalidateForkComparison(): void
-	// Force-refresh against the last (parent, fork) pair the runtime
-	// fetched for. No-op if no comparison has ever been loaded. Useful
-	// for session-activation hooks that need a fresh count regardless of
-	// the dedupe key match.
-	refreshForkComparison(): Promise<void>
-	// Re-fetch the comparison shortly after a local mutation (e.g. an
-	// editor "Save draft"). The backend tally that registers the change
-	// lands asynchronously, so an immediate refresh races it — this
-	// schedules a couple of delayed refreshes so the fork-bar count
-	// updates without waiting for an AI turn or a tab refocus.
-	scheduleForkComparisonRefresh(): void
-	// Cancel pending fork-comparison refresh timers. Called by disposeRuntime so
-	// a torn-down (e.g. LRU-evicted, deleted) runtime can't fire a stray
-	// refreshForkComparisonNow / compareWorkspaces after it's gone.
-	dispose(): void
 }
 
 const runtimes = new SvelteMap<string, SessionRuntime>()
@@ -320,34 +294,6 @@ function createRuntime(session: Session): SessionRuntime {
 	let runtimeLogRequester: RawAppRuntimeLogRequester | undefined = undefined
 	let appRunsProvider: RawAppRunsProvider | undefined = undefined
 
-	const forkComparison: { val: WorkspaceComparison | undefined } = $state({ val: undefined })
-	let loadingForkComparison = $state(false)
-	let forkComparisonKey: string | undefined = undefined
-	let forkRefreshTimers: ReturnType<typeof setTimeout>[] = []
-
-	// Stale-while-revalidate re-fetch against the last (parent, fork) pair.
-	// Shared by refreshForkComparison() and scheduleForkComparisonRefresh().
-	async function refreshForkComparisonNow() {
-		const key = forkComparisonKey
-		if (!key) return
-		const sep = key.indexOf('|')
-		if (sep < 0) return
-		const parent = key.slice(0, sep)
-		const fork = key.slice(sep + 1)
-		if (loadingForkComparison) return
-		loadingForkComparison = true
-		try {
-			forkComparison.val = await WorkspaceService.compareWorkspaces({
-				workspace: parent,
-				targetWorkspaceId: fork
-			})
-		} catch (e) {
-			console.error('SessionRuntime: forkComparison refresh failed', e)
-		} finally {
-			loadingForkComparison = false
-		}
-	}
-
 	return {
 		sessionId: session.id,
 		manager,
@@ -645,7 +591,6 @@ function createRuntime(session: Session): SessionRuntime {
 		},
 
 		syncPreviewWithDeployed(workspace, kind, path) {
-			this.scheduleForkComparisonRefresh()
 			// After deploy the editor state equals the deployed value; the reload
 			// below re-seeds the cell from it, which must NOT POST as a fresh draft.
 			// The full-page editor guards this with discardDraftAfterDeploy, but the
@@ -671,63 +616,6 @@ function createRuntime(session: Session): SessionRuntime {
 		},
 		getAppRuns() {
 			return appRunsProvider ? appRunsProvider() : undefined
-		},
-
-		forkComparison,
-		get loadingForkComparison() {
-			return loadingForkComparison
-		},
-
-		async ensureForkComparison(parent: string, fork: string) {
-			const key = `${parent}|${fork}`
-			if (forkComparisonKey === key && forkComparison.val) return
-			if (loadingForkComparison && forkComparisonKey === key) return
-			forkComparisonKey = key
-			loadingForkComparison = true
-			try {
-				forkComparison.val = await WorkspaceService.compareWorkspaces({
-					workspace: parent,
-					targetWorkspaceId: fork
-				})
-			} catch (e) {
-				console.error('SessionRuntime: forkComparison fetch failed', e)
-				forkComparison.val = undefined
-				// On error, clear the key so the next call retries.
-				if (forkComparisonKey === key) forkComparisonKey = undefined
-			} finally {
-				loadingForkComparison = false
-			}
-		},
-
-		invalidateForkComparison() {
-			forkComparisonKey = undefined
-			forkComparison.val = undefined
-		},
-
-		// Stale-while-revalidate: re-fetch in place so the cached status
-		// (driving the sidebar dot, fork bar, etc.) stays put until the new
-		// result lands. Clearing forkComparison.val here flickered the icon
-		// back to the neutral GitFork on every session-activate refresh.
-		refreshForkComparison() {
-			return refreshForkComparisonNow()
-		},
-
-		scheduleForkComparisonRefresh() {
-			// The backend fork tally registers a draft save (createScript
-			// draft_only / DraftService.createDraft) asynchronously — ~300ms
-			// after the API call returns — so an immediate refresh races it.
-			// Fetch once after the tally typically lands, then again as a
-			// backstop for slower backends. Coalesce rapid saves by clearing
-			// any still-pending timers first.
-			for (const t of forkRefreshTimers) clearTimeout(t)
-			forkRefreshTimers = [
-				setTimeout(() => void refreshForkComparisonNow(), 700),
-				setTimeout(() => void refreshForkComparisonNow(), 2200)
-			]
-		},
-		dispose() {
-			for (const t of forkRefreshTimers) clearTimeout(t)
-			forkRefreshTimers = []
 		}
 	}
 }
@@ -741,11 +629,21 @@ async function initRuntime(runtime: SessionRuntime, session: Session) {
 	await manager.attachedFiles.restore(session.id, !session.transient)
 	await ensureChatIdsSeeded(manager.historyManager)
 
+	// Keep the session record's chatId following the manager's active chat: a
+	// "/clear" rotation or a history switch would otherwise leave it pointing at
+	// the previous chat, and the compare-page handoff (`from_session`) would
+	// preselect the wrong chat's items.
+	manager.onChatRotated = (chatId) => setSessionChatId(session.id, chatId)
+
 	if (session.chatId) {
 		manager.historyManager.setCurrentChatId(session.chatId)
 		await manager.historyManager.tagChatWithSession(session.chatId, session.id)
 		await manager.loadPastChat(session.chatId)
 	} else {
+		// Brand-new session chat: start tracking modified items now (empty mask)
+		// so the session bar filters to this chat's changes from the first turn.
+		// (loadPastChat handles seeding for the existing-chat branch above.)
+		manager.initModifiedItemsTracking()
 		setSessionChatId(session.id, manager.historyManager.getCurrentChatId())
 	}
 }
@@ -763,7 +661,6 @@ export function getOrCreateRuntime(session: Session): SessionRuntime {
 export function disposeRuntime(sessionId: string) {
 	const runtime = runtimes.get(sessionId)
 	if (!runtime) return
-	runtime.dispose()
 	runtime.manager.cancel('runtime disposed')
 	runtime.manager.historyManager.close()
 	runtimes.delete(sessionId)
diff --git a/frontend/src/lib/components/sessions/sessionState.svelte.ts b/frontend/src/lib/components/sessions/sessionState.svelte.ts
index 4d976a163f..a4ce0d0853 100644
--- a/frontend/src/lib/components/sessions/sessionState.svelte.ts
+++ b/frontend/src/lib/components/sessions/sessionState.svelte.ts
@@ -32,7 +32,7 @@ export function syncWorkspaceTo(workspaceId: string | undefined): void {
 	if (workspaceId === get(workspaceStore)) return
 	switchWorkspace(workspaceId)
 }
-import { WorkspaceService, type WorkspaceComparison } from '$lib/gen'
+import { WorkspaceService } from '$lib/gen'
 import { sendUserToast } from '$lib/toast'
 import type HistoryManager from '$lib/components/copilot/chat/HistoryManager.svelte'
 import { onUserChange } from '$lib/userScopedStorage'
@@ -52,23 +52,9 @@ export const EDITOR_TARGET_KINDS: ReadonlySet<SessionTarget['kind']> = new Set([
 	'pipeline'
 ])
 
-// Lifecycle status for a fork session. Git-parallel:
-//   in_sync     — fork is up to date with parent (or only behind — treated
-//                 the same since the user has no unmerged work either way).
-//   ahead       — fork has unmerged changes vs parent (branch ahead).
-//   diverged    — fork has unmerged changes AND parent has moved (branch
-//                 diverged from upstream — potential conflicts).
-//   unavailable — fork workspace is no longer in the user's list (deleted,
-//                 archived, or access revoked). Read-only fallback.
-//
-// `undefined` is the loading / not-applicable state (root session,
-// comparison not yet fetched).
-export type ForkStatus = 'in_sync' | 'ahead' | 'diverged' | 'unavailable'
-
 // Whether the session points at a workspace that is itself a fork (i.e.
-// has a parent). Independent of comparison-fetch state — used by the
-// sidebar to pick between a root (Building) icon and a fork-status icon
-// before the comparison has loaded.
+// has a parent). Used by the sidebar to pick between a root (Building)
+// icon and a fork icon.
 //
 // Sessions whose committed workspace is no longer in the user's list are
 // still treated as forks (the "unavailable" terminal state) so we don't
@@ -81,29 +67,6 @@ export function isForkSession(session: Session, allWorkspaces: UserWorkspace[]):
 	return !!ws.parent_workspace_id
 }
 
-export function deriveForkStatus(
-	session: Session,
-	allWorkspaces: UserWorkspace[],
-	comparison: WorkspaceComparison | undefined
-): ForkStatus | undefined {
-	const wsId = session.workspace_id ?? session.pending_workspace_id
-	if (!wsId) return undefined
-	const ws = allWorkspaces.find((w) => w.id === wsId)
-	// Committed fork workspaces that disappear from the user's list
-	// (deleted, archived, or access lost) are flagged unavailable so
-	// the UI can render a terminal state without trying to switch into
-	// them. Drafts whose pending workspace also vanished get the same
-	// treatment.
-	if (!ws) return session.workspace_id ? 'unavailable' : undefined
-	if (!ws.parent_workspace_id) return undefined
-	if (!comparison) return undefined
-	const ahead = comparison.summary?.total_ahead ?? 0
-	const behind = comparison.summary?.total_behind ?? 0
-	if (ahead > 0 && behind > 0) return 'diverged'
-	if (ahead > 0) return 'ahead'
-	return 'in_sync'
-}
-
 export type PendingFork = {
 	// Existing workspace to fork from (drives routing/scope pre-send).
 	parent_workspace_id: string
diff --git a/frontend/src/lib/components/sessions/sessionState.test.ts b/frontend/src/lib/components/sessions/sessionState.test.ts
index 851ab27153..d81d797737 100644
--- a/frontend/src/lib/components/sessions/sessionState.test.ts
+++ b/frontend/src/lib/components/sessions/sessionState.test.ts
@@ -3,7 +3,6 @@ import { get } from 'svelte/store'
 import {
 	commitSessionWorkspace,
 	decideSessionLifecycle,
-	deriveForkStatus,
 	isForkSession,
 	renameSession,
 	setGeneratedSessionSummary,
@@ -16,7 +15,7 @@ import {
 	workspaceStore,
 	type UserWorkspace
 } from '$lib/stores'
-import { WorkspaceService, type WorkspaceComparison } from '$lib/gen'
+import { WorkspaceService } from '$lib/gen'
 
 // Force createWorkspaceFork to fail so we can pin commitSessionWorkspace's
 // failure contract (the invariant the beforeSend abort fix relies on).
@@ -40,9 +39,6 @@ function session(over: Partial<Session> = {}): Session {
 function ws(id: string, parent?: string): UserWorkspace {
 	return { id, name: id, parent_workspace_id: parent } as unknown as UserWorkspace
 }
-function comparison(total_ahead: number, total_behind: number): WorkspaceComparison {
-	return { summary: { total_ahead, total_behind } } as unknown as WorkspaceComparison
-}
 
 describe('isForkSession', () => {
 	it('is false for a draft with no workspace at all', () => {
@@ -72,60 +68,6 @@ describe('isForkSession', () => {
 	})
 })
 
-describe('deriveForkStatus', () => {
-	it('is undefined for a draft with no workspace', () => {
-		expect(deriveForkStatus(session(), [], undefined)).toBeUndefined()
-	})
-
-	it('is unavailable when a committed workspace is no longer in the list', () => {
-		expect(deriveForkStatus(session({ workspace_id: 'gone' }), [], comparison(0, 0))).toBe(
-			'unavailable'
-		)
-	})
-
-	it('is undefined when a draft pending workspace is missing (not yet committed)', () => {
-		expect(
-			deriveForkStatus(session({ pending_workspace_id: 'gone' }), [], undefined)
-		).toBeUndefined()
-	})
-
-	it('is undefined for a non-fork (root) workspace', () => {
-		expect(
-			deriveForkStatus(session({ workspace_id: 'root' }), [ws('root')], comparison(3, 3))
-		).toBeUndefined()
-	})
-
-	it('is undefined for a fork before the comparison has loaded', () => {
-		expect(
-			deriveForkStatus(session({ workspace_id: 'fork' }), [ws('fork', 'root')], undefined)
-		).toBeUndefined()
-	})
-
-	it('is diverged when the fork is both ahead and behind', () => {
-		expect(
-			deriveForkStatus(session({ workspace_id: 'fork' }), [ws('fork', 'root')], comparison(2, 1))
-		).toBe('diverged')
-	})
-
-	it('is ahead when the fork has unmerged changes and the parent has not moved', () => {
-		expect(
-			deriveForkStatus(session({ workspace_id: 'fork' }), [ws('fork', 'root')], comparison(2, 0))
-		).toBe('ahead')
-	})
-
-	it('is in_sync when neither side is ahead', () => {
-		expect(
-			deriveForkStatus(session({ workspace_id: 'fork' }), [ws('fork', 'root')], comparison(0, 0))
-		).toBe('in_sync')
-	})
-
-	it('is in_sync when only the parent moved (behind-only, fork has no local changes)', () => {
-		expect(
-			deriveForkStatus(session({ workspace_id: 'fork' }), [ws('fork', 'root')], comparison(0, 2))
-		).toBe('in_sync')
-	})
-})
-
 describe('commitSessionWorkspace — fork-creation failure', () => {
 	it('returns undefined and drops pending_fork (so beforeSend aborts the send)', async () => {
 		const id = 'test-commit-fork-fail'
@@ -351,9 +293,12 @@ describe('decideSessionLifecycle — the never-orphaned rule (pure)', () => {
 	})
 
 	it('active workspace → unarchive only the ones WE archived (archivedByWorkspace)', () => {
-		expect(decideSessionLifecycle(mk({ archived: true, archivedByWorkspace: true }), 'active')).toEqual(
-			{ action: 'unarchive', patch: { archived: undefined, archivedByWorkspace: undefined } }
-		)
+		expect(
+			decideSessionLifecycle(mk({ archived: true, archivedByWorkspace: true }), 'active')
+		).toEqual({
+			action: 'unarchive',
+			patch: { archived: undefined, archivedByWorkspace: undefined }
+		})
 		// user-archived (no archivedByWorkspace flag) is left alone
 		expect(decideSessionLifecycle(mk({ archived: true }), 'active')).toEqual({ action: 'noop' })
 		expect(decideSessionLifecycle(mk(), 'active')).toEqual({ action: 'noop' })
diff --git a/frontend/src/lib/components/sidebar/SidebarContent.svelte b/frontend/src/lib/components/sidebar/SidebarContent.svelte
index 395ce00fa2..82f48c35b6 100644
--- a/frontend/src/lib/components/sidebar/SidebarContent.svelte
+++ b/frontend/src/lib/components/sidebar/SidebarContent.svelte
@@ -138,9 +138,28 @@
 			}
 		}
 
+		// Fork-scoped ducklake namespaces (metadata schemas + data files) — driven by the
+		// backend registry, so no per-lake selection is needed. Best-effort: a failure is
+		// surfaced but doesn't block the workspace delete (the registry rows survive a
+		// failed cleanup and re-creating the same fork id retries it — the toast tells the
+		// user something was left behind).
+		try {
+			const dlErrors = await WorkspaceService.dropForkedDucklakeNamespaces({ workspace })
+			for (const err of dlErrors) {
+				sendUserToast(err, true)
+			}
+		} catch (err) {
+			sendUserToast(`Failed to drop fork ducklake namespaces: ${err}`, true)
+		}
+
 		if (deleteForkedChildren && forkedDescendants.length > 0) {
 			for (const child of forkedDescendants) {
 				try {
+					await WorkspaceService.dropForkedDucklakeNamespaces({ workspace: child.id }).then(
+						(errs) => errs.forEach((e) => sendUserToast(e, true)),
+						(err) =>
+							sendUserToast(`Failed to drop fork ducklake namespaces of ${child.id}: ${err}`, true)
+					)
 					await WorkspaceService.deleteWorkspace({ workspace: child.id })
 				} catch (err) {
 					sendUserToast(`Failed to delete forked child ${child.id}: ${err}`, true)
diff --git a/frontend/src/lib/components/triggers/utils.ts b/frontend/src/lib/components/triggers/utils.ts
index 231de5cea4..3d17491791 100644
--- a/frontend/src/lib/components/triggers/utils.ts
+++ b/frontend/src/lib/components/triggers/utils.ts
@@ -1,4 +1,14 @@
-import { Webhook, Mail, Calendar, Route, Unplug, Database, Terminal } from 'lucide-svelte'
+import {
+	Webhook,
+	Mail,
+	Calendar,
+	Route,
+	Unplug,
+	Database,
+	Terminal,
+	Timer,
+	Zap
+} from 'lucide-svelte'
 import KafkaIcon from '$lib/components/icons/KafkaIcon.svelte'
 import NatsIcon from '$lib/components/icons/NatsIcon.svelte'
 import MqttIcon from '$lib/components/icons/MqttIcon.svelte'
@@ -82,7 +92,8 @@ export const jobTriggerKinds: JobTriggerKind[] = [
 	'azure',
 	'google',
 	'github',
-	'asset'
+	'asset',
+	'freshness'
 ]
 
 export type Trigger = {
@@ -118,7 +129,12 @@ export const triggerIconMap = {
 	cli: Terminal,
 	nextcloud: NextcloudIcon,
 	google: GoogleIcon,
-	github: GithubIcon
+	github: GithubIcon,
+	// Job-attribution-only kinds (no trigger CRUD page): the pipeline asset
+	// cascade and the freshness watchdog. Needed so the Runs filter and job
+	// detail render these trigger kinds instead of a blank label / no icon.
+	asset: Zap,
+	freshness: Timer
 }
 
 export const triggerDisplayNamesMap = {
@@ -139,8 +155,12 @@ export const triggerDisplayNamesMap = {
 	cli: 'CLI',
 	nextcloud: 'Nextcloud',
 	google: 'Google',
-	github: 'GitHub'
-} as const satisfies Record<TriggerType, string>
+	github: 'GitHub',
+	asset: 'Asset cascade',
+	freshness: 'Freshness'
+	// `asset` / `freshness` are job-attribution-only (JobTriggerKind, not
+	// TriggerType) — hence the union in the satisfies below.
+} as const satisfies Record<TriggerType | 'asset' | 'freshness', string>
 
 /**
  * Converts a TriggerType to a CaptureTriggerKind when a mapping exists
diff --git a/frontend/src/lib/components/workspaceSettings/CreateWorkspaceInner.svelte b/frontend/src/lib/components/workspaceSettings/CreateWorkspaceInner.svelte
index 2012870d3a..34f0277c4f 100644
--- a/frontend/src/lib/components/workspaceSettings/CreateWorkspaceInner.svelte
+++ b/frontend/src/lib/components/workspaceSettings/CreateWorkspaceInner.svelte
@@ -38,6 +38,7 @@
 	import { base } from '$lib/base'
 	import Label from '../Label.svelte'
 	import ForkDatatableSection from './ForkDatatableSection.svelte'
+	import ForkDucklakeSection from './ForkDucklakeSection.svelte'
 
 	interface Props {
 		isFork?: boolean
@@ -92,6 +93,7 @@
 	let checking = $state(false)
 
 	let forkDatatableSection: ReturnType<typeof ForkDatatableSection> | undefined = $state(undefined)
+	let forkDucklakeSection: ReturnType<typeof ForkDucklakeSection> | undefined = $state(undefined)
 
 	let workspaceColor: string | undefined = $state(undefined)
 	let colorEnabled = $state(false)
@@ -304,6 +306,7 @@
 					name,
 					color: colorEnabled && workspaceColor ? workspaceColor : undefined,
 					forked_datatables: forkedDatatables,
+					shared_ducklakes: forkDucklakeSection?.getSharedDucklakes() ?? [],
 					is_dev_workspace: createAsDevWorkspace,
 					lock_prod_deploy: createAsDevWorkspace && lockProdDeploy,
 					lock_prod_forking: createAsDevWorkspace && lockProdForking,
@@ -666,6 +669,7 @@
 						forkCreationLoading = false
 					}}
 				/>
+				<ForkDucklakeSection bind:this={forkDucklakeSection} />
 			{/if}
 			{#if !automateUsernameCreation}
 				<Label label="Your username in that workspace">
diff --git a/frontend/src/lib/components/workspaceSettings/DucklakeSettings.svelte b/frontend/src/lib/components/workspaceSettings/DucklakeSettings.svelte
index 4dd0ed0053..a0d29af434 100644
--- a/frontend/src/lib/components/workspaceSettings/DucklakeSettings.svelte
+++ b/frontend/src/lib/components/workspaceSettings/DucklakeSettings.svelte
@@ -1,6 +1,14 @@
 <script module lang="ts">
 	import { _ } from 'ag-grid-community'
 
+	export type DucklakeMaintenanceType = {
+		enabled: boolean
+		schedule?: string
+		retention_days?: number
+		compaction?: boolean
+		orphan_cleanup?: boolean
+	}
+
 	export type DucklakeSettingsType = {
 		ducklakes: {
 			name: string
@@ -13,6 +21,11 @@
 				path: string
 			}
 			extra_args?: string
+			// Fork workspaces only — stamped at fork creation, absent = isolated.
+			// Not editable here, but it MUST round-trip through save or a settings
+			// save in a shared fork would silently flip the lake to isolated.
+			fork_behavior?: 'isolated' | 'shared'
+			maintenance?: DucklakeMaintenanceType
 		}[]
 	}
 
@@ -44,7 +57,9 @@
 			s.ducklakes[ducklake.name] = {
 				catalog: ducklake.catalog,
 				storage: ducklake.storage,
-				extra_args: ducklake.extra_args || undefined
+				extra_args: ducklake.extra_args || undefined,
+				fork_behavior: ducklake.fork_behavior,
+				maintenance: ducklake.maintenance
 			}
 		}
 		return s
@@ -52,7 +67,15 @@
 </script>
 
 <script lang="ts">
-	import { Plus, SettingsIcon } from 'lucide-svelte'
+	import {
+		AlertTriangle,
+		ArrowUpRight,
+		ExternalLink,
+		GitFork,
+		Plus,
+		SettingsIcon,
+		Wrench
+	} from 'lucide-svelte'
 
 	import Button from '../common/button/Button.svelte'
 	import SettingsFooter from './SettingsFooter.svelte'
@@ -65,10 +88,12 @@
 	import Select from '../select/Select.svelte'
 	import ResourcePicker from '../ResourcePicker.svelte'
 	import { usePromise } from '$lib/svelte5Utils.svelte'
-	import { SettingService, WorkspaceService } from '$lib/gen'
+	import { ScheduleService, SettingService, WorkspaceService } from '$lib/gen'
 	import type { GetSettingsResponse } from '$lib/gen'
 
-	import { workspaceStore } from '$lib/stores'
+	import { enterpriseLicense, userWorkspaces, workspaceStore } from '$lib/stores'
+	import { base } from '$app/paths'
+	import Toggle from '../Toggle.svelte'
 	import { sendUserToast } from '$lib/toast'
 	import ExploreAssetButton from '../ExploreAssetButton.svelte'
 	import Tooltip from '../Tooltip.svelte'
@@ -177,6 +202,40 @@
 		}
 	}
 
+	function editableMaintenance(
+		ducklake: DucklakeSettingsType['ducklakes'][number]
+	): DucklakeMaintenanceType {
+		if (!ducklake.maintenance) ducklake.maintenance = { enabled: false }
+		return ducklake.maintenance
+	}
+
+	// Health of the managed maintenance schedules (push failures auto-disable
+	// them with an error; the schedules UI hides the reserved prefix, so this
+	// is the only surface where that state is visible).
+	const maintenanceHealth = resource(
+		[() => $workspaceStore, () => ducklakeSavedSettings],
+		async ([workspace, saved]) => {
+			const out: Record<string, { enabled: boolean; error?: string }> = {}
+			if (!workspace) return out
+			await Promise.all(
+				(saved?.ducklakes ?? [])
+					.filter((d) => d.maintenance?.enabled)
+					.map(async (d) => {
+						try {
+							const s = await ScheduleService.getSchedule({
+								workspace,
+								path: `f/ducklake_maintenance/${d.name}`
+							})
+							out[d.name] = { enabled: s.enabled ?? false, error: s.error ?? undefined }
+						} catch {
+							// no schedule row (e.g. save predates the feature): nothing to report
+						}
+					})
+			)
+			return out
+		}
+	)
+
 	let secondaryStorageNames = usePromise(
 		() => SettingService.getSecondaryStorageNames({ workspace: $workspaceStore! }),
 		{ loadInit: false }
@@ -186,16 +245,26 @@
 		secondaryStorageNames.refresh()
 	})
 
-	let tableHeadNames = ['Name', 'Catalog', 'Workspace storage', '', ''] as const
+	let tableHeadNames = ['Name', 'Catalog', 'Workspace storage', 'Maintenance', '', ''] as const
 
 	let tableHeadTooltips: Partial<Record<(typeof tableHeadNames)[number], string | undefined>> = {
 		Name: "Ducklakes are referenced in DuckDB scripts with the <code class='px-1 py-0.5 border rounded-md'>ATTACH 'ducklake://name' AS dl;</code> syntax",
 		Catalog: 'Ducklake needs an SQL database to store metadata about the data',
 		'Workspace storage':
-			'Where the data is actually stored, in parquet format. You need to configure a workspace storage first'
+			'Where the data is actually stored, in parquet format. You need to configure a workspace storage first',
+		Maintenance:
+			'Scheduled snapshot expiry, small-file compaction and orphaned-file cleanup, run as jobs on a managed per-lake schedule (EE)'
 	}
 
 	let confirmationModal = createAsyncConfirmationModal()
+
+	// Same fork detection as the backend's isolation gate: parent link (dev workspaces are
+	// prefix-less) or the wm-fork- prefix (an orphaned fork keeps isolation after its parent
+	// is deleted).
+	let isFork = $derived(
+		$userWorkspaces.find((w) => w.id === $workspaceStore)?.parent_workspace_id != null ||
+			($workspaceStore?.startsWith('wm-fork-') ?? false)
+	)
 </script>
 
 <div class="flex flex-col gap-4 mb-8">
@@ -208,6 +277,20 @@
 	</div>
 </div>
 
+{#if isFork && ducklakeSettings.ducklakes.length > 0}
+	<div class="mb-4">
+		<Alert title="Fork data environments" type="info">
+			This workspace is a fork, and these settings are its own copy. Lakes marked
+			<span class="font-semibold">isolated</span> read the parent's tables through defer views and
+			write to a fork-scoped namespace that is cleaned up when the fork is deleted. Lakes marked
+			<span class="font-semibold">shared with parent</span> read and write the parent's physical
+			lake directly — editing their catalog or storage here repoints the shared lake for this
+			fork's jobs. The choice is made per lake when the fork is created and cannot be changed
+			here.
+		</Alert>
+	</div>
+{/if}
+
 {#if ducklakeSettings.ducklakes.some((d) => d.catalog.resource_type === 'instance')}
 	<div transition:slide={{ duration: 200 }} class="mb-4">
 		<Alert title="Instance databases use the Windmill database" type="info">
@@ -255,6 +338,33 @@
 						inputProps={{ placeholder: 'Name' }}
 						class="ducklake-name"
 					/>
+					{#if isFork}
+						<div class="mt-1">
+							{#if ducklake.fork_behavior === 'shared'}
+								<span
+									class="inline-flex items-center gap-1 text-2xs px-1.5 py-0.5 rounded border border-amber-500/40 bg-amber-100 dark:bg-amber-900/30 text-amber-700 dark:text-amber-300"
+								>
+									<ArrowUpRight size={10} />
+									shared with parent
+								</span>
+								<Tooltip>
+									This fork reads and writes the parent's physical lake directly. Edits to this
+									lake's catalog or storage repoint the shared lake for this fork's jobs.
+								</Tooltip>
+							{:else}
+								<span
+									class="inline-flex items-center gap-1 text-2xs px-1.5 py-0.5 rounded border border-emerald-500/40 bg-emerald-100 dark:bg-emerald-900/30 text-emerald-700 dark:text-emerald-300"
+								>
+									<GitFork size={10} />
+									isolated
+								</span>
+								<Tooltip>
+									Writes go to a fork-scoped namespace; reads of tables not yet materialized in
+									this fork defer to the parent. Deleting the fork cleans the namespace up.
+								</Tooltip>
+							{/if}
+						</div>
+					{/if}
 				</Cell>
 				<Cell>
 					<div class="flex gap-1">
@@ -337,6 +447,133 @@
 						/>
 					</div>
 				</Cell>
+				<Cell class="w-32">
+					<Popover contentClasses="p-4" enableFlyTransition closeOnOtherPopoverOpen>
+						{#snippet trigger()}
+							<div class="relative">
+								<Button
+									variant="default"
+									size="sm"
+									startIcon={{ icon: Wrench }}
+									btnClasses="whitespace-nowrap ducklake-maintenance-btn"
+								>
+									{ducklake.maintenance?.enabled
+										? `${ducklake.maintenance?.retention_days ?? 7}d retention`
+										: 'Off'}
+								</Button>
+								{#if maintenanceHealth.current?.[ducklake.name] && (maintenanceHealth.current[ducklake.name].error || !maintenanceHealth.current[ducklake.name].enabled)}
+									<AlertTriangle
+										size={14}
+										class="absolute -top-1.5 -right-1.5 text-yellow-500 bg-surface rounded-full"
+									/>
+								{/if}
+							</div>
+						{/snippet}
+						{#snippet content()}
+							<div class="flex flex-col gap-3 w-96">
+								<Toggle
+									size="sm"
+									disabled={!$enterpriseLicense && !ducklake.maintenance?.enabled}
+									eeOnly
+									options={{
+										right: 'Scheduled maintenance',
+										rightTooltip:
+											'Expire old snapshots, merge adjacent small parquet files and delete orphaned files on a schedule. Runs appear as jobs — run history is the audit trail.'
+									}}
+									bind:checked={
+										() => ducklake.maintenance?.enabled ?? false,
+										(v) => (editableMaintenance(ducklake).enabled = v)
+									}
+								/>
+								{#if ducklake.maintenance?.enabled}
+									<Label
+										label="Snapshot retention (days)"
+										tooltip="Snapshots older than this window are expired on each maintenance run. 0 keeps only the current snapshot."
+									>
+										<TextInput
+											inputProps={{ type: 'number', min: 0, step: 1 }}
+											bind:value={
+												() => ducklake.maintenance?.retention_days ?? 7,
+												(v) => {
+													const n = typeof v === 'number' ? v : parseInt(v ?? '')
+													editableMaintenance(ducklake).retention_days = isNaN(n)
+														? undefined
+														: Math.max(0, n)
+												}
+											}
+										/>
+									</Label>
+									{#if (ducklake.maintenance?.retention_days ?? 7) === 0}
+										<p class="text-2xs text-yellow-600 dark:text-yellow-500">
+											Retention 0 expires every snapshot but the current one on each run —
+											time-travel is effectively disabled for this lake.
+										</p>
+									{/if}
+									<Label
+										label="Cadence (cron, UTC)"
+										tooltip="v2 cron expression evaluated in UTC. Leave empty for the default: daily at 03h with a per-lake minute offset."
+									>
+										<TextInput
+											inputProps={{ placeholder: 'daily at 03h (default)' }}
+											bind:value={
+												() => ducklake.maintenance?.schedule ?? '',
+												(v) => (editableMaintenance(ducklake).schedule = v ? String(v) : undefined)
+											}
+										/>
+									</Label>
+									<Toggle
+										size="xs"
+										options={{
+											right: 'Compaction',
+											rightTooltip:
+												'Merge adjacent small parquet files (ducklake_merge_adjacent_files)'
+										}}
+										bind:checked={
+											() => ducklake.maintenance?.compaction ?? true,
+											(v) => (editableMaintenance(ducklake).compaction = v)
+										}
+									/>
+									<Toggle
+										size="xs"
+										options={{
+											right: 'Orphaned file cleanup',
+											rightTooltip:
+												'Delete files present in storage but unknown to the catalog, older than max(retention, 1 day)'
+										}}
+										bind:checked={
+											() => ducklake.maintenance?.orphan_cleanup ?? true,
+											(v) => (editableMaintenance(ducklake).orphan_cleanup = v)
+										}
+									/>
+									<p class="text-2xs text-secondary">
+										Expired snapshots are gone for good: time-travel reads (<code
+											>AT (VERSION => n)</code
+										>) and recorded snapshot references older than the retention window become
+										non-queryable. Freed files are physically deleted with a ~1 day lag.
+									</p>
+									{#if maintenanceHealth.current?.[ducklake.name]?.error || maintenanceHealth.current?.[ducklake.name]?.enabled === false}
+										<Alert title="Maintenance schedule needs attention" type="warning" size="xs">
+											{maintenanceHealth.current?.[ducklake.name]?.error ??
+												'The managed schedule is disabled.'}
+											Re-save the ducklake settings to retry.
+										</Alert>
+									{/if}
+									{#if ducklakeSavedSettings.ducklakes.find((d) => d.name === ducklake.name)?.maintenance?.enabled}
+										<a
+											href={`${base}/runs/?schedule_path=${encodeURIComponent(
+												`f/ducklake_maintenance/${ducklake.name}`
+											)}&job_kinds=previews`}
+											target="_blank"
+											class="text-2xs inline-flex items-center gap-1"
+										>
+											View maintenance runs <ExternalLink size={12} />
+										</a>
+									{/if}
+								{/if}
+							</div>
+						{/snippet}
+					</Popover>
+				</Cell>
 				<Cell class="w-12">
 					<div class="flex gap-1">
 						<Popover contentClasses="p-4" enableFlyTransition closeOnOtherPopoverOpen>
diff --git a/frontend/src/lib/components/workspaceSettings/ForkDucklakeSection.svelte b/frontend/src/lib/components/workspaceSettings/ForkDucklakeSection.svelte
new file mode 100644
index 0000000000..675247a1e3
--- /dev/null
+++ b/frontend/src/lib/components/workspaceSettings/ForkDucklakeSection.svelte
@@ -0,0 +1,61 @@
+<script lang="ts">
+	import { WorkspaceService } from '$lib/gen'
+	import { workspaceStore } from '$lib/stores'
+	import { resource } from 'runed'
+	import Select from '../select/Select.svelte'
+	import Label from '../Label.svelte'
+	import { TriangleAlert } from 'lucide-svelte'
+
+	// Keyed on the store so a direct page load (store hydrates after mount) still fetches.
+	let allDucklakes = resource(
+		() => $workspaceStore,
+		async (ws) => (ws ? WorkspaceService.listDucklakes({ workspace: ws }) : undefined)
+	)
+
+	let lakeBehaviors: Record<string, 'isolated' | 'shared'> = $state({})
+
+	// Lakes the user explicitly opted out of isolation for — sent as
+	// `shared_ducklakes` on the create-fork request. Unlisted lakes default to the
+	// isolated fork namespace with read-defer, so nothing needs sending for them.
+	export function getSharedDucklakes(): string[] {
+		return (allDucklakes.current ?? []).filter((name) => lakeBehaviors[name] === 'shared')
+	}
+
+	let anyShared = $derived((allDucklakes.current ?? []).some((n) => lakeBehaviors[n] === 'shared'))
+</script>
+
+<!-- Self-hides when the workspace has no ducklake configured, like the datatable section. -->
+{#if allDucklakes.current && allDucklakes.current.length > 0}
+	<Label label="Ducklake data environment">
+		<span class="text-xs text-secondary">
+			By default each lake is isolated in the fork: materializations write a fork-scoped namespace
+			and reads of not-yet-materialized tables defer to this workspace's current data.
+		</span>
+		<div class="border rounded-md divide-y">
+			{#each allDucklakes.current as name (name)}
+				<div class="flex items-center gap-2 justify-between px-4 py-1.5">
+					<span class="text-xs font-medium">{name}</span>
+					<Select
+						dropdownClass="max-w-96"
+						bind:value={() => lakeBehaviors[name] ?? 'isolated', (v) => (lakeBehaviors[name] = v)}
+						items={[
+							{ value: 'isolated', label: 'Isolated (defer reads to parent)' },
+							{ value: 'shared', label: 'Shared with parent' }
+						]}
+					/>
+				</div>
+			{/each}
+		</div>
+		{#if anyShared}
+			<div
+				class="flex items-start gap-2 px-3 py-2 text-xs rounded-md border border-amber-200 dark:border-amber-900/60 bg-amber-50 dark:bg-amber-950/40 text-amber-700 dark:text-amber-300"
+			>
+				<TriangleAlert size={14} class="shrink-0 mt-0.5" />
+				<span>
+					A shared lake is NOT isolated: pipeline runs in the fork read and write this workspace's
+					tables directly.
+				</span>
+			</div>
+		{/if}
+	</Label>
+{/if}
diff --git a/frontend/src/lib/components/workspaceSettings/StorageSettings.svelte b/frontend/src/lib/components/workspaceSettings/StorageSettings.svelte
index be49e3c564..1e6c990819 100644
--- a/frontend/src/lib/components/workspaceSettings/StorageSettings.svelte
+++ b/frontend/src/lib/components/workspaceSettings/StorageSettings.svelte
@@ -190,8 +190,7 @@
 {#if !$enterpriseLicense}
 	<Alert type="info" title="Workspace storage is limited to {quotaDisplay} in Windmill CE">
 		Total workspace storage is capped at {quotaDisplay} in the Community Edition: writes that would exceed
-		the quota are rejected. The bucket browser will also not work for buckets containing more than 20
-		files. Consider upgrading to Windmill EE for unlimited workspace storage.
+		the quota are rejected. Consider upgrading to Windmill EE for unlimited workspace storage.
 	</Alert>
 {:else}
 	<Alert type="info" title="Logs storage is set at the instance level">
diff --git a/frontend/src/lib/utils_draft_deploy.test.ts b/frontend/src/lib/utils_draft_deploy.test.ts
new file mode 100644
index 0000000000..bae50691cc
--- /dev/null
+++ b/frontend/src/lib/utils_draft_deploy.test.ts
@@ -0,0 +1,40 @@
+import { describe, it, expect } from 'vitest'
+import { draftBaseIsStale } from './utils_draft_deploy'
+
+// draftBaseIsStale compares a draft's base pointer against the deployed head
+// of the item it was fetched with (`get_draft=true`). Shared by CompareDrafts
+// and the session Edits drawer — a regression here silently hides (or
+// fabricates) the "started from an older deployed version" warning.
+
+describe('draftBaseIsStale', () => {
+	it('script: stale iff the draft parent_hash differs from the deployed hash', () => {
+		expect(draftBaseIsStale('script', { hash: 'v2', draft: { parent_hash: 'v1' } })).toBe(true)
+		expect(draftBaseIsStale('script', { hash: 'v2', draft: { parent_hash: 'v2' } })).toBe(false)
+	})
+
+	it('script: no base pointer or no head → not stale (nothing to compare)', () => {
+		expect(draftBaseIsStale('script', { hash: 'v2', draft: {} })).toBe(false)
+		expect(draftBaseIsStale('script', { draft: { parent_hash: 'v1' } })).toBe(false)
+	})
+
+	it('flow: compares the pinned version_id against the deployed head', () => {
+		expect(draftBaseIsStale('flow', { version_id: 7, draft: { version_id: 5 } })).toBe(true)
+		expect(draftBaseIsStale('flow', { version_id: 7, draft: { version_id: 7 } })).toBe(false)
+		expect(draftBaseIsStale('flow', { version_id: 7, draft: {} })).toBe(false)
+	})
+
+	it('app/raw_app: compares parent_version against the last of versions', () => {
+		expect(draftBaseIsStale('app', { versions: [1, 2, 3], draft: { parent_version: 2 } })).toBe(
+			true
+		)
+		expect(draftBaseIsStale('raw_app', { versions: [1, 2, 3], draft: { parent_version: 3 } })).toBe(
+			false
+		)
+		expect(draftBaseIsStale('app', { versions: [], draft: { parent_version: 2 } })).toBe(false)
+	})
+
+	it('no draft on the response → not stale', () => {
+		expect(draftBaseIsStale('script', { hash: 'v2' })).toBe(false)
+		expect(draftBaseIsStale('script', undefined)).toBe(false)
+	})
+})
diff --git a/frontend/src/lib/utils_draft_deploy.ts b/frontend/src/lib/utils_draft_deploy.ts
index 2b08b379cf..ee8538e4db 100644
--- a/frontend/src/lib/utils_draft_deploy.ts
+++ b/frontend/src/lib/utils_draft_deploy.ts
@@ -262,6 +262,56 @@ export async function getDraftDiffValues(
 	}
 }
 
+/**
+ * Whether a draft's base is stale: the deployed version the draft forked from
+ * no longer matches the current deployed head — a newer version was deployed
+ * after the draft began, so deploying the draft would silently revert it.
+ * Scripts compare the draft's `parent_hash` vs the deployed `hash`; flows the
+ * pinned `version_id` vs the deployed head `version_id`; apps (incl. raw) the
+ * pinned `parent_version` vs the head of `versions`. `r` is the item fetched
+ * with `get_draft=true`; only script/flow/app kinds carry a base pointer.
+ */
+export function draftBaseIsStale(draftKind: UserDraftItemKind, r: any): boolean {
+	const draft = r?.draft
+	if (!draft) return false
+	if (draftKind === 'script') {
+		return !!r.hash && !!draft.parent_hash && draft.parent_hash !== r.hash
+	}
+	if (draftKind === 'flow') {
+		return r.version_id != null && draft.version_id != null && draft.version_id !== r.version_id
+	}
+	const head = Array.isArray(r.versions) ? r.versions[r.versions.length - 1] : undefined
+	return head != null && draft.parent_version != null && draft.parent_version !== head
+}
+
+/** Fetch-and-test wrapper over `draftBaseIsStale` for one draft item. Returns
+ *  false for kinds without a base pointer and on fetch errors (warn, not block). */
+export async function fetchDraftBaseStale(
+	draftKind: UserDraftItemKind,
+	path: string,
+	workspace: string
+): Promise<boolean> {
+	try {
+		if (draftKind === 'script') {
+			const r = await ScriptService.getScriptByPath({ workspace, path, getDraft: true })
+			return draftBaseIsStale(draftKind, r)
+		}
+		if (draftKind === 'flow') {
+			const r = await FlowService.getFlowByPath({ workspace, path, getDraft: true })
+			return draftBaseIsStale(draftKind, r)
+		}
+		if (draftKind === 'app' || draftKind === 'raw_app') {
+			// The apps endpoint auto-detects a raw app and overlays its draft.
+			const r = await AppService.getAppByPath({ workspace, path, getDraft: true })
+			return draftBaseIsStale(draftKind, r)
+		}
+		return false
+	} catch (e) {
+		console.error(`Stale-draft check failed for ${draftKind}:${path}`, e)
+		return false
+	}
+}
+
 /**
  * Deploy a script/flow draft's trigger changes the same way the editors do.
  * Scripts and flows can carry `draft_triggers`; the create/update call below
diff --git a/frontend/src/lib/utils_workspace_deploy.ts b/frontend/src/lib/utils_workspace_deploy.ts
index 616654b446..72400bb962 100644
--- a/frontend/src/lib/utils_workspace_deploy.ts
+++ b/frontend/src/lib/utils_workspace_deploy.ts
@@ -14,10 +14,15 @@ import {
 	ScheduleService,
 	ScriptService,
 	SqsTriggerService,
+	UserService,
 	VariableService,
 	WebsocketTriggerService,
 	WorkspaceService
 } from '$lib/gen'
+import {
+	fetchProtectionRulesForWorkspace,
+	canUserBypassRuleKindInRulesets
+} from '$lib/workspaceProtectionRules.svelte'
 import {
 	existsTrigger,
 	getTriggersDeployData,
@@ -387,3 +392,42 @@ export async function getOnBehalfOf(
 	}
 	return sharedGetOnBehalfOf(makeProvider(), kind as DeployKind, path, workspace)
 }
+
+export type DeployPermission = { ok: boolean; reason?: string }
+
+/**
+ * Whether the current user may deploy into `workspace`. Mirrors the server-side
+ * deploy authorization (`check_user_against_rule` in windmill-common) so the UI
+ * can disable the action with a reason instead of letting the click 403:
+ *  - operators can never deploy;
+ *  - when the `RestrictDeployToDeployers` protection rule is active, only
+ *    admins, `wm_deployers` members (implicitly), and per-ruleset bypass
+ *    users/groups may deploy.
+ * Fails open on any error — the server still enforces on the actual deploy.
+ * Shared by the session dock and the compare page so both gate identically.
+ */
+export async function checkDeployPermission(workspace: string): Promise<DeployPermission> {
+	try {
+		const me = await UserService.whoami({ workspace })
+		if (me.operator) {
+			return { ok: false, reason: "You're an operator in this workspace — operators can't deploy" }
+		}
+		// Admins and wm_deployers members always satisfy RestrictDeployToDeployers
+		// (the backend allows wm_deployers implicitly, so check it before the
+		// per-ruleset bypass_users/bypass_groups fallback).
+		const isDeployer = me.is_admin || (me.groups ?? []).includes('wm_deployers')
+		if (!isDeployer) {
+			const rulesets = await fetchProtectionRulesForWorkspace(workspace)
+			const userInfo = { is_admin: !!me.is_admin, username: me.username, groups: me.groups ?? [] }
+			if (!canUserBypassRuleKindInRulesets(rulesets, 'RestrictDeployToDeployers', userInfo)) {
+				return {
+					ok: false,
+					reason: 'Only workspace admins and members of wm_deployers can deploy here'
+				}
+			}
+		}
+		return { ok: true }
+	} catch {
+		return { ok: true }
+	}
+}
diff --git a/frontend/src/lib/workspaceProtectionRules.svelte.ts b/frontend/src/lib/workspaceProtectionRules.svelte.ts
index fa9627ba02..1774ed60e2 100644
--- a/frontend/src/lib/workspaceProtectionRules.svelte.ts
+++ b/frontend/src/lib/workspaceProtectionRules.svelte.ts
@@ -1,6 +1,11 @@
 import { WorkspaceService, type ProtectionRuleset, type ProtectionRuleKind } from './gen'
 import type { UserExt } from './stores'
 
+// The slice of the user identity the bypass checks read — structural, so
+// callers can pass a whoami response (normalised groups) as well as the
+// UserExt store value.
+export type RuleBypassUser = Pick<UserExt, 'is_admin' | 'username' | 'groups'>
+
 /**
  * Internal reactive state using Svelte 5 $state rune
  */
@@ -94,7 +99,7 @@ export async function fetchProtectionRulesForWorkspace(
  * @param userInfo The user information
  * @returns true if user can bypass (is admin, in bypass_users, or has group in bypass_groups)
  */
-export function canUserBypassRule(ruleset: ProtectionRuleset, userInfo: UserExt): boolean {
+export function canUserBypassRule(ruleset: ProtectionRuleset, userInfo: RuleBypassUser): boolean {
 	// Admin always bypasses
 	if (userInfo.is_admin) {
 		return true
@@ -134,7 +139,7 @@ export function isRuleActive(ruleKind: ProtectionRuleKind): boolean {
  */
 export function canUserBypassRuleKind(
 	ruleKind: ProtectionRuleKind,
-	userInfo: UserExt | undefined
+	userInfo: RuleBypassUser | undefined
 ): boolean {
 	// If no user info, default to permissive
 	if (!userInfo) {
@@ -187,7 +192,7 @@ export function isRuleActiveInRulesets(
 export function canUserBypassRuleKindInRulesets(
 	rulesets: ProtectionRuleset[],
 	ruleKind: ProtectionRuleKind,
-	userInfo: UserExt | undefined
+	userInfo: RuleBypassUser | undefined
 ): boolean {
 	// If no user info, default to not allowing bypass
 	if (!userInfo) {
diff --git a/frontend/src/routes/(root)/(logged)/forks/compare/+page.svelte b/frontend/src/routes/(root)/(logged)/forks/compare/+page.svelte
index b521cf8dc5..6670be1225 100644
--- a/frontend/src/routes/(root)/(logged)/forks/compare/+page.svelte
+++ b/frontend/src/routes/(root)/(logged)/forks/compare/+page.svelte
@@ -19,6 +19,7 @@
 	import { sendUserToast } from '$lib/toast'
 	import { switchWorkspace } from '$lib/storeUtils'
 	import { goto } from '$lib/navigation'
+	import { readChatModifiedItems } from '$lib/components/copilot/chat/HistoryManager.svelte'
 
 	type CompareMode = 'fork' | 'draft'
 
@@ -48,6 +49,37 @@
 	// selection here; the page only swaps which comparison component is shown.
 	let forkDirection = $state<'deploy_to' | 'update'>('deploy_to')
 
+	// When reached via a session's Review button (`from_session=<chatId>`), preselect
+	// only the items that chat modified. The mask is the chat's stored
+	// `${UserDraftItemKind}:${storagePath}` set; undefined for a legacy chat (no
+	// stored mask) → the children fall back to selecting all deployable items.
+	// Derived from the live URL: an in-app navigation to this route with a
+	// different from_session must reload the mask, not keep the first one.
+	const fromChatId = $derived(page.url.searchParams.get('from_session'))
+	let chatMask = $state<Set<string> | undefined>(undefined)
+	// The mask loads asynchronously, while the resolved value can legitimately be
+	// undefined (legacy chat). The children must not run their select-all default
+	// until the mask is known, else they'd race it and select everything. Ready
+	// immediately when there's no session to read from.
+	let chatMaskReady = $state(!page.url.searchParams.get('from_session'))
+	$effect(() => {
+		const id = fromChatId
+		chatMask = undefined
+		chatMaskReady = !id
+		if (!id) return
+		untrack(() => {
+			void readChatModifiedItems(id)
+				.then((arr) => {
+					// A slower read for a superseded chat id must not win.
+					if (id !== untrack(() => fromChatId)) return
+					chatMask = arr ? new Set(arr) : undefined
+				})
+				.finally(() => {
+					if (id === untrack(() => fromChatId)) chatMaskReady = true
+				})
+		})
+	})
+
 	function selectMode(v: 'deploy_to' | 'update' | 'draft') {
 		if (v === 'draft') {
 			mode = 'draft'
@@ -252,6 +284,8 @@
 			{deployCount}
 			{updateCount}
 			{draftCount}
+			{chatMask}
+			{chatMaskReady}
 			onModeSelected={selectMode}
 		/>
 	{:else if parentWorkspaceId}
@@ -264,6 +298,8 @@
 			{updateCount}
 			{draftCount}
 			{draftKeys}
+			{chatMask}
+			{chatMaskReady}
 			onChanged={refreshCounts}
 			onModeSelected={selectMode}
 		/>
diff --git a/frontend/src/routes/(root)/(logged)/pipeline/+page.svelte b/frontend/src/routes/(root)/(logged)/pipeline/+page.svelte
index ab36b4c1f7..e15c3abdf7 100644
--- a/frontend/src/routes/(root)/(logged)/pipeline/+page.svelte
+++ b/frontend/src/routes/(root)/(logged)/pipeline/+page.svelte
@@ -1,6 +1,7 @@
 <script lang="ts">
-	import { userStore } from '$lib/stores'
+	import { userStore, workspaceStore } from '$lib/stores'
 	import PipelineFolderList from '$lib/components/assets/AssetGraph/PipelineFolderList.svelte'
+	import PipelineSetupSignpost from '$lib/components/assets/AssetGraph/PipelineSetupSignpost.svelte'
 	import PipelineAlphaAckModal from '$lib/components/assets/AssetGraph/PipelineAlphaAckModal.svelte'
 	import { BookOpen, NetworkIcon } from 'lucide-svelte'
 	import { onMount } from 'svelte'
@@ -73,6 +74,10 @@
 				</a>
 			</div>
 
+			{#if !$userStore?.operator && $workspaceStore}
+				<PipelineSetupSignpost workspace={$workspaceStore} />
+			{/if}
+
 			<PipelineFolderList />
 		</div>
 	</div>
diff --git a/frontend/src/routes/(root)/(logged)/pipeline/[folder]/+page.svelte b/frontend/src/routes/(root)/(logged)/pipeline/[folder]/+page.svelte
index 4d41f7ff05..e65c97b83d 100644
--- a/frontend/src/routes/(root)/(logged)/pipeline/[folder]/+page.svelte
+++ b/frontend/src/routes/(root)/(logged)/pipeline/[folder]/+page.svelte
@@ -36,6 +36,7 @@
 		type ColumnLineageGraph
 	} from '$lib/components/assets/AssetGraph/columnLineageGraph'
 	import { resolveGraph } from '$lib/components/assets/AssetGraph/resolveGraph'
+	import { buildSchemaContractContext } from '$lib/components/assets/AssetGraph/schemaContracts'
 	import {
 		computeDownstreamClosure,
 		computeInducedSchedule,
@@ -46,10 +47,12 @@
 		boundedSet,
 		buildLineageDag,
 		buildLineageDownstreamMap,
-		descendants,
 		isScriptNode,
+		nonAutorunTriggerScripts,
+		reachableCutting,
 		scriptNodeId,
 		scriptsOf,
+		validFromStarts,
 		validStarts
 	} from '$lib/components/assets/AssetGraph/boundedCascade'
 	import {
@@ -1337,8 +1340,17 @@
 						? 'failure'
 						: 'success'
 			const cur = m.get(id)
-			if (cur) cur.runs += 1
-			else m.set(id, { status, runs: 1 })
+			// Freshness compares against completion; `at` (start) is the
+			// fallback lower bound for rows without a duration.
+			const successAt = e.status === 'success' ? (e.completedAt ?? e.at) : undefined
+			if (cur) {
+				cur.runs += 1
+				// Newest-first, so the first success per id is the latest one —
+				// it feeds the freshness chip between graph refetches.
+				if (successAt && !cur.lastSuccessAt) cur.lastSuccessAt = successAt
+			} else {
+				m.set(id, { status, runs: 1, lastSuccessAt: successAt })
+			}
 		}
 		return m
 	})
@@ -1470,6 +1482,14 @@
 			} else {
 				const failed = [...res.statuses.entries()].filter(([, s]) => s.status === 'failure')
 				const skipped = [...res.statuses.values()].filter((s) => s.status === 'skipped').length
+				// Surface the failed node's error in the details pane. Clear the
+				// active draft too — it has pane priority over `selection`
+				// (openScriptPath), so a bare selection would stay masked while a
+				// draft is open.
+				if (failed.length > 0) {
+					pe.activeDraftPath = undefined
+					pe.selection = { kind: 'runnable', runnable_kind: 'script', path: failed[0][0] }
+				}
 				sendUserToast(
 					`Chain run failed at ${failed.map(([p]) => p).join(', ')}` +
 						(skipped > 0 ? ` — ${skipped} downstream skipped` : ''),
@@ -1492,7 +1512,11 @@
 	let boundPickEnds = $state<Set<string>>(new Set())
 
 	// Script paths eligible to start a bounded run, for the canvas menu gate.
-	let validStartPaths = $derived(new Set(scriptsOf(validStarts(displayGraph))))
+	// Any node with downstream — roots AND mid-DAG models — can be a "Run +
+	// downstream" start (dbt `model+`); only event-triggered scripts are excluded
+	// (see boundedCascade.validFromStarts). The canvas additionally requires the
+	// node to have lineage downstream before offering the entry.
+	let validStartPaths = $derived(new Set(scriptsOf(validFromStarts(displayGraph))))
 	// Scripts with read-aware downstream — the same gate the canvas applies
 	// (AssetGraphCanvas `hasLineageDownstream`). A valid start with no downstream
 	// has no end to pick, so the bounded-run entry is suppressed everywhere,
@@ -1501,15 +1525,45 @@
 
 	// Rebuilt only while a pick is active (cheap to skip otherwise).
 	let boundDag = $derived(boundPickStart ? buildLineageDag(displayGraph) : undefined)
-	let boundEligible = $derived(
-		boundDag && boundPickStart ? descendants(boundDag, boundPickStart) : new Set<string>()
-	)
 	let boundResult = $derived(
 		boundDag && boundPickStart
 			? boundedSet(boundDag, boundPickStart, [...boundPickEnds])
 			: undefined
 	)
-	let boundScripts = $derived(boundResult ? scriptsOf(boundResult.nodes) : [])
+	// Event handlers (kafka/mqtt/…) can't run with empty args, so they're cut from
+	// any cascade run — as is a consumer reachable only through one. But a
+	// scheduled/manual root is NEVER a barrier even if it also carries an event
+	// trigger: it runs on its own schedule/manual identity (schedule wins in
+	// validStarts), so it — and its downstream — stay reachable when running from
+	// an upstream start. The explicit start is likewise protected. Parity with the
+	// CLI `barriers` set (`nonAutorunTriggerScripts` minus `starts` minus start).
+	let boundReachable = $derived.by(() => {
+		if (!boundDag || !boundPickStart) return new Set<string>()
+		const roots = validStarts(displayGraph)
+		const barriers = new Set(
+			[...nonAutorunTriggerScripts(displayGraph)].filter(
+				(id) => !roots.has(id) && id !== boundPickStart
+			)
+		)
+		return reachableCutting(boundDag, [boundPickStart], barriers)
+	})
+	// Nodes pickable as end bounds: the barrier-cut downstream (excluding the
+	// start), NOT raw descendants — else an event handler or a node only reachable
+	// through one could be clicked as an end yet get silently dropped from the run.
+	let boundEligible = $derived(new Set([...boundReachable].filter((id) => id !== boundPickStart)))
+	// The actual run set (nodes, scripts + assets). No end picked → "Run +
+	// downstream" (dbt `model+`): the start plus its full transitive downstream.
+	// Picking end(s) narrows it to the path-between set. Either way, intersect with
+	// the barrier-cut closure so an event descendant is never launched empty. The
+	// canvas highlights exactly this set, so the ring matches what will run.
+	let boundRunNodes = $derived(
+		boundPickStart
+			? boundPickEnds.size === 0
+				? boundReachable
+				: new Set([...(boundResult?.nodes ?? [])].filter((n) => boundReachable.has(n)))
+			: new Set<string>()
+	)
+	let boundScripts = $derived(scriptsOf(boundRunNodes))
 
 	// Engine id → canvas id: scripts keep `script:path`; assets gain the
 	// canvas's `asset:` prefix (AssetGraphCanvas node ids).
@@ -1527,7 +1581,7 @@
 					start: boundPickStart,
 					eligible: new Set([...boundEligible].map(toCanvasId)),
 					ends: new Set([...boundPickEnds].map(toCanvasId)),
-					bounded: new Set([...(boundResult?.nodes ?? [])].map(toCanvasId))
+					bounded: new Set([...boundRunNodes].map(toCanvasId))
 				}
 			: undefined
 	)
@@ -1606,6 +1660,14 @@
 			} else {
 				const failed = [...res.statuses.entries()].filter(([, s]) => s.status === 'failure')
 				const skipped = [...res.statuses.values()].filter((s) => s.status === 'skipped').length
+				// Surface the failed node's error in the details pane. Clear the
+				// active draft too — it has pane priority over `selection`
+				// (openScriptPath), so a bare selection would stay masked while a
+				// draft is open.
+				if (failed.length > 0) {
+					pe.activeDraftPath = undefined
+					pe.selection = { kind: 'runnable', runnable_kind: 'script', path: failed[0][0] }
+				}
 				sendUserToast(
 					`Bounded run failed at ${failed.map(([p]) => p).join(', ')}` +
 						(skipped > 0 ? ` — ${skipped} downstream skipped` : ''),
@@ -1617,6 +1679,25 @@
 		}
 	}
 
+	// Every pipeline-member script, for the always-visible header "Run pipeline"
+	// control. Per-node runs are hover/select-gated on the canvas; this
+	// pipeline-level affordance runs the whole graph without hunting for a root
+	// node to hover. Gated on `in_pipeline` so it never launches dependency-only
+	// endpoints the graph surfaces for context (macro libraries, custom
+	// data-test scripts, out-of-folder producers) — only actual pipeline steps.
+	let allPipelineScripts = $derived(
+		displayGraph.runnables
+			.filter((r) => r.usage_kind === 'script' && r.in_pipeline)
+			.map((r) => r.path)
+	)
+	// Run the whole pipeline: hand every script to the bounded-cascade engine,
+	// which topo-orders them (roots first) and fans downstream — i.e. run + all
+	// downstream from every source at once. Reuses the same per-hop launch/poll
+	// and one-cascade-at-a-time guard as the node-level chain runs.
+	async function runWholePipeline() {
+		await runBoundedCascade(allPipelineScripts)
+	}
+
 	// Counter bumped when the canvas Run button targets the currently-open
 	// script — the pane intercepts and routes through ScriptEditor.runTest
 	// so logs/result/cancel land in the test panel instead of going off
@@ -1666,6 +1747,12 @@
 			: EMPTY_COLUMN_GRAPH
 	)
 
+	// Producer-side facts for the editor's live schema-contract diagnostics:
+	// which assets are muted (`on_schema_change=ignore`) and which `_current`
+	// views map to an scd2 base table. Derived from the same resolved graph the
+	// canvas renders so the mirror suppresses exactly what the server check does.
+	let schemaContractContext = $derived(buildSchemaContractContext(graphWithDraft.runnables))
+
 	// Whether the selected ducklake asset's captured schema can *evolve* (drives
 	// the asset panel's Schema tab: version history vs. a single fixed schema).
 	// Only a whole-table `replace` producer (CREATE OR REPLACE) can change
@@ -1687,6 +1774,16 @@
 		return producers.length === 0 || !producers.every(knownFixed)
 	})
 
+	// Fork data-environment state of the selected ducklake asset (fork workspaces
+	// only): read off the graph node so the details pane can show the
+	// deferred-to-parent / fork-materialized banner matching the canvas chip.
+	let selectionForkMaterialization = $derived.by(() => {
+		const sel = pe.selection
+		if (!sel || sel.kind !== 'asset' || sel.asset_kind !== 'ducklake') return undefined
+		return displayGraph.assets.find((a) => a.kind === 'ducklake' && a.path === sel.path)
+			?.fork_materialization
+	})
+
 	// Downstream subscriber count for the currently-edited script. Drives
 	// the Test button's cascade UX: when > 0, ScriptEditor renders a split
 	// button exposing "just this step" (default, with `_wmill_skip_asset_dispatch`)
@@ -1962,6 +2059,18 @@
 		return `${n} ${singular}${n === 1 ? '' : 's'}`
 	}
 
+	// Human noun per asset kind for the header summary. The raw `ducklake` kind
+	// counts materialized tables/views (including `_current` history views), so
+	// "N ducklakes" mis-reads as a count of lakes — surface "table" instead. Other
+	// kinds keep their own noun; unmapped kinds fall back to the raw kind.
+	const ASSET_KIND_NOUN: Record<string, string> = {
+		ducklake: 'table',
+		datatable: 'table',
+		s3object: 'file',
+		volume: 'volume',
+		resource: 'resource'
+	}
+
 	let summary = $derived.by<string[]>(() => {
 		const g = graphRes.current
 		if (!g) return []
@@ -1970,9 +2079,14 @@
 		const flows = g.runnables.filter((r) => r.usage_kind === 'flow').length
 		if (scripts) parts.push(pluralize(scripts, 'script'))
 		if (flows) parts.push(pluralize(flows, 'flow'))
-		const byKind = new Map<string, number>()
-		for (const a of g.assets) byKind.set(a.kind, (byKind.get(a.kind) ?? 0) + 1)
-		for (const [kind, n] of byKind) parts.push(pluralize(n, kind))
+		// Collapse kinds that share a noun (ducklake + datatable → "table") into a
+		// single tally so the summary reads "5 tables", not "3 tables · 2 tables".
+		const byNoun = new Map<string, number>()
+		for (const a of g.assets) {
+			const noun = ASSET_KIND_NOUN[a.kind] ?? a.kind
+			byNoun.set(noun, (byNoun.get(noun) ?? 0) + 1)
+		}
+		for (const [noun, n] of byNoun) parts.push(pluralize(n, noun))
 		return parts
 	})
 </script>
@@ -2056,6 +2170,30 @@
 			</div>
 		{/if}
 		<div class="flex flex-row items-center gap-2 flex-1 justify-end">
+			{#if !isOperator && allPipelineScripts.length > 0}
+				<!-- Pipeline-level run: always visible in both View and Edit so a
+				     run never requires hunting for a specific node's play button
+				     (dbt `build` / Dagster "Materialize all"). Runs every script in
+				     dependency order (roots first, cascading downstream) over the
+				     displayed graph — deployed in View, draft-overlaid in Edit. -->
+				<Button
+					variant="accent-secondary"
+					unifiedSize="sm"
+					startIcon={{
+						icon: cascadeRunningRoot ? Loader2 : Play,
+						classes: cascadeRunningRoot ? 'animate-spin' : undefined
+					}}
+					onclick={runWholePipeline}
+					disabled={!!cascadeRunningRoot}
+					title={cascadeRunningRoot
+						? 'A pipeline run is already in progress'
+						: `Run all ${allPipelineScripts.length} script${
+								allPipelineScripts.length === 1 ? '' : 's'
+							} in dependency order (roots first, cascading downstream)`}
+				>
+					{cascadeRunningRoot ? 'Running…' : 'Run pipeline'}
+				</Button>
+			{/if}
 			{#if mode === 'edit' && saveErrors.size > 0}
 				<!-- Compact errors popover anchored next to Save all so users
 				     can see exactly which drafts failed and why without losing
@@ -2201,6 +2339,8 @@
 				{selectionProducers}
 				selectionColumnGraph={pe.activeDraft ? EMPTY_COLUMN_GRAPH : columnGraph}
 				{schemaCanEvolve}
+				{selectionForkMaterialization}
+				{schemaContractContext}
 				downstreamSubscribers={editedScriptDownstreamCount}
 				onStartBoundedRunForOpen={startBoundedRun}
 				canBoundedRunOpenScript={!!openScriptPath &&
@@ -2272,7 +2412,7 @@
 							<div class="flex flex-col leading-tight">
 								<span class="text-xs font-semibold text-emphasis">
 									{boundPickEnds.size === 0
-										? 'Click end node(s) to bound the run'
+										? `Run + all downstream · ${boundScripts.length} script${boundScripts.length === 1 ? '' : 's'} (click node(s) to bound)`
 										: `${boundScripts.length} script${boundScripts.length === 1 ? '' : 's'} up to ${boundPickEnds.size} end${boundPickEnds.size === 1 ? '' : 's'}`}
 								</span>
 								<span class="text-2xs text-tertiary">
@@ -2284,10 +2424,10 @@
 								variant="accent"
 								unifiedSize="sm"
 								startIcon={{ icon: Play }}
-								disabled={boundPickEnds.size === 0 || boundScripts.length === 0}
+								disabled={boundScripts.length === 0}
 								onclick={confirmBoundedRun}
 							>
-								Run selection
+								{boundPickEnds.size === 0 ? 'Run + downstream' : 'Run selection'}
 							</Button>
 						</div>
 					{/if}
diff --git a/frontend/src/routes/(root)/(logged)/sessions/+page.svelte b/frontend/src/routes/(root)/(logged)/sessions/+page.svelte
index 1d6f3f45ec..d5bf3ceceb 100644
--- a/frontend/src/routes/(root)/(logged)/sessions/+page.svelte
+++ b/frontend/src/routes/(root)/(logged)/sessions/+page.svelte
@@ -51,17 +51,12 @@
 
 	// Touch the runtime for the active session so it gets created on first visit
 	// and the pane shows up. Subsequent renders find it via listRuntimes().
-	// Also refresh the fork diff count: deep-link / back-button navigation
-	// changes the URL but doesn't fire the picker.activate path nor the
-	// visibility-change signal, so this is the only hook that catches a
-	// user returning from another route in the same tab.
 	//
 	// Gate on session identity (id) rather than the full activeSession
 	// derived — sessionState.sessions mutates on every persisted change
 	// (including token-by-token last_message updates during AI streaming),
-	// so a value-trigger would re-fetch compareWorkspaces dozens of times
-	// per turn. We only want to refresh when the user actually arrives at
-	// a new session.
+	// so a value-trigger would re-run dozens of times per turn. We only
+	// want to react when the user actually arrives at a new session.
 	let lastArrivedSessionId: string | undefined
 	$effect(() => {
 		const session = activeSession
@@ -76,8 +71,7 @@
 			// (refresh hooks, picker selection) react to deep links the
 			// same way they react to picker clicks.
 			selectSession(session.id)
-			const rt = getOrCreateRuntime(session)
-			void rt.refreshForkComparison()
+			getOrCreateRuntime(session)
 		})
 	})
 
diff --git a/frontend/src/routes/kitchen_sink/deploy_animation/+page.svelte b/frontend/src/routes/kitchen_sink/deploy_animation/+page.svelte
new file mode 100644
index 0000000000..6cd7e7197f
--- /dev/null
+++ b/frontend/src/routes/kitchen_sink/deploy_animation/+page.svelte
@@ -0,0 +1,194 @@
+<script lang="ts">
+	import WorkspaceDiffDrawer from '$lib/components/sessions/WorkspaceDiffDrawer.svelte'
+	import { Button } from '$lib/components/common'
+	import Toggle from '$lib/components/Toggle.svelte'
+	import DarkModeToggle from '$lib/components/sidebar/DarkModeToggle.svelte'
+	import type { DeployItem } from '$lib/components/sessions/sessionDeployModel'
+	import type {
+		DeploymentStatus,
+		SessionDeployModel
+	} from '$lib/components/sessions/sessionDeployModel.svelte'
+
+	// Playground for the session Edits drawer deploy animation: the REAL
+	// WorkspaceDiffDrawer driven by a mock model with adjustable latency,
+	// outcome, data-flip lag, and content size — no backend involved.
+
+	let deployMs = $state(800)
+	let flipDelayMs = $state(300)
+	let holdMs = $state(1200)
+	let diffLines = $state(25)
+	let itemCount = $state(3)
+	let failDeploys = $state(false)
+	let permOk = $state(true)
+	let staleDrafts = $state(false)
+
+	function makeItem(i: number, done = false): DeployItem {
+		return {
+			key: `script:u/dev/demo_${i}`,
+			deployKind: 'script',
+			draftKind: 'script',
+			path: `u/dev/demo_${i}`,
+			displayPath: `u/dev/demo_${i}`,
+			summary: `Demo script ${i}`,
+			done,
+			hasDraft: !done,
+			draftOnly: i % 2 === 0,
+			draftUsers: undefined,
+			mine: true,
+			canWrite: true,
+			legacy: false,
+			rawApp: false
+		}
+	}
+
+	let items = $state<DeployItem[]>([])
+	let statuses = $state<Record<string, DeploymentStatus>>({})
+	let deploying = $state(false)
+
+	function reset() {
+		statuses = {}
+		items = [...Array.from({ length: itemCount }, (_, i) => makeItem(i)), makeItem(99, true)]
+	}
+	reset()
+
+	const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms))
+
+	function genContent(seed: string, lines: number, mutated: boolean): string {
+		const out = [`// ${seed}`, 'export async function main() {']
+		for (let i = 0; i < lines; i++) {
+			out.push(
+				mutated && i % 4 === 0
+					? `\tconst v${i} = ${i} * 2 // changed by the chat`
+					: `\tconst v${i} = ${i}`
+			)
+		}
+		if (mutated) out.push('\tconst added = "new trailing logic"')
+		out.push(`\treturn v0`, '}')
+		return out.join('\n')
+	}
+
+	function fakeScript(content: string) {
+		return { summary: 'Demo', description: '', content, language: 'bun', schema: {} }
+	}
+
+	function setStatus(key: string, s: DeploymentStatus | undefined) {
+		const next = { ...statuses }
+		if (s) next[key] = s
+		else delete next[key]
+		statuses = next
+	}
+
+	const model: SessionDeployModel = {
+		get items() {
+			return items
+		},
+		get loading() {
+			return false
+		},
+		get error() {
+			return undefined
+		},
+		load() {},
+		async loadDiffValues(item: DeployItem) {
+			await sleep(250)
+			const after = fakeScript(genContent(item.key, diffLines, true))
+			if (item.done) return { before: after, after }
+			return {
+				before: item.draftOnly ? undefined : fakeScript(genContent(item.key, diffLines, false)),
+				after
+			}
+		},
+		get deploying() {
+			return deploying
+		},
+		statusOf(key: string) {
+			return statuses[key]
+		},
+		staleOf(key: string) {
+			// Only non-draft_only rows carry a base pointer in production.
+			return staleDrafts && !items.find((it) => it.key === key)?.draftOnly
+		},
+		get deployPermission() {
+			return permOk
+				? { ok: true as const }
+				: { ok: false as const, reason: 'Deploy disabled by the playground toggle' }
+		},
+		async deployRow(item: DeployItem) {
+			setStatus(item.key, { status: 'loading' })
+			deploying = true
+			await sleep(deployMs)
+			deploying = false
+			if (failDeploys) {
+				setStatus(item.key, { status: 'failed', error: 'Simulated failure from the playground' })
+				return false
+			}
+			setStatus(item.key, undefined)
+			// Mimic the production lag between deploy success and the draft
+			// refetch flipping the item to done.
+			setTimeout(() => {
+				items = items.map((it) =>
+					it.key === item.key ? { ...it, done: true, hasDraft: false, draftOnly: false } : it
+				)
+			}, flipDelayMs)
+			return true
+		},
+		async discardRow(item: DeployItem) {
+			await sleep(deployMs)
+			items = items.filter((it) => it.key !== item.key)
+		}
+	}
+
+	let drawer: WorkspaceDiffDrawer | undefined = $state(undefined)
+</script>
+
+<div class="p-8 flex flex-col gap-6 max-w-2xl">
+	<div class="flex items-center justify-between">
+		<h1 class="text-lg font-semibold text-primary">Deploy animation playground</h1>
+		<DarkModeToggle forcedDarkMode={false} />
+	</div>
+	<p class="text-xs text-secondary">
+		Drives the real <code>WorkspaceDiffDrawer</code> with a mock deploy model. Tune the knobs, open the
+		drawer, hit Deploy, feel the transition. Reset re-arms the drafts.
+	</p>
+
+	<div class="grid grid-cols-2 gap-x-8 gap-y-4 text-xs text-primary">
+		<label class="flex flex-col gap-1">
+			<span>Deploy latency: <b>{deployMs}ms</b> (spinner phase)</span>
+			<input type="range" min="0" max="5000" step="100" bind:value={deployMs} />
+		</label>
+		<label class="flex flex-col gap-1">
+			<span>Success hold: <b>{holdMs}ms</b> (green check beat)</span>
+			<input type="range" min="0" max="4000" step="100" bind:value={holdMs} />
+		</label>
+		<label class="flex flex-col gap-1">
+			<span>Data flip lag: <b>{flipDelayMs}ms</b> (mock draft refetch)</span>
+			<input type="range" min="0" max="3000" step="100" bind:value={flipDelayMs} />
+		</label>
+		<label class="flex flex-col gap-1">
+			<span>Diff size: <b>{diffLines}</b> lines</span>
+			<input type="range" min="3" max="200" step="1" bind:value={diffLines} />
+		</label>
+		<label class="flex flex-col gap-1">
+			<span>Items: <b>{itemCount}</b> drafts (+1 deployed)</span>
+			<input type="range" min="1" max="10" step="1" bind:value={itemCount} onchange={reset} />
+		</label>
+		<div class="flex flex-col gap-2 justify-center">
+			<Toggle bind:checked={failDeploys} options={{ right: 'Fail deploys' }} size="xs" />
+			<Toggle bind:checked={permOk} options={{ right: 'Deploy permission' }} size="xs" />
+			<Toggle bind:checked={staleDrafts} options={{ right: 'Stale drafts' }} size="xs" />
+		</div>
+	</div>
+
+	<div class="flex items-center gap-2">
+		<Button variant="accent" unifiedSize="sm" onclick={() => drawer?.open()}>Open drawer</Button>
+		<Button variant="default" unifiedSize="sm" onclick={reset}>Reset items</Button>
+	</div>
+</div>
+
+<WorkspaceDiffDrawer
+	bind:this={drawer}
+	{model}
+	title="Deploy animation playground"
+	workspaceLabel="playground-workspace"
+	successHoldMs={holdMs}
+/>
diff --git a/frontend/tailwind.config.cjs b/frontend/tailwind.config.cjs
index d7dbf2d754..39e43c7722 100644
--- a/frontend/tailwind.config.cjs
+++ b/frontend/tailwind.config.cjs
@@ -295,7 +295,8 @@ const config = {
 				600: '#d97706',
 				700: '#b45309',
 				800: '#92400e',
-				900: '#78350f'
+				900: '#78350f',
+				950: '#451a03'
 			},
 			emerald: {
 				50: '#ecfdf5',
diff --git a/lsp/Pipfile b/lsp/Pipfile
index 482c95db43..17233bac9c 100644
--- a/lsp/Pipfile
+++ b/lsp/Pipfile
@@ -4,7 +4,7 @@ verify_ssl = true
 name = "pypi"
 
 [packages]
-wmill = ">=1.747.0"
+wmill = ">=1.749.0"
 sendgrid = "*"
 mysql-connector-python = "*"
 pymongo = "*"
diff --git a/openflow.openapi.yaml b/openflow.openapi.yaml
index ab81f1ea14..da3cbd2325 100644
--- a/openflow.openapi.yaml
+++ b/openflow.openapi.yaml
@@ -1,7 +1,7 @@
 openapi: '3.0.3'
 
 info:
-  version: 1.747.0
+  version: 1.749.0
   title: OpenFlow Spec
   contact:
     name: Ruben Fiszel
@@ -475,6 +475,9 @@ components:
         model:
           type: string
           description: Model identifier (e.g., 'gpt-4', 'claude-3-opus-20240229', 'gemini-pro')
+        reasoning_effort:
+          type: string
+          description: Provider-native reasoning effort token (e.g. 'low', 'high', 'none') for models that support extended thinking. Optional; unset leaves the provider default.
       required:
         - kind
         - resource
@@ -1028,7 +1031,7 @@ components:
                 - $ref: '#/components/schemas/InputTransform'
               description: |
                 Boolean. If true, stream the AI response incrementally.
-                Streaming events include: token_delta, tool_call, tool_call_arguments, tool_execution, tool_result
+                Streaming events include: token_delta, reasoning_token_delta, tool_call, tool_call_arguments, tool_execution, tool_result
             memory:
               $ref: '#/components/schemas/MemoryTransform'
             output_schema:
diff --git a/powershell-client/WindmillClient/WindmillClient.psd1 b/powershell-client/WindmillClient/WindmillClient.psd1
index 0b3006323a..863a7c487f 100644
--- a/powershell-client/WindmillClient/WindmillClient.psd1
+++ b/powershell-client/WindmillClient/WindmillClient.psd1
@@ -12,7 +12,7 @@
     RootModule        = 'WindmillClient.psm1'
 
     # Version number of this module.
-    ModuleVersion     = '1.747.0'
+    ModuleVersion     = '1.749.0'
 
     # Supported PSEditions
     # CompatiblePSEditions = @()
diff --git a/python-client/tests/wmill_client_test.py b/python-client/tests/wmill_client_test.py
index 3309e1ab5f..6df80919cf 100644
--- a/python-client/tests/wmill_client_test.py
+++ b/python-client/tests/wmill_client_test.py
@@ -124,5 +124,49 @@ SET s3_secret_access_key='80yMndIMcyXwEujxVNINQbf0tBlIzRaLPyM2m1n4';
             wmill.load_s3_file(s3_obj)
 
 
+class TestParseS3Object(unittest.TestCase):
+    """Pure-unit tests for parse_s3_object — no network/env needed."""
+
+    def test_bare_string_raises_with_uri_hint(self):
+        # A bare key is rejected rather than silently uploading under an
+        # auto-generated name; the error points at the s3:/// spelling.
+        with self.assertRaisesRegex(ValueError, "s3:///dir/file.json"):
+            wmill.parse_s3_object("dir/file.json")
+
+    def test_triple_slash_uri_is_default_storage(self):
+        self.assertEqual(
+            wmill.parse_s3_object("s3:///dir/file.json"),
+            S3Object(s3="dir/file.json", storage=None),
+        )
+
+    def test_full_uri_splits_storage_and_key(self):
+        self.assertEqual(
+            wmill.parse_s3_object("s3://bucket/dir/f"),
+            S3Object(s3="dir/f", storage="bucket"),
+        )
+
+    def test_malformed_uri_raises(self):
+        # `s3://x` has no key part — fail loudly instead of silently
+        # misplacing the object.
+        with self.assertRaises(ValueError):
+            wmill.parse_s3_object("s3://broken")
+
+    def test_empty_key_uri_raises(self):
+        # An empty key is never a valid target: it would fall back to an
+        # auto-generated key, which is requested by omitting the object.
+        with self.assertRaises(ValueError):
+            wmill.parse_s3_object("s3:///")
+        with self.assertRaises(ValueError):
+            wmill.parse_s3_object("s3://bucket/")
+
+    def test_empty_string_raises(self):
+        # Auto-generated keys are requested by omitting the object (None),
+        # not by an empty string.
+        with self.assertRaises(ValueError):
+            wmill.parse_s3_object("")
+
+    def test_s3object_passes_through(self):
+        self.assertEqual(wmill.parse_s3_object(S3Object(s3="x")), S3Object(s3="x"))
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/python-client/wmill/pyproject.toml b/python-client/wmill/pyproject.toml
index dda29ba2b4..16470eba60 100644
--- a/python-client/wmill/pyproject.toml
+++ b/python-client/wmill/pyproject.toml
@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "wmill"
-version = "1.747.0"
+version = "1.749.0"
 description = "A client library for accessing Windmill server wrapping the Windmill client API"
 license = "Apache-2.0"
 homepage = "https://windmill.dev"
diff --git a/python-client/wmill/wmill/client.py b/python-client/wmill/wmill/client.py
index e1a59b312d..fc4c34737d 100644
--- a/python-client/wmill/wmill/client.py
+++ b/python-client/wmill/wmill/client.py
@@ -2212,12 +2212,27 @@ def parse_resource_syntax(s: str) -> Optional[str]:
     return None
 
 def parse_s3_object(s3_object: S3Object | str) -> S3Object:
-    """Parse S3 object from string or S3Object format."""
+    """Parse S3 object from a `s3://<storage>/<key>` URI string (`s3:///<key>`
+    for the default storage) or S3Object format. Any other string raises
+    rather than falling back to an auto-generated key: an auto key is
+    requested by omitting the object, and a fallback would silently misplace
+    the upload on any typo.
+    """
     if isinstance(s3_object, str):
-        match = re.match(r'^s3://([^/]*)/(.*)$', s3_object)
+        match = re.match(r'^s3://([^/]*)/(.+)$', s3_object)
         if match:
-            return S3Object(s3=match.group(2) or "", storage=match.group(1) or None)
-        return S3Object(s3="")
+            return S3Object(s3=match.group(2), storage=match.group(1) or None)
+        if s3_object.startswith("s3://"):
+            raise ValueError(
+                f"Invalid s3 object URI {s3_object!r}: expected "
+                "s3://<storage>/<key> with a non-empty key "
+                "(s3:///<key> for the default storage)"
+            )
+        raise ValueError(
+            f"Invalid s3 object {s3_object!r}: expected an s3://<storage>/<key> "
+            f"URI (e.g. 's3:///{s3_object}' for key {s3_object!r} in the default "
+            "storage) or S3Object(s3=<key>)"
+        )
     else:
         return s3_object
 
diff --git a/system_prompts/auto-generated/cli/cli-commands.md b/system_prompts/auto-generated/cli/cli-commands.md
index 22c1605078..993dcac5cd 100644
--- a/system_prompts/auto-generated/cli/cli-commands.md
+++ b/system_prompts/auto-generated/cli/cli-commands.md
@@ -426,8 +426,8 @@ inspect asset-driven pipelines (scripts marked `// pipeline`, wired by `// on <s
 - `pipeline show <folder:string>` - render a pipeline folder's DAG (sources, lineage, subscriptions) in the terminal
   - `--json` - Output the raw asset graph as JSON
   - `--local` - Build the graph from local working-tree files (// pipeline scripts) instead of the deployed workspace — no deploy needed.
-- `pipeline run <folder:string>` - run a bounded cascade: from a schedule/manual root, fan downstream up to the --to end node(s)
-  - `--from <script:string>` - Start script (short name or path). Defaults to the folder's sole schedule/manual root.
+- `pipeline run <folder:string>` - run a cascade: from --from (a root OR any mid-DAG model), fan downstream up to the --to end node(s)
+  - `--from <script:string>` - Start script (short name or path). May be any node, including a mid-DAG model — that node plus its transitive downstream runs, upstream is NOT re-run (dbt `--select model+`). Defaults to the folder's sole schedule/manual root.
   - `--to <node:string>` - End node(s) to stop at — script names/paths or asset URIs (e.g. datatable://main/staged). Repeatable or comma-separated. Omit to run the full downstream.
   - `--dry-run` - Print the topological run plan without executing.
   - `--json` - Output the plan as JSON (for piping to jq).
diff --git a/system_prompts/auto-generated/flow.md b/system_prompts/auto-generated/flow.md
index 7f70280e9f..70bec07fe6 100644
--- a/system_prompts/auto-generated/flow.md
+++ b/system_prompts/auto-generated/flow.md
@@ -295,4 +295,4 @@ Reference a specific resource using `$res:` prefix:
 
 ## OpenFlow Schema
 
-{"OpenFlow":{"type":"object","description":"Top-level flow definition containing metadata, configuration, and the flow structure","properties":{"summary":{"type":"string","description":"Short description of what this flow does"},"description":{"type":"string","description":"Detailed documentation for this flow"},"value":{"$ref":"#/components/schemas/FlowValue"},"schema":{"type":"object","description":"JSON Schema for flow inputs. Use this to define input parameters, their types, defaults, and validation. For resource inputs, set type to 'object' and format to 'resource-<type>' (e.g., 'resource-stripe')"},"on_behalf_of_email":{"type":"string","description":"The flow will be run with the permissions of the user with this email."}},"required":["summary","value"]},"FlowValue":{"type":"object","description":"The flow structure containing modules and optional preprocessor/failure handlers","properties":{"modules":{"type":"array","description":"Array of steps that execute in sequence. Each step can be a script, subflow, loop, or branch","items":{"$ref":"#/components/schemas/FlowModule"}},"failure_module":{"description":"Special module that executes when the flow fails. Receives error object with message, name, stack, and step_id. Must have id 'failure'. Only supports script/rawscript types","$ref":"#/components/schemas/FlowModule"},"preprocessor_module":{"description":"Special module that runs before the first step on external triggers. Must have id 'preprocessor'. Only supports script/rawscript types. Cannot reference other step results","$ref":"#/components/schemas/FlowModule"},"same_worker":{"type":"boolean","description":"If true, all steps run on the same worker for better performance"},"preserve_step_tags":{"type":"boolean","description":"If true and the flow runs on a custom worker tag, steps that declare their own non-empty tag run on it instead of inheriting the flow tag. Steps without their own tag still inherit the flow tag."},"concurrent_limit":{"type":"number","description":"Maximum number of concurrent executions of this flow"},"concurrency_key":{"type":"string","description":"Expression to group concurrent executions (e.g., by user ID)"},"concurrency_time_window_s":{"type":"number","description":"Time window in seconds for concurrent_limit"},"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce flow executions"},"debounce_key":{"type":"string","description":"Expression to group debounced executions"},"debounce_args_to_accumulate":{"type":"array","description":"Arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds that a job can be debounced"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of times a job can be debounced"},"skip_expr":{"type":"string","description":"JavaScript expression to conditionally skip the entire flow"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for flow results"},"cache_ignore_s3_path":{"type":"boolean"},"delete_after_secs":{"type":"integer","description":"If set, delete the flow job's args, result and logs after this many seconds following job completion"},"flow_env":{"type":"object","description":"Environment variables available to all steps. Values can be strings, JSON values, or special references: '$var:path' (workspace variable) or '$res:path' (resource).","additionalProperties":{}},"priority":{"type":"number","description":"Execution priority (higher numbers run first)"},"early_return":{"type":"string","description":"JavaScript expression to return early from the flow"},"chat_input_enabled":{"type":"boolean","description":"Whether this flow accepts chat-style input"},"notes":{"type":"array","description":"Sticky notes attached to the flow","items":{"$ref":"#/components/schemas/FlowNote"}},"groups":{"type":"array","description":"Semantic groups of modules for organizational purposes","items":{"$ref":"#/components/schemas/FlowGroup"}}},"required":["modules"]},"Retry":{"type":"object","description":"Retry configuration for failed module executions","properties":{"constant":{"type":"object","description":"Retry with constant delay between attempts","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"seconds":{"type":"integer","description":"Seconds to wait between retries"}}},"exponential":{"type":"object","description":"Retry with exponential backoff (delay doubles each time)","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"multiplier":{"type":"integer","description":"Multiplier for exponential backoff"},"seconds":{"type":"integer","minimum":1,"description":"Initial delay in seconds"},"random_factor":{"type":"integer","minimum":0,"maximum":100,"description":"Random jitter percentage (0-100) to avoid thundering herd"}}},"retry_if":{"$ref":"#/components/schemas/RetryIf"}}},"FlowNote":{"type":"object","description":"A sticky note attached to a flow for documentation and annotation","properties":{"id":{"type":"string","description":"Unique identifier for the note"},"text":{"type":"string","description":"Content of the note"},"position":{"type":"object","description":"Position of the note in the flow editor","properties":{"x":{"type":"number","description":"X coordinate"},"y":{"type":"number","description":"Y coordinate"}},"required":["x","y"]},"size":{"type":"object","description":"Size of the note in the flow editor","properties":{"width":{"type":"number","description":"Width in pixels"},"height":{"type":"number","description":"Height in pixels"}},"required":["width","height"]},"color":{"type":"string","description":"Color of the note (e.g., \"yellow\", \"#ffff00\")"},"type":{"type":"string","enum":["free","group"],"description":"Type of note - 'free' for standalone notes, 'group' for notes that group other nodes"},"locked":{"type":"boolean","default":false,"description":"Whether the note is locked and cannot be edited or moved"},"contained_node_ids":{"type":"array","items":{"type":"string"},"description":"For group notes, the IDs of nodes contained within this group"}},"required":["id","text","color","type"]},"FlowGroup":{"type":"object","description":"A semantic group of flow modules for organizational purposes. Does not affect execution \u2014 modules remain in their original position in the flow. Groups provide naming and collapsibility in the editor. Members are computed dynamically from all nodes on paths between start_id and end_id.","properties":{"summary":{"type":"string","description":"Display name for this group"},"note":{"type":"string","description":"Markdown note shown below the group header"},"autocollapse":{"type":"boolean","default":false,"description":"If true, this group is collapsed by default in the flow editor. UI hint only."},"start_id":{"type":"string","description":"ID of the first flow module in this group (topological entry point)"},"end_id":{"type":"string","description":"ID of the last flow module in this group (topological exit point)"},"color":{"type":"string","description":"Color for the group in the flow editor"}},"required":["start_id","end_id"]},"RetryIf":{"type":"object","description":"Conditional retry based on error or result","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to retry. Has access to 'result' and 'error' variables"}},"required":["expr"]},"StopAfterIf":{"type":"object","description":"Early termination condition for a module","properties":{"skip_if_stopped":{"type":"boolean","description":"If true, following steps are skipped when this condition triggers"},"expr":{"type":"string","description":"JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"},"error_message":{"type":"string","nullable":true,"description":"Custom error message when stopping with an error. Mutually exclusive with skip_if_stopped. If set to a non-empty string, the flow stops with this error. If empty string, a default error message is used. If null or omitted, no error is raised."},"error_include_result":{"type":"boolean","description":"When stopping with an error (error_message set), embed the stopping step's own result inside the raised error object (as error.result) instead of discarding it. The top-level result stays { error }. Defaults to false."}},"required":["expr"]},"FlowModule":{"type":"object","description":"A single step in a flow. Can be a script, subflow, loop, or branch","properties":{"id":{"type":"string","description":"Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)"},"value":{"$ref":"#/components/schemas/FlowModuleValue"},"stop_after_if":{"description":"Early termination condition evaluated after this step completes","$ref":"#/components/schemas/StopAfterIf"},"stop_after_all_iters_if":{"description":"For loops only - early termination condition evaluated after all iterations complete","$ref":"#/components/schemas/StopAfterIf"},"skip_if":{"type":"object","description":"Conditionally skip this step based on previous results or flow inputs","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to skip. Can use 'flow_input' or 'results.<step_id>'"}},"required":["expr"]},"sleep":{"description":"Delay before executing this step (in seconds or as expression)","$ref":"#/components/schemas/InputTransform"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for this step's results"},"cache_ignore_s3_path":{"type":"boolean"},"timeout":{"description":"Maximum execution time in seconds (static value or expression)","$ref":"#/components/schemas/InputTransform"},"delete_after_secs":{"type":"integer","description":"If set, delete the step's args, result and logs after this many seconds following job completion"},"summary":{"type":"string","description":"Short description of what this step does"},"mock":{"type":"object","description":"Mock configuration for testing without executing the actual step","properties":{"enabled":{"type":"boolean","description":"If true, return mock value instead of executing"},"return_value":{"description":"Value to return when mocked"}}},"suspend":{"type":"object","description":"Configuration for approval/resume steps that wait for user input","properties":{"required_events":{"type":"integer","description":"Number of approvals required before continuing"},"timeout":{"type":"integer","description":"Timeout in seconds before auto-continuing or canceling"},"resume_form":{"type":"object","description":"Form schema for collecting input when resuming","properties":{"schema":{"type":"object","description":"JSON Schema for the resume form"}}},"user_auth_required":{"type":"boolean","description":"If true, only authenticated users can approve"},"user_groups_required":{"description":"Expression or list of groups that can approve","$ref":"#/components/schemas/InputTransform"},"self_approval_disabled":{"type":"boolean","description":"If true, the user who started the flow cannot approve"},"hide_cancel":{"type":"boolean","description":"If true, hide the cancel button on the approval form"},"continue_on_disapprove_timeout":{"type":"boolean","description":"If true, continue flow on timeout instead of canceling"}}},"priority":{"type":"number","description":"Execution priority for this step (higher numbers run first)"},"continue_on_error":{"type":"boolean","description":"If true, flow continues even if this step fails"},"retry":{"description":"Retry configuration if this step fails","$ref":"#/components/schemas/Retry"},"debouncing":{"description":"Debounce configuration for this step (EE only)","type":"object","properties":{"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce this step's executions across flow runs"},"debounce_key":{"type":"string","description":"Expression to group debounced executions. Supports $workspace and $args[name]. Default: $workspace/flow/<flow_path>-<step_id>"},"debounce_args_to_accumulate":{"type":"array","description":"Array-type arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds before forced execution"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of debounces before forced execution"}}}},"required":["value","id"]},"InputTransform":{"description":"Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs","oneOf":[{"$ref":"#/components/schemas/StaticTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"StaticTransform":{"type":"object","description":"Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'","properties":{"value":{"description":"The static value. For resources, use format '$res:path/to/resource'"},"type":{"type":"string","enum":["static"]}},"required":["type"]},"JavascriptTransform":{"type":"object","description":"JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside loops, use 'flow_input.iter.value' for the current iteration value","properties":{"expr":{"type":"string","description":"JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"},"type":{"type":"string","enum":["javascript"]}},"required":["expr","type"]},"AiTransform":{"type":"object","description":"Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.","properties":{"type":{"type":"string","enum":["ai"]}},"required":["type"]},"AIProviderKind":{"type":"string","description":"Supported AI provider types","enum":["openai","azure_openai","azure_foundry","anthropic","mistral","deepseek","googleai","groq","openrouter","togetherai","customai","aws_bedrock"]},"ProviderConfig":{"type":"object","description":"Complete AI provider configuration with resource reference and model selection","properties":{"kind":{"$ref":"#/components/schemas/AIProviderKind"},"resource":{"type":"string","description":"Resource reference in format '$res:{resource_path}' pointing to provider credentials"},"model":{"type":"string","description":"Model identifier (e.g., 'gpt-4', 'claude-3-opus-20240229', 'gemini-pro')"}},"required":["kind","resource","model"]},"StaticProviderTransform":{"type":"object","description":"Static provider configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/ProviderConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"ProviderTransform":{"description":"Provider configuration - can be static (ProviderConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticProviderTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticProviderTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"MemoryOff":{"type":"object","description":"No conversation memory/context","properties":{"kind":{"type":"string","enum":["off"]}},"required":["kind"]},"MemoryAuto":{"type":"object","description":"Automatic context management","properties":{"kind":{"type":"string","enum":["auto"]},"context_length":{"type":"integer","description":"Maximum number of messages to retain in context"},"memory_id":{"type":"string","description":"Identifier for persistent memory across agent invocations"}},"required":["kind"]},"MemoryMessage":{"type":"object","description":"A single message in conversation history","properties":{"role":{"type":"string","enum":["user","assistant","system"]},"content":{"type":"string"}},"required":["role","content"]},"MemoryManual":{"type":"object","description":"Explicit message history","properties":{"kind":{"type":"string","enum":["manual"]},"messages":{"type":"array","items":{"$ref":"#/components/schemas/MemoryMessage"}}},"required":["kind","messages"]},"MemoryConfig":{"description":"Conversation memory configuration","oneOf":[{"$ref":"#/components/schemas/MemoryOff"},{"$ref":"#/components/schemas/MemoryAuto"},{"$ref":"#/components/schemas/MemoryManual"}],"discriminator":{"propertyName":"kind","mapping":{"off":"#/components/schemas/MemoryOff","auto":"#/components/schemas/MemoryAuto","manual":"#/components/schemas/MemoryManual"}}},"StaticMemoryTransform":{"type":"object","description":"Static memory configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/MemoryConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"MemoryTransform":{"description":"Memory configuration - can be static (MemoryConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticMemoryTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticMemoryTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"FlowModuleValue":{"description":"The actual implementation of a flow step. Can be a script (inline or referenced), subflow, loop, branch, or special module type","oneOf":[{"$ref":"#/components/schemas/RawScript"},{"$ref":"#/components/schemas/PathScript"},{"$ref":"#/components/schemas/PathFlow"},{"$ref":"#/components/schemas/ForloopFlow"},{"$ref":"#/components/schemas/WhileloopFlow"},{"$ref":"#/components/schemas/BranchOne"},{"$ref":"#/components/schemas/BranchAll"},{"$ref":"#/components/schemas/Identity"},{"$ref":"#/components/schemas/AiAgent"}],"discriminator":{"propertyName":"type","mapping":{"rawscript":"#/components/schemas/RawScript","script":"#/components/schemas/PathScript","flow":"#/components/schemas/PathFlow","forloopflow":"#/components/schemas/ForloopFlow","whileloopflow":"#/components/schemas/WhileloopFlow","branchone":"#/components/schemas/BranchOne","branchall":"#/components/schemas/BranchAll","identity":"#/components/schemas/Identity","aiagent":"#/components/schemas/AiAgent"}}},"RawScript":{"type":"object","description":"Inline script with code defined directly in the flow. Use 'bun' as default language if unspecified. The script receives arguments from input_transforms","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"content":{"type":"string","description":"The script source code. Should export a 'main' function"},"language":{"type":"string","description":"Programming language for this script","enum":["deno","bun","python3","go","bash","powershell","postgresql","mysql","bigquery","snowflake","mssql","oracledb","graphql","nativets","php","rust","ansible","csharp","nu","java","ruby","rlang","duckdb"]},"path":{"type":"string","description":"Optional path for saving this script"},"lock":{"type":"string","description":"Lock file content for dependencies"},"type":{"type":"string","enum":["rawscript"]},"tag":{"type":"string","description":"Worker group tag for execution routing"},"concurrent_limit":{"type":"number","description":"Maximum concurrent executions of this script"},"concurrency_time_window_s":{"type":"number","description":"Time window for concurrent_limit"},"custom_concurrency_key":{"type":"string","description":"Custom key for grouping concurrent executions"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"},"assets":{"type":"array","description":"External resources this script accesses (S3 objects, resources, etc.)","items":{"type":"object","required":["path","kind"],"properties":{"path":{"type":"string","description":"Path to the asset"},"kind":{"type":"string","description":"Type of asset","enum":["s3object","resource","ducklake","datatable","volume"]},"access_type":{"type":"string","nullable":true,"description":"Access level for this asset","enum":["r","w","rw"]},"alt_access_type":{"type":"string","nullable":true,"description":"Alternative access level","enum":["r","w","rw"]}}}}},"required":["type","content","language","input_transforms"]},"PathScript":{"type":"object","description":"Reference to an existing script by path. Use this when calling a previously saved script instead of writing inline code","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the script in the workspace (e.g., 'f/scripts/send_email')"},"hash":{"type":"string","description":"Optional specific version hash of the script to use"},"type":{"type":"string","enum":["script"]},"tag_override":{"type":"string","description":"Override the script's default worker group tag"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"}},"required":["type","path","input_transforms"]},"PathFlow":{"type":"object","description":"Reference to an existing flow by path. Use this to call another flow as a subflow","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the subflow's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the flow in the workspace (e.g., 'f/flows/process_user')"},"type":{"type":"string","enum":["flow"]}},"required":["type","path","input_transforms"]},"ForloopFlow":{"type":"object","description":"Executes nested modules in a loop over an iterator. Inside the loop, use 'flow_input.iter.value' to access the current iteration value, and 'flow_input.iter.index' for the index. Supports parallel execution for better performance on I/O-bound operations","properties":{"modules":{"type":"array","description":"Steps to execute for each iteration. These can reference the iteration value via 'flow_input.iter.value'","items":{"$ref":"#/components/schemas/FlowModule"}},"iterator":{"description":"JavaScript expression that returns an array to iterate over. Can reference 'results.step_id' or 'flow_input'","$ref":"#/components/schemas/InputTransform"},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["forloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (faster for I/O-bound operations). Use with parallelism to control concurrency"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true. Limits resource usage. Can be static number or expression","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","iterator","skip_failures","type"]},"WhileloopFlow":{"type":"object","description":"Executes nested modules repeatedly while a condition is true. The loop checks the condition after each iteration. Use stop_after_if on modules to control loop termination","properties":{"modules":{"type":"array","description":"Steps to execute in each iteration. Use stop_after_if to control when the loop ends","items":{"$ref":"#/components/schemas/FlowModule"}},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["whileloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (use with caution in while loops)"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","skip_failures","type"]},"BranchOne":{"type":"object","description":"Conditional branching where only the first matching branch executes. Branches are evaluated in order, and the first one with a true expression runs. If no branches match, the default branch executes","properties":{"branches":{"type":"array","description":"Array of branches to evaluate in order. The first branch with expr evaluating to true executes","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch condition"},"expr":{"type":"string","description":"JavaScript expression that returns boolean. Can use 'results.step_id' or 'flow_input'. First true expr wins"},"modules":{"type":"array","description":"Steps to execute if this branch's expr is true","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules","expr"]}},"default":{"type":"array","description":"Steps to execute if no branch expressions match","items":{"$ref":"#/components/schemas/FlowModule"}},"type":{"type":"string","enum":["branchone"]}},"required":["branches","default","type"]},"BranchAll":{"type":"object","description":"Parallel branching where all branches execute simultaneously. Unlike BranchOne, all branches run regardless of conditions. Useful for executing independent tasks concurrently","properties":{"branches":{"type":"array","description":"Array of branches that all execute (either in parallel or sequentially)","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch's purpose"},"skip_failure":{"type":"boolean","description":"If true, failure in this branch doesn't fail the entire flow"},"modules":{"type":"array","description":"Steps to execute in this branch","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules"]}},"type":{"type":"string","enum":["branchall"]},"parallel":{"type":"boolean","description":"If true, all branches execute concurrently. If false, they execute sequentially"}},"required":["branches","type"]},"AgentTool":{"type":"object","description":"A tool available to an AI agent. Can be a flow module or an external MCP (Model Context Protocol) tool","properties":{"id":{"type":"string","description":"Unique identifier for this tool. Cannot contain spaces - use underscores instead (e.g., 'get_user_data' not 'get user data')"},"summary":{"type":"string","description":"Short description of what this tool does (shown to the AI)"},"value":{"$ref":"#/components/schemas/ToolValue"}},"required":["id","value"]},"ToolValue":{"description":"The implementation of a tool. Can be a flow module (script/flow) or an MCP tool reference","oneOf":[{"$ref":"#/components/schemas/FlowModuleTool"},{"$ref":"#/components/schemas/McpToolValue"},{"$ref":"#/components/schemas/WebsearchToolValue"}],"discriminator":{"propertyName":"tool_type","mapping":{"flowmodule":"#/components/schemas/FlowModuleTool","mcp":"#/components/schemas/McpToolValue","websearch":"#/components/schemas/WebsearchToolValue"}}},"FlowModuleTool":{"description":"A tool implemented as a flow module (script, flow, etc.). The AI can call this like any other flow module","allOf":[{"type":"object","properties":{"tool_type":{"type":"string","enum":["flowmodule"]}},"required":["tool_type"]},{"$ref":"#/components/schemas/FlowModuleValue"}]},"WebsearchToolValue":{"type":"object","description":"A tool implemented as a websearch tool. The AI can call this like any other websearch tool","properties":{"tool_type":{"type":"string","enum":["websearch"]}},"required":["tool_type"]},"McpToolValue":{"type":"object","description":"Reference to an external MCP (Model Context Protocol) tool. The AI can call tools from MCP servers","properties":{"tool_type":{"type":"string","enum":["mcp"]},"resource_path":{"type":"string","description":"Path to the MCP resource/server configuration"},"include_tools":{"type":"array","description":"Whitelist of specific tools to include from this MCP server","items":{"type":"string"}},"exclude_tools":{"type":"array","description":"Blacklist of tools to exclude from this MCP server","items":{"type":"string"}}},"required":["tool_type","resource_path"]},"AiAgent":{"type":"object","description":"AI agent step that can use tools to accomplish tasks. The agent receives inputs and can call any of its configured tools to complete the task","properties":{"input_transforms":{"type":"object","description":"Input parameters for the AI agent mapped to their values","properties":{"provider":{"$ref":"#/components/schemas/ProviderTransform"},"output_type":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Output format type.\nValid values: 'text' (default) - plain text response, 'image' - image generation\n"},"user_message":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"The user's prompt/message to the AI agent. Supports variable interpolation with flow.input syntax."},"system_prompt":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"System instructions that guide the AI's behavior, persona, and response style. Optional."},"streaming":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Boolean. If true, stream the AI response incrementally.\nStreaming events include: token_delta, tool_call, tool_call_arguments, tool_execution, tool_result\n"},"memory":{"$ref":"#/components/schemas/MemoryTransform"},"output_schema":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"JSON Schema object defining structured output format. Used when you need the AI to return data in a specific shape.\nSupports standard JSON Schema properties: type, properties, required, items, enum, pattern, minLength, maxLength, minimum, maximum, etc.\nExample: { type: 'object', properties: { name: { type: 'string' }, age: { type: 'integer' } }, required: ['name'] }\n"},"user_attachments":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Array of file references (images or PDFs) for the AI agent.\nFormat: Array<{ bucket: string, key: string }> - S3 object references\nExample: [{ bucket: 'my-bucket', key: 'documents/report.pdf' }]\n"},"max_completion_tokens":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Integer. Maximum number of tokens the AI will generate in its response.\nRange: 1 to 4,294,967,295. Typical values: 256-4096 for most use cases.\n"},"temperature":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Float. Controls randomness/creativity of responses.\nRange: 0.0 to 2.0 (provider-dependent)\n- 0.0 = deterministic, focused responses\n- 0.7 = balanced (common default)\n- 1.0+ = more creative/random\n"},"max_iterations":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Number. Limits how many times the agent can loop through reasoning and tool use.\nRange: 1-1000.\n"}},"required":["provider","user_message","output_type"]},"tools":{"type":"array","description":"Array of tools the agent can use. The agent decides which tools to call based on the task","items":{"$ref":"#/components/schemas/AgentTool"}},"type":{"type":"string","enum":["aiagent"]},"tag":{"type":"string","description":"Worker group tag for execution routing. If not set, the AI agent step runs on the flow's tag (default `flow`)"},"omit_output_from_conversation":{"type":"boolean","default":false,"description":"If true, this AI agent step does not persist its assistant or tool messages to the flow conversation when chat mode is enabled."},"parallel":{"type":"boolean","description":"If true, the agent can execute multiple tool calls in parallel"}},"required":["tools","type","input_transforms"]},"Identity":{"type":"object","description":"Pass-through module that returns its input unchanged. Useful for flow structure or as a placeholder","properties":{"type":{"type":"string","enum":["identity"]},"flow":{"type":"boolean","description":"If true, marks this as a flow identity (special handling)"}},"required":["type"]},"FlowStatus":{"type":"object","properties":{"step":{"type":"integer"},"modules":{"type":"array","items":{"$ref":"#/components/schemas/FlowStatusModule"}},"user_states":{"additionalProperties":true},"preprocessor_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"}]},"failure_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"},{"type":"object","properties":{"parent_module":{"type":"string"}}}]},"retry":{"type":"object","properties":{"fail_count":{"type":"integer"},"failed_jobs":{"type":"array","items":{"type":"string","format":"uuid"}}}}},"required":["step","modules","failure_module"]},"FlowStatusModule":{"type":"object","properties":{"type":{"type":"string","enum":["WaitingForPriorSteps","WaitingForEvents","WaitingForExecutor","InProgress","Success","Failure"]},"id":{"type":"string"},"job":{"type":"string","format":"uuid"},"count":{"type":"integer"},"progress":{"type":"integer"},"iterator":{"type":"object","properties":{"index":{"type":"integer"},"itered":{"type":"array","items":{}},"itered_len":{"type":"integer"},"args":{}}},"flow_jobs":{"type":"array","items":{"type":"string"}},"flow_jobs_success":{"type":"array","items":{"type":"boolean"}},"flow_jobs_duration":{"type":"object","properties":{"started_at":{"type":"array","items":{"type":"string"}},"duration_ms":{"type":"array","items":{"type":"integer"}}}},"branch_chosen":{"type":"object","properties":{"type":{"type":"string","enum":["branch","default"]},"branch":{"type":"integer"}},"required":["type"]},"branchall":{"type":"object","properties":{"branch":{"type":"integer"},"len":{"type":"integer"}},"required":["branch","len"]},"approvers":{"type":"array","items":{"type":"object","properties":{"resume_id":{"type":"integer"},"approver":{"type":"string"}},"required":["resume_id","approver"]}},"failed_retries":{"type":"array","items":{"type":"string","format":"uuid"}},"skipped":{"type":"boolean"},"agent_actions":{"type":"array","items":{"type":"object","oneOf":[{"type":"object","properties":{"job_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"type":{"type":"string","enum":["tool_call"]},"module_id":{"type":"string"}},"required":["job_id","function_name","type","module_id"]},{"type":"object","properties":{"call_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"resource_path":{"type":"string"},"type":{"type":"string","enum":["mcp_tool_call"]},"arguments":{"type":"object"}},"required":["call_id","function_name","resource_path","type"]},{"type":"object","properties":{"type":{"type":"string","enum":["web_search"]}},"required":["type"]},{"type":"object","properties":{"type":{"type":"string","enum":["message"]}},"required":["content","type"]}]}},"agent_actions_success":{"type":"array","items":{"type":"boolean"}}},"required":["type"]}}
\ No newline at end of file
+{"OpenFlow":{"type":"object","description":"Top-level flow definition containing metadata, configuration, and the flow structure","properties":{"summary":{"type":"string","description":"Short description of what this flow does"},"description":{"type":"string","description":"Detailed documentation for this flow"},"value":{"$ref":"#/components/schemas/FlowValue"},"schema":{"type":"object","description":"JSON Schema for flow inputs. Use this to define input parameters, their types, defaults, and validation. For resource inputs, set type to 'object' and format to 'resource-<type>' (e.g., 'resource-stripe')"},"on_behalf_of_email":{"type":"string","description":"The flow will be run with the permissions of the user with this email."}},"required":["summary","value"]},"FlowValue":{"type":"object","description":"The flow structure containing modules and optional preprocessor/failure handlers","properties":{"modules":{"type":"array","description":"Array of steps that execute in sequence. Each step can be a script, subflow, loop, or branch","items":{"$ref":"#/components/schemas/FlowModule"}},"failure_module":{"description":"Special module that executes when the flow fails. Receives error object with message, name, stack, and step_id. Must have id 'failure'. Only supports script/rawscript types","$ref":"#/components/schemas/FlowModule"},"preprocessor_module":{"description":"Special module that runs before the first step on external triggers. Must have id 'preprocessor'. Only supports script/rawscript types. Cannot reference other step results","$ref":"#/components/schemas/FlowModule"},"same_worker":{"type":"boolean","description":"If true, all steps run on the same worker for better performance"},"preserve_step_tags":{"type":"boolean","description":"If true and the flow runs on a custom worker tag, steps that declare their own non-empty tag run on it instead of inheriting the flow tag. Steps without their own tag still inherit the flow tag."},"concurrent_limit":{"type":"number","description":"Maximum number of concurrent executions of this flow"},"concurrency_key":{"type":"string","description":"Expression to group concurrent executions (e.g., by user ID)"},"concurrency_time_window_s":{"type":"number","description":"Time window in seconds for concurrent_limit"},"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce flow executions"},"debounce_key":{"type":"string","description":"Expression to group debounced executions"},"debounce_args_to_accumulate":{"type":"array","description":"Arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds that a job can be debounced"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of times a job can be debounced"},"skip_expr":{"type":"string","description":"JavaScript expression to conditionally skip the entire flow"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for flow results"},"cache_ignore_s3_path":{"type":"boolean"},"delete_after_secs":{"type":"integer","description":"If set, delete the flow job's args, result and logs after this many seconds following job completion"},"flow_env":{"type":"object","description":"Environment variables available to all steps. Values can be strings, JSON values, or special references: '$var:path' (workspace variable) or '$res:path' (resource).","additionalProperties":{}},"priority":{"type":"number","description":"Execution priority (higher numbers run first)"},"early_return":{"type":"string","description":"JavaScript expression to return early from the flow"},"chat_input_enabled":{"type":"boolean","description":"Whether this flow accepts chat-style input"},"notes":{"type":"array","description":"Sticky notes attached to the flow","items":{"$ref":"#/components/schemas/FlowNote"}},"groups":{"type":"array","description":"Semantic groups of modules for organizational purposes","items":{"$ref":"#/components/schemas/FlowGroup"}}},"required":["modules"]},"Retry":{"type":"object","description":"Retry configuration for failed module executions","properties":{"constant":{"type":"object","description":"Retry with constant delay between attempts","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"seconds":{"type":"integer","description":"Seconds to wait between retries"}}},"exponential":{"type":"object","description":"Retry with exponential backoff (delay doubles each time)","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"multiplier":{"type":"integer","description":"Multiplier for exponential backoff"},"seconds":{"type":"integer","minimum":1,"description":"Initial delay in seconds"},"random_factor":{"type":"integer","minimum":0,"maximum":100,"description":"Random jitter percentage (0-100) to avoid thundering herd"}}},"retry_if":{"$ref":"#/components/schemas/RetryIf"}}},"FlowNote":{"type":"object","description":"A sticky note attached to a flow for documentation and annotation","properties":{"id":{"type":"string","description":"Unique identifier for the note"},"text":{"type":"string","description":"Content of the note"},"position":{"type":"object","description":"Position of the note in the flow editor","properties":{"x":{"type":"number","description":"X coordinate"},"y":{"type":"number","description":"Y coordinate"}},"required":["x","y"]},"size":{"type":"object","description":"Size of the note in the flow editor","properties":{"width":{"type":"number","description":"Width in pixels"},"height":{"type":"number","description":"Height in pixels"}},"required":["width","height"]},"color":{"type":"string","description":"Color of the note (e.g., \"yellow\", \"#ffff00\")"},"type":{"type":"string","enum":["free","group"],"description":"Type of note - 'free' for standalone notes, 'group' for notes that group other nodes"},"locked":{"type":"boolean","default":false,"description":"Whether the note is locked and cannot be edited or moved"},"contained_node_ids":{"type":"array","items":{"type":"string"},"description":"For group notes, the IDs of nodes contained within this group"}},"required":["id","text","color","type"]},"FlowGroup":{"type":"object","description":"A semantic group of flow modules for organizational purposes. Does not affect execution \u2014 modules remain in their original position in the flow. Groups provide naming and collapsibility in the editor. Members are computed dynamically from all nodes on paths between start_id and end_id.","properties":{"summary":{"type":"string","description":"Display name for this group"},"note":{"type":"string","description":"Markdown note shown below the group header"},"autocollapse":{"type":"boolean","default":false,"description":"If true, this group is collapsed by default in the flow editor. UI hint only."},"start_id":{"type":"string","description":"ID of the first flow module in this group (topological entry point)"},"end_id":{"type":"string","description":"ID of the last flow module in this group (topological exit point)"},"color":{"type":"string","description":"Color for the group in the flow editor"}},"required":["start_id","end_id"]},"RetryIf":{"type":"object","description":"Conditional retry based on error or result","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to retry. Has access to 'result' and 'error' variables"}},"required":["expr"]},"StopAfterIf":{"type":"object","description":"Early termination condition for a module","properties":{"skip_if_stopped":{"type":"boolean","description":"If true, following steps are skipped when this condition triggers"},"expr":{"type":"string","description":"JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"},"error_message":{"type":"string","nullable":true,"description":"Custom error message when stopping with an error. Mutually exclusive with skip_if_stopped. If set to a non-empty string, the flow stops with this error. If empty string, a default error message is used. If null or omitted, no error is raised."},"error_include_result":{"type":"boolean","description":"When stopping with an error (error_message set), embed the stopping step's own result inside the raised error object (as error.result) instead of discarding it. The top-level result stays { error }. Defaults to false."}},"required":["expr"]},"FlowModule":{"type":"object","description":"A single step in a flow. Can be a script, subflow, loop, or branch","properties":{"id":{"type":"string","description":"Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)"},"value":{"$ref":"#/components/schemas/FlowModuleValue"},"stop_after_if":{"description":"Early termination condition evaluated after this step completes","$ref":"#/components/schemas/StopAfterIf"},"stop_after_all_iters_if":{"description":"For loops only - early termination condition evaluated after all iterations complete","$ref":"#/components/schemas/StopAfterIf"},"skip_if":{"type":"object","description":"Conditionally skip this step based on previous results or flow inputs","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to skip. Can use 'flow_input' or 'results.<step_id>'"}},"required":["expr"]},"sleep":{"description":"Delay before executing this step (in seconds or as expression)","$ref":"#/components/schemas/InputTransform"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for this step's results"},"cache_ignore_s3_path":{"type":"boolean"},"timeout":{"description":"Maximum execution time in seconds (static value or expression)","$ref":"#/components/schemas/InputTransform"},"delete_after_secs":{"type":"integer","description":"If set, delete the step's args, result and logs after this many seconds following job completion"},"summary":{"type":"string","description":"Short description of what this step does"},"mock":{"type":"object","description":"Mock configuration for testing without executing the actual step","properties":{"enabled":{"type":"boolean","description":"If true, return mock value instead of executing"},"return_value":{"description":"Value to return when mocked"}}},"suspend":{"type":"object","description":"Configuration for approval/resume steps that wait for user input","properties":{"required_events":{"type":"integer","description":"Number of approvals required before continuing"},"timeout":{"type":"integer","description":"Timeout in seconds before auto-continuing or canceling"},"resume_form":{"type":"object","description":"Form schema for collecting input when resuming","properties":{"schema":{"type":"object","description":"JSON Schema for the resume form"}}},"user_auth_required":{"type":"boolean","description":"If true, only authenticated users can approve"},"user_groups_required":{"description":"Expression or list of groups that can approve","$ref":"#/components/schemas/InputTransform"},"self_approval_disabled":{"type":"boolean","description":"If true, the user who started the flow cannot approve"},"hide_cancel":{"type":"boolean","description":"If true, hide the cancel button on the approval form"},"continue_on_disapprove_timeout":{"type":"boolean","description":"If true, continue flow on timeout instead of canceling"}}},"priority":{"type":"number","description":"Execution priority for this step (higher numbers run first)"},"continue_on_error":{"type":"boolean","description":"If true, flow continues even if this step fails"},"retry":{"description":"Retry configuration if this step fails","$ref":"#/components/schemas/Retry"},"debouncing":{"description":"Debounce configuration for this step (EE only)","type":"object","properties":{"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce this step's executions across flow runs"},"debounce_key":{"type":"string","description":"Expression to group debounced executions. Supports $workspace and $args[name]. Default: $workspace/flow/<flow_path>-<step_id>"},"debounce_args_to_accumulate":{"type":"array","description":"Array-type arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds before forced execution"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of debounces before forced execution"}}}},"required":["value","id"]},"InputTransform":{"description":"Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs","oneOf":[{"$ref":"#/components/schemas/StaticTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"StaticTransform":{"type":"object","description":"Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'","properties":{"value":{"description":"The static value. For resources, use format '$res:path/to/resource'"},"type":{"type":"string","enum":["static"]}},"required":["type"]},"JavascriptTransform":{"type":"object","description":"JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside loops, use 'flow_input.iter.value' for the current iteration value","properties":{"expr":{"type":"string","description":"JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"},"type":{"type":"string","enum":["javascript"]}},"required":["expr","type"]},"AiTransform":{"type":"object","description":"Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.","properties":{"type":{"type":"string","enum":["ai"]}},"required":["type"]},"AIProviderKind":{"type":"string","description":"Supported AI provider types","enum":["openai","azure_openai","azure_foundry","anthropic","mistral","deepseek","googleai","groq","openrouter","togetherai","customai","aws_bedrock"]},"ProviderConfig":{"type":"object","description":"Complete AI provider configuration with resource reference and model selection","properties":{"kind":{"$ref":"#/components/schemas/AIProviderKind"},"resource":{"type":"string","description":"Resource reference in format '$res:{resource_path}' pointing to provider credentials"},"model":{"type":"string","description":"Model identifier (e.g., 'gpt-4', 'claude-3-opus-20240229', 'gemini-pro')"},"reasoning_effort":{"type":"string","description":"Provider-native reasoning effort token (e.g. 'low', 'high', 'none') for models that support extended thinking. Optional; unset leaves the provider default."}},"required":["kind","resource","model"]},"StaticProviderTransform":{"type":"object","description":"Static provider configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/ProviderConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"ProviderTransform":{"description":"Provider configuration - can be static (ProviderConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticProviderTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticProviderTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"MemoryOff":{"type":"object","description":"No conversation memory/context","properties":{"kind":{"type":"string","enum":["off"]}},"required":["kind"]},"MemoryAuto":{"type":"object","description":"Automatic context management","properties":{"kind":{"type":"string","enum":["auto"]},"context_length":{"type":"integer","description":"Maximum number of messages to retain in context"},"memory_id":{"type":"string","description":"Identifier for persistent memory across agent invocations"}},"required":["kind"]},"MemoryMessage":{"type":"object","description":"A single message in conversation history","properties":{"role":{"type":"string","enum":["user","assistant","system"]},"content":{"type":"string"}},"required":["role","content"]},"MemoryManual":{"type":"object","description":"Explicit message history","properties":{"kind":{"type":"string","enum":["manual"]},"messages":{"type":"array","items":{"$ref":"#/components/schemas/MemoryMessage"}}},"required":["kind","messages"]},"MemoryConfig":{"description":"Conversation memory configuration","oneOf":[{"$ref":"#/components/schemas/MemoryOff"},{"$ref":"#/components/schemas/MemoryAuto"},{"$ref":"#/components/schemas/MemoryManual"}],"discriminator":{"propertyName":"kind","mapping":{"off":"#/components/schemas/MemoryOff","auto":"#/components/schemas/MemoryAuto","manual":"#/components/schemas/MemoryManual"}}},"StaticMemoryTransform":{"type":"object","description":"Static memory configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/MemoryConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"MemoryTransform":{"description":"Memory configuration - can be static (MemoryConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticMemoryTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticMemoryTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"FlowModuleValue":{"description":"The actual implementation of a flow step. Can be a script (inline or referenced), subflow, loop, branch, or special module type","oneOf":[{"$ref":"#/components/schemas/RawScript"},{"$ref":"#/components/schemas/PathScript"},{"$ref":"#/components/schemas/PathFlow"},{"$ref":"#/components/schemas/ForloopFlow"},{"$ref":"#/components/schemas/WhileloopFlow"},{"$ref":"#/components/schemas/BranchOne"},{"$ref":"#/components/schemas/BranchAll"},{"$ref":"#/components/schemas/Identity"},{"$ref":"#/components/schemas/AiAgent"}],"discriminator":{"propertyName":"type","mapping":{"rawscript":"#/components/schemas/RawScript","script":"#/components/schemas/PathScript","flow":"#/components/schemas/PathFlow","forloopflow":"#/components/schemas/ForloopFlow","whileloopflow":"#/components/schemas/WhileloopFlow","branchone":"#/components/schemas/BranchOne","branchall":"#/components/schemas/BranchAll","identity":"#/components/schemas/Identity","aiagent":"#/components/schemas/AiAgent"}}},"RawScript":{"type":"object","description":"Inline script with code defined directly in the flow. Use 'bun' as default language if unspecified. The script receives arguments from input_transforms","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"content":{"type":"string","description":"The script source code. Should export a 'main' function"},"language":{"type":"string","description":"Programming language for this script","enum":["deno","bun","python3","go","bash","powershell","postgresql","mysql","bigquery","snowflake","mssql","oracledb","graphql","nativets","php","rust","ansible","csharp","nu","java","ruby","rlang","duckdb"]},"path":{"type":"string","description":"Optional path for saving this script"},"lock":{"type":"string","description":"Lock file content for dependencies"},"type":{"type":"string","enum":["rawscript"]},"tag":{"type":"string","description":"Worker group tag for execution routing"},"concurrent_limit":{"type":"number","description":"Maximum concurrent executions of this script"},"concurrency_time_window_s":{"type":"number","description":"Time window for concurrent_limit"},"custom_concurrency_key":{"type":"string","description":"Custom key for grouping concurrent executions"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"},"assets":{"type":"array","description":"External resources this script accesses (S3 objects, resources, etc.)","items":{"type":"object","required":["path","kind"],"properties":{"path":{"type":"string","description":"Path to the asset"},"kind":{"type":"string","description":"Type of asset","enum":["s3object","resource","ducklake","datatable","volume"]},"access_type":{"type":"string","nullable":true,"description":"Access level for this asset","enum":["r","w","rw"]},"alt_access_type":{"type":"string","nullable":true,"description":"Alternative access level","enum":["r","w","rw"]}}}}},"required":["type","content","language","input_transforms"]},"PathScript":{"type":"object","description":"Reference to an existing script by path. Use this when calling a previously saved script instead of writing inline code","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the script in the workspace (e.g., 'f/scripts/send_email')"},"hash":{"type":"string","description":"Optional specific version hash of the script to use"},"type":{"type":"string","enum":["script"]},"tag_override":{"type":"string","description":"Override the script's default worker group tag"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"}},"required":["type","path","input_transforms"]},"PathFlow":{"type":"object","description":"Reference to an existing flow by path. Use this to call another flow as a subflow","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the subflow's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the flow in the workspace (e.g., 'f/flows/process_user')"},"type":{"type":"string","enum":["flow"]}},"required":["type","path","input_transforms"]},"ForloopFlow":{"type":"object","description":"Executes nested modules in a loop over an iterator. Inside the loop, use 'flow_input.iter.value' to access the current iteration value, and 'flow_input.iter.index' for the index. Supports parallel execution for better performance on I/O-bound operations","properties":{"modules":{"type":"array","description":"Steps to execute for each iteration. These can reference the iteration value via 'flow_input.iter.value'","items":{"$ref":"#/components/schemas/FlowModule"}},"iterator":{"description":"JavaScript expression that returns an array to iterate over. Can reference 'results.step_id' or 'flow_input'","$ref":"#/components/schemas/InputTransform"},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["forloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (faster for I/O-bound operations). Use with parallelism to control concurrency"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true. Limits resource usage. Can be static number or expression","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","iterator","skip_failures","type"]},"WhileloopFlow":{"type":"object","description":"Executes nested modules repeatedly while a condition is true. The loop checks the condition after each iteration. Use stop_after_if on modules to control loop termination","properties":{"modules":{"type":"array","description":"Steps to execute in each iteration. Use stop_after_if to control when the loop ends","items":{"$ref":"#/components/schemas/FlowModule"}},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["whileloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (use with caution in while loops)"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","skip_failures","type"]},"BranchOne":{"type":"object","description":"Conditional branching where only the first matching branch executes. Branches are evaluated in order, and the first one with a true expression runs. If no branches match, the default branch executes","properties":{"branches":{"type":"array","description":"Array of branches to evaluate in order. The first branch with expr evaluating to true executes","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch condition"},"expr":{"type":"string","description":"JavaScript expression that returns boolean. Can use 'results.step_id' or 'flow_input'. First true expr wins"},"modules":{"type":"array","description":"Steps to execute if this branch's expr is true","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules","expr"]}},"default":{"type":"array","description":"Steps to execute if no branch expressions match","items":{"$ref":"#/components/schemas/FlowModule"}},"type":{"type":"string","enum":["branchone"]}},"required":["branches","default","type"]},"BranchAll":{"type":"object","description":"Parallel branching where all branches execute simultaneously. Unlike BranchOne, all branches run regardless of conditions. Useful for executing independent tasks concurrently","properties":{"branches":{"type":"array","description":"Array of branches that all execute (either in parallel or sequentially)","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch's purpose"},"skip_failure":{"type":"boolean","description":"If true, failure in this branch doesn't fail the entire flow"},"modules":{"type":"array","description":"Steps to execute in this branch","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules"]}},"type":{"type":"string","enum":["branchall"]},"parallel":{"type":"boolean","description":"If true, all branches execute concurrently. If false, they execute sequentially"}},"required":["branches","type"]},"AgentTool":{"type":"object","description":"A tool available to an AI agent. Can be a flow module or an external MCP (Model Context Protocol) tool","properties":{"id":{"type":"string","description":"Unique identifier for this tool. Cannot contain spaces - use underscores instead (e.g., 'get_user_data' not 'get user data')"},"summary":{"type":"string","description":"Short description of what this tool does (shown to the AI)"},"value":{"$ref":"#/components/schemas/ToolValue"}},"required":["id","value"]},"ToolValue":{"description":"The implementation of a tool. Can be a flow module (script/flow) or an MCP tool reference","oneOf":[{"$ref":"#/components/schemas/FlowModuleTool"},{"$ref":"#/components/schemas/McpToolValue"},{"$ref":"#/components/schemas/WebsearchToolValue"}],"discriminator":{"propertyName":"tool_type","mapping":{"flowmodule":"#/components/schemas/FlowModuleTool","mcp":"#/components/schemas/McpToolValue","websearch":"#/components/schemas/WebsearchToolValue"}}},"FlowModuleTool":{"description":"A tool implemented as a flow module (script, flow, etc.). The AI can call this like any other flow module","allOf":[{"type":"object","properties":{"tool_type":{"type":"string","enum":["flowmodule"]}},"required":["tool_type"]},{"$ref":"#/components/schemas/FlowModuleValue"}]},"WebsearchToolValue":{"type":"object","description":"A tool implemented as a websearch tool. The AI can call this like any other websearch tool","properties":{"tool_type":{"type":"string","enum":["websearch"]}},"required":["tool_type"]},"McpToolValue":{"type":"object","description":"Reference to an external MCP (Model Context Protocol) tool. The AI can call tools from MCP servers","properties":{"tool_type":{"type":"string","enum":["mcp"]},"resource_path":{"type":"string","description":"Path to the MCP resource/server configuration"},"include_tools":{"type":"array","description":"Whitelist of specific tools to include from this MCP server","items":{"type":"string"}},"exclude_tools":{"type":"array","description":"Blacklist of tools to exclude from this MCP server","items":{"type":"string"}}},"required":["tool_type","resource_path"]},"AiAgent":{"type":"object","description":"AI agent step that can use tools to accomplish tasks. The agent receives inputs and can call any of its configured tools to complete the task","properties":{"input_transforms":{"type":"object","description":"Input parameters for the AI agent mapped to their values","properties":{"provider":{"$ref":"#/components/schemas/ProviderTransform"},"output_type":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Output format type.\nValid values: 'text' (default) - plain text response, 'image' - image generation\n"},"user_message":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"The user's prompt/message to the AI agent. Supports variable interpolation with flow.input syntax."},"system_prompt":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"System instructions that guide the AI's behavior, persona, and response style. Optional."},"streaming":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Boolean. If true, stream the AI response incrementally.\nStreaming events include: token_delta, reasoning_token_delta, tool_call, tool_call_arguments, tool_execution, tool_result\n"},"memory":{"$ref":"#/components/schemas/MemoryTransform"},"output_schema":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"JSON Schema object defining structured output format. Used when you need the AI to return data in a specific shape.\nSupports standard JSON Schema properties: type, properties, required, items, enum, pattern, minLength, maxLength, minimum, maximum, etc.\nExample: { type: 'object', properties: { name: { type: 'string' }, age: { type: 'integer' } }, required: ['name'] }\n"},"user_attachments":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Array of file references (images or PDFs) for the AI agent.\nFormat: Array<{ bucket: string, key: string }> - S3 object references\nExample: [{ bucket: 'my-bucket', key: 'documents/report.pdf' }]\n"},"max_completion_tokens":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Integer. Maximum number of tokens the AI will generate in its response.\nRange: 1 to 4,294,967,295. Typical values: 256-4096 for most use cases.\n"},"temperature":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Float. Controls randomness/creativity of responses.\nRange: 0.0 to 2.0 (provider-dependent)\n- 0.0 = deterministic, focused responses\n- 0.7 = balanced (common default)\n- 1.0+ = more creative/random\n"},"max_iterations":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Number. Limits how many times the agent can loop through reasoning and tool use.\nRange: 1-1000.\n"}},"required":["provider","user_message","output_type"]},"tools":{"type":"array","description":"Array of tools the agent can use. The agent decides which tools to call based on the task","items":{"$ref":"#/components/schemas/AgentTool"}},"type":{"type":"string","enum":["aiagent"]},"tag":{"type":"string","description":"Worker group tag for execution routing. If not set, the AI agent step runs on the flow's tag (default `flow`)"},"omit_output_from_conversation":{"type":"boolean","default":false,"description":"If true, this AI agent step does not persist its assistant or tool messages to the flow conversation when chat mode is enabled."},"parallel":{"type":"boolean","description":"If true, the agent can execute multiple tool calls in parallel"}},"required":["tools","type","input_transforms"]},"Identity":{"type":"object","description":"Pass-through module that returns its input unchanged. Useful for flow structure or as a placeholder","properties":{"type":{"type":"string","enum":["identity"]},"flow":{"type":"boolean","description":"If true, marks this as a flow identity (special handling)"}},"required":["type"]},"FlowStatus":{"type":"object","properties":{"step":{"type":"integer"},"modules":{"type":"array","items":{"$ref":"#/components/schemas/FlowStatusModule"}},"user_states":{"additionalProperties":true},"preprocessor_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"}]},"failure_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"},{"type":"object","properties":{"parent_module":{"type":"string"}}}]},"retry":{"type":"object","properties":{"fail_count":{"type":"integer"},"failed_jobs":{"type":"array","items":{"type":"string","format":"uuid"}}}}},"required":["step","modules","failure_module"]},"FlowStatusModule":{"type":"object","properties":{"type":{"type":"string","enum":["WaitingForPriorSteps","WaitingForEvents","WaitingForExecutor","InProgress","Success","Failure"]},"id":{"type":"string"},"job":{"type":"string","format":"uuid"},"count":{"type":"integer"},"progress":{"type":"integer"},"iterator":{"type":"object","properties":{"index":{"type":"integer"},"itered":{"type":"array","items":{}},"itered_len":{"type":"integer"},"args":{}}},"flow_jobs":{"type":"array","items":{"type":"string"}},"flow_jobs_success":{"type":"array","items":{"type":"boolean"}},"flow_jobs_duration":{"type":"object","properties":{"started_at":{"type":"array","items":{"type":"string"}},"duration_ms":{"type":"array","items":{"type":"integer"}}}},"branch_chosen":{"type":"object","properties":{"type":{"type":"string","enum":["branch","default"]},"branch":{"type":"integer"}},"required":["type"]},"branchall":{"type":"object","properties":{"branch":{"type":"integer"},"len":{"type":"integer"}},"required":["branch","len"]},"approvers":{"type":"array","items":{"type":"object","properties":{"resume_id":{"type":"integer"},"approver":{"type":"string"}},"required":["resume_id","approver"]}},"failed_retries":{"type":"array","items":{"type":"string","format":"uuid"}},"skipped":{"type":"boolean"},"agent_actions":{"type":"array","items":{"type":"object","oneOf":[{"type":"object","properties":{"job_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"type":{"type":"string","enum":["tool_call"]},"module_id":{"type":"string"}},"required":["job_id","function_name","type","module_id"]},{"type":"object","properties":{"call_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"resource_path":{"type":"string"},"type":{"type":"string","enum":["mcp_tool_call"]},"arguments":{"type":"object"}},"required":["call_id","function_name","resource_path","type"]},{"type":"object","properties":{"type":{"type":"string","enum":["web_search"]}},"required":["type"]},{"type":"object","properties":{"type":{"type":"string","enum":["message"]}},"required":["content","type"]}]}},"agent_actions_success":{"type":"array","items":{"type":"boolean"}}},"required":["type"]}}
\ No newline at end of file
diff --git a/system_prompts/auto-generated/prompts.ts b/system_prompts/auto-generated/prompts.ts
index 5fe8e66f7b..b68c9ef55f 100644
--- a/system_prompts/auto-generated/prompts.ts
+++ b/system_prompts/auto-generated/prompts.ts
@@ -1447,13 +1447,6 @@ async requestInteractiveSlackApproval({ slackResourcePath, channelId, message, a
  */
 async requestInteractiveTeamsApproval({ teamName, channelName, message, approver, defaultArgsJson, dynamicEnumsJson, }: TeamsApprovalOptions): Promise<void>
 
-/**
- * Parse an S3 object from URI string or record format
- * @param s3Object - S3 object as URI string (s3://storage/key) or record
- * @returns S3 object record with storage and s3 key
- */
-parseS3Object(s3Object: S3Object): S3ObjectRecord
-
 setWorkflowCtx(ctx: WorkflowCtx | null): void
 
 async sleep(seconds: number): Promise<void>
@@ -1523,6 +1516,17 @@ async parallel<T, R>(items: T[], fn: (item: T) => PromiseLike<R> | R, options?:
  */
 async commitKafkaOffsets(triggerPath: string, topic: string, partition: number, offset: number,): Promise<void>
 
+/**
+ * Parse an S3 object from URI string or record format
+ * @param s3Object - S3 object as URI string (\`s3://storage/key\`, \`s3:///key\`
+ *   for the default storage) or record. Any other string throws rather than
+ *   falling back to an auto-generated key: an auto key is requested by
+ *   omitting the object, and a fallback would silently misplace the upload
+ *   on any typo.
+ * @returns S3 object record with storage and s3 key
+ */
+parseS3Object(s3Object: S3Object): S3ObjectRecord
+
 /**
  * Create a SQL template function for PostgreSQL/datatable queries
  * @param name - Database/datatable name (default: "main")
@@ -2108,7 +2112,11 @@ def get_state_path() -> str
 # Parse resource syntax from string.
 def parse_resource_syntax(s: str) -> Optional[str]
 
-# Parse S3 object from string or S3Object format.
+# Parse S3 object from a \`s3://<storage>/<key>\` URI string (\`s3:///<key>\`
+# for the default storage) or S3Object format. Any other string raises
+# rather than falling back to an auto-generated key: an auto key is
+# requested by omitting the object, and a fallback would silently misplace
+# the upload on any typo.
 def parse_s3_object(s3_object: S3Object | str) -> S3Object
 
 # Parse variable syntax from string.
@@ -2664,7 +2672,7 @@ class SqlQuery:
 
 export const OPENFLOW_SCHEMA = `## OpenFlow Schema
 
-{"OpenFlow":{"type":"object","description":"Top-level flow definition containing metadata, configuration, and the flow structure","properties":{"summary":{"type":"string","description":"Short description of what this flow does"},"description":{"type":"string","description":"Detailed documentation for this flow"},"value":{"$ref":"#/components/schemas/FlowValue"},"schema":{"type":"object","description":"JSON Schema for flow inputs. Use this to define input parameters, their types, defaults, and validation. For resource inputs, set type to 'object' and format to 'resource-<type>' (e.g., 'resource-stripe')"},"on_behalf_of_email":{"type":"string","description":"The flow will be run with the permissions of the user with this email."}},"required":["summary","value"]},"FlowValue":{"type":"object","description":"The flow structure containing modules and optional preprocessor/failure handlers","properties":{"modules":{"type":"array","description":"Array of steps that execute in sequence. Each step can be a script, subflow, loop, or branch","items":{"$ref":"#/components/schemas/FlowModule"}},"failure_module":{"description":"Special module that executes when the flow fails. Receives error object with message, name, stack, and step_id. Must have id 'failure'. Only supports script/rawscript types","$ref":"#/components/schemas/FlowModule"},"preprocessor_module":{"description":"Special module that runs before the first step on external triggers. Must have id 'preprocessor'. Only supports script/rawscript types. Cannot reference other step results","$ref":"#/components/schemas/FlowModule"},"same_worker":{"type":"boolean","description":"If true, all steps run on the same worker for better performance"},"preserve_step_tags":{"type":"boolean","description":"If true and the flow runs on a custom worker tag, steps that declare their own non-empty tag run on it instead of inheriting the flow tag. Steps without their own tag still inherit the flow tag."},"concurrent_limit":{"type":"number","description":"Maximum number of concurrent executions of this flow"},"concurrency_key":{"type":"string","description":"Expression to group concurrent executions (e.g., by user ID)"},"concurrency_time_window_s":{"type":"number","description":"Time window in seconds for concurrent_limit"},"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce flow executions"},"debounce_key":{"type":"string","description":"Expression to group debounced executions"},"debounce_args_to_accumulate":{"type":"array","description":"Arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds that a job can be debounced"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of times a job can be debounced"},"skip_expr":{"type":"string","description":"JavaScript expression to conditionally skip the entire flow"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for flow results"},"cache_ignore_s3_path":{"type":"boolean"},"delete_after_secs":{"type":"integer","description":"If set, delete the flow job's args, result and logs after this many seconds following job completion"},"flow_env":{"type":"object","description":"Environment variables available to all steps. Values can be strings, JSON values, or special references: '$var:path' (workspace variable) or '$res:path' (resource).","additionalProperties":{}},"priority":{"type":"number","description":"Execution priority (higher numbers run first)"},"early_return":{"type":"string","description":"JavaScript expression to return early from the flow"},"chat_input_enabled":{"type":"boolean","description":"Whether this flow accepts chat-style input"},"notes":{"type":"array","description":"Sticky notes attached to the flow","items":{"$ref":"#/components/schemas/FlowNote"}},"groups":{"type":"array","description":"Semantic groups of modules for organizational purposes","items":{"$ref":"#/components/schemas/FlowGroup"}}},"required":["modules"]},"Retry":{"type":"object","description":"Retry configuration for failed module executions","properties":{"constant":{"type":"object","description":"Retry with constant delay between attempts","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"seconds":{"type":"integer","description":"Seconds to wait between retries"}}},"exponential":{"type":"object","description":"Retry with exponential backoff (delay doubles each time)","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"multiplier":{"type":"integer","description":"Multiplier for exponential backoff"},"seconds":{"type":"integer","minimum":1,"description":"Initial delay in seconds"},"random_factor":{"type":"integer","minimum":0,"maximum":100,"description":"Random jitter percentage (0-100) to avoid thundering herd"}}},"retry_if":{"$ref":"#/components/schemas/RetryIf"}}},"FlowNote":{"type":"object","description":"A sticky note attached to a flow for documentation and annotation","properties":{"id":{"type":"string","description":"Unique identifier for the note"},"text":{"type":"string","description":"Content of the note"},"position":{"type":"object","description":"Position of the note in the flow editor","properties":{"x":{"type":"number","description":"X coordinate"},"y":{"type":"number","description":"Y coordinate"}},"required":["x","y"]},"size":{"type":"object","description":"Size of the note in the flow editor","properties":{"width":{"type":"number","description":"Width in pixels"},"height":{"type":"number","description":"Height in pixels"}},"required":["width","height"]},"color":{"type":"string","description":"Color of the note (e.g., \\"yellow\\", \\"#ffff00\\")"},"type":{"type":"string","enum":["free","group"],"description":"Type of note - 'free' for standalone notes, 'group' for notes that group other nodes"},"locked":{"type":"boolean","default":false,"description":"Whether the note is locked and cannot be edited or moved"},"contained_node_ids":{"type":"array","items":{"type":"string"},"description":"For group notes, the IDs of nodes contained within this group"}},"required":["id","text","color","type"]},"FlowGroup":{"type":"object","description":"A semantic group of flow modules for organizational purposes. Does not affect execution \\u2014 modules remain in their original position in the flow. Groups provide naming and collapsibility in the editor. Members are computed dynamically from all nodes on paths between start_id and end_id.","properties":{"summary":{"type":"string","description":"Display name for this group"},"note":{"type":"string","description":"Markdown note shown below the group header"},"autocollapse":{"type":"boolean","default":false,"description":"If true, this group is collapsed by default in the flow editor. UI hint only."},"start_id":{"type":"string","description":"ID of the first flow module in this group (topological entry point)"},"end_id":{"type":"string","description":"ID of the last flow module in this group (topological exit point)"},"color":{"type":"string","description":"Color for the group in the flow editor"}},"required":["start_id","end_id"]},"RetryIf":{"type":"object","description":"Conditional retry based on error or result","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to retry. Has access to 'result' and 'error' variables"}},"required":["expr"]},"StopAfterIf":{"type":"object","description":"Early termination condition for a module","properties":{"skip_if_stopped":{"type":"boolean","description":"If true, following steps are skipped when this condition triggers"},"expr":{"type":"string","description":"JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"},"error_message":{"type":"string","nullable":true,"description":"Custom error message when stopping with an error. Mutually exclusive with skip_if_stopped. If set to a non-empty string, the flow stops with this error. If empty string, a default error message is used. If null or omitted, no error is raised."},"error_include_result":{"type":"boolean","description":"When stopping with an error (error_message set), embed the stopping step's own result inside the raised error object (as error.result) instead of discarding it. The top-level result stays { error }. Defaults to false."}},"required":["expr"]},"FlowModule":{"type":"object","description":"A single step in a flow. Can be a script, subflow, loop, or branch","properties":{"id":{"type":"string","description":"Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)"},"value":{"$ref":"#/components/schemas/FlowModuleValue"},"stop_after_if":{"description":"Early termination condition evaluated after this step completes","$ref":"#/components/schemas/StopAfterIf"},"stop_after_all_iters_if":{"description":"For loops only - early termination condition evaluated after all iterations complete","$ref":"#/components/schemas/StopAfterIf"},"skip_if":{"type":"object","description":"Conditionally skip this step based on previous results or flow inputs","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to skip. Can use 'flow_input' or 'results.<step_id>'"}},"required":["expr"]},"sleep":{"description":"Delay before executing this step (in seconds or as expression)","$ref":"#/components/schemas/InputTransform"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for this step's results"},"cache_ignore_s3_path":{"type":"boolean"},"timeout":{"description":"Maximum execution time in seconds (static value or expression)","$ref":"#/components/schemas/InputTransform"},"delete_after_secs":{"type":"integer","description":"If set, delete the step's args, result and logs after this many seconds following job completion"},"summary":{"type":"string","description":"Short description of what this step does"},"mock":{"type":"object","description":"Mock configuration for testing without executing the actual step","properties":{"enabled":{"type":"boolean","description":"If true, return mock value instead of executing"},"return_value":{"description":"Value to return when mocked"}}},"suspend":{"type":"object","description":"Configuration for approval/resume steps that wait for user input","properties":{"required_events":{"type":"integer","description":"Number of approvals required before continuing"},"timeout":{"type":"integer","description":"Timeout in seconds before auto-continuing or canceling"},"resume_form":{"type":"object","description":"Form schema for collecting input when resuming","properties":{"schema":{"type":"object","description":"JSON Schema for the resume form"}}},"user_auth_required":{"type":"boolean","description":"If true, only authenticated users can approve"},"user_groups_required":{"description":"Expression or list of groups that can approve","$ref":"#/components/schemas/InputTransform"},"self_approval_disabled":{"type":"boolean","description":"If true, the user who started the flow cannot approve"},"hide_cancel":{"type":"boolean","description":"If true, hide the cancel button on the approval form"},"continue_on_disapprove_timeout":{"type":"boolean","description":"If true, continue flow on timeout instead of canceling"}}},"priority":{"type":"number","description":"Execution priority for this step (higher numbers run first)"},"continue_on_error":{"type":"boolean","description":"If true, flow continues even if this step fails"},"retry":{"description":"Retry configuration if this step fails","$ref":"#/components/schemas/Retry"},"debouncing":{"description":"Debounce configuration for this step (EE only)","type":"object","properties":{"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce this step's executions across flow runs"},"debounce_key":{"type":"string","description":"Expression to group debounced executions. Supports $workspace and $args[name]. Default: $workspace/flow/<flow_path>-<step_id>"},"debounce_args_to_accumulate":{"type":"array","description":"Array-type arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds before forced execution"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of debounces before forced execution"}}}},"required":["value","id"]},"InputTransform":{"description":"Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs","oneOf":[{"$ref":"#/components/schemas/StaticTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"StaticTransform":{"type":"object","description":"Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'","properties":{"value":{"description":"The static value. For resources, use format '$res:path/to/resource'"},"type":{"type":"string","enum":["static"]}},"required":["type"]},"JavascriptTransform":{"type":"object","description":"JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside loops, use 'flow_input.iter.value' for the current iteration value","properties":{"expr":{"type":"string","description":"JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"},"type":{"type":"string","enum":["javascript"]}},"required":["expr","type"]},"AiTransform":{"type":"object","description":"Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.","properties":{"type":{"type":"string","enum":["ai"]}},"required":["type"]},"AIProviderKind":{"type":"string","description":"Supported AI provider types","enum":["openai","azure_openai","azure_foundry","anthropic","mistral","deepseek","googleai","groq","openrouter","togetherai","customai","aws_bedrock"]},"ProviderConfig":{"type":"object","description":"Complete AI provider configuration with resource reference and model selection","properties":{"kind":{"$ref":"#/components/schemas/AIProviderKind"},"resource":{"type":"string","description":"Resource reference in format '$res:{resource_path}' pointing to provider credentials"},"model":{"type":"string","description":"Model identifier (e.g., 'gpt-4', 'claude-3-opus-20240229', 'gemini-pro')"}},"required":["kind","resource","model"]},"StaticProviderTransform":{"type":"object","description":"Static provider configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/ProviderConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"ProviderTransform":{"description":"Provider configuration - can be static (ProviderConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticProviderTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticProviderTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"MemoryOff":{"type":"object","description":"No conversation memory/context","properties":{"kind":{"type":"string","enum":["off"]}},"required":["kind"]},"MemoryAuto":{"type":"object","description":"Automatic context management","properties":{"kind":{"type":"string","enum":["auto"]},"context_length":{"type":"integer","description":"Maximum number of messages to retain in context"},"memory_id":{"type":"string","description":"Identifier for persistent memory across agent invocations"}},"required":["kind"]},"MemoryMessage":{"type":"object","description":"A single message in conversation history","properties":{"role":{"type":"string","enum":["user","assistant","system"]},"content":{"type":"string"}},"required":["role","content"]},"MemoryManual":{"type":"object","description":"Explicit message history","properties":{"kind":{"type":"string","enum":["manual"]},"messages":{"type":"array","items":{"$ref":"#/components/schemas/MemoryMessage"}}},"required":["kind","messages"]},"MemoryConfig":{"description":"Conversation memory configuration","oneOf":[{"$ref":"#/components/schemas/MemoryOff"},{"$ref":"#/components/schemas/MemoryAuto"},{"$ref":"#/components/schemas/MemoryManual"}],"discriminator":{"propertyName":"kind","mapping":{"off":"#/components/schemas/MemoryOff","auto":"#/components/schemas/MemoryAuto","manual":"#/components/schemas/MemoryManual"}}},"StaticMemoryTransform":{"type":"object","description":"Static memory configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/MemoryConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"MemoryTransform":{"description":"Memory configuration - can be static (MemoryConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticMemoryTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticMemoryTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"FlowModuleValue":{"description":"The actual implementation of a flow step. Can be a script (inline or referenced), subflow, loop, branch, or special module type","oneOf":[{"$ref":"#/components/schemas/RawScript"},{"$ref":"#/components/schemas/PathScript"},{"$ref":"#/components/schemas/PathFlow"},{"$ref":"#/components/schemas/ForloopFlow"},{"$ref":"#/components/schemas/WhileloopFlow"},{"$ref":"#/components/schemas/BranchOne"},{"$ref":"#/components/schemas/BranchAll"},{"$ref":"#/components/schemas/Identity"},{"$ref":"#/components/schemas/AiAgent"}],"discriminator":{"propertyName":"type","mapping":{"rawscript":"#/components/schemas/RawScript","script":"#/components/schemas/PathScript","flow":"#/components/schemas/PathFlow","forloopflow":"#/components/schemas/ForloopFlow","whileloopflow":"#/components/schemas/WhileloopFlow","branchone":"#/components/schemas/BranchOne","branchall":"#/components/schemas/BranchAll","identity":"#/components/schemas/Identity","aiagent":"#/components/schemas/AiAgent"}}},"RawScript":{"type":"object","description":"Inline script with code defined directly in the flow. Use 'bun' as default language if unspecified. The script receives arguments from input_transforms","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"content":{"type":"string","description":"The script source code. Should export a 'main' function"},"language":{"type":"string","description":"Programming language for this script","enum":["deno","bun","python3","go","bash","powershell","postgresql","mysql","bigquery","snowflake","mssql","oracledb","graphql","nativets","php","rust","ansible","csharp","nu","java","ruby","rlang","duckdb"]},"path":{"type":"string","description":"Optional path for saving this script"},"lock":{"type":"string","description":"Lock file content for dependencies"},"type":{"type":"string","enum":["rawscript"]},"tag":{"type":"string","description":"Worker group tag for execution routing"},"concurrent_limit":{"type":"number","description":"Maximum concurrent executions of this script"},"concurrency_time_window_s":{"type":"number","description":"Time window for concurrent_limit"},"custom_concurrency_key":{"type":"string","description":"Custom key for grouping concurrent executions"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"},"assets":{"type":"array","description":"External resources this script accesses (S3 objects, resources, etc.)","items":{"type":"object","required":["path","kind"],"properties":{"path":{"type":"string","description":"Path to the asset"},"kind":{"type":"string","description":"Type of asset","enum":["s3object","resource","ducklake","datatable","volume"]},"access_type":{"type":"string","nullable":true,"description":"Access level for this asset","enum":["r","w","rw"]},"alt_access_type":{"type":"string","nullable":true,"description":"Alternative access level","enum":["r","w","rw"]}}}}},"required":["type","content","language","input_transforms"]},"PathScript":{"type":"object","description":"Reference to an existing script by path. Use this when calling a previously saved script instead of writing inline code","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the script in the workspace (e.g., 'f/scripts/send_email')"},"hash":{"type":"string","description":"Optional specific version hash of the script to use"},"type":{"type":"string","enum":["script"]},"tag_override":{"type":"string","description":"Override the script's default worker group tag"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"}},"required":["type","path","input_transforms"]},"PathFlow":{"type":"object","description":"Reference to an existing flow by path. Use this to call another flow as a subflow","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the subflow's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the flow in the workspace (e.g., 'f/flows/process_user')"},"type":{"type":"string","enum":["flow"]}},"required":["type","path","input_transforms"]},"ForloopFlow":{"type":"object","description":"Executes nested modules in a loop over an iterator. Inside the loop, use 'flow_input.iter.value' to access the current iteration value, and 'flow_input.iter.index' for the index. Supports parallel execution for better performance on I/O-bound operations","properties":{"modules":{"type":"array","description":"Steps to execute for each iteration. These can reference the iteration value via 'flow_input.iter.value'","items":{"$ref":"#/components/schemas/FlowModule"}},"iterator":{"description":"JavaScript expression that returns an array to iterate over. Can reference 'results.step_id' or 'flow_input'","$ref":"#/components/schemas/InputTransform"},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["forloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (faster for I/O-bound operations). Use with parallelism to control concurrency"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true. Limits resource usage. Can be static number or expression","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","iterator","skip_failures","type"]},"WhileloopFlow":{"type":"object","description":"Executes nested modules repeatedly while a condition is true. The loop checks the condition after each iteration. Use stop_after_if on modules to control loop termination","properties":{"modules":{"type":"array","description":"Steps to execute in each iteration. Use stop_after_if to control when the loop ends","items":{"$ref":"#/components/schemas/FlowModule"}},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["whileloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (use with caution in while loops)"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","skip_failures","type"]},"BranchOne":{"type":"object","description":"Conditional branching where only the first matching branch executes. Branches are evaluated in order, and the first one with a true expression runs. If no branches match, the default branch executes","properties":{"branches":{"type":"array","description":"Array of branches to evaluate in order. The first branch with expr evaluating to true executes","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch condition"},"expr":{"type":"string","description":"JavaScript expression that returns boolean. Can use 'results.step_id' or 'flow_input'. First true expr wins"},"modules":{"type":"array","description":"Steps to execute if this branch's expr is true","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules","expr"]}},"default":{"type":"array","description":"Steps to execute if no branch expressions match","items":{"$ref":"#/components/schemas/FlowModule"}},"type":{"type":"string","enum":["branchone"]}},"required":["branches","default","type"]},"BranchAll":{"type":"object","description":"Parallel branching where all branches execute simultaneously. Unlike BranchOne, all branches run regardless of conditions. Useful for executing independent tasks concurrently","properties":{"branches":{"type":"array","description":"Array of branches that all execute (either in parallel or sequentially)","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch's purpose"},"skip_failure":{"type":"boolean","description":"If true, failure in this branch doesn't fail the entire flow"},"modules":{"type":"array","description":"Steps to execute in this branch","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules"]}},"type":{"type":"string","enum":["branchall"]},"parallel":{"type":"boolean","description":"If true, all branches execute concurrently. If false, they execute sequentially"}},"required":["branches","type"]},"AgentTool":{"type":"object","description":"A tool available to an AI agent. Can be a flow module or an external MCP (Model Context Protocol) tool","properties":{"id":{"type":"string","description":"Unique identifier for this tool. Cannot contain spaces - use underscores instead (e.g., 'get_user_data' not 'get user data')"},"summary":{"type":"string","description":"Short description of what this tool does (shown to the AI)"},"value":{"$ref":"#/components/schemas/ToolValue"}},"required":["id","value"]},"ToolValue":{"description":"The implementation of a tool. Can be a flow module (script/flow) or an MCP tool reference","oneOf":[{"$ref":"#/components/schemas/FlowModuleTool"},{"$ref":"#/components/schemas/McpToolValue"},{"$ref":"#/components/schemas/WebsearchToolValue"}],"discriminator":{"propertyName":"tool_type","mapping":{"flowmodule":"#/components/schemas/FlowModuleTool","mcp":"#/components/schemas/McpToolValue","websearch":"#/components/schemas/WebsearchToolValue"}}},"FlowModuleTool":{"description":"A tool implemented as a flow module (script, flow, etc.). The AI can call this like any other flow module","allOf":[{"type":"object","properties":{"tool_type":{"type":"string","enum":["flowmodule"]}},"required":["tool_type"]},{"$ref":"#/components/schemas/FlowModuleValue"}]},"WebsearchToolValue":{"type":"object","description":"A tool implemented as a websearch tool. The AI can call this like any other websearch tool","properties":{"tool_type":{"type":"string","enum":["websearch"]}},"required":["tool_type"]},"McpToolValue":{"type":"object","description":"Reference to an external MCP (Model Context Protocol) tool. The AI can call tools from MCP servers","properties":{"tool_type":{"type":"string","enum":["mcp"]},"resource_path":{"type":"string","description":"Path to the MCP resource/server configuration"},"include_tools":{"type":"array","description":"Whitelist of specific tools to include from this MCP server","items":{"type":"string"}},"exclude_tools":{"type":"array","description":"Blacklist of tools to exclude from this MCP server","items":{"type":"string"}}},"required":["tool_type","resource_path"]},"AiAgent":{"type":"object","description":"AI agent step that can use tools to accomplish tasks. The agent receives inputs and can call any of its configured tools to complete the task","properties":{"input_transforms":{"type":"object","description":"Input parameters for the AI agent mapped to their values","properties":{"provider":{"$ref":"#/components/schemas/ProviderTransform"},"output_type":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Output format type.\\nValid values: 'text' (default) - plain text response, 'image' - image generation\\n"},"user_message":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"The user's prompt/message to the AI agent. Supports variable interpolation with flow.input syntax."},"system_prompt":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"System instructions that guide the AI's behavior, persona, and response style. Optional."},"streaming":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Boolean. If true, stream the AI response incrementally.\\nStreaming events include: token_delta, tool_call, tool_call_arguments, tool_execution, tool_result\\n"},"memory":{"$ref":"#/components/schemas/MemoryTransform"},"output_schema":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"JSON Schema object defining structured output format. Used when you need the AI to return data in a specific shape.\\nSupports standard JSON Schema properties: type, properties, required, items, enum, pattern, minLength, maxLength, minimum, maximum, etc.\\nExample: { type: 'object', properties: { name: { type: 'string' }, age: { type: 'integer' } }, required: ['name'] }\\n"},"user_attachments":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Array of file references (images or PDFs) for the AI agent.\\nFormat: Array<{ bucket: string, key: string }> - S3 object references\\nExample: [{ bucket: 'my-bucket', key: 'documents/report.pdf' }]\\n"},"max_completion_tokens":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Integer. Maximum number of tokens the AI will generate in its response.\\nRange: 1 to 4,294,967,295. Typical values: 256-4096 for most use cases.\\n"},"temperature":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Float. Controls randomness/creativity of responses.\\nRange: 0.0 to 2.0 (provider-dependent)\\n- 0.0 = deterministic, focused responses\\n- 0.7 = balanced (common default)\\n- 1.0+ = more creative/random\\n"},"max_iterations":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Number. Limits how many times the agent can loop through reasoning and tool use.\\nRange: 1-1000.\\n"}},"required":["provider","user_message","output_type"]},"tools":{"type":"array","description":"Array of tools the agent can use. The agent decides which tools to call based on the task","items":{"$ref":"#/components/schemas/AgentTool"}},"type":{"type":"string","enum":["aiagent"]},"tag":{"type":"string","description":"Worker group tag for execution routing. If not set, the AI agent step runs on the flow's tag (default \`flow\`)"},"omit_output_from_conversation":{"type":"boolean","default":false,"description":"If true, this AI agent step does not persist its assistant or tool messages to the flow conversation when chat mode is enabled."},"parallel":{"type":"boolean","description":"If true, the agent can execute multiple tool calls in parallel"}},"required":["tools","type","input_transforms"]},"Identity":{"type":"object","description":"Pass-through module that returns its input unchanged. Useful for flow structure or as a placeholder","properties":{"type":{"type":"string","enum":["identity"]},"flow":{"type":"boolean","description":"If true, marks this as a flow identity (special handling)"}},"required":["type"]},"FlowStatus":{"type":"object","properties":{"step":{"type":"integer"},"modules":{"type":"array","items":{"$ref":"#/components/schemas/FlowStatusModule"}},"user_states":{"additionalProperties":true},"preprocessor_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"}]},"failure_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"},{"type":"object","properties":{"parent_module":{"type":"string"}}}]},"retry":{"type":"object","properties":{"fail_count":{"type":"integer"},"failed_jobs":{"type":"array","items":{"type":"string","format":"uuid"}}}}},"required":["step","modules","failure_module"]},"FlowStatusModule":{"type":"object","properties":{"type":{"type":"string","enum":["WaitingForPriorSteps","WaitingForEvents","WaitingForExecutor","InProgress","Success","Failure"]},"id":{"type":"string"},"job":{"type":"string","format":"uuid"},"count":{"type":"integer"},"progress":{"type":"integer"},"iterator":{"type":"object","properties":{"index":{"type":"integer"},"itered":{"type":"array","items":{}},"itered_len":{"type":"integer"},"args":{}}},"flow_jobs":{"type":"array","items":{"type":"string"}},"flow_jobs_success":{"type":"array","items":{"type":"boolean"}},"flow_jobs_duration":{"type":"object","properties":{"started_at":{"type":"array","items":{"type":"string"}},"duration_ms":{"type":"array","items":{"type":"integer"}}}},"branch_chosen":{"type":"object","properties":{"type":{"type":"string","enum":["branch","default"]},"branch":{"type":"integer"}},"required":["type"]},"branchall":{"type":"object","properties":{"branch":{"type":"integer"},"len":{"type":"integer"}},"required":["branch","len"]},"approvers":{"type":"array","items":{"type":"object","properties":{"resume_id":{"type":"integer"},"approver":{"type":"string"}},"required":["resume_id","approver"]}},"failed_retries":{"type":"array","items":{"type":"string","format":"uuid"}},"skipped":{"type":"boolean"},"agent_actions":{"type":"array","items":{"type":"object","oneOf":[{"type":"object","properties":{"job_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"type":{"type":"string","enum":["tool_call"]},"module_id":{"type":"string"}},"required":["job_id","function_name","type","module_id"]},{"type":"object","properties":{"call_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"resource_path":{"type":"string"},"type":{"type":"string","enum":["mcp_tool_call"]},"arguments":{"type":"object"}},"required":["call_id","function_name","resource_path","type"]},{"type":"object","properties":{"type":{"type":"string","enum":["web_search"]}},"required":["type"]},{"type":"object","properties":{"type":{"type":"string","enum":["message"]}},"required":["content","type"]}]}},"agent_actions_success":{"type":"array","items":{"type":"boolean"}}},"required":["type"]}}`;
+{"OpenFlow":{"type":"object","description":"Top-level flow definition containing metadata, configuration, and the flow structure","properties":{"summary":{"type":"string","description":"Short description of what this flow does"},"description":{"type":"string","description":"Detailed documentation for this flow"},"value":{"$ref":"#/components/schemas/FlowValue"},"schema":{"type":"object","description":"JSON Schema for flow inputs. Use this to define input parameters, their types, defaults, and validation. For resource inputs, set type to 'object' and format to 'resource-<type>' (e.g., 'resource-stripe')"},"on_behalf_of_email":{"type":"string","description":"The flow will be run with the permissions of the user with this email."}},"required":["summary","value"]},"FlowValue":{"type":"object","description":"The flow structure containing modules and optional preprocessor/failure handlers","properties":{"modules":{"type":"array","description":"Array of steps that execute in sequence. Each step can be a script, subflow, loop, or branch","items":{"$ref":"#/components/schemas/FlowModule"}},"failure_module":{"description":"Special module that executes when the flow fails. Receives error object with message, name, stack, and step_id. Must have id 'failure'. Only supports script/rawscript types","$ref":"#/components/schemas/FlowModule"},"preprocessor_module":{"description":"Special module that runs before the first step on external triggers. Must have id 'preprocessor'. Only supports script/rawscript types. Cannot reference other step results","$ref":"#/components/schemas/FlowModule"},"same_worker":{"type":"boolean","description":"If true, all steps run on the same worker for better performance"},"preserve_step_tags":{"type":"boolean","description":"If true and the flow runs on a custom worker tag, steps that declare their own non-empty tag run on it instead of inheriting the flow tag. Steps without their own tag still inherit the flow tag."},"concurrent_limit":{"type":"number","description":"Maximum number of concurrent executions of this flow"},"concurrency_key":{"type":"string","description":"Expression to group concurrent executions (e.g., by user ID)"},"concurrency_time_window_s":{"type":"number","description":"Time window in seconds for concurrent_limit"},"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce flow executions"},"debounce_key":{"type":"string","description":"Expression to group debounced executions"},"debounce_args_to_accumulate":{"type":"array","description":"Arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds that a job can be debounced"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of times a job can be debounced"},"skip_expr":{"type":"string","description":"JavaScript expression to conditionally skip the entire flow"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for flow results"},"cache_ignore_s3_path":{"type":"boolean"},"delete_after_secs":{"type":"integer","description":"If set, delete the flow job's args, result and logs after this many seconds following job completion"},"flow_env":{"type":"object","description":"Environment variables available to all steps. Values can be strings, JSON values, or special references: '$var:path' (workspace variable) or '$res:path' (resource).","additionalProperties":{}},"priority":{"type":"number","description":"Execution priority (higher numbers run first)"},"early_return":{"type":"string","description":"JavaScript expression to return early from the flow"},"chat_input_enabled":{"type":"boolean","description":"Whether this flow accepts chat-style input"},"notes":{"type":"array","description":"Sticky notes attached to the flow","items":{"$ref":"#/components/schemas/FlowNote"}},"groups":{"type":"array","description":"Semantic groups of modules for organizational purposes","items":{"$ref":"#/components/schemas/FlowGroup"}}},"required":["modules"]},"Retry":{"type":"object","description":"Retry configuration for failed module executions","properties":{"constant":{"type":"object","description":"Retry with constant delay between attempts","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"seconds":{"type":"integer","description":"Seconds to wait between retries"}}},"exponential":{"type":"object","description":"Retry with exponential backoff (delay doubles each time)","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"multiplier":{"type":"integer","description":"Multiplier for exponential backoff"},"seconds":{"type":"integer","minimum":1,"description":"Initial delay in seconds"},"random_factor":{"type":"integer","minimum":0,"maximum":100,"description":"Random jitter percentage (0-100) to avoid thundering herd"}}},"retry_if":{"$ref":"#/components/schemas/RetryIf"}}},"FlowNote":{"type":"object","description":"A sticky note attached to a flow for documentation and annotation","properties":{"id":{"type":"string","description":"Unique identifier for the note"},"text":{"type":"string","description":"Content of the note"},"position":{"type":"object","description":"Position of the note in the flow editor","properties":{"x":{"type":"number","description":"X coordinate"},"y":{"type":"number","description":"Y coordinate"}},"required":["x","y"]},"size":{"type":"object","description":"Size of the note in the flow editor","properties":{"width":{"type":"number","description":"Width in pixels"},"height":{"type":"number","description":"Height in pixels"}},"required":["width","height"]},"color":{"type":"string","description":"Color of the note (e.g., \\"yellow\\", \\"#ffff00\\")"},"type":{"type":"string","enum":["free","group"],"description":"Type of note - 'free' for standalone notes, 'group' for notes that group other nodes"},"locked":{"type":"boolean","default":false,"description":"Whether the note is locked and cannot be edited or moved"},"contained_node_ids":{"type":"array","items":{"type":"string"},"description":"For group notes, the IDs of nodes contained within this group"}},"required":["id","text","color","type"]},"FlowGroup":{"type":"object","description":"A semantic group of flow modules for organizational purposes. Does not affect execution \\u2014 modules remain in their original position in the flow. Groups provide naming and collapsibility in the editor. Members are computed dynamically from all nodes on paths between start_id and end_id.","properties":{"summary":{"type":"string","description":"Display name for this group"},"note":{"type":"string","description":"Markdown note shown below the group header"},"autocollapse":{"type":"boolean","default":false,"description":"If true, this group is collapsed by default in the flow editor. UI hint only."},"start_id":{"type":"string","description":"ID of the first flow module in this group (topological entry point)"},"end_id":{"type":"string","description":"ID of the last flow module in this group (topological exit point)"},"color":{"type":"string","description":"Color for the group in the flow editor"}},"required":["start_id","end_id"]},"RetryIf":{"type":"object","description":"Conditional retry based on error or result","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to retry. Has access to 'result' and 'error' variables"}},"required":["expr"]},"StopAfterIf":{"type":"object","description":"Early termination condition for a module","properties":{"skip_if_stopped":{"type":"boolean","description":"If true, following steps are skipped when this condition triggers"},"expr":{"type":"string","description":"JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"},"error_message":{"type":"string","nullable":true,"description":"Custom error message when stopping with an error. Mutually exclusive with skip_if_stopped. If set to a non-empty string, the flow stops with this error. If empty string, a default error message is used. If null or omitted, no error is raised."},"error_include_result":{"type":"boolean","description":"When stopping with an error (error_message set), embed the stopping step's own result inside the raised error object (as error.result) instead of discarding it. The top-level result stays { error }. Defaults to false."}},"required":["expr"]},"FlowModule":{"type":"object","description":"A single step in a flow. Can be a script, subflow, loop, or branch","properties":{"id":{"type":"string","description":"Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)"},"value":{"$ref":"#/components/schemas/FlowModuleValue"},"stop_after_if":{"description":"Early termination condition evaluated after this step completes","$ref":"#/components/schemas/StopAfterIf"},"stop_after_all_iters_if":{"description":"For loops only - early termination condition evaluated after all iterations complete","$ref":"#/components/schemas/StopAfterIf"},"skip_if":{"type":"object","description":"Conditionally skip this step based on previous results or flow inputs","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to skip. Can use 'flow_input' or 'results.<step_id>'"}},"required":["expr"]},"sleep":{"description":"Delay before executing this step (in seconds or as expression)","$ref":"#/components/schemas/InputTransform"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for this step's results"},"cache_ignore_s3_path":{"type":"boolean"},"timeout":{"description":"Maximum execution time in seconds (static value or expression)","$ref":"#/components/schemas/InputTransform"},"delete_after_secs":{"type":"integer","description":"If set, delete the step's args, result and logs after this many seconds following job completion"},"summary":{"type":"string","description":"Short description of what this step does"},"mock":{"type":"object","description":"Mock configuration for testing without executing the actual step","properties":{"enabled":{"type":"boolean","description":"If true, return mock value instead of executing"},"return_value":{"description":"Value to return when mocked"}}},"suspend":{"type":"object","description":"Configuration for approval/resume steps that wait for user input","properties":{"required_events":{"type":"integer","description":"Number of approvals required before continuing"},"timeout":{"type":"integer","description":"Timeout in seconds before auto-continuing or canceling"},"resume_form":{"type":"object","description":"Form schema for collecting input when resuming","properties":{"schema":{"type":"object","description":"JSON Schema for the resume form"}}},"user_auth_required":{"type":"boolean","description":"If true, only authenticated users can approve"},"user_groups_required":{"description":"Expression or list of groups that can approve","$ref":"#/components/schemas/InputTransform"},"self_approval_disabled":{"type":"boolean","description":"If true, the user who started the flow cannot approve"},"hide_cancel":{"type":"boolean","description":"If true, hide the cancel button on the approval form"},"continue_on_disapprove_timeout":{"type":"boolean","description":"If true, continue flow on timeout instead of canceling"}}},"priority":{"type":"number","description":"Execution priority for this step (higher numbers run first)"},"continue_on_error":{"type":"boolean","description":"If true, flow continues even if this step fails"},"retry":{"description":"Retry configuration if this step fails","$ref":"#/components/schemas/Retry"},"debouncing":{"description":"Debounce configuration for this step (EE only)","type":"object","properties":{"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce this step's executions across flow runs"},"debounce_key":{"type":"string","description":"Expression to group debounced executions. Supports $workspace and $args[name]. Default: $workspace/flow/<flow_path>-<step_id>"},"debounce_args_to_accumulate":{"type":"array","description":"Array-type arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds before forced execution"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of debounces before forced execution"}}}},"required":["value","id"]},"InputTransform":{"description":"Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs","oneOf":[{"$ref":"#/components/schemas/StaticTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"StaticTransform":{"type":"object","description":"Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'","properties":{"value":{"description":"The static value. For resources, use format '$res:path/to/resource'"},"type":{"type":"string","enum":["static"]}},"required":["type"]},"JavascriptTransform":{"type":"object","description":"JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside loops, use 'flow_input.iter.value' for the current iteration value","properties":{"expr":{"type":"string","description":"JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"},"type":{"type":"string","enum":["javascript"]}},"required":["expr","type"]},"AiTransform":{"type":"object","description":"Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.","properties":{"type":{"type":"string","enum":["ai"]}},"required":["type"]},"AIProviderKind":{"type":"string","description":"Supported AI provider types","enum":["openai","azure_openai","azure_foundry","anthropic","mistral","deepseek","googleai","groq","openrouter","togetherai","customai","aws_bedrock"]},"ProviderConfig":{"type":"object","description":"Complete AI provider configuration with resource reference and model selection","properties":{"kind":{"$ref":"#/components/schemas/AIProviderKind"},"resource":{"type":"string","description":"Resource reference in format '$res:{resource_path}' pointing to provider credentials"},"model":{"type":"string","description":"Model identifier (e.g., 'gpt-4', 'claude-3-opus-20240229', 'gemini-pro')"},"reasoning_effort":{"type":"string","description":"Provider-native reasoning effort token (e.g. 'low', 'high', 'none') for models that support extended thinking. Optional; unset leaves the provider default."}},"required":["kind","resource","model"]},"StaticProviderTransform":{"type":"object","description":"Static provider configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/ProviderConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"ProviderTransform":{"description":"Provider configuration - can be static (ProviderConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticProviderTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticProviderTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"MemoryOff":{"type":"object","description":"No conversation memory/context","properties":{"kind":{"type":"string","enum":["off"]}},"required":["kind"]},"MemoryAuto":{"type":"object","description":"Automatic context management","properties":{"kind":{"type":"string","enum":["auto"]},"context_length":{"type":"integer","description":"Maximum number of messages to retain in context"},"memory_id":{"type":"string","description":"Identifier for persistent memory across agent invocations"}},"required":["kind"]},"MemoryMessage":{"type":"object","description":"A single message in conversation history","properties":{"role":{"type":"string","enum":["user","assistant","system"]},"content":{"type":"string"}},"required":["role","content"]},"MemoryManual":{"type":"object","description":"Explicit message history","properties":{"kind":{"type":"string","enum":["manual"]},"messages":{"type":"array","items":{"$ref":"#/components/schemas/MemoryMessage"}}},"required":["kind","messages"]},"MemoryConfig":{"description":"Conversation memory configuration","oneOf":[{"$ref":"#/components/schemas/MemoryOff"},{"$ref":"#/components/schemas/MemoryAuto"},{"$ref":"#/components/schemas/MemoryManual"}],"discriminator":{"propertyName":"kind","mapping":{"off":"#/components/schemas/MemoryOff","auto":"#/components/schemas/MemoryAuto","manual":"#/components/schemas/MemoryManual"}}},"StaticMemoryTransform":{"type":"object","description":"Static memory configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/MemoryConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"MemoryTransform":{"description":"Memory configuration - can be static (MemoryConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticMemoryTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticMemoryTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"FlowModuleValue":{"description":"The actual implementation of a flow step. Can be a script (inline or referenced), subflow, loop, branch, or special module type","oneOf":[{"$ref":"#/components/schemas/RawScript"},{"$ref":"#/components/schemas/PathScript"},{"$ref":"#/components/schemas/PathFlow"},{"$ref":"#/components/schemas/ForloopFlow"},{"$ref":"#/components/schemas/WhileloopFlow"},{"$ref":"#/components/schemas/BranchOne"},{"$ref":"#/components/schemas/BranchAll"},{"$ref":"#/components/schemas/Identity"},{"$ref":"#/components/schemas/AiAgent"}],"discriminator":{"propertyName":"type","mapping":{"rawscript":"#/components/schemas/RawScript","script":"#/components/schemas/PathScript","flow":"#/components/schemas/PathFlow","forloopflow":"#/components/schemas/ForloopFlow","whileloopflow":"#/components/schemas/WhileloopFlow","branchone":"#/components/schemas/BranchOne","branchall":"#/components/schemas/BranchAll","identity":"#/components/schemas/Identity","aiagent":"#/components/schemas/AiAgent"}}},"RawScript":{"type":"object","description":"Inline script with code defined directly in the flow. Use 'bun' as default language if unspecified. The script receives arguments from input_transforms","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"content":{"type":"string","description":"The script source code. Should export a 'main' function"},"language":{"type":"string","description":"Programming language for this script","enum":["deno","bun","python3","go","bash","powershell","postgresql","mysql","bigquery","snowflake","mssql","oracledb","graphql","nativets","php","rust","ansible","csharp","nu","java","ruby","rlang","duckdb"]},"path":{"type":"string","description":"Optional path for saving this script"},"lock":{"type":"string","description":"Lock file content for dependencies"},"type":{"type":"string","enum":["rawscript"]},"tag":{"type":"string","description":"Worker group tag for execution routing"},"concurrent_limit":{"type":"number","description":"Maximum concurrent executions of this script"},"concurrency_time_window_s":{"type":"number","description":"Time window for concurrent_limit"},"custom_concurrency_key":{"type":"string","description":"Custom key for grouping concurrent executions"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"},"assets":{"type":"array","description":"External resources this script accesses (S3 objects, resources, etc.)","items":{"type":"object","required":["path","kind"],"properties":{"path":{"type":"string","description":"Path to the asset"},"kind":{"type":"string","description":"Type of asset","enum":["s3object","resource","ducklake","datatable","volume"]},"access_type":{"type":"string","nullable":true,"description":"Access level for this asset","enum":["r","w","rw"]},"alt_access_type":{"type":"string","nullable":true,"description":"Alternative access level","enum":["r","w","rw"]}}}}},"required":["type","content","language","input_transforms"]},"PathScript":{"type":"object","description":"Reference to an existing script by path. Use this when calling a previously saved script instead of writing inline code","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the script in the workspace (e.g., 'f/scripts/send_email')"},"hash":{"type":"string","description":"Optional specific version hash of the script to use"},"type":{"type":"string","enum":["script"]},"tag_override":{"type":"string","description":"Override the script's default worker group tag"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"}},"required":["type","path","input_transforms"]},"PathFlow":{"type":"object","description":"Reference to an existing flow by path. Use this to call another flow as a subflow","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the subflow's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the flow in the workspace (e.g., 'f/flows/process_user')"},"type":{"type":"string","enum":["flow"]}},"required":["type","path","input_transforms"]},"ForloopFlow":{"type":"object","description":"Executes nested modules in a loop over an iterator. Inside the loop, use 'flow_input.iter.value' to access the current iteration value, and 'flow_input.iter.index' for the index. Supports parallel execution for better performance on I/O-bound operations","properties":{"modules":{"type":"array","description":"Steps to execute for each iteration. These can reference the iteration value via 'flow_input.iter.value'","items":{"$ref":"#/components/schemas/FlowModule"}},"iterator":{"description":"JavaScript expression that returns an array to iterate over. Can reference 'results.step_id' or 'flow_input'","$ref":"#/components/schemas/InputTransform"},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["forloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (faster for I/O-bound operations). Use with parallelism to control concurrency"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true. Limits resource usage. Can be static number or expression","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","iterator","skip_failures","type"]},"WhileloopFlow":{"type":"object","description":"Executes nested modules repeatedly while a condition is true. The loop checks the condition after each iteration. Use stop_after_if on modules to control loop termination","properties":{"modules":{"type":"array","description":"Steps to execute in each iteration. Use stop_after_if to control when the loop ends","items":{"$ref":"#/components/schemas/FlowModule"}},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["whileloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (use with caution in while loops)"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","skip_failures","type"]},"BranchOne":{"type":"object","description":"Conditional branching where only the first matching branch executes. Branches are evaluated in order, and the first one with a true expression runs. If no branches match, the default branch executes","properties":{"branches":{"type":"array","description":"Array of branches to evaluate in order. The first branch with expr evaluating to true executes","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch condition"},"expr":{"type":"string","description":"JavaScript expression that returns boolean. Can use 'results.step_id' or 'flow_input'. First true expr wins"},"modules":{"type":"array","description":"Steps to execute if this branch's expr is true","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules","expr"]}},"default":{"type":"array","description":"Steps to execute if no branch expressions match","items":{"$ref":"#/components/schemas/FlowModule"}},"type":{"type":"string","enum":["branchone"]}},"required":["branches","default","type"]},"BranchAll":{"type":"object","description":"Parallel branching where all branches execute simultaneously. Unlike BranchOne, all branches run regardless of conditions. Useful for executing independent tasks concurrently","properties":{"branches":{"type":"array","description":"Array of branches that all execute (either in parallel or sequentially)","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch's purpose"},"skip_failure":{"type":"boolean","description":"If true, failure in this branch doesn't fail the entire flow"},"modules":{"type":"array","description":"Steps to execute in this branch","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules"]}},"type":{"type":"string","enum":["branchall"]},"parallel":{"type":"boolean","description":"If true, all branches execute concurrently. If false, they execute sequentially"}},"required":["branches","type"]},"AgentTool":{"type":"object","description":"A tool available to an AI agent. Can be a flow module or an external MCP (Model Context Protocol) tool","properties":{"id":{"type":"string","description":"Unique identifier for this tool. Cannot contain spaces - use underscores instead (e.g., 'get_user_data' not 'get user data')"},"summary":{"type":"string","description":"Short description of what this tool does (shown to the AI)"},"value":{"$ref":"#/components/schemas/ToolValue"}},"required":["id","value"]},"ToolValue":{"description":"The implementation of a tool. Can be a flow module (script/flow) or an MCP tool reference","oneOf":[{"$ref":"#/components/schemas/FlowModuleTool"},{"$ref":"#/components/schemas/McpToolValue"},{"$ref":"#/components/schemas/WebsearchToolValue"}],"discriminator":{"propertyName":"tool_type","mapping":{"flowmodule":"#/components/schemas/FlowModuleTool","mcp":"#/components/schemas/McpToolValue","websearch":"#/components/schemas/WebsearchToolValue"}}},"FlowModuleTool":{"description":"A tool implemented as a flow module (script, flow, etc.). The AI can call this like any other flow module","allOf":[{"type":"object","properties":{"tool_type":{"type":"string","enum":["flowmodule"]}},"required":["tool_type"]},{"$ref":"#/components/schemas/FlowModuleValue"}]},"WebsearchToolValue":{"type":"object","description":"A tool implemented as a websearch tool. The AI can call this like any other websearch tool","properties":{"tool_type":{"type":"string","enum":["websearch"]}},"required":["tool_type"]},"McpToolValue":{"type":"object","description":"Reference to an external MCP (Model Context Protocol) tool. The AI can call tools from MCP servers","properties":{"tool_type":{"type":"string","enum":["mcp"]},"resource_path":{"type":"string","description":"Path to the MCP resource/server configuration"},"include_tools":{"type":"array","description":"Whitelist of specific tools to include from this MCP server","items":{"type":"string"}},"exclude_tools":{"type":"array","description":"Blacklist of tools to exclude from this MCP server","items":{"type":"string"}}},"required":["tool_type","resource_path"]},"AiAgent":{"type":"object","description":"AI agent step that can use tools to accomplish tasks. The agent receives inputs and can call any of its configured tools to complete the task","properties":{"input_transforms":{"type":"object","description":"Input parameters for the AI agent mapped to their values","properties":{"provider":{"$ref":"#/components/schemas/ProviderTransform"},"output_type":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Output format type.\\nValid values: 'text' (default) - plain text response, 'image' - image generation\\n"},"user_message":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"The user's prompt/message to the AI agent. Supports variable interpolation with flow.input syntax."},"system_prompt":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"System instructions that guide the AI's behavior, persona, and response style. Optional."},"streaming":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Boolean. If true, stream the AI response incrementally.\\nStreaming events include: token_delta, reasoning_token_delta, tool_call, tool_call_arguments, tool_execution, tool_result\\n"},"memory":{"$ref":"#/components/schemas/MemoryTransform"},"output_schema":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"JSON Schema object defining structured output format. Used when you need the AI to return data in a specific shape.\\nSupports standard JSON Schema properties: type, properties, required, items, enum, pattern, minLength, maxLength, minimum, maximum, etc.\\nExample: { type: 'object', properties: { name: { type: 'string' }, age: { type: 'integer' } }, required: ['name'] }\\n"},"user_attachments":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Array of file references (images or PDFs) for the AI agent.\\nFormat: Array<{ bucket: string, key: string }> - S3 object references\\nExample: [{ bucket: 'my-bucket', key: 'documents/report.pdf' }]\\n"},"max_completion_tokens":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Integer. Maximum number of tokens the AI will generate in its response.\\nRange: 1 to 4,294,967,295. Typical values: 256-4096 for most use cases.\\n"},"temperature":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Float. Controls randomness/creativity of responses.\\nRange: 0.0 to 2.0 (provider-dependent)\\n- 0.0 = deterministic, focused responses\\n- 0.7 = balanced (common default)\\n- 1.0+ = more creative/random\\n"},"max_iterations":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Number. Limits how many times the agent can loop through reasoning and tool use.\\nRange: 1-1000.\\n"}},"required":["provider","user_message","output_type"]},"tools":{"type":"array","description":"Array of tools the agent can use. The agent decides which tools to call based on the task","items":{"$ref":"#/components/schemas/AgentTool"}},"type":{"type":"string","enum":["aiagent"]},"tag":{"type":"string","description":"Worker group tag for execution routing. If not set, the AI agent step runs on the flow's tag (default \`flow\`)"},"omit_output_from_conversation":{"type":"boolean","default":false,"description":"If true, this AI agent step does not persist its assistant or tool messages to the flow conversation when chat mode is enabled."},"parallel":{"type":"boolean","description":"If true, the agent can execute multiple tool calls in parallel"}},"required":["tools","type","input_transforms"]},"Identity":{"type":"object","description":"Pass-through module that returns its input unchanged. Useful for flow structure or as a placeholder","properties":{"type":{"type":"string","enum":["identity"]},"flow":{"type":"boolean","description":"If true, marks this as a flow identity (special handling)"}},"required":["type"]},"FlowStatus":{"type":"object","properties":{"step":{"type":"integer"},"modules":{"type":"array","items":{"$ref":"#/components/schemas/FlowStatusModule"}},"user_states":{"additionalProperties":true},"preprocessor_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"}]},"failure_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"},{"type":"object","properties":{"parent_module":{"type":"string"}}}]},"retry":{"type":"object","properties":{"fail_count":{"type":"integer"},"failed_jobs":{"type":"array","items":{"type":"string","format":"uuid"}}}}},"required":["step","modules","failure_module"]},"FlowStatusModule":{"type":"object","properties":{"type":{"type":"string","enum":["WaitingForPriorSteps","WaitingForEvents","WaitingForExecutor","InProgress","Success","Failure"]},"id":{"type":"string"},"job":{"type":"string","format":"uuid"},"count":{"type":"integer"},"progress":{"type":"integer"},"iterator":{"type":"object","properties":{"index":{"type":"integer"},"itered":{"type":"array","items":{}},"itered_len":{"type":"integer"},"args":{}}},"flow_jobs":{"type":"array","items":{"type":"string"}},"flow_jobs_success":{"type":"array","items":{"type":"boolean"}},"flow_jobs_duration":{"type":"object","properties":{"started_at":{"type":"array","items":{"type":"string"}},"duration_ms":{"type":"array","items":{"type":"integer"}}}},"branch_chosen":{"type":"object","properties":{"type":{"type":"string","enum":["branch","default"]},"branch":{"type":"integer"}},"required":["type"]},"branchall":{"type":"object","properties":{"branch":{"type":"integer"},"len":{"type":"integer"}},"required":["branch","len"]},"approvers":{"type":"array","items":{"type":"object","properties":{"resume_id":{"type":"integer"},"approver":{"type":"string"}},"required":["resume_id","approver"]}},"failed_retries":{"type":"array","items":{"type":"string","format":"uuid"}},"skipped":{"type":"boolean"},"agent_actions":{"type":"array","items":{"type":"object","oneOf":[{"type":"object","properties":{"job_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"type":{"type":"string","enum":["tool_call"]},"module_id":{"type":"string"}},"required":["job_id","function_name","type","module_id"]},{"type":"object","properties":{"call_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"resource_path":{"type":"string"},"type":{"type":"string","enum":["mcp_tool_call"]},"arguments":{"type":"object"}},"required":["call_id","function_name","resource_path","type"]},{"type":"object","properties":{"type":{"type":"string","enum":["web_search"]}},"required":["type"]},{"type":"object","properties":{"type":{"type":"string","enum":["message"]}},"required":["content","type"]}]}},"agent_actions_success":{"type":"array","items":{"type":"boolean"}}},"required":["type"]}}`;
 
 export const CLI_COMMANDS = `# Windmill CLI Commands
 
@@ -3094,8 +3102,8 @@ inspect asset-driven pipelines (scripts marked \`// pipeline\`, wired by \`// on
 - \`pipeline show <folder:string>\` - render a pipeline folder's DAG (sources, lineage, subscriptions) in the terminal
   - \`--json\` - Output the raw asset graph as JSON
   - \`--local\` - Build the graph from local working-tree files (// pipeline scripts) instead of the deployed workspace — no deploy needed.
-- \`pipeline run <folder:string>\` - run a bounded cascade: from a schedule/manual root, fan downstream up to the --to end node(s)
-  - \`--from <script:string>\` - Start script (short name or path). Defaults to the folder's sole schedule/manual root.
+- \`pipeline run <folder:string>\` - run a cascade: from --from (a root OR any mid-DAG model), fan downstream up to the --to end node(s)
+  - \`--from <script:string>\` - Start script (short name or path). May be any node, including a mid-DAG model — that node plus its transitive downstream runs, upstream is NOT re-run (dbt \`--select model+\`). Defaults to the folder's sole schedule/manual root.
   - \`--to <node:string>\` - End node(s) to stop at — script names/paths or asset URIs (e.g. datatable://main/staged). Repeatable or comma-separated. Omit to run the full downstream.
   - \`--dry-run\` - Print the topological run plan without executing.
   - \`--json\` - Output the plan as JSON (for piping to jq).
diff --git a/system_prompts/auto-generated/script.md b/system_prompts/auto-generated/script.md
index bdfec21036..408f1354b7 100644
--- a/system_prompts/auto-generated/script.md
+++ b/system_prompts/auto-generated/script.md
@@ -1888,13 +1888,6 @@ async requestInteractiveSlackApproval({ slackResourcePath, channelId, message, a
  */
 async requestInteractiveTeamsApproval({ teamName, channelName, message, approver, defaultArgsJson, dynamicEnumsJson, }: TeamsApprovalOptions): Promise<void>
 
-/**
- * Parse an S3 object from URI string or record format
- * @param s3Object - S3 object as URI string (s3://storage/key) or record
- * @returns S3 object record with storage and s3 key
- */
-parseS3Object(s3Object: S3Object): S3ObjectRecord
-
 setWorkflowCtx(ctx: WorkflowCtx | null): void
 
 async sleep(seconds: number): Promise<void>
@@ -1964,6 +1957,17 @@ async parallel<T, R>(items: T[], fn: (item: T) => PromiseLike<R> | R, options?:
  */
 async commitKafkaOffsets(triggerPath: string, topic: string, partition: number, offset: number,): Promise<void>
 
+/**
+ * Parse an S3 object from URI string or record format
+ * @param s3Object - S3 object as URI string (`s3://storage/key`, `s3:///key`
+ *   for the default storage) or record. Any other string throws rather than
+ *   falling back to an auto-generated key: an auto key is requested by
+ *   omitting the object, and a fallback would silently misplace the upload
+ *   on any typo.
+ * @returns S3 object record with storage and s3 key
+ */
+parseS3Object(s3Object: S3Object): S3ObjectRecord
+
 /**
  * Create a SQL template function for PostgreSQL/datatable queries
  * @param name - Database/datatable name (default: "main")
@@ -2549,7 +2553,11 @@ def get_state_path() -> str
 # Parse resource syntax from string.
 def parse_resource_syntax(s: str) -> Optional[str]
 
-# Parse S3 object from string or S3Object format.
+# Parse S3 object from a `s3://<storage>/<key>` URI string (`s3:///<key>`
+# for the default storage) or S3Object format. Any other string raises
+# rather than falling back to an auto-generated key: an auto key is
+# requested by omitting the object, and a fallback would silently misplace
+# the upload on any typo.
 def parse_s3_object(s3_object: S3Object | str) -> S3Object
 
 # Parse variable syntax from string.
diff --git a/system_prompts/auto-generated/sdks/python.md b/system_prompts/auto-generated/sdks/python.md
index e6bb79d8d8..c750f03bcf 100644
--- a/system_prompts/auto-generated/sdks/python.md
+++ b/system_prompts/auto-generated/sdks/python.md
@@ -526,7 +526,11 @@ def get_state_path() -> str
 # Parse resource syntax from string.
 def parse_resource_syntax(s: str) -> Optional[str]
 
-# Parse S3 object from string or S3Object format.
+# Parse S3 object from a `s3://<storage>/<key>` URI string (`s3:///<key>`
+# for the default storage) or S3Object format. Any other string raises
+# rather than falling back to an auto-generated key: an auto key is
+# requested by omitting the object, and a fallback would silently misplace
+# the upload on any typo.
 def parse_s3_object(s3_object: S3Object | str) -> S3Object
 
 # Parse variable syntax from string.
diff --git a/system_prompts/auto-generated/sdks/typescript.md b/system_prompts/auto-generated/sdks/typescript.md
index 8557995d55..8100929776 100644
--- a/system_prompts/auto-generated/sdks/typescript.md
+++ b/system_prompts/auto-generated/sdks/typescript.md
@@ -455,13 +455,6 @@ async requestInteractiveSlackApproval({ slackResourcePath, channelId, message, a
  */
 async requestInteractiveTeamsApproval({ teamName, channelName, message, approver, defaultArgsJson, dynamicEnumsJson, }: TeamsApprovalOptions): Promise<void>
 
-/**
- * Parse an S3 object from URI string or record format
- * @param s3Object - S3 object as URI string (s3://storage/key) or record
- * @returns S3 object record with storage and s3 key
- */
-parseS3Object(s3Object: S3Object): S3ObjectRecord
-
 setWorkflowCtx(ctx: WorkflowCtx | null): void
 
 async sleep(seconds: number): Promise<void>
@@ -531,6 +524,17 @@ async parallel<T, R>(items: T[], fn: (item: T) => PromiseLike<R> | R, options?:
  */
 async commitKafkaOffsets(triggerPath: string, topic: string, partition: number, offset: number,): Promise<void>
 
+/**
+ * Parse an S3 object from URI string or record format
+ * @param s3Object - S3 object as URI string (`s3://storage/key`, `s3:///key`
+ *   for the default storage) or record. Any other string throws rather than
+ *   falling back to an auto-generated key: an auto key is requested by
+ *   omitting the object, and a fallback would silently misplace the upload
+ *   on any typo.
+ * @returns S3 object record with storage and s3 key
+ */
+parseS3Object(s3Object: S3Object): S3ObjectRecord
+
 /**
  * Create a SQL template function for PostgreSQL/datatable queries
  * @param name - Database/datatable name (default: "main")
diff --git a/system_prompts/auto-generated/skills/cli-commands/SKILL.md b/system_prompts/auto-generated/skills/cli-commands/SKILL.md
index 141b3fc0c4..1a4738ecf5 100644
--- a/system_prompts/auto-generated/skills/cli-commands/SKILL.md
+++ b/system_prompts/auto-generated/skills/cli-commands/SKILL.md
@@ -431,8 +431,8 @@ inspect asset-driven pipelines (scripts marked `// pipeline`, wired by `// on <s
 - `pipeline show <folder:string>` - render a pipeline folder's DAG (sources, lineage, subscriptions) in the terminal
   - `--json` - Output the raw asset graph as JSON
   - `--local` - Build the graph from local working-tree files (// pipeline scripts) instead of the deployed workspace — no deploy needed.
-- `pipeline run <folder:string>` - run a bounded cascade: from a schedule/manual root, fan downstream up to the --to end node(s)
-  - `--from <script:string>` - Start script (short name or path). Defaults to the folder's sole schedule/manual root.
+- `pipeline run <folder:string>` - run a cascade: from --from (a root OR any mid-DAG model), fan downstream up to the --to end node(s)
+  - `--from <script:string>` - Start script (short name or path). May be any node, including a mid-DAG model — that node plus its transitive downstream runs, upstream is NOT re-run (dbt `--select model+`). Defaults to the folder's sole schedule/manual root.
   - `--to <node:string>` - End node(s) to stop at — script names/paths or asset URIs (e.g. datatable://main/staged). Repeatable or comma-separated. Omit to run the full downstream.
   - `--dry-run` - Print the topological run plan without executing.
   - `--json` - Output the plan as JSON (for piping to jq).
diff --git a/system_prompts/auto-generated/skills/write-flow/SKILL.md b/system_prompts/auto-generated/skills/write-flow/SKILL.md
index 26f06fb667..a2a5d294e7 100644
--- a/system_prompts/auto-generated/skills/write-flow/SKILL.md
+++ b/system_prompts/auto-generated/skills/write-flow/SKILL.md
@@ -381,4 +381,4 @@ Reference a specific resource using `$res:` prefix:
 
 ## OpenFlow Schema
 
-{"OpenFlow":{"type":"object","description":"Top-level flow definition containing metadata, configuration, and the flow structure","properties":{"summary":{"type":"string","description":"Short description of what this flow does"},"description":{"type":"string","description":"Detailed documentation for this flow"},"value":{"$ref":"#/components/schemas/FlowValue"},"schema":{"type":"object","description":"JSON Schema for flow inputs. Use this to define input parameters, their types, defaults, and validation. For resource inputs, set type to 'object' and format to 'resource-<type>' (e.g., 'resource-stripe')"},"on_behalf_of_email":{"type":"string","description":"The flow will be run with the permissions of the user with this email."}},"required":["summary","value"]},"FlowValue":{"type":"object","description":"The flow structure containing modules and optional preprocessor/failure handlers","properties":{"modules":{"type":"array","description":"Array of steps that execute in sequence. Each step can be a script, subflow, loop, or branch","items":{"$ref":"#/components/schemas/FlowModule"}},"failure_module":{"description":"Special module that executes when the flow fails. Receives error object with message, name, stack, and step_id. Must have id 'failure'. Only supports script/rawscript types","$ref":"#/components/schemas/FlowModule"},"preprocessor_module":{"description":"Special module that runs before the first step on external triggers. Must have id 'preprocessor'. Only supports script/rawscript types. Cannot reference other step results","$ref":"#/components/schemas/FlowModule"},"same_worker":{"type":"boolean","description":"If true, all steps run on the same worker for better performance"},"preserve_step_tags":{"type":"boolean","description":"If true and the flow runs on a custom worker tag, steps that declare their own non-empty tag run on it instead of inheriting the flow tag. Steps without their own tag still inherit the flow tag."},"concurrent_limit":{"type":"number","description":"Maximum number of concurrent executions of this flow"},"concurrency_key":{"type":"string","description":"Expression to group concurrent executions (e.g., by user ID)"},"concurrency_time_window_s":{"type":"number","description":"Time window in seconds for concurrent_limit"},"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce flow executions"},"debounce_key":{"type":"string","description":"Expression to group debounced executions"},"debounce_args_to_accumulate":{"type":"array","description":"Arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds that a job can be debounced"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of times a job can be debounced"},"skip_expr":{"type":"string","description":"JavaScript expression to conditionally skip the entire flow"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for flow results"},"cache_ignore_s3_path":{"type":"boolean"},"delete_after_secs":{"type":"integer","description":"If set, delete the flow job's args, result and logs after this many seconds following job completion"},"flow_env":{"type":"object","description":"Environment variables available to all steps. Values can be strings, JSON values, or special references: '$var:path' (workspace variable) or '$res:path' (resource).","additionalProperties":{}},"priority":{"type":"number","description":"Execution priority (higher numbers run first)"},"early_return":{"type":"string","description":"JavaScript expression to return early from the flow"},"chat_input_enabled":{"type":"boolean","description":"Whether this flow accepts chat-style input"},"notes":{"type":"array","description":"Sticky notes attached to the flow","items":{"$ref":"#/components/schemas/FlowNote"}},"groups":{"type":"array","description":"Semantic groups of modules for organizational purposes","items":{"$ref":"#/components/schemas/FlowGroup"}}},"required":["modules"]},"Retry":{"type":"object","description":"Retry configuration for failed module executions","properties":{"constant":{"type":"object","description":"Retry with constant delay between attempts","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"seconds":{"type":"integer","description":"Seconds to wait between retries"}}},"exponential":{"type":"object","description":"Retry with exponential backoff (delay doubles each time)","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"multiplier":{"type":"integer","description":"Multiplier for exponential backoff"},"seconds":{"type":"integer","minimum":1,"description":"Initial delay in seconds"},"random_factor":{"type":"integer","minimum":0,"maximum":100,"description":"Random jitter percentage (0-100) to avoid thundering herd"}}},"retry_if":{"$ref":"#/components/schemas/RetryIf"}}},"FlowNote":{"type":"object","description":"A sticky note attached to a flow for documentation and annotation","properties":{"id":{"type":"string","description":"Unique identifier for the note"},"text":{"type":"string","description":"Content of the note"},"position":{"type":"object","description":"Position of the note in the flow editor","properties":{"x":{"type":"number","description":"X coordinate"},"y":{"type":"number","description":"Y coordinate"}},"required":["x","y"]},"size":{"type":"object","description":"Size of the note in the flow editor","properties":{"width":{"type":"number","description":"Width in pixels"},"height":{"type":"number","description":"Height in pixels"}},"required":["width","height"]},"color":{"type":"string","description":"Color of the note (e.g., \"yellow\", \"#ffff00\")"},"type":{"type":"string","enum":["free","group"],"description":"Type of note - 'free' for standalone notes, 'group' for notes that group other nodes"},"locked":{"type":"boolean","default":false,"description":"Whether the note is locked and cannot be edited or moved"},"contained_node_ids":{"type":"array","items":{"type":"string"},"description":"For group notes, the IDs of nodes contained within this group"}},"required":["id","text","color","type"]},"FlowGroup":{"type":"object","description":"A semantic group of flow modules for organizational purposes. Does not affect execution \u2014 modules remain in their original position in the flow. Groups provide naming and collapsibility in the editor. Members are computed dynamically from all nodes on paths between start_id and end_id.","properties":{"summary":{"type":"string","description":"Display name for this group"},"note":{"type":"string","description":"Markdown note shown below the group header"},"autocollapse":{"type":"boolean","default":false,"description":"If true, this group is collapsed by default in the flow editor. UI hint only."},"start_id":{"type":"string","description":"ID of the first flow module in this group (topological entry point)"},"end_id":{"type":"string","description":"ID of the last flow module in this group (topological exit point)"},"color":{"type":"string","description":"Color for the group in the flow editor"}},"required":["start_id","end_id"]},"RetryIf":{"type":"object","description":"Conditional retry based on error or result","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to retry. Has access to 'result' and 'error' variables"}},"required":["expr"]},"StopAfterIf":{"type":"object","description":"Early termination condition for a module","properties":{"skip_if_stopped":{"type":"boolean","description":"If true, following steps are skipped when this condition triggers"},"expr":{"type":"string","description":"JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"},"error_message":{"type":"string","nullable":true,"description":"Custom error message when stopping with an error. Mutually exclusive with skip_if_stopped. If set to a non-empty string, the flow stops with this error. If empty string, a default error message is used. If null or omitted, no error is raised."},"error_include_result":{"type":"boolean","description":"When stopping with an error (error_message set), embed the stopping step's own result inside the raised error object (as error.result) instead of discarding it. The top-level result stays { error }. Defaults to false."}},"required":["expr"]},"FlowModule":{"type":"object","description":"A single step in a flow. Can be a script, subflow, loop, or branch","properties":{"id":{"type":"string","description":"Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)"},"value":{"$ref":"#/components/schemas/FlowModuleValue"},"stop_after_if":{"description":"Early termination condition evaluated after this step completes","$ref":"#/components/schemas/StopAfterIf"},"stop_after_all_iters_if":{"description":"For loops only - early termination condition evaluated after all iterations complete","$ref":"#/components/schemas/StopAfterIf"},"skip_if":{"type":"object","description":"Conditionally skip this step based on previous results or flow inputs","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to skip. Can use 'flow_input' or 'results.<step_id>'"}},"required":["expr"]},"sleep":{"description":"Delay before executing this step (in seconds or as expression)","$ref":"#/components/schemas/InputTransform"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for this step's results"},"cache_ignore_s3_path":{"type":"boolean"},"timeout":{"description":"Maximum execution time in seconds (static value or expression)","$ref":"#/components/schemas/InputTransform"},"delete_after_secs":{"type":"integer","description":"If set, delete the step's args, result and logs after this many seconds following job completion"},"summary":{"type":"string","description":"Short description of what this step does"},"mock":{"type":"object","description":"Mock configuration for testing without executing the actual step","properties":{"enabled":{"type":"boolean","description":"If true, return mock value instead of executing"},"return_value":{"description":"Value to return when mocked"}}},"suspend":{"type":"object","description":"Configuration for approval/resume steps that wait for user input","properties":{"required_events":{"type":"integer","description":"Number of approvals required before continuing"},"timeout":{"type":"integer","description":"Timeout in seconds before auto-continuing or canceling"},"resume_form":{"type":"object","description":"Form schema for collecting input when resuming","properties":{"schema":{"type":"object","description":"JSON Schema for the resume form"}}},"user_auth_required":{"type":"boolean","description":"If true, only authenticated users can approve"},"user_groups_required":{"description":"Expression or list of groups that can approve","$ref":"#/components/schemas/InputTransform"},"self_approval_disabled":{"type":"boolean","description":"If true, the user who started the flow cannot approve"},"hide_cancel":{"type":"boolean","description":"If true, hide the cancel button on the approval form"},"continue_on_disapprove_timeout":{"type":"boolean","description":"If true, continue flow on timeout instead of canceling"}}},"priority":{"type":"number","description":"Execution priority for this step (higher numbers run first)"},"continue_on_error":{"type":"boolean","description":"If true, flow continues even if this step fails"},"retry":{"description":"Retry configuration if this step fails","$ref":"#/components/schemas/Retry"},"debouncing":{"description":"Debounce configuration for this step (EE only)","type":"object","properties":{"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce this step's executions across flow runs"},"debounce_key":{"type":"string","description":"Expression to group debounced executions. Supports $workspace and $args[name]. Default: $workspace/flow/<flow_path>-<step_id>"},"debounce_args_to_accumulate":{"type":"array","description":"Array-type arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds before forced execution"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of debounces before forced execution"}}}},"required":["value","id"]},"InputTransform":{"description":"Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs","oneOf":[{"$ref":"#/components/schemas/StaticTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"StaticTransform":{"type":"object","description":"Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'","properties":{"value":{"description":"The static value. For resources, use format '$res:path/to/resource'"},"type":{"type":"string","enum":["static"]}},"required":["type"]},"JavascriptTransform":{"type":"object","description":"JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside loops, use 'flow_input.iter.value' for the current iteration value","properties":{"expr":{"type":"string","description":"JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"},"type":{"type":"string","enum":["javascript"]}},"required":["expr","type"]},"AiTransform":{"type":"object","description":"Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.","properties":{"type":{"type":"string","enum":["ai"]}},"required":["type"]},"AIProviderKind":{"type":"string","description":"Supported AI provider types","enum":["openai","azure_openai","azure_foundry","anthropic","mistral","deepseek","googleai","groq","openrouter","togetherai","customai","aws_bedrock"]},"ProviderConfig":{"type":"object","description":"Complete AI provider configuration with resource reference and model selection","properties":{"kind":{"$ref":"#/components/schemas/AIProviderKind"},"resource":{"type":"string","description":"Resource reference in format '$res:{resource_path}' pointing to provider credentials"},"model":{"type":"string","description":"Model identifier (e.g., 'gpt-4', 'claude-3-opus-20240229', 'gemini-pro')"}},"required":["kind","resource","model"]},"StaticProviderTransform":{"type":"object","description":"Static provider configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/ProviderConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"ProviderTransform":{"description":"Provider configuration - can be static (ProviderConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticProviderTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticProviderTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"MemoryOff":{"type":"object","description":"No conversation memory/context","properties":{"kind":{"type":"string","enum":["off"]}},"required":["kind"]},"MemoryAuto":{"type":"object","description":"Automatic context management","properties":{"kind":{"type":"string","enum":["auto"]},"context_length":{"type":"integer","description":"Maximum number of messages to retain in context"},"memory_id":{"type":"string","description":"Identifier for persistent memory across agent invocations"}},"required":["kind"]},"MemoryMessage":{"type":"object","description":"A single message in conversation history","properties":{"role":{"type":"string","enum":["user","assistant","system"]},"content":{"type":"string"}},"required":["role","content"]},"MemoryManual":{"type":"object","description":"Explicit message history","properties":{"kind":{"type":"string","enum":["manual"]},"messages":{"type":"array","items":{"$ref":"#/components/schemas/MemoryMessage"}}},"required":["kind","messages"]},"MemoryConfig":{"description":"Conversation memory configuration","oneOf":[{"$ref":"#/components/schemas/MemoryOff"},{"$ref":"#/components/schemas/MemoryAuto"},{"$ref":"#/components/schemas/MemoryManual"}],"discriminator":{"propertyName":"kind","mapping":{"off":"#/components/schemas/MemoryOff","auto":"#/components/schemas/MemoryAuto","manual":"#/components/schemas/MemoryManual"}}},"StaticMemoryTransform":{"type":"object","description":"Static memory configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/MemoryConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"MemoryTransform":{"description":"Memory configuration - can be static (MemoryConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticMemoryTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticMemoryTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"FlowModuleValue":{"description":"The actual implementation of a flow step. Can be a script (inline or referenced), subflow, loop, branch, or special module type","oneOf":[{"$ref":"#/components/schemas/RawScript"},{"$ref":"#/components/schemas/PathScript"},{"$ref":"#/components/schemas/PathFlow"},{"$ref":"#/components/schemas/ForloopFlow"},{"$ref":"#/components/schemas/WhileloopFlow"},{"$ref":"#/components/schemas/BranchOne"},{"$ref":"#/components/schemas/BranchAll"},{"$ref":"#/components/schemas/Identity"},{"$ref":"#/components/schemas/AiAgent"}],"discriminator":{"propertyName":"type","mapping":{"rawscript":"#/components/schemas/RawScript","script":"#/components/schemas/PathScript","flow":"#/components/schemas/PathFlow","forloopflow":"#/components/schemas/ForloopFlow","whileloopflow":"#/components/schemas/WhileloopFlow","branchone":"#/components/schemas/BranchOne","branchall":"#/components/schemas/BranchAll","identity":"#/components/schemas/Identity","aiagent":"#/components/schemas/AiAgent"}}},"RawScript":{"type":"object","description":"Inline script with code defined directly in the flow. Use 'bun' as default language if unspecified. The script receives arguments from input_transforms","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"content":{"type":"string","description":"The script source code. Should export a 'main' function"},"language":{"type":"string","description":"Programming language for this script","enum":["deno","bun","python3","go","bash","powershell","postgresql","mysql","bigquery","snowflake","mssql","oracledb","graphql","nativets","php","rust","ansible","csharp","nu","java","ruby","rlang","duckdb"]},"path":{"type":"string","description":"Optional path for saving this script"},"lock":{"type":"string","description":"Lock file content for dependencies"},"type":{"type":"string","enum":["rawscript"]},"tag":{"type":"string","description":"Worker group tag for execution routing"},"concurrent_limit":{"type":"number","description":"Maximum concurrent executions of this script"},"concurrency_time_window_s":{"type":"number","description":"Time window for concurrent_limit"},"custom_concurrency_key":{"type":"string","description":"Custom key for grouping concurrent executions"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"},"assets":{"type":"array","description":"External resources this script accesses (S3 objects, resources, etc.)","items":{"type":"object","required":["path","kind"],"properties":{"path":{"type":"string","description":"Path to the asset"},"kind":{"type":"string","description":"Type of asset","enum":["s3object","resource","ducklake","datatable","volume"]},"access_type":{"type":"string","nullable":true,"description":"Access level for this asset","enum":["r","w","rw"]},"alt_access_type":{"type":"string","nullable":true,"description":"Alternative access level","enum":["r","w","rw"]}}}}},"required":["type","content","language","input_transforms"]},"PathScript":{"type":"object","description":"Reference to an existing script by path. Use this when calling a previously saved script instead of writing inline code","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the script in the workspace (e.g., 'f/scripts/send_email')"},"hash":{"type":"string","description":"Optional specific version hash of the script to use"},"type":{"type":"string","enum":["script"]},"tag_override":{"type":"string","description":"Override the script's default worker group tag"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"}},"required":["type","path","input_transforms"]},"PathFlow":{"type":"object","description":"Reference to an existing flow by path. Use this to call another flow as a subflow","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the subflow's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the flow in the workspace (e.g., 'f/flows/process_user')"},"type":{"type":"string","enum":["flow"]}},"required":["type","path","input_transforms"]},"ForloopFlow":{"type":"object","description":"Executes nested modules in a loop over an iterator. Inside the loop, use 'flow_input.iter.value' to access the current iteration value, and 'flow_input.iter.index' for the index. Supports parallel execution for better performance on I/O-bound operations","properties":{"modules":{"type":"array","description":"Steps to execute for each iteration. These can reference the iteration value via 'flow_input.iter.value'","items":{"$ref":"#/components/schemas/FlowModule"}},"iterator":{"description":"JavaScript expression that returns an array to iterate over. Can reference 'results.step_id' or 'flow_input'","$ref":"#/components/schemas/InputTransform"},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["forloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (faster for I/O-bound operations). Use with parallelism to control concurrency"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true. Limits resource usage. Can be static number or expression","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","iterator","skip_failures","type"]},"WhileloopFlow":{"type":"object","description":"Executes nested modules repeatedly while a condition is true. The loop checks the condition after each iteration. Use stop_after_if on modules to control loop termination","properties":{"modules":{"type":"array","description":"Steps to execute in each iteration. Use stop_after_if to control when the loop ends","items":{"$ref":"#/components/schemas/FlowModule"}},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["whileloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (use with caution in while loops)"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","skip_failures","type"]},"BranchOne":{"type":"object","description":"Conditional branching where only the first matching branch executes. Branches are evaluated in order, and the first one with a true expression runs. If no branches match, the default branch executes","properties":{"branches":{"type":"array","description":"Array of branches to evaluate in order. The first branch with expr evaluating to true executes","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch condition"},"expr":{"type":"string","description":"JavaScript expression that returns boolean. Can use 'results.step_id' or 'flow_input'. First true expr wins"},"modules":{"type":"array","description":"Steps to execute if this branch's expr is true","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules","expr"]}},"default":{"type":"array","description":"Steps to execute if no branch expressions match","items":{"$ref":"#/components/schemas/FlowModule"}},"type":{"type":"string","enum":["branchone"]}},"required":["branches","default","type"]},"BranchAll":{"type":"object","description":"Parallel branching where all branches execute simultaneously. Unlike BranchOne, all branches run regardless of conditions. Useful for executing independent tasks concurrently","properties":{"branches":{"type":"array","description":"Array of branches that all execute (either in parallel or sequentially)","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch's purpose"},"skip_failure":{"type":"boolean","description":"If true, failure in this branch doesn't fail the entire flow"},"modules":{"type":"array","description":"Steps to execute in this branch","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules"]}},"type":{"type":"string","enum":["branchall"]},"parallel":{"type":"boolean","description":"If true, all branches execute concurrently. If false, they execute sequentially"}},"required":["branches","type"]},"AgentTool":{"type":"object","description":"A tool available to an AI agent. Can be a flow module or an external MCP (Model Context Protocol) tool","properties":{"id":{"type":"string","description":"Unique identifier for this tool. Cannot contain spaces - use underscores instead (e.g., 'get_user_data' not 'get user data')"},"summary":{"type":"string","description":"Short description of what this tool does (shown to the AI)"},"value":{"$ref":"#/components/schemas/ToolValue"}},"required":["id","value"]},"ToolValue":{"description":"The implementation of a tool. Can be a flow module (script/flow) or an MCP tool reference","oneOf":[{"$ref":"#/components/schemas/FlowModuleTool"},{"$ref":"#/components/schemas/McpToolValue"},{"$ref":"#/components/schemas/WebsearchToolValue"}],"discriminator":{"propertyName":"tool_type","mapping":{"flowmodule":"#/components/schemas/FlowModuleTool","mcp":"#/components/schemas/McpToolValue","websearch":"#/components/schemas/WebsearchToolValue"}}},"FlowModuleTool":{"description":"A tool implemented as a flow module (script, flow, etc.). The AI can call this like any other flow module","allOf":[{"type":"object","properties":{"tool_type":{"type":"string","enum":["flowmodule"]}},"required":["tool_type"]},{"$ref":"#/components/schemas/FlowModuleValue"}]},"WebsearchToolValue":{"type":"object","description":"A tool implemented as a websearch tool. The AI can call this like any other websearch tool","properties":{"tool_type":{"type":"string","enum":["websearch"]}},"required":["tool_type"]},"McpToolValue":{"type":"object","description":"Reference to an external MCP (Model Context Protocol) tool. The AI can call tools from MCP servers","properties":{"tool_type":{"type":"string","enum":["mcp"]},"resource_path":{"type":"string","description":"Path to the MCP resource/server configuration"},"include_tools":{"type":"array","description":"Whitelist of specific tools to include from this MCP server","items":{"type":"string"}},"exclude_tools":{"type":"array","description":"Blacklist of tools to exclude from this MCP server","items":{"type":"string"}}},"required":["tool_type","resource_path"]},"AiAgent":{"type":"object","description":"AI agent step that can use tools to accomplish tasks. The agent receives inputs and can call any of its configured tools to complete the task","properties":{"input_transforms":{"type":"object","description":"Input parameters for the AI agent mapped to their values","properties":{"provider":{"$ref":"#/components/schemas/ProviderTransform"},"output_type":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Output format type.\nValid values: 'text' (default) - plain text response, 'image' - image generation\n"},"user_message":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"The user's prompt/message to the AI agent. Supports variable interpolation with flow.input syntax."},"system_prompt":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"System instructions that guide the AI's behavior, persona, and response style. Optional."},"streaming":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Boolean. If true, stream the AI response incrementally.\nStreaming events include: token_delta, tool_call, tool_call_arguments, tool_execution, tool_result\n"},"memory":{"$ref":"#/components/schemas/MemoryTransform"},"output_schema":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"JSON Schema object defining structured output format. Used when you need the AI to return data in a specific shape.\nSupports standard JSON Schema properties: type, properties, required, items, enum, pattern, minLength, maxLength, minimum, maximum, etc.\nExample: { type: 'object', properties: { name: { type: 'string' }, age: { type: 'integer' } }, required: ['name'] }\n"},"user_attachments":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Array of file references (images or PDFs) for the AI agent.\nFormat: Array<{ bucket: string, key: string }> - S3 object references\nExample: [{ bucket: 'my-bucket', key: 'documents/report.pdf' }]\n"},"max_completion_tokens":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Integer. Maximum number of tokens the AI will generate in its response.\nRange: 1 to 4,294,967,295. Typical values: 256-4096 for most use cases.\n"},"temperature":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Float. Controls randomness/creativity of responses.\nRange: 0.0 to 2.0 (provider-dependent)\n- 0.0 = deterministic, focused responses\n- 0.7 = balanced (common default)\n- 1.0+ = more creative/random\n"},"max_iterations":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Number. Limits how many times the agent can loop through reasoning and tool use.\nRange: 1-1000.\n"}},"required":["provider","user_message","output_type"]},"tools":{"type":"array","description":"Array of tools the agent can use. The agent decides which tools to call based on the task","items":{"$ref":"#/components/schemas/AgentTool"}},"type":{"type":"string","enum":["aiagent"]},"tag":{"type":"string","description":"Worker group tag for execution routing. If not set, the AI agent step runs on the flow's tag (default `flow`)"},"omit_output_from_conversation":{"type":"boolean","default":false,"description":"If true, this AI agent step does not persist its assistant or tool messages to the flow conversation when chat mode is enabled."},"parallel":{"type":"boolean","description":"If true, the agent can execute multiple tool calls in parallel"}},"required":["tools","type","input_transforms"]},"Identity":{"type":"object","description":"Pass-through module that returns its input unchanged. Useful for flow structure or as a placeholder","properties":{"type":{"type":"string","enum":["identity"]},"flow":{"type":"boolean","description":"If true, marks this as a flow identity (special handling)"}},"required":["type"]},"FlowStatus":{"type":"object","properties":{"step":{"type":"integer"},"modules":{"type":"array","items":{"$ref":"#/components/schemas/FlowStatusModule"}},"user_states":{"additionalProperties":true},"preprocessor_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"}]},"failure_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"},{"type":"object","properties":{"parent_module":{"type":"string"}}}]},"retry":{"type":"object","properties":{"fail_count":{"type":"integer"},"failed_jobs":{"type":"array","items":{"type":"string","format":"uuid"}}}}},"required":["step","modules","failure_module"]},"FlowStatusModule":{"type":"object","properties":{"type":{"type":"string","enum":["WaitingForPriorSteps","WaitingForEvents","WaitingForExecutor","InProgress","Success","Failure"]},"id":{"type":"string"},"job":{"type":"string","format":"uuid"},"count":{"type":"integer"},"progress":{"type":"integer"},"iterator":{"type":"object","properties":{"index":{"type":"integer"},"itered":{"type":"array","items":{}},"itered_len":{"type":"integer"},"args":{}}},"flow_jobs":{"type":"array","items":{"type":"string"}},"flow_jobs_success":{"type":"array","items":{"type":"boolean"}},"flow_jobs_duration":{"type":"object","properties":{"started_at":{"type":"array","items":{"type":"string"}},"duration_ms":{"type":"array","items":{"type":"integer"}}}},"branch_chosen":{"type":"object","properties":{"type":{"type":"string","enum":["branch","default"]},"branch":{"type":"integer"}},"required":["type"]},"branchall":{"type":"object","properties":{"branch":{"type":"integer"},"len":{"type":"integer"}},"required":["branch","len"]},"approvers":{"type":"array","items":{"type":"object","properties":{"resume_id":{"type":"integer"},"approver":{"type":"string"}},"required":["resume_id","approver"]}},"failed_retries":{"type":"array","items":{"type":"string","format":"uuid"}},"skipped":{"type":"boolean"},"agent_actions":{"type":"array","items":{"type":"object","oneOf":[{"type":"object","properties":{"job_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"type":{"type":"string","enum":["tool_call"]},"module_id":{"type":"string"}},"required":["job_id","function_name","type","module_id"]},{"type":"object","properties":{"call_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"resource_path":{"type":"string"},"type":{"type":"string","enum":["mcp_tool_call"]},"arguments":{"type":"object"}},"required":["call_id","function_name","resource_path","type"]},{"type":"object","properties":{"type":{"type":"string","enum":["web_search"]}},"required":["type"]},{"type":"object","properties":{"type":{"type":"string","enum":["message"]}},"required":["content","type"]}]}},"agent_actions_success":{"type":"array","items":{"type":"boolean"}}},"required":["type"]}}
\ No newline at end of file
+{"OpenFlow":{"type":"object","description":"Top-level flow definition containing metadata, configuration, and the flow structure","properties":{"summary":{"type":"string","description":"Short description of what this flow does"},"description":{"type":"string","description":"Detailed documentation for this flow"},"value":{"$ref":"#/components/schemas/FlowValue"},"schema":{"type":"object","description":"JSON Schema for flow inputs. Use this to define input parameters, their types, defaults, and validation. For resource inputs, set type to 'object' and format to 'resource-<type>' (e.g., 'resource-stripe')"},"on_behalf_of_email":{"type":"string","description":"The flow will be run with the permissions of the user with this email."}},"required":["summary","value"]},"FlowValue":{"type":"object","description":"The flow structure containing modules and optional preprocessor/failure handlers","properties":{"modules":{"type":"array","description":"Array of steps that execute in sequence. Each step can be a script, subflow, loop, or branch","items":{"$ref":"#/components/schemas/FlowModule"}},"failure_module":{"description":"Special module that executes when the flow fails. Receives error object with message, name, stack, and step_id. Must have id 'failure'. Only supports script/rawscript types","$ref":"#/components/schemas/FlowModule"},"preprocessor_module":{"description":"Special module that runs before the first step on external triggers. Must have id 'preprocessor'. Only supports script/rawscript types. Cannot reference other step results","$ref":"#/components/schemas/FlowModule"},"same_worker":{"type":"boolean","description":"If true, all steps run on the same worker for better performance"},"preserve_step_tags":{"type":"boolean","description":"If true and the flow runs on a custom worker tag, steps that declare their own non-empty tag run on it instead of inheriting the flow tag. Steps without their own tag still inherit the flow tag."},"concurrent_limit":{"type":"number","description":"Maximum number of concurrent executions of this flow"},"concurrency_key":{"type":"string","description":"Expression to group concurrent executions (e.g., by user ID)"},"concurrency_time_window_s":{"type":"number","description":"Time window in seconds for concurrent_limit"},"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce flow executions"},"debounce_key":{"type":"string","description":"Expression to group debounced executions"},"debounce_args_to_accumulate":{"type":"array","description":"Arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds that a job can be debounced"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of times a job can be debounced"},"skip_expr":{"type":"string","description":"JavaScript expression to conditionally skip the entire flow"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for flow results"},"cache_ignore_s3_path":{"type":"boolean"},"delete_after_secs":{"type":"integer","description":"If set, delete the flow job's args, result and logs after this many seconds following job completion"},"flow_env":{"type":"object","description":"Environment variables available to all steps. Values can be strings, JSON values, or special references: '$var:path' (workspace variable) or '$res:path' (resource).","additionalProperties":{}},"priority":{"type":"number","description":"Execution priority (higher numbers run first)"},"early_return":{"type":"string","description":"JavaScript expression to return early from the flow"},"chat_input_enabled":{"type":"boolean","description":"Whether this flow accepts chat-style input"},"notes":{"type":"array","description":"Sticky notes attached to the flow","items":{"$ref":"#/components/schemas/FlowNote"}},"groups":{"type":"array","description":"Semantic groups of modules for organizational purposes","items":{"$ref":"#/components/schemas/FlowGroup"}}},"required":["modules"]},"Retry":{"type":"object","description":"Retry configuration for failed module executions","properties":{"constant":{"type":"object","description":"Retry with constant delay between attempts","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"seconds":{"type":"integer","description":"Seconds to wait between retries"}}},"exponential":{"type":"object","description":"Retry with exponential backoff (delay doubles each time)","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"multiplier":{"type":"integer","description":"Multiplier for exponential backoff"},"seconds":{"type":"integer","minimum":1,"description":"Initial delay in seconds"},"random_factor":{"type":"integer","minimum":0,"maximum":100,"description":"Random jitter percentage (0-100) to avoid thundering herd"}}},"retry_if":{"$ref":"#/components/schemas/RetryIf"}}},"FlowNote":{"type":"object","description":"A sticky note attached to a flow for documentation and annotation","properties":{"id":{"type":"string","description":"Unique identifier for the note"},"text":{"type":"string","description":"Content of the note"},"position":{"type":"object","description":"Position of the note in the flow editor","properties":{"x":{"type":"number","description":"X coordinate"},"y":{"type":"number","description":"Y coordinate"}},"required":["x","y"]},"size":{"type":"object","description":"Size of the note in the flow editor","properties":{"width":{"type":"number","description":"Width in pixels"},"height":{"type":"number","description":"Height in pixels"}},"required":["width","height"]},"color":{"type":"string","description":"Color of the note (e.g., \"yellow\", \"#ffff00\")"},"type":{"type":"string","enum":["free","group"],"description":"Type of note - 'free' for standalone notes, 'group' for notes that group other nodes"},"locked":{"type":"boolean","default":false,"description":"Whether the note is locked and cannot be edited or moved"},"contained_node_ids":{"type":"array","items":{"type":"string"},"description":"For group notes, the IDs of nodes contained within this group"}},"required":["id","text","color","type"]},"FlowGroup":{"type":"object","description":"A semantic group of flow modules for organizational purposes. Does not affect execution \u2014 modules remain in their original position in the flow. Groups provide naming and collapsibility in the editor. Members are computed dynamically from all nodes on paths between start_id and end_id.","properties":{"summary":{"type":"string","description":"Display name for this group"},"note":{"type":"string","description":"Markdown note shown below the group header"},"autocollapse":{"type":"boolean","default":false,"description":"If true, this group is collapsed by default in the flow editor. UI hint only."},"start_id":{"type":"string","description":"ID of the first flow module in this group (topological entry point)"},"end_id":{"type":"string","description":"ID of the last flow module in this group (topological exit point)"},"color":{"type":"string","description":"Color for the group in the flow editor"}},"required":["start_id","end_id"]},"RetryIf":{"type":"object","description":"Conditional retry based on error or result","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to retry. Has access to 'result' and 'error' variables"}},"required":["expr"]},"StopAfterIf":{"type":"object","description":"Early termination condition for a module","properties":{"skip_if_stopped":{"type":"boolean","description":"If true, following steps are skipped when this condition triggers"},"expr":{"type":"string","description":"JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"},"error_message":{"type":"string","nullable":true,"description":"Custom error message when stopping with an error. Mutually exclusive with skip_if_stopped. If set to a non-empty string, the flow stops with this error. If empty string, a default error message is used. If null or omitted, no error is raised."},"error_include_result":{"type":"boolean","description":"When stopping with an error (error_message set), embed the stopping step's own result inside the raised error object (as error.result) instead of discarding it. The top-level result stays { error }. Defaults to false."}},"required":["expr"]},"FlowModule":{"type":"object","description":"A single step in a flow. Can be a script, subflow, loop, or branch","properties":{"id":{"type":"string","description":"Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)"},"value":{"$ref":"#/components/schemas/FlowModuleValue"},"stop_after_if":{"description":"Early termination condition evaluated after this step completes","$ref":"#/components/schemas/StopAfterIf"},"stop_after_all_iters_if":{"description":"For loops only - early termination condition evaluated after all iterations complete","$ref":"#/components/schemas/StopAfterIf"},"skip_if":{"type":"object","description":"Conditionally skip this step based on previous results or flow inputs","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to skip. Can use 'flow_input' or 'results.<step_id>'"}},"required":["expr"]},"sleep":{"description":"Delay before executing this step (in seconds or as expression)","$ref":"#/components/schemas/InputTransform"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for this step's results"},"cache_ignore_s3_path":{"type":"boolean"},"timeout":{"description":"Maximum execution time in seconds (static value or expression)","$ref":"#/components/schemas/InputTransform"},"delete_after_secs":{"type":"integer","description":"If set, delete the step's args, result and logs after this many seconds following job completion"},"summary":{"type":"string","description":"Short description of what this step does"},"mock":{"type":"object","description":"Mock configuration for testing without executing the actual step","properties":{"enabled":{"type":"boolean","description":"If true, return mock value instead of executing"},"return_value":{"description":"Value to return when mocked"}}},"suspend":{"type":"object","description":"Configuration for approval/resume steps that wait for user input","properties":{"required_events":{"type":"integer","description":"Number of approvals required before continuing"},"timeout":{"type":"integer","description":"Timeout in seconds before auto-continuing or canceling"},"resume_form":{"type":"object","description":"Form schema for collecting input when resuming","properties":{"schema":{"type":"object","description":"JSON Schema for the resume form"}}},"user_auth_required":{"type":"boolean","description":"If true, only authenticated users can approve"},"user_groups_required":{"description":"Expression or list of groups that can approve","$ref":"#/components/schemas/InputTransform"},"self_approval_disabled":{"type":"boolean","description":"If true, the user who started the flow cannot approve"},"hide_cancel":{"type":"boolean","description":"If true, hide the cancel button on the approval form"},"continue_on_disapprove_timeout":{"type":"boolean","description":"If true, continue flow on timeout instead of canceling"}}},"priority":{"type":"number","description":"Execution priority for this step (higher numbers run first)"},"continue_on_error":{"type":"boolean","description":"If true, flow continues even if this step fails"},"retry":{"description":"Retry configuration if this step fails","$ref":"#/components/schemas/Retry"},"debouncing":{"description":"Debounce configuration for this step (EE only)","type":"object","properties":{"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce this step's executions across flow runs"},"debounce_key":{"type":"string","description":"Expression to group debounced executions. Supports $workspace and $args[name]. Default: $workspace/flow/<flow_path>-<step_id>"},"debounce_args_to_accumulate":{"type":"array","description":"Array-type arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds before forced execution"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of debounces before forced execution"}}}},"required":["value","id"]},"InputTransform":{"description":"Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs","oneOf":[{"$ref":"#/components/schemas/StaticTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"StaticTransform":{"type":"object","description":"Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'","properties":{"value":{"description":"The static value. For resources, use format '$res:path/to/resource'"},"type":{"type":"string","enum":["static"]}},"required":["type"]},"JavascriptTransform":{"type":"object","description":"JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside loops, use 'flow_input.iter.value' for the current iteration value","properties":{"expr":{"type":"string","description":"JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"},"type":{"type":"string","enum":["javascript"]}},"required":["expr","type"]},"AiTransform":{"type":"object","description":"Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.","properties":{"type":{"type":"string","enum":["ai"]}},"required":["type"]},"AIProviderKind":{"type":"string","description":"Supported AI provider types","enum":["openai","azure_openai","azure_foundry","anthropic","mistral","deepseek","googleai","groq","openrouter","togetherai","customai","aws_bedrock"]},"ProviderConfig":{"type":"object","description":"Complete AI provider configuration with resource reference and model selection","properties":{"kind":{"$ref":"#/components/schemas/AIProviderKind"},"resource":{"type":"string","description":"Resource reference in format '$res:{resource_path}' pointing to provider credentials"},"model":{"type":"string","description":"Model identifier (e.g., 'gpt-4', 'claude-3-opus-20240229', 'gemini-pro')"},"reasoning_effort":{"type":"string","description":"Provider-native reasoning effort token (e.g. 'low', 'high', 'none') for models that support extended thinking. Optional; unset leaves the provider default."}},"required":["kind","resource","model"]},"StaticProviderTransform":{"type":"object","description":"Static provider configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/ProviderConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"ProviderTransform":{"description":"Provider configuration - can be static (ProviderConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticProviderTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticProviderTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"MemoryOff":{"type":"object","description":"No conversation memory/context","properties":{"kind":{"type":"string","enum":["off"]}},"required":["kind"]},"MemoryAuto":{"type":"object","description":"Automatic context management","properties":{"kind":{"type":"string","enum":["auto"]},"context_length":{"type":"integer","description":"Maximum number of messages to retain in context"},"memory_id":{"type":"string","description":"Identifier for persistent memory across agent invocations"}},"required":["kind"]},"MemoryMessage":{"type":"object","description":"A single message in conversation history","properties":{"role":{"type":"string","enum":["user","assistant","system"]},"content":{"type":"string"}},"required":["role","content"]},"MemoryManual":{"type":"object","description":"Explicit message history","properties":{"kind":{"type":"string","enum":["manual"]},"messages":{"type":"array","items":{"$ref":"#/components/schemas/MemoryMessage"}}},"required":["kind","messages"]},"MemoryConfig":{"description":"Conversation memory configuration","oneOf":[{"$ref":"#/components/schemas/MemoryOff"},{"$ref":"#/components/schemas/MemoryAuto"},{"$ref":"#/components/schemas/MemoryManual"}],"discriminator":{"propertyName":"kind","mapping":{"off":"#/components/schemas/MemoryOff","auto":"#/components/schemas/MemoryAuto","manual":"#/components/schemas/MemoryManual"}}},"StaticMemoryTransform":{"type":"object","description":"Static memory configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/MemoryConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"MemoryTransform":{"description":"Memory configuration - can be static (MemoryConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticMemoryTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticMemoryTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"FlowModuleValue":{"description":"The actual implementation of a flow step. Can be a script (inline or referenced), subflow, loop, branch, or special module type","oneOf":[{"$ref":"#/components/schemas/RawScript"},{"$ref":"#/components/schemas/PathScript"},{"$ref":"#/components/schemas/PathFlow"},{"$ref":"#/components/schemas/ForloopFlow"},{"$ref":"#/components/schemas/WhileloopFlow"},{"$ref":"#/components/schemas/BranchOne"},{"$ref":"#/components/schemas/BranchAll"},{"$ref":"#/components/schemas/Identity"},{"$ref":"#/components/schemas/AiAgent"}],"discriminator":{"propertyName":"type","mapping":{"rawscript":"#/components/schemas/RawScript","script":"#/components/schemas/PathScript","flow":"#/components/schemas/PathFlow","forloopflow":"#/components/schemas/ForloopFlow","whileloopflow":"#/components/schemas/WhileloopFlow","branchone":"#/components/schemas/BranchOne","branchall":"#/components/schemas/BranchAll","identity":"#/components/schemas/Identity","aiagent":"#/components/schemas/AiAgent"}}},"RawScript":{"type":"object","description":"Inline script with code defined directly in the flow. Use 'bun' as default language if unspecified. The script receives arguments from input_transforms","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"content":{"type":"string","description":"The script source code. Should export a 'main' function"},"language":{"type":"string","description":"Programming language for this script","enum":["deno","bun","python3","go","bash","powershell","postgresql","mysql","bigquery","snowflake","mssql","oracledb","graphql","nativets","php","rust","ansible","csharp","nu","java","ruby","rlang","duckdb"]},"path":{"type":"string","description":"Optional path for saving this script"},"lock":{"type":"string","description":"Lock file content for dependencies"},"type":{"type":"string","enum":["rawscript"]},"tag":{"type":"string","description":"Worker group tag for execution routing"},"concurrent_limit":{"type":"number","description":"Maximum concurrent executions of this script"},"concurrency_time_window_s":{"type":"number","description":"Time window for concurrent_limit"},"custom_concurrency_key":{"type":"string","description":"Custom key for grouping concurrent executions"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"},"assets":{"type":"array","description":"External resources this script accesses (S3 objects, resources, etc.)","items":{"type":"object","required":["path","kind"],"properties":{"path":{"type":"string","description":"Path to the asset"},"kind":{"type":"string","description":"Type of asset","enum":["s3object","resource","ducklake","datatable","volume"]},"access_type":{"type":"string","nullable":true,"description":"Access level for this asset","enum":["r","w","rw"]},"alt_access_type":{"type":"string","nullable":true,"description":"Alternative access level","enum":["r","w","rw"]}}}}},"required":["type","content","language","input_transforms"]},"PathScript":{"type":"object","description":"Reference to an existing script by path. Use this when calling a previously saved script instead of writing inline code","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the script in the workspace (e.g., 'f/scripts/send_email')"},"hash":{"type":"string","description":"Optional specific version hash of the script to use"},"type":{"type":"string","enum":["script"]},"tag_override":{"type":"string","description":"Override the script's default worker group tag"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"}},"required":["type","path","input_transforms"]},"PathFlow":{"type":"object","description":"Reference to an existing flow by path. Use this to call another flow as a subflow","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the subflow's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the flow in the workspace (e.g., 'f/flows/process_user')"},"type":{"type":"string","enum":["flow"]}},"required":["type","path","input_transforms"]},"ForloopFlow":{"type":"object","description":"Executes nested modules in a loop over an iterator. Inside the loop, use 'flow_input.iter.value' to access the current iteration value, and 'flow_input.iter.index' for the index. Supports parallel execution for better performance on I/O-bound operations","properties":{"modules":{"type":"array","description":"Steps to execute for each iteration. These can reference the iteration value via 'flow_input.iter.value'","items":{"$ref":"#/components/schemas/FlowModule"}},"iterator":{"description":"JavaScript expression that returns an array to iterate over. Can reference 'results.step_id' or 'flow_input'","$ref":"#/components/schemas/InputTransform"},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["forloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (faster for I/O-bound operations). Use with parallelism to control concurrency"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true. Limits resource usage. Can be static number or expression","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","iterator","skip_failures","type"]},"WhileloopFlow":{"type":"object","description":"Executes nested modules repeatedly while a condition is true. The loop checks the condition after each iteration. Use stop_after_if on modules to control loop termination","properties":{"modules":{"type":"array","description":"Steps to execute in each iteration. Use stop_after_if to control when the loop ends","items":{"$ref":"#/components/schemas/FlowModule"}},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["whileloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (use with caution in while loops)"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","skip_failures","type"]},"BranchOne":{"type":"object","description":"Conditional branching where only the first matching branch executes. Branches are evaluated in order, and the first one with a true expression runs. If no branches match, the default branch executes","properties":{"branches":{"type":"array","description":"Array of branches to evaluate in order. The first branch with expr evaluating to true executes","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch condition"},"expr":{"type":"string","description":"JavaScript expression that returns boolean. Can use 'results.step_id' or 'flow_input'. First true expr wins"},"modules":{"type":"array","description":"Steps to execute if this branch's expr is true","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules","expr"]}},"default":{"type":"array","description":"Steps to execute if no branch expressions match","items":{"$ref":"#/components/schemas/FlowModule"}},"type":{"type":"string","enum":["branchone"]}},"required":["branches","default","type"]},"BranchAll":{"type":"object","description":"Parallel branching where all branches execute simultaneously. Unlike BranchOne, all branches run regardless of conditions. Useful for executing independent tasks concurrently","properties":{"branches":{"type":"array","description":"Array of branches that all execute (either in parallel or sequentially)","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch's purpose"},"skip_failure":{"type":"boolean","description":"If true, failure in this branch doesn't fail the entire flow"},"modules":{"type":"array","description":"Steps to execute in this branch","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules"]}},"type":{"type":"string","enum":["branchall"]},"parallel":{"type":"boolean","description":"If true, all branches execute concurrently. If false, they execute sequentially"}},"required":["branches","type"]},"AgentTool":{"type":"object","description":"A tool available to an AI agent. Can be a flow module or an external MCP (Model Context Protocol) tool","properties":{"id":{"type":"string","description":"Unique identifier for this tool. Cannot contain spaces - use underscores instead (e.g., 'get_user_data' not 'get user data')"},"summary":{"type":"string","description":"Short description of what this tool does (shown to the AI)"},"value":{"$ref":"#/components/schemas/ToolValue"}},"required":["id","value"]},"ToolValue":{"description":"The implementation of a tool. Can be a flow module (script/flow) or an MCP tool reference","oneOf":[{"$ref":"#/components/schemas/FlowModuleTool"},{"$ref":"#/components/schemas/McpToolValue"},{"$ref":"#/components/schemas/WebsearchToolValue"}],"discriminator":{"propertyName":"tool_type","mapping":{"flowmodule":"#/components/schemas/FlowModuleTool","mcp":"#/components/schemas/McpToolValue","websearch":"#/components/schemas/WebsearchToolValue"}}},"FlowModuleTool":{"description":"A tool implemented as a flow module (script, flow, etc.). The AI can call this like any other flow module","allOf":[{"type":"object","properties":{"tool_type":{"type":"string","enum":["flowmodule"]}},"required":["tool_type"]},{"$ref":"#/components/schemas/FlowModuleValue"}]},"WebsearchToolValue":{"type":"object","description":"A tool implemented as a websearch tool. The AI can call this like any other websearch tool","properties":{"tool_type":{"type":"string","enum":["websearch"]}},"required":["tool_type"]},"McpToolValue":{"type":"object","description":"Reference to an external MCP (Model Context Protocol) tool. The AI can call tools from MCP servers","properties":{"tool_type":{"type":"string","enum":["mcp"]},"resource_path":{"type":"string","description":"Path to the MCP resource/server configuration"},"include_tools":{"type":"array","description":"Whitelist of specific tools to include from this MCP server","items":{"type":"string"}},"exclude_tools":{"type":"array","description":"Blacklist of tools to exclude from this MCP server","items":{"type":"string"}}},"required":["tool_type","resource_path"]},"AiAgent":{"type":"object","description":"AI agent step that can use tools to accomplish tasks. The agent receives inputs and can call any of its configured tools to complete the task","properties":{"input_transforms":{"type":"object","description":"Input parameters for the AI agent mapped to their values","properties":{"provider":{"$ref":"#/components/schemas/ProviderTransform"},"output_type":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Output format type.\nValid values: 'text' (default) - plain text response, 'image' - image generation\n"},"user_message":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"The user's prompt/message to the AI agent. Supports variable interpolation with flow.input syntax."},"system_prompt":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"System instructions that guide the AI's behavior, persona, and response style. Optional."},"streaming":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Boolean. If true, stream the AI response incrementally.\nStreaming events include: token_delta, reasoning_token_delta, tool_call, tool_call_arguments, tool_execution, tool_result\n"},"memory":{"$ref":"#/components/schemas/MemoryTransform"},"output_schema":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"JSON Schema object defining structured output format. Used when you need the AI to return data in a specific shape.\nSupports standard JSON Schema properties: type, properties, required, items, enum, pattern, minLength, maxLength, minimum, maximum, etc.\nExample: { type: 'object', properties: { name: { type: 'string' }, age: { type: 'integer' } }, required: ['name'] }\n"},"user_attachments":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Array of file references (images or PDFs) for the AI agent.\nFormat: Array<{ bucket: string, key: string }> - S3 object references\nExample: [{ bucket: 'my-bucket', key: 'documents/report.pdf' }]\n"},"max_completion_tokens":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Integer. Maximum number of tokens the AI will generate in its response.\nRange: 1 to 4,294,967,295. Typical values: 256-4096 for most use cases.\n"},"temperature":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Float. Controls randomness/creativity of responses.\nRange: 0.0 to 2.0 (provider-dependent)\n- 0.0 = deterministic, focused responses\n- 0.7 = balanced (common default)\n- 1.0+ = more creative/random\n"},"max_iterations":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Number. Limits how many times the agent can loop through reasoning and tool use.\nRange: 1-1000.\n"}},"required":["provider","user_message","output_type"]},"tools":{"type":"array","description":"Array of tools the agent can use. The agent decides which tools to call based on the task","items":{"$ref":"#/components/schemas/AgentTool"}},"type":{"type":"string","enum":["aiagent"]},"tag":{"type":"string","description":"Worker group tag for execution routing. If not set, the AI agent step runs on the flow's tag (default `flow`)"},"omit_output_from_conversation":{"type":"boolean","default":false,"description":"If true, this AI agent step does not persist its assistant or tool messages to the flow conversation when chat mode is enabled."},"parallel":{"type":"boolean","description":"If true, the agent can execute multiple tool calls in parallel"}},"required":["tools","type","input_transforms"]},"Identity":{"type":"object","description":"Pass-through module that returns its input unchanged. Useful for flow structure or as a placeholder","properties":{"type":{"type":"string","enum":["identity"]},"flow":{"type":"boolean","description":"If true, marks this as a flow identity (special handling)"}},"required":["type"]},"FlowStatus":{"type":"object","properties":{"step":{"type":"integer"},"modules":{"type":"array","items":{"$ref":"#/components/schemas/FlowStatusModule"}},"user_states":{"additionalProperties":true},"preprocessor_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"}]},"failure_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"},{"type":"object","properties":{"parent_module":{"type":"string"}}}]},"retry":{"type":"object","properties":{"fail_count":{"type":"integer"},"failed_jobs":{"type":"array","items":{"type":"string","format":"uuid"}}}}},"required":["step","modules","failure_module"]},"FlowStatusModule":{"type":"object","properties":{"type":{"type":"string","enum":["WaitingForPriorSteps","WaitingForEvents","WaitingForExecutor","InProgress","Success","Failure"]},"id":{"type":"string"},"job":{"type":"string","format":"uuid"},"count":{"type":"integer"},"progress":{"type":"integer"},"iterator":{"type":"object","properties":{"index":{"type":"integer"},"itered":{"type":"array","items":{}},"itered_len":{"type":"integer"},"args":{}}},"flow_jobs":{"type":"array","items":{"type":"string"}},"flow_jobs_success":{"type":"array","items":{"type":"boolean"}},"flow_jobs_duration":{"type":"object","properties":{"started_at":{"type":"array","items":{"type":"string"}},"duration_ms":{"type":"array","items":{"type":"integer"}}}},"branch_chosen":{"type":"object","properties":{"type":{"type":"string","enum":["branch","default"]},"branch":{"type":"integer"}},"required":["type"]},"branchall":{"type":"object","properties":{"branch":{"type":"integer"},"len":{"type":"integer"}},"required":["branch","len"]},"approvers":{"type":"array","items":{"type":"object","properties":{"resume_id":{"type":"integer"},"approver":{"type":"string"}},"required":["resume_id","approver"]}},"failed_retries":{"type":"array","items":{"type":"string","format":"uuid"}},"skipped":{"type":"boolean"},"agent_actions":{"type":"array","items":{"type":"object","oneOf":[{"type":"object","properties":{"job_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"type":{"type":"string","enum":["tool_call"]},"module_id":{"type":"string"}},"required":["job_id","function_name","type","module_id"]},{"type":"object","properties":{"call_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"resource_path":{"type":"string"},"type":{"type":"string","enum":["mcp_tool_call"]},"arguments":{"type":"object"}},"required":["call_id","function_name","resource_path","type"]},{"type":"object","properties":{"type":{"type":"string","enum":["web_search"]}},"required":["type"]},{"type":"object","properties":{"type":{"type":"string","enum":["message"]}},"required":["content","type"]}]}},"agent_actions_success":{"type":"array","items":{"type":"boolean"}}},"required":["type"]}}
\ No newline at end of file
diff --git a/system_prompts/auto-generated/skills/write-script-bun/SKILL.md b/system_prompts/auto-generated/skills/write-script-bun/SKILL.md
index e6b7e3273e..7dcaec30bc 100644
--- a/system_prompts/auto-generated/skills/write-script-bun/SKILL.md
+++ b/system_prompts/auto-generated/skills/write-script-bun/SKILL.md
@@ -626,13 +626,6 @@ async requestInteractiveSlackApproval({ slackResourcePath, channelId, message, a
  */
 async requestInteractiveTeamsApproval({ teamName, channelName, message, approver, defaultArgsJson, dynamicEnumsJson, }: TeamsApprovalOptions): Promise<void>
 
-/**
- * Parse an S3 object from URI string or record format
- * @param s3Object - S3 object as URI string (s3://storage/key) or record
- * @returns S3 object record with storage and s3 key
- */
-parseS3Object(s3Object: S3Object): S3ObjectRecord
-
 setWorkflowCtx(ctx: WorkflowCtx | null): void
 
 async sleep(seconds: number): Promise<void>
@@ -702,6 +695,17 @@ async parallel<T, R>(items: T[], fn: (item: T) => PromiseLike<R> | R, options?:
  */
 async commitKafkaOffsets(triggerPath: string, topic: string, partition: number, offset: number,): Promise<void>
 
+/**
+ * Parse an S3 object from URI string or record format
+ * @param s3Object - S3 object as URI string (`s3://storage/key`, `s3:///key`
+ *   for the default storage) or record. Any other string throws rather than
+ *   falling back to an auto-generated key: an auto key is requested by
+ *   omitting the object, and a fallback would silently misplace the upload
+ *   on any typo.
+ * @returns S3 object record with storage and s3 key
+ */
+parseS3Object(s3Object: S3Object): S3ObjectRecord
+
 /**
  * Create a SQL template function for PostgreSQL/datatable queries
  * @param name - Database/datatable name (default: "main")
diff --git a/system_prompts/auto-generated/skills/write-script-bunnative/SKILL.md b/system_prompts/auto-generated/skills/write-script-bunnative/SKILL.md
index 8ef23a996c..86c3bfd010 100644
--- a/system_prompts/auto-generated/skills/write-script-bunnative/SKILL.md
+++ b/system_prompts/auto-generated/skills/write-script-bunnative/SKILL.md
@@ -626,13 +626,6 @@ async requestInteractiveSlackApproval({ slackResourcePath, channelId, message, a
  */
 async requestInteractiveTeamsApproval({ teamName, channelName, message, approver, defaultArgsJson, dynamicEnumsJson, }: TeamsApprovalOptions): Promise<void>
 
-/**
- * Parse an S3 object from URI string or record format
- * @param s3Object - S3 object as URI string (s3://storage/key) or record
- * @returns S3 object record with storage and s3 key
- */
-parseS3Object(s3Object: S3Object): S3ObjectRecord
-
 setWorkflowCtx(ctx: WorkflowCtx | null): void
 
 async sleep(seconds: number): Promise<void>
@@ -702,6 +695,17 @@ async parallel<T, R>(items: T[], fn: (item: T) => PromiseLike<R> | R, options?:
  */
 async commitKafkaOffsets(triggerPath: string, topic: string, partition: number, offset: number,): Promise<void>
 
+/**
+ * Parse an S3 object from URI string or record format
+ * @param s3Object - S3 object as URI string (`s3://storage/key`, `s3:///key`
+ *   for the default storage) or record. Any other string throws rather than
+ *   falling back to an auto-generated key: an auto key is requested by
+ *   omitting the object, and a fallback would silently misplace the upload
+ *   on any typo.
+ * @returns S3 object record with storage and s3 key
+ */
+parseS3Object(s3Object: S3Object): S3ObjectRecord
+
 /**
  * Create a SQL template function for PostgreSQL/datatable queries
  * @param name - Database/datatable name (default: "main")
diff --git a/system_prompts/auto-generated/skills/write-script-deno/SKILL.md b/system_prompts/auto-generated/skills/write-script-deno/SKILL.md
index 9b1b04fa89..f7f3a517db 100644
--- a/system_prompts/auto-generated/skills/write-script-deno/SKILL.md
+++ b/system_prompts/auto-generated/skills/write-script-deno/SKILL.md
@@ -626,13 +626,6 @@ async requestInteractiveSlackApproval({ slackResourcePath, channelId, message, a
  */
 async requestInteractiveTeamsApproval({ teamName, channelName, message, approver, defaultArgsJson, dynamicEnumsJson, }: TeamsApprovalOptions): Promise<void>
 
-/**
- * Parse an S3 object from URI string or record format
- * @param s3Object - S3 object as URI string (s3://storage/key) or record
- * @returns S3 object record with storage and s3 key
- */
-parseS3Object(s3Object: S3Object): S3ObjectRecord
-
 setWorkflowCtx(ctx: WorkflowCtx | null): void
 
 async sleep(seconds: number): Promise<void>
@@ -702,6 +695,17 @@ async parallel<T, R>(items: T[], fn: (item: T) => PromiseLike<R> | R, options?:
  */
 async commitKafkaOffsets(triggerPath: string, topic: string, partition: number, offset: number,): Promise<void>
 
+/**
+ * Parse an S3 object from URI string or record format
+ * @param s3Object - S3 object as URI string (`s3://storage/key`, `s3:///key`
+ *   for the default storage) or record. Any other string throws rather than
+ *   falling back to an auto-generated key: an auto key is requested by
+ *   omitting the object, and a fallback would silently misplace the upload
+ *   on any typo.
+ * @returns S3 object record with storage and s3 key
+ */
+parseS3Object(s3Object: S3Object): S3ObjectRecord
+
 /**
  * Create a SQL template function for PostgreSQL/datatable queries
  * @param name - Database/datatable name (default: "main")
diff --git a/system_prompts/auto-generated/skills/write-script-python3/SKILL.md b/system_prompts/auto-generated/skills/write-script-python3/SKILL.md
index 4aee54e29a..49c0ab057f 100644
--- a/system_prompts/auto-generated/skills/write-script-python3/SKILL.md
+++ b/system_prompts/auto-generated/skills/write-script-python3/SKILL.md
@@ -711,7 +711,11 @@ def get_state_path() -> str
 # Parse resource syntax from string.
 def parse_resource_syntax(s: str) -> Optional[str]
 
-# Parse S3 object from string or S3Object format.
+# Parse S3 object from a `s3://<storage>/<key>` URI string (`s3:///<key>`
+# for the default storage) or S3Object format. Any other string raises
+# rather than falling back to an auto-generated key: an auto key is
+# requested by omitting the object, and a fallback would silently misplace
+# the upload on any typo.
 def parse_s3_object(s3_object: S3Object | str) -> S3Object
 
 # Parse variable syntax from string.
diff --git a/typescript-client/client.ts b/typescript-client/client.ts
index 8b6117fef1..5d2342471b 100644
--- a/typescript-client/client.ts
+++ b/typescript-client/client.ts
@@ -16,10 +16,12 @@ import { OpenAPI } from "./core/OpenAPI";
 import {
   DenoS3LightClientSettings,
   S3ObjectRecord,
+  parseS3Object,
   type S3Object,
 } from "./s3Types";
 
 export {
+  parseS3Object,
   type S3Object,
   type S3ObjectRecord,
   type S3ObjectURI,
@@ -1505,17 +1507,6 @@ function parseResourceSyntax(s: string | undefined) {
   if (s?.startsWith("res://")) return s.substring(6);
 }
 
-/**
- * Parse an S3 object from URI string or record format
- * @param s3Object - S3 object as URI string (s3://storage/key) or record
- * @returns S3 object record with storage and s3 key
- */
-export function parseS3Object(s3Object: S3Object): S3ObjectRecord {
-  if (typeof s3Object === "object") return s3Object;
-  const match = s3Object.match(/^s3:\/\/([^/]*)\/(.*)$/);
-  return { storage: match?.[1] || undefined, s3: match?.[2] ?? "" };
-}
-
 function parseVariableSyntax(s: string) {
   if (s.startsWith("var://")) return s.substring(6);
 }
diff --git a/typescript-client/jsr.json b/typescript-client/jsr.json
index afcb96626d..a47fa427c2 100644
--- a/typescript-client/jsr.json
+++ b/typescript-client/jsr.json
@@ -1,6 +1,6 @@
 {
   "name": "@windmill/windmill",
-  "version": "1.747.0",
+  "version": "1.749.0",
   "exports": "./src/index.ts",
   "publish": {
     "exclude": ["!src", "./s3Types.ts", "./sqlUtils.ts", "./client.ts"]
diff --git a/typescript-client/package.json b/typescript-client/package.json
index d8058153be..c142b1b01a 100644
--- a/typescript-client/package.json
+++ b/typescript-client/package.json
@@ -1,7 +1,7 @@
 {
   "name": "windmill-client",
   "description": "Windmill SDK client for browsers and Node.js",
-  "version": "1.747.0",
+  "version": "1.749.0",
   "author": "Ruben Fiszel",
   "license": "Apache 2.0",
   "homepage": "https://github.com/windmill-labs/windmill/tree/main/typescript-client#readme",
diff --git a/typescript-client/s3Types.d.ts b/typescript-client/s3Types.d.ts
index 4903edc8ff..57a4af2222 100644
--- a/typescript-client/s3Types.d.ts
+++ b/typescript-client/s3Types.d.ts
@@ -14,3 +14,4 @@ export type DenoS3LightClientSettings = {
     secretKey?: string;
     pathStyle?: boolean;
 };
+export declare function parseS3Object(s3Object: S3Object): S3ObjectRecord;
diff --git a/typescript-client/s3Types.ts b/typescript-client/s3Types.ts
index e9af9b2d30..d2049570f8 100644
--- a/typescript-client/s3Types.ts
+++ b/typescript-client/s3Types.ts
@@ -4,7 +4,8 @@
 export type S3Object = S3ObjectURI | S3ObjectRecord;
 
 /**
- * S3 object URI in the format `s3://storage/key`
+ * S3 object URI in the format `s3://storage/key` (`s3:///key` targets the
+ * workspace default storage)
  */
 export type S3ObjectURI = `s3://${string}/${string}`;
 
@@ -39,3 +40,26 @@ export type DenoS3LightClientSettings = {
   /** Use path-style URLs instead of virtual-hosted style */
   pathStyle?: boolean;
 };
+
+/**
+ * Parse an S3 object from URI string or record format
+ * @param s3Object - S3 object as URI string (`s3://storage/key`, `s3:///key`
+ *   for the default storage) or record. Any other string throws rather than
+ *   falling back to an auto-generated key: an auto key is requested by
+ *   omitting the object, and a fallback would silently misplace the upload
+ *   on any typo.
+ * @returns S3 object record with storage and s3 key
+ */
+export function parseS3Object(s3Object: S3Object): S3ObjectRecord {
+  if (typeof s3Object === "object") return s3Object;
+  const match = s3Object.match(/^s3:\/\/([^/]*)\/(.+)$/);
+  if (match) return { storage: match[1] || undefined, s3: match[2] };
+  if (s3Object.startsWith("s3://")) {
+    throw new Error(
+      `Invalid s3 object URI ${JSON.stringify(s3Object)}: expected s3://<storage>/<key> with a non-empty key (s3:///<key> for the default storage)`
+    );
+  }
+  throw new Error(
+    `Invalid s3 object ${JSON.stringify(s3Object)}: expected an s3://<storage>/<key> URI (e.g. "s3:///${s3Object}" for key "${s3Object}" in the default storage) or { s3: <key> }`
+  );
+}
diff --git a/typescript-client/tests/s3Types.test.ts b/typescript-client/tests/s3Types.test.ts
new file mode 100644
index 0000000000..6f67a6493c
--- /dev/null
+++ b/typescript-client/tests/s3Types.test.ts
@@ -0,0 +1,52 @@
+import { describe, expect, test } from "bun:test";
+import { parseS3Object } from "../s3Types";
+
+describe("parseS3Object", () => {
+  test("bare string throws with the s3:/// hint", () => {
+    // A bare key is rejected rather than silently uploading under an
+    // auto-generated name; the error points at the s3:/// spelling.
+    expect(() => parseS3Object("dir/file.json" as any)).toThrow(
+      /s3:\/\/\/dir\/file\.json/
+    );
+  });
+
+  test("triple-slash URI targets the default storage", () => {
+    expect(parseS3Object("s3:///dir/file.json")).toEqual({
+      storage: undefined,
+      s3: "dir/file.json",
+    });
+  });
+
+  test("full URI splits storage and key", () => {
+    expect(parseS3Object("s3://bucket/dir/f")).toEqual({
+      storage: "bucket",
+      s3: "dir/f",
+    });
+  });
+
+  test("malformed s3:// URI throws", () => {
+    // `s3://x` has no key part — fail loudly instead of silently misplacing
+    // the object.
+    expect(() => parseS3Object("s3://broken" as any)).toThrow(
+      /Invalid s3 object/
+    );
+  });
+
+  test("empty-key URIs throw", () => {
+    // An empty key is never a valid target: it would fall back to an
+    // auto-generated key, which is requested by omitting the object.
+    expect(() => parseS3Object("s3:///" as any)).toThrow(/Invalid s3 object/);
+    expect(() => parseS3Object("s3://bucket/")).toThrow(/Invalid s3 object/);
+  });
+
+  test("empty string throws (omit the object for an auto-generated key)", () => {
+    expect(() => parseS3Object("" as any)).toThrow(/Invalid s3 object/);
+  });
+
+  test("record form passes through", () => {
+    expect(parseS3Object({ s3: "x", storage: "b" })).toEqual({
+      s3: "x",
+      storage: "b",
+    });
+  });
+});
diff --git a/version.txt b/version.txt
index 8eff60cc0e..1575293753 100644
--- a/version.txt
+++ b/version.txt
@@ -1 +1 @@
-1.747.0
+1.749.0