From 032300e28eba9f8e790f16e894bb00fff22eb296 Mon Sep 17 00:00:00 2001
From: Ruben Fiszel <ruben@windmill.dev>
Date: Sat, 1 Aug 2026 13:58:05 +0200
Subject: [PATCH] feat: run dbt projects as a first-class Windmill runtime
 (#10326)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* fix: mount only the engine in the dbt jail, reject shadowed and malformed args

Review round 42.

The jail mounted the whole dbt cache directory, whose siblings of the
engine are `repos/` and `packages/` — other workspaces' private checkouts
and package trees, kept apart by cache key rather than by permissions. A
jailed project could read them. It now mounts the engine's own directory,
which the provisioner names; verified from inside the jail that `repos/`,
`packages/` and `state/` are invisible while the engine stays usable.

A `{{ placeholder }}` may no longer take the name of a run argument this
runtime defines. It was silently dropped from the signature, so a
descriptor like `value: "{{ select }}"` deployed and then could not be
run at all: the built-in `select` is an array and the interpolation needs
a scalar. Refused at parse, so the deploy says so.

A `vars` override that is not an object is refused rather than ignored.
Argument-schema validation is opt-in, so a string or an array silently
ran the descriptor's own vars — against a different schema or alias than
the caller asked for. `select` and `exclude` already refused theirs.

* feat(dbt): the project is the script's module bundle, not a git checkout

A dbt script now carries its whole dbt project as its module bundle. The
descriptor is the script content; `<script>__dbt/` holds the project verbatim,
so importing an existing project is `cp -r` plus `wmill sync push`, and the
worker materialises the bundle into the job directory instead of cloning.

Backend
- `prepare_project` writes the script's modules and requires `dbt_project.yml`
  at the bundle root. `checkout`, the git-ssh command, the clone cache and the
  repository resource are gone, along with `repo`, `project`, `ref` and
  `git_ssh_identity` on the descriptor.
- Run identity and the package cache key take a `project_digest` (sorted SHA256
  over the bundle) where the commit used to sit, so an edited project cannot
  resume a previous run's `run_results.json` or reuse its `dbt_packages`.
- The per-run graph re-ingest is now gated on `vars` placeholders and `$var:`
  env alone.
- `capture_dependency_job` takes the script's modules so a dependency job, which
  has no generic module-writing step, materialises them itself.
- `dbt deps` caching strips the git remote from every package it cached, not
  just the tree root: `packages.yml` can render a token into a `git:` URL.
- `git_clone.rs` is dropped and `ansible_executor.rs` returns to its own copy of
  the clone helpers.

CLI
- `wmill sync pull` keeps a dbt script's lock beside its folder rather than
  inside it, so the folder holds nothing but the project.
- Directories dbt generates (`target-path`, `packages-install-path`,
  `clean-targets` and the usual defaults, read from `dbt_project.yml`) are
  excluded from the bundle, from the sync diff and from staleness hashing.
- A module-only edit now pushes its parent dbt script and is reported as a
  changed module rather than passing unnoticed.

* fix: keep a script's modules in the worker's file-system cache

The first fetch of a script version reads the database and carries its
modules; every later fetch imports from the worker's cache directory, whose
`RawScript::import` hard-coded `modules: None` and whose `export` never wrote
them. A worker restart therefore started running the script without its own
files, silently — for a dbt script, without its project, which fails with
"carries no project"; for any other script with a module bundle, with the
imports missing.

`modules.json` is now written on every export and required on import, so an
entry written by an older version fails to import and is refetched rather than
serving a stripped script for as long as the directory lives.

Also derives a dbt run's `project_digest` from the bundle the run actually
carries: `handle_dbt_job` was passing `None`, which collapsed every project in
a workspace onto one digest and let `dbt retry` resume a different project's
`run_results.json`.

* fix(dbt): give every phase the script's environment, bound the cache copies

`dbt deps` ran without the script's environment variables on an unsandboxed
worker, so a `packages.yml` resolving a private package URL through
`env_var()` could not see them while the package cache key was still built on
their digest. `with_invocation_env`, applied at three of the four call sites,
is folded into `dbt_command` so no phase can be added without it, and
`DBT_TARGET_PATH` is set after both environments rather than before.

The package cache copies ran through a bare `Command::output()`: the tree is
the project's, so a cancelled or timed-out job held its worker slot until `cp`
finished. Both the restore and the publish now run under the job poller like
every other phase.

* fix(dbt): only offer commands whose writes match the graph, honour packages-install-path

`dbt_command: run` is dropped from the allowed overrides. Asset dispatch fires a
script's deploy-time writes on any successful job, and `dbt run` covers models
only, so a project with seeds or snapshots notified consumers of relations the
invocation left stale. That is the same reason `test` was already excluded.
Narrowing what a run touches is `select`/`exclude`, which scope the graph too.

`dbt deps` writes to the project's `packages-install-path`, so a project that
moved it got no package cache at all: the publish found nothing at
`dbt_packages` and every job resolved its dependencies over the network again.
The path is read from `dbt_project.yml` and validated as project-relative,
since both cache copies are rooted at it.

Also states the sidecar's mutator contract at the module level: the dbt manifest
tables carry no RLS and grant `windmill_user` full access, so a user-scoped
transaction is not enforcement and every caller must have verified write access
to the script itself.

CLI: a module file is now grouped with its parent script for the push. Left in
a group of its own it got its own `alreadySynced`, so a push touching several
files of one bundle deployed the script once per file; the resulting versions
raced, and the asset graph could end up describing none of them.

* fix(dbt): seed a project for browser-created scripts, refuse a no-op retry

A dbt script created in the browser only got a descriptor, and the runtime
refuses a script whose bundle has no `dbt_project.yml`, so the advertised
Create → Deploy → Run path always failed its dependency job. New dbt scripts
now start with a project that builds: pointing `profile.resource` at a
warehouse is the one edit, and growing it is `wmill sync pull` plus a local
editor, which is where dbt development happens.

`dbt retry` builds its graph from the previous run's error, fail and skipped
nodes alone, so retrying an all-green run selected nothing and wrote nothing —
and a job that succeeds having written nothing still dispatches every
deploy-time write, waking every downstream consumer for relations no one
touched. Refused, with the reason.

CLI: a configured `target-path` or `packages-install-path` may be nested
(`build/target`), and `clean-targets` has a block form as well as an inline
one. Both are now parsed, and the exclusion compares the project-relative path
rather than the top-level segment, so a nested generated tree no longer lands
in the bundle and no longer makes a local `dbt run` look like a project change.

* fix(dbt): lock a project once, find the parent on either path separator

A dbt script's modules are its dbt project, not helper code with dependencies
of its own, so the generic per-module lock loop is skipped for it: the parent
lock already ran `dbt deps` and `dbt parse` over the whole project. Locking
each file separately re-materialised the bundle and re-invoked dbt once per
file, so a project of N files paid N project-sized passes and a large one timed
the deploy out. The 13-file fixture went from 14 relock passes to 1.

`pushParentScriptForModule` searched the raw path for `__dbt/`, so on Windows,
where the folder is spelled `__dbt\`, a module-only edit returned without
deploying its parent while the caller still recorded the file as synced. It now
goes through `getScriptBasePathFromModulePath`, which normalizes separators.

Also drops the last of the external-repository wording from the descriptor's
module docs and from the `codebase` rejection a user can hit.

* feat(dbt): infer the run form locally, keep test-only retries from cascading

`windmill-parser-wasm-yaml` 1.770.0 carries `parse_dbt`, so the browser and the
CLI derive a dbt script's run arguments from its descriptor instead of waiting
for the deploy to hand back a schema. Pins bumped in both.

`generate-metadata` was rewriting a dbt script's `lock` field on every run: a
dbt lock comes from the dependency job on a worker, so nothing generates it
locally and the resolved `!inline` reference was left inlined into the metadata
or blanked. It is restored instead, and a push straight after
`generate-metadata` is a no-op again.

A retry now needs a failed node that materialises something. `dbt retry` builds
its graph from error, fail and skipped nodes, and with `test_behavior:
after_all` a failing test is what `run_results.json` ends up describing — so the
retry reran tests, wrote nothing, succeeded, and still dispatched every
deploy-time write.

The dbt badge's destination is deterministic: writers outrank readers, and among
several writers of one relation (which the backend permits) the smallest id
wins, rather than whichever write edge arrived last.

* feat(dbt): browse the project and read a run's per-node result

Two views a dbt user expects and that the generic script surfaces do not give.

**The project.** A dbt script's editor gains a Project tab beside its
descriptor: the module bundle as the tree dbt itself expects, each file
read-only with syntax highlighting. The existing module tab strip is a flat row
built for a couple of helper files and does not survive a real project; a
13-file fixture already overflows it. Directories sort before files so it reads
like the checkout on disk, and an empty bundle explains the `cp -r` instead of
showing a blank pane.

**The run.** `DisplayResult` renders a dbt invocation's per-node breakdown above
the raw payload: totals, then a table of node, kind, target relation, rows and
time, with failures and warnings sorted first and carrying their message. The
data was already structured; it was being shown as JSON to scroll and PASS/WARN
counts to find in the log. On a failed run the same JSON rides in the error
message after the exit-status line, so it is parsed back out — that is the case
worth rendering, since the failing node is what the user came for.

* docs(dbt): say that profile.resource is what buys the asset graph

The starter descriptor described `profile.resource` as the thing rendered into
profiles.yml, with the project's own file as an equal alternative. It is not
equal: the resource PATH is the warehouse's identity in the asset graph, so a
project bringing its own profiles.yml runs fine and silently gets no assets, no
lineage and no cascade. The deploy already says so in its log; now the
descriptor a user starts from says it too, before they choose.

* fix(dbt): authorize a resource used only for asset identity, clean up after failed installs

A descriptor setting both `profile.profiles_yml` and `profile.resource` took
its connection from the project's file but returned the resource path as the
graph's warehouse identity without ever reading it. A script editor could
therefore publish `table://<any resource>/...` writes, and wake that
warehouse's subscribers, while connecting somewhere else. The resource is now
read on that path too — reading is what authorizes it — so the combination
keeps working for the case that wants it (keep your own profiles.yml, still get
lineage) and fails closed otherwise.

Provisioning cleaned up its staging directory only on the paths someone
remembered, so a run of failed or cancelled first-use installs accumulated
venvs, tarballs and installer scripts until the worker's disk was gone. All
three engines now hold their scratch paths in a guard that removes them on
drop, which is the one exit every path takes, cancellation included.

Frontend: `partial success` is dbt's word for a node that built but whose tests
failed, counted in `totals.error` and redone by a retry, so it ranks with the
failures instead of rendering green with its message hidden. And the run panel
now keys off the worker's engine discriminator rather than `{nodes, totals}`,
which is a shape an ordinary script can return. Both pinned by unit tests on
the extracted `parseDbtRun` helpers.

* feat(dbt): show a run's models on the run page

The run page is where you land on a running job, and until now it showed a dbt
run as streaming text: the per-node table only renders once the job has
produced a result, and the graph that moves per model lived on the pipeline
page you had to navigate to. A Models section now sits above the result,
scoped to the running script's own relations and its `ref()` lineage, polling
while the job is in flight so nodes move as dbt walks the DAG.

No `resolveGraph`: that merges drafts and live editor buffers into the
persisted graph, and a run page has neither.

* feat(dbt): retry failed nodes automatically, and from any worker

**Node-level retry, in the job.** `retry_failed_nodes: {attempts, delay_seconds}`
rebuilds only what a failed build left failed or skipped, before the job reports
failure. dbt confines a failure to its own subtree and `dbt retry` resumes
exactly that set, so a transient warehouse error costs those nodes rather than
the project. Doing it in-job is what keeps the state question out of it: the
previous attempt's `run_results.json` is still in the job directory, so there is
nothing to persist and no worker to land back on. This is the granularity
astronomer-cosmos gets from one Airflow task per model, without the ~6x that
per-model tasks measured.

A retry's `run_results.json` names only the nodes it redid, so it overlays the
accumulated results rather than replacing them: the job's result has to be every
node the job touched, or the nodes that succeeded before the retry settle no
materializations. Pinned by a test.

**Durable retry state.** `run_results.json` is now saved to `dbt_run_state` as
well as the worker's local cache, so an explicit `dbt_command: retry` works from
any worker of the group rather than only the one that failed. Only the results
are stored: `dbt retry` also needs `manifest.json`, roughly sixty times larger
and growing with the project (732 KB against 12 KB on the six-node fixture), but
the manifest is a pure function of the project files, vars and env, all of which
the stored identity already pins, so a worker restoring from the database
re-derives it with a `dbt parse` of about a second.

* fix(dbt): restore the sqlx cache, make retries cancellable and path-aware

**SQLx cache.** A `cargo sqlx prepare` deleted 750 entries, including the
enterprise queries CI needs under `SQLX_OFFLINE=true`, and the check that was
supposed to catch it reported zero losses because it was run from `backend/`
with a `backend/`-prefixed path, so its baseline was empty and it failed open.
All 750 are restored; the branch now adds 19 and deletes none, and
`SQLX_OFFLINE=true cargo check` passes.

**Retry backoff observes cancellation.** `canceled_by` is only written by the
job poller, which does not run between attempts, so re-reading it reported the
state as of the failed attempt and missed every cancel issued during the wait
— the whole window the check exists to cover. The wait now reads
`v2_job_queue.canceled_by` each second, and the job's deadline is honoured
before starting another dbt process.

**Retry state follows its script.** `dbt_run_state` is path-keyed like the
manifest sidecar but, unlike it, nothing regenerates it: a rename moves the row
so a resumable failure survives, while archive and delete clear it, so a script
later created at that path cannot inherit a stranger's failure and its
arguments.

**CLI.** `table` joins ducklake and s3object in the local graph's auto-trigger
kinds, matching `is_auto_trigger_kind` and the frontend's set; without it a
local graph and the generated docs omitted a cascade edge the deploy has.

* fix(dbt): carry only the project files a bundle can hold, and say what it drops

Exploring real and edge-case projects surfaced three frictions, all in the
import path a user hits first.

**A binary file broke the push, opaquely.** dbt projects carry images under
`docs/`, stray `.DS_Store` files and occasionally a parquet seed. Read as text
they become mojibake, and a NUL among them is rejected by Postgres with
`unsupported Unicode escape sequence` — which `wmill sync push` then reported as
success, exiting 0 with the script never created. Binary files are now detected
the way `git` detects them, by a NUL in the first 8000 bytes rather than by
extension, and skipped with the reason.

**The size guard the docs promised did not exist.** Now it does: 5 MB per file,
which only ever catches a committed dataset. Real dbt code is about 500 bytes
median and 1.9 KB at p90.

**Skipped files became a permanent phantom diff.** The push dropped them while
the sync diff still offered them, so every push reported changes no push could
resolve. One predicate now answers for the push, the staleness hash and the
diff.

Verified on a project with unicode filenames and content, CRLF endings, an
empty model, an ephemeral model, a disabled model, a `.md` docs block, an
extensionless README, six levels of nesting, a 7.6 MB seed and a PNG: it
pushes, round-trips byte-for-byte through pull, deploys to 7 dbt nodes and 6
`table://` assets (ephemeral and disabled correctly absent), and runs green.

* fix(dbt): resolve dbt-core against the adapter, settle partial success, unify status

**Adapters could not be provisioned.** The 1.x engine pinned `dbt-core` to a
fixed version independent of the adapter, but several adapters cap below it:
`dbt-mysql` at `~=1.7`, `dbt-oracle` and `dbt-databricks` below 1.12, and
`dbt-salesforce` has no package at all (it exists only inside Fusion). Those
projects failed at provisioning with a uv resolver dump. The install now asks
for a range and lets the adapter choose, and records what the resolver picked so
the lock pins a version that adapter can take.

The floor is the CLI this runtime invokes: resolving down to dbt-core 1.7
produced a working venv that then failed with `No such option '--target'`, which
is worse than not resolving. An adapter with no release in range now fails
naming itself and pointing at `dbt-core-2x` or `fusion`, instead of a resolver
dump. Salesforce is refused up front with the reason.

**`partial success` left a model stuck on `Running`.** It is dbt's word for a
node that built and then failed its tests, and it was already treated as a
failure when counting totals and deciding a retry — but the two sites that
settle the RELATION fell through to "says nothing", so the tailer's `Running`
was never replaced and a finished job showed a model still building. Six status
comparisons had drifted apart, two folding case and four not, while dbt-core 1.x
echoes the author's casing and 2.x uppercases; they are now one classifier.

**Agent workers.** The durable retry state and the cancellation poll both need a
database, which an agent worker reaches only through the API. The automatic node
retry is refused there rather than running a wait it could not interrupt, and
the docs say "any worker with a database connection" instead of overclaiming.

Also clears `dbt_run_state` when a path stops being a dbt script, and moves
`run_identity`'s contract onto `run_identity` from the digest helper below it.

* feat(dbt): show the transform behind a model on the run graph

The run page's graph carried a node for the script itself and drew every
relation as a bare table. Both were wrong for that page: the graph there is
already scoped to one script, so a node standing for it distinguishes nothing
(on the pipeline page it separates one project from another, which is why it
exists), and dbt's own DAG node is the model — the SQL and the relation it
writes are one thing, so a graph of relations alone leaves out what a reader
came to see.

The script node is dropped, and selecting a model now shows its SQL underneath
the canvas with its file path and materialization, read-only, the same view the
pipeline details pane gives.

* feat(dbt): move the graph with the run

The worker has always recorded a state per relation as dbt walks the DAG —
`running` when a model starts, `materialized` or `failed` when it ends — but
nothing rendered it: the graph response carries what a relation IS, not what a
particular run is doing to it, so the canvas had nothing to show and a running
job looked identical to a finished one.

`assets/run_progress/{job_id}` returns that state for one job, the run page
polls it beside the graph, and the asset node carries a spinner or its outcome.
Errors and retries need nothing extra: a failed node writes `failed`, and an
in-job retry rewrites the same row, so the node returns to `running` and on to
its new outcome by itself.

`materialized_partition` holds a relation's CURRENT state keyed by relation, so
filtering on `job_id` returns exactly what this run last touched — which is the
question a run page asks, and why a superseded older run shows nothing.

* feat(dbt): a dbt project is not a data pipeline

Deploying a dbt script marked it `auto_kind = 'pipeline'`, which enrolled it
in pipeline membership: the folder became a Pipeline entry on the home page,
the script folded into it, and `/pipeline/<folder>` opened a canvas holding
the project's whole model DAG next to the pipeline's own scripts. A folder
holding both then read as two projects in one editor, and the pipeline editor
offered to author transforms that are in fact authored in a local `dbt run`
loop and pushed as the script's bundle.

A dbt script is now never a pipeline member, and the pipeline canvas drops the
dbt script node. Its models stay, with their `ref()` lineage: the relations are
what a downstream pipeline script reads, and dropping them would break the
cascade from a dbt run — the point of giving dbt models `table://` identity.

Also drops a screenshot committed to this branch by accident.

* fix(dbt): authorize run_progress through the job, drop dbt from the local graph

`run_progress` read `materialized_partition` through `user_db` on the
assumption that RLS would scope the rows. That table has RLS disabled and no
policies, so any workspace member could pass a job id and read that run's
relation paths, row counts and error text. It now joins `v2_job`, which does
carry per-user policies, so a caller who cannot see the job sees nothing —
the same pattern `v2_job_completed` reads need. Verified as a plain member:
the old query returned 6 rows for another user's run, the new one returns 0,
while the job's owner still sees all 6.

The CLI's local graph still forced `in_pipeline` on every dbt script, so
`pipeline docs --local` and `pipeline dev` kept presenting a dbt project as a
pipeline the deploy no longer enrolls. It now skips them, matching the server.
A dbt descriptor has no asset parser locally, so nothing is lost: its models
come from the manifest the deploy derives.

Declares `run_progress` in openapi.yaml so the frontend uses the generated
client instead of a handwritten fetch; the generated `status` union also
replaces a hand-rolled string mapping.

* fix(dbt): drop the dbt node from the CLI's deployed pipeline views too

`pipeline dev` and `pipeline docs` (without `--local`) read `/assets/graph`
directly. That endpoint is asset-usage driven rather than membership driven, so
it returns a dbt script like any producer — and both commands render every
runnable, so a dbt project still showed up as a pipeline script there after the
local builder stopped emitting one.

`hideDbtRunnables` mirrors the frontend's projection of the same payload. It is
generic over the graph shape so the bounded-cascade view (`BCGraph`, a narrower
type over identical JSON) passes through without a cast.

The relations stay: they are what a downstream pipeline script reads, and the
node is what attributes them to a producer for every other consumer of the
endpoint, so the filter belongs in the views rather than the query.

* fix(dbt): narrow a selective run's cascade, settle the finished run graph

Review-round fixes.

A `select`/`exclude` run builds part of the project, but asset dispatch reads
the deploy-time write set for the whole script, so a run selecting one model
woke the subscribers of every other. Dispatch now intersects that set with the
relations the run actually recorded as materialized, scoped to dbt because it is
the only producer whose write set is decided per run. A run that recorded
nothing still dispatches everything, so an agent worker whose reconciliation
failed cascades as before. Verified both ways: `select: [extra_model]` no longer
wakes the `fct_orders` subscriber, and a full run still does.

`hideDbtRunnables` keyed its removal set on path alone while the graph keys
runnables by `(usage_kind, path)`, so a flow sharing a path with a dbt script
lost its node, edges and triggers too. Both copies now key on the pair.

The run graph never took a final reading when a job finished, so the last state
shown was whatever the tick before completion saw. Only `dbt-core-1x` streams
node events; the other engines record every relation during end-of-run
reconciliation, so their finished graph showed nothing until a reload.

`DbtNodeOutcome::Inconclusive` collapsed statuses the tally has to tell apart,
so two sites re-lowercased the status beside the classifier and `no-op` landed
in `totals.error` — a clean run reporting an error in its own result. Split into
Warn / Skipped / NoOp / Unknown so every site falls out of one match; `no-op` is
kept out of the retry set, which dbt spells as error / fail / skipped.

Also: reattach two doc comments to the items they describe, and correct the
engine-distribution table — only dbt-core-2x is baked into the images, 1.x is a
per-adapter venv provisioned on first use, and the default is compiled in rather
than an instance setting.

* fix(dbt): make the model chip inert where its project node is not on the graph

The canvas passed `onDbtSelect` unconditionally, so the chip always rendered
`cursor-pointer` and hover-highlighted — but the owner map is empty on both
graphs this feature added, since the run page carries no runnables and the
pipeline page hides the dbt node. The chip advertised a click that resolved to
nothing. It now takes its handlers only when the relation has an owner on this
graph, so it stays live on the surfaces that do show the project node.

`classify_status` and `DbtNodeOutcome` were `pub` in a private module with no
caller outside the file, unlike every neighbour.

* fix(dbt): take the cascade's write set from the run's own result

The previous narrowing read `materialized_partition`, which was wrong twice.

That table keeps one row per relation and the newest writer takes `job_id`, so
two overlapping runs over the same model erase each other's claim to it: the
earlier job would dispatch a subset of what it built, or none of it.

And an empty row set was read as "recording failed, dispatch everything" when it
is also a real answer. A `select` matching no model, or one resolving to tests
only, exits 0 having built nothing — and then woke every consumer of every model
in the project, which is the opposite of what the narrowing exists to do and is
reachable by a typo in a run argument.

The run now reports the relations it materialized in its own result, which is
immutable and per job. Absent means the producer said nothing (a job from before
the field, a non-dbt producer) and the whole deploy-time set dispatches as
before; present-and-empty means it built nothing and dispatches nothing.

Verified on all three: an unmatched selector builds nothing and wakes nobody, a
selector naming one unsubscribed model wakes nobody, and a full run wakes the
subscriber.

Also indexes `materialized_partition (workspace_id, job_id)` -- the run page
polls that shape every 2s and no existing index leads with `job_id` -- corrects
the selective-cascade section of the design doc, which still described the old
deploy-time behavior, and reattaches `buildLocalPipelineGraph`'s doc comment.

* docs(dbt): attach the CLI JSDoc to its function, correct the index rationale

The `hideDbtRunnables` JSDoc ended up documenting the type declared beneath it —
made while fixing the same mistake one function down.

The migration's comment credited the cascade with a `job_id` lookup that the
same commit replaced with a read of the job's own result. The run page's poll is
the only reader keyed on that column.

* fix(dbt): refuse graph publication for a removed script, allow test-only retries

An archived or hard-deleted script could still republish its graph: the
publication guard filtered `deleted` but not `archived`, and treated a missing
row as "nothing newer exists" rather than "nothing left to publish for". A
dependency job or dynamic run finishing after the removal put the asset,
provenance and subscription rows back with nothing left to clear them.

`dbt_command: retry` refused a run whose only failures were tests, which is
precisely what `test_behavior: after_all` produces. That restriction existed
because a successful job dispatched its whole deploy-time write set, so a
test-only retry would have woken every consumer for relations no one touched —
the cascade now dispatches what the run reports materializing, so it wakes
nobody and the restriction only blocked a legitimate retry.

* fix(dbt): gate run progress behind the job-read check, not RLS alone

The endpoint joined `v2_job` so RLS would decide visibility, which it does — but
`require_job_read_access` adds two things RLS does not: a scoped token's
`if_jobs:filter_tags` restriction, and the app-embed cutoff that stops untrusted
app JS from inheriting the viewer's broader job access. A scoped or embed token
could therefore read relation names, statuses, row counts and errors for jobs
the ordinary job endpoints deny it.

That helper is private to `windmill-api`, which depends on `windmill-api-assets`
rather than the reverse, so the endpoint moves to the job routes instead of the
check being duplicated. It is job-scoped anyway:
`/w/{ws}/assets/run_progress/{job_id}` becomes
`/w/{ws}/jobs/run_progress/{id}`, and the frontend follows the generated client.

* feat(dbt): a dbt run does not trigger downstream runs

dbt orders its own DAG, so a cascade only ever adds one thing: waking a Windmill
script that reads a mart. That edge is narrow, and only half of it can even be
expressed — nothing outside dbt can declare a `table://` write, since
`// materialize` accepts DuckLake targets only, so an ingestion script cannot
wake a dbt project.

Against that, dispatching correctly is not cheap. A run's `select` can build any
subset of the project, so the deploy-time write set is not what ran; using it
wakes consumers of relations the run never touched, and narrowing it needs a
per-job record of what was built. The per-relation state table cannot supply one
(it keeps a single row per relation stamped with the last writer), and the
result field added for it made a run's own output carry the cascade's bookkeeping.

So `asset_dispatch` returns early for `ScriptLang::Dbt`, before the producer
gate. dbt still materializes, records per-model state and publishes its graph:
models, `ref()` lineage and live run progress are unchanged, and a
`# on table://<mart>` reader still renders beside the model it reads. It simply
does not fire. Wiring it up later means deciding what a selective run should
notify, which is the actual work.

Verified: a full run of a 6-model project succeeds and starts nothing, where it
previously triggered its subscriber; the run page still reports all 6 relations
and the folder graph still carries 14 tables and 8 ref() edges.

* fix(dbt): remove the cascade surface, settle stranded models, fix nested __mod

Stopping dispatch left its surface behind. `table://` was still an auto-trigger
kind, `persist_ingest` still derived subscriptions from a manifest's reads, and
the deploy still accepted `# on table://` — so the canvas drew cascade arrows
into scripts nothing could wake. All three are gone: the kind no longer derives,
the ingest only deletes rows earlier versions wrote, and the deploy refuses the
annotation with a message saying why rather than persisting a silent no-op.
`DescriptorTriggers` went with them; every field it parsed was cascade config.

A model marked `running` by the live tailer was never settled when the run did
not finish: reconciliation only revisits nodes `run_results.json` names, and a
cancelled or timed-out run has none for the model in flight, so the finished job
showed a relation building forever. It is now settled on every exit path.
Verified by cancelling a run mid-flight: 3 models `running` before, 3 `failed`
after, none stranded.

`getScriptBasePathFromModulePath` took the first matching suffix rather than the
outermost boundary, so `proj__dbt/models/legacy__mod/a.sql` resolved to
`proj__dbt/models/legacy`. dbt owns its directory names verbatim, so a folder
ending `__mod` is legal inside a project, and a module-only sync would have
looked for a descriptor that is not there and skipped the deploy.

* fix(dbt): colour a finished run's models from its own result

`materialized_partition` keeps one row per relation stamped with whichever job
wrote it last, so reopening a run showed only the models no later run had
touched since — down to none for an old run, which reads as a broken page rather
than as stale data. Reproduced: a 6-model run reported 6 relations, then a second
run rebuilt one shared model and the first reported 5.

A finished run already carries the answer. Its result lists every node with a
status, and the graph carries each asset's dbt `unique_id`, so the two join
directly — no path derivation, nothing stored twice, and nothing a later run can
overwrite. The endpoint stays for the live window, where the result does not
exist yet, and as the fallback for a run that never produced one (cancelled or
killed, whose relations the worker settles in the table instead).

`relationOutcome` mirrors the worker's `classify_status` so the colour drawn over
a record agrees with the record: `warn`, `skipped` and `no-op` leave the relation
untouched and stay uncoloured, as do tests and analyses, which match no asset.

Verified in the browser on the run whose model had been stolen: all six
relations green again, both sources correctly uncoloured.

* docs(dbt): record why only dbt-core 1.x has live per-model progress

`emits_node_events()` reads as "the Rust engines produce no node events", which
is false and would close off the option. They produce exactly the same events;
they put them on the console and ignore `--log-format-file json`, which both
accept. Measured on 2.0.0-alpha.5 and fusion 2.0.0-preview.202: 15 node events
each on stdout, 0 in the file log, for a three-model project.

Taking them means owning the job log's presentation to work around a flag that
is documented and simply unimplemented, so the note records the measurement, the
sample event, and that flipping the predicate is the whole change once either
engine honours it.

* fix(dbt): give HighlightCode a dialect-agnostic sql language

`npm run check` had three errors the fast check does not reach: `"sql"` is not a
value `HighlightCode` accepts. Every SQL dialect it knows maps to one grammar,
but a dbt model is compiled by whichever adapter the project targets, so naming
a dialect would be a guess — `sql` is now a value in its own right.

`langOf` was typed `string` and returned `markdown`, `python` and `text`, none
of which the component accepts either, so a dbt project's YAML and Python files
rendered unhighlighted. It now returns the component's own prop type, which is
what caught them, and `undefined` for what has no grammar rather than a name
that silently means the same thing.

Verified in the project panel: SQL 22 tokens, YAML 27, where YAML was plain.

* fix(dbt): stop failing no-op models, drop table triggers client-side, keep cross-selection edges

The sweep that settles a run's stranded relations was marking `no-op`, `warn`
and `skipped` models FAILED on successful runs: reconciliation reports those
nodes without settling their record, so they were indistinguishable from a model
the run never reached. It now excludes every relation the run accounted for, so
only the genuinely abandoned ones are settled.

`table` was removed from the backend's auto-trigger kinds but left in both
client mirrors, so the editor and `pipeline dev`/`docs` kept drawing cascade
arrows the deploy will not create.

`isModuleEntryPoint` scanned for the first `__mod/`, the same bug its sibling
just had: a `legacy__mod/script.ts` nested in a dbt project — dbt owns those
names verbatim — read as that script's entry point. Both now anchor on the
outermost boundary.

A script selecting a model whose parent another script builds dropped the parent
entirely, so no `dbt_edge` could reach it and the two relations sat on the graph
unconnected. The parent is now kept as an endpoint and recorded as a READ, since
this script does not build it — splitting a project across selections only
composes if the seam still draws.

* fix(dbt): don't double-run after-all tests, count only models a script builds

An `after_all` run whose test phase failed saves a `run_results.json` holding
tests alone. Retrying it reran exactly those tests — and then the test phase ran
the whole suite again, appending a second copy of every result: duplicate ids in
the run table, doubled totals. A retry whose saved results are tests alone IS
the test phase, so the suite is not run after it, and the two phases now merge
by node id rather than concatenating.

Keeping a selection's unselected parents as nodes made them count toward the
`×N` badge, whose tooltip says "materializes N models" — a script selecting one
mart claimed the staging models upstream of it, and the number grew with the
seam. The count now comes from the relations the script writes.

That change also made the cross-selection read block dead, with a comment
asserting the inverse of what now happens; it is removed, and the test that
covered it still passes on the new arm. The test I added landed between a
neighbouring test's comment and its `#[test]`, orphaning the attribute so that
test stopped running.

Two display fixes: the run page no longer shows a relation's SQL when the
provenance belongs to another project that materializes the same relation, and
the editor no longer draws an explicit `# on table://` arrow the deploy refuses.
The starter descriptor no longer promises the removed cascade.

* fix(dbt): clear untouched models, reject unknown descriptor fields

A `no-op` model was left `running` forever on a successful run. The previous
attempt at this stopped the sweep marking such models FAILED but gave them no
terminal state instead, so they simply never settled. Reconciliation now returns
what it settled and what the run reported but did not build, and the two get
opposite treatment: a relation the run left untouched has its row DELETED, which
is what the finished run's own result says about it (`relationOutcome` colours a
`no-op` nothing), so the live and settled views agree; only a relation the run
never reached at all is failed.

The descriptor accepted unknown fields, so `selcet:` was ignored and left an
empty selection — building the whole project — and a misspelled `target` fell
back to the profile's default. It rejects them now. That immediately caught two
of our own test fixtures still passing `repo:`, a field removed with the git
path, which is exactly the class of mistake it exists to stop.

`isDbtModulePath` matched `__dbt/` anywhere in a path, the third site with that
bug: `foo__mod/vendor/x__dbt/a.ts` read as a dbt project file, and the push then
looked for `foo.script.yaml` and could skip the edit.

A verbatim dbt bundle dropped any file named `*.lock` before it reached the
module map, so an authored `uv.lock` never deployed and the unmodified-project
round trip quietly lost it. The exclusion now applies only to `__mod` bundles,
where `.lock` really is the script's own lockfile — in the walker that hashes
modules too, or a change to such a file would not register as one.

Also: `langOf` fell back to `undefined`, which HighlightCode resolves to
TypeScript rather than to no highlighting, so seeds and Markdown were coloured
as code; and four comments still gave the removed cascade as the reason for
sharing an asset node, which is now lineage.

* fix(dbt): retry failed tests too, anchor the last __dbt path check

`retry_failed_nodes` only ran after the model phase, which fails before the
`after_all` test phase exists — so a project whose models built and whose tests
failed got no retry at all, exempting exactly the failure mode that separate
phase produces. The loop is now a function, called after both phases.

`isDbtGeneratedPath` matched `__dbt/` anywhere, the fourth site with that bug:
`foo__mod/vendor/x__dbt/target/a.ts` counted as generated dbt output, so
`ignoreF` excluded an ordinary module file and a module-only edit never deployed
its parent script.

`wmill sync push` still dropped an ADDED or DELETED `.lock` three branches
before the module arm, so the earlier fix only covered a first push: adding a
`uv.lock` to a deployed project was reported as a change forever and never
applied, and deleting one left it deployed. Editing worked, which is what made
the round trip look whole.

Also removes a duplicate `#[test]` that was double-registering a test and
detaching its neighbour's comment, and rewrites seven comments that still gave
the cascade as the reason for behaviour that now serves lineage only.

* fix(dbt): bound the excluded-file read, keep the retry budget job-wide

`isBundledModuleFile` read a file in full before deciding it was too big or
binary, so a project sitting next to a multi-gigabyte parquet seed loaded the
whole thing only to reject it. It now takes the size from `stat` and reads at
most the 8 KB the NUL check needs: a 191 MB file is rejected in 0.0ms at 82 MB
RSS.

Calling the retry helper after both phases gave each its own `attempts` budget,
so a job could spend double what the descriptor asked for — the bound exists
because every attempt is a real dbt invocation holding a worker slot. The budget
is now the job's, spent across whichever phases fail, and the field says so.

Extracting that helper had also placed it between `#[allow(clippy::
too_many_arguments)]` and `run_dbt`, taking the attribute off the 12-argument
function it was written for.

* fix(dbt): actually spend the retry budget

`retry_failed_nodes` looped on `while *remaining > 0` and never decremented it,
so a failing job reissued `dbt retry` — logging "attempt 1 of 3" each time —
until the job's deadline instead of `attempts` times. The decrement existed
briefly and was lost when the function was re-extracted by hand.

Claiming and counting are now one operation, `claim_attempt`, because keeping
them apart is exactly how the bound goes missing: the loop cannot iterate
without spending the budget.

Its test is bounded by its own `for` rather than by the function under test. An
earlier version collected `std::iter::from_fn(|| claim_attempt(..))`, which
against a non-spending `claim_attempt` is an infinite iterator — it allocated
until the machine died. A test for a loop bound must fail an assertion when the
bound regresses, not consume the host: it now reports `[1, 1, 1, …]` against
`[1, 2, 3]` in 0.00s.

* fix(dbt): ask before reading, not after

Bounding `isBundledModuleFile` did nothing for the bundle builder, which read
the whole file into memory and only then asked whether to keep it — so a
multi-gigabyte seed beside a project was still loaded in full just to be
skipped. The predicate is now consulted first, and the read happens only for
files the bundle actually carries.

* feat(dbt): animate the ref() edges feeding the model being built

The nodes moved during a run but the edges did not, so the graph showed where
dbt had got to without showing it flowing there.

Reuses the canvas's existing rule rather than adding a second one: an edge
animates when it touches what is happening. For a pipeline that is the running
script; for dbt the unit of work is the model, so a `ref()` edge animates while
its target builds. Same `animated` field, same visual language, no new styling.

Verified mid-run on a 7-model project: of six `ref()` edges only the two feeding
the model then building were animated, and none once the job finished.

* feat(dbt): show what each model wrote, and say when its SQL is another project's

Three things a reader wanted from the run graph and could not get.

Row counts: the worker already records one per relation and `run_progress`
already returned it, but the graph used only `status` and dropped the number. A
model that built green having emitted zero rows is the failure that looks like a
success, so the count is on the node.

The relation's fully-qualified name, copyable: there is no table browser to open,
so the next best affordance is the exact identifier to paste into a SQL client.
It is parsed with `splitRelation`, which honours quoting the way the worker's
`split_relation` does — splitting on every period renders
`"wh"."analytics.v2"."orders"` as a relation `orders` in a schema `v2`, which
does not exist.

And when two projects materialize one relation, the graph keeps a single
provenance winner, so the losing project's node carries the other's model. The
SQL was already suppressed there — correctly, it is not this run's code — but
silently, which reads as a dead click. It now says so.

* fix(dbt): a finished run's graph is the models it built, not today's project

`/assets/graph` is the current deploy, so an old run's graph drifted with the
project: a model added after it appeared as though the run had built it, and the
older the run the wronger the picture. A finished run's node set now comes from
its own result, which named exactly what it touched.

Sources survive the filter regardless — dbt never lists them in
`run_results.json` because it does not build them, but they are the upstream the
run read, and dropping them would leave the models hanging.

The graph is still the current deploy's, so a model renamed or deleted since
cannot be drawn at all. Rather than a silently shorter graph, the count is
stated above it.

Verified by adding a model after a run: the old run renders 7 models without it,
a fresh run renders 8 with it.

* feat(dbt): preview a model's rows with `dbt show`

There was no way to see the data behind a node — only its SQL and its row count.
`dbt show` selects from a model and returns rows, and every engine ships it, so
the preview needs no adapter code of ours: no connection path, no dialect-correct
quoting, no type coercion for ten warehouses. It runs against the profile the
run already renders.

It is a `dbt_command` rather than a new endpoint, so it inherits the whole job
path — authorization, isolation, cancellation, logs, engine provisioning — and
`limit` joins the run form beside it. That the allowlist can admit it at all is a
consequence of dropping the cascade: while a successful job dispatched its
deploy-time write set, a command that wrote nothing woke every consumer for
relations nothing had touched.

Read-only, and treated as such: no graph republish, no materialization records,
no retry state, no test phase. Captured rather than streamed, like `dbt ls` —
these rows are the result, not commentary, and the job-log writer is what
`NO_LOGS_AT_ALL` discards.

Verified: `{"dbt_command":"show","select":["stg_customers"],"limit":3}` returns
three rows; a preview leaves `materialized_partition` untouched (62 → 62, 0 rows
for the job); `clean` is still refused by the allowlist.

* feat(dbt): preview a model's rows from the graph, and keep our locks out of dbt projects

The run page could show a model's SQL and how many rows it wrote, but not the
data. Selecting a model now offers "Preview rows", which runs the script with
`dbt_command: show` and renders the result as a table.

Explicit rather than on-select: a preview is a job, so it costs a worker slot
and the engine's start-up, and previewing on every click would spend both on
mere navigation. Sources are excluded — dbt shows what a model SELECTs, and a
source is not one.

Also: `updateModuleLocks` was the one module helper that never learned about
verbatim bundles, so it walked a dbt project writing `foo.lock` beside `foo.sql`.
None of those files is a Windmill script needing a lockfile, and the bundle
promises to round-trip the project byte-for-byte — our artifacts have no business
in it.

Verified in the browser: selecting `stg_customers` and previewing returns the
columns `id`/`src` and five rows from the warehouse.

* fix(dbt): keep a run's models when another project owns their provenance

Scoping a finished run's graph to the ids it named dropped relations whose
provenance winner belongs to a different project — so a run of a project sharing
a schema showed 3 of the 6 models it had built. An id that was never this run's
package cannot be judged against its result, so it is kept: the relation IS one
the run wrote, and hiding it understates the run. The same rule applies to the
"no longer in the project" count, which otherwise reported deletions that were
only provenance collisions.

Previews are now cached per model and survive the selection moving. One was
thrown away whenever the reader clicked elsewhere, which for a job costing a
worker slot and an engine start-up meant re-running it to see it again — and the
run continues in the background, so leaving and returning finds the rows there.
The spinner also never span: `startIcon` takes the icon and its classes
separately, so the animation has to be passed alongside.

How long it took is shown with the rows. A preview is a job, and its cost should
not be something the reader has to guess at.

* fix(dbt): resolve argument references, clamp the show limit, flag renamed relations

`handle_dbt_job` cloned `job.args` where every other executor calls
`build_args_map`, so a `$var:` / `$res:` / `$encrypted:` argument reached dbt as
the literal string. A placeholder holding a schema or an `enabled` flag would
then build a different slice of the project than the caller asked for.

`--limit` took any positive i64, and the worker buffers the whole of dbt's
stdout to read the rows out of it — so a caller with only run permission could
make it hold an unbounded allocation. It is clamped to a ceiling now, extracted
as `show_limit` so the bound is pinned by a test rather than inline in an async
function nothing can reach.

And a model keeps its id when its alias or schema changes, so an old run's node
showed today's relation while the run wrote another — the page asserting it had
materialized a table that did not exist yet. The run's result carries the
relation each node actually wrote, so the drift is detectable without a graph
snapshot, and the count is stated above the graph. Rendering the run's own
lineage still needs a per-job snapshot; this stops the page claiming otherwise.

* fix(dbt): stop persisting resolved secrets, bound the preview by bytes

Resolving `$var:` / `$res:` / `$encrypted:` for dbt — added in the previous
commit — meant `save_run_state` wrote the resolved PLAINTEXT into
`dbt_run_state.args` and the worker's `state.json`. The row outlives the job, so
a secret stayed in the database and a later `dbt_command: retry` replayed it
after the grant was revoked or the value rotated. The invocation now carries the
args as submitted alongside the resolved ones, run state persists those, and the
restore path resolves them again under whoever is retrying.

Clamping `--limit` bounded the row COUNT, not the size: one column can hold a
megabyte, so a thousand rows is a thousand megabytes, and `run_capturing`
buffers all of it. The captured output has a byte ceiling now.

`limit` became a built-in argument without joining `RESERVED_ARG_NAMES`, so a
descriptor writing `{{ limit }}` was silently handed the preview control's
default instead of being told the name is taken.

Two display fixes: the relation-drift banner compared a canonicalized (lower
case) asset path against the warehouse's own spelling, so it fired on every
model of every finished Snowflake run; and caching a preview's failure left
`Preview rows` dead for that model until reload.

* feat(dbt): key the graph by script version so a run renders its own project

The dbt graph was keyed by path alone, so a deploy overwrote the only copy and a
run page could only ever show today's project — an older run rendered today's
models, SQL and `ref()` lineage no matter what it had run. My previous attempt
filtered that view to the ids the run named, which stopped it lying but could not
show what was gone: the data no longer existed.

`dbt_node` / `dbt_edge` now carry `script_hash` in their primary key, so each
deployed version keeps its own graph, and the run page passes the version its job
recorded. Per DEPLOY, not per run — ten thousand runs of one version share one
graph — and a composite FK to `script (workspace_id, hash)` with ON DELETE
CASCADE means a version's graph dies with it. Nothing pruned these before,
because there was one copy per path; they would otherwise have accumulated with
no sweep.

Two deploys of one path now write disjoint rows, so the graph can no longer be
lost to a race. `claim_graph_publication` remains only for what is still
path-keyed — the `asset` usage rows — and an older deploy finishing late records
its own graph before declining to touch those, where before it published nothing
at all.

A pinned request is scoped by the version's own nodes rather than by `asset`:
that table describes the current deploy, so scoping through it would filter a
model out of the very run that built it.

Verified end to end: deployed v1 (8 models), ran it, deployed v2 with four models
removed and one rewritten. The old run renders 8 models, 6 ref() edges and v1's
SQL; a new run renders 4 and the v2 rewrite.

* fix(dbt): scope graph cleanup to one version, bound the preview capture

Archive and delete both act on a single `hash`, but the graph cleanup they
called deleted every row for the path. Now that the graph is keyed per
version, archiving an old version erased the live one's models, SQL and
lineage, and nothing repaired it. Both callers have the path in hand, so the
by-hash wrapper is gone and they use the version-scoped clear directly.

`dbt show` checked its 8 MB ceiling after `wait_with_output` had already
buffered everything, so the ceiling could not bound what the worker held.
`run_capturing` now reads both pipes incrementally against a caller-supplied
limit and kills the child on overflow. The read buffers are heap-allocated:
as arrays they were baked into the future, which the job poller boxes several
layers deep, and that overflowed the worker thread's stack — a `dbt show` run
aborted the whole worker process.

A retry's `dbt parse` ran on the arguments as submitted while the build ran on
resolved ones, so a `$var:` shaping the graph parsed verbatim. The parse moves
to the caller, after resolution.

A run that names its own `select`/`exclude` now drops the descriptor's
`selector`: dbt resolves `--selector` instead of `--select`, so passing both
made a preview of one model return another's rows.

Also: log instead of silently swallowing a `modules` column that fails to
deserialize (pre-existing, but for dbt it means running with no project at
all); keep the model SQL reachable once a preview has landed; render which
node the rows came from; stringify object-valued cells; document
`dbt_script_hash` in the OpenAPI spec.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* docs: record the per-worktree dev environment and the backend-run check

Three mistakes this guidance would have prevented, each of which cost a cycle:

A worktree has its own database and ports, but AGENTS.md stated the
single-checkout defaults as facts. Pointing `DATABASE_URL` at another
worktree's database makes `cargo sqlx prepare` fail on every query touching a
table your migrations added — and it deletes `.sqlx/` before it fails, so the
cache is gutted rather than merely stale. Starting a backend on the wrong port
leaves the UI up with every call 502ing, which reads as an application bug.
Both values are now discoverable with commands that work as written.

`prepare` is also documented as the wrong tool for a removal-only change: the
cache is already complete for CI, and the only residue is orphaned entries that
can be found by text-matching against the sources without a database.

Nothing told a reader that `cargo check` does not exercise a worker path. A
read buffer declared as an array inside an async block is baked into the
future, and once boxed by the job poller it overflows the worker thread's
stack — compiling and unit-testing clean while aborting the whole worker
process at runtime.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* fix(dbt): scope the remaining path-wide reads and clears to one version

Four places still spoke for a whole path after the graph became per-version:

The relation-root drift check read `dbt_node` by path with an unordered
`LIMIT 1`, so with v1 at root A and v2 at root B it could answer with v1's
row, suppress the refresh v2 needed, and leave v2's graph naming relations the
run does not build. It now reads this job's version.

`dbt_dep`'s no-resource branch cleared the path, so a descriptor edited to
bring its own `profiles.yml` emptied every earlier version's graph and with it
every finished run's page. The ownership being given up is the path-keyed
`asset` usages cleared beside it; the graph clear is now this version's.

The graph was inserted before the publication claim checked the version was
still live. Archive and delete only soft-update `script`, so the foreign key
still accepted an in-flight dependency job's rows and the failed claim
committed them — and because pinned queries deliberately serve archived
versions, deleted model SQL became readable again. The write is now gated on a
`FOR UPDATE` liveness check.

`clear_dbt_run_state_by_script_hash` resolved a hash to a path and deleted the
path's saved run. `dbt_run_state` is keyed by path by design — one saved run
per script — so archiving one version discarded the live version's resumable
failure. It clears only once no live version of the path is left; `identity`
already refuses a resume whose project, warehouse or engine moved.

"Preview rows" ran `runScriptByPath` while the SQL beside it was pinned to a
hash, so an old run showed its own SQL over today's rows. Verified end to end:
with v3 deployed, the v2 run's preview runs v2's hash and returns v2's rows.

Also: keep the TAIL of a captured stderr, since dbt prints its summary last;
one `$derived` for the parsed result rather than five; collapse three
near-identical argument accessors onto one generic; fold the single-use
`copy_dir_command` into its caller; and give `parseDbtRun.ts` one status
classifier instead of spelling dbt's failure vocabulary twice.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* refactor(dbt): one JobCtx down the executor, one table per adapter

Two changes aimed at the operations this code will keep having: adding a
phase, and adding a warehouse.

`JobCtx` already bundled the five values every phase needs, and nine functions
took it — but the top of the executor threaded the fields apart and rebuilt the
struct at each call, so the same literal appeared eight times and each new
phase meant five more parameters. It is now built once per entry point and
reborrowed. `prepare_project` goes from 21 parameters to 17, `retry_failed_nodes`
from 15 to 11, and `run_dbt` drops below the lint threshold. The two remaining
constructions are the worker boundary, where the pieces genuinely arrive apart.

`DbtAdapter` answered five questions with five parallel matches over the same
eleven variants, plus a sixth list of adapters kept by hand in a test. The
facts now live in one `AdapterSpec` per adapter, reached through one exhaustive
match, so adding a warehouse states its name, driver, package, port, database
key and licensing together and the compiler demands the arm. Each arm spreads
from a Postgres base, which makes the inheritance visible per adapter instead
of hidden in the `_ =>` defaults `default_port` and `database_key` used to
carry. `DbtAdapter::ALL` replaces the list the test kept separately.

Verified by dumping all seven facts for all eleven adapters before and after:
byte-identical.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* fix(dbt): job-keyed run progress, and stop path-wide reads and clears

Six findings from the last round, in the order they bite.

The publication liveness gate refused on `archived`, but `create_script`
archives the parent on every redeploy — so deploying v2 while v1's dependency
job was still parsing left v1 without a graph, permanently, which is the exact
case the unconditional write existed to serve. It gates on `deleted` alone now;
an explicit archive is still covered by the `FOR UPDATE` ordering.

A project-owned `profiles.yml` trusted `profile.type` instead of reading the
file. The Rust engines carry every adapter, so a CE script could declare
`postgres` over a target that is `sqlserver` and have dbt connect with the
enterprise adapter. The file is read whichever way, and a descriptor that
disagrees with it is refused.

Renaming a dbt script, or editing one so its newest version is no longer dbt,
cleared the graph for the whole path — every older version's models, SQL and
lineage, which their own finished runs still render. Neither needs it: graph
queries join on `(path, hash)` through a `language = 'dbt'` CTE, so an old
version's rows cannot attach to whatever lives at that path next.

Live progress read `materialized_partition`, whose key is the relation and
whose `job_id` is only the last writer. Two runs of one project took rows from
each other. Progress now has its own job-keyed table; the relation table is
untouched, because one row per relation is right for the pipeline canvas and
fork defer. Verified with two overlapping builds: both keep 6 rows in the new
table, while the old one attributes 6 to one run and 0 to the other.

`Scratch::drop` removed a half-installed virtualenv synchronously from inside
the job future, blocking a runtime thread; it goes to `spawn_blocking`, with a
direct call when there is no runtime to hand it to.

The E2E list asked for a `# on table://` subscription the deploy now refuses.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* feat(dbt): snapshot a dynamic descriptor's graph per run

A `{{ }}` placeholder in `vars` can enable a different set of models per run, so
those runs re-ingest the graph. Keyed by version alone, each re-ingest
overwrote the last: reopening an older run showed the newer run's project, and
a model only the older run built was gone entirely — no SQL, no lineage, and
nothing the saved result could colour, since it can only tint nodes that are
there.

`dbt_node` / `dbt_edge` gain `job_id`. A run of a dynamic descriptor writes its
own snapshot under its job id and its page reads it back; a static descriptor
writes the version's graph once, under a zero-UUID sentinel, and every run of it
reads that. The sentinel is a value rather than NULL because `job_id` is part of
the primary key and Postgres does not treat two NULLs as the same key, so each
re-ingest would add a row set instead of replacing one.

`/assets/graph` takes `dbt_job_id` and prefers a snapshot when one exists,
falling back to the version's graph otherwise — so a run page passes it
unconditionally and static descriptors are unaffected. Snapshots age out after
30 days, pruned by the runs that write them, so no background sweep has to learn
about these tables.

Verified end to end: one deploy, two runs of it with `extra=yes` and `extra=no`
gating a model's `enabled`. The version's graph holds 6 models, run 1's snapshot
7 including `opt_extra`, run 2's 6 without it; the endpoint returns each run's
own and falls back to the version's when the parameter is omitted.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* perf(dbt): only snapshot a run whose graph differs, and prune from every run

Two costs the per-run snapshot carried, both found by measuring it rather than
by reading it.

A snapshot was written for every run of a dynamic descriptor, but marking one
dynamic is conservative: `graph_is_per_run` is true whenever `vars` holds a
`{{ }}` placeholder or `env` holds a `$var:`, which says the arguments reach dbt
and not that they change which models exist. The usual case is a date var, whose
graph is identical run after run, so the table filled with copies of an
unchanging picture — around 1 KB per model per run, which is a gigabyte or so a
month for a 200-model project on an hourly schedule. A row set now carries a
digest of its nodes, edges and relation root, and a run whose digest matches the
version's writes nothing; the read already falls back to the version's graph, so
those pages are unchanged. Only a run whose model set really differs pays.

The prune was hung off the progress reporter, which exists only for engines that
emit node events — so a Fusion or dbt-core-2x instance accumulated snapshots and
never deleted any. Retention that stops working because of an engine choice is
not retention; it runs detached from every dbt run instead.

Verified against a descriptor with a var-gated model: the version's graph holds
8 rows, a run that resolves to that same graph stores none at all, and a run
that enables the extra model stores its own 9. Both pages still render their own
project — 6 assets without the extra model, 7 with it.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* fix(dbt): scope every dbt_node join to the chosen snapshot

`job_id` joined the key, but only the scoping CTE and `dbt_edge` were taught to
filter on it. The outer node SELECT and the parent/child joins in the edge query
were not, so each model came back once per retained snapshot plus once for the
version's graph, and each edge matched every combination of the two — the model
count multiplied and the edge join fanned out quadratically. Measured against
one stored snapshot: 17 node rows where 8 are wanted, and 28 edge pairs where 7
are. The response dedup hid the edge blow-up from the payload, not from the
plan, and the run page refetches the graph every two seconds.

The progress table gained writers it was missing. `terminalize_running_relations`
settled only the relation-keyed table, so a cancelled or killed run — the case
that function exists for, since it leaves no `run_results.json` — showed every
in-flight model still spinning on the run page for as long as the row lived. An
agent worker cannot write the new table at all, having no database of its own,
so the read falls back to the relation-keyed one when a job has no rows there.

Also: a wrapped string literal missing its backslash put eighteen spaces in the
middle of the profile-disagreement error; a comment still described concurrent
runs of one dynamic version overwriting each other's graph, which is what
keying by job removed; and the `materialized_partition` index justified itself
by a run-page poll that has since moved to another table, though the closing
sweep still earns it.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* fix(dbt): give a graph snapshot a marker row, and scope what reads it

Five findings, four of which are the same mistake in different places: a
snapshot's identity was inferred from its contents.

Existence was inferred from a `dbt_node` row, so a dynamic run that disabled
every model — a legitimately empty graph — read as "no snapshot" and its page
showed the deployed models instead. The digest was a column repeated on every
node and read back with a `LIMIT 1` carrying no `job_id`, so a run could compare
itself against another run's digest and suppress a snapshot it needed. The
relation-root drift check read the same rows unscoped, so after a drift it could
find a previous run's root and conclude nothing had moved.

`dbt_graph_snapshot` holds one row per stored graph — path, version, job,
digest, timestamp. Existence is that row, the digest lives there once, the drift
check reads the deployed row explicitly, and the retention sweep deletes markers
first and then the rows no marker stands for. The digest is SHA-256 rather than
`DefaultHasher`, whose output is documented as unstable across Rust releases:
this value outlives the process that computed it, so a toolchain bump would have
silently stopped every comparison matching and quietly reinstated the duplicate
snapshots the digest exists to prevent.

`/run_progress` ignored the view token, so a share-link viewer got the graph and
was refused the progress that colours it.

A preview sent only its own three arguments, so a descriptor with a required
`{{ }}` var could not be previewed at all and an overridden one previewed a
different relation than the page was showing. The run's arguments go first now,
with the preview's three overriding.

Verified on a project whose only model is var-gated: the deploy stores a marker
with zero nodes, a run with the var set stores a marker with one, and the
endpoint answers 0 and 1 respectively rather than showing the deployed models
for both.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* refactor(dbt): squash the runtime's migrations into one

Ten migrations reshaping the same three tables is a history no installation
ever had. `dbt_node` gained `script_hash`, then `job_id`, then `ingested_at`,
with its primary key rebuilt twice; `graph_digest` was added by one migration
and dropped by the next after the digest moved to its own table. On a fresh
database all of that replays to arrive at a shape the schema can simply state,
and this feature has never shipped, so there is no upgrade path to preserve.

One migration now creates `dbt_node`, `dbt_edge`, `dbt_graph_snapshot`,
`dbt_run_state` and `dbt_run_progress` in their final shape, carrying forward
the rationale each of the replaced migrations recorded. The enum additions stay
in `add_dbt_lang`, since a value cannot be added and used in one transaction,
and the `materialized_partition` index stays separate because it belongs to a
table this feature did not introduce.

Verified by rebuilding: dropped the five tables, replayed from the single
migration, and confirmed the result is identical — same primary keys, the same
two composite `script` foreign keys, the same seven indexes. Every `sqlx::query!`
in the workspace then compiled against it, which checks each column's name, type
and nullability, and a deploy plus run on the rebuilt schema produced 8 nodes,
7 edges, a snapshot marker and 6 progress rows.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* fix(dbt): authorize snapshot reads, bound the prune, give the marker a lifecycle

`dbt_job_id` is caller-supplied and selected straight from `dbt_graph_snapshot`,
which carries no RLS — so a caller who could see the script could read any run's
model set and relation paths, which a dynamic alias or schema can encode. Both
graph queries now require the job itself to be visible, in the authed
transaction, the same gate `raw_code` already applies to the script that
produced it.

The drift check compared against the deployed graph alone, which misses the way
back: a run at root B republishes the path-keyed `asset` usages at B, and
returning the profile to A then matches the deploy and skips the refresh,
leaving those usages at B while dbt builds A. It reads the most recent ingest
for the version instead — the one that last wrote them — ordered rather than an
arbitrary `LIMIT 1`.

The prune anti-joined every non-deployed node and edge with no age predicate, so
each run scanned the whole retained sidecar and concurrent runs duplicated it.
All three deletes share one age bound again, with the sentinel spelled as a
literal so the partial indexes apply — a bound parameter cannot be proven to
match the index predicate.

`dbt_graph_snapshot` was the one dbt table nothing in the script lifecycle
deleted: no `script` foreign key and absent from both `clear_dbt_manifest*`
sites. A marker outliving its rows is read as a snapshot with no nodes, and its
digest still answers the suppression check, so an identical run would write
nothing and then render an empty graph. It cascades like the rows now and both
clears take it.

Also: the preview cleared `exclude` rather than inheriting it, since previewing
a model the run excluded reached dbt as `--select m --exclude m`; and
`terminalize_running_relations` no longer claims to cover a killed worker, which
never reaches it.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* fix(dbt): quote profile names, record where usages were published, stop polling the graph

A profile name comes from the project's own `dbt_project.yml` and a target from
the descriptor, and both were interpolated into `profiles.yml` as bare YAML —
including as mapping keys. A name like `prod # hidden` truncates the mapping and
a newline opens a sibling key of the author's choosing. Both are rendered as
quoted scalars now, as are the BigQuery keyfile's keys, with a test that asserts
the document still parses to exactly the keys we wrote.

The drift check read the most recent ingest, which latches: a run that returns
to the deployed root re-ingests but stores no snapshot (its digest matches the
version's), so the moved run's rows stay newest and every later run pays an
extra parse and ingest. The publisher now records the root it published the
path-keyed usages at, which is the only thing that answers "where do the current
usages point" — the deploy's own root goes stale as soon as a run republishes.

The run page polled `/assets/graph` every two seconds alongside progress, so it
re-sent every node's SQL for the length of a run — hundreds of KB a tick on a
real project, for a graph that a dynamic descriptor re-ingests exactly once
before the build. It fetches once more shortly after mount and then polls
progress alone.

Node results carry `outcome` beside `status`. `status` stays dbt's own word, but
dbt owns that vocabulary — 1.x and 2.x differ on casing and `no-op` arrived in a
minor release — so publishing only it would force a break or a lie the first
time it moves. `outcome` is the stable half a downstream script branches on.

Also: the worker's dbt entry points are `pub(crate)`, since nothing outside the
crate calls them and they resolve secrets and launch processes; and the snapshot
gate records that it is RLS-only where `/jobs/run_progress` also honours a
share-link token, which is a gap in what a shared page shows rather than in what
it protects.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* test(dbt): pin the graph storage invariants against a real database

Every defect review found in this area was DB-shaped — which row set a read
resolves to, which rows a clear takes, whether a snapshot exists at all — and
none of it is reachable from a unit test on a pure function. Four rounds
established these answers and nothing guarded them, which is why each round kept
finding another.

Six cases, on the harness the repo already uses for schema-shaped behaviour:
an identical run stores no snapshot and leaves no marker; a differing run keeps
its own while the version's is untouched; an empty run graph is still a snapshot
rather than an absent one; clearing one version leaves the others whole; the
path-wide clear takes the markers with it; and the sweep ages out run snapshots
while never touching a version's own graph.

`IngestedNode` gains `Default` so a test can state the two fields a case is
about rather than the eighteen it is not.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* perf(dbt): bound a script's stored graphs by deploy count

Run snapshots expire on a clock, but a VERSION's graph could not: its reader is
every finished run of that version, and a run page is as old as its job. So
nothing reclaimed them — a deploy graph went only when its `script` row was hard
deleted, which Windmill does not routinely do. A CI deploying on every commit
added a full model set with SQL bodies per commit, forever: roughly 200 KB a
deploy for a 200-model project, which is gigabytes a year across an instance.

Bounded by COUNT instead of age, since age is the thing that cannot be right
here. The newest 50 deploys per path keep their graph and older ones are
reclaimed, making growth `versions x models` rather than unbounded in time.
Generous on purpose: reaching the bound empties that version's run pages, so it
exists to stop unbounded growth rather than to be hit in normal use. Ordered by
the script's own `created_at`, so a late-finishing job re-ingesting an old
version cannot promote it.

Pinned by a test that deploys past the bound and asserts both halves: the count
holds, and the newest version is always among the survivors.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* fix(dbt): let the run page know when its snapshot has landed

The one-shot graph refetch was wrong: a dynamic descriptor's ingest happens
before the build but after cloning, dependency install and parse, so a fixed
delay either fires too early — and the run page then shows the deployed models
for the whole run, never that run's own — or keeps re-sending the whole graph
for the length of it. Neither is a timing problem to tune; the page had no way
to tell "the snapshot is not written yet" from "this run has none".

`/assets/graph` answers that directly: `dbt_snapshot_job` is the job the dbt half
resolved from, when one was asked for and found. The page polls the graph until
that is its own job, and stops. A static descriptor never snapshots, so an
attempt cap ends it there rather than polling for the run's duration.

`dbt_node.relation_root` is gone. The drift check moved to the marker's
`published_relation_root`, which left the column written on every node and read
by nothing.

`outcome` was published as the stable half of the result contract, but the
in-tree consumer still ranked and coloured from dbt's own word — so the field
existed and nothing used it. `statusRank` takes it, `DbtRunResult` passes it, and
`classifyStatus` is documented as the fallback for results that predate it and
for the live event stream, which carries dbt's word alone.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* docs(dbt): record what a share-link viewer actually sees

The comment at the snapshot gate said the graph "falls back to the deployed
set", which is only the rarer half of it. A share link is an extra grant for a
logged-in user who lacks access to the job, so the usual case is no read on the
script either — and then the `live` CTE matches nothing and the whole dbt half
comes back empty. A blank Models panel over working progress rows, not a
fallback.

`docs/dbt-runtime.md` now carries the analysis a follow-up needs: that relaxing
this leaks nothing, because `v2_job_completed.result` already gives that viewer
every node's `unique_id` and `relation_name` — the graph's only incremental
exposure is `raw_code`, which is gated separately on seeing the script. And the
shape of the fix: `OptViewToken` and `validate_view_token` are self-contained
enough to move into `windmill-api-auth`, which `windmill-api-assets` already
depends on, after which the gate can honour a token for that job's snapshot
alone while `raw_code` stays where it is.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* fix(dbt): keep model SQL behind the scripts:read scope, and unbreak CI

`/assets/graph` is authorized as `assets:read`, and RLS decides whether the
caller can see the script that produced a node — but RLS is not a scoped
token's grants. A token deliberately narrowed to `assets:read` could therefore
read model source and repository paths for scripts outside its `scripts:read`
paths. The same `build_scope_path_predicate` the macro endpoint already applies
now gates `raw_code` and `original_file_path`; the relation's shape is
unaffected, only its body is withheld.

`DbtAdapter::ALL` exists for the tests that must cover every adapter, so it is
dead in a release build and `-D warnings` failed all four backend checks on it.
It is `#[cfg(test)]` now.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* fix(dbt): stop the graph poll at the ingest, and type `limit` in the schema

The poll's stop condition was a snapshot appearing, with a 40-attempt cap
behind it — so a STATIC descriptor, which never snapshots, took the cap every
time and re-fetched the whole graph forty times. That is most of what removing
the poll was meant to save, and static is the common case.

The ingest runs BEFORE the build, so the first model to report progress proves
it has already happened: a snapshot absent by then is one this run never
writes. Progress arriving is now the second exit, and the cap is only a
backstop for a run that reports none at all.

`limit` is declared `Typ::Int` but `dbt_arg_schema` had no integer arm, so the
run form and the generated clients saw an untyped default and offered no
numeric control for a value the worker clamps. Covered by the schema test.

`relationOutcome` still re-derived from dbt's word while `statusRank` had moved
to `outcome`; both read it now.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* fix(dbt): make a retry prove its arguments still resolve the same

The saved arguments are the ones SUBMITTED, so a `$var:` in them is re-resolved
on retry. The identity did not cover the resolved values, so a variable that
changed between the failed run and the retry was accepted — and which graph the
retry then used depended on WHERE it landed: a worker holding the local
snapshot replays the saved manifest, while a database restore reparses with the
new value. Placement decided whether the resumed failures described the
relations being built.

The identity gains a digest of the resolved arguments, and is compared in two
halves because resolution happens between them. Project, warehouse, engine and
env are checkable up front; the arguments are not, because a retry request
carries only `dbt_command` and the ones to compare are the SAVED arguments after
this caller has re-resolved them. Comparing the whole string up front would have
refused every retry — which is what the obvious version of this fix does.

A row written before the digest existed has no last segment, and still restores
rather than being refused.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* fix(dbt): keep pre-upgrade retries working, and stop losing a late snapshot

Splitting the identity on its last `|` read a pre-upgrade row's env digest as an
arguments digest and left only `<run_identity>` as the prefix, so every saved
failure on an upgraded instance became unretryable — a regression the previous
commit's own test missed by using an identity with no `|` in it at all, which is
not what an old one looks like. The digest is tagged (`|args=`) rather than
positional, and the test now uses a real pre-upgrade identity.

The graph poll gave up after a bounded number of tries, but provisioning and
`dbt deps` precede the ingest and can outlast that on a cold worker — and the
engines that emit no node events never produce the progress that ends it early.
A finished run now reloads the graph unconditionally, and the poll's own exit
issues one last load: progress proves the ingest happened, not that the previous
tick saw it, and dbt's compile window is wider than one tick.

A `dbt retry` restores the failed run's arguments inside the worker and they are
never written back to the retry job, whose own args are just
`{"dbt_command": "retry"}` — so previewing a row on a retry's page ran without
the vars the run used. The result now carries the invocation's arguments as
SUBMITTED, so a `$var:` stays a reference and no resolved value is published.

The deploy-count sweep ran instance-wide on every dbt run: `FROM script WHERE
language = 'dbt'` has no index to stand on, and both orphan deletes are the
complement of every partial index here. It is scoped to the running script's
`(workspace_id, path)` — which `index_script_on_path_created_at` serves — and
the orphan deletes only run when a marker actually went.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* fix(dbt): hide dbt from module-less pickers, and stabilise the retry digests

`processLangs` feeds every language picker, including flow steps and app inline
scripts. Those are raw bodies with nowhere to carry a module bundle, and a dbt
script IS its bundle — so choosing dbt there produced a job that could only fail
once the worker looked for `dbt_project.yml`. Those two surfaces use
`processInlineLangs`, which drops the languages that need modules; a flow still
reaches dbt the way it reaches any script, by path to a deployed one.

`graph_digest` moved to SHA-256 because it is persisted and compared by a later
worker, and `DefaultHasher` is documented as unstable across Rust releases — but
the retry identity's own digests were left on it, and they are persisted in
`dbt_run_state.identity` for exactly the same comparison. A toolchain bump would
have refused every saved failure as a different project. All three go through
one `stable_digest`, length-prefixed so no split of the same bytes collides.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* fix(dbt): enforce the tag scope on snapshot reads, reset state between runs

A tag scope is an orthogonal hard restriction: a token limited to some tags must
not read a job outside them however else it is authorized. The snapshot lookup
went through `v2_job` RLS alone, which knows nothing about tags, so such a token
could still retrieve a run's model set and its dynamic relation paths. The same
predicate `require_job_read_access` applies for the progress half of the page is
applied here — `get_scope_tags` is already public in `windmill-api-auth`, and it
is `None` for an unscoped caller, so a normal session pays nothing.

SvelteKit reuses the run graph between run ids, and `graphTries`, `polled` and
`raw` all describe the previous job: a spent retry count stopped the next run's
snapshot poll before it began, and stale progress coloured its models with
another run's statuses. All three reset when the graph key changes.

Also a wrapped string literal missing its backslashes, which put two ~22-space
runs in the middle of the retry-refusal message.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* docs(dbt): put each digest helper's rationale on its own function

Inserting `stable_digest` above `split_identity` split that function's doc, so
five lines describing where the identity divides ended up introducing the
hasher. Each is back on the function it describes, stated once.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* fix(dbt): read the run-pinned graph through the job, not the asset graph

Pinning the asset graph to one run is job-scoped data, but `dbt_job_id` sat on
`/assets/graph`, authorized as `assets:read`. The job-read contract —
`require_job_read_access` — is five parts that pull in opposite directions (tag
scope restrictive, `created_by` permissive, app-embed restrictive-overriding,
view token permissive, RLS underneath), so plain RLS is neither a stricter nor a
looser approximation of it. Restating the parts near the graph query kept leaving
one out: first the job check entirely, then the share-link asymmetry, then the
tag scope, and the app-embed restriction was still missing and failing open.

The helper cannot be called from `windmill-api-assets`, because `windmill-api`
depends on that crate. So move the read instead of the check: the run-pinned
graph is now `GET /w/{w_id}/jobs/dbt_graph/{id}` in `windmill-api`, on the same
gate as the `run_progress` it colours, and `/assets/graph` has no `dbt_job_id`
parameter at all.

- `asset_graph_for` takes the job as an argument from an already-authorized
  caller; the route handler passes `None`.
- Extract the graph response into a `AssetGraph` component schema, now that two
  paths return it.
- The run page fetches the job route when it has a job id.

* fix(dbt): charge assets:read on the run-graph route, trust the job gate in SQL

Round 13 findings on the route moved last commit.

The scope domain comes from the URL segment, so putting the read under `/jobs`
asked a scoped token for `jobs:read` alone while returning asset-graph data that
`/assets/graph` charges `assets:read` for. A token narrowed to polling run status
could read workspace topology, and the missing-job fallback made it cheaper still
— any random UUID skipped the job gate. Both scopes are now required: the job
gate reaches this run, `assets:read` reaches asset data at all.

The `chosen` CTE re-decided job visibility under plain RLS after the caller had
already passed `require_job_read_access`. It could only disagree, and did so
silently by falling back to the deployed graph — a share-link viewer entitled to
the run was shown a different run's model set. Dropped; the contract is that a
job reaching `asset_graph_for` is already authorized.

Also: the flow editor's `+` insert menu still offered dbt (the third
`processLangs` caller, missed when the other two moved to `processInlineLangs`),
the docs still described the deleted `dbt_job_id` parameter, and the new handler
had again been inserted between `get_run_progress`'s doc comment and its
function.

* fix(dbt): resolve a pinned run's version from the job row, not script RLS

Local codex review of the branch.

A share-link viewer is entitled to the run and usually has no grant on the
project — that is what the link works around. The graph's `live` CTE resolved the
version by selecting `script` inside the viewer's RLS transaction, so it answered
for their access to the project rather than for the run they were given: the
Models panel came back blank beneath working progress rows.

A pinned run now takes its path and hash from the job row the handler already
read after authorizing the job, so `live` does not consult `script` at all.
`raw_code` keeps its own `EXISTS` against `script`, so the model bodies stay
behind access to the project. Verified under RLS as an unprivileged role: the
shape query goes 0 rows -> 1, the `raw_code` gate stays 0.

Taking the version from the job also means a caller can no longer pin one
project's version while naming another's run, since `dbt_script_hash` is ignored
when a job is given.

The run page's graph fetch is a raw `fetch`, which bypasses the interceptor that
adds `X-View-Token` to generated-client calls, so a shared page was refused
before any of this mattered; it goes through `appendViewToken` now.

Also trims three comments to the AGENTS.md limit, dropping drafting-history
rationale that belongs in docs/dbt-runtime.md.

* fix(dbt): snapshot vars-overridden runs, carry the pinned version everywhere

Second local codex pass.

A `vars` run argument overrides the descriptor's, and vars drive `enabled`,
alias, schema, database and materialization — so such a run builds relations the
deployed graph does not describe. It now snapshots under its own job id, which
per-job keying makes safe: the version's graph stays for runs that did not
override. The old comment claimed gating on it would strand the override's graph
for the next default run, which was true only when the write went to the
deployed slot.

Two sites still read the caller's `dbt_script_hash` instead of the version
resolved from the job, so `/jobs/dbt_graph/{id}` without that redundant
parameter dropped models the run's version had and a later deploy removed.

The `dbt_snapshot_job` marker re-checked `v2_job` under RLS — the recheck the
graph query itself drops. A share-link viewer got the right graph and a null
marker, so the run page refetched it 40 times before giving up.

`wmill script preview` read the bundle with the generic `__mod` suffix and
script-module parsing, so previewing a `.dbt.yaml` omitted the project and failed
on the missing `dbt_project.yml`. It uses the same suffix and verbatim read as
deploy.

* fix(dbt): key retry state by principal, not by script path alone

`dbt_run_state` held one row per (workspace, script path), and a retry replaces
the caller's arguments with the saved ones. Anyone able to run the script could
therefore retry whoever ran it last, replaying that run's literal `select` and
`vars` against the warehouse and publishing them as their own job's
`invocation_args`. Running the script was already theirs to do; seeing another
principal's arguments was not.

`permissioned_as` joins the key, so a retry resumes only state written under the
same authority. Two runs sharing an authority can already act for each other, so
this is the boundary that matches the rest of the job model.

* test(dbt): pin what a caller without access to the project sees of its run

The share-link case had no regression guard, and every fix in this area touched
one of its two halves: the graph's SHAPE has to survive a caller who cannot read
the script, and the model SQL must not.

Two cases against a real database, calling `asset_graph_for` as a member with no
grant on the project's folder: pinned to a run, the models render and `raw_code`
is withheld; unpinned, the same caller sees nothing of it, so making the first
work did not relax the second.

Both assertions were checked by mutation — reverting the `live` bypass empties
the graph, and dropping the `raw_code` script gate leaks `select 1` — so neither
passes on the code it is meant to catch.

* fix(dbt): key the worker-local retry cache by principal too

Keying `dbt_run_state` by `permissioned_as` left its worker-local twin keyed by
workspace and script path alone, so the boundary held only where the database row
was consulted. An agent worker never reads that table — `Connection::Http` leaves
`latest_job` as `None` — so there the local cache was the whole boundary and it
had none: the next principal to retry the script on that worker restored the
previous one's `select` and `vars`.

Also records the sqlx `--all-targets` trap in the update-sqlx skill: it is needed
for queries inside tests, and in a CE checkout it aborts on `tests/otel.rs`
(EE-only `otel_ee`) after having already emptied the cache.

* fix(dbt): log a dropped retry-state save, correct the run-progress contract

Saving retry state is best-effort — losing it costs a retry, not the run that
just finished — but `.ok()` dropped the reason too. The only symptom was `dbt
retry` reporting nothing to resume, which reads as a bug in retry rather than a
failed write. Found by running a real failing build against a worker whose
binary predated the `permissioned_as` column: the insert violated NOT NULL and
said nothing.

The run-progress endpoint's OpenAPI description promised an empty list for a
caller who cannot see the job. It is refused instead; an empty list means the job
recorded nothing yet or is unknown here.

* fix(dbt): return the retry-state write failure the warning was added to report

`save_run_state` discarded the insert result, so the caller's warning could never
fire and a lost retry row stayed silent — the symptom being `dbt retry` finding
nothing on another worker.

The error is held rather than returned at once: the worker-local copy is what an
agent worker resumes from, so a failed insert must not cost that too. Every exit
after it surfaces it, including the ones that give up on the local save.

* fix(dbt): decide a retry's graph from its restored args, keep local state in step

Three from the seventh local review.

A retry submits only `dbt_command`, so the vars-override check ran against an
empty argument set and left `graph_is_per_run` false. The failed run's arguments
are restored afterwards, and those are what the retry builds with — an overridden
one wrote no snapshot for its own job and its page fell back to the deployed
graph, showing the wrong enabled models, aliases and schemas. The decision is
re-asked once the restore has happened.

A failed durable write no longer publishes the worker-local generation either.
`restore` accepts a local generation only when the database row names it, so
publishing one the database never recorded made this worker reject its own newest
state and resume the previous run's — its selection and vars, or "nothing to
retry" if that one had succeeded. An agent worker attempts no durable write, so
it keeps its local copy as before.

A rename that also converts away from dbt moved the old path's retry state onto
the new one, reinstating what the conversion had just cleared and leaving one
user's arguments and results under a path no dbt script occupies. It moves only
while the destination stays dbt, and clears the source otherwise.

* fix(dbt): drop retry state when a run produced none, let module pushes fail loudly

Three from the eighth local review.

A run that never wrote `run_results.json` — cancelled, timed out, or dead before
dbt got there — left the PREVIOUS run's state authoritative in both the database
and the local pointer, so a later `dbt retry` resumed that older invocation's
failed nodes. Producing nothing resumable now clears both copies, so neither can
answer for the other.

`wmill sync push` wrapped the descriptor lookup and its deployment in one
try/catch meant for a missing parent. Any API failure or invalid descriptor was
reported as "no parent found" and swallowed, so a module-only push exited zero
with the remote project unchanged. Only the lookup is tolerated now.

Also condenses a comment that narrated how earlier status comparisons behaved.

* fix(dbt): forget retry state on pre-build exits too, drop cascade claims

A dynamic run whose pre-build `dbt parse` or graph ingest fails returns before
the save that clears stale state, so the previous run stayed authoritative in
both the database and the local pointer and `dbt retry` resumed ITS failed nodes
— writing relations the run that just failed never touched. Both exits now
invalidate, through one helper shared with the no-artifact case.

Two frontend comments described dbt producer rows as driving cascade dispatch.
The executor returns before dispatch for every dbt job and deployment rejects
`table://` subscriptions, so they promised behaviour that cannot occur; they
describe the lineage and ownership that is actually retained.

* fix(dbt): let the database decide retry state where it is reachable

A SQL worker treated "no `dbt_run_state` row" as no opinion and accepted any
worker-local generation. But no row is the authoritative answer that the last
invocation left nothing resumable, so a local pointer that outlived it — an
unlink that failed, a process killed between the delete and the removal, a stale
cache — resurrected a replaced run and let `dbt retry` write relations it never
touched. An agent worker keeps accepting its local copy: it has no authority to
consult.

Invalidation failures are logged rather than dropped, since a silent one is
exactly what leaves the pointer behind.

* docs(dbt): record how to run an agent worker locally, keep archived graphs

Every step of standing one up fails as something else: a normal build cannot
start one at all, the server's routes need a separate feature, and all three
token mistakes surface as a bare 401 on the agent with the reason only in the
server log. Written down with the error each produces.

Also keeps a dbt script's graph when it is ARCHIVED rather than deleted. The
pinned read resolves versions through a CTE that already skips archived rows, so
clearing bought nothing and emptied the Models panel of every completed run of
the project. Deletion still clears it.

* feat(dbt): let an agent worker publish its graph, through one endpoint

An agent worker was refused any dbt script whose profile comes from a Windmill
resource — the common case — because it could neither read the stored relation
root to check for drift nor re-ingest a corrected one.

Those look like two needs but collapse into one: verification exists only to
decide whether the stored graph still describes reality, so a worker that can
PUBLISH never has to ask. It stores what it just parsed.

`POST /api/agent_workers/dbt_graph/{workspace_id}` is the whole addition. It
wraps the same `replace_dbt_manifest` the SQL path calls, so digest suppression,
the marker write and retention cannot drift between the two transports, and it
refuses a job the token's tags do not cover. `IngestedManifest`/`IngestedNode`
gain Deserialize to cross the wire.

Two guards go, both now false: the pre-build refusal, and the `Connection::Sql`
gate added earlier to stop a `vars` override grounding an agent run.

Live progress stays SQL-only — that is a per-model event stream, and routing it
through the API would mean a round trip per node.

* docs(dbt): warn that a differing cargo feature set swaps the shared binary

* docs(dbt): record the verified agent-worker behaviour and the tmpfs quota trap

An agent worker now runs a dbt job end to end, retries, and publishes its graph
— confirmed with a dynamic descriptor whose per-run snapshot came back through
the new endpoint. The doc said it was refused; that was true before the endpoint
existed.

Also `WINDMILL_DIR`: on a dev box the job dies with `Disk quota exceeded (os
error 122)` writing the project's files while `df` shows free space AND free
inodes, because /tmp is a tmpfs carrying a per-USER quota. Point the worker at a
real disk rather than trying to clean up beneath it.

* chore(dbt): pin the EE revision carrying the agent graph endpoint

* fix(dbt): bind the published graph to the job, break the completed-page poll loop

Five from the thirteenth local review.

The EE endpoint took `script_path` and `script_hash` from the payload and checked
only that the supplied job carried one of the agent's tags, so an agent holding
any matching-tag job could name another script and replace its graph. Both are
read from the verified queue row now and the request carries only the job id. A
raw preview has no version, so it no-ops rather than 422ing before dbt runs.

`IngestedManifest`/`IngestedNode` take `#[serde(default)]`: they were
serialize-only, and a field the serializer skips made the whole manifest
unparseable on the receiving side.

A completed run page fetched the graph forever — `load()` assigns `raw`, which
recomputes `settled`, which re-entered the same effect. The final fetch is keyed
to the job by a plain (non-reactive) variable, and `settled` is read untracked.

The pin now names a revision that compiles: the previous one still called
`authed.tags()`, a method that does not exist, because both that fix and the JSON
response landed after it was committed.

* fix(dbt): keep a run snapshot out of the script's deployed ownership

Everything `persist_ingest` writes after the manifest is keyed by PATH — one row
set per script, describing what is deployed there. A run snapshot was still
reaching it, so a one-off `vars` override republished that invocation's relations
as the script's ownership and the workspace graph stayed on the override's
schemas and aliases: an ordinary run of a static descriptor never ingests again
to correct it, so only a redeploy would. A snapshot now stops after recording its
own rows.

The row preview also selected a bare model name, which dbt resolves across every
installed package while `show` takes a single node — a project model sharing its
name with a package's was previewed wrongly or refused. It selects the
package-qualified FQN.

* fix(dbt): forget stale retry state when preparation itself fails

`prepare_project` runs before every path that could clear it, and it fails for
reasons unrelated to the saved run — a profile that stopped resolving, a
provision cancelled, packages that will not install. The invocation still left
nothing resumable, so the previous one must not stay authoritative: a repaired
project would otherwise let `dbt retry` rebuild an older run's selection and
write relations the latest invocation never reached. A retry is exempt, since it
is trying to use that state and failing to prepare says nothing about it.

Also corrects the runtime doc, which still described agent workers as unable to
run dynamic descriptors or Windmill-resolved profiles. They publish their graph
through the API now; what they do not get is live progress and a durable retry
row, and the doc says so.

* fix(dbt): spell the whole FQN for preview, bound retained retry generations

The FQN selector added last commit was `<package>.<name>`, but a dbt FQN is the
resource's path within its package and the matcher must consume the selector and
end on equal lengths — so it matched nothing for a model under `models/marts/`,
which is the layout most projects use and the one this repo's own complex fixture
has. The middle segments come from `original_file_path`, whose first element is
the resource root the FQN excludes. Without a path it falls back to the bare
name: ambiguous across packages, but a selector dbt resolves rather than rejects.
Tested on a nested model, which is the input that separates the three spellings.

Superseded retry generations were removed only when a later run published one,
and never inside the hour-long grace period — so a burst left a manifest and a
results copy per run with nothing afterwards to collect them. At most four now
sit in the grace window, oldest evicted first.

* fix(dbt): scope preview state to the run, seed the project on a language switch

Previews are keyed by `unique_id`, which is the same string for the same model in
every run, and the run-change effect reset only the graph and progress. Opening a
second run of one project therefore showed the previous run's rows immediately,
and `runPreview` treated them as cached and refused to fetch. A generation
counter also drops a preview that resolves after navigation, which the reset
alone cannot catch.

The dbt project was seeded only by the empty-script bootstrap, but dbt is in the
ordinary language picker: reaching it by switching a draft produced a script with
no `dbt_project.yml`, which the runtime refuses to deploy or run. Both entry
points seed now, and neither touches modules that already exist.

* chore(dbt): cache the agent graph endpoint's query for the EE offline build

* fix(dbt): publish the graph a moved profile built

A run snapshot stopped before everything `persist_ingest` keys by PATH, which is
right for a one-off `vars` override and wrong for the other two reasons a run
re-ingests. `graph_is_per_run` was one bool for all of them, and the profile
drift check both sets it and reads back what the publisher recorded: a profile
moved A->B was detected by every run forever, each paying a `dbt parse` for a
snapshot nobody reads while the asset rows went on naming schema A.

The reason is carried now (`GraphRefresh`), and it decides both writes. Drift is
the version's own move, so it rewrites the VERSION's graph and republishes the
ownership that ends the drift; a dynamic descriptor snapshots under its job id
and still publishes; anything the CALLER scoped — an overridden `vars`, a
narrowed `select` — snapshots and publishes nothing, so one invocation's subset
can neither stand as what the script owns nor drop the models it left out from
the version's graph. Where they meet the caller wins, and the next ordinary run
settles the drift.

A restore also rebuilt `run_results.json` by copying the generation directory a
second time, so a burst of saves pruning it mid-restore left `dbt retry` with
nothing to resume and a job that reported success. It is written from the bytes
the restore already read; a manifest that went the same way falls back to the
parse a database restore pays anyway, and a generation that vanished before
either read falls back to the database's row for that same run instead of
reporting there is nothing to retry.

* fix(dbt): select a row preview by package, not by file path

The preview built dbt's FQN by dropping one segment of `original_file_path`,
which assumes the model root is `models/`. A project setting
`model-paths: ["src/models"]` turned `src/models/marts/orders.sql` into
`pkg.models.marts.orders`, and dbt's matcher — equal lengths, compared from the
front — resolves that to nothing: the preview came back empty for every model in
the project.

It selects `<name>,package:<pkg>` instead. The comma is dbt's intersection
operator, so this names the node by its own name and the package it belongs to,
which is what the FQN was reaching for and needs no knowledge of the resource
root. Verified on dbt-core 1.12, dbt-core 2.0.0-alpha.5 and fusion
2.0.0-preview.202, including a package shipping a model whose name the root
project also uses.

* fix(dbt): refuse a lockfile version that is not one, keep a named selector

Two things a preview reaches that a deploy does not vouch for.

A raw preview submits its own `lock`, so `engine_version` arrives from the
caller and was interpolated straight into the engine cache path — `../..` in it
made the download, extraction and rename land anywhere the worker can write,
and provisioning runs on the host rather than inside the dbt jail. Both it and
`adapter_version` (a pip requirement) are now accepted only as a plain version
token.

`effective_selector` also read any submitted `select`/`exclude` as an override
of the descriptor's named selector. The generated run form posts a default back
for every field the caller left untouched, and a selector descriptor's `select`
default is `[]` — so pressing Test, saving a schedule or firing a webhook built
the WHOLE project instead of `--selector nightly`. An override is now one that
DIFFERS from the descriptor's own value; a run that wants the whole project
despite the selector asks with `["*"]`.

* fix(dbt): let a moved profile settle, from the runs that actually happen

Two ways the drift check could never come to rest, both verified against a real
run of a real project on a normal worker.

`add_caller_args` read any submitted `select`/`exclude` as a caller's narrowing.
The generated run form posts a default back for every field left untouched, so
every run from the UI, a schedule, a webhook or a flow step carried them and was
marked caller-scoped: with the profile moved A->B, each one stored its models
under its own job id and left the workspace graph — and the root the check reads
back — at A. Since no UI run omits the field, the "an ordinary run settles it"
escape hatch was unreachable. Both this and `effective_selector` now ask one
question, `selection_is_overridden`: DIFFERENT from the descriptor's, not merely
submitted.

The root was also recorded beside the path-keyed publication rather than beside
the graph it describes, so a version that cannot claim the path — an older one
run by hash, a deploy overtaken by a newer one — rewrote its graph at the moved
root and recorded nothing. Its next run then compared against a root that was
absent or two moves stale and skipped the refresh its own run page needed. It is
written wherever the deployed row's graph is.

Verified end to end: same UI-shaped arguments before and after, the moved
profile now republishes (asset rows and version graph both move to the new
schema), a second run detects nothing and re-parses nothing, and moving the
profile back settles it again.

`prune_dbt_run_graphs` also ran from runs alone, while a deploy writes a whole
node set of its own, `raw_code` per model included: a project redeployed on
every push by CI and run nightly kept one full graph per push until the next
run, and one deployed but never run kept them for good.

* fix(dbt): drop a self-dependent effect in the run graph

`previewGen` was `$state` written by the effect that also reads it, three lines
under a `finalLoadFor` that is a plain `let` for exactly that reason. Nothing
reactive reads it — the only reads are inside `runPreview`, a plain async
function — so it becomes a plain `let` too.

* fix(dbt): pin a retry to the engine versions it resolved

`run_identity` carried the engine KIND but not the version it resolved, nor the
dbt-core 1.x adapter's. Redeploy an unchanged project after a release and it
locks a newer dbt or adapter while the saved `run_results.json` still passes the
check, so `dbt retry` feeds one version's artifacts to another — the exact
reproducibility the lockfile exists to hold. Both resolved versions are in the
identity now; a real failure and retry still resumes.

Also drops three comments that outlived what they describe: two said `[]`
clears a descriptor's selector, which `selection_is_overridden` reversed, and
one pointed at an agent-worker guard that no longer exists — the agent path
reaches the ingest deliberately and publishes through the API.

* fix(dbt): discard a run graph the page has already navigated away from

The component is reused across runs, so a slow `/jobs/dbt_graph` or progress
response could land after the reset and put the previous run's models, statuses
and failure state on the current run's page, where nothing would fetch again to
correct it. Every response is now checked against the generation it was
requested under — the counter the preview path already used, renamed for what
it means.

The graph poll also backs off. Neither of its stops is reachable for a whole
class of runs — `dbt_snapshot_job` never matches a static descriptor, and
`polled` stays empty for the engines that emit no node events — so an ordinary
run walked to the cap, re-sending every model's SQL 40 times in two minutes.

* fix(dbt): forget the previous run when the durable save fails, keep quoting

`save_run_state` returns the database error when its upsert fails, which leaves
run N-1's row and local generation in place: same project, same arguments, so a
`dbt retry` matches them and resumes an older attempt's failed nodes against
this checkout — the outcome the no-results branch twelve lines above calls
`invalidate_run_state` to prevent, reached by another door. It now goes through
the same call. Best effort, since the delete goes to the database that just
refused a write, but the local pointer is what a retry landing back here reads.

The run page also rejoined a relation's parts after `splitRelation` stripped
their quotes, so the one name the button exists to paste —
`"wh"."analytics.v2"."Order Items"` — was copied as something no client
resolves. It copies `relation_name` verbatim.

And a source on a finished run was called another project's: the check that
guards against two projects claiming one relation asks whether this run executed
the node, and a run executes no sources — they appear in no `run_results.json`.
Nothing materializes a source, so that warning could never be true of one.

Docs: the `vars`-override paragraph still said such a run does not refresh the
graph, which the table above it contradicts — it refreshes under its job id and
publishes nothing.

* fix(dbt): keep the asset rows and the version's models describing one graph

The workspace graph takes an asset's relations from the path-keyed `asset` rows
and its models, SQL, tests and lineage from the version's `dbt_node`/`dbt_edge`.
A dynamic descriptor published the former while storing the latter under its own
job id, so a placeholder that moved an alias or a schema left the current graph
with assets no model stands behind — nothing dbt contributes to them survives.
Ownership is published exactly when the VERSION's graph was written now, which
is the only state in which the two agree. Two cases are settled elsewhere by
design: an override's relations are a one-off, and a dynamic descriptor at a
moved profile keeps the deploy's ownership until a redeploy — its runs each show
their own models and it re-parses regardless, so the undetected drift costs it
nothing it was not already paying.

An agent worker has no durable row, so its local `current` pointer is the whole
of what a retry reads — and every local publication failure returned success
with the PREVIOUS run's pointer still in place. Where a row exists that is
harmless (`restore` takes a local generation only when the row names it), so the
abandonment is scoped to the agent case.

A failed `dbt show` also cleared the retry state: the preparation-failure exempts
`retry` but not a read-only command, and the run page's row preview is exactly
that, run as the principal the state is keyed by — so a preview that could not
provision took the retry away from the run being looked at.

Frontend: the run-change reset left `loading` and `failed` behind, so the gap
before the next run's answer rendered "no models in the asset graph" — a claim
about the descriptor — over a project that is fine. And three derivations argued
from "the graph is the current deploy", which the pinned endpoint made untrue;
each is still needed, for the version-graph rewrite and retention reasons now
written down.

* fix(cli): let --skip-scripts cover a script's module files

The module shortcut in `elementsToMap` maps the file and `continue`s before
every skip filter, and a module is deployed as part of its parent script — so
`wmill sync push --skip-scripts` still pushed the script whenever one of its
modules changed, and pull still overwrote them locally. Harmless while a module
was a rare helper file; every file of a dbt project is one of these now.

* docs(dbt): a dynamic descriptor's ownership stays the deploy's

* fix(dbt): read the run out of a failure whose message has braces of its own

`parseDbtRun` anchored on the FIRST `{` in the error message and parsed
everything after it. The worker appends the structured result after the error
text, and dbt's errors carry braces — a Jinja template, the compiled SQL, an
adapter's own JSON — so the failures most worth reading were the ones whose
summary and per-node outcomes the run page dropped. Every brace is tried now,
bounded, and the first that parses as a run wins.

Pins the EE revision that gives the agent publish endpoint the deleted-version
guard the SQL path takes: deletion is soft, the foreign key still accepts graph
rows, and the pinned graph query serves non-live versions, so an agent finishing
during a delete put a deleted project's model SQL back on screen. The query is
byte-identical to `persist_ingest`'s, so the offline cache already covers it —
verified with a full-EE `SQLX_OFFLINE=true` check.

* fix(dbt): seed a project when a modular draft switches to dbt

`seedDbtProject` returned whenever the draft carried any module at all, so a
modular script holding a `helper.ts` reached dbt with none of what dbt needs:
the project view is read-only, and the worker refuses a bundle without
`dbt_project.yml`, so that draft could neither run nor deploy. Keyed on the
project file now, and the seed goes in under whatever is already there — the
previous language's helpers are inert to dbt and the user's to remove.

Also records this runtime's schema in `backend/summarized_schema.txt`: the
`table` asset kind, the `dbt` script language, the five dbt tables and the
`materialization_status` enum the progress table uses.

* docs(dbt): move the pipeline-membership rationale out of the deploy path

* fix(dbt): gate a pinned run's model SQL on the version it belongs to

The `EXISTS` against `script` is the only thing standing between a share-link
viewer and the project's source, and it matched the workspace and path alone.
`extra_perms` is a grant on a ROW: archive a version that granted someone
access, recreate the path with narrower permissions, and that stale grant
satisfied the probe while the query returned the NEW version's `raw_code`. Both
probes name the hash now. The regression test drives exactly that shape and
fails without it, returning `select 2` to a caller granted only on the archived
version.

* fix(dbt): keep a delimiter an identifier escaped by doubling

Every dialect these relations come from escapes its own delimiter by doubling
it, and both split functions closed the quoted section on the first half and
reopened on the second: `"schema"."a""b"` came out as `a.b`. The manifest keeps
the real spelling, so the run wrote its per-model status and row counts under an
asset path no graph node has — the node simply never moves, which is the failure
mode this splitter exists to prevent.

Fixed in the worker and in its frontend mirror, which have to agree, with a case
per delimiter on both sides.

* fix(dbt): key retry state by the caller, not only by the principal it runs as

An `on_behalf_of` script executes every caller's job as its owner, so
`permissioned_as` names one principal for all of them and the retry state — the
durable row and the worker-local generation both — collapsed onto a single
entry. After one caller's run failed, the next could submit `dbt_command: retry`
and resume it: their arguments replayed against the warehouse, and handed back
through `invocation_args`. Nothing else separated them, and on an agent worker
the local directory is the whole boundary.

`created_by` joins the key in both places. For an ordinary script it changes
nothing — `permissioned_as` is already that caller — and a run that was itself
superseded was never resumable anyway.

Includes the offline cache for the four changed queries and the three the
pinned-graph regression test added last commit, which had none: `prepare`
without `--all-targets` does not compile test targets, so CI's
`SQLX_OFFLINE=true ... --all-targets` would have failed on them.

* fix(dbt): compare the schema too when reporting a relation that moved

`relationDrift` compared the leaf name alone, and the move it exists to report —
a profile repointed at another schema, which a later run then writes into the
version's graph — leaves every model's name exactly where it was. So the one
case that reliably produces a graph naming relations this run did not write was
the one case the notice stayed silent for.

The schema segment joins the comparison, qualified against qualified: an
unqualified one means the target's own database, which the relation names
anyway, so comparing that would report a move on every node.

* fix(dbt): bound the retry state now that it is keyed per caller

Keying by `created_by` fixed one caller resuming another's run and created a
growth problem doing it: a shared `on_behalf_of` script kept one row and one
worker directory for everyone who had ever run it, and the generation prune only
bounds files INSIDE a directory.

Three bounds, none of them new machinery. A run with nothing failed or skipped
saves nothing — `dbt retry` builds from those nodes alone, so that state could
only ever be refused — while still clearing what the previous run left, since
its failures are no longer what last happened here. The rows expire on the same
30-day clock as a run snapshot, swept per path by the prune every dbt job
already spawns. And the worker-local directories are swept there too, by the age
of the pointer a save rewrites, because their digest names neither the script
nor the caller.

* docs(dbt): the retry state is worker-affine only on an agent worker

* fix(auth): only the server may set a token label that names a user

`create_token_internal` wrote `NewToken.label` verbatim, and the auth layer reads
some labels as an IDENTITY: `username_override_from_label` maps
`ephemeral-script-end-user-<name>` to exactly `<name>`, which then becomes
`created_by` on every job that token pushes. The label is free-form request
input, so any member could mint a token that speaks as somebody else — the shape
`require_job_read_access` already works around when it refuses to trust
`username_override` and falls back to an RLS probe, and the one that made dbt's
retry-state key (`created_by`) forgeable for an `on_behalf_of` script.

The labels are refused where request input enters: the member-facing
`tokens/create`, and `impersonate`, which names its subject in
`impersonate_email` and has no business renaming the caller too. The legitimate
producers are unaffected — a job's own token comes from `create_token_for_owner`
in the worker, and native triggers and app-embed tokens build their labels
themselves rather than accepting one.

`Ephemeral lsp token` stays allowed: its override is the fixed sentinel `lsp`,
not a name the caller chose, and the editor mints exactly that label through this
endpoint for its language server. The test pins the two lists together, so an arm
added to `username_override_from_label` that lets a label choose a name fails
until it is reserved too.

* Revert "fix(auth): only the server may set a token label that names a user"

This reverts commit efaa498d82c23a9b096b72c399c9da28b65dd550.

* fix(auth): only the server may set a token label that becomes a bare username

* revert(dbt): key retry state by the execution principal again

Reverts the per-caller key and the retention it needed. `created_by` cannot
carry an isolation boundary: it is `display_username()`, which a token LABEL
supplies, so two callers can share one value and — before the guard two commits
back — one could name a third person. GHSA-8x8x-88qc-qp4r settled that class by
refusing to trust the name for authorization, and keying on it here was the same
mistake in a new place. It also cost a migration, a PK column, two sqlx cycles
and a retention sweep to defend.

Back to `(workspace, script_path, permissioned_as)`, which is derived from the
authenticated username and cannot be chosen by a request. What that boundary is,
and the one case it does not cover, is now written down where the retry is
specified rather than left to be re-derived: anyone entitled to run the script as
that principal may resume its last failure — the same capability as re-running
that job, since running it requires the read access that already shows them the
run and its arguments — except for a run pushed `invisible_to_owner`, whose
arguments a retry still returns. Closing that means having a retry NAME the job
it resumes and authorizing it as a job read, which is a change to the run
argument, not to the key.

* fix(dbt): give a caller's own selection a graph, and load a finished run once

A run that overrides `select`/`exclude` was marked caller-scoped but not
per-run, so it ingested nothing and its page fell back to the deployed graph.
That is only right when the override NARROWS the descriptor's selection —
`["*"]`, or any model outside it, builds relations the deployed graph never had,
and those are exactly the ones whose progress, SQL and lineage had nothing to
draw. It ingests its own graph now, still caller-scoped, so the subset stays out
of what the script owns.

`relationDrift` also read a schema whose own name contains a period as a move: a
segment holding one is ambiguous — an overridden database, or a schema really
called `a.b` — so either spelling now counts as unmoved.

And a finished run fetched the whole graph twice on mount, every model's SQL
included: the reset effect and the finished-run effect both fired in the same
tick. The reset only loads while the run is in flight; the other owns the
finished case, because a snapshot can land after the run ends.

* fix(dbt): classify a restored retry by its resolved arguments

`add_caller_args` was handed `raw_args` on the retry path — the arguments as
SUBMITTED, where a `select` spelled `$res:` is still a string. `arg_list` then
refuses it as "must be a list of strings" and the retry dies before parsing,
for a reference that resolves to the very list the failed run built with. The
resolved map decides it now, matching the selection resolver and the build;
`raw_args` stays what is persisted and published, so no resolved secret outlives
the job. Verified against the shape it breaks on: a `select` from a resource,
failed, then resumed.

Two docs that outlived their code: `dbt_script_hash` is described as a fallback
for a job naming no deployed script rather than as the pinning mechanism, since
a script job's version comes from the job row and the query value is ignored
(spec plus the generated client, which carries the same sentence); and
`GraphRefresh`'s fields no longer claim a caller's selection only ever narrows,
which is the premise the previous commit disproved.

* fix(dbt): a hidden run keeps no retry state

The state is keyed by the execution principal, which every caller of an
`on_behalf_of` script shares, and a retry publishes the arguments it restored —
so for a run the other callers cannot read, that retry was the one way to see
them. The equivalence the key rests on ("resuming it is the same capability as
re-running it") holds only while the run IS readable, and exactly one run is not:
one pushed `invisible_to_owner`. Those now save nothing, and clear whatever the
previous run left, since this invocation happened. A hidden run therefore cannot
be resumed by anyone, its author included — the cheaper half of the trade, and
the reason having a retry NAME its source job is the design that would give it
back.

Verified: a visible failure still saves and resumes; a hidden one leaves no row,
and the retry after it refuses without returning the hidden `vars`.

Also collapses `GraphRefresh::caller_scoped`, which stopped distinguishing
anything once a selection override became per-run: both writers set both flags,
so `snapshot_job` and `publishes_ownership` are now one field and its negation —
which is what lets the agent payload carry a single `per_run` bit, recorded
there. `is_reserved_token_label` says why `ephemeral-` is reserved (a
client-chosen system label is a token its owner cannot list or revoke) rather
than restating a username rule its second prefix does not follow. And the
module-cache import comment states the invariant once, without the shape of the
cache that preceded it.

* fix(dbt): a pre-build failure leaves the saved run alone

Three exits cleared the retry state before `dbt build` ever ran: a preparation
failure, a failed `dbt parse`, a failed ingest. None of them touches a relation,
so the warehouse is exactly what the previous run left and its failures are still
the accurate description of it — clearing there just costs a resumable failure,
and a resume that no longer fits is refused by `run_identity` and the arguments
digest regardless. The reachable one is a cancellation during provisioning. Only
an interrupted BUILD invalidates, which the save at the end of the job already
decides.

Verified: a failure saves state, a run whose selection matches no node fails in
the ingest and leaves it, and the retry after that still resumes the original
failure.

Agent-published graphs also had no sweep — `Connection::Http` snapshots every run
and spawns none — so the EE endpoint prunes too (pinned at f58bf06), and
`prune_dbt_run_graphs` now names every writer rather than only the runs.

Drops `ephemeral-webhook-` from the reserved token labels: it yields the label
verbatim, not a bare username, so the check now matches the rule its doc and its
test state, and the reason given for it was wrong about what `is_user_token`
costs an owner. And the result contract lists `invocation_args` — the field most
needing it, being another invocation's arguments on a retry.

* fix(assets): decode a doubled delimiter when canonicalizing a table key

`split_relation` decodes it on the worker side, so the canonicalizer had to as
well: a relation whose identifier escapes its own delimiter — `"sales""east"` —
was filed by the ingest under `sales"east` and by a hand-written `table://`
annotation under `sales""east`. Two nodes for one table, no edge, which is the
exact split this key exists to prevent (decision 11). Fixed for both the name and
each half of a database-qualified schema segment, with a case per dialect.

`invalidate_run_state`'s contract also still promised the pre-build behaviour the
previous commit removed; it now names the cases that do invalidate — an
interrupted build, and a run hidden from the script's owners.

* fix(dbt): reclaim package trees no project asks for any more

The cache key covers the whole project digest — a `local:` dependency's content
is in no manifest, so nothing narrower is safe — which means every edit of a
project that declares packages publishes another full dependency tree, and
nothing ever removed one. A worker that lives through a hundred deploys held a
hundred trees until an operator cleared the entire cache by hand, and the disk
that fills fails every job on that worker, not only dbt's.

Swept by last USE, not by publication: a hit dates the tree, so a project
unchanged for months is not evicted from under the jobs still running it. The
marker is a sibling rather than a file inside the tree, which the restore copies
into the project. Staging directories go after a day — one belongs to a single
job and is removed when it ends, so an older one is from a worker that died
mid-publish. Verified by planting a 30-day-old tree and a stale staging dir: one
run reclaimed both and left a fresh tree alone.

Narrowing the key to the declared `local:` paths would fix the churn as well, and
is deliberately not done here: getting it wrong runs a project against another
revision's packages, which is worse than the disk it saves.

* docs(api): declare the dbt half of the asset-graph response

`AssetGraph` is the response of both `/assets/graph` and the new
`/jobs/dbt_graph/{id}`, and the spec described neither `assets[].dbt`,
`runnables[].dbt`, `dbt_edges` nor `dbt_snapshot_job` — so every client generated
from it saw a graph with no dbt metadata, no `ref()` lineage and no snapshot
marker, which is why the run page reaches the endpoint with a raw `fetch` and a
hand-written cast. `frontend/src/lib/gen` is gitignored, so the spec is the only
tracked description of this surface.

Declared, and the client regenerated from it now carries all four (verified: the
regen is otherwise a byte-for-byte no-op).

* fix(dbt): stop the package sweep from racing the restore it protects

Three faults in the sweep the previous commit added.

The `.last_used` marker was written AFTER the copy, and the tree it matters for
is the one at the retention edge — where the first use in a fortnight is also
when the sweep fires. So the source looked stale for the length of the restore
and a concurrent job's sweep could remove it mid-copy, failing a run that should
merely have refetched. Marked before the copy, and a restore that loses the race
anyway is treated as a cache MISS: `dbt deps` resolves the tree again, costing a
fetch rather than the run.

The sweep also sat inside `if let Connection::Sql`, though it is a walk of the
worker's own disk that needs no database — so an agent worker, which has none,
published a tree per project edit and reclaimed nothing. That is the state the
doc claimed was fixed, and the same argument the graph sweep makes two lines
above: retention that depends on the connection is not retention.

And the canonicalizer's two halves disagreed after `5890436`. `unquote_identifier`
requires the quote at both ends, so a lone `"` in an already-decoded name
survives; the schema walk treated one as opening a quote and dropped it, filing
the ingest's `sa"les` under `sales` while an annotation's `"sa""les"` decoded to
`sa"les` — the split this canonicalization exists to prevent, in the function I
had just touched. The halves share one rule now, and the test drives the decoded
spelling against the quoted one rather than asserting only the annotation's.

* fix(cli): track a dbt project's parent descriptor for every authored file

`buildTracker` decides whose top hash `wmill-lock.yaml` refreshes, and it reached
the module branch only for files matching a Windmill script extension. A dbt
project is mostly files that are not: `dbt_project.yml`, `packages.yml`, schema
YAML, seed CSVs. Editing any of them left the descriptor untracked and its
module-inclusive hash stale, so the lock disagreed with the bundle that was
pushed. Module paths are now handled ahead of that gate.

The parent was also derived by searching the RAW path for `__dbt/`, which finds
nothing on Windows, where the folder is spelled `__dbt\` — so even a model edit
was skipped there. It goes through `getScriptBasePathFromModulePath`, which
normalizes separators, and which the sibling helpers already used for this exact
reason.

The regression test drives all three shapes. With the old gate reinstated it
fails on the non-script files and on the backslash path, and passes only for
`.sql`.

* fix(dbt): re-resolve unlocked dependencies, and reclaim retry state nobody writes

A project with no checked-in `package-lock.yml` asked dbt to RESOLVE its ranges
and mutable git revisions, and dbt does that on every run. A cache hit skipped
`dbt deps` entirely and every hit refreshed the marker, so the first resolution
was pinned for as long as the project stayed in use — a version range that moved
was never picked up. An unlocked tree is now a miss once it is a day old; a
locked project keeps its tree, since the lock is in the key and pinning is what
it asked for.

Retry state: `invalidate_run_state` removed the pointer and left the generations,
and the whole state root was swept by nothing after `a236972` — so a script that
stops running, or a principal who stops running it, kept its last generations
(a `manifest.json` each) for good. Forgetting the state now prunes its
generations, and a 30-day sweep of the state root runs beside the package sweep,
for the reason that one already gives: retention that runs only for the script
being run is not retention for the ones that are not. This restores one half of
what `a236972` reverted — the local sweep, not the per-caller key or the row
retention — because it never depended on that key.

The graph orphan sweep also committed its marker delete separately from the two
deletes it gates, so an error or a restart in the gap left graph rows whose
marker was gone — and since the sweep only runs when a marker went, every later
call skipped it and those rows were unreachable for good. One transaction now.

`parseDbtRun` scans from the LAST brace: the payload is appended, so backwards
finds it immediately where forwards parsed the whole message once per brace in
the error text. And `reject_reserved_label` moved into `create_token_internal`,
the one path every caller-supplied label reaches, so the invariant sits where a
new route would break it.

* fix: undo two of my own regressions, and agree with the backend everywhere

`2e34dd48` hoisted the module check above the extension gate, which is right, but
did not bring the entry-point rule with it: a folder-layout script's METADATA is
`<base>__mod/script.yaml`, an entry-point path, and pushing it as a content file
makes the metadata pass ask for the language of `.yaml` and abort the whole
command. Reached by editing the summary of ANY modular script — pre-existing,
nothing to do with dbt. Metadata resolves to its content file now, with a test.

`d3716a09`'s unlocked-dependency refresh is reverted. It measured staleness
against the last-USE marker, which every hit rewrites, so an actively used
project never reached the threshold — and when it did fire, the re-publish
`rename` cannot land on a populated directory, so the freshly resolved tree was
discarded and the stale one re-stamped: a network resolve thrown away per idle
day. Doing it properly needs a publication timestamp and a publish that can
replace a tree; the limitation is recorded where the cache is keyed instead of
half-implemented.

`parseDbtRun` no longer counts braces in either direction. The payload is
appended pretty-printed, so its `{` is the only one at column zero — forwards
blew the cap on an error full of braces, backwards on one `{` per node, which a
few hundred nodes reaches. Test drives a 400-node failure.

And `parsePipelineAnnotations` was the third copy of the quote rule, still
splitting a doubled delimiter: the live canvas keyed `"sales""east"` as
`saleseast` where the deploy keys `sales"east`, so an annotation pointed at a
node the deployed graph does not have. All three agree now, including on a lone
delimiter in an already-decoded name.

* chore(dbt): leave cache retention and the migration's comment out of this PR

Two deliberate subtractions, so what ships is the set that has been verified
rather than the set that was written.

The package-tree and state-directory sweeps are gone (recoverable on
`dbt-cache-retention-followup`). They delete directories on a worker, they were
the newest code here, and one of them already needed a second pass for racing an
active restore — while what they buy is disk hygiene, not correctness: today an
operator's `cache_clear` reclaims these caches, exactly as it does for every
other language. Both limitations they addressed are now recorded where the cache
is keyed. `invalidate_run_state` still prunes the generations it orphans, since
that reuses the existing pruner and its grace window rather than sweeping a root
by age.

And the migration is back to its pre-PR bytes. The only change left in it was a
corrected comment, which every database that already applied this migration would
have paid for with a checksum mismatch at startup — the explanation lives in
`prepare_project` and in the design doc, which is where it is read.

* fix(dbt): pin the resolved package tree to the deployed version

A cache hit skipped `dbt deps`, so an unlocked range or mutable git revision
stayed on whatever the first worker resolved, and a retry could feed one
resolution's run_results.json to another. The deploy now records the digest of
the generated package-lock.yml, the package cache is keyed by it, and it joins
the run identity; a worker that resolves anything else is refused rather than
run.

Also carries the agent-wire round trip test for an ingested manifest, and the
EE pin for the agent publish endpoint.

* docs(dbt): state the dependency contract the deploy pins

The design doc still described the package cache as keyed by the project digest
alone, and carried an open question about refreshing unlocked dependencies that
the deploy-time pin answers: resolution happens once, at deploy, and every run of
that version installs it or is refused. Records what that costs and buys —
committing package-lock.yml makes deploys cache-hit, deploying again is what
picks up a newer range — and that these worker-local caches are reclaimed by
cache_clear, as every other language's are.

* fix(dbt): four findings from the review round

- An interrupted retry republished the results it had only restored. A retry
  starts with the previous attempt's run_results.json in place; cancelled before
  dbt rewrites it, the save dated those failures to this job, so the next retry
  rebuilt nodes this one had already redone. Verified by A/B: without the check
  the row survives, carrying the cancelled retry's id.

- The deploy refused a committed package-lock.yml that dbt itself updates, which
  it does whenever the sha1_hash it recorded for packages.yml no longer matches.
  Only a run has a resolution to be held to; the deploy establishes one.

- A second graph load for the SAME run could land out of order, leaving a
  finished run showing the deployed fallback for good.

- Directory nodes in the project tree carried no path, so two of one name at the
  same depth shared a collapse key and folded together.

* fix(dbt): name every adapter, and stop guessing which project owns a model

The invalid-adapter message listed four of the eleven accepted spellings.

And a relation may have several script producers, none of which the provenance
record identifies — prefixing the first one names a __dbt folder that does not
exist, so an ambiguous relation now shows the path inside the project alone.

* refactor(dbt): name the graph-snapshot column for when it is written

`published_relation_root` described a design persist_ingest does not use: the
root is recorded by every ingest that is not a run's own snapshot, including
one that publishes no ownership — deliberately, since a version that cannot
claim the path would otherwise record nothing and compare against a stale root
forever. The column comment said the opposite and the name followed it.

Safe to edit the migration in place because this PR introduces it: no database
outside a checkout of this branch has ever applied it. One that has needs

  UPDATE _sqlx_migrations SET checksum = decode('<sha384 of the file>','hex')
   WHERE version = 20260725084314;

alongside the column rename, or a fresh database.

* style(dbt): bring comment blocks within the four-line guidance

AGENTS.md asks for each invariant at the place someone would break it, in at
most four lines. The new dbt files carried 60 inline blocks past that, several
of them three rationales deep at one site.

Nothing durable is dropped: what covered several constraints at once is split
to the lines it constrains, and eight comments that had drifted above the wrong
test — six stacked over one profile test, two over the wrong executor test —
are reattached to the tests they describe.

* docs(dbt): carry the snapshot-column rename into the summarized schema

The rename reached the migration, both queries, the sqlx cache and the design
doc, but not the compact schema summary — which is the file agents read instead
of the migrations, so it was the one copy that could mislead silently.

* docs(dbt): bound the retry-state and package-pin residuals precisely

Two claims in the design doc were true but not precise enough to act on.

Retry state: the equivalence between resuming a failure and re-running the job
holds because folder read grants job read, which is also what grants execution.
It does NOT hold for a u/<owner> script shared through extra_perms, where no
folder policy applies and a grantee cannot read even their own on-behalf run.

The package pin: the refusal is per worker. A ranged dependency with no
committed lock reproduces its resolution only from a cache hit, so it keeps
running where the tree is warm and fails on the first cold worker.

* fix(dbt): refuse a retry of a run its caller cannot read

Retry state is keyed by execution principal, so every caller of an on_behalf_of
script shares one saved run. Under a folder that matches job visibility exactly,
but a u/<owner> script shared through extra_perms has no folder policy: a
grantee can read neither the run nor their own, while a retry published its
arguments.

The restore now applies require_job_read_access's rule — you can always read a
job you launched, otherwise the row must be visible under your own RLS.
Deliberately NOT job_perms, which carries the identity the job runs AS: for an
on_behalf_of script that is the owner, and probing with it authorizes everyone.

Verified with two members on one shared principal: bob is refused alice's run
on the u/ path and her marker never reaches his result, alice resumes her own,
and bob still resumes alice's run of the same script under a folder.

* fix(dbt): close the retry check's own gaps

The check landed with three holes and four rough edges, all found by review:

- A pruned source run was allowed. dbt_run_state outlives job retention, so
  that handed the last failure's arguments to whoever asked next. It now fails
  closed, and says so rather than claiming the run was someone else's.
- An agent worker skipped the check entirely: it reaches no database. The saved
  generation now records who launched it, and an agent authorizes the half it
  can prove — the launcher may resume. A generation written before this field
  is not resumable there.
- The row was authorized on one read and restored on another, so a run
  completing in between was restored unauthorized. restore_from_db now takes
  the job it was authorized against.

Also: restore_run_state's doc comment had drifted onto the new helper, the
not-a-member comment described the saved run rather than the caller, and the
refusal message carried a run of spaces from its line continuation.

* fix(dbt): keep the descriptor in --json sync, and fail closed on a stateless row

A dbt script's content is `<name>.dbt.yaml`, and `elementsToMap` drops every
.yaml when metadata is JSON — so a --json workspace tracked the metadata, the
lock and the whole project bundle but not the descriptor: a descriptor-only edit
pushed nothing and a fresh pull wrote a script with no source. Pinned by a test
that fails without the exemption.

And the retry check read job_id flattened, which merged "no row" with "a row
naming no job" and skipped authorization for the second. Unflattened, the row
that cannot be authorized is refused.

Also graph_digest: serde rather than {:?} for edges, and delimited parts.

* docs(dbt): state that retry authorization is by identity, not token scope

The section claimed the read-access equivalence was enforced. It is, for
identity — but the worker never sees the submitting token, and neither v2_job
nor job_perms records a scope, so a token denied jobs:read can still resume its
own principal's last failure. What it gets is the arguments as submitted, so a
reference is re-resolved under whoever retries rather than disclosed.

Also names the cases the check refuses outright, which were spread across three
commit messages and nowhere a reader would look.

* chore(dbt): repin EE after rebasing the agent-graph branch onto EE main

* fix(dbt): say why a test-only run has no models, instead of blaming the profile

A selection of tests alone builds nothing, and a test is an assertion rather
than a relation, so the ingest keeps nodes with no asset to hang on and the
graph comes back empty. The run is correct and its results render — but the
empty state named the one cause it is not, a project with no warehouse
identity, and sent the reader to their profile.

The graph itself is unchanged: retaining a selected test's attached model would
have a test-only script claim a read on every model it asserts against, which
is an asset-graph semantics change and wants its own review.

* fix(dbt): authorize a retry by RLS alone, and eight review findings

Retry authorization drops the created_by grant that mirrored
require_job_read_access's "you launched it". That name is a display name derived
from a token label, so a worker cannot tell a launcher from a collision — the
objection Codex raised on four heads. Visibility under the caller's own RLS is
the whole rule now. An on_behalf_of script under u/<owner> shared by extra_perms
is resumable by the owner alone; under a folder every caller keeps the resume.

Also, and each verified against the code first:

- The local generation is revalidated after the file work, so a newer run
  publishing state mid-restore no longer lets the superseded one resume.
- Both dbt zip lookups in sync normalize the OS separator, as the resource
  lookup beside them already did: on Windows a pulled dbt project was laid out
  as __mod, the one layout dbt cannot run from.
- A resource storing port as a string no longer silently connects to the adapter
  default; a value that is not a port is refused.
- An oversized but readable project file fails the deploy instead of shipping an
  incomplete project that compiles and fails at run time.
- cache_clear does NOT reach the dbt caches: it clears cache/ while these live
  under cache_nomount/, as bun's do. The doc said the opposite, and that claim
  was the justification for dropping the retention sweeps.
- A dbt unit test counts as a test for the empty-state message, as it already
  does for the worker's test-phase detection.
- Per-node results keep the catalog segment when rows disagree on it.
- The project panel copies through the app's clipboard helper, .dbt.yaml
  resolves back to dbt in EXTENSION_TO_LANGUAGE, and two test blocks clean up
  their temp directories.

A comment describing a race against a sweep this PR does not ship is gone.

* fix(cli): keep the oversized-file check to a bounded read

The refusal statted the file and then read it whole to tell text from binary,
which is the cost the two comments above it and isBundledModuleFile exist to
avoid: a multi-gigabyte seed would be loaded just to be refused. Same 8 KB head
read as that predicate.

* revert(dbt): accept the retry residual instead of gating it

Resuming grants no capability a caller lacks: they may already run the script as
that principal, and a plain run builds a superset of what a retry rebuilds. The
one thing a retry adds is information -- the result echoes the resumed run's
submitted arguments, for the row preview -- and in almost every shape the caller
could already read that run: a folder grants job read alongside execution, and an
ordinary script's runs are keyed under the caller's own principal. It takes a
user-path script AND extra_perms sharing AND on_behalf_of for the two to diverge.

Gating it needed an identity the worker does not have. created_by is
display_username(), which a token label supplies: trusting it authorizes a
collision, and resolving it as a username denied every labelled token -- a CI
token is `label-<name>`, no workspace member, so its own retry was refused. That
regression cost more than the exposure.

Kept, because none of it is about the caller:
- a cancelled retry no longer republishes the results it only restored,
- the restore is pinned to the row it chose rather than re-reading it,
- a newer run publishing mid-restore no longer lets the superseded generation
  resume.

The three sqlx entries the gate needed are gone with it.

* fix(dbt): select unit tests, and say why the state key is the boundary

`dbt ls` enumerated five resource types and omitted `unit_test`, which dbt treats
as its own type rather than a flavour of `test`. A descriptor selecting
`test_type:unit` or a unit test by name therefore resolved to the empty set,
which the deploy refuses outright with "matched no dbt nodes". Verified both
ways on a fresh path: the deploy fails without this and succeeds with it. All
three engines list `unit_test` among the accepted values.

The restore's state lookup now carries the reason it keys on the principal and
not the caller. That decision was in the design doc, the commit messages and a
PR thread — everywhere except the line someone would change to "fix" it, which
is where AGENTS.md asks for it and where I twice went wrong myself.

Also: the `GraphRefresh` doc claimed a dynamic descriptor publishes its graph as
the script's ownership, while `per_run_models` snapshots it under the job id and
`publishes_ownership()` returns false — only a moved profile republishes. And
`fn n` in dbt_profiles.rs had no callers left after `port_of` replaced it.

* feat(dbt): offer the resume on a failed run, where the choice is relevant

"Run again" prefills the arguments the run just used, so the obvious action after
a failure rebuilds the whole project while the cheap resume stays invisible
unless the reader knows dbt_command has a retry value.

A finished run with failed or skipped nodes now says how many, and links to its
own run form with the command already switched. A link rather than a submission:
the caller still presses Run, so nothing about permissions or arguments changes.

Deliberately not automatic. A resume is not a re-run — models are usually
rebuilt because upstream data moved, not because they failed — so a schedule
that resumed after a failure would leave every model that succeeded carrying
yesterday's data while reporting success.

* feat(dbt): put the command first, and offer the resume where the rebuild is

Three things made rebuilding the whole project the path of least resistance
after a failure, when resuming its failed and skipped nodes is what dbt offers:

- `dbt_command` was LAST in the generated signature, under `limit`. The schema's
  `order` drives the run form, so the argument that decides what the run does sat
  below the ones that only narrow it. It leads now, and the signature test
  asserts the order rather than the set, with the reason it is pinned.
- "Run again" prefills the arguments of the run it came from, so for a failed run
  it reproduces the rebuild. It now carries `dbt_retry_hint`, and the form shows
  what resuming would do instead -- without choosing it, so the caller decides.
- Its dropdown offers "dbt retry with same args" above the plain re-run, for a
  failed dbt job only: a run that succeeded has no saved failure to resume.

Verified in the browser: both dropdown labels render unclipped, the alert appears
only on that path and disappears once the command is switched, and the schema of
a redeployed script lists dbt_command first.

* feat(dbt): describe the run arguments, and hide the ones a command ignores

The form offered six fields at once with no indication that most of them apply
to one command each. `retry` reuses the arguments of the run it resumes, so
every override is ignored; `limit` belongs to `show`; `full_refresh` to `build`.

Each argument now carries what it is for, and a `showExpr` for when it applies,
which SchemaForm honours by hiding the field AND dropping its value from the
payload. Selecting `retry` leaves the command alone on the form.

Not modelled as a `oneOf`, which is the more precise shape: Windmill renders
that as a variant selector whose value is a nested object keyed by a
discriminator, so the arguments would stop being flat -- and the worker reads
them by name, as do schedules, webhooks, the CLI, saved inputs and the retry
state's own copy of them.

* fix(dbt): a retry may name the run it means to resume

The retry actions I added an hour ago appear on any failed run, but the saved
failure is keyed by script and principal rather than by job — so from an older
run's page they resumed whatever failed most recently, under a label promising
"same args". Both now pass `dbt_retry_job`, and a retry naming a run the state
no longer holds is refused with the id it does hold.

Verified: with failures A then B saved, a retry naming A is refused and names B
in the message, while a retry naming B resumes.

Also from the same review: the `select` help advertised `state:modified`, which
needs a comparison manifest this runtime supplies no `--state` for, and the
openflow note still described a dbt script as a descriptor naming a git repo
rather than the module bundle this ships.

* fix(dbt): make both retry actions actually name their run

`dbt_retry_job` is not a form field, so the banner's link to the run form dropped
it and the retry resumed whatever failed last — the bug the argument exists to
prevent, reintroduced by the affordance meant to use it. The banner submits the
run itself now, as the "Run again" dropdown item already did.

And an agent worker never applied the check at all: its `latest_job` is always
None, so the local generation was accepted unconditionally. Both reviewers found
this independently. The decision moved into `chosen_generation`, which the agent
path shares, with the refusal naming the run the worker does hold.

Pinned by a test that fails without the check, on the connection kind where it
was missing rather than on the one that already worked.

* fix(dbt): let an unchanged push be a no-op, and stop advertising a retry the form cannot aim

Two of a dbt script's fields are DERIVED by the server after the no-op check
runs: the lock, which only a dependency job can produce, and the schema, which
comes from the descriptor and which no client can derive (windmill-parser-wasm
has no dbt arm). The check compared what arrived instead of what would be
stored, so every unchanged `wmill sync push` created another version and another
dependency job -- the sync churn skip_if_noop exists to prevent. Both are now
compared as stored, with the parent required to hold a lock so a deploy whose
dependency job failed can still be retried by pushing again.

Verified by A/B on a faithful payload: without this the same unchanged push
creates a version, with it the existing hash comes back and the count holds.

The run form's retry hint is gone. `dbt_retry_job` is not a form field, so a
retry started there resumes the last failure of the script rather than the run
the message pointed at -- the two buttons name their run, that path could not.
Better to not offer it than to offer it wrong.

Also reunites a comment with the derivation it describes, 40 lines below where
an earlier edit of mine left it.

* docs(dbt): an unchanged push no longer re-resolves dependencies

The section told the reader that a byte-identical deploy re-pins a ranged
dependency, which was true only because no-op detection was broken for dbt. Now
that an unchanged push is skipped, moving a pinned resolution takes an actual
change.

* feat(dbt): offer the resume only on the run it would actually reach

* fix(dbt): a refusal names both the run asked for and the one held

* docs(dbt): say that show previews one node when several are selected

* feat(dbt): a retry names the run it resumes, and the form can fill it in

* refactor(dbt): make the run's command a oneOf carrying its own overrides

* fix(dbt): refuse a command block that names no command, and keep state off retired paths

* fix(assets): let copilot and the assets filter see warehouse tables

* fix(dbt): drop the unused db handle from the retry-principal lookup

* fix(dbt): stop a preview poll when the run page moves on

* fix(dbt): refuse an escaping packages-install-path, re-arm the graph poll on navigation

* docs(dbt): concurrent runs of one script are the script's to serialize

* fix(dbt): bound what the log tailer holds in the worker process

* fix(dbt): a stale prefill answer must not aim another script's retry

* fix(dbt): a rename leaves the old path archived, so state must not be rewritten there

* fix(dbt): keep a retry's routing inputs, and stop an app-embed token probing resumability

* docs(assets): state the authorization the graph helper expects of its callers

* fix(dbt): merge the retry into the fetched arguments, not the too-big placeholder

* fix(dbt): the command block's label decides the command, not map order

* fix(cli): an oversized dbt project file must not read as generated output

* fix(dbt): the prefill names a run only when the caller may read it

* fix(cli): refuse an oversized dbt file before anything reads its body

* fix(dbt): fold table paths as the deploy does, and preview with fetched args

* fix(dbt): stream an engine archive to disk instead of holding it in the worker

* refactor(assets): the dbt asset kind is dbt://, keyed on the relation

* chore: regenerate the auto-generated prompts for the dbt asset kind

* fix(assets): rename the kind at the callers that request it, and refuse an unknown one

* feat(dbt): show the project's models under the run form on the script page

* fix(dbt): the rename missed the dbt-edge membership keys, so the DAG lost every edge

* fix(dbt): a preview must run the dbt writer, with the form's arguments

* feat(dbt): the models graph takes the bottom of the script page, as a flow's does

* fix(dbt): an unknown outcome is not a pass, and a preview keys on its arguments

* feat(dbt): a warehouse is configured on the workspace, named like the lake

* feat(dbt): asset identity keys on the warehouse name, resolved for agents too

* feat(dbt): warehouses are configured in workspace settings

* feat(dbt): the descriptor lives in the project and is optional

* docs(dbt): the warehouse is a workspace setting and the descriptor is optional

* fix(dbt): the warehouse route names its capture, and the editor stores the map

* test(dbt): pin the warehouse setting round-trip and the job-scoped route

* fix(dbt): a project-owned profile must authorize the warehouse it names

* fix(dbt): the settings tab imports TextInput from where it lives

* fix(dbt): a warehouse name is validated wherever one enters, and an absent descriptor is not a diff

* fix(dbt): the settings inputs pass their placeholder the way TextInput takes it

* fix(dbt): pushing a project that has no descriptor is not an error

* chore(dbt): keep the module suffix private to its module

* fix(dbt): warehouses survive a fork or rename, and an empty descriptor is never a file

* fix(dbt): a workspace rename carries its dbt graph with it

* fix(dbt): a rename takes the run state with it, not only the graph

* chore(dbt): drop the query-cache entries the settings edits orphaned

* docs(dbt): state the three rules that keep an absent descriptor absent

* fix(dbt): an unreadable descriptor is an error, and an emptied one is a deletion

* feat(dbt): the warehouse is unpermissioned, like the workspace bucket

* feat(dbt): an agent worker's run reports its per-model state too

* docs(dbt): how an agent worker reports what it ran

* feat(dbt): a project-owned profile reports its database, so its models share nodes

* style(dbt): rustfmt the files this branch touched

* fix(dbt): drop the job id write_profiles no longer reads a resource with

* fix(dbt): a preview reads the graph's edges and sends the model, not the cache key

* fix(dbt): a deleted producer explains itself instead of a bare 404

* fix(dbt): one warehouse resolution path, interpolated against the job

* fix(dbt): a project with no descriptor pulls and opens in dev mode

* feat(dbt): one file tree, editable, and Test builds the model you have open

* fix(dbt): a preview asks the writer's own graph, and lfs keeps its omission

* fix(dbt): metadata stays beside the project, and only a model narrows a build

* fix(dbt): a descriptor-less project previews, and dev reloads the whole bundle

* fix(dbt): forks carry the graph, and a vanished project stops the push

* fix(dbt): no-auth resolves warehouses, and a preview runs the version it read

* fix(dbt): a retry recognizes its own run when the profile carries a job token

* fix(dbt): the project marker is not deletable and the descriptor path is reserved

* fix(dbt): a templated adapter type is refused, and a removed project archives

* perf(dbt): the manifest lands in batches, and .py models are creatable

* fix(dbt): only a 404 excuses a failed archive, and edges are covered

* fix(dbt): a python model narrows the build, and a failed removal is not silence

* fix(dbt): a settings name may be any word, and the reserved path is stated once

* fix(dbt): an absent descriptor needs its project, and the form matches the run

* fix(dbt): a bundle is dbt by language, and both job routes agree who may call

* docs(dbt): every identity doc names the warehouse, as the code does

* perf(dbt): an agent posts its run's progress once, and show cannot touch a seed

* fix(dbt): bound what a warehouse may be named, and say who may ask

* fix(dbt): a run's graph withholds what the project's author wrote, and dbt_project.yml is rendered before it is read

* feat(dbt): withhold dbt from the language picker until it has its own editor

* fix(dbt): refuse a path claimed by both a dbt project and an ordinary script

* test(dbt): the bundle assertion is a set, not an order

* fix(dbt): a project's generated dirs are re-read when its config changes

* test(dbt): assert the synthesized descriptor without assuming a separator

* fix(dbt): both push paths refuse a shared path, and every writer sweeps its progress rows

* fix(dbt): preview only what dbt show can select, and a retry keeps its command block

* fix(dbt): an identifier carrying a path separator gets no asset key

* fix(dbt): no engine ships in an image, and show may name only one node

---------

Co-authored-by: Claude Opus 5 <noreply@anthropic.com>
---
 .agents/skills/update-sqlx/SKILL.md           |   75 +-
 AGENTS.md                                     |   58 +
 ...b5829657224a743af9c0b2d5a140ad70e13dd.json |    3 +-
 ...fd945796a2657e58cf1c5086d971e652803d5.json |   17 +
 ...8d35a313fc321df788e1c701e11f60da46480.json |   29 +
 ...0d778a27619dd7fad71ba656f6b54c4915d1e.json |    3 +-
 ...5443dc634b8628e90cce879952c8c4319a6a6.json |   17 +
 ...7038750a44a67360d342b6ef705ef2e4d3007.json |   15 +
 ...8d1d346f9d67056ef272314dd9b80bee9f285.json |    6 +-
 ...b921c308b6a047530eccd8966513ffdc722d0.json |    3 +-
 ...6249fa16fd913dc1a2c7babc329cc2d636342.json |   15 +
 ...0501ed3098f33a234f283def6932ce491eb66.json |   17 +
 ...6836099dd325fa25d3660eb766a895b07c1da.json |   15 +
 ...8b92697ae3640a2e680395c2958c5d8664e27.json |   16 +
 ...d0751f77f9cb41055481bc06af6827d647041.json |    3 +-
 ...0c98c1dc8c913dc95b691cc6f92ffcd57989e.json |   15 +
 ...3c600224681e11c016eea5cee3086a7bea8d0.json |   15 -
 ...4ff3ff25fb57954dd1ba2d552c7b263696c07.json |   17 +
 ...1ec620fc98c5fb77061ed192a6f75bea2b049.json |   16 +
 ...061d2562c3ac4af8d088f9eea9f0bc11d5fe7.json |    3 +-
 ...f72ece70ec92c5b04baad2622639850445900.json |    3 +-
 ...cf0d8d2a3d7e8552d8ad09512d2d6bf27c3fb.json |    3 +-
 ...014f869ade4a139956dcb082f0524779f7680.json |   24 +
 ...dc8c5729cb2b828cae94c047b896ebff37fd3.json |   24 +
 ...5cc16f6216de6e483f3bbb1c2f54b51a37a24.json |   18 +
 ...a8c69a3151266e2bf475da10feb4916e436e9.json |    3 +-
 ...ce702603b7ae170054cda7ed5f6f0a9f44a28.json |   16 +
 ...a8835f2630389dc339be0fda614ddb4d773df.json |   17 +
 ...2d96f22375fa2b1eccafb7f09928a8b0cb549.json |   15 +
 ...aee26c81a8fe909e12ae997eaaba83ade634d.json |   17 +
 ...cb3adcf0175d0a71013f2497397c1c8ccc619.json |    3 +-
 ...554314177fc11bc82212d95182e3723e64c6b.json |   15 +
 ...2de473e3f319ba13fa0784dd5bef24224233c.json |   15 +
 ...800c2d068cbafbd279454724451d7f57e108e.json |   16 +
 ...6e5ce78c738c163b3ccdc3fe252b2980f6f1d.json |   35 +
 ...f0afc28f425b061e90e1dfc6133b426a7f339.json |   22 +
 ...26fe8fb6aefe54ad5862cad9b8fd9868cdd91.json |   15 +
 ...f06e6ad12305a5b845948dc200f304fb87a61.json |   22 +
 ...169fbc7a500c11e79d2c78d6eccccf6491aec.json |    3 +-
 ...9ea2f0a41771376720fb72c6b3c1fa4972eab.json |    3 +-
 ...9649d0f5db125776fbdffea993a53a09708de.json |    3 +-
 ...e0a0401517a9b60e5689d3c9cdc9a87aaf2a8.json |   15 +
 ...c4352708f65a6c094a89b4cafa1e6450a4e6a.json |   23 +
 ...87562dbdac633f3248ac228e00b7c8b49b800.json |    6 +-
 ...59b785515a79dcda3745663e4c4f2cf328389.json |    3 +-
 ...f669cfde49cc9872228998ce4a00b829250a1.json |   30 +
 ...f6d2c2caa94f39a0e57fe015e19fd1d0ab0ea.json |    3 +-
 ...9101644d1869af85687ab55067308644a2523.json |   23 +
 ...e07f0965efb65c51580c529e61d09b8742dfd.json |    3 +-
 ...9c3d7b2fb156a43299e9a1209d05293c4f50f.json |    3 +-
 ...ef5fb7c5ae46bede607cca308e1d5778e6d1e.json |   62 +
 ...502cc7e848b82cc8a3e6032d8cd030ee8a1db.json |   15 +
 ...fec074f8e02408efc6da2c742d81fd47c14f0.json |   24 +
 ...f980f712f92798d11feaeb0832962ad9ddb2e.json |    3 +-
 ...f16a8fc4fdf0bcebecfd21c9b7154dedea25f.json |   16 +
 ...36f495a84e0ad7d60fd39eddcccbc129d43c8.json |    3 +-
 ...46cb485c593b6df2194ae91ba2d8c584c0cce.json |   42 +
 ...ae110e2c0628b2721a44735f4fc06e59b5c77.json |   23 +
 ...46c5fcc0c3654746c5e65994123ffb4d05f78.json |   15 -
 ...036c6967b5a2ebb88cf174f435a2ce692c5dc.json |   23 +
 ...1fdb97b053620ac14b8196ebf09208510fb1f.json |   17 +
 ...8c20a9e310092ae787efe4b0657399c799424.json |    3 +-
 ...ecdac6806e1a306dca880943d97bb6d6a889d.json |    3 +-
 ...20748a912eff01dda22df9f489b6703435166.json |   16 +
 ...4d04b941e928c7621e66d3bdc510c335f8c20.json |    3 +-
 ...e136b562ace2d8265c9d26bcdf866f0f2c280.json |   15 +
 ...3460b6438d0a320b5554acec0beddbdeb008b.json |    3 +-
 ...520d67718b2c60e717d69439ea13da272c81e.json |   23 +
 ...66eb7a83e312b88f0244d1c517b03a9bcdea0.json |    3 +-
 ...51756433c03af6e7810c2a5f9421515df8aa3.json |   29 +
 ...2f8f0ca36920ab66e8922815157a0c147bc47.json |   15 +
 ...b12a4c8aa3dda05cceb694234107eb324cbf9.json |   16 +
 ...25b58b5ce504f2f4c4db952a796b3019a67d0.json |   15 +
 ...9be14ec5518c6ba8572362f5a849657237294.json |   17 +
 ...59c77a37ef784fdac78ca1e7a971e141e780f.json |    3 +-
 ...2b6abc0829349a2b189083f61cf06c15113fe.json |  134 +
 ...89ccc84720581d7e3661c5eb2719c8ccff08a.json |   15 +
 ...9e16ea112e0a3855cc730d2fe99259c64eb41.json |   23 +
 ...e33244fe8ab9a803248fc23f334034d24aad4.json |    3 +-
 ...a9c6f2ede08c33605c6a3c3dfc213a3eda76a.json |   15 +
 ...8807bc464a81c0883e68f5a69b89b94b0b34b.json |    3 +-
 ...faaf06b89fb7396a1a7bf9f370c32d6ad67ee.json |   23 +
 ...296ce9855bce50ea8c5918941564a696c029c.json |   14 +
 ...2790ff61549c5dd76e5b5cfb14b110a98abf2.json |    3 +-
 ...8207e1b46ba34fcb0f6957caef4be49bbbaa9.json |   23 +
 ...250879d18751a53597ef262b63d1e29bcb6a7.json |   15 +
 ...bf54a3f182c03cef0aef06a1c75b45992cd39.json |   23 +
 ...99a11874d6680f584324827f0ae59bb9fe506.json |   16 +
 ...01aa9d12e461a89243bd0b651d1e5b837b6f4.json |   16 +
 ...c2cb01d65b1b46693331ac157dfca0dab6824.json |    3 +-
 ...35b8a1e4d1ba18298ace1602defacb9e67f0c.json |   16 +
 ...c2a3bd3ca8334f6cb5eaf42e14265a32ae472.json |   15 +
 ...5225058fb14d29a8a4de04fe161af0ff2d167.json |   16 +
 ...e8fda531e69a880d0ebc44fb5f13ac976b67d.json |    3 +-
 ...9746147aa9b8d0a81642a7b7cb4738a0cad66.json |    3 +-
 ...e0d075701d541a44dd7a0b586d1f337ced5e1.json |    3 +-
 ...43d44a23f2fe2abf7a9ff8f271f9dfb1433e3.json |   14 +
 ...df037178ba246092dbc1d2b3816e7a9269dc3.json |    6 +-
 ...af736b456dbdd7d358e58744aa565e5889241.json |   21 +
 ...7285177bd4eaa3a14af5bf08dbc32c7bda558.json |   23 +
 ...7446a5e8e23d87eebc46bbb90bdbdf128935b.json |    3 +-
 ...4a7b4604171d12c6a4620514c6d030086936d.json |    3 +-
 ...e1ea2fe96a1b94f5a92953fb1c1642d15c016.json |    3 +-
 ...897c5ad764a882b2c9054a7665dd68b7a528b.json |   14 +
 ...ef1ae7c58848714974a8c803085a0c0e655d6.json |   16 +
 ...cc3ee04f6782587bc34d44338d2b2cad03165.json |   14 +
 ...a4a07af79130e1dbfd91f1601c04721186609.json |   16 +
 ...0bcf0691ab2554ead6b489a8441a32fc0af82.json |    3 +-
 ...1fcce10865992242cd053779760cc68909ff7.json |   15 +
 ...9352d4d1e3cb3a8a08f1c9c03055a1cab1235.json |    3 +-
 ...cbc2a399e3a0e126c9ba7d0558d37c16926fa.json |   30 +
 ...bd7c687900b66cd8c3a173f2e3410e4ed86d9.json |   24 +
 ...20eb439a80d52ae75ebd25128ffce759cd313.json |    3 +-
 ...b6771e9a2bcc847c5b64ee784b469242a1717.json |   32 +
 ...6845c6249c4598c4e16aa50067fdc6136451c.json |   15 +
 ...887c5424562acd9769c80c5899193ef16b56b.json |    3 +-
 ...465e579dd71a9439a2182ef05d9d3cfe462e.json} |   40 +-
 ...09de8863a5d10a482f012ee790eda64e88211.json |    3 +-
 ...6be1bceb79c82e7b5542f17b23b6d70cc02d6.json |    6 +-
 ...a6420ac7e0d548fb59473a2f7ac5be2ee5194.json |   24 +
 ...aa73793c99a2ab5793bebc5924146f60d19a8.json |   62 +
 ...8545c969d995dc02aaf6673183a73cab67179.json |   24 +
 ...4f01ceb707d9ae0b02bf382d4f5dca73829e2.json |   25 +
 backend/Cargo.lock                            |    6 +
 backend/ee-repo-ref.txt                       |    2 +-
 .../20260725084224_add_dbt_lang.down.sql      |    1 +
 .../20260725084224_add_dbt_lang.up.sql        |    2 +
 .../20260725084314_dbt_runtime.down.sql       |    7 +
 .../20260725084314_dbt_runtime.up.sql         |  218 +
 ...terialized_partition_job_id_index.down.sql |    1 +
 ...materialized_partition_job_id_index.up.sql |    9 +
 .../windmill-parser-py-asset/src/lib.rs       |    2 +-
 .../parsers/windmill-parser-wasm/Cargo.lock   |    5 +
 .../parsers/windmill-parser-wasm/src/lib.rs   |    8 +
 .../parsers/windmill-parser-yaml/Cargo.toml   |    3 +
 .../parsers/windmill-parser-yaml/src/dbt.rs   |  768 +++
 .../parsers/windmill-parser-yaml/src/lib.rs   |    7 +
 .../windmill-parser/src/asset_parser.rs       |  307 +-
 .../tests/pipeline_annotations_parity.rs      |    1 +
 backend/summarized_schema.txt                 |   17 +-
 backend/windmill-api-assets/Cargo.toml        |    4 +
 backend/windmill-api-assets/src/lib.rs        |  555 +-
 .../tests/dbt_pinned_graph.rs                 |  348 +
 .../tests/fixtures/base.sql                   |  146 +
 backend/windmill-api-auth/src/lib.rs          |   12 +-
 .../tests/workspaces.rs                       |   43 +
 .../src/asset_inference.rs                    |    7 +
 backend/windmill-api-scripts/src/scripts.rs   |  145 +-
 backend/windmill-api-users/src/users.rs       |   14 +
 .../windmill-api-workspaces/src/workspaces.rs |  169 +
 .../src/workspaces_extra.rs                   |   26 +-
 backend/windmill-api/build.rs                 |    4 +-
 backend/windmill-api/openapi.yaml             |  713 ++-
 backend/windmill-api/src/ai_skills.rs         |    2 +-
 backend/windmill-api/src/dbt.rs               |  211 +
 backend/windmill-api/src/jobs.rs              |  316 +
 backend/windmill-api/src/lib.rs               |    2 +
 .../src/mcp/auto_generated_endpoints.rs       |    6 +-
 backend/windmill-api/src/workspaces_export.rs |   25 +-
 backend/windmill-common/src/assets.rs         |    5 +
 backend/windmill-common/src/cache.rs          |   58 +-
 backend/windmill-common/src/client.rs         |   53 +
 backend/windmill-common/src/dbt_manifest.rs   | 1696 +++++
 .../windmill-common/src/global_settings.rs    |    3 +-
 .../windmill-common/src/instance_config.rs    |    4 +-
 backend/windmill-common/src/lib.rs            |    1 +
 backend/windmill-common/src/worker.rs         |    1 +
 backend/windmill-common/src/workspaces.rs     |  130 +
 .../tests/dbt_graph_storage.rs                |  345 +
 backend/windmill-queue/src/asset_dispatch.rs  |   15 +-
 backend/windmill-types/src/assets.rs          |   13 +
 backend/windmill-types/src/scripts.rs         |    5 +-
 backend/windmill-worker/Cargo.toml            |    1 +
 .../nsjail/run.dbt.config.proto               |  138 +
 backend/windmill-worker/src/agent_workers.rs  |    2 -
 .../windmill-worker/src/ansible_executor.rs   |   96 +-
 backend/windmill-worker/src/common.rs         |   92 +
 .../windmill-worker/src/csharp_executor.rs    |    4 +-
 backend/windmill-worker/src/dbt_engine.rs     |  771 +++
 backend/windmill-worker/src/dbt_executor.rs   | 5572 +++++++++++++++++
 backend/windmill-worker/src/dbt_profiles.rs   |  908 +++
 backend/windmill-worker/src/handle_child.rs   |   78 +
 backend/windmill-worker/src/lib.rs            |    3 +
 backend/windmill-worker/src/php_executor.rs   |    4 +-
 backend/windmill-worker/src/rust_executor.rs  |    4 +-
 backend/windmill-worker/src/worker.rs         |   27 +
 .../windmill-worker/src/worker_lockfiles.rs   |  122 +-
 cli/bun.lock                                  |   21 +-
 cli/package.json                              |    3 +-
 cli/src/commands/dev/dev.ts                   |  104 +-
 .../generate-metadata/generate-metadata.ts    |    6 +-
 cli/src/commands/pipeline/docs.ts             |    5 +-
 cli/src/commands/pipeline/localGraph.ts       |   85 +-
 cli/src/commands/pipeline/pipeline.ts         |   15 +-
 cli/src/commands/script/script.ts             |  261 +-
 cli/src/commands/sync/sync.ts                 |  938 ++-
 cli/src/guidance/skills.gen.ts                |    2 +-
 cli/src/types.ts                              |    7 +-
 cli/src/utils/metadata.ts                     |   96 +-
 cli/src/utils/resource_folders.ts             |  345 +-
 cli/src/utils/script_common.ts                |    6 +-
 cli/test/dbt_module_tracker_unit.test.ts      |  145 +
 cli/test/dbt_optional_descriptor_unit.test.ts |  211 +
 ...ements_to_map_branch_specific_unit.test.ts |   42 +
 cli/test/pipeline_local_graph_unit.test.ts    |   94 +
 cli/test/resource_folders_unit.test.ts        |  200 +-
 .../src/path-utils/path-assigner.ts           |    2 +
 docker/DockerfileFull                         |   13 +
 docker/DockerfileFullEe                       |   13 +
 docs/agent-worker-e2e.md                      |  131 +
 docs/dbt-runtime.md                           | 1083 ++++
 frontend/package-lock.json                    |    8 +-
 frontend/package.json                         |    2 +-
 .../lib/components/DefaultScriptsInner.svelte |   11 +-
 .../src/lib/components/DisplayResult.svelte   |   13 +
 .../src/lib/components/HighlightCode.svelte   |   11 +-
 .../src/lib/components/ScriptBuilder.svelte   |   33 +
 .../src/lib/components/ScriptEditor.svelte    |  162 +-
 .../EmptyInlineScript.svelte                  |    4 +-
 .../assets/AssetGraph/AssetGraphCanvas.svelte |  133 +-
 .../AssetGraph/AssetGraphDetailsPane.svelte   |   41 +-
 .../assets/AssetGraph/AssetNode.svelte        |  115 +-
 .../AssetGraph/PipelineGraphEditor.svelte     |    7 +-
 .../assets/AssetGraph/RunnableNode.svelte     |   31 +-
 .../assets/AssetGraph/cascadeRun.ts           |    2 +-
 .../AssetGraph/hideDbtRunnables.test.ts       |   99 +
 .../assets/AssetGraph/hideDbtRunnables.ts     |   40 +
 .../parsePipelineAnnotations.test.ts          |   59 +
 .../AssetGraph/parsePipelineAnnotations.ts    |   89 +-
 .../assets/AssetGraph/pipelineTemplates.ts    |    8 +-
 .../assets/AssetGraph/resolveGraph.test.ts    |  133 +-
 .../assets/AssetGraph/resolveGraph.ts         |   81 +-
 .../lib/components/assets/AssetGraph/types.ts |   68 +
 frontend/src/lib/components/assets/lib.ts     |    8 +
 .../common/languageIcons/LanguageIcon.svelte  |    3 +
 .../copilot/chat/flow/assetKind.test.ts       |   35 +
 .../copilot/chat/flow/openFlowZod.gen.ts      |    4 +-
 .../lib/components/dbt/DbtProjectPanel.svelte |  214 +
 .../src/lib/components/dbt/DbtRunGraph.svelte |  769 +++
 .../lib/components/dbt/DbtRunResult.svelte    |  146 +
 .../lib/components/dbt/parseDbtRun.test.ts    |  193 +
 .../src/lib/components/dbt/parseDbtRun.ts     |  247 +
 .../src/lib/components/dbt/previewRows.ts     |   68 +
 .../flows/content/FlowInputs.svelte           |    4 +-
 .../flows/content/FlowInputsQuick.svelte      |    4 +-
 .../components/icons/AssetGenericIcon.svelte  |    4 +-
 .../src/lib/components/icons/DbtIcon.svelte   |   27 +
 frontend/src/lib/components/worker_group.ts   |    3 +-
 .../workspaceSettings/DbtSettings.svelte      |  173 +
 frontend/src/lib/infer.ts                     |    6 +-
 frontend/src/lib/mcpEndpointTools.ts          |    6 +-
 frontend/src/lib/script_helpers.ts            |   42 +
 frontend/src/lib/scripts.ts                   |   56 +-
 .../(root)/(logged)/assets/+page.svelte       |  165 +-
 .../(logged)/pipeline/[folder]/+page.svelte   |   16 +-
 .../(root)/(logged)/run/[...run]/+page.svelte |   85 +-
 .../scripts/get/[...hash]/+page.svelte        |  115 +-
 .../(logged)/workspace_settings/+page.svelte  |   35 +
 openflow.openapi.yaml                         |    5 +
 system_prompts/auto-generated/flow.md         |    2 +-
 system_prompts/auto-generated/prompts.ts      |    2 +-
 .../auto-generated/skills/write-flow/SKILL.md |    2 +-
 262 files changed, 22823 insertions(+), 853 deletions(-)
 create mode 100644 backend/.sqlx/query-03238f44f8d4db3ed406f853b5afd945796a2657e58cf1c5086d971e652803d5.json
 create mode 100644 backend/.sqlx/query-04896f435eee78f5ac604f5a57c8d35a313fc321df788e1c701e11f60da46480.json
 create mode 100644 backend/.sqlx/query-0b3754e11677390837ec7ab00ba5443dc634b8628e90cce879952c8c4319a6a6.json
 create mode 100644 backend/.sqlx/query-0c5b02b6b70fb8fd2ab3e6c57897038750a44a67360d342b6ef705ef2e4d3007.json
 create mode 100644 backend/.sqlx/query-11d979216951a85835c15e02c756249fa16fd913dc1a2c7babc329cc2d636342.json
 create mode 100644 backend/.sqlx/query-12912ebe5df4eda15976e7c3a2f0501ed3098f33a234f283def6932ce491eb66.json
 create mode 100644 backend/.sqlx/query-19d19f3ed995ac68d9692c8fdf96836099dd325fa25d3660eb766a895b07c1da.json
 create mode 100644 backend/.sqlx/query-1d4fb43c4856679371abfa5eeea8b92697ae3640a2e680395c2958c5d8664e27.json
 create mode 100644 backend/.sqlx/query-1f39f7ca0c04e825d3648906eed0c98c1dc8c913dc95b691cc6f92ffcd57989e.json
 delete mode 100644 backend/.sqlx/query-2213dc4b594d27b3788c48b19e13c600224681e11c016eea5cee3086a7bea8d0.json
 create mode 100644 backend/.sqlx/query-229cc3975b7f579c35ac0daa9204ff3ff25fb57954dd1ba2d552c7b263696c07.json
 create mode 100644 backend/.sqlx/query-22be2359b966bd92d8327f142281ec620fc98c5fb77061ed192a6f75bea2b049.json
 create mode 100644 backend/.sqlx/query-2a8b9b199a6d383ed39a64dad54014f869ade4a139956dcb082f0524779f7680.json
 create mode 100644 backend/.sqlx/query-2d943b22eb69010f3c2388b9443dc8c5729cb2b828cae94c047b896ebff37fd3.json
 create mode 100644 backend/.sqlx/query-2f883466fb4237a3bee51813d1b5cc16f6216de6e483f3bbb1c2f54b51a37a24.json
 create mode 100644 backend/.sqlx/query-33b9ef6fabbb5f0de64246b51f0ce702603b7ae170054cda7ed5f6f0a9f44a28.json
 create mode 100644 backend/.sqlx/query-38125105da39bfedbdc1396fe37a8835f2630389dc339be0fda614ddb4d773df.json
 create mode 100644 backend/.sqlx/query-381d59e7ab08e2ae7147e4c277a2d96f22375fa2b1eccafb7f09928a8b0cb549.json
 create mode 100644 backend/.sqlx/query-3b40cccf059fbd28ff9c8d0004daee26c81a8fe909e12ae997eaaba83ade634d.json
 create mode 100644 backend/.sqlx/query-41428ecb8940a8fb4043b71eacb554314177fc11bc82212d95182e3723e64c6b.json
 create mode 100644 backend/.sqlx/query-4330e66917f04dc6597d323e9102de473e3f319ba13fa0784dd5bef24224233c.json
 create mode 100644 backend/.sqlx/query-4374167ebf64c4e8dd683e31451800c2d068cbafbd279454724451d7f57e108e.json
 create mode 100644 backend/.sqlx/query-44ee3944c35080999850a85857d6e5ce78c738c163b3ccdc3fe252b2980f6f1d.json
 create mode 100644 backend/.sqlx/query-471edf439cb293aa824440a2ef2f0afc28f425b061e90e1dfc6133b426a7f339.json
 create mode 100644 backend/.sqlx/query-493b29e093bb2b8f8ed6947843e26fe8fb6aefe54ad5862cad9b8fd9868cdd91.json
 create mode 100644 backend/.sqlx/query-4ed961992cd6c99e2efe889ab1cf06e6ad12305a5b845948dc200f304fb87a61.json
 create mode 100644 backend/.sqlx/query-56badc145d03676b6bd80a3830ce0a0401517a9b60e5689d3c9cdc9a87aaf2a8.json
 create mode 100644 backend/.sqlx/query-58e7d590631294899025c2cc279c4352708f65a6c094a89b4cafa1e6450a4e6a.json
 create mode 100644 backend/.sqlx/query-5cda335f22d96fb8bf351f03248f669cfde49cc9872228998ce4a00b829250a1.json
 create mode 100644 backend/.sqlx/query-5fd6467e3316b64e0451614d6bb9101644d1869af85687ab55067308644a2523.json
 create mode 100644 backend/.sqlx/query-6d89436b268157453784087c076ef5fb7c5ae46bede607cca308e1d5778e6d1e.json
 create mode 100644 backend/.sqlx/query-71462a33d126a7b70c5ef570c63502cc7e848b82cc8a3e6032d8cd030ee8a1db.json
 create mode 100644 backend/.sqlx/query-717188b993d9c87f2de51d8edbafec074f8e02408efc6da2c742d81fd47c14f0.json
 create mode 100644 backend/.sqlx/query-71b341ba06d588a7fb425d97921f16a8fc4fdf0bcebecfd21c9b7154dedea25f.json
 create mode 100644 backend/.sqlx/query-7be4645fe51c8a9bd13645a245846cb485c593b6df2194ae91ba2d8c584c0cce.json
 create mode 100644 backend/.sqlx/query-7c19d92d25b799e8872452c5c77ae110e2c0628b2721a44735f4fc06e59b5c77.json
 delete mode 100644 backend/.sqlx/query-8058042d5564a934534517e9c0446c5fcc0c3654746c5e65994123ffb4d05f78.json
 create mode 100644 backend/.sqlx/query-843ef7d1c619d2784306fa1dd06036c6967b5a2ebb88cf174f435a2ce692c5dc.json
 create mode 100644 backend/.sqlx/query-850b5e3414851e53f9d5580b0ab1fdb97b053620ac14b8196ebf09208510fb1f.json
 create mode 100644 backend/.sqlx/query-8a40b3e7b9c59f1a0b50d3fe6b320748a912eff01dda22df9f489b6703435166.json
 create mode 100644 backend/.sqlx/query-8bad2a916f9afe1c037a01ffe69e136b562ace2d8265c9d26bcdf866f0f2c280.json
 create mode 100644 backend/.sqlx/query-8e4397a299c29687bec108899bd520d67718b2c60e717d69439ea13da272c81e.json
 create mode 100644 backend/.sqlx/query-932f7d0df4ab3e200b9eaea424f51756433c03af6e7810c2a5f9421515df8aa3.json
 create mode 100644 backend/.sqlx/query-94c0aae349172b9295b81b9e61e2f8f0ca36920ab66e8922815157a0c147bc47.json
 create mode 100644 backend/.sqlx/query-96ba9c55e1f3b6ec20ce4c21a72b12a4c8aa3dda05cceb694234107eb324cbf9.json
 create mode 100644 backend/.sqlx/query-972ee0dd58b98c1f0ff7242922e25b58b5ce504f2f4c4db952a796b3019a67d0.json
 create mode 100644 backend/.sqlx/query-9809fad5552d306f8cf04dfd9059be14ec5518c6ba8572362f5a849657237294.json
 create mode 100644 backend/.sqlx/query-9d97c18abb292c841c3c95510022b6abc0829349a2b189083f61cf06c15113fe.json
 create mode 100644 backend/.sqlx/query-a2e7c8c0d1cc256e59976845c5189ccc84720581d7e3661c5eb2719c8ccff08a.json
 create mode 100644 backend/.sqlx/query-a4651f0ec5daaa0cbf09a71a7da9e16ea112e0a3855cc730d2fe99259c64eb41.json
 create mode 100644 backend/.sqlx/query-a6decdebcd9750691f20f874b66a9c6f2ede08c33605c6a3c3dfc213a3eda76a.json
 create mode 100644 backend/.sqlx/query-a99c9c63fee048333bbf633bb92faaf06b89fb7396a1a7bf9f370c32d6ad67ee.json
 create mode 100644 backend/.sqlx/query-aa463baab01d9530ae97ace8b5a296ce9855bce50ea8c5918941564a696c029c.json
 create mode 100644 backend/.sqlx/query-ac113ee13ac2b6e8da5ebb6bf9f8207e1b46ba34fcb0f6957caef4be49bbbaa9.json
 create mode 100644 backend/.sqlx/query-af2f8c70ad5a14d35048211631b250879d18751a53597ef262b63d1e29bcb6a7.json
 create mode 100644 backend/.sqlx/query-b19f5156b3e36b5e831ce792637bf54a3f182c03cef0aef06a1c75b45992cd39.json
 create mode 100644 backend/.sqlx/query-b24c1ed9aa3b856eed3da73eadb99a11874d6680f584324827f0ae59bb9fe506.json
 create mode 100644 backend/.sqlx/query-b2dd773eebe0005eb4220f19e6a01aa9d12e461a89243bd0b651d1e5b837b6f4.json
 create mode 100644 backend/.sqlx/query-b546a7a68143a3b0de1d900e5f635b8a1e4d1ba18298ace1602defacb9e67f0c.json
 create mode 100644 backend/.sqlx/query-bc59b7d863fc9df10cddf7487d6c2a3bd3ca8334f6cb5eaf42e14265a32ae472.json
 create mode 100644 backend/.sqlx/query-bd293b1e468f70dcc21ab4a91eb5225058fb14d29a8a4de04fe161af0ff2d167.json
 create mode 100644 backend/.sqlx/query-c1a85cf2d1555ae33bbdaf85cf243d44a23f2fe2abf7a9ff8f271f9dfb1433e3.json
 create mode 100644 backend/.sqlx/query-c2e5f233e134ccc70b05d62239aaf736b456dbdd7d358e58744aa565e5889241.json
 create mode 100644 backend/.sqlx/query-c868e87f7ccc5ce19c421c857f67285177bd4eaa3a14af5bf08dbc32c7bda558.json
 create mode 100644 backend/.sqlx/query-d735f355d9eb2612b563b606c6c897c5ad764a882b2c9054a7665dd68b7a528b.json
 create mode 100644 backend/.sqlx/query-dbe64a8367fad74866b15f96565ef1ae7c58848714974a8c803085a0c0e655d6.json
 create mode 100644 backend/.sqlx/query-e013b906ba3e95350ebcda6a8b8cc3ee04f6782587bc34d44338d2b2cad03165.json
 create mode 100644 backend/.sqlx/query-e01e9040f2336d9db41638842c5a4a07af79130e1dbfd91f1601c04721186609.json
 create mode 100644 backend/.sqlx/query-e3fd8cfde2ae3e374b7c4ffcab91fcce10865992242cd053779760cc68909ff7.json
 create mode 100644 backend/.sqlx/query-ec2ed5203effe26c9584b266c5ccbc2a399e3a0e126c9ba7d0558d37c16926fa.json
 create mode 100644 backend/.sqlx/query-ed421d15d2f9883196619418b3ebd7c687900b66cd8c3a173f2e3410e4ed86d9.json
 create mode 100644 backend/.sqlx/query-ee4bf2bbc5ee6a49d7b5493793bb6771e9a2bcc847c5b64ee784b469242a1717.json
 create mode 100644 backend/.sqlx/query-eed8122fdcd007543dc6ca28b216845c6249c4598c4e16aa50067fdc6136451c.json
 rename backend/.sqlx/{query-88a6a86285fcfaa778e9716d5072f555dff175feb704c3d825d6100defe91bce.json => query-f1a34561f208c05d75b2f981cd55465e579dd71a9439a2182ef05d9d3cfe462e.json} (83%)
 create mode 100644 backend/.sqlx/query-f45962e947ae236266f8eb9b08ca6420ac7e0d548fb59473a2f7ac5be2ee5194.json
 create mode 100644 backend/.sqlx/query-f5eedc14b082c88a1096e61279faa73793c99a2ab5793bebc5924146f60d19a8.json
 create mode 100644 backend/.sqlx/query-fb2a7f9b797a45351439746e1478545c969d995dc02aaf6673183a73cab67179.json
 create mode 100644 backend/.sqlx/query-ff244d58f154fc3132205fbb8374f01ceb707d9ae0b02bf382d4f5dca73829e2.json
 create mode 100644 backend/migrations/20260725084224_add_dbt_lang.down.sql
 create mode 100644 backend/migrations/20260725084224_add_dbt_lang.up.sql
 create mode 100644 backend/migrations/20260725084314_dbt_runtime.down.sql
 create mode 100644 backend/migrations/20260725084314_dbt_runtime.up.sql
 create mode 100644 backend/migrations/20260727145314_materialized_partition_job_id_index.down.sql
 create mode 100644 backend/migrations/20260727145314_materialized_partition_job_id_index.up.sql
 create mode 100644 backend/parsers/windmill-parser-yaml/src/dbt.rs
 create mode 100644 backend/windmill-api-assets/tests/dbt_pinned_graph.rs
 create mode 100644 backend/windmill-api-assets/tests/fixtures/base.sql
 create mode 100644 backend/windmill-api/src/dbt.rs
 create mode 100644 backend/windmill-common/src/dbt_manifest.rs
 create mode 100644 backend/windmill-common/tests/dbt_graph_storage.rs
 create mode 100644 backend/windmill-worker/nsjail/run.dbt.config.proto
 create mode 100644 backend/windmill-worker/src/dbt_engine.rs
 create mode 100644 backend/windmill-worker/src/dbt_executor.rs
 create mode 100644 backend/windmill-worker/src/dbt_profiles.rs
 create mode 100644 cli/test/dbt_module_tracker_unit.test.ts
 create mode 100644 cli/test/dbt_optional_descriptor_unit.test.ts
 create mode 100644 docs/agent-worker-e2e.md
 create mode 100644 docs/dbt-runtime.md
 create mode 100644 frontend/src/lib/components/assets/AssetGraph/hideDbtRunnables.test.ts
 create mode 100644 frontend/src/lib/components/assets/AssetGraph/hideDbtRunnables.ts
 create mode 100644 frontend/src/lib/components/copilot/chat/flow/assetKind.test.ts
 create mode 100644 frontend/src/lib/components/dbt/DbtProjectPanel.svelte
 create mode 100644 frontend/src/lib/components/dbt/DbtRunGraph.svelte
 create mode 100644 frontend/src/lib/components/dbt/DbtRunResult.svelte
 create mode 100644 frontend/src/lib/components/dbt/parseDbtRun.test.ts
 create mode 100644 frontend/src/lib/components/dbt/parseDbtRun.ts
 create mode 100644 frontend/src/lib/components/dbt/previewRows.ts
 create mode 100644 frontend/src/lib/components/icons/DbtIcon.svelte
 create mode 100644 frontend/src/lib/components/workspaceSettings/DbtSettings.svelte

diff --git a/.agents/skills/update-sqlx/SKILL.md b/.agents/skills/update-sqlx/SKILL.md
index ce4eaa5ff7..ccbd7baf3d 100644
--- a/.agents/skills/update-sqlx/SKILL.md
+++ b/.agents/skills/update-sqlx/SKILL.md
@@ -9,11 +9,75 @@ Windmill uses `SQLX_OFFLINE=true` in CI, which requires all `sqlx::query!` / `sq
 
 ## When to Run
 
-Run after any change to SQL queries in Rust source files. Without it, CI will fail with:
+Run after **adding or editing** a SQL query in Rust source. Without it, CI fails with:
 ```
 error: `SQLX_OFFLINE=true` but there is no cached data for this query
 ```
 
+**Do NOT run it when a change only *removes* queries.** The cache is already complete for
+CI; all that is left are orphaned entries, which are cosmetic and never break a build.
+Running `prepare` to tidy them risks destroying the cache for no gain. Delete them
+offline instead: for each `.sqlx/query-*.json`, normalize its `query` field (strip `\`
+line-continuations, collapse whitespace) and check whether it still appears in any `.rs`
+file. That detector reports ~48 false positives in a CE checkout — EE queries live in
+`*_ee.rs` symlinks it cannot read — so **filter to the tables your change touched** and
+delete only those.
+
+## Before You Run Anything
+
+1. **Back the cache up.** `prepare` deletes `.sqlx/` *before* regenerating, so any compile
+   failure leaves it gutted (observed: 2350 → 142 entries).
+   ```bash
+   cp -r backend/.sqlx /tmp/sqlx_backup    # restore with: rm -rf backend/.sqlx && cp -r /tmp/sqlx_backup backend/.sqlx
+   ```
+2. **Point `DATABASE_URL` at THIS worktree's database.** `prepare` compiles every
+   `sqlx::query!` against the **live** database. Another worktree's DB lacks your
+   migrations, so every new-table query fails and takes the cache down with it. The
+   symptom is `relation "<your_new_table>" does not exist` — that is a wrong
+   `DATABASE_URL`, not a broken query. See AGENTS.md → "Per-worktree ports and database".
+
+## Queries Inside Tests Need `--all-targets`, Which Fails In A CE Checkout
+
+`prepare` only caches queries in code it compiles, and `--workspace` alone does **not**
+compile test targets. A `sqlx::query!` inside `tests/*.rs` therefore gets no entry, and CI
+fails on the test target with the usual "no cached data" error even though the lib built
+clean. `SQLX_OFFLINE=true cargo check --workspace --all-targets` is what reproduces it.
+
+Adding `--all-targets` caches them — and, in a CE checkout, **aborts partway through**:
+`backend/tests/otel.rs` imports `windmill_common::otel_ee`, which exists only behind the
+`private` feature, so the compile dies after `prepare` has already emptied `.sqlx/`.
+Observed: 2435 → 4 entries, `error: cargo check failed with status: exit status: 101`.
+
+Do not fight it — the abort is a pre-existing EE gap, not something your change caused.
+Take the entries you need and put the backup back:
+
+```bash
+cd backend
+cp -r .sqlx /tmp/sqlx_backup
+ls /tmp/sqlx_backup | sort > /tmp/before.txt
+
+DATABASE_URL=<this worktree's db> \
+  cargo sqlx prepare --workspace -- --workspace --features all_sqlx_features --all-targets
+# expected to fail; it still wrote the entries it got to before dying
+
+ls .sqlx | sort > /tmp/after.txt
+mkdir -p /tmp/newq
+comm -13 /tmp/before.txt /tmp/after.txt | while read f; do cp ".sqlx/$f" /tmp/newq/; done
+
+rm -rf .sqlx && cp -r /tmp/sqlx_backup .sqlx && cp /tmp/newq/*.json .sqlx/
+```
+
+**Read every file in `/tmp/newq` before copying it in** — print each one's `query` field and
+confirm it is one of yours. The set is small (one per new test query), and anything else in
+there means the run got further than you think.
+
+Then verify both targets, since the lib passing says nothing about the tests:
+
+```bash
+SQLX_OFFLINE=true cargo check --workspace --features all_sqlx_features   # lib
+SQLX_OFFLINE=true cargo check -p <your-crate> --all-targets              # tests
+```
+
 ## The Problem
 
 `cargo sqlx prepare --workspace` **deletes all existing cache files** and regenerates only the ones found in the current compilation. If you don't compile with every feature flag (especially `private` for EE files), you will **silently delete EE query caches**, breaking CI for enterprise tests.
@@ -68,7 +132,16 @@ But if it fails with EE compilation errors, use the safe procedure above.
 
 - **Never** run `cargo sqlx prepare --workspace` with only OSS features and commit the result — it will delete EE caches.
 - **Never** set `SQLX_OFFLINE=true` for local `cargo sqlx prepare` — use a live database per CLAUDE.md. (CI runs with `SQLX_OFFLINE=true`, which is why the cache must be complete.)
+- **Never** run `prepare` without a `.sqlx` backup, or against a `DATABASE_URL` you have not confirmed belongs to this worktree.
+- **Never** run `prepare` at all for a removal-only change.
 - **Never** skip the verification step (step 4 above).
+- **Never** leave a `--all-targets` run's output in place after it aborts — it is a
+  near-empty cache. Restore the backup and graft on only the entries you verified.
+
+Step 4 compares against `origin/main` because step 1 restored from it, so the two agree.
+If you did **not** run step 1 — auditing a branch's cache on its own, say — compare
+against `git merge-base HEAD origin/main` instead: `origin/main` advances, so its newer
+entries would read as losses on your branch.
 
 ## Verification
 
diff --git a/AGENTS.md b/AGENTS.md
index 90c0060ae2..31c8a93de3 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -13,6 +13,9 @@ Open-source platform for internal tools, workflows, API integrations, background
 
 - **Validation**: `docs/validation.md` — what checks to run based on what you changed
 - **Unreleased SDK changes**: `docs/wac-sdk-e2e.md` — exercising a client change on a real worker
+- **Agent workers**: `docs/agent-worker-e2e.md` — building and running one locally. An agent
+  reaches the DB only through the API, so `Connection::Http` paths are never taken by a plain
+  `cargo run`; a normal build cannot start one at all.
 - **Enterprise**: `docs/enterprise.md` — EE file conventions and PR workflow
 - **Backend patterns**: use the `rust-backend` skill when writing Rust code
 - **Frontend patterns**: use the `svelte-frontend` skill when writing Svelte code. Do NOT edit svelte files unless you have read that skill.
@@ -24,6 +27,11 @@ Open-source platform for internal tools, workflows, API integrations, background
 
 ## Dev Environment
 
+> **In a git worktree, the ports and database below are NOT the ones to use.** Each
+> worktree gets its own backend port, frontend port and Postgres database, so the
+> defaults in this section apply only to a plain single checkout. **Discover the real
+> values before running anything** — see "Per-worktree ports and database" below.
+
 - **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. 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.
@@ -33,6 +41,37 @@ Open-source platform for internal tools, workflows, API integrations, background
 - **Instance settings**: navigate to `/#superadmin-settings`
 - **Migrations**: use `cargo sqlx migrate add -r <name>` from `backend/` to create new migrations (never generate timestamps manually)
 
+### Per-worktree ports and database
+
+A worktree's `.env` / `.env.local` (repo root) and `backend/.env` hold its own
+`DATABASE_URL` and `PORT`; the database is typically `windmill_<branch_with_underscores>`
+(branch `dbt-runtime` → `windmill_dbt_runtime`). Read them, or discover from what is
+already running:
+
+```bash
+psql postgres://postgres:changeme@localhost:5432/postgres -tAc \
+  "select datname from pg_database where datname like 'windmill%'" | grep "$(git branch --show-current | tr - _)"
+# the port the frontend actually proxies to (REMOTE of this worktree's vite):
+for p in $(pgrep -f vite); do case "$(readlink /proc/$p/cwd)" in *"$(basename "$(git rev-parse --show-toplevel)")"*)
+  tr '\0' '\n' < /proc/$p/environ | grep -E '^REMOTE=|^PORT=';; esac; done
+```
+
+Getting these wrong is not a cheap mistake:
+
+- **`DATABASE_URL` pointed at another worktree's database silently destroys the sqlx
+  cache.** `cargo run` and `cargo sqlx prepare` both compile `sqlx::query!` against the
+  **live** database, so the wrong one fails with `relation "<your_new_table>" does not
+  exist` — and `prepare` deletes the whole `.sqlx/` directory *before* it fails, leaving
+  it gutted. Always `cp -r backend/.sqlx <tmp>/sqlx_backup` first (see the `update-sqlx`
+  skill).
+- **The frontend proxies to its own worktree's backend port, not 8000.** Starting a
+  backend on the wrong port leaves the UI up but every API call 502s, which reads like an
+  application bug rather than a misconfiguration.
+- **Kill backends by pid scoped to this worktree's cwd** (`readlink /proc/<pid>/cwd`),
+  never `pkill -f target/debug/windmill` — that kills every sibling worktree's backend.
+  Beware that a `pgrep -f "<pattern>"` in a shell whose own command line contains
+  `<pattern>` matches the shell itself.
+
 ## Verifying Frontend Changes
 
 After modifying frontend code, drive the running dev server with the **Playwright MCP** to verify the change in a real browser — don't claim a UI change works without exercising it.
@@ -55,6 +94,25 @@ Typical flow:
 
 If you cannot exercise a UI change (no dev server, etc.), say so explicitly rather than claiming success.
 
+## Verifying Backend Changes
+
+`cargo check` and the unit tests do not exercise a worker code path. **If you changed how
+a job runs — an executor, `handle_child`, anything spawning or reading from a
+subprocess — run an actual job of that kind** and confirm it completed, then say so.
+Whole classes of defect compile and unit-test clean:
+
+- **Stack overflow from a large buffer in an async block.** An array declared across an
+  `.await` is baked into the future's state; once that future is boxed a few layers deep
+  by the job poller, two 16 KB arrays abort the worker *process* (`thread
+  'tokio-runtime-worker' has overflowed its stack`). Heap-allocate read buffers
+  (`vec![0u8; N]`, not `[0u8; N]`).
+- Deadlocks from draining only one of a child's pipes, missed cancellation or timeout
+  propagation, and anything depending on the real engine's output format.
+
+A crash like this takes down every job on that worker, not just yours, so check the
+backend log after the run rather than only the job's own status. If you cannot run one,
+say which path went unexercised instead of implying it was verified.
+
 ## Banned Patterns
 
 ### `$bindable(default_value)` on optional props
diff --git a/backend/.sqlx/query-01732ca02b1888145c48c4e51e5b5829657224a743af9c0b2d5a140ad70e13dd.json b/backend/.sqlx/query-01732ca02b1888145c48c4e51e5b5829657224a743af9c0b2d5a140ad70e13dd.json
index a0d8b66a26..d2828a36a4 100644
--- a/backend/.sqlx/query-01732ca02b1888145c48c4e51e5b5829657224a743af9c0b2d5a140ad70e13dd.json
+++ b/backend/.sqlx/query-01732ca02b1888145c48c4e51e5b5829657224a743af9c0b2d5a140ad70e13dd.json
@@ -16,7 +16,8 @@
                 "variable",
                 "ducklake",
                 "datatable",
-                "volume"
+                "volume",
+                "table"
               ]
             }
           }
diff --git a/backend/.sqlx/query-03238f44f8d4db3ed406f853b5afd945796a2657e58cf1c5086d971e652803d5.json b/backend/.sqlx/query-03238f44f8d4db3ed406f853b5afd945796a2657e58cf1c5086d971e652803d5.json
new file mode 100644
index 0000000000..f99e53856c
--- /dev/null
+++ b/backend/.sqlx/query-03238f44f8d4db3ed406f853b5afd945796a2657e58cf1c5086d971e652803d5.json
@@ -0,0 +1,17 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO dbt_graph_snapshot (workspace_id, script_path, script_hash, job_id, digest)\n         VALUES ($1, $2, $3, $4, 'd2')",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Varchar",
+        "Int8",
+        "Uuid"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "03238f44f8d4db3ed406f853b5afd945796a2657e58cf1c5086d971e652803d5"
+}
diff --git a/backend/.sqlx/query-04896f435eee78f5ac604f5a57c8d35a313fc321df788e1c701e11f60da46480.json b/backend/.sqlx/query-04896f435eee78f5ac604f5a57c8d35a313fc321df788e1c701e11f60da46480.json
new file mode 100644
index 0000000000..4a632d868e
--- /dev/null
+++ b/backend/.sqlx/query-04896f435eee78f5ac604f5a57c8d35a313fc321df788e1c701e11f60da46480.json
@@ -0,0 +1,29 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT created_by, runnable_path FROM v2_job\n          WHERE id = $1 AND workspace_id = $2",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "created_by",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 1,
+        "name": "runnable_path",
+        "type_info": "Varchar"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Uuid",
+        "Text"
+      ]
+    },
+    "nullable": [
+      false,
+      true
+    ]
+  },
+  "hash": "04896f435eee78f5ac604f5a57c8d35a313fc321df788e1c701e11f60da46480"
+}
diff --git a/backend/.sqlx/query-09ae123099f05fe3db8bd67ca2c0d778a27619dd7fad71ba656f6b54c4915d1e.json b/backend/.sqlx/query-09ae123099f05fe3db8bd67ca2c0d778a27619dd7fad71ba656f6b54c4915d1e.json
index 60c3820b3d..8840ce4958 100644
--- a/backend/.sqlx/query-09ae123099f05fe3db8bd67ca2c0d778a27619dd7fad71ba656f6b54c4915d1e.json
+++ b/backend/.sqlx/query-09ae123099f05fe3db8bd67ca2c0d778a27619dd7fad71ba656f6b54c4915d1e.json
@@ -119,7 +119,8 @@
                 "java",
                 "duckdb",
                 "ruby",
-                "rlang"
+                "rlang",
+                "dbt"
               ]
             }
           }
diff --git a/backend/.sqlx/query-0b3754e11677390837ec7ab00ba5443dc634b8628e90cce879952c8c4319a6a6.json b/backend/.sqlx/query-0b3754e11677390837ec7ab00ba5443dc634b8628e90cce879952c8c4319a6a6.json
new file mode 100644
index 0000000000..99bf8ee009
--- /dev/null
+++ b/backend/.sqlx/query-0b3754e11677390837ec7ab00ba5443dc634b8628e90cce879952c8c4319a6a6.json
@@ -0,0 +1,17 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM dbt_edge WHERE workspace_id = $1 AND script_path = $2\n           AND script_hash = $3 AND job_id = $4",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text",
+        "Int8",
+        "Uuid"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "0b3754e11677390837ec7ab00ba5443dc634b8628e90cce879952c8c4319a6a6"
+}
diff --git a/backend/.sqlx/query-0c5b02b6b70fb8fd2ab3e6c57897038750a44a67360d342b6ef705ef2e4d3007.json b/backend/.sqlx/query-0c5b02b6b70fb8fd2ab3e6c57897038750a44a67360d342b6ef705ef2e4d3007.json
new file mode 100644
index 0000000000..e74bd5de0e
--- /dev/null
+++ b/backend/.sqlx/query-0c5b02b6b70fb8fd2ab3e6c57897038750a44a67360d342b6ef705ef2e4d3007.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO workspace_settings (workspace_id, slack_team_id, slack_name, slack_command_script, slack_email, customer_id, plan, webhook, ai_config, large_file_storage, git_sync, default_app, default_scripts, deploy_ui, mute_critical_alerts, color, operator_settings, teams_command_script, teams_team_id, teams_team_name, git_app_installations, ducklake, dbt_warehouses, slack_oauth_client_id, slack_oauth_client_secret, datatable, teams_team_guid, auto_invite, error_handler, success_handler, public_app_execution_limit_per_minute, error_handler_fallback_to_instance_alerts) SELECT $1, slack_team_id, slack_name, slack_command_script, slack_email, customer_id, plan, webhook, ai_config, large_file_storage, git_sync, default_app, default_scripts, deploy_ui, mute_critical_alerts, color, operator_settings, teams_command_script, teams_team_id, teams_team_name, git_app_installations, ducklake, dbt_warehouses, slack_oauth_client_id, slack_oauth_client_secret, datatable, teams_team_guid, auto_invite, error_handler, success_handler, public_app_execution_limit_per_minute, error_handler_fallback_to_instance_alerts FROM workspace_settings WHERE workspace_id = $2",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "0c5b02b6b70fb8fd2ab3e6c57897038750a44a67360d342b6ef705ef2e4d3007"
+}
diff --git a/backend/.sqlx/query-0ee4a4dc8c6f09e7027bd99f98d8d1d346f9d67056ef272314dd9b80bee9f285.json b/backend/.sqlx/query-0ee4a4dc8c6f09e7027bd99f98d8d1d346f9d67056ef272314dd9b80bee9f285.json
index 238522a3ff..62e65c847b 100644
--- a/backend/.sqlx/query-0ee4a4dc8c6f09e7027bd99f98d8d1d346f9d67056ef272314dd9b80bee9f285.json
+++ b/backend/.sqlx/query-0ee4a4dc8c6f09e7027bd99f98d8d1d346f9d67056ef272314dd9b80bee9f285.json
@@ -16,7 +16,8 @@
                 "variable",
                 "ducklake",
                 "datatable",
-                "volume"
+                "volume",
+                "table"
               ]
             }
           }
@@ -55,7 +56,8 @@
                       "variable",
                       "ducklake",
                       "datatable",
-                      "volume"
+                      "volume",
+                      "table"
                     ]
                   }
                 }
diff --git a/backend/.sqlx/query-0f58d4e7e6f3e962e8a86a2d9feb921c308b6a047530eccd8966513ffdc722d0.json b/backend/.sqlx/query-0f58d4e7e6f3e962e8a86a2d9feb921c308b6a047530eccd8966513ffdc722d0.json
index 4194e7e9cc..0bc0c3ce03 100644
--- a/backend/.sqlx/query-0f58d4e7e6f3e962e8a86a2d9feb921c308b6a047530eccd8966513ffdc722d0.json
+++ b/backend/.sqlx/query-0f58d4e7e6f3e962e8a86a2d9feb921c308b6a047530eccd8966513ffdc722d0.json
@@ -35,7 +35,8 @@
                 "java",
                 "duckdb",
                 "ruby",
-                "rlang"
+                "rlang",
+                "dbt"
               ]
             }
           }
diff --git a/backend/.sqlx/query-11d979216951a85835c15e02c756249fa16fd913dc1a2c7babc329cc2d636342.json b/backend/.sqlx/query-11d979216951a85835c15e02c756249fa16fd913dc1a2c7babc329cc2d636342.json
new file mode 100644
index 0000000000..4c3c53120c
--- /dev/null
+++ b/backend/.sqlx/query-11d979216951a85835c15e02c756249fa16fd913dc1a2c7babc329cc2d636342.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM dbt_graph_snapshot WHERE workspace_id = $1 AND script_path = $2",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "11d979216951a85835c15e02c756249fa16fd913dc1a2c7babc329cc2d636342"
+}
diff --git a/backend/.sqlx/query-12912ebe5df4eda15976e7c3a2f0501ed3098f33a234f283def6932ce491eb66.json b/backend/.sqlx/query-12912ebe5df4eda15976e7c3a2f0501ed3098f33a234f283def6932ce491eb66.json
new file mode 100644
index 0000000000..a797527421
--- /dev/null
+++ b/backend/.sqlx/query-12912ebe5df4eda15976e7c3a2f0501ed3098f33a234f283def6932ce491eb66.json
@@ -0,0 +1,17 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO dbt_graph_snapshot (workspace_id, script_path, script_hash, job_id, digest)\n         VALUES ($1, $2, $3, $4, 'd')",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Varchar",
+        "Int8",
+        "Uuid"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "12912ebe5df4eda15976e7c3a2f0501ed3098f33a234f283def6932ce491eb66"
+}
diff --git a/backend/.sqlx/query-19d19f3ed995ac68d9692c8fdf96836099dd325fa25d3660eb766a895b07c1da.json b/backend/.sqlx/query-19d19f3ed995ac68d9692c8fdf96836099dd325fa25d3660eb766a895b07c1da.json
new file mode 100644
index 0000000000..76404ffce5
--- /dev/null
+++ b/backend/.sqlx/query-19d19f3ed995ac68d9692c8fdf96836099dd325fa25d3660eb766a895b07c1da.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM dbt_run_state WHERE workspace_id = $1 AND script_path = $2",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "19d19f3ed995ac68d9692c8fdf96836099dd325fa25d3660eb766a895b07c1da"
+}
diff --git a/backend/.sqlx/query-1d4fb43c4856679371abfa5eeea8b92697ae3640a2e680395c2958c5d8664e27.json b/backend/.sqlx/query-1d4fb43c4856679371abfa5eeea8b92697ae3640a2e680395c2958c5d8664e27.json
new file mode 100644
index 0000000000..7f1618b3ad
--- /dev/null
+++ b/backend/.sqlx/query-1d4fb43c4856679371abfa5eeea8b92697ae3640a2e680395c2958c5d8664e27.json
@@ -0,0 +1,16 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM dbt_run_progress\n          WHERE workspace_id = $1 AND job_id = $2 AND status = 'running'\n            AND asset_path = ANY($3)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Uuid",
+        "TextArray"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "1d4fb43c4856679371abfa5eeea8b92697ae3640a2e680395c2958c5d8664e27"
+}
diff --git a/backend/.sqlx/query-1f1e477b27f38f410b7e6f436ced0751f77f9cb41055481bc06af6827d647041.json b/backend/.sqlx/query-1f1e477b27f38f410b7e6f436ced0751f77f9cb41055481bc06af6827d647041.json
index 9149698131..84ce6720d6 100644
--- a/backend/.sqlx/query-1f1e477b27f38f410b7e6f436ced0751f77f9cb41055481bc06af6827d647041.json
+++ b/backend/.sqlx/query-1f1e477b27f38f410b7e6f436ced0751f77f9cb41055481bc06af6827d647041.json
@@ -44,7 +44,8 @@
                 "java",
                 "duckdb",
                 "ruby",
-                "rlang"
+                "rlang",
+                "dbt"
               ]
             }
           }
diff --git a/backend/.sqlx/query-1f39f7ca0c04e825d3648906eed0c98c1dc8c913dc95b691cc6f92ffcd57989e.json b/backend/.sqlx/query-1f39f7ca0c04e825d3648906eed0c98c1dc8c913dc95b691cc6f92ffcd57989e.json
new file mode 100644
index 0000000000..57861d6518
--- /dev/null
+++ b/backend/.sqlx/query-1f39f7ca0c04e825d3648906eed0c98c1dc8c913dc95b691cc6f92ffcd57989e.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "UPDATE script SET archived = true WHERE workspace_id = $1 AND hash = $2",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Int8"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "1f39f7ca0c04e825d3648906eed0c98c1dc8c913dc95b691cc6f92ffcd57989e"
+}
diff --git a/backend/.sqlx/query-2213dc4b594d27b3788c48b19e13c600224681e11c016eea5cee3086a7bea8d0.json b/backend/.sqlx/query-2213dc4b594d27b3788c48b19e13c600224681e11c016eea5cee3086a7bea8d0.json
deleted file mode 100644
index 14f17d871e..0000000000
--- a/backend/.sqlx/query-2213dc4b594d27b3788c48b19e13c600224681e11c016eea5cee3086a7bea8d0.json
+++ /dev/null
@@ -1,15 +0,0 @@
-{
-  "db_name": "PostgreSQL",
-  "query": "\n        UPDATE workspace_settings\n        SET\n            ai_config = source_ws.ai_config,\n            large_file_storage = source_ws.large_file_storage,\n            ducklake = source_ws.ducklake,\n            datatable = source_ws.datatable,\n            git_app_installations = source_ws.git_app_installations\n        FROM workspace_settings source_ws\n        WHERE source_ws.workspace_id = $1\n        AND workspace_settings.workspace_id = $2\n        ",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Left": [
-        "Text",
-        "Text"
-      ]
-    },
-    "nullable": []
-  },
-  "hash": "2213dc4b594d27b3788c48b19e13c600224681e11c016eea5cee3086a7bea8d0"
-}
diff --git a/backend/.sqlx/query-229cc3975b7f579c35ac0daa9204ff3ff25fb57954dd1ba2d552c7b263696c07.json b/backend/.sqlx/query-229cc3975b7f579c35ac0daa9204ff3ff25fb57954dd1ba2d552c7b263696c07.json
new file mode 100644
index 0000000000..1e92b86bb2
--- /dev/null
+++ b/backend/.sqlx/query-229cc3975b7f579c35ac0daa9204ff3ff25fb57954dd1ba2d552c7b263696c07.json
@@ -0,0 +1,17 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO dbt_node (workspace_id, script_path, script_hash, job_id, unique_id,\n                                 resource_type, name, asset_path, raw_code, tags, description,\n                                 columns, freshness)\n           VALUES ($1, $2, $3, $4, 'model.p.orders', 'model', 'orders',\n                   'u/a/wh/analytics/orders', 'select 1', '{finance}', 'daily order facts',\n                   '{\"order_id\": {\"description\": \"natural key\"}}'::jsonb,\n                   '{\"warn_after\": {\"count\": 12, \"period\": \"hour\"}}'::jsonb)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Varchar",
+        "Int8",
+        "Uuid"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "229cc3975b7f579c35ac0daa9204ff3ff25fb57954dd1ba2d552c7b263696c07"
+}
diff --git a/backend/.sqlx/query-22be2359b966bd92d8327f142281ec620fc98c5fb77061ed192a6f75bea2b049.json b/backend/.sqlx/query-22be2359b966bd92d8327f142281ec620fc98c5fb77061ed192a6f75bea2b049.json
new file mode 100644
index 0000000000..baef76a508
--- /dev/null
+++ b/backend/.sqlx/query-22be2359b966bd92d8327f142281ec620fc98c5fb77061ed192a6f75bea2b049.json
@@ -0,0 +1,16 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "WITH keep AS (\n           SELECT hash FROM script\n            WHERE workspace_id = $2 AND path = $3 AND language = 'dbt'\n            ORDER BY created_at DESC LIMIT $1\n         )\n         DELETE FROM dbt_graph_snapshot g\n          WHERE g.workspace_id = $2 AND g.script_path = $3\n            AND g.job_id = '00000000-0000-0000-0000-000000000000'\n            AND NOT EXISTS (SELECT 1 FROM keep k WHERE k.hash = g.script_hash)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Int8",
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "22be2359b966bd92d8327f142281ec620fc98c5fb77061ed192a6f75bea2b049"
+}
diff --git a/backend/.sqlx/query-231475dc825518aa88f562698f8061d2562c3ac4af8d088f9eea9f0bc11d5fe7.json b/backend/.sqlx/query-231475dc825518aa88f562698f8061d2562c3ac4af8d088f9eea9f0bc11d5fe7.json
index e3f72d9c3a..ff79b3bfa5 100644
--- a/backend/.sqlx/query-231475dc825518aa88f562698f8061d2562c3ac4af8d088f9eea9f0bc11d5fe7.json
+++ b/backend/.sqlx/query-231475dc825518aa88f562698f8061d2562c3ac4af8d088f9eea9f0bc11d5fe7.json
@@ -27,7 +27,8 @@
                 "variable",
                 "ducklake",
                 "datatable",
-                "volume"
+                "volume",
+                "table"
               ]
             }
           }
diff --git a/backend/.sqlx/query-26e63135fcd8e7d48e25de190a2f72ece70ec92c5b04baad2622639850445900.json b/backend/.sqlx/query-26e63135fcd8e7d48e25de190a2f72ece70ec92c5b04baad2622639850445900.json
index 02a419de06..73feccaf09 100644
--- a/backend/.sqlx/query-26e63135fcd8e7d48e25de190a2f72ece70ec92c5b04baad2622639850445900.json
+++ b/backend/.sqlx/query-26e63135fcd8e7d48e25de190a2f72ece70ec92c5b04baad2622639850445900.json
@@ -21,7 +21,8 @@
                 "variable",
                 "ducklake",
                 "datatable",
-                "volume"
+                "volume",
+                "table"
               ]
             }
           }
diff --git a/backend/.sqlx/query-2a28f13c1f06a77bc9a164393cccf0d8d2a3d7e8552d8ad09512d2d6bf27c3fb.json b/backend/.sqlx/query-2a28f13c1f06a77bc9a164393cccf0d8d2a3d7e8552d8ad09512d2d6bf27c3fb.json
index f940f25b4a..b2c5b915f5 100644
--- a/backend/.sqlx/query-2a28f13c1f06a77bc9a164393cccf0d8d2a3d7e8552d8ad09512d2d6bf27c3fb.json
+++ b/backend/.sqlx/query-2a28f13c1f06a77bc9a164393cccf0d8d2a3d7e8552d8ad09512d2d6bf27c3fb.json
@@ -42,7 +42,8 @@
                 "variable",
                 "ducklake",
                 "datatable",
-                "volume"
+                "volume",
+                "table"
               ]
             }
           }
diff --git a/backend/.sqlx/query-2a8b9b199a6d383ed39a64dad54014f869ade4a139956dcb082f0524779f7680.json b/backend/.sqlx/query-2a8b9b199a6d383ed39a64dad54014f869ade4a139956dcb082f0524779f7680.json
new file mode 100644
index 0000000000..f770ee58df
--- /dev/null
+++ b/backend/.sqlx/query-2a8b9b199a6d383ed39a64dad54014f869ade4a139956dcb082f0524779f7680.json
@@ -0,0 +1,24 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT relation_root_at_last_ingest FROM dbt_graph_snapshot\n                  WHERE workspace_id = $1 AND script_path = $2 AND script_hash = $3\n                    AND job_id = '00000000-0000-0000-0000-000000000000'",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "relation_root_at_last_ingest",
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text",
+        "Int8"
+      ]
+    },
+    "nullable": [
+      true
+    ]
+  },
+  "hash": "2a8b9b199a6d383ed39a64dad54014f869ade4a139956dcb082f0524779f7680"
+}
diff --git a/backend/.sqlx/query-2d943b22eb69010f3c2388b9443dc8c5729cb2b828cae94c047b896ebff37fd3.json b/backend/.sqlx/query-2d943b22eb69010f3c2388b9443dc8c5729cb2b828cae94c047b896ebff37fd3.json
new file mode 100644
index 0000000000..558e5e466e
--- /dev/null
+++ b/backend/.sqlx/query-2d943b22eb69010f3c2388b9443dc8c5729cb2b828cae94c047b896ebff37fd3.json
@@ -0,0 +1,24 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT job_id FROM dbt_run_state\n          WHERE workspace_id = $1 AND script_path = $2 AND permissioned_as = $3 AND retryable",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "job_id",
+        "type_info": "Uuid"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": [
+      true
+    ]
+  },
+  "hash": "2d943b22eb69010f3c2388b9443dc8c5729cb2b828cae94c047b896ebff37fd3"
+}
diff --git a/backend/.sqlx/query-2f883466fb4237a3bee51813d1b5cc16f6216de6e483f3bbb1c2f54b51a37a24.json b/backend/.sqlx/query-2f883466fb4237a3bee51813d1b5cc16f6216de6e483f3bbb1c2f54b51a37a24.json
new file mode 100644
index 0000000000..a0afad1b40
--- /dev/null
+++ b/backend/.sqlx/query-2f883466fb4237a3bee51813d1b5cc16f6216de6e483f3bbb1c2f54b51a37a24.json
@@ -0,0 +1,18 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO dbt_graph_snapshot\n           (workspace_id, script_path, script_hash, job_id, digest, ingested_at)\n         VALUES ($1, $2, $3, $4, $5, now())\n         ON CONFLICT (workspace_id, script_path, script_hash, job_id)\n         DO UPDATE SET digest = EXCLUDED.digest, ingested_at = now()",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Varchar",
+        "Int8",
+        "Uuid",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "2f883466fb4237a3bee51813d1b5cc16f6216de6e483f3bbb1c2f54b51a37a24"
+}
diff --git a/backend/.sqlx/query-31bbd03932912df069cfc97fd1ca8c69a3151266e2bf475da10feb4916e436e9.json b/backend/.sqlx/query-31bbd03932912df069cfc97fd1ca8c69a3151266e2bf475da10feb4916e436e9.json
index ded7b65a83..832a118e11 100644
--- a/backend/.sqlx/query-31bbd03932912df069cfc97fd1ca8c69a3151266e2bf475da10feb4916e436e9.json
+++ b/backend/.sqlx/query-31bbd03932912df069cfc97fd1ca8c69a3151266e2bf475da10feb4916e436e9.json
@@ -21,7 +21,8 @@
                       "variable",
                       "ducklake",
                       "datatable",
-                      "volume"
+                      "volume",
+                      "table"
                     ]
                   }
                 }
diff --git a/backend/.sqlx/query-33b9ef6fabbb5f0de64246b51f0ce702603b7ae170054cda7ed5f6f0a9f44a28.json b/backend/.sqlx/query-33b9ef6fabbb5f0de64246b51f0ce702603b7ae170054cda7ed5f6f0a9f44a28.json
new file mode 100644
index 0000000000..8316ec5fab
--- /dev/null
+++ b/backend/.sqlx/query-33b9ef6fabbb5f0de64246b51f0ce702603b7ae170054cda7ed5f6f0a9f44a28.json
@@ -0,0 +1,16 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM dbt_node WHERE workspace_id = $1 AND script_path = $2 AND script_hash = $3",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text",
+        "Int8"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "33b9ef6fabbb5f0de64246b51f0ce702603b7ae170054cda7ed5f6f0a9f44a28"
+}
diff --git a/backend/.sqlx/query-38125105da39bfedbdc1396fe37a8835f2630389dc339be0fda614ddb4d773df.json b/backend/.sqlx/query-38125105da39bfedbdc1396fe37a8835f2630389dc339be0fda614ddb4d773df.json
new file mode 100644
index 0000000000..a779a3c995
--- /dev/null
+++ b/backend/.sqlx/query-38125105da39bfedbdc1396fe37a8835f2630389dc339be0fda614ddb4d773df.json
@@ -0,0 +1,17 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM dbt_node WHERE workspace_id = $1 AND script_path = $2\n           AND script_hash = $3 AND job_id = $4",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text",
+        "Int8",
+        "Uuid"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "38125105da39bfedbdc1396fe37a8835f2630389dc339be0fda614ddb4d773df"
+}
diff --git a/backend/.sqlx/query-381d59e7ab08e2ae7147e4c277a2d96f22375fa2b1eccafb7f09928a8b0cb549.json b/backend/.sqlx/query-381d59e7ab08e2ae7147e4c277a2d96f22375fa2b1eccafb7f09928a8b0cb549.json
new file mode 100644
index 0000000000..18df498bba
--- /dev/null
+++ b/backend/.sqlx/query-381d59e7ab08e2ae7147e4c277a2d96f22375fa2b1eccafb7f09928a8b0cb549.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "UPDATE script SET archived = true, extra_perms = '{\"u/outsider\": true}'::jsonb\n            WHERE workspace_id = $1 AND hash = $2",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Int8"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "381d59e7ab08e2ae7147e4c277a2d96f22375fa2b1eccafb7f09928a8b0cb549"
+}
diff --git a/backend/.sqlx/query-3b40cccf059fbd28ff9c8d0004daee26c81a8fe909e12ae997eaaba83ade634d.json b/backend/.sqlx/query-3b40cccf059fbd28ff9c8d0004daee26c81a8fe909e12ae997eaaba83ade634d.json
new file mode 100644
index 0000000000..d8afb95017
--- /dev/null
+++ b/backend/.sqlx/query-3b40cccf059fbd28ff9c8d0004daee26c81a8fe909e12ae997eaaba83ade634d.json
@@ -0,0 +1,17 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO dbt_node (workspace_id, script_path, script_hash, job_id, unique_id,\n                               resource_type, name, asset_path, raw_code, tags)\n         VALUES ($1, $2, $3, $4, 'model.p.orders', 'model', 'orders',\n                 'u/a/wh/analytics/orders', 'select 2', '{}')",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Varchar",
+        "Int8",
+        "Uuid"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "3b40cccf059fbd28ff9c8d0004daee26c81a8fe909e12ae997eaaba83ade634d"
+}
diff --git a/backend/.sqlx/query-3c84781704b84b8a927ecce5a3fcb3adcf0175d0a71013f2497397c1c8ccc619.json b/backend/.sqlx/query-3c84781704b84b8a927ecce5a3fcb3adcf0175d0a71013f2497397c1c8ccc619.json
index 257e1e528f..2a02e5a8ce 100644
--- a/backend/.sqlx/query-3c84781704b84b8a927ecce5a3fcb3adcf0175d0a71013f2497397c1c8ccc619.json
+++ b/backend/.sqlx/query-3c84781704b84b8a927ecce5a3fcb3adcf0175d0a71013f2497397c1c8ccc619.json
@@ -77,7 +77,8 @@
                 "java",
                 "duckdb",
                 "ruby",
-                "rlang"
+                "rlang",
+                "dbt"
               ]
             }
           }
diff --git a/backend/.sqlx/query-41428ecb8940a8fb4043b71eacb554314177fc11bc82212d95182e3723e64c6b.json b/backend/.sqlx/query-41428ecb8940a8fb4043b71eacb554314177fc11bc82212d95182e3723e64c6b.json
new file mode 100644
index 0000000000..c812a91912
--- /dev/null
+++ b/backend/.sqlx/query-41428ecb8940a8fb4043b71eacb554314177fc11bc82212d95182e3723e64c6b.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM dbt_run_progress\n          WHERE workspace_id = $1 AND updated_at < now() - make_interval(days => $2)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Int4"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "41428ecb8940a8fb4043b71eacb554314177fc11bc82212d95182e3723e64c6b"
+}
diff --git a/backend/.sqlx/query-4330e66917f04dc6597d323e9102de473e3f319ba13fa0784dd5bef24224233c.json b/backend/.sqlx/query-4330e66917f04dc6597d323e9102de473e3f319ba13fa0784dd5bef24224233c.json
new file mode 100644
index 0000000000..4762ed3279
--- /dev/null
+++ b/backend/.sqlx/query-4330e66917f04dc6597d323e9102de473e3f319ba13fa0784dd5bef24224233c.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "UPDATE dbt_run_state SET workspace_id = $1 WHERE workspace_id = $2",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "4330e66917f04dc6597d323e9102de473e3f319ba13fa0784dd5bef24224233c"
+}
diff --git a/backend/.sqlx/query-4374167ebf64c4e8dd683e31451800c2d068cbafbd279454724451d7f57e108e.json b/backend/.sqlx/query-4374167ebf64c4e8dd683e31451800c2d068cbafbd279454724451d7f57e108e.json
new file mode 100644
index 0000000000..a2e8f4127c
--- /dev/null
+++ b/backend/.sqlx/query-4374167ebf64c4e8dd683e31451800c2d068cbafbd279454724451d7f57e108e.json
@@ -0,0 +1,16 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO script (workspace_id, hash, path, summary, description, content,\n                             created_by, language, lock)\n         VALUES ($1, $2, $3, '', '', 'profile: {}', 'test-user', 'dbt', '')",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Int8",
+        "Varchar"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "4374167ebf64c4e8dd683e31451800c2d068cbafbd279454724451d7f57e108e"
+}
diff --git a/backend/.sqlx/query-44ee3944c35080999850a85857d6e5ce78c738c163b3ccdc3fe252b2980f6f1d.json b/backend/.sqlx/query-44ee3944c35080999850a85857d6e5ce78c738c163b3ccdc3fe252b2980f6f1d.json
new file mode 100644
index 0000000000..e3d6f0be65
--- /dev/null
+++ b/backend/.sqlx/query-44ee3944c35080999850a85857d6e5ce78c738c163b3ccdc3fe252b2980f6f1d.json
@@ -0,0 +1,35 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT created_by, runnable_path,\n                CASE WHEN kind = 'script' THEN runnable_id END AS script_hash\n           FROM v2_job WHERE id = $1 AND workspace_id = $2",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "created_by",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 1,
+        "name": "runnable_path",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 2,
+        "name": "script_hash",
+        "type_info": "Int8"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Uuid",
+        "Text"
+      ]
+    },
+    "nullable": [
+      false,
+      true,
+      null
+    ]
+  },
+  "hash": "44ee3944c35080999850a85857d6e5ce78c738c163b3ccdc3fe252b2980f6f1d"
+}
diff --git a/backend/.sqlx/query-471edf439cb293aa824440a2ef2f0afc28f425b061e90e1dfc6133b426a7f339.json b/backend/.sqlx/query-471edf439cb293aa824440a2ef2f0afc28f425b061e90e1dfc6133b426a7f339.json
new file mode 100644
index 0000000000..5903661c1a
--- /dev/null
+++ b/backend/.sqlx/query-471edf439cb293aa824440a2ef2f0afc28f425b061e90e1dfc6133b426a7f339.json
@@ -0,0 +1,22 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT runnable_id FROM v2_job WHERE id = $1",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "runnable_id",
+        "type_info": "Int8"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Uuid"
+      ]
+    },
+    "nullable": [
+      true
+    ]
+  },
+  "hash": "471edf439cb293aa824440a2ef2f0afc28f425b061e90e1dfc6133b426a7f339"
+}
diff --git a/backend/.sqlx/query-493b29e093bb2b8f8ed6947843e26fe8fb6aefe54ad5862cad9b8fd9868cdd91.json b/backend/.sqlx/query-493b29e093bb2b8f8ed6947843e26fe8fb6aefe54ad5862cad9b8fd9868cdd91.json
new file mode 100644
index 0000000000..04626fefe3
--- /dev/null
+++ b/backend/.sqlx/query-493b29e093bb2b8f8ed6947843e26fe8fb6aefe54ad5862cad9b8fd9868cdd91.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "UPDATE workspace_settings SET dbt_warehouses = $1 WHERE workspace_id = $2",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Jsonb",
+        "Varchar"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "493b29e093bb2b8f8ed6947843e26fe8fb6aefe54ad5862cad9b8fd9868cdd91"
+}
diff --git a/backend/.sqlx/query-4ed961992cd6c99e2efe889ab1cf06e6ad12305a5b845948dc200f304fb87a61.json b/backend/.sqlx/query-4ed961992cd6c99e2efe889ab1cf06e6ad12305a5b845948dc200f304fb87a61.json
new file mode 100644
index 0000000000..a1cd77128d
--- /dev/null
+++ b/backend/.sqlx/query-4ed961992cd6c99e2efe889ab1cf06e6ad12305a5b845948dc200f304fb87a61.json
@@ -0,0 +1,22 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT dbt_warehouses FROM workspace_settings WHERE workspace_id = $1",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "dbt_warehouses",
+        "type_info": "Jsonb"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Varchar"
+      ]
+    },
+    "nullable": [
+      true
+    ]
+  },
+  "hash": "4ed961992cd6c99e2efe889ab1cf06e6ad12305a5b845948dc200f304fb87a61"
+}
diff --git a/backend/.sqlx/query-50f81c128d644c60837e603099e169fbc7a500c11e79d2c78d6eccccf6491aec.json b/backend/.sqlx/query-50f81c128d644c60837e603099e169fbc7a500c11e79d2c78d6eccccf6491aec.json
index a7f5d2f785..e4e2c240c7 100644
--- a/backend/.sqlx/query-50f81c128d644c60837e603099e169fbc7a500c11e79d2c78d6eccccf6491aec.json
+++ b/backend/.sqlx/query-50f81c128d644c60837e603099e169fbc7a500c11e79d2c78d6eccccf6491aec.json
@@ -71,7 +71,8 @@
                 "java",
                 "duckdb",
                 "ruby",
-                "rlang"
+                "rlang",
+                "dbt"
               ]
             }
           }
diff --git a/backend/.sqlx/query-5369258383098062e454539be369ea2f0a41771376720fb72c6b3c1fa4972eab.json b/backend/.sqlx/query-5369258383098062e454539be369ea2f0a41771376720fb72c6b3c1fa4972eab.json
index 6a010dd1f4..f1941c012c 100644
--- a/backend/.sqlx/query-5369258383098062e454539be369ea2f0a41771376720fb72c6b3c1fa4972eab.json
+++ b/backend/.sqlx/query-5369258383098062e454539be369ea2f0a41771376720fb72c6b3c1fa4972eab.json
@@ -35,7 +35,8 @@
                 "java",
                 "duckdb",
                 "ruby",
-                "rlang"
+                "rlang",
+                "dbt"
               ]
             }
           }
diff --git a/backend/.sqlx/query-5387fbfd4be55674dcbe9f9b3ce9649d0f5db125776fbdffea993a53a09708de.json b/backend/.sqlx/query-5387fbfd4be55674dcbe9f9b3ce9649d0f5db125776fbdffea993a53a09708de.json
index c617944b91..b00c398445 100644
--- a/backend/.sqlx/query-5387fbfd4be55674dcbe9f9b3ce9649d0f5db125776fbdffea993a53a09708de.json
+++ b/backend/.sqlx/query-5387fbfd4be55674dcbe9f9b3ce9649d0f5db125776fbdffea993a53a09708de.json
@@ -41,7 +41,8 @@
                 "java",
                 "duckdb",
                 "ruby",
-                "rlang"
+                "rlang",
+                "dbt"
               ]
             }
           }
diff --git a/backend/.sqlx/query-56badc145d03676b6bd80a3830ce0a0401517a9b60e5689d3c9cdc9a87aaf2a8.json b/backend/.sqlx/query-56badc145d03676b6bd80a3830ce0a0401517a9b60e5689d3c9cdc9a87aaf2a8.json
new file mode 100644
index 0000000000..134960fb28
--- /dev/null
+++ b/backend/.sqlx/query-56badc145d03676b6bd80a3830ce0a0401517a9b60e5689d3c9cdc9a87aaf2a8.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO dbt_edge (workspace_id, script_path, script_hash, job_id,\n            parent_unique_id, child_unique_id, ingested_at)\n         SELECT $2, script_path, script_hash, job_id, parent_unique_id, child_unique_id,\n            ingested_at\n         FROM dbt_edge\n         WHERE workspace_id = $1 AND job_id = '00000000-0000-0000-0000-000000000000'",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "56badc145d03676b6bd80a3830ce0a0401517a9b60e5689d3c9cdc9a87aaf2a8"
+}
diff --git a/backend/.sqlx/query-58e7d590631294899025c2cc279c4352708f65a6c094a89b4cafa1e6450a4e6a.json b/backend/.sqlx/query-58e7d590631294899025c2cc279c4352708f65a6c094a89b4cafa1e6450a4e6a.json
new file mode 100644
index 0000000000..1edc69b002
--- /dev/null
+++ b/backend/.sqlx/query-58e7d590631294899025c2cc279c4352708f65a6c094a89b4cafa1e6450a4e6a.json
@@ -0,0 +1,23 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT result->'materialized' FROM v2_job_completed WHERE workspace_id = $1 AND id = $2",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "?column?",
+        "type_info": "Jsonb"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Uuid"
+      ]
+    },
+    "nullable": [
+      null
+    ]
+  },
+  "hash": "58e7d590631294899025c2cc279c4352708f65a6c094a89b4cafa1e6450a4e6a"
+}
diff --git a/backend/.sqlx/query-5ae004333c20e6f7c28025f16ad87562dbdac633f3248ac228e00b7c8b49b800.json b/backend/.sqlx/query-5ae004333c20e6f7c28025f16ad87562dbdac633f3248ac228e00b7c8b49b800.json
index c126b6371a..32284da567 100644
--- a/backend/.sqlx/query-5ae004333c20e6f7c28025f16ad87562dbdac633f3248ac228e00b7c8b49b800.json
+++ b/backend/.sqlx/query-5ae004333c20e6f7c28025f16ad87562dbdac633f3248ac228e00b7c8b49b800.json
@@ -16,7 +16,8 @@
                 "variable",
                 "ducklake",
                 "datatable",
-                "volume"
+                "volume",
+                "table"
               ]
             }
           }
@@ -71,7 +72,8 @@
                       "variable",
                       "ducklake",
                       "datatable",
-                      "volume"
+                      "volume",
+                      "table"
                     ]
                   }
                 }
diff --git a/backend/.sqlx/query-5c609ea0696df96ca02cba7fee359b785515a79dcda3745663e4c4f2cf328389.json b/backend/.sqlx/query-5c609ea0696df96ca02cba7fee359b785515a79dcda3745663e4c4f2cf328389.json
index 03de8472ad..b7191f389c 100644
--- a/backend/.sqlx/query-5c609ea0696df96ca02cba7fee359b785515a79dcda3745663e4c4f2cf328389.json
+++ b/backend/.sqlx/query-5c609ea0696df96ca02cba7fee359b785515a79dcda3745663e4c4f2cf328389.json
@@ -21,7 +21,8 @@
                 "variable",
                 "ducklake",
                 "datatable",
-                "volume"
+                "volume",
+                "table"
               ]
             }
           }
diff --git a/backend/.sqlx/query-5cda335f22d96fb8bf351f03248f669cfde49cc9872228998ce4a00b829250a1.json b/backend/.sqlx/query-5cda335f22d96fb8bf351f03248f669cfde49cc9872228998ce4a00b829250a1.json
new file mode 100644
index 0000000000..7b172b5a63
--- /dev/null
+++ b/backend/.sqlx/query-5cda335f22d96fb8bf351f03248f669cfde49cc9872228998ce4a00b829250a1.json
@@ -0,0 +1,30 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT j.runnable_path, j.runnable_id\n           FROM v2_job_queue q JOIN v2_job j ON j.id = q.id\n          WHERE q.id = $1 AND j.workspace_id = $2 AND q.tag = ANY($3)",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "runnable_path",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 1,
+        "name": "runnable_id",
+        "type_info": "Int8"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Uuid",
+        "Text",
+        "TextArray"
+      ]
+    },
+    "nullable": [
+      true,
+      true
+    ]
+  },
+  "hash": "5cda335f22d96fb8bf351f03248f669cfde49cc9872228998ce4a00b829250a1"
+}
diff --git a/backend/.sqlx/query-5ec262094e8ddf420b9098f2b3ef6d2c2caa94f39a0e57fe015e19fd1d0ab0ea.json b/backend/.sqlx/query-5ec262094e8ddf420b9098f2b3ef6d2c2caa94f39a0e57fe015e19fd1d0ab0ea.json
index 8ff04d2fc1..34f1870b7a 100644
--- a/backend/.sqlx/query-5ec262094e8ddf420b9098f2b3ef6d2c2caa94f39a0e57fe015e19fd1d0ab0ea.json
+++ b/backend/.sqlx/query-5ec262094e8ddf420b9098f2b3ef6d2c2caa94f39a0e57fe015e19fd1d0ab0ea.json
@@ -44,7 +44,8 @@
                 "java",
                 "duckdb",
                 "ruby",
-                "rlang"
+                "rlang",
+                "dbt"
               ]
             }
           }
diff --git a/backend/.sqlx/query-5fd6467e3316b64e0451614d6bb9101644d1869af85687ab55067308644a2523.json b/backend/.sqlx/query-5fd6467e3316b64e0451614d6bb9101644d1869af85687ab55067308644a2523.json
new file mode 100644
index 0000000000..38d40a97c9
--- /dev/null
+++ b/backend/.sqlx/query-5fd6467e3316b64e0451614d6bb9101644d1869af85687ab55067308644a2523.json
@@ -0,0 +1,23 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT script_lang = 'dbt' FROM v2_job WHERE id = $1 AND workspace_id = $2",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "?column?",
+        "type_info": "Bool"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Uuid",
+        "Varchar"
+      ]
+    },
+    "nullable": [
+      null
+    ]
+  },
+  "hash": "5fd6467e3316b64e0451614d6bb9101644d1869af85687ab55067308644a2523"
+}
diff --git a/backend/.sqlx/query-66c775b6e1120c5ed53b903d252e07f0965efb65c51580c529e61d09b8742dfd.json b/backend/.sqlx/query-66c775b6e1120c5ed53b903d252e07f0965efb65c51580c529e61d09b8742dfd.json
index 80f172aa40..f6e000ba6f 100644
--- a/backend/.sqlx/query-66c775b6e1120c5ed53b903d252e07f0965efb65c51580c529e61d09b8742dfd.json
+++ b/backend/.sqlx/query-66c775b6e1120c5ed53b903d252e07f0965efb65c51580c529e61d09b8742dfd.json
@@ -45,7 +45,8 @@
                 "java",
                 "duckdb",
                 "ruby",
-                "rlang"
+                "rlang",
+                "dbt"
               ]
             }
           }
diff --git a/backend/.sqlx/query-6aaddd80f8c07cfafea2021c1879c3d7b2fb156a43299e9a1209d05293c4f50f.json b/backend/.sqlx/query-6aaddd80f8c07cfafea2021c1879c3d7b2fb156a43299e9a1209d05293c4f50f.json
index 144bcb13f2..8d8ebfbed1 100644
--- a/backend/.sqlx/query-6aaddd80f8c07cfafea2021c1879c3d7b2fb156a43299e9a1209d05293c4f50f.json
+++ b/backend/.sqlx/query-6aaddd80f8c07cfafea2021c1879c3d7b2fb156a43299e9a1209d05293c4f50f.json
@@ -22,7 +22,8 @@
                       "variable",
                       "ducklake",
                       "datatable",
-                      "volume"
+                      "volume",
+                      "table"
                     ]
                   }
                 }
diff --git a/backend/.sqlx/query-6d89436b268157453784087c076ef5fb7c5ae46bede607cca308e1d5778e6d1e.json b/backend/.sqlx/query-6d89436b268157453784087c076ef5fb7c5ae46bede607cca308e1d5778e6d1e.json
new file mode 100644
index 0000000000..1e99437ab0
--- /dev/null
+++ b/backend/.sqlx/query-6d89436b268157453784087c076ef5fb7c5ae46bede607cca308e1d5778e6d1e.json
@@ -0,0 +1,62 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT asset_kind AS \"asset_kind: windmill_common::assets::AssetKind\", asset_path,\n                status::text AS \"status!\", row_count, error\n           FROM dbt_run_progress\n          WHERE workspace_id = $1 AND job_id = $2",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "asset_kind: windmill_common::assets::AssetKind",
+        "type_info": {
+          "Custom": {
+            "name": "asset_kind",
+            "kind": {
+              "Enum": [
+                "s3object",
+                "resource",
+                "variable",
+                "ducklake",
+                "datatable",
+                "volume",
+                "table"
+              ]
+            }
+          }
+        }
+      },
+      {
+        "ordinal": 1,
+        "name": "asset_path",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 2,
+        "name": "status!",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 3,
+        "name": "row_count",
+        "type_info": "Int8"
+      },
+      {
+        "ordinal": 4,
+        "name": "error",
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Uuid"
+      ]
+    },
+    "nullable": [
+      false,
+      false,
+      null,
+      true,
+      true
+    ]
+  },
+  "hash": "6d89436b268157453784087c076ef5fb7c5ae46bede607cca308e1d5778e6d1e"
+}
diff --git a/backend/.sqlx/query-71462a33d126a7b70c5ef570c63502cc7e848b82cc8a3e6032d8cd030ee8a1db.json b/backend/.sqlx/query-71462a33d126a7b70c5ef570c63502cc7e848b82cc8a3e6032d8cd030ee8a1db.json
new file mode 100644
index 0000000000..7b1509ce02
--- /dev/null
+++ b/backend/.sqlx/query-71462a33d126a7b70c5ef570c63502cc7e848b82cc8a3e6032d8cd030ee8a1db.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM dbt_node WHERE workspace_id = $1 AND script_path = $2",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "71462a33d126a7b70c5ef570c63502cc7e848b82cc8a3e6032d8cd030ee8a1db"
+}
diff --git a/backend/.sqlx/query-717188b993d9c87f2de51d8edbafec074f8e02408efc6da2c742d81fd47c14f0.json b/backend/.sqlx/query-717188b993d9c87f2de51d8edbafec074f8e02408efc6da2c742d81fd47c14f0.json
new file mode 100644
index 0000000000..6dc8e9acc2
--- /dev/null
+++ b/backend/.sqlx/query-717188b993d9c87f2de51d8edbafec074f8e02408efc6da2c742d81fd47c14f0.json
@@ -0,0 +1,24 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT count(*) FROM dbt_node WHERE workspace_id = $1 AND script_hash = $2 AND job_id = $3",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "count",
+        "type_info": "Int8"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Int8",
+        "Uuid"
+      ]
+    },
+    "nullable": [
+      null
+    ]
+  },
+  "hash": "717188b993d9c87f2de51d8edbafec074f8e02408efc6da2c742d81fd47c14f0"
+}
diff --git a/backend/.sqlx/query-71767e6684957af5dff56a1bb64f980f712f92798d11feaeb0832962ad9ddb2e.json b/backend/.sqlx/query-71767e6684957af5dff56a1bb64f980f712f92798d11feaeb0832962ad9ddb2e.json
index 96a68f827d..64c6611843 100644
--- a/backend/.sqlx/query-71767e6684957af5dff56a1bb64f980f712f92798d11feaeb0832962ad9ddb2e.json
+++ b/backend/.sqlx/query-71767e6684957af5dff56a1bb64f980f712f92798d11feaeb0832962ad9ddb2e.json
@@ -84,7 +84,8 @@
                 "java",
                 "duckdb",
                 "ruby",
-                "rlang"
+                "rlang",
+                "dbt"
               ]
             }
           }
diff --git a/backend/.sqlx/query-71b341ba06d588a7fb425d97921f16a8fc4fdf0bcebecfd21c9b7154dedea25f.json b/backend/.sqlx/query-71b341ba06d588a7fb425d97921f16a8fc4fdf0bcebecfd21c9b7154dedea25f.json
new file mode 100644
index 0000000000..397b310807
--- /dev/null
+++ b/backend/.sqlx/query-71b341ba06d588a7fb425d97921f16a8fc4fdf0bcebecfd21c9b7154dedea25f.json
@@ -0,0 +1,16 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "UPDATE materialized_partition\n            SET status = 'failed',\n                error = COALESCE(error, 'the run ended before this model finished')\n          WHERE workspace_id = $1 AND job_id = $2 AND status = 'running'\n            AND NOT (asset_path = ANY($3))",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Uuid",
+        "TextArray"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "71b341ba06d588a7fb425d97921f16a8fc4fdf0bcebecfd21c9b7154dedea25f"
+}
diff --git a/backend/.sqlx/query-7bb8ff3426ec73672fb572cd1ce36f495a84e0ad7d60fd39eddcccbc129d43c8.json b/backend/.sqlx/query-7bb8ff3426ec73672fb572cd1ce36f495a84e0ad7d60fd39eddcccbc129d43c8.json
index b38e22ad67..d26e9f7c87 100644
--- a/backend/.sqlx/query-7bb8ff3426ec73672fb572cd1ce36f495a84e0ad7d60fd39eddcccbc129d43c8.json
+++ b/backend/.sqlx/query-7bb8ff3426ec73672fb572cd1ce36f495a84e0ad7d60fd39eddcccbc129d43c8.json
@@ -77,7 +77,8 @@
                 "java",
                 "duckdb",
                 "ruby",
-                "rlang"
+                "rlang",
+                "dbt"
               ]
             }
           }
diff --git a/backend/.sqlx/query-7be4645fe51c8a9bd13645a245846cb485c593b6df2194ae91ba2d8c584c0cce.json b/backend/.sqlx/query-7be4645fe51c8a9bd13645a245846cb485c593b6df2194ae91ba2d8c584c0cce.json
new file mode 100644
index 0000000000..936a85b611
--- /dev/null
+++ b/backend/.sqlx/query-7be4645fe51c8a9bd13645a245846cb485c593b6df2194ae91ba2d8c584c0cce.json
@@ -0,0 +1,42 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT identity, args, run_results, job_id FROM dbt_run_state\n         WHERE workspace_id = $1 AND script_path = $2 AND permissioned_as = $3",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "identity",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 1,
+        "name": "args",
+        "type_info": "Jsonb"
+      },
+      {
+        "ordinal": 2,
+        "name": "run_results",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 3,
+        "name": "job_id",
+        "type_info": "Uuid"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": [
+      false,
+      false,
+      false,
+      true
+    ]
+  },
+  "hash": "7be4645fe51c8a9bd13645a245846cb485c593b6df2194ae91ba2d8c584c0cce"
+}
diff --git a/backend/.sqlx/query-7c19d92d25b799e8872452c5c77ae110e2c0628b2721a44735f4fc06e59b5c77.json b/backend/.sqlx/query-7c19d92d25b799e8872452c5c77ae110e2c0628b2721a44735f4fc06e59b5c77.json
new file mode 100644
index 0000000000..ee215b9615
--- /dev/null
+++ b/backend/.sqlx/query-7c19d92d25b799e8872452c5c77ae110e2c0628b2721a44735f4fc06e59b5c77.json
@@ -0,0 +1,23 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT count(*) FROM dbt_graph_snapshot WHERE workspace_id = $1 AND script_path = $2",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "count",
+        "type_info": "Int8"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": [
+      null
+    ]
+  },
+  "hash": "7c19d92d25b799e8872452c5c77ae110e2c0628b2721a44735f4fc06e59b5c77"
+}
diff --git a/backend/.sqlx/query-8058042d5564a934534517e9c0446c5fcc0c3654746c5e65994123ffb4d05f78.json b/backend/.sqlx/query-8058042d5564a934534517e9c0446c5fcc0c3654746c5e65994123ffb4d05f78.json
deleted file mode 100644
index 5453ec6899..0000000000
--- a/backend/.sqlx/query-8058042d5564a934534517e9c0446c5fcc0c3654746c5e65994123ffb4d05f78.json
+++ /dev/null
@@ -1,15 +0,0 @@
-{
-  "db_name": "PostgreSQL",
-  "query": "INSERT INTO workspace_settings (workspace_id, slack_team_id, slack_name, slack_command_script, slack_email, customer_id, plan, webhook, ai_config, large_file_storage, git_sync, default_app, default_scripts, deploy_ui, mute_critical_alerts, color, operator_settings, teams_command_script, teams_team_id, teams_team_name, git_app_installations, ducklake, slack_oauth_client_id, slack_oauth_client_secret, datatable, teams_team_guid, auto_invite, error_handler, success_handler, public_app_execution_limit_per_minute, error_handler_fallback_to_instance_alerts) SELECT $1, slack_team_id, slack_name, slack_command_script, slack_email, customer_id, plan, webhook, ai_config, large_file_storage, git_sync, default_app, default_scripts, deploy_ui, mute_critical_alerts, color, operator_settings, teams_command_script, teams_team_id, teams_team_name, git_app_installations, ducklake, slack_oauth_client_id, slack_oauth_client_secret, datatable, teams_team_guid, auto_invite, error_handler, success_handler, public_app_execution_limit_per_minute, error_handler_fallback_to_instance_alerts FROM workspace_settings WHERE workspace_id = $2",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Left": [
-        "Varchar",
-        "Text"
-      ]
-    },
-    "nullable": []
-  },
-  "hash": "8058042d5564a934534517e9c0446c5fcc0c3654746c5e65994123ffb4d05f78"
-}
diff --git a/backend/.sqlx/query-843ef7d1c619d2784306fa1dd06036c6967b5a2ebb88cf174f435a2ce692c5dc.json b/backend/.sqlx/query-843ef7d1c619d2784306fa1dd06036c6967b5a2ebb88cf174f435a2ce692c5dc.json
new file mode 100644
index 0000000000..5c000ffd34
--- /dev/null
+++ b/backend/.sqlx/query-843ef7d1c619d2784306fa1dd06036c6967b5a2ebb88cf174f435a2ce692c5dc.json
@@ -0,0 +1,23 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT count(*) FROM dbt_graph_snapshot WHERE workspace_id = $1 AND job_id = $2",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "count",
+        "type_info": "Int8"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Uuid"
+      ]
+    },
+    "nullable": [
+      null
+    ]
+  },
+  "hash": "843ef7d1c619d2784306fa1dd06036c6967b5a2ebb88cf174f435a2ce692c5dc"
+}
diff --git a/backend/.sqlx/query-850b5e3414851e53f9d5580b0ab1fdb97b053620ac14b8196ebf09208510fb1f.json b/backend/.sqlx/query-850b5e3414851e53f9d5580b0ab1fdb97b053620ac14b8196ebf09208510fb1f.json
new file mode 100644
index 0000000000..4c72eca991
--- /dev/null
+++ b/backend/.sqlx/query-850b5e3414851e53f9d5580b0ab1fdb97b053620ac14b8196ebf09208510fb1f.json
@@ -0,0 +1,17 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "UPDATE dbt_graph_snapshot SET relation_root_at_last_ingest = $4\n          WHERE workspace_id = $1 AND script_path = $2 AND script_hash = $3\n            AND job_id = '00000000-0000-0000-0000-000000000000'",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text",
+        "Int8",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "850b5e3414851e53f9d5580b0ab1fdb97b053620ac14b8196ebf09208510fb1f"
+}
diff --git a/backend/.sqlx/query-853230da671371fd8bbeeb4c87f8c20a9e310092ae787efe4b0657399c799424.json b/backend/.sqlx/query-853230da671371fd8bbeeb4c87f8c20a9e310092ae787efe4b0657399c799424.json
index 5aacf1a295..ed77b9e649 100644
--- a/backend/.sqlx/query-853230da671371fd8bbeeb4c87f8c20a9e310092ae787efe4b0657399c799424.json
+++ b/backend/.sqlx/query-853230da671371fd8bbeeb4c87f8c20a9e310092ae787efe4b0657399c799424.json
@@ -16,7 +16,8 @@
                 "variable",
                 "ducklake",
                 "datatable",
-                "volume"
+                "volume",
+                "table"
               ]
             }
           }
diff --git a/backend/.sqlx/query-87ca1f2a34f54dade76f5a2cde5ecdac6806e1a306dca880943d97bb6d6a889d.json b/backend/.sqlx/query-87ca1f2a34f54dade76f5a2cde5ecdac6806e1a306dca880943d97bb6d6a889d.json
index ffce4491e3..f26bca1232 100644
--- a/backend/.sqlx/query-87ca1f2a34f54dade76f5a2cde5ecdac6806e1a306dca880943d97bb6d6a889d.json
+++ b/backend/.sqlx/query-87ca1f2a34f54dade76f5a2cde5ecdac6806e1a306dca880943d97bb6d6a889d.json
@@ -44,7 +44,8 @@
                 "java",
                 "duckdb",
                 "ruby",
-                "rlang"
+                "rlang",
+                "dbt"
               ]
             }
           }
diff --git a/backend/.sqlx/query-8a40b3e7b9c59f1a0b50d3fe6b320748a912eff01dda22df9f489b6703435166.json b/backend/.sqlx/query-8a40b3e7b9c59f1a0b50d3fe6b320748a912eff01dda22df9f489b6703435166.json
new file mode 100644
index 0000000000..0f743221dc
--- /dev/null
+++ b/backend/.sqlx/query-8a40b3e7b9c59f1a0b50d3fe6b320748a912eff01dda22df9f489b6703435166.json
@@ -0,0 +1,16 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO script (workspace_id, hash, path, summary, description, content, created_by,\n                             language, lock)\n         VALUES ($1, $2, $3, '', '', 'profile: {}', 'test-user', 'dbt', '')",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Int8",
+        "Varchar"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "8a40b3e7b9c59f1a0b50d3fe6b320748a912eff01dda22df9f489b6703435166"
+}
diff --git a/backend/.sqlx/query-8acc8c47123af84d2308042dcd34d04b941e928c7621e66d3bdc510c335f8c20.json b/backend/.sqlx/query-8acc8c47123af84d2308042dcd34d04b941e928c7621e66d3bdc510c335f8c20.json
index 6f7468033a..44e6cc5c81 100644
--- a/backend/.sqlx/query-8acc8c47123af84d2308042dcd34d04b941e928c7621e66d3bdc510c335f8c20.json
+++ b/backend/.sqlx/query-8acc8c47123af84d2308042dcd34d04b941e928c7621e66d3bdc510c335f8c20.json
@@ -42,7 +42,8 @@
                 "java",
                 "duckdb",
                 "ruby",
-                "rlang"
+                "rlang",
+                "dbt"
               ]
             }
           }
diff --git a/backend/.sqlx/query-8bad2a916f9afe1c037a01ffe69e136b562ace2d8265c9d26bcdf866f0f2c280.json b/backend/.sqlx/query-8bad2a916f9afe1c037a01ffe69e136b562ace2d8265c9d26bcdf866f0f2c280.json
new file mode 100644
index 0000000000..6f4d10b1f5
--- /dev/null
+++ b/backend/.sqlx/query-8bad2a916f9afe1c037a01ffe69e136b562ace2d8265c9d26bcdf866f0f2c280.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "UPDATE dbt_run_progress SET workspace_id = $1\n         WHERE workspace_id = $2 AND job_id IN (SELECT id FROM v2_job WHERE workspace_id = $1)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "8bad2a916f9afe1c037a01ffe69e136b562ace2d8265c9d26bcdf866f0f2c280"
+}
diff --git a/backend/.sqlx/query-8cd02a5378bea03012e6cb937f23460b6438d0a320b5554acec0beddbdeb008b.json b/backend/.sqlx/query-8cd02a5378bea03012e6cb937f23460b6438d0a320b5554acec0beddbdeb008b.json
index 24d70efae1..9e4209a706 100644
--- a/backend/.sqlx/query-8cd02a5378bea03012e6cb937f23460b6438d0a320b5554acec0beddbdeb008b.json
+++ b/backend/.sqlx/query-8cd02a5378bea03012e6cb937f23460b6438d0a320b5554acec0beddbdeb008b.json
@@ -36,7 +36,8 @@
                 "variable",
                 "ducklake",
                 "datatable",
-                "volume"
+                "volume",
+                "table"
               ]
             }
           }
diff --git a/backend/.sqlx/query-8e4397a299c29687bec108899bd520d67718b2c60e717d69439ea13da272c81e.json b/backend/.sqlx/query-8e4397a299c29687bec108899bd520d67718b2c60e717d69439ea13da272c81e.json
new file mode 100644
index 0000000000..04d2fe0a77
--- /dev/null
+++ b/backend/.sqlx/query-8e4397a299c29687bec108899bd520d67718b2c60e717d69439ea13da272c81e.json
@@ -0,0 +1,23 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT count(*) FROM dbt_graph_snapshot WHERE workspace_id = $1 AND script_hash = $2",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "count",
+        "type_info": "Int8"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Int8"
+      ]
+    },
+    "nullable": [
+      null
+    ]
+  },
+  "hash": "8e4397a299c29687bec108899bd520d67718b2c60e717d69439ea13da272c81e"
+}
diff --git a/backend/.sqlx/query-8e829a7358ea47100c99e78067266eb7a83e312b88f0244d1c517b03a9bcdea0.json b/backend/.sqlx/query-8e829a7358ea47100c99e78067266eb7a83e312b88f0244d1c517b03a9bcdea0.json
index eac4547361..3ea7be5cb8 100644
--- a/backend/.sqlx/query-8e829a7358ea47100c99e78067266eb7a83e312b88f0244d1c517b03a9bcdea0.json
+++ b/backend/.sqlx/query-8e829a7358ea47100c99e78067266eb7a83e312b88f0244d1c517b03a9bcdea0.json
@@ -16,7 +16,8 @@
                 "variable",
                 "ducklake",
                 "datatable",
-                "volume"
+                "volume",
+                "table"
               ]
             }
           }
diff --git a/backend/.sqlx/query-932f7d0df4ab3e200b9eaea424f51756433c03af6e7810c2a5f9421515df8aa3.json b/backend/.sqlx/query-932f7d0df4ab3e200b9eaea424f51756433c03af6e7810c2a5f9421515df8aa3.json
new file mode 100644
index 0000000000..e2e3f374a6
--- /dev/null
+++ b/backend/.sqlx/query-932f7d0df4ab3e200b9eaea424f51756433c03af6e7810c2a5f9421515df8aa3.json
@@ -0,0 +1,29 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT created_by, on_behalf_of_email FROM script\n          WHERE path = $1 AND workspace_id = $2 AND archived = false AND deleted = false\n          ORDER BY created_at DESC LIMIT 1",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "created_by",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 1,
+        "name": "on_behalf_of_email",
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": [
+      false,
+      true
+    ]
+  },
+  "hash": "932f7d0df4ab3e200b9eaea424f51756433c03af6e7810c2a5f9421515df8aa3"
+}
diff --git a/backend/.sqlx/query-94c0aae349172b9295b81b9e61e2f8f0ca36920ab66e8922815157a0c147bc47.json b/backend/.sqlx/query-94c0aae349172b9295b81b9e61e2f8f0ca36920ab66e8922815157a0c147bc47.json
new file mode 100644
index 0000000000..eb0aad5124
--- /dev/null
+++ b/backend/.sqlx/query-94c0aae349172b9295b81b9e61e2f8f0ca36920ab66e8922815157a0c147bc47.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO dbt_node (workspace_id, script_path, script_hash, job_id, unique_id,\n            resource_type, name, asset_path, materialized, materialize_strategy, unique_key,\n            tags, description, test_kind, test_column, test_args, severity, attached_node,\n            columns, freshness, raw_code, original_file_path, ingested_at)\n         SELECT $2, script_path, script_hash, job_id, unique_id,\n            resource_type, name, asset_path, materialized, materialize_strategy, unique_key,\n            tags, description, test_kind, test_column, test_args, severity, attached_node,\n            columns, freshness, raw_code, original_file_path, ingested_at\n         FROM dbt_node\n         WHERE workspace_id = $1 AND job_id = '00000000-0000-0000-0000-000000000000'",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "94c0aae349172b9295b81b9e61e2f8f0ca36920ab66e8922815157a0c147bc47"
+}
diff --git a/backend/.sqlx/query-96ba9c55e1f3b6ec20ce4c21a72b12a4c8aa3dda05cceb694234107eb324cbf9.json b/backend/.sqlx/query-96ba9c55e1f3b6ec20ce4c21a72b12a4c8aa3dda05cceb694234107eb324cbf9.json
new file mode 100644
index 0000000000..5061c42c94
--- /dev/null
+++ b/backend/.sqlx/query-96ba9c55e1f3b6ec20ce4c21a72b12a4c8aa3dda05cceb694234107eb324cbf9.json
@@ -0,0 +1,16 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM materialized_partition\n          WHERE workspace_id = $1 AND job_id = $2 AND status = 'running'\n            AND asset_path = ANY($3)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Uuid",
+        "TextArray"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "96ba9c55e1f3b6ec20ce4c21a72b12a4c8aa3dda05cceb694234107eb324cbf9"
+}
diff --git a/backend/.sqlx/query-972ee0dd58b98c1f0ff7242922e25b58b5ce504f2f4c4db952a796b3019a67d0.json b/backend/.sqlx/query-972ee0dd58b98c1f0ff7242922e25b58b5ce504f2f4c4db952a796b3019a67d0.json
new file mode 100644
index 0000000000..ec34b5f46a
--- /dev/null
+++ b/backend/.sqlx/query-972ee0dd58b98c1f0ff7242922e25b58b5ce504f2f4c4db952a796b3019a67d0.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM dbt_run_state WHERE workspace_id = $1 AND script_path = $2\n           AND NOT EXISTS (SELECT 1 FROM script\n                            WHERE workspace_id = $1 AND path = $2\n                              AND deleted = false AND archived = false)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "972ee0dd58b98c1f0ff7242922e25b58b5ce504f2f4c4db952a796b3019a67d0"
+}
diff --git a/backend/.sqlx/query-9809fad5552d306f8cf04dfd9059be14ec5518c6ba8572362f5a849657237294.json b/backend/.sqlx/query-9809fad5552d306f8cf04dfd9059be14ec5518c6ba8572362f5a849657237294.json
new file mode 100644
index 0000000000..42b8a2b09c
--- /dev/null
+++ b/backend/.sqlx/query-9809fad5552d306f8cf04dfd9059be14ec5518c6ba8572362f5a849657237294.json
@@ -0,0 +1,17 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO dbt_node (workspace_id, script_path, script_hash, job_id, unique_id,\n                                 resource_type, name, tags, test_kind, test_column, test_args,\n                                 attached_node)\n           VALUES ($1, $2, $3, $4, 'test.p.accepted_values_orders_status', 'test',\n                   'accepted_values_orders_status', '{}', 'accepted_values', 'status',\n                   '{\"values\": [\"gold\", \"silver\"]}'::jsonb, 'model.p.orders')",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Varchar",
+        "Int8",
+        "Uuid"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "9809fad5552d306f8cf04dfd9059be14ec5518c6ba8572362f5a849657237294"
+}
diff --git a/backend/.sqlx/query-9d331b63c901071a7e82c0a4a6859c77a37ef784fdac78ca1e7a971e141e780f.json b/backend/.sqlx/query-9d331b63c901071a7e82c0a4a6859c77a37ef784fdac78ca1e7a971e141e780f.json
index 1b11e0c470..b73ee34566 100644
--- a/backend/.sqlx/query-9d331b63c901071a7e82c0a4a6859c77a37ef784fdac78ca1e7a971e141e780f.json
+++ b/backend/.sqlx/query-9d331b63c901071a7e82c0a4a6859c77a37ef784fdac78ca1e7a971e141e780f.json
@@ -124,7 +124,8 @@
                 "java",
                 "duckdb",
                 "ruby",
-                "rlang"
+                "rlang",
+                "dbt"
               ]
             }
           }
diff --git a/backend/.sqlx/query-9d97c18abb292c841c3c95510022b6abc0829349a2b189083f61cf06c15113fe.json b/backend/.sqlx/query-9d97c18abb292c841c3c95510022b6abc0829349a2b189083f61cf06c15113fe.json
new file mode 100644
index 0000000000..493653e3dd
--- /dev/null
+++ b/backend/.sqlx/query-9d97c18abb292c841c3c95510022b6abc0829349a2b189083f61cf06c15113fe.json
@@ -0,0 +1,134 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "WITH live AS (\n             -- The graph is stored per deployed VERSION, so this endpoint — which\n             -- describes the project as it is now — takes the newest live one per\n             -- path. Resolved once here rather than per row: a correlated lookup\n             -- on every node is what makes these queries fall over.\n             SELECT * FROM (\n               SELECT DISTINCT ON (s.path) s.path, s.hash\n                 FROM script s\n                WHERE $5::text IS NULL AND s.workspace_id = $1 AND s.language = 'dbt'\n                  AND ($3::bigint IS NULL OR s.hash = $3)\n                  -- A pinned version may be archived by now; that is precisely\n                  -- the case a historical run needs, so the liveness filter\n                  -- applies only when picking the current one.\n                  AND ($3::bigint IS NOT NULL OR (s.deleted = false AND s.archived = false))\n                ORDER BY s.path, s.created_at DESC\n             ) cur\n             UNION ALL\n             -- A pinned run names its own version, so `script` is not consulted:\n             -- under RLS it would answer for the CALLER's grants on the project,\n             -- emptying the graph for a share-link viewer who is entitled to the\n             -- run but not the script.\n             SELECT $5::text, $3::bigint WHERE $5::text IS NOT NULL\n           ),\n           -- The run's own snapshot when it left one, the version's graph\n           -- otherwise. A static descriptor never snapshots, so all of its runs\n           -- fall through to the same rows. Existence comes from the marker, not\n           -- from a node row: a dynamic run that disabled every model has a\n           -- snapshot whose graph is legitimately empty.\n           chosen AS (\n             -- No visibility check on the job here: reaching this with a job at\n             -- all means the caller passed `require_job_read_access` for it, and\n             -- re-deciding it under plain RLS can only DISAGREE with that answer\n             -- — silently, by falling back to the deployed graph rather than\n             -- erroring. A share-link viewer is entitled to the run and would be\n             -- shown a different run's model set. See `asset_graph_for`.\n             SELECT CASE WHEN $4::uuid IS NOT NULL AND EXISTS (\n                      SELECT 1 FROM dbt_graph_snapshot g\n                       WHERE g.workspace_id = $1 AND g.job_id = $4)\n                    THEN $4::uuid\n                    ELSE '00000000-0000-0000-0000-000000000000'::uuid END AS job_id\n           ),\n           scoped AS (\n             SELECT n.script_path, n.unique_id FROM dbt_node n\n              JOIN live l ON l.path = n.script_path AND l.hash = n.script_hash\n              JOIN chosen ch ON ch.job_id = n.job_id\n              WHERE n.workspace_id = $1 AND n.asset_path IS NOT NULL\n                -- Unpinned, the scope is the relations in view: `asset` says\n                -- which of them this folder touches. Pinned, that table is the\n                -- WRONG scope — it holds one row set per path, describing the\n                -- current deploy, so a model this version had and the current one\n                -- dropped would be filtered out of its own run's graph. The\n                -- pinned version's nodes are the scope.\n                AND ($3::bigint IS NOT NULL OR n.asset_path IN (\n                  SELECT path FROM asset\n                   WHERE workspace_id = $1 AND kind = 'dbt'\n                     AND ($2::text IS NULL OR usage_path LIKE $2)))\n           )\n           SELECT n.script_path AS \"script_path!\", n.unique_id AS \"unique_id!\",\n                  n.resource_type AS \"resource_type!\", n.name AS \"name!\", n.asset_path,\n                  n.materialized, n.materialize_strategy, n.tags AS \"tags!\", n.description,\n                  n.test_kind, n.test_column, n.test_args, n.severity, n.attached_node,\n                  n.columns, n.freshness,\n                  n.raw_code, n.original_file_path,\n                  -- Whether the caller may read the project this row describes.\n                  -- The query deliberately reaches outside the requested folder\n                  -- so an in-scope consumer can explain the relation it reads,\n                  -- and `dbt_node` carries no RLS of its own; the relation's\n                  -- SHAPE is fine to answer that way, everything the project's\n                  -- author WROTE is not. Applied in Rust, over one predicate, so\n                  -- the fields it covers are named in one place. This runs in the\n                  -- authed transaction, so `script`'s RLS answers it. Matched on\n                  -- the HASH as well: `extra_perms` is per row, so a path\n                  -- recreated with narrower ones leaves the archived version\n                  -- readable, and a path-only probe would answer for THAT grant\n                  -- while returning this version's source.\n                  EXISTS (\n                      SELECT 1 FROM script sc\n                       WHERE sc.workspace_id = n.workspace_id AND sc.path = n.script_path\n                         AND sc.hash = n.script_hash\n                  ) AS \"script_visible!\"\n             FROM dbt_node n\n             JOIN live l ON l.path = n.script_path AND l.hash = n.script_hash\n             -- Every join onto `dbt_node` needs this, not just the scoping CTE:\n             -- `job_id` is part of the key, so without it each model comes back\n             -- once per retained snapshot plus once for the version's graph.\n             JOIN chosen ch ON ch.job_id = n.job_id\n            WHERE n.workspace_id = $1\n              -- Joined on BOTH columns: a dbt `unique_id` is project-local, so\n              -- two projects with the same model name would otherwise pull each\n              -- other's rows.\n              AND (EXISTS (SELECT 1 FROM scoped s\n                            WHERE s.script_path = n.script_path\n                              AND s.unique_id = n.unique_id)\n                   OR EXISTS (SELECT 1 FROM scoped s\n                               WHERE s.script_path = n.script_path\n                                 AND s.unique_id = n.attached_node))\n            ORDER BY n.script_path, n.unique_id",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "script_path!",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 1,
+        "name": "unique_id!",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 2,
+        "name": "resource_type!",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 3,
+        "name": "name!",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 4,
+        "name": "asset_path",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 5,
+        "name": "materialized",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 6,
+        "name": "materialize_strategy",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 7,
+        "name": "tags!",
+        "type_info": "TextArray"
+      },
+      {
+        "ordinal": 8,
+        "name": "description",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 9,
+        "name": "test_kind",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 10,
+        "name": "test_column",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 11,
+        "name": "test_args",
+        "type_info": "Jsonb"
+      },
+      {
+        "ordinal": 12,
+        "name": "severity",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 13,
+        "name": "attached_node",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 14,
+        "name": "columns",
+        "type_info": "Jsonb"
+      },
+      {
+        "ordinal": 15,
+        "name": "freshness",
+        "type_info": "Jsonb"
+      },
+      {
+        "ordinal": 16,
+        "name": "raw_code",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 17,
+        "name": "original_file_path",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 18,
+        "name": "script_visible!",
+        "type_info": "Bool"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text",
+        "Int8",
+        "Uuid",
+        "Text"
+      ]
+    },
+    "nullable": [
+      false,
+      false,
+      false,
+      false,
+      true,
+      true,
+      true,
+      false,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      true,
+      null
+    ]
+  },
+  "hash": "9d97c18abb292c841c3c95510022b6abc0829349a2b189083f61cf06c15113fe"
+}
diff --git a/backend/.sqlx/query-a2e7c8c0d1cc256e59976845c5189ccc84720581d7e3661c5eb2719c8ccff08a.json b/backend/.sqlx/query-a2e7c8c0d1cc256e59976845c5189ccc84720581d7e3661c5eb2719c8ccff08a.json
new file mode 100644
index 0000000000..679e03a3c7
--- /dev/null
+++ b/backend/.sqlx/query-a2e7c8c0d1cc256e59976845c5189ccc84720581d7e3661c5eb2719c8ccff08a.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM dbt_edge WHERE workspace_id = $1 AND script_path = $2",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "a2e7c8c0d1cc256e59976845c5189ccc84720581d7e3661c5eb2719c8ccff08a"
+}
diff --git a/backend/.sqlx/query-a4651f0ec5daaa0cbf09a71a7da9e16ea112e0a3855cc730d2fe99259c64eb41.json b/backend/.sqlx/query-a4651f0ec5daaa0cbf09a71a7da9e16ea112e0a3855cc730d2fe99259c64eb41.json
new file mode 100644
index 0000000000..de91a548ad
--- /dev/null
+++ b/backend/.sqlx/query-a4651f0ec5daaa0cbf09a71a7da9e16ea112e0a3855cc730d2fe99259c64eb41.json
@@ -0,0 +1,23 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT envs FROM script WHERE workspace_id = $1 AND hash = $2",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "envs",
+        "type_info": "VarcharArray"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Int8"
+      ]
+    },
+    "nullable": [
+      true
+    ]
+  },
+  "hash": "a4651f0ec5daaa0cbf09a71a7da9e16ea112e0a3855cc730d2fe99259c64eb41"
+}
diff --git a/backend/.sqlx/query-a4b6371d33206010b2f3ffd2b09e33244fe8ab9a803248fc23f334034d24aad4.json b/backend/.sqlx/query-a4b6371d33206010b2f3ffd2b09e33244fe8ab9a803248fc23f334034d24aad4.json
index 4824bba526..2b9ac8283b 100644
--- a/backend/.sqlx/query-a4b6371d33206010b2f3ffd2b09e33244fe8ab9a803248fc23f334034d24aad4.json
+++ b/backend/.sqlx/query-a4b6371d33206010b2f3ffd2b09e33244fe8ab9a803248fc23f334034d24aad4.json
@@ -134,7 +134,8 @@
                 "java",
                 "duckdb",
                 "ruby",
-                "rlang"
+                "rlang",
+                "dbt"
               ]
             }
           }
diff --git a/backend/.sqlx/query-a6decdebcd9750691f20f874b66a9c6f2ede08c33605c6a3c3dfc213a3eda76a.json b/backend/.sqlx/query-a6decdebcd9750691f20f874b66a9c6f2ede08c33605c6a3c3dfc213a3eda76a.json
new file mode 100644
index 0000000000..0532a5d3a0
--- /dev/null
+++ b/backend/.sqlx/query-a6decdebcd9750691f20f874b66a9c6f2ede08c33605c6a3c3dfc213a3eda76a.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "\n        UPDATE workspace_settings\n        SET\n            ai_config = source_ws.ai_config,\n            large_file_storage = source_ws.large_file_storage,\n            ducklake = source_ws.ducklake,\n            dbt_warehouses = source_ws.dbt_warehouses,\n            datatable = source_ws.datatable,\n            git_app_installations = source_ws.git_app_installations\n        FROM workspace_settings source_ws\n        WHERE source_ws.workspace_id = $1\n        AND workspace_settings.workspace_id = $2\n        ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "a6decdebcd9750691f20f874b66a9c6f2ede08c33605c6a3c3dfc213a3eda76a"
+}
diff --git a/backend/.sqlx/query-a8bcae108af1eda6efe3a4b8c6f8807bc464a81c0883e68f5a69b89b94b0b34b.json b/backend/.sqlx/query-a8bcae108af1eda6efe3a4b8c6f8807bc464a81c0883e68f5a69b89b94b0b34b.json
index 0d1bb6cb41..0faa9d0e33 100644
--- a/backend/.sqlx/query-a8bcae108af1eda6efe3a4b8c6f8807bc464a81c0883e68f5a69b89b94b0b34b.json
+++ b/backend/.sqlx/query-a8bcae108af1eda6efe3a4b8c6f8807bc464a81c0883e68f5a69b89b94b0b34b.json
@@ -39,7 +39,8 @@
                 "java",
                 "duckdb",
                 "ruby",
-                "rlang"
+                "rlang",
+                "dbt"
               ]
             }
           }
diff --git a/backend/.sqlx/query-a99c9c63fee048333bbf633bb92faaf06b89fb7396a1a7bf9f370c32d6ad67ee.json b/backend/.sqlx/query-a99c9c63fee048333bbf633bb92faaf06b89fb7396a1a7bf9f370c32d6ad67ee.json
new file mode 100644
index 0000000000..14eb734864
--- /dev/null
+++ b/backend/.sqlx/query-a99c9c63fee048333bbf633bb92faaf06b89fb7396a1a7bf9f370c32d6ad67ee.json
@@ -0,0 +1,23 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT g.job_id FROM dbt_graph_snapshot g\n              WHERE g.workspace_id = $1 AND g.job_id = $2\n              LIMIT 1",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "job_id",
+        "type_info": "Uuid"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Uuid"
+      ]
+    },
+    "nullable": [
+      false
+    ]
+  },
+  "hash": "a99c9c63fee048333bbf633bb92faaf06b89fb7396a1a7bf9f370c32d6ad67ee"
+}
diff --git a/backend/.sqlx/query-aa463baab01d9530ae97ace8b5a296ce9855bce50ea8c5918941564a696c029c.json b/backend/.sqlx/query-aa463baab01d9530ae97ace8b5a296ce9855bce50ea8c5918941564a696c029c.json
new file mode 100644
index 0000000000..e417d1e948
--- /dev/null
+++ b/backend/.sqlx/query-aa463baab01d9530ae97ace8b5a296ce9855bce50ea8c5918941564a696c029c.json
@@ -0,0 +1,14 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO folder (workspace_id, name, display_name, owners, extra_perms)\n         VALUES ($1, 'private', 'private', '{}', '{}')",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "aa463baab01d9530ae97ace8b5a296ce9855bce50ea8c5918941564a696c029c"
+}
diff --git a/backend/.sqlx/query-ab18d8765d6795eaa8035a8ac902790ff61549c5dd76e5b5cfb14b110a98abf2.json b/backend/.sqlx/query-ab18d8765d6795eaa8035a8ac902790ff61549c5dd76e5b5cfb14b110a98abf2.json
index 04131f8f88..6a370ef364 100644
--- a/backend/.sqlx/query-ab18d8765d6795eaa8035a8ac902790ff61549c5dd76e5b5cfb14b110a98abf2.json
+++ b/backend/.sqlx/query-ab18d8765d6795eaa8035a8ac902790ff61549c5dd76e5b5cfb14b110a98abf2.json
@@ -16,7 +16,8 @@
                 "variable",
                 "ducklake",
                 "datatable",
-                "volume"
+                "volume",
+                "table"
               ]
             }
           }
diff --git a/backend/.sqlx/query-ac113ee13ac2b6e8da5ebb6bf9f8207e1b46ba34fcb0f6957caef4be49bbbaa9.json b/backend/.sqlx/query-ac113ee13ac2b6e8da5ebb6bf9f8207e1b46ba34fcb0f6957caef4be49bbbaa9.json
new file mode 100644
index 0000000000..52ebcb5422
--- /dev/null
+++ b/backend/.sqlx/query-ac113ee13ac2b6e8da5ebb6bf9f8207e1b46ba34fcb0f6957caef4be49bbbaa9.json
@@ -0,0 +1,23 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT hash FROM script WHERE workspace_id = $1 AND path = $2 AND deleted = false AND archived = false ORDER BY created_at DESC LIMIT 1",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "hash",
+        "type_info": "Int8"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": [
+      false
+    ]
+  },
+  "hash": "ac113ee13ac2b6e8da5ebb6bf9f8207e1b46ba34fcb0f6957caef4be49bbbaa9"
+}
diff --git a/backend/.sqlx/query-af2f8c70ad5a14d35048211631b250879d18751a53597ef262b63d1e29bcb6a7.json b/backend/.sqlx/query-af2f8c70ad5a14d35048211631b250879d18751a53597ef262b63d1e29bcb6a7.json
new file mode 100644
index 0000000000..0446f2ea8a
--- /dev/null
+++ b/backend/.sqlx/query-af2f8c70ad5a14d35048211631b250879d18751a53597ef262b63d1e29bcb6a7.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "UPDATE dbt_run_state SET workspace_id = $1\n         WHERE workspace_id = $2 AND job_id IN (SELECT id FROM v2_job WHERE workspace_id = $1)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "af2f8c70ad5a14d35048211631b250879d18751a53597ef262b63d1e29bcb6a7"
+}
diff --git a/backend/.sqlx/query-b19f5156b3e36b5e831ce792637bf54a3f182c03cef0aef06a1c75b45992cd39.json b/backend/.sqlx/query-b19f5156b3e36b5e831ce792637bf54a3f182c03cef0aef06a1c75b45992cd39.json
new file mode 100644
index 0000000000..10adc6e68d
--- /dev/null
+++ b/backend/.sqlx/query-b19f5156b3e36b5e831ce792637bf54a3f182c03cef0aef06a1c75b45992cd39.json
@@ -0,0 +1,23 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT count(*) FROM dbt_edge WHERE workspace_id = $1 AND script_hash = $2",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "count",
+        "type_info": "Int8"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Int8"
+      ]
+    },
+    "nullable": [
+      null
+    ]
+  },
+  "hash": "b19f5156b3e36b5e831ce792637bf54a3f182c03cef0aef06a1c75b45992cd39"
+}
diff --git a/backend/.sqlx/query-b24c1ed9aa3b856eed3da73eadb99a11874d6680f584324827f0ae59bb9fe506.json b/backend/.sqlx/query-b24c1ed9aa3b856eed3da73eadb99a11874d6680f584324827f0ae59bb9fe506.json
new file mode 100644
index 0000000000..e29c1c0dbb
--- /dev/null
+++ b/backend/.sqlx/query-b24c1ed9aa3b856eed3da73eadb99a11874d6680f584324827f0ae59bb9fe506.json
@@ -0,0 +1,16 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM dbt_graph_snapshot\n          WHERE workspace_id = $1 AND script_path = $2 AND script_hash = $3",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text",
+        "Int8"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "b24c1ed9aa3b856eed3da73eadb99a11874d6680f584324827f0ae59bb9fe506"
+}
diff --git a/backend/.sqlx/query-b2dd773eebe0005eb4220f19e6a01aa9d12e461a89243bd0b651d1e5b837b6f4.json b/backend/.sqlx/query-b2dd773eebe0005eb4220f19e6a01aa9d12e461a89243bd0b651d1e5b837b6f4.json
new file mode 100644
index 0000000000..b865865c1d
--- /dev/null
+++ b/backend/.sqlx/query-b2dd773eebe0005eb4220f19e6a01aa9d12e461a89243bd0b651d1e5b837b6f4.json
@@ -0,0 +1,16 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM dbt_run_state\n                  WHERE workspace_id = $1 AND script_path = $2 AND permissioned_as = $3",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "b2dd773eebe0005eb4220f19e6a01aa9d12e461a89243bd0b651d1e5b837b6f4"
+}
diff --git a/backend/.sqlx/query-b44afcf1b9c047ac525638f0952c2cb01d65b1b46693331ac157dfca0dab6824.json b/backend/.sqlx/query-b44afcf1b9c047ac525638f0952c2cb01d65b1b46693331ac157dfca0dab6824.json
index eab78c7de8..9187cc29b7 100644
--- a/backend/.sqlx/query-b44afcf1b9c047ac525638f0952c2cb01d65b1b46693331ac157dfca0dab6824.json
+++ b/backend/.sqlx/query-b44afcf1b9c047ac525638f0952c2cb01d65b1b46693331ac157dfca0dab6824.json
@@ -44,7 +44,8 @@
                 "java",
                 "duckdb",
                 "ruby",
-                "rlang"
+                "rlang",
+                "dbt"
               ]
             }
           }
diff --git a/backend/.sqlx/query-b546a7a68143a3b0de1d900e5f635b8a1e4d1ba18298ace1602defacb9e67f0c.json b/backend/.sqlx/query-b546a7a68143a3b0de1d900e5f635b8a1e4d1ba18298ace1602defacb9e67f0c.json
new file mode 100644
index 0000000000..3aaa58da40
--- /dev/null
+++ b/backend/.sqlx/query-b546a7a68143a3b0de1d900e5f635b8a1e4d1ba18298ace1602defacb9e67f0c.json
@@ -0,0 +1,16 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "UPDATE dbt_run_state SET script_path = $3 WHERE workspace_id = $1 AND script_path = $2",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text",
+        "Varchar"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "b546a7a68143a3b0de1d900e5f635b8a1e4d1ba18298ace1602defacb9e67f0c"
+}
diff --git a/backend/.sqlx/query-bc59b7d863fc9df10cddf7487d6c2a3bd3ca8334f6cb5eaf42e14265a32ae472.json b/backend/.sqlx/query-bc59b7d863fc9df10cddf7487d6c2a3bd3ca8334f6cb5eaf42e14265a32ae472.json
new file mode 100644
index 0000000000..09367d07d3
--- /dev/null
+++ b/backend/.sqlx/query-bc59b7d863fc9df10cddf7487d6c2a3bd3ca8334f6cb5eaf42e14265a32ae472.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "UPDATE dbt_run_progress SET workspace_id = $1 WHERE workspace_id = $2",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "bc59b7d863fc9df10cddf7487d6c2a3bd3ca8334f6cb5eaf42e14265a32ae472"
+}
diff --git a/backend/.sqlx/query-bd293b1e468f70dcc21ab4a91eb5225058fb14d29a8a4de04fe161af0ff2d167.json b/backend/.sqlx/query-bd293b1e468f70dcc21ab4a91eb5225058fb14d29a8a4de04fe161af0ff2d167.json
new file mode 100644
index 0000000000..501a8460a1
--- /dev/null
+++ b/backend/.sqlx/query-bd293b1e468f70dcc21ab4a91eb5225058fb14d29a8a4de04fe161af0ff2d167.json
@@ -0,0 +1,16 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM dbt_run_state\n              WHERE workspace_id = $1 AND script_path = $2 AND permissioned_as = $3",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "bd293b1e468f70dcc21ab4a91eb5225058fb14d29a8a4de04fe161af0ff2d167"
+}
diff --git a/backend/.sqlx/query-bdb53068a223c12c2d317635993e8fda531e69a880d0ebc44fb5f13ac976b67d.json b/backend/.sqlx/query-bdb53068a223c12c2d317635993e8fda531e69a880d0ebc44fb5f13ac976b67d.json
index 2e194c9580..be50a16b17 100644
--- a/backend/.sqlx/query-bdb53068a223c12c2d317635993e8fda531e69a880d0ebc44fb5f13ac976b67d.json
+++ b/backend/.sqlx/query-bdb53068a223c12c2d317635993e8fda531e69a880d0ebc44fb5f13ac976b67d.json
@@ -41,7 +41,8 @@
                 "java",
                 "duckdb",
                 "ruby",
-                "rlang"
+                "rlang",
+                "dbt"
               ]
             }
           }
diff --git a/backend/.sqlx/query-be6d2c92a62b7b284651c45af809746147aa9b8d0a81642a7b7cb4738a0cad66.json b/backend/.sqlx/query-be6d2c92a62b7b284651c45af809746147aa9b8d0a81642a7b7cb4738a0cad66.json
index 809deb1a55..32e4c5404e 100644
--- a/backend/.sqlx/query-be6d2c92a62b7b284651c45af809746147aa9b8d0a81642a7b7cb4738a0cad66.json
+++ b/backend/.sqlx/query-be6d2c92a62b7b284651c45af809746147aa9b8d0a81642a7b7cb4738a0cad66.json
@@ -78,7 +78,8 @@
                 "java",
                 "duckdb",
                 "ruby",
-                "rlang"
+                "rlang",
+                "dbt"
               ]
             }
           }
diff --git a/backend/.sqlx/query-bfb97d2f48157a1575b7b6f3e64e0d075701d541a44dd7a0b586d1f337ced5e1.json b/backend/.sqlx/query-bfb97d2f48157a1575b7b6f3e64e0d075701d541a44dd7a0b586d1f337ced5e1.json
index a051b068a5..48abc75347 100644
--- a/backend/.sqlx/query-bfb97d2f48157a1575b7b6f3e64e0d075701d541a44dd7a0b586d1f337ced5e1.json
+++ b/backend/.sqlx/query-bfb97d2f48157a1575b7b6f3e64e0d075701d541a44dd7a0b586d1f337ced5e1.json
@@ -34,7 +34,8 @@
                 "variable",
                 "ducklake",
                 "datatable",
-                "volume"
+                "volume",
+                "table"
               ]
             }
           }
diff --git a/backend/.sqlx/query-c1a85cf2d1555ae33bbdaf85cf243d44a23f2fe2abf7a9ff8f271f9dfb1433e3.json b/backend/.sqlx/query-c1a85cf2d1555ae33bbdaf85cf243d44a23f2fe2abf7a9ff8f271f9dfb1433e3.json
new file mode 100644
index 0000000000..5fb1a353e7
--- /dev/null
+++ b/backend/.sqlx/query-c1a85cf2d1555ae33bbdaf85cf243d44a23f2fe2abf7a9ff8f271f9dfb1433e3.json
@@ -0,0 +1,14 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM dbt_edge\n          WHERE job_id <> '00000000-0000-0000-0000-000000000000'\n            AND ingested_at < now() - make_interval(days => $1)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Int4"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "c1a85cf2d1555ae33bbdaf85cf243d44a23f2fe2abf7a9ff8f271f9dfb1433e3"
+}
diff --git a/backend/.sqlx/query-c28e066bf24263f9e3b48a2ecabdf037178ba246092dbc1d2b3816e7a9269dc3.json b/backend/.sqlx/query-c28e066bf24263f9e3b48a2ecabdf037178ba246092dbc1d2b3816e7a9269dc3.json
index 7981dbc983..2e08168c2f 100644
--- a/backend/.sqlx/query-c28e066bf24263f9e3b48a2ecabdf037178ba246092dbc1d2b3816e7a9269dc3.json
+++ b/backend/.sqlx/query-c28e066bf24263f9e3b48a2ecabdf037178ba246092dbc1d2b3816e7a9269dc3.json
@@ -16,7 +16,8 @@
                 "variable",
                 "ducklake",
                 "datatable",
-                "volume"
+                "volume",
+                "table"
               ]
             }
           }
@@ -87,7 +88,8 @@
                 "variable",
                 "ducklake",
                 "datatable",
-                "volume"
+                "volume",
+                "table"
               ]
             }
           }
diff --git a/backend/.sqlx/query-c2e5f233e134ccc70b05d62239aaf736b456dbdd7d358e58744aa565e5889241.json b/backend/.sqlx/query-c2e5f233e134ccc70b05d62239aaf736b456dbdd7d358e58744aa565e5889241.json
new file mode 100644
index 0000000000..d8f9fbcee4
--- /dev/null
+++ b/backend/.sqlx/query-c2e5f233e134ccc70b05d62239aaf736b456dbdd7d358e58744aa565e5889241.json
@@ -0,0 +1,21 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO dbt_run_state (workspace_id, script_path, permissioned_as, identity, args, run_results, job_id, retryable, updated_at)\n                 SELECT $1::varchar, $2::varchar, $7::varchar, $3::text, $4::jsonb, $5::text, $6::uuid, $8::boolean, now()\n                  WHERE EXISTS (SELECT 1 FROM script\n                                 WHERE workspace_id = $1 AND path = $2\n                                   AND deleted = false AND archived = false\n                                   AND language = 'dbt')\n                 ON CONFLICT (workspace_id, script_path, permissioned_as) DO UPDATE SET\n                   identity = EXCLUDED.identity, args = EXCLUDED.args,\n                   run_results = EXCLUDED.run_results, job_id = EXCLUDED.job_id,\n                   retryable = EXCLUDED.retryable, updated_at = now()",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Varchar",
+        "Text",
+        "Jsonb",
+        "Text",
+        "Uuid",
+        "Varchar",
+        "Bool"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "c2e5f233e134ccc70b05d62239aaf736b456dbdd7d358e58744aa565e5889241"
+}
diff --git a/backend/.sqlx/query-c868e87f7ccc5ce19c421c857f67285177bd4eaa3a14af5bf08dbc32c7bda558.json b/backend/.sqlx/query-c868e87f7ccc5ce19c421c857f67285177bd4eaa3a14af5bf08dbc32c7bda558.json
new file mode 100644
index 0000000000..8bc10809dc
--- /dev/null
+++ b/backend/.sqlx/query-c868e87f7ccc5ce19c421c857f67285177bd4eaa3a14af5bf08dbc32c7bda558.json
@@ -0,0 +1,23 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT deleted FROM script WHERE workspace_id = $1 AND hash = $2 FOR UPDATE",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "deleted",
+        "type_info": "Bool"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Int8"
+      ]
+    },
+    "nullable": [
+      false
+    ]
+  },
+  "hash": "c868e87f7ccc5ce19c421c857f67285177bd4eaa3a14af5bf08dbc32c7bda558"
+}
diff --git a/backend/.sqlx/query-d0df9d1fda20f0366505bf6abf67446a5e8e23d87eebc46bbb90bdbdf128935b.json b/backend/.sqlx/query-d0df9d1fda20f0366505bf6abf67446a5e8e23d87eebc46bbb90bdbdf128935b.json
index 2578d91d10..0da783f056 100644
--- a/backend/.sqlx/query-d0df9d1fda20f0366505bf6abf67446a5e8e23d87eebc46bbb90bdbdf128935b.json
+++ b/backend/.sqlx/query-d0df9d1fda20f0366505bf6abf67446a5e8e23d87eebc46bbb90bdbdf128935b.json
@@ -149,7 +149,8 @@
                 "java",
                 "duckdb",
                 "ruby",
-                "rlang"
+                "rlang",
+                "dbt"
               ]
             }
           }
diff --git a/backend/.sqlx/query-d22f81df67d55b2d8f1d15404194a7b4604171d12c6a4620514c6d030086936d.json b/backend/.sqlx/query-d22f81df67d55b2d8f1d15404194a7b4604171d12c6a4620514c6d030086936d.json
index c4526daccc..64b4056596 100644
--- a/backend/.sqlx/query-d22f81df67d55b2d8f1d15404194a7b4604171d12c6a4620514c6d030086936d.json
+++ b/backend/.sqlx/query-d22f81df67d55b2d8f1d15404194a7b4604171d12c6a4620514c6d030086936d.json
@@ -69,7 +69,8 @@
                 "java",
                 "duckdb",
                 "ruby",
-                "rlang"
+                "rlang",
+                "dbt"
               ]
             }
           }
diff --git a/backend/.sqlx/query-d41ea93fd58381b89e151c965eae1ea2fe96a1b94f5a92953fb1c1642d15c016.json b/backend/.sqlx/query-d41ea93fd58381b89e151c965eae1ea2fe96a1b94f5a92953fb1c1642d15c016.json
index 2660ca05ef..cd1e0c4c39 100644
--- a/backend/.sqlx/query-d41ea93fd58381b89e151c965eae1ea2fe96a1b94f5a92953fb1c1642d15c016.json
+++ b/backend/.sqlx/query-d41ea93fd58381b89e151c965eae1ea2fe96a1b94f5a92953fb1c1642d15c016.json
@@ -78,7 +78,8 @@
                 "java",
                 "duckdb",
                 "ruby",
-                "rlang"
+                "rlang",
+                "dbt"
               ]
             }
           }
diff --git a/backend/.sqlx/query-d735f355d9eb2612b563b606c6c897c5ad764a882b2c9054a7665dd68b7a528b.json b/backend/.sqlx/query-d735f355d9eb2612b563b606c6c897c5ad764a882b2c9054a7665dd68b7a528b.json
new file mode 100644
index 0000000000..edd7f2f97a
--- /dev/null
+++ b/backend/.sqlx/query-d735f355d9eb2612b563b606c6c897c5ad764a882b2c9054a7665dd68b7a528b.json
@@ -0,0 +1,14 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM dbt_graph_snapshot\n          WHERE job_id <> '00000000-0000-0000-0000-000000000000'\n            AND ingested_at < now() - make_interval(days => $1)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Int4"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "d735f355d9eb2612b563b606c6c897c5ad764a882b2c9054a7665dd68b7a528b"
+}
diff --git a/backend/.sqlx/query-dbe64a8367fad74866b15f96565ef1ae7c58848714974a8c803085a0c0e655d6.json b/backend/.sqlx/query-dbe64a8367fad74866b15f96565ef1ae7c58848714974a8c803085a0c0e655d6.json
new file mode 100644
index 0000000000..520d04c762
--- /dev/null
+++ b/backend/.sqlx/query-dbe64a8367fad74866b15f96565ef1ae7c58848714974a8c803085a0c0e655d6.json
@@ -0,0 +1,16 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM dbt_edge WHERE workspace_id = $1 AND script_path = $2 AND script_hash = $3",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text",
+        "Int8"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "dbe64a8367fad74866b15f96565ef1ae7c58848714974a8c803085a0c0e655d6"
+}
diff --git a/backend/.sqlx/query-e013b906ba3e95350ebcda6a8b8cc3ee04f6782587bc34d44338d2b2cad03165.json b/backend/.sqlx/query-e013b906ba3e95350ebcda6a8b8cc3ee04f6782587bc34d44338d2b2cad03165.json
new file mode 100644
index 0000000000..36161cb99c
--- /dev/null
+++ b/backend/.sqlx/query-e013b906ba3e95350ebcda6a8b8cc3ee04f6782587bc34d44338d2b2cad03165.json
@@ -0,0 +1,14 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM dbt_node\n          WHERE job_id <> '00000000-0000-0000-0000-000000000000'\n            AND ingested_at < now() - make_interval(days => $1)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Int4"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "e013b906ba3e95350ebcda6a8b8cc3ee04f6782587bc34d44338d2b2cad03165"
+}
diff --git a/backend/.sqlx/query-e01e9040f2336d9db41638842c5a4a07af79130e1dbfd91f1601c04721186609.json b/backend/.sqlx/query-e01e9040f2336d9db41638842c5a4a07af79130e1dbfd91f1601c04721186609.json
new file mode 100644
index 0000000000..4967ac0212
--- /dev/null
+++ b/backend/.sqlx/query-e01e9040f2336d9db41638842c5a4a07af79130e1dbfd91f1601c04721186609.json
@@ -0,0 +1,16 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "UPDATE dbt_run_progress\n            SET status = 'failed',\n                error = COALESCE(error, 'the run ended before this model finished')\n          WHERE workspace_id = $1 AND job_id = $2 AND status = 'running'\n            AND NOT (asset_path = ANY($3))",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Uuid",
+        "TextArray"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "e01e9040f2336d9db41638842c5a4a07af79130e1dbfd91f1601c04721186609"
+}
diff --git a/backend/.sqlx/query-e041b20c1c4166b30ced8c6a0f50bcf0691ab2554ead6b489a8441a32fc0af82.json b/backend/.sqlx/query-e041b20c1c4166b30ced8c6a0f50bcf0691ab2554ead6b489a8441a32fc0af82.json
index 037c796fc7..175e2b51b6 100644
--- a/backend/.sqlx/query-e041b20c1c4166b30ced8c6a0f50bcf0691ab2554ead6b489a8441a32fc0af82.json
+++ b/backend/.sqlx/query-e041b20c1c4166b30ced8c6a0f50bcf0691ab2554ead6b489a8441a32fc0af82.json
@@ -17,7 +17,8 @@
                 "variable",
                 "ducklake",
                 "datatable",
-                "volume"
+                "volume",
+                "table"
               ]
             }
           }
diff --git a/backend/.sqlx/query-e3fd8cfde2ae3e374b7c4ffcab91fcce10865992242cd053779760cc68909ff7.json b/backend/.sqlx/query-e3fd8cfde2ae3e374b7c4ffcab91fcce10865992242cd053779760cc68909ff7.json
new file mode 100644
index 0000000000..9509a76604
--- /dev/null
+++ b/backend/.sqlx/query-e3fd8cfde2ae3e374b7c4ffcab91fcce10865992242cd053779760cc68909ff7.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM script_trigger\n          WHERE workspace_id = $1 AND runnable_kind = 'script' AND runnable_path = $2\n            AND trigger_kind = 'asset' AND trigger_ref LIKE 'dbt://%'",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "e3fd8cfde2ae3e374b7c4ffcab91fcce10865992242cd053779760cc68909ff7"
+}
diff --git a/backend/.sqlx/query-e4d71278fb80126a7a9da73f1889352d4d1e3cb3a8a08f1c9c03055a1cab1235.json b/backend/.sqlx/query-e4d71278fb80126a7a9da73f1889352d4d1e3cb3a8a08f1c9c03055a1cab1235.json
index ad34773e36..29d3eede53 100644
--- a/backend/.sqlx/query-e4d71278fb80126a7a9da73f1889352d4d1e3cb3a8a08f1c9c03055a1cab1235.json
+++ b/backend/.sqlx/query-e4d71278fb80126a7a9da73f1889352d4d1e3cb3a8a08f1c9c03055a1cab1235.json
@@ -134,7 +134,8 @@
                 "java",
                 "duckdb",
                 "ruby",
-                "rlang"
+                "rlang",
+                "dbt"
               ]
             }
           }
diff --git a/backend/.sqlx/query-ec2ed5203effe26c9584b266c5ccbc2a399e3a0e126c9ba7d0558d37c16926fa.json b/backend/.sqlx/query-ec2ed5203effe26c9584b266c5ccbc2a399e3a0e126c9ba7d0558d37c16926fa.json
new file mode 100644
index 0000000000..d6e1a1bb57
--- /dev/null
+++ b/backend/.sqlx/query-ec2ed5203effe26c9584b266c5ccbc2a399e3a0e126c9ba7d0558d37c16926fa.json
@@ -0,0 +1,30 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO dbt_run_progress\n           (workspace_id, job_id, asset_kind, asset_path, status, row_count, error, updated_at)\n         VALUES ($1, $2, 'dbt', $3, $4, $5, $6, now())\n         ON CONFLICT (workspace_id, job_id, asset_kind, asset_path)\n         DO UPDATE SET status = EXCLUDED.status, row_count = EXCLUDED.row_count,\n                       error = EXCLUDED.error, updated_at = now()",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Uuid",
+        "Varchar",
+        {
+          "Custom": {
+            "name": "materialization_status",
+            "kind": {
+              "Enum": [
+                "running",
+                "materialized",
+                "failed"
+              ]
+            }
+          }
+        },
+        "Int8",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "ec2ed5203effe26c9584b266c5ccbc2a399e3a0e126c9ba7d0558d37c16926fa"
+}
diff --git a/backend/.sqlx/query-ed421d15d2f9883196619418b3ebd7c687900b66cd8c3a173f2e3410e4ed86d9.json b/backend/.sqlx/query-ed421d15d2f9883196619418b3ebd7c687900b66cd8c3a173f2e3410e4ed86d9.json
new file mode 100644
index 0000000000..90e4ba1e36
--- /dev/null
+++ b/backend/.sqlx/query-ed421d15d2f9883196619418b3ebd7c687900b66cd8c3a173f2e3410e4ed86d9.json
@@ -0,0 +1,24 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT EXISTS(SELECT 1 FROM v2_job_queue q JOIN v2_job j ON j.id = q.id\n                            WHERE q.id = $1 AND j.workspace_id = $2 AND q.tag = ANY($3))",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "exists",
+        "type_info": "Bool"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Uuid",
+        "Text",
+        "TextArray"
+      ]
+    },
+    "nullable": [
+      null
+    ]
+  },
+  "hash": "ed421d15d2f9883196619418b3ebd7c687900b66cd8c3a173f2e3410e4ed86d9"
+}
diff --git a/backend/.sqlx/query-edd6c09b7f012588788fd3c572d20eb439a80d52ae75ebd25128ffce759cd313.json b/backend/.sqlx/query-edd6c09b7f012588788fd3c572d20eb439a80d52ae75ebd25128ffce759cd313.json
index 33b0b1f144..2357865ebc 100644
--- a/backend/.sqlx/query-edd6c09b7f012588788fd3c572d20eb439a80d52ae75ebd25128ffce759cd313.json
+++ b/backend/.sqlx/query-edd6c09b7f012588788fd3c572d20eb439a80d52ae75ebd25128ffce759cd313.json
@@ -44,7 +44,8 @@
                 "java",
                 "duckdb",
                 "ruby",
-                "rlang"
+                "rlang",
+                "dbt"
               ]
             }
           }
diff --git a/backend/.sqlx/query-ee4bf2bbc5ee6a49d7b5493793bb6771e9a2bcc847c5b64ee784b469242a1717.json b/backend/.sqlx/query-ee4bf2bbc5ee6a49d7b5493793bb6771e9a2bcc847c5b64ee784b469242a1717.json
new file mode 100644
index 0000000000..89a7be2f20
--- /dev/null
+++ b/backend/.sqlx/query-ee4bf2bbc5ee6a49d7b5493793bb6771e9a2bcc847c5b64ee784b469242a1717.json
@@ -0,0 +1,32 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "WITH live AS (\n             SELECT * FROM (\n               SELECT DISTINCT ON (s.path) s.path, s.hash\n                 FROM script s\n                WHERE $5::text IS NULL AND s.workspace_id = $1 AND s.language = 'dbt'\n                  AND ($3::bigint IS NULL OR s.hash = $3)\n                  AND ($3::bigint IS NOT NULL OR (s.deleted = false AND s.archived = false))\n                ORDER BY s.path, s.created_at DESC\n             ) cur\n             UNION ALL\n             SELECT $5::text, $3::bigint WHERE $5::text IS NOT NULL\n           ),\n           -- The run's own snapshot when it left one, the version's graph\n           -- otherwise. A static descriptor never snapshots, so all of its runs\n           -- fall through to the same rows. Existence comes from the marker, not\n           -- from a node row: a dynamic run that disabled every model has a\n           -- snapshot whose graph is legitimately empty.\n           chosen AS (\n             -- No visibility check on the job here: reaching this with a job at\n             -- all means the caller passed `require_job_read_access` for it, and\n             -- re-deciding it under plain RLS can only DISAGREE with that answer\n             -- \u2014 silently, by falling back to the deployed graph rather than\n             -- erroring. A share-link viewer is entitled to the run and would be\n             -- shown a different run's model set. See `asset_graph_for`.\n             SELECT CASE WHEN $4::uuid IS NOT NULL AND EXISTS (\n                      SELECT 1 FROM dbt_graph_snapshot g\n                       WHERE g.workspace_id = $1 AND g.job_id = $4)\n                    THEN $4::uuid\n                    ELSE '00000000-0000-0000-0000-000000000000'::uuid END AS job_id\n           )\n           SELECT p.asset_path AS \"from_path!\", c.asset_path AS \"to_path!\"\n             FROM dbt_edge e\n             JOIN live l ON l.path = e.script_path AND l.hash = e.script_hash\n             JOIN chosen ch ON ch.job_id = e.job_id\n             JOIN dbt_node p ON p.workspace_id = e.workspace_id\n                            AND p.script_path = e.script_path\n                            AND p.script_hash = e.script_hash\n                            AND p.job_id = ch.job_id\n                            AND p.unique_id = e.parent_unique_id\n             JOIN dbt_node c ON c.workspace_id = e.workspace_id\n                            AND c.script_path = e.script_path\n                            AND c.script_hash = e.script_hash\n                            AND c.job_id = ch.job_id\n                            AND c.unique_id = e.child_unique_id\n            WHERE e.workspace_id = $1\n              AND p.asset_path IS NOT NULL AND c.asset_path IS NOT NULL\n              -- Tests attach to their model as a badge, not as a lineage edge.\n              AND c.resource_type <> 'test'\n              -- Scoped by the RELATIONS, like the node provenance above, not by\n              -- the producing script's folder: two tables consumed in this\n              -- folder but produced by a dbt project outside it would otherwise\n              -- both render with their `ref()` edge missing.\n              -- Same as the node scope: pinned, `asset` describes the CURRENT\n              -- deploy, so gating on it drops the edges of models this version\n              -- had and a later one removed. The pinned version's own edges are\n              -- the answer.\n              AND ($3::bigint IS NOT NULL OR EXISTS (\n                SELECT 1 FROM asset a\n                 WHERE a.workspace_id = $1 AND a.kind = 'dbt'\n                   AND a.path = c.asset_path\n                   AND ($2::text IS NULL OR a.usage_path LIKE $2)))",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "from_path!",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 1,
+        "name": "to_path!",
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text",
+        "Int8",
+        "Uuid",
+        "Text"
+      ]
+    },
+    "nullable": [
+      true,
+      true
+    ]
+  },
+  "hash": "ee4bf2bbc5ee6a49d7b5493793bb6771e9a2bcc847c5b64ee784b469242a1717"
+}
diff --git a/backend/.sqlx/query-eed8122fdcd007543dc6ca28b216845c6249c4598c4e16aa50067fdc6136451c.json b/backend/.sqlx/query-eed8122fdcd007543dc6ca28b216845c6249c4598c4e16aa50067fdc6136451c.json
new file mode 100644
index 0000000000..e02c5897a4
--- /dev/null
+++ b/backend/.sqlx/query-eed8122fdcd007543dc6ca28b216845c6249c4598c4e16aa50067fdc6136451c.json
@@ -0,0 +1,15 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO dbt_graph_snapshot (workspace_id, script_path, script_hash, job_id,\n            digest, relation_root_at_last_ingest, ingested_at)\n         SELECT $2, script_path, script_hash, job_id, digest, relation_root_at_last_ingest,\n            ingested_at\n         FROM dbt_graph_snapshot\n         WHERE workspace_id = $1 AND job_id = '00000000-0000-0000-0000-000000000000'",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "eed8122fdcd007543dc6ca28b216845c6249c4598c4e16aa50067fdc6136451c"
+}
diff --git a/backend/.sqlx/query-f0858450021df721d8a48b1b5dc887c5424562acd9769c80c5899193ef16b56b.json b/backend/.sqlx/query-f0858450021df721d8a48b1b5dc887c5424562acd9769c80c5899193ef16b56b.json
index ad6028c14f..1bd565d00c 100644
--- a/backend/.sqlx/query-f0858450021df721d8a48b1b5dc887c5424562acd9769c80c5899193ef16b56b.json
+++ b/backend/.sqlx/query-f0858450021df721d8a48b1b5dc887c5424562acd9769c80c5899193ef16b56b.json
@@ -44,7 +44,8 @@
                 "java",
                 "duckdb",
                 "ruby",
-                "rlang"
+                "rlang",
+                "dbt"
               ]
             }
           }
diff --git a/backend/.sqlx/query-88a6a86285fcfaa778e9716d5072f555dff175feb704c3d825d6100defe91bce.json b/backend/.sqlx/query-f1a34561f208c05d75b2f981cd55465e579dd71a9439a2182ef05d9d3cfe462e.json
similarity index 83%
rename from backend/.sqlx/query-88a6a86285fcfaa778e9716d5072f555dff175feb704c3d825d6100defe91bce.json
rename to backend/.sqlx/query-f1a34561f208c05d75b2f981cd55465e579dd71a9439a2182ef05d9d3cfe462e.json
index 9097eb8584..81034a3861 100644
--- a/backend/.sqlx/query-88a6a86285fcfaa778e9716d5072f555dff175feb704c3d825d6100defe91bce.json
+++ b/backend/.sqlx/query-f1a34561f208c05d75b2f981cd55465e579dd71a9439a2182ef05d9d3cfe462e.json
@@ -1,6 +1,6 @@
 {
   "db_name": "PostgreSQL",
-  "query": "\n        SELECT\n            workspace_id,\n            slack_team_id,\n            teams_team_id,\n            teams_team_name,\n            teams_team_guid,\n            slack_name,\n            slack_command_script,\n            teams_command_script,\n            slack_email,\n            slack_oauth_client_id,\n            slack_oauth_client_secret,\n            customer_id,\n            plan,\n            webhook,\n            ai_config,\n            large_file_storage,\n            datatable,\n            ducklake,\n            git_sync,\n            deploy_ui,\n            default_app,\n            default_scripts,\n            mute_critical_alerts,\n            color,\n            operator_settings,\n            git_app_installations,\n            auto_invite,\n            error_handler,\n            success_handler,\n            public_app_execution_limit_per_minute,\n            error_handler_fallback_to_instance_alerts\n        FROM\n            workspace_settings\n        WHERE\n            workspace_id = $1\n        ",
+  "query": "\n        SELECT\n            workspace_id,\n            slack_team_id,\n            teams_team_id,\n            teams_team_name,\n            teams_team_guid,\n            slack_name,\n            slack_command_script,\n            teams_command_script,\n            slack_email,\n            slack_oauth_client_id,\n            slack_oauth_client_secret,\n            customer_id,\n            plan,\n            webhook,\n            ai_config,\n            dbt_warehouses,\n            large_file_storage,\n            datatable,\n            ducklake,\n            git_sync,\n            deploy_ui,\n            default_app,\n            default_scripts,\n            mute_critical_alerts,\n            color,\n            operator_settings,\n            git_app_installations,\n            auto_invite,\n            error_handler,\n            success_handler,\n            public_app_execution_limit_per_minute,\n            error_handler_fallback_to_instance_alerts\n        FROM\n            workspace_settings\n        WHERE\n            workspace_id = $1\n        ",
   "describe": {
     "columns": [
       {
@@ -80,81 +80,86 @@
       },
       {
         "ordinal": 15,
-        "name": "large_file_storage",
+        "name": "dbt_warehouses",
         "type_info": "Jsonb"
       },
       {
         "ordinal": 16,
-        "name": "datatable",
+        "name": "large_file_storage",
         "type_info": "Jsonb"
       },
       {
         "ordinal": 17,
-        "name": "ducklake",
+        "name": "datatable",
         "type_info": "Jsonb"
       },
       {
         "ordinal": 18,
-        "name": "git_sync",
+        "name": "ducklake",
         "type_info": "Jsonb"
       },
       {
         "ordinal": 19,
-        "name": "deploy_ui",
+        "name": "git_sync",
         "type_info": "Jsonb"
       },
       {
         "ordinal": 20,
+        "name": "deploy_ui",
+        "type_info": "Jsonb"
+      },
+      {
+        "ordinal": 21,
         "name": "default_app",
         "type_info": "Varchar"
       },
       {
-        "ordinal": 21,
+        "ordinal": 22,
         "name": "default_scripts",
         "type_info": "Jsonb"
       },
       {
-        "ordinal": 22,
+        "ordinal": 23,
         "name": "mute_critical_alerts",
         "type_info": "Bool"
       },
       {
-        "ordinal": 23,
+        "ordinal": 24,
         "name": "color",
         "type_info": "Varchar"
       },
       {
-        "ordinal": 24,
+        "ordinal": 25,
         "name": "operator_settings",
         "type_info": "Jsonb"
       },
       {
-        "ordinal": 25,
+        "ordinal": 26,
         "name": "git_app_installations",
         "type_info": "Jsonb"
       },
       {
-        "ordinal": 26,
+        "ordinal": 27,
         "name": "auto_invite",
         "type_info": "Jsonb"
       },
       {
-        "ordinal": 27,
+        "ordinal": 28,
         "name": "error_handler",
         "type_info": "Jsonb"
       },
       {
-        "ordinal": 28,
+        "ordinal": 29,
         "name": "success_handler",
         "type_info": "Jsonb"
       },
       {
-        "ordinal": 29,
+        "ordinal": 30,
         "name": "public_app_execution_limit_per_minute",
         "type_info": "Int4"
       },
       {
-        "ordinal": 30,
+        "ordinal": 31,
         "name": "error_handler_fallback_to_instance_alerts",
         "type_info": "Bool"
       }
@@ -190,6 +195,7 @@
       true,
       true,
       true,
+      true,
       false,
       true,
       true,
@@ -198,5 +204,5 @@
       false
     ]
   },
-  "hash": "88a6a86285fcfaa778e9716d5072f555dff175feb704c3d825d6100defe91bce"
+  "hash": "f1a34561f208c05d75b2f981cd55465e579dd71a9439a2182ef05d9d3cfe462e"
 }
diff --git a/backend/.sqlx/query-f2bd875385052618533c868bee309de8863a5d10a482f012ee790eda64e88211.json b/backend/.sqlx/query-f2bd875385052618533c868bee309de8863a5d10a482f012ee790eda64e88211.json
index 07191c20b8..197229bb4c 100644
--- a/backend/.sqlx/query-f2bd875385052618533c868bee309de8863a5d10a482f012ee790eda64e88211.json
+++ b/backend/.sqlx/query-f2bd875385052618533c868bee309de8863a5d10a482f012ee790eda64e88211.json
@@ -41,7 +41,8 @@
                 "java",
                 "duckdb",
                 "ruby",
-                "rlang"
+                "rlang",
+                "dbt"
               ]
             }
           }
diff --git a/backend/.sqlx/query-f2fa27ed5020aa9c085176b25466be1bceb79c82e7b5542f17b23b6d70cc02d6.json b/backend/.sqlx/query-f2fa27ed5020aa9c085176b25466be1bceb79c82e7b5542f17b23b6d70cc02d6.json
index 12eceb0110..57d80d6aaa 100644
--- a/backend/.sqlx/query-f2fa27ed5020aa9c085176b25466be1bceb79c82e7b5542f17b23b6d70cc02d6.json
+++ b/backend/.sqlx/query-f2fa27ed5020aa9c085176b25466be1bceb79c82e7b5542f17b23b6d70cc02d6.json
@@ -39,7 +39,8 @@
                 "java",
                 "duckdb",
                 "ruby",
-                "rlang"
+                "rlang",
+                "dbt"
               ]
             }
           }
@@ -86,7 +87,8 @@
                       "java",
                       "duckdb",
                       "ruby",
-                      "rlang"
+                      "rlang",
+                      "dbt"
                     ]
                   }
                 }
diff --git a/backend/.sqlx/query-f45962e947ae236266f8eb9b08ca6420ac7e0d548fb59473a2f7ac5be2ee5194.json b/backend/.sqlx/query-f45962e947ae236266f8eb9b08ca6420ac7e0d548fb59473a2f7ac5be2ee5194.json
new file mode 100644
index 0000000000..8cae250396
--- /dev/null
+++ b/backend/.sqlx/query-f45962e947ae236266f8eb9b08ca6420ac7e0d548fb59473a2f7ac5be2ee5194.json
@@ -0,0 +1,24 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT job_id FROM dbt_run_state\n          WHERE workspace_id = $1 AND script_path = $2 AND permissioned_as = $3",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "job_id",
+        "type_info": "Uuid"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": [
+      true
+    ]
+  },
+  "hash": "f45962e947ae236266f8eb9b08ca6420ac7e0d548fb59473a2f7ac5be2ee5194"
+}
diff --git a/backend/.sqlx/query-f5eedc14b082c88a1096e61279faa73793c99a2ab5793bebc5924146f60d19a8.json b/backend/.sqlx/query-f5eedc14b082c88a1096e61279faa73793c99a2ab5793bebc5924146f60d19a8.json
new file mode 100644
index 0000000000..51c665b245
--- /dev/null
+++ b/backend/.sqlx/query-f5eedc14b082c88a1096e61279faa73793c99a2ab5793bebc5924146f60d19a8.json
@@ -0,0 +1,62 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT asset_kind AS \"asset_kind: windmill_common::assets::AssetKind\", asset_path,\n                    status::text AS \"status!\", row_count, error\n               FROM materialized_partition\n              WHERE workspace_id = $1 AND job_id = $2",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "asset_kind: windmill_common::assets::AssetKind",
+        "type_info": {
+          "Custom": {
+            "name": "asset_kind",
+            "kind": {
+              "Enum": [
+                "s3object",
+                "resource",
+                "variable",
+                "ducklake",
+                "datatable",
+                "volume",
+                "table"
+              ]
+            }
+          }
+        }
+      },
+      {
+        "ordinal": 1,
+        "name": "asset_path",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 2,
+        "name": "status!",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 3,
+        "name": "row_count",
+        "type_info": "Int8"
+      },
+      {
+        "ordinal": 4,
+        "name": "error",
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Uuid"
+      ]
+    },
+    "nullable": [
+      false,
+      false,
+      null,
+      true,
+      true
+    ]
+  },
+  "hash": "f5eedc14b082c88a1096e61279faa73793c99a2ab5793bebc5924146f60d19a8"
+}
diff --git a/backend/.sqlx/query-fb2a7f9b797a45351439746e1478545c969d995dc02aaf6673183a73cab67179.json b/backend/.sqlx/query-fb2a7f9b797a45351439746e1478545c969d995dc02aaf6673183a73cab67179.json
new file mode 100644
index 0000000000..d74c17a1ed
--- /dev/null
+++ b/backend/.sqlx/query-fb2a7f9b797a45351439746e1478545c969d995dc02aaf6673183a73cab67179.json
@@ -0,0 +1,24 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT job_id FROM dbt_run_state\n              WHERE workspace_id = $1 AND script_path = $2 AND permissioned_as = $3",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "job_id",
+        "type_info": "Uuid"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": [
+      true
+    ]
+  },
+  "hash": "fb2a7f9b797a45351439746e1478545c969d995dc02aaf6673183a73cab67179"
+}
diff --git a/backend/.sqlx/query-ff244d58f154fc3132205fbb8374f01ceb707d9ae0b02bf382d4f5dca73829e2.json b/backend/.sqlx/query-ff244d58f154fc3132205fbb8374f01ceb707d9ae0b02bf382d4f5dca73829e2.json
new file mode 100644
index 0000000000..13ed472958
--- /dev/null
+++ b/backend/.sqlx/query-ff244d58f154fc3132205fbb8374f01ceb707d9ae0b02bf382d4f5dca73829e2.json
@@ -0,0 +1,25 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "SELECT digest FROM dbt_graph_snapshot\n              WHERE workspace_id = $1 AND script_path = $2 AND script_hash = $3\n                AND job_id = $4",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "digest",
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text",
+        "Int8",
+        "Uuid"
+      ]
+    },
+    "nullable": [
+      false
+    ]
+  },
+  "hash": "ff244d58f154fc3132205fbb8374f01ceb707d9ae0b02bf382d4f5dca73829e2"
+}
diff --git a/backend/Cargo.lock b/backend/Cargo.lock
index bd12841ccc..4f24929695 100644
--- a/backend/Cargo.lock
+++ b/backend/Cargo.lock
@@ -14789,7 +14789,9 @@ dependencies = [
  "serde",
  "serde_json",
  "sqlx",
+ "tokio",
  "tracing",
+ "uuid",
  "windmill-api-auth",
  "windmill-common",
  "windmill-parser-sql-asset",
@@ -15854,8 +15856,11 @@ name = "windmill-parser-yaml"
 version = "1.775.2"
 dependencies = [
  "anyhow",
+ "lazy_static",
+ "regex",
  "serde",
  "serde_json",
+ "serde_yml",
  "windmill-parser",
  "yaml-rust",
 ]
@@ -16434,6 +16439,7 @@ dependencies = [
  "rustls-pemfile 2.2.0",
  "serde",
  "serde_json",
+ "serde_yml",
  "sha2 0.10.9",
  "sqlx",
  "tar",
diff --git a/backend/ee-repo-ref.txt b/backend/ee-repo-ref.txt
index 108c17635c..df1600e68b 100644
--- a/backend/ee-repo-ref.txt
+++ b/backend/ee-repo-ref.txt
@@ -1 +1 @@
-564ad8932e1488dfc4b2694d9b4e50c580d1b8ed
+cfd98fe9f640d86f34a363519e09a1ee0a5dedb3
diff --git a/backend/migrations/20260725084224_add_dbt_lang.down.sql b/backend/migrations/20260725084224_add_dbt_lang.down.sql
new file mode 100644
index 0000000000..d2f607c5b8
--- /dev/null
+++ b/backend/migrations/20260725084224_add_dbt_lang.down.sql
@@ -0,0 +1 @@
+-- Add down migration script here
diff --git a/backend/migrations/20260725084224_add_dbt_lang.up.sql b/backend/migrations/20260725084224_add_dbt_lang.up.sql
new file mode 100644
index 0000000000..ec99678460
--- /dev/null
+++ b/backend/migrations/20260725084224_add_dbt_lang.up.sql
@@ -0,0 +1,2 @@
+ALTER TYPE SCRIPT_LANG ADD VALUE IF NOT EXISTS 'dbt';
+UPDATE config SET config = jsonb_set(config, '{worker_tags}', config->'worker_tags' || '["dbt"]'::jsonb) WHERE name = 'worker__default' AND config @> '{"worker_tags": ["deno", "python3", "go", "bash", "powershell", "dependency", "flow", "hub", "other", "bun", "php", "rust", "ansible", "csharp", "nu", "java", "duckdb", "ruby", "rlang"]}'::jsonb AND NOT config->'worker_tags' @> '"dbt"'::jsonb;
diff --git a/backend/migrations/20260725084314_dbt_runtime.down.sql b/backend/migrations/20260725084314_dbt_runtime.down.sql
new file mode 100644
index 0000000000..93fd7ef4b5
--- /dev/null
+++ b/backend/migrations/20260725084314_dbt_runtime.down.sql
@@ -0,0 +1,7 @@
+DROP TABLE IF EXISTS dbt_run_progress;
+DROP TABLE IF EXISTS dbt_run_state;
+DROP TABLE IF EXISTS dbt_graph_snapshot;
+DROP TABLE IF EXISTS dbt_edge;
+DROP TABLE IF EXISTS dbt_node;
+
+ALTER TABLE workspace_settings DROP COLUMN IF EXISTS dbt_warehouses;
diff --git a/backend/migrations/20260725084314_dbt_runtime.up.sql b/backend/migrations/20260725084314_dbt_runtime.up.sql
new file mode 100644
index 0000000000..c40441933d
--- /dev/null
+++ b/backend/migrations/20260725084314_dbt_runtime.up.sql
@@ -0,0 +1,218 @@
+-- The dbt runtime's tables: the parsed manifest that becomes the asset graph,
+-- the retry state a `dbt retry` resumes from, and a run's live per-model
+-- progress.
+
+-- Physical-relation asset kind. Identity is the relation itself
+-- (`<warehouse>/<schema>/<name>`, the warehouse named as the workspace
+-- configures it), never the producing tool, so a dbt mart and a native script
+-- reading the same table resolve to one node and the lineage is one graph
+-- across the boundary (docs/dbt-runtime.md, decision 11).
+ALTER TYPE ASSET_KIND ADD VALUE IF NOT EXISTS 'dbt';
+
+-- Warehouses configured once for the workspace, so a dbt project needs no
+-- connection knowledge to run: the descriptor names one by NAME (or nothing, for
+-- `main`) and the value here points at the RESOURCE that holds the credentials,
+-- exactly as `large_file_storage` does for buckets. A flat map keyed by name,
+-- which is also what asset identity keys on.
+--
+--   {"main": {"resource_path": "$res:u/admin/wh", "target": "prod"},
+--    "eu":   {"resource_path": "$res:u/admin/wh_eu"}}
+ALTER TABLE workspace_settings ADD COLUMN IF NOT EXISTS dbt_warehouses JSONB;
+
+-- Parsed dbt manifest, one row per dbt node. The full manifest.json is not
+-- stored -- only the fields the asset graph renders.
+--
+-- Keyed by (path, version, job). The VERSION because each deployed version of a
+-- script keeps its own graph, so a finished run can be shown the project as it
+-- was rather than whatever is deployed today. The JOB because a dynamic
+-- descriptor -- a `{{ }}` placeholder in `vars` -- can resolve to a different
+-- set of models per run, and those runs re-ingest; the zero UUID means "the
+-- version's own graph, as deployed", which is what a static descriptor writes
+-- once and every one of its runs reads. A sentinel rather than NULL because
+-- `job_id` is part of the key and Postgres does not treat two NULLs as the same
+-- key, so each re-ingest would add a row set instead of replacing one.
+CREATE TABLE IF NOT EXISTS dbt_node (
+  workspace_id     VARCHAR(50) NOT NULL REFERENCES workspace(id) ON DELETE CASCADE ON UPDATE CASCADE,
+  script_path      VARCHAR(255) NOT NULL,
+  script_hash      BIGINT NOT NULL,
+  job_id           UUID NOT NULL DEFAULT '00000000-0000-0000-0000-000000000000',
+  -- dbt's own node id, e.g. `model.jaffle_shop.customers`. Stable across runs
+  -- and the join key for dbt_edge and for run_results ingestion.
+  unique_id        TEXT NOT NULL,
+  resource_type    TEXT NOT NULL,
+  name             TEXT NOT NULL,
+  -- The physical relation this node produces, spelled as the matching `asset`
+  -- row's path (`<warehouse>/<schema>/<name>`). NULL for nodes with no
+  -- relation: ephemeral models, tests.
+  asset_path       TEXT,
+  materialized     TEXT,
+  -- Windmill's equivalent write strategy (replace | append | merge | scd2),
+  -- NULL when dbt's materialization has no analogue (view, ephemeral).
+  materialize_strategy TEXT,
+  unique_key       TEXT,
+  tags             TEXT[] NOT NULL DEFAULT '{}',
+  description      TEXT,
+  -- Test nodes only: the generic test name (`unique`, `not_null`,
+  -- `accepted_values`, `relationships`, or a package/custom test's own name),
+  -- the column it is attached to, its rendered kwargs and dbt's severity.
+  -- Severity is stored as dbt spells it; readers compare case-insensitively
+  -- because dbt-core 1.x echoes the author's casing while 2.x uppercases it.
+  test_kind        TEXT,
+  test_column      TEXT,
+  test_args        JSONB,
+  severity         TEXT,
+  attached_node    TEXT,
+  -- Declared per-column metadata (name -> description), the column sets the
+  -- asset graph shows. dbt's manifest carries no column-to-column lineage, so
+  -- this is not a column lineage graph.
+  columns          JSONB,
+  freshness        JSONB,
+  -- The model's SQL as written, for the graph to render. `dbt parse` fills it;
+  -- `compiled_code` would need a `dbt compile`, which no phase runs.
+  raw_code         TEXT,
+  -- Its path inside the dbt project, e.g. `models/staging/stg_orders.sql`.
+  original_file_path TEXT,
+  ingested_at      TIMESTAMPTZ NOT NULL DEFAULT now(),
+  PRIMARY KEY (workspace_id, script_path, script_hash, job_id, unique_id),
+  -- Composite because `script`'s key is (workspace_id, hash). A version's graph
+  -- dies with the version and nothing has to sweep it.
+  CONSTRAINT dbt_node_script_fkey FOREIGN KEY (workspace_id, script_hash)
+    REFERENCES script (workspace_id, hash) ON DELETE CASCADE ON UPDATE CASCADE
+);
+
+-- `ref()` / `source()` lineage, straight from the manifest's parent_map.
+CREATE TABLE IF NOT EXISTS dbt_edge (
+  workspace_id     VARCHAR(50) NOT NULL REFERENCES workspace(id) ON DELETE CASCADE ON UPDATE CASCADE,
+  script_path      VARCHAR(255) NOT NULL,
+  script_hash      BIGINT NOT NULL,
+  job_id           UUID NOT NULL DEFAULT '00000000-0000-0000-0000-000000000000',
+  parent_unique_id TEXT NOT NULL,
+  child_unique_id  TEXT NOT NULL,
+  ingested_at      TIMESTAMPTZ NOT NULL DEFAULT now(),
+  PRIMARY KEY (workspace_id, script_path, script_hash, job_id, parent_unique_id, child_unique_id),
+  CONSTRAINT dbt_edge_script_fkey FOREIGN KEY (workspace_id, script_hash)
+    REFERENCES script (workspace_id, hash) ON DELETE CASCADE ON UPDATE CASCADE
+);
+
+-- One row per stored graph, so a snapshot's EXISTENCE does not depend on it
+-- having any nodes: a dynamic run can disable every model, and that empty graph
+-- has to be distinguishable from a run that stored nothing -- otherwise the run
+-- page falls back to the deployed models and shows what the run never built.
+--
+-- It is also where the content digest lives, once. A run whose digest matches
+-- the version's writes no snapshot at all: marking a descriptor dynamic is
+-- conservative (a `{{ }}` in `vars` says the arguments reach dbt, not that they
+-- change which models exist), so the usual dynamic run resolves to exactly the
+-- graph the deploy stored.
+CREATE TABLE IF NOT EXISTS dbt_graph_snapshot (
+  workspace_id VARCHAR(50) NOT NULL REFERENCES workspace(id) ON DELETE CASCADE ON UPDATE CASCADE,
+  script_path  VARCHAR(255) NOT NULL,
+  script_hash  BIGINT NOT NULL,
+  job_id       UUID NOT NULL,
+  digest       TEXT NOT NULL,
+  -- On the DEPLOYED row only: the relation root the last ingest to write this
+  -- row resolved. Written by every ingest that is not a run's own snapshot,
+  -- including one that publishes no ownership — a version that cannot claim the
+  -- path would otherwise record nothing and compare against a stale root.
+  --
+  -- The drift check needs "where do the current usages point", and no other
+  -- row answers it: the deploy's own root goes stale the moment a run at a
+  -- moved profile republishes, and "the newest ingest" is wrong because a run
+  -- whose graph matches the deploy's stores nothing at all.
+  relation_root_at_last_ingest TEXT,
+  ingested_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
+  PRIMARY KEY (workspace_id, script_path, script_hash, job_id),
+  -- Same cascade as the rows it stands for. A marker outliving its nodes is
+  -- read as a snapshot that has none, and its digest still answers the
+  -- suppression check.
+  CONSTRAINT dbt_graph_snapshot_script_fkey FOREIGN KEY (workspace_id, script_hash)
+    REFERENCES script (workspace_id, hash) ON DELETE CASCADE ON UPDATE CASCADE
+);
+
+-- What a `dbt retry` resumes from. Keyed by path, not by version: there is one
+-- saved run per script, and `identity` -- the project digest, warehouse and
+-- engine -- is what refuses a resume that no longer describes the same run.
+CREATE TABLE IF NOT EXISTS dbt_run_state (
+  workspace_id VARCHAR(50) NOT NULL REFERENCES workspace(id) ON DELETE CASCADE ON UPDATE CASCADE,
+  script_path  VARCHAR(255) NOT NULL,
+  -- Part of the key: a retry replaces the caller's arguments with the saved
+  -- ones, so state written by one principal must not be restorable by another
+  -- — that would hand them the literal `select` and `vars` of a run they were
+  -- never entitled to see.
+  permissioned_as VARCHAR(255) NOT NULL,
+  identity     TEXT NOT NULL,
+  -- The invocation's job arguments. `dbt retry` reuses the original selection
+  -- and vars, so the graph refresh and the build must agree with them rather
+  -- than with the retry request's.
+  args         JSONB NOT NULL DEFAULT '{}'::jsonb,
+  -- Text rather than jsonb: nothing queries inside it, and this is highly
+  -- repetitive JSON that TOAST's compression handles well (about nine to one).
+  run_results  TEXT NOT NULL,
+  job_id       UUID,
+  -- Whether those results hold a node `dbt retry` would rebuild. A run that
+  -- failed before building anything, or succeeded outright, is still saved —
+  -- restoring it is how a retry can say the run succeeded rather than that no
+  -- state exists — but nothing may offer it as resumable.
+  retryable    BOOLEAN NOT NULL DEFAULT false,
+  updated_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
+  PRIMARY KEY (workspace_id, script_path, permissioned_as)
+);
+
+-- Live per-model progress for one RUN.
+--
+-- `materialized_partition` cannot answer this: its key is the relation, one row
+-- per table, and its `job_id` names only the last writer. Two runs of one
+-- project building the same models take that row from each other, so a progress
+-- read filtered by job loses nodes and flickers between states. That table is
+-- left as it is -- the current state of a relation is what the pipeline canvas
+-- and fork defer read, and one row per relation is right for them.
+CREATE TABLE IF NOT EXISTS dbt_run_progress (
+  workspace_id VARCHAR(50) NOT NULL REFERENCES workspace(id) ON DELETE CASCADE ON UPDATE CASCADE,
+  job_id       UUID NOT NULL,
+  asset_kind   ASSET_KIND NOT NULL,
+  asset_path   VARCHAR(255) NOT NULL,
+  status       MATERIALIZATION_STATUS NOT NULL,
+  row_count    BIGINT,
+  error        TEXT,
+  updated_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
+  PRIMARY KEY (workspace_id, job_id, asset_kind, asset_path)
+);
+
+-- Resolve a physical relation back to the dbt node that produces it: the asset
+-- graph renders from `asset` rows and needs the dbt provenance per node.
+CREATE INDEX IF NOT EXISTS idx_dbt_node_asset_path
+  ON dbt_node (workspace_id, asset_path) WHERE asset_path IS NOT NULL;
+
+-- No foreign key from the per-run rows to `v2_job`: three were deliberately
+-- dropped from it for the write amplification they cost on the hottest table in
+-- the system. Growth is bounded by age instead and pruned by the dbt runs
+-- themselves, so no background sweep has to learn about these tables -- hence
+-- an index per age sweep, and one per "does this job have a snapshot" lookup.
+CREATE INDEX IF NOT EXISTS idx_dbt_node_job ON dbt_node (job_id)
+  WHERE job_id <> '00000000-0000-0000-0000-000000000000';
+CREATE INDEX IF NOT EXISTS idx_dbt_node_run_age ON dbt_node (ingested_at)
+  WHERE job_id <> '00000000-0000-0000-0000-000000000000';
+CREATE INDEX IF NOT EXISTS idx_dbt_edge_run_age ON dbt_edge (ingested_at)
+  WHERE job_id <> '00000000-0000-0000-0000-000000000000';
+CREATE INDEX IF NOT EXISTS idx_dbt_graph_snapshot_job
+  ON dbt_graph_snapshot (workspace_id, job_id);
+CREATE INDEX IF NOT EXISTS idx_dbt_graph_snapshot_age
+  ON dbt_graph_snapshot (ingested_at)
+  WHERE job_id <> '00000000-0000-0000-0000-000000000000';
+CREATE INDEX IF NOT EXISTS idx_dbt_run_progress_updated_at
+  ON dbt_run_progress (updated_at);
+
+-- All of these are written on a user_db transaction (SET LOCAL ROLE
+-- windmill_user/windmill_admin), so they must be granted explicitly rather than
+-- relying on ALTER DEFAULT PRIVILEGES, which only covers objects created by the
+-- role that set them (see 20260720131744).
+GRANT ALL ON dbt_node TO windmill_user;
+GRANT ALL ON dbt_node TO windmill_admin;
+GRANT ALL ON dbt_edge TO windmill_user;
+GRANT ALL ON dbt_edge TO windmill_admin;
+GRANT ALL ON dbt_graph_snapshot TO windmill_user;
+GRANT ALL ON dbt_graph_snapshot TO windmill_admin;
+GRANT ALL ON dbt_run_state TO windmill_user;
+GRANT ALL ON dbt_run_state TO windmill_admin;
+GRANT ALL ON dbt_run_progress TO windmill_user;
+GRANT ALL ON dbt_run_progress TO windmill_admin;
diff --git a/backend/migrations/20260727145314_materialized_partition_job_id_index.down.sql b/backend/migrations/20260727145314_materialized_partition_job_id_index.down.sql
new file mode 100644
index 0000000000..9b33bff978
--- /dev/null
+++ b/backend/migrations/20260727145314_materialized_partition_job_id_index.down.sql
@@ -0,0 +1 @@
+DROP INDEX IF EXISTS idx_materialized_partition_job;
diff --git a/backend/migrations/20260727145314_materialized_partition_job_id_index.up.sql b/backend/migrations/20260727145314_materialized_partition_job_id_index.up.sql
new file mode 100644
index 0000000000..6bcdc246ae
--- /dev/null
+++ b/backend/migrations/20260727145314_materialized_partition_job_id_index.up.sql
@@ -0,0 +1,9 @@
+-- `job_id` leads neither the primary key nor the asset/status index, both shaped
+-- for the per-relation lookups that came first — but the closing sweep a dbt run
+-- makes (`terminalize_running_relations`) reads and writes by it, settling the
+-- models a cancelled or timed-out run left `running`.
+-- Small table until a partitioned asset is backfilled, then one row per slice
+-- per asset.
+CREATE INDEX IF NOT EXISTS idx_materialized_partition_job
+    ON materialized_partition (workspace_id, job_id)
+    WHERE job_id IS NOT NULL;
diff --git a/backend/parsers/windmill-parser-py-asset/src/lib.rs b/backend/parsers/windmill-parser-py-asset/src/lib.rs
index b8a12fb476..9c70b93d64 100644
--- a/backend/parsers/windmill-parser-py-asset/src/lib.rs
+++ b/backend/parsers/windmill-parser-py-asset/src/lib.rs
@@ -273,7 +273,7 @@ impl AssetsFinder {
             Some(Expr::Constant(ExprConstant { value: Constant::Str(value), .. })) => {
                 let path = parse_asset_syntax(&value, false)
                     .map(|(_, p)| p)
-                    .unwrap_or(&value);
+                    .unwrap_or(std::borrow::Cow::Borrowed(value));
                 self.assets.push(ParseAssetsResult {
                     kind,
                     path: path.to_string(),
diff --git a/backend/parsers/windmill-parser-wasm/Cargo.lock b/backend/parsers/windmill-parser-wasm/Cargo.lock
index 0e4e12eb89..7811768720 100644
--- a/backend/parsers/windmill-parser-wasm/Cargo.lock
+++ b/backend/parsers/windmill-parser-wasm/Cargo.lock
@@ -6227,6 +6227,7 @@ dependencies = [
  "jsonwebtoken",
  "lazy_static",
  "magic-crypt",
+ "memchr",
  "native-tls",
  "once_cell",
  "pep440_rs",
@@ -6266,6 +6267,7 @@ dependencies = [
  "windmill-macros",
  "windmill-parser",
  "windmill-parser-sql",
+ "windmill-parser-sql-asset",
  "windmill-parser-ts",
  "windmill-types",
 ]
@@ -6573,8 +6575,11 @@ name = "windmill-parser-yaml"
 version = "1.775.2"
 dependencies = [
  "anyhow",
+ "lazy_static",
+ "regex",
  "serde",
  "serde_json",
+ "serde_yml",
  "windmill-parser",
  "yaml-rust",
 ]
diff --git a/backend/parsers/windmill-parser-wasm/src/lib.rs b/backend/parsers/windmill-parser-wasm/src/lib.rs
index c843652e26..59e963d52c 100644
--- a/backend/parsers/windmill-parser-wasm/src/lib.rs
+++ b/backend/parsers/windmill-parser-wasm/src/lib.rs
@@ -164,6 +164,14 @@ pub fn parse_ansible(code: &str) -> String {
     wrap_sig(windmill_parser_yaml::parse_ansible_sig(code))
 }
 
+/// Shares the ansible parser's feature: both live in windmill-parser-yaml, and
+/// a dbt descriptor is YAML too.
+#[cfg(feature = "ansible-parser")]
+#[wasm_bindgen]
+pub fn parse_dbt(code: &str) -> String {
+    wrap_sig(windmill_parser_yaml::parse_dbt_sig(code))
+}
+
 #[cfg(feature = "ansible-parser")]
 #[wasm_bindgen]
 pub fn parse_ansible_delegate(code: &str) -> String {
diff --git a/backend/parsers/windmill-parser-yaml/Cargo.toml b/backend/parsers/windmill-parser-yaml/Cargo.toml
index eb01ba1936..eb2f16fccc 100644
--- a/backend/parsers/windmill-parser-yaml/Cargo.toml
+++ b/backend/parsers/windmill-parser-yaml/Cargo.toml
@@ -14,3 +14,6 @@ windmill-parser.workspace = true
 anyhow.workspace = true
 serde_json.workspace = true
 serde.workspace = true
+serde_yml.workspace = true
+regex.workspace = true
+lazy_static.workspace = true
diff --git a/backend/parsers/windmill-parser-yaml/src/dbt.rs b/backend/parsers/windmill-parser-yaml/src/dbt.rs
new file mode 100644
index 0000000000..e9778fd3f2
--- /dev/null
+++ b/backend/parsers/windmill-parser-yaml/src/dbt.rs
@@ -0,0 +1,768 @@
+//! The `ScriptLang::Dbt` script artifact: a YAML descriptor holding a dbt
+//! project's run configuration. The project itself is the script's module
+//! bundle, so the descriptor names no source for it.
+//!
+//! Field names track dbt's and astronomer-cosmos's vocabulary so the mental
+//! model ports without translation (docs/dbt-runtime.md, decision 22).
+//! `select` / `exclude` / `selector` are passed to dbt **verbatim**: the
+//! selector grammar is dbt's, and reimplementing it is a standing source of
+//! divergence.
+
+use std::collections::BTreeMap;
+
+use serde::{Deserialize, Serialize};
+use windmill_parser::{Arg, MainArgSignature, Typ};
+
+/// Which dbt to run. The shipped default is `dbt-core-1x` because it runs
+/// today's projects untouched; `fusion` is never bundled and is fetched from
+/// dbt Labs at runtime (docs/dbt-runtime.md, decision 1).
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, Default)]
+#[serde(rename_all = "kebab-case")]
+pub enum DbtEngine {
+    #[default]
+    #[serde(rename = "dbt-core-1x")]
+    DbtCore1x,
+    #[serde(rename = "dbt-core-2x")]
+    DbtCore2x,
+    Fusion,
+}
+
+impl DbtEngine {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            DbtEngine::DbtCore1x => "dbt-core-1x",
+            DbtEngine::DbtCore2x => "dbt-core-2x",
+            DbtEngine::Fusion => "fusion",
+        }
+    }
+
+    /// The level the machine-readable file log is written at. Separate from the
+    /// console log, which always stays human-readable at the default level and
+    /// is what reaches the job log.
+    pub fn progress_log_level(&self) -> &'static str {
+        match self {
+            DbtEngine::DbtCore1x => "info",
+            DbtEngine::DbtCore2x | DbtEngine::Fusion => "debug",
+        }
+    }
+
+    /// Whether the engine writes per-node events to its JSON **file** log — the
+    /// only source of *live* per-model status.
+    ///
+    /// Not a claim that the others produce none: dbt-core 2.x and Fusion emit
+    /// the same events, on the console, and ignore `--log-format-file json`
+    /// though both accept it. Reading them would mean taking over the console
+    /// and re-rendering the job log. Flip this the moment either honours the
+    /// flag — nothing else has to change (docs/dbt-runtime.md, "Live per-model
+    /// progress").
+    pub fn emits_node_events(&self) -> bool {
+        matches!(self, DbtEngine::DbtCore1x)
+    }
+}
+
+/// How the warehouse connection is supplied. Both paths are supported
+/// (decision 8): render `profiles.yml` from a Windmill resource, or keep the
+/// project's own file and inject Windmill secrets as env vars for
+/// `{{ env_var() }}`.
+#[derive(Serialize, Deserialize, Debug, Clone, Default)]
+#[serde(deny_unknown_fields)]
+pub struct DbtProfile {
+    /// A warehouse configured on the workspace, by name; omitted takes the
+    /// default one. This is the ONLY way a project names a warehouse — there is
+    /// no per-descriptor resource — so a dbt project carries no connection at
+    /// all, the same bargain `s3://` and `ducklake://` make with workspace
+    /// storage, and asset identity has exactly one spelling to key on.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub warehouse: Option<String>,
+
+    /// dbt target name. It selects which output of the profile runs; the
+    /// `<warehouse>` component of asset identity comes from `warehouse` above.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<String>,
+    /// Path (relative to `project`) of the project's own `profiles.yml`, used
+    /// instead of rendering one.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub profiles_yml: Option<String>,
+    /// Target schema (BigQuery calls it the dataset). Required for adapters
+    /// whose Windmill resource carries none — a BigQuery resource is a raw
+    /// service-account JSON, which has no dataset in it. Overrides the
+    /// resource's own value where there is one.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    /// dbt adapter (`postgres` | `snowflake` | `bigquery` | `databricks`),
+    /// spelled as dbt's own `type:`. Optional: the worker infers it from the
+    /// resource's shape, and this pins it when the inference is wrong or the
+    /// resource is a custom type.
+    #[serde(default, rename = "type", skip_serializing_if = "Option::is_none")]
+    pub adapter: Option<String>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, Default)]
+#[serde(rename_all = "snake_case")]
+pub enum DbtTestBehavior {
+    /// `dbt build` — models and their tests interleaved, a model's tests gating
+    /// its children. dbt's own default and the only behavior that stops bad
+    /// data propagating mid-run.
+    #[default]
+    Build,
+    /// `dbt run` then `dbt test`.
+    AfterAll,
+    /// `dbt run` only.
+    None,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, Default)]
+#[serde(deny_unknown_fields)]
+pub struct DbtDescriptor {
+    #[serde(default)]
+    pub engine: Option<DbtEngine>,
+    #[serde(default)]
+    pub profile: DbtProfile,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub select: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub exclude: Vec<String>,
+    /// A named selector from the project's `selectors.yml`, passed verbatim.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub selector: Option<String>,
+    #[serde(default)]
+    pub test_behavior: DbtTestBehavior,
+    /// `--vars`. dbt vars are typed — numbers, booleans, lists and objects are
+    /// all normal — so values keep their YAML type; only string leaves carry
+    /// `{{ arg }}` placeholders the worker substitutes from job args. Coercing
+    /// everything to a string would make a `false` var truthy in Jinja.
+    #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
+    pub vars: BTreeMap<String, serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub threads: Option<u32>,
+    #[serde(default)]
+    pub full_refresh: bool,
+    /// Automatic in-job retry of the nodes a build failed on.
+    ///
+    /// dbt already confines a failure to its own subtree, and `dbt retry`
+    /// rebuilds exactly the failed and skipped set, so a transient warehouse
+    /// error costs those nodes rather than the whole project. Doing it inside
+    /// the same job is what keeps the state question out of it: the previous
+    /// attempt's `run_results.json` is still in the job directory.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub retry_failed_nodes: Option<DbtNodeRetry>,
+    /// Extra environment for the dbt process, for the project's own
+    /// `{{ env_var() }}` lookups and for engine flags such as
+    /// `DBT_ALLOW_EXPERIMENTAL_ADAPTERS`. A `$var:<path>` value is resolved to
+    /// that Windmill variable's value by the worker, so a password never has to
+    /// sit in the descriptor — which is versioned script content.
+    ///
+    /// This is the map to use for anything the GRAPH depends on — an
+    /// `env_var()` driving a schema, alias or `enabled` — because it applies at
+    /// deploy as well as at run. Script-level environment variables reach the
+    /// run only, so a graph parsed without them would disagree with what the
+    /// build writes.
+    #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
+    pub env: BTreeMap<String, String>,
+}
+
+/// How many times, and how far apart, to retry a build's failed nodes.
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
+#[serde(deny_unknown_fields)]
+pub struct DbtNodeRetry {
+    /// Extra `dbt retry` attempts for the job, spent across whichever phases
+    /// fail — a model phase that uses them all leaves none for the tests.
+    pub attempts: u32,
+    /// Seconds between attempts. A transient warehouse error is usually a lock
+    /// or a restart, so a pause is the point.
+    #[serde(default)]
+    pub delay_seconds: u64,
+}
+
+impl DbtNodeRetry {
+    /// Bounded because each attempt is a real dbt invocation inside a job that
+    /// already holds a worker slot, and the job's own deadline still applies.
+    pub const MAX_ATTEMPTS: u32 = 10;
+
+    pub fn attempts(&self) -> u32 {
+        self.attempts.min(Self::MAX_ATTEMPTS)
+    }
+}
+
+/// The dbt subcommands a run may ask for. Kept here so the signature and the
+/// worker's validation cannot drift apart.
+///
+/// An allowlist rather than a passthrough: the value becomes the dbt subcommand,
+/// and running a script needs weaker permission than editing it, so an unchecked
+/// arg would let a runner invoke `clean` or `source freshness` against the
+/// descriptor's warehouse.
+///
+/// `run` is absent because it covers models only: a project with seeds or
+/// snapshots would build a subset of what its graph claims. Narrowing what a run
+/// touches is `select`/`exclude`, which scope the graph too. Tests run as part
+/// of `build`, or as the second phase of `test_behavior: after_all`.
+///
+/// `show` writes nothing — it SELECTs from a model and returns rows. That is
+/// only admissible because a dbt run no longer dispatches: while it did, any
+/// successful job fired the script's whole deploy-time write set, so a command
+/// that built none of them woke every consumer for relations nothing touched.
+pub const DBT_COMMANDS: &[&str] = &["build", "retry", "show"];
+
+/// Rows a `show` returns unless the run asks for fewer. dbt enforces it, so the
+/// bound is not us splicing a `LIMIT` into someone's SQL.
+pub const DBT_SHOW_DEFAULT_LIMIT: u32 = 100;
+
+/// Hard ceiling on that limit. The worker buffers `dbt show`'s whole stdout to
+/// read the rows out of it, so the argument decides how much memory a caller can
+/// make it hold — and running a script needs only run permission. A preview is
+/// for looking at a few rows; anything larger is a query, which is what a SQL
+/// script is for.
+pub const DBT_SHOW_MAX_LIMIT: u32 = 1_000;
+
+/// Whether the command only reads. Such a run publishes no graph, records no
+/// materializations and runs no test phase — there is nothing it could have
+/// changed.
+pub fn is_read_only_command(command: &str) -> bool {
+    command == "show"
+}
+
+/// The command a run uses when it does not name one. Public because the worker
+/// must choose exactly what the run form's default advertises.
+pub fn default_command(d: &DbtDescriptor) -> &'static str {
+    match d.test_behavior {
+        DbtTestBehavior::Build => "build",
+        // Also `build`, with the tests excluded rather than the command
+        // narrowed to `run`: `run` covers models only, so a selection that
+        // includes a seed or a snapshot would silently not build it and the
+        // models reading it would fail — or worse, read a stale table.
+        DbtTestBehavior::AfterAll | DbtTestBehavior::None => "build",
+    }
+}
+
+impl DbtDescriptor {
+    pub fn engine(&self) -> DbtEngine {
+        self.engine.unwrap_or_default()
+    }
+}
+
+/// Names a `{{ placeholder }}` may not take. `command` is the argument holding
+/// the run's command block; the rest are the fields inside it, which the worker
+/// spreads over the run's arguments to read them — a placeholder of the same
+/// name would be shadowed there, and the script could never be run (`select` is
+/// an array, and interpolating one into a string is not something any invocation
+/// can satisfy).
+pub const RESERVED_ARG_NAMES: &[&str] = &[
+    "command",
+    "select",
+    "exclude",
+    "vars",
+    "full_refresh",
+    "dbt_command",
+    "dbt_retry_job",
+    "model",
+    "limit",
+];
+
+pub fn parse_dbt_descriptor(inner_content: &str) -> anyhow::Result<DbtDescriptor> {
+    let d = serde_yml::from_str::<DbtDescriptor>(inner_content)
+        .map_err(|e| anyhow::anyhow!("Failed to parse dbt descriptor: {e}"))?;
+    if let Some(name) = placeholders(&d)
+        .into_iter()
+        .find(|n| RESERVED_ARG_NAMES.contains(&n.as_str()))
+    {
+        return Err(anyhow::anyhow!(
+            "`{{{{ {name} }}}}` collides with the run argument `{name}` this runtime already \
+             defines ({}); rename the placeholder",
+            RESERVED_ARG_NAMES.join(", ")
+        ));
+    }
+    Ok(d)
+}
+
+/// The workspace warehouse a descriptor gets when it names none — spelled like
+/// the default lake (`ducklake://main.orders`), so one workspace concept reads
+/// the same across kinds.
+pub const DBT_DEFAULT_WAREHOUSE: &str = "main";
+
+/// The single argument holding the command and the overrides it takes. Its
+/// variant IS the command, so a run cannot carry an override the command
+/// ignores: `retry` rebuilds the failed run's nodes with the arguments that run
+/// had, and `full_refresh` means nothing to a `show`.
+pub const DBT_COMMAND_ARG: &str = "command";
+
+/// The variant discriminator, which is the key Windmill's run form tags a
+/// `oneOf` value with.
+pub const DBT_COMMAND_LABEL: &str = "label";
+
+fn list_arg(name: &str, default: &[String]) -> Arg {
+    Arg {
+        name: name.to_string(),
+        otyp: None,
+        typ: Typ::List(Box::new(Typ::Str(None))),
+        has_default: true,
+        default: Some(serde_json::json!(default)),
+        oidx: None,
+        otyp_inferred: false,
+    }
+}
+
+/// An OVERRIDE map, so its default is empty rather than a copy of the
+/// descriptor's vars. Seeding it with the descriptor would make the run form
+/// post the raw `{{ placeholder }}` text back and clobber the value the worker
+/// just interpolated for it.
+fn vars_arg() -> Arg {
+    Arg {
+        name: "vars".to_string(),
+        otyp: None,
+        typ: Typ::Object(windmill_parser::ObjectType::new(None, Some(vec![]))),
+        has_default: true,
+        default: Some(serde_json::json!({})),
+        oidx: None,
+        otyp_inferred: false,
+    }
+}
+
+/// What each command takes, in form order.
+///
+/// `show` is absent on purpose: it previews ONE model's rows, which is a thing
+/// to do to a table you are looking at rather than a job to fill a form in for.
+/// The run page's graph and the assets list offer it where the tables are; the
+/// worker still accepts `{label: show, model, limit}` from a flow, the CLI or the
+/// API (`DBT_COMMANDS`, docs/dbt-runtime.md).
+fn command_variants(d: &DbtDescriptor) -> Vec<(&'static str, Vec<Arg>)> {
+    let selection = || {
+        vec![
+            list_arg("select", &d.select),
+            list_arg("exclude", &d.exclude),
+            vars_arg(),
+        ]
+    };
+    vec![
+        (
+            "build",
+            selection()
+                .into_iter()
+                .chain([Arg {
+                    name: "full_refresh".to_string(),
+                    otyp: None,
+                    typ: Typ::Bool,
+                    has_default: true,
+                    default: Some(serde_json::json!(d.full_refresh)),
+                    oidx: None,
+                    otyp_inferred: false,
+                }])
+                .collect(),
+        ),
+        (
+            "retry",
+            // The run it resumes, named rather than implied: only the latest
+            // failure of this script is kept, so "resume the last one" would
+            // silently aim somewhere else the moment another run failed. No
+            // default, so this variant requires it.
+            vec![Arg {
+                name: "dbt_retry_job".to_string(),
+                otyp: None,
+                typ: Typ::Str(None),
+                has_default: false,
+                default: None,
+                oidx: None,
+                otyp_inferred: false,
+            }],
+        ),
+    ]
+}
+
+/// The command block a run gets when it overrides nothing: the descriptor's own
+/// selection under the descriptor's default command, so an untouched run
+/// reproduces it exactly.
+fn default_command_value(d: &DbtDescriptor) -> serde_json::Value {
+    let label = default_command(d);
+    let mut obj = serde_json::Map::new();
+    obj.insert(DBT_COMMAND_LABEL.to_string(), serde_json::json!(label));
+    for arg in command_variants(d)
+        .into_iter()
+        .find(|(l, _)| *l == label)
+        .map(|(_, args)| args)
+        .unwrap_or_default()
+    {
+        if let Some(default) = arg.default {
+            obj.insert(arg.name, default);
+        }
+    }
+    serde_json::Value::Object(obj)
+}
+
+/// Run-time arguments of a dbt script: the command block above, plus one
+/// argument per `{{ placeholder }}` the descriptor interpolates. Placeholders
+/// stay top-level — they are the project's own inputs, not a command's.
+pub fn parse_dbt_sig(inner_content: &str) -> anyhow::Result<MainArgSignature> {
+    let d = parse_dbt_descriptor(inner_content)?;
+    let mut args = vec![Arg {
+        name: DBT_COMMAND_ARG.to_string(),
+        otyp: None,
+        typ: Typ::Object(windmill_parser::ObjectType::new(None, Some(vec![]))),
+        has_default: true,
+        default: Some(default_command_value(&d)),
+        oidx: None,
+        otyp_inferred: false,
+    }];
+
+    for name in placeholders(&d) {
+        if args.iter().any(|a| a.name == name) {
+            continue;
+        }
+        args.push(Arg {
+            name,
+            otyp: None,
+            // Untyped, not `Str`: a placeholder standing alone in a var takes
+            // the argument's own JSON type, and declaring it a string makes the
+            // run form post `"false"` — truthy in Jinja — for a boolean.
+            typ: Typ::Unknown,
+            has_default: false,
+            default: None,
+            oidx: None,
+            otyp_inferred: false,
+        });
+    }
+
+    Ok(MainArgSignature {
+        star_args: false,
+        star_kwargs: false,
+        args,
+        auto_kind: None,
+        has_preprocessor: None,
+        ..Default::default()
+    })
+}
+
+/// The run form's JSON schema for a dbt descriptor.
+///
+/// Derived here rather than in the browser or the CLI: both infer a script's
+/// schema client-side through `windmill-parser-wasm`, whose published package
+/// has no dbt arm, so they leave the schema untouched. Without this a dbt
+/// script deploys with an empty schema and its run form offers none of the
+/// overrides — and an edited descriptor keeps the previous one's arguments.
+/// The command is a `oneOf` rather than an enum beside the overrides it selects:
+/// a variant carries exactly the arguments its command takes, so `dbt_retry_job`
+/// is required where it means something and absent everywhere else, and no run
+/// can submit a `full_refresh` to a command that ignores it. The run form renders
+/// it as a toggle over the variants and tags the value with `label`.
+pub fn dbt_arg_schema(inner_content: &str) -> anyhow::Result<serde_json::Value> {
+    let d = parse_dbt_descriptor(inner_content)?;
+    let sig = parse_dbt_sig(inner_content)?;
+    let mut properties = serde_json::Map::new();
+    let mut required: Vec<serde_json::Value> = vec![];
+    let mut order: Vec<serde_json::Value> = vec![];
+
+    let variants: Vec<serde_json::Value> = command_variants(&d)
+        .into_iter()
+        .map(|(label, args)| {
+            let mut props = serde_json::Map::new();
+            let mut var_required: Vec<serde_json::Value> = vec![];
+            let mut var_order: Vec<serde_json::Value> = vec![serde_json::json!(DBT_COMMAND_LABEL)];
+            // The discriminator. Single-valued, so the form's toggle is what sets
+            // it and a submitted block cannot claim one command while carrying
+            // another's fields.
+            props.insert(
+                DBT_COMMAND_LABEL.to_string(),
+                serde_json::json!({"type": "string", "enum": [label]}),
+            );
+            for arg in args {
+                if !arg.has_default {
+                    var_required.push(serde_json::json!(arg.name));
+                }
+                var_order.push(serde_json::json!(arg.name));
+                props.insert(arg.name.clone(), property_of(&arg));
+            }
+            serde_json::json!({
+                "title": label,
+                "type": "object",
+                "properties": props,
+                "order": var_order,
+                "required": var_required,
+            })
+        })
+        .collect();
+
+    for arg in &sig.args {
+        let mut prop = property_of(arg);
+        if arg.name == DBT_COMMAND_ARG {
+            if let Some(obj) = prop.as_object_mut() {
+                obj.insert(
+                    "oneOf".to_string(),
+                    serde_json::Value::Array(variants.clone()),
+                );
+                obj.insert(
+                    "description".to_string(),
+                    serde_json::json!(
+                        "`build` runs the project. `retry` resumes a failed run, rebuilding only \
+                         its failed and skipped nodes with the arguments it ran with."
+                    ),
+                );
+            }
+        }
+        if !arg.has_default {
+            required.push(serde_json::json!(arg.name));
+        }
+        order.push(serde_json::json!(arg.name));
+        properties.insert(arg.name.clone(), prop);
+    }
+    Ok(serde_json::json!({
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "type": "object",
+        "properties": properties,
+        "required": required,
+        "order": order,
+    }))
+}
+
+/// One argument as a JSON-schema property, with the description the run form
+/// shows under its label.
+fn property_of(arg: &Arg) -> serde_json::Value {
+    let mut prop = match &arg.typ {
+        Typ::Bool => serde_json::json!({"type": "boolean"}),
+        // `limit` is an integer to the worker, which clamps it; without this the
+        // generated clients and the run form offer no numeric control.
+        Typ::Int => serde_json::json!({"type": "integer"}),
+        Typ::List(_) => serde_json::json!({"type": "array", "items": {"type": "string"}}),
+        Typ::Object(_) => serde_json::json!({"type": "object"}),
+        Typ::Str(Some(variants)) => serde_json::json!({"type": "string", "enum": variants}),
+        Typ::Str(None) => serde_json::json!({"type": "string"}),
+        // A placeholder takes the JSON type of whatever is passed, so it is
+        // deliberately left untyped rather than guessed at.
+        _ => serde_json::json!({}),
+    };
+    if let Some(obj) = prop.as_object_mut() {
+        if let Some(default) = arg.default.as_ref() {
+            obj.insert("default".to_string(), default.clone());
+        }
+        let description = match arg.name.as_str() {
+            "dbt_retry_job" => Some(
+                "The failed run to resume, by run id. Its failed and skipped nodes are rebuilt \
+                 with the arguments it ran with. Resuming from that run's page fills this in.",
+            ),
+            "select" => Some(
+                "dbt selection syntax, e.g. `tag:nightly`, `stg_orders+`, \
+                 `config.materialized:incremental`. Empty runs the descriptor's own selection.",
+            ),
+            "exclude" => Some("Nodes to leave out of the selection above, same syntax."),
+            "vars" => Some(
+                "dbt `--vars`, merged over the descriptor's. A var that changes which models \
+                 exist makes this run store its own graph rather than the deployed one.",
+            ),
+            "full_refresh" => Some("Rebuild incremental models from scratch instead of appending."),
+            "model" => Some(
+                "The model to preview, by name — `stg_orders`, or `my_package.stg_orders` when \
+                 two packages share a name. Any dbt selector resolving to ONE node works.",
+            ),
+            "limit" => Some("Rows the preview returns."),
+            // A placeholder the descriptor interpolates: its meaning is the
+            // project's, so there is nothing generic to say about it.
+            _ => None,
+        };
+        if let Some(d) = description {
+            obj.insert("description".to_string(), serde_json::json!(d));
+        }
+    }
+    prop
+}
+
+/// `{{ name }}` placeholders in the interpolated descriptor fields, in a stable
+/// order. Must stay in sync with the fields the worker actually interpolates.
+fn placeholders(d: &DbtDescriptor) -> Vec<String> {
+    let mut out: Vec<String> = vec![];
+    let mut push_from = |s: &str| {
+        for caps in PLACEHOLDER_RE.captures_iter(s) {
+            let name = caps[1].to_string();
+            if !out.contains(&name) {
+                out.push(name);
+            }
+        }
+    };
+    for v in d.vars.values() {
+        for leaf in string_leaves(v) {
+            push_from(leaf);
+        }
+    }
+    out
+}
+
+/// Every string inside a var's value, at any depth — the only places a
+/// `{{ arg }}` placeholder can appear.
+pub fn string_leaves(v: &serde_json::Value) -> Vec<&str> {
+    match v {
+        serde_json::Value::String(s) => vec![s.as_str()],
+        serde_json::Value::Array(a) => a.iter().flat_map(string_leaves).collect(),
+        serde_json::Value::Object(o) => o.values().flat_map(string_leaves).collect(),
+        _ => vec![],
+    }
+}
+
+lazy_static::lazy_static! {
+    /// Same spelling as the Ansible executor's `interpolate_template`, which is
+    /// what actually performs the substitution at run time.
+    static ref PLACEHOLDER_RE: regex::Regex =
+        regex::Regex::new(r"\{\{\s*([A-Za-z_][A-Za-z0-9_]*)\s*\}\}").unwrap();
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const DESCRIPTOR: &str = r#"
+engine: dbt-core-2x
+profile:
+  warehouse: main
+  target: prod
+select: ["tag:nightly+"]
+test_behavior: after_all
+vars:
+  run_date: "{{ day }}"
+  strict: false
+threads: 8
+full_refresh: true
+"#;
+
+    // A descriptor drives warehouse writes, so a field it does not recognise is
+    // an error rather than a default. `selcet:` would otherwise leave `select`
+    // empty and build the entire project; a misspelled `target` would silently
+    // fall back to the profile's own default.
+    #[test]
+    fn an_unknown_descriptor_field_is_refused() {
+        let err = parse_dbt_descriptor("profile:\n  warehouse: main\nselcet: [a]\n")
+            .unwrap_err()
+            .to_string();
+        assert!(err.contains("selcet"), "{err}");
+        let err = parse_dbt_descriptor("profile:\n  warehouse: main\n  targt: prod\n")
+            .unwrap_err()
+            .to_string();
+        assert!(err.contains("targt"), "{err}");
+    }
+
+    // A placeholder that takes a run argument's name would be shadowed by it,
+    // leaving a descriptor no invocation can satisfy: `select` is an array and
+    // the interpolation needs a scalar. Refused at parse, so the deploy says so
+    // rather than the script becoming unrunnable after it.
+    #[test]
+    fn a_placeholder_may_not_take_a_run_argument_name() {
+        for name in RESERVED_ARG_NAMES {
+            let d =
+                format!("profile:\n  warehouse: main\nvars:\n  v: \"{{{{ {name} }}}}\"\n");
+            let err = parse_dbt_descriptor(&d).unwrap_err().to_string();
+            assert!(err.contains(name), "{name}: {err}");
+        }
+        // A name of its own is fine.
+        assert!(parse_dbt_descriptor(
+            "profile:\n  warehouse: main\nvars:\n  v: \"{{ day }}\"\n"
+        )
+        .is_ok());
+    }
+
+    // The run form is built from this schema, and nothing else can build it:
+    // the browser and the CLI both infer through a wasm parser that has no dbt
+    // arm, so a missing property here is an override the user cannot reach.
+    // The variants are what make the form show a command's own fields and only
+    // those, so each is asserted by the arguments it carries.
+    #[test]
+    fn the_schema_carries_every_run_override_and_placeholder() {
+        let schema = dbt_arg_schema(DESCRIPTOR).unwrap();
+        let props = schema["properties"].as_object().unwrap();
+        let variants = props[DBT_COMMAND_ARG]["oneOf"].as_array().unwrap();
+        let of = |label: &str| {
+            let v = variants
+                .iter()
+                .find(|v| v["title"] == label)
+                .unwrap_or_else(|| panic!("no `{label}` variant: {schema}"));
+            let mut names: Vec<String> = v["properties"]
+                .as_object()
+                .unwrap()
+                .keys()
+                .filter(|k| k.as_str() != DBT_COMMAND_LABEL)
+                .cloned()
+                .collect();
+            names.sort();
+            (v.clone(), names)
+        };
+
+        let (build, build_args) = of("build");
+        assert_eq!(build_args, ["exclude", "full_refresh", "select", "vars"]);
+        assert_eq!(build["properties"]["full_refresh"]["type"], "boolean");
+        // Defaults come from the descriptor, so an untouched run reproduces it.
+        assert_eq!(
+            build["properties"]["select"]["default"],
+            serde_json::json!(["tag:nightly+"])
+        );
+        // The discriminator takes one value per variant: the toggle sets it, and
+        // a block cannot claim one command while carrying another's fields.
+        assert_eq!(
+            build["properties"][DBT_COMMAND_LABEL]["enum"],
+            serde_json::json!(["build"])
+        );
+
+        let (retry, retry_args) = of("retry");
+        assert_eq!(retry_args, ["dbt_retry_job"]);
+        // Required where it means something, rather than required everywhere and
+        // hidden: a retry names the run it resumes.
+        assert_eq!(retry["required"], serde_json::json!(["dbt_retry_job"]));
+
+        // `show` is NOT a form variant: previewing one model's rows is something
+        // you do to a table you are looking at, and the graph and the assets list
+        // are where that lives. The worker still accepts it programmatically.
+        assert!(
+            !variants.iter().any(|v| v["title"] == "show"),
+            "show must not be offered in the run form: {schema}"
+        );
+        assert!(DBT_COMMANDS.contains(&"show"), "but the worker still takes it");
+
+        // Every `{{ placeholder }}` the descriptor interpolates is an argument a
+        // run must supply. The command block is not one: it defaults to the
+        // descriptor's own selection under the descriptor's command.
+        assert_eq!(schema["required"], serde_json::json!(["day"]));
+        assert_eq!(schema["order"], serde_json::json!([DBT_COMMAND_ARG, "day"]));
+    }
+
+    #[test]
+    fn parses_descriptor() {
+        let d = parse_dbt_descriptor(DESCRIPTOR).unwrap();
+        assert_eq!(d.engine(), DbtEngine::DbtCore2x);
+        assert_eq!(d.profile.target.as_deref(), Some("prod"));
+        assert_eq!(d.select, vec!["tag:nightly+"]);
+        assert_eq!(d.threads, Some(8));
+        assert!(d.full_refresh);
+        // dbt vars keep their YAML type: a `false` coerced to "false" is truthy
+        // in Jinja and would silently invert the condition it gates.
+        assert_eq!(d.vars["strict"], serde_json::json!(false));
+        assert_eq!(d.vars["run_date"], serde_json::json!("{{ day }}"));
+    }
+
+    #[test]
+    fn an_empty_descriptor_defaults_to_the_bundled_engine() {
+        let d = parse_dbt_descriptor("").unwrap();
+        assert_eq!(d.engine(), DbtEngine::DbtCore1x);
+    }
+
+    // The ORDER is asserted, not just the set: the schema's `order` is built from
+    // this vec and the run form follows it, so the command block leading is what
+    // puts the choice of what the run does above the project's own inputs.
+    #[test]
+    fn signature_exposes_the_command_block_and_placeholders() {
+        let sig = parse_dbt_sig(DESCRIPTOR).unwrap();
+        let names: Vec<&str> = sig.args.iter().map(|a| a.name.as_str()).collect();
+        assert_eq!(names, vec![DBT_COMMAND_ARG, "day"]);
+        // An untouched run reproduces the descriptor: its default is the whole
+        // block — the descriptor's command, carrying the descriptor's selection.
+        let cmd = sig.args.iter().find(|a| a.name == DBT_COMMAND_ARG).unwrap();
+        let default = cmd.default.clone().unwrap();
+        // `build`, not `run`: `run` covers models only, so a selection naming a
+        // seed or a snapshot would silently not build it.
+        assert_eq!(default[DBT_COMMAND_LABEL], serde_json::json!("build"));
+        assert_eq!(default["select"], serde_json::json!(["tag:nightly+"]));
+        assert_eq!(default["full_refresh"], serde_json::json!(true));
+        // `vars` is the exception: it overrides, so its default must be empty.
+        // Seeded with the descriptor, the run form would post `{{ day }}` back
+        // and overwrite the value the worker interpolated for it.
+        assert_eq!(default["vars"], serde_json::json!({}));
+        // Placeholders are required (the descriptor names no value for them)
+        // and untyped, so a `{{ }}` var can carry a boolean or a number rather
+        // than the string "false", which Jinja treats as truthy.
+        let day = sig.args.iter().find(|a| a.name == "day").unwrap();
+        assert!(!day.has_default);
+        assert_eq!(day.typ, Typ::Unknown);
+    }
+}
+
diff --git a/backend/parsers/windmill-parser-yaml/src/lib.rs b/backend/parsers/windmill-parser-yaml/src/lib.rs
index f2a1a2b824..e025849769 100644
--- a/backend/parsers/windmill-parser-yaml/src/lib.rs
+++ b/backend/parsers/windmill-parser-yaml/src/lib.rs
@@ -9,6 +9,13 @@ use yaml_rust::{Yaml, YamlEmitter, YamlLoader};
 pub mod asset_parser;
 pub use asset_parser::parse_assets;
 
+pub mod dbt;
+pub use dbt::{
+    dbt_arg_schema, default_command as default_dbt_command, parse_dbt_descriptor, parse_dbt_sig,
+    DbtDescriptor, DbtEngine, DbtTestBehavior, DBT_COMMANDS, DBT_COMMAND_ARG, DBT_COMMAND_LABEL,
+    DBT_DEFAULT_WAREHOUSE,
+};
+
 pub fn parse_ansible_sig(inner_content: &str) -> anyhow::Result<MainArgSignature> {
     let docs = YamlLoader::load_from_str(inner_content)
         .map_err(|e| anyhow!("Failed to parse yaml: {}", e))?;
diff --git a/backend/parsers/windmill-parser/src/asset_parser.rs b/backend/parsers/windmill-parser/src/asset_parser.rs
index de35ccdd6e..843a83a310 100644
--- a/backend/parsers/windmill-parser/src/asset_parser.rs
+++ b/backend/parsers/windmill-parser/src/asset_parser.rs
@@ -1,4 +1,5 @@
 use serde::Serialize;
+use std::borrow::Cow;
 use std::collections::BTreeMap;
 
 // Token recognized inside declared asset URIs that the runtime substitutes
@@ -28,6 +29,11 @@ pub enum AssetKind {
     Ducklake,
     DataTable,
     Volume,
+    /// A warehouse relation a dbt project builds or reads,
+    /// `dbt://<warehouse>/<schema>/<name>`, the warehouse named as the
+    /// workspace configures it. The scheme names the producer, the path stays
+    /// the relation — see `windmill_types::AssetKind::Dbt`.
+    Dbt,
 }
 
 #[derive(Serialize, Debug, PartialEq, Clone)]
@@ -714,21 +720,32 @@ pub fn asset_was_used(assets: &Vec<ParseAssetsResult>, (kind, path): (AssetKind,
     })
 }
 
-pub fn parse_asset_syntax(s: &str, enable_default_syntax: bool) -> Option<(AssetKind, &str)> {
+/// Split an asset URI into `(kind, path)`. The single point where user-written
+/// asset URIs become graph keys, and therefore where `dbt://` paths get
+/// canonicalized (see `canonicalize_table_asset_path`) — every other kind's
+/// suffix is kept verbatim and stays borrowed.
+pub fn parse_asset_syntax(
+    s: &str,
+    enable_default_syntax: bool,
+) -> Option<(AssetKind, Cow<'_, str>)> {
     if enable_default_syntax && s == "datatable" {
-        return Some((AssetKind::DataTable, "main"));
+        return Some((AssetKind::DataTable, Cow::Borrowed("main")));
     } else if enable_default_syntax && s == "ducklake" {
-        return Some((AssetKind::Ducklake, "main"));
+        return Some((AssetKind::Ducklake, Cow::Borrowed("main")));
     }
     for (prefix, kind) in ASSET_KINDS.iter() {
         if s.starts_with(prefix) {
+            let suffix = &s[prefix.len()..];
+            if *kind == AssetKind::Dbt {
+                return Some((*kind, Cow::Owned(canonicalize_table_asset_path(suffix))));
+            }
             // The suffix is kept verbatim. For S3 the path encodes the storage:
             // `s3://<storage>/<key>`, with an EMPTY storage segment for the
             // workspace default — so `s3:///key` yields `/key` (leading slash
             // significant, default storage) while `s3://secondary/key` yields
             // `secondary/key`. Stripping leading slashes here would conflate a
             // default-storage object with a named-storage one.
-            return Some((*kind, &s[prefix.len()..]));
+            return Some((*kind, Cow::Borrowed(suffix)));
         }
     }
     None
@@ -741,8 +758,123 @@ pub const ASSET_KINDS: &[(&str, AssetKind)] = &[
     ("ducklake://", AssetKind::Ducklake),
     ("datatable://", AssetKind::DataTable),
     ("volume://", AssetKind::Volume),
+    ("dbt://", AssetKind::Dbt),
 ];
 
+/// Canonical spelling of a `dbt://` path, `<warehouse>/<schema>/<name>`.
+///
+/// The whole point of keying warehouse relations on the relation rather than on
+/// the producing tool is that a dbt mart and a native script reading the same
+/// table land on one graph node. That only holds if both sides spell the key
+/// identically, and they will not by default: dbt's `manifest.json` gives
+/// `relation_name` pre-quoted (`"db"."Schema"."Tbl"`) while an annotation is
+/// written by hand, and the warehouses disagree on case (Snowflake folds
+/// unquoted identifiers up, Postgres folds them down, DuckDB compares them
+/// case-insensitively). Two spellings of one table produce two nodes, no edge,
+/// and nothing looks broken in isolation — so the rule is applied once, here,
+/// on every path that becomes a `dbt://` asset.
+///
+/// The rule: strip the quote characters the warehouses use (`"`, backtick,
+/// `[`/`]`) from the schema and name, then ASCII-lowercase them. This matches
+/// the case-insensitive identifier comparison the DuckDB paths already use
+/// (`schema_contracts::CapturedSchema::find`). The warehouse-name prefix is
+/// spelled as the workspace configures it, which is case-sensitive, and is left
+/// untouched.
+///
+/// Consequence to accept: a relation deliberately created under a quoted
+/// mixed-case identifier collides with its lowercase spelling. That is rarer
+/// than the case-fold mismatch it prevents, and it errs toward unifying nodes
+/// rather than splitting them.
+pub fn canonicalize_table_asset_path(path: &str) -> String {
+    let Some((resource, rest)) = path.rsplit_once('/').and_then(|(head, name)| {
+        head.rsplit_once('/')
+            .map(|(resource, schema)| (resource, (schema, name)))
+    }) else {
+        // Fewer than three segments: not a well-formed relation path. Leave it
+        // alone so the malformed value stays visible instead of being reshaped
+        // into something that looks valid.
+        return path.to_string();
+    };
+    let (schema, name) = rest;
+    format!(
+        "{}/{}/{}",
+        resource,
+        unquote_schema_segment(schema).to_ascii_lowercase(),
+        unquote_identifier(name).to_ascii_lowercase()
+    )
+}
+
+/// A doubled delimiter inside a quoted identifier is that delimiter, literally —
+/// the same rule the worker's `split_relation` applies to `relation_name`. Both
+/// have to decode it or one spelling of a table becomes two graph nodes: the dbt
+/// model under `sales"east`, its native consumer under `sales""east`.
+fn unquote_identifier(s: &str) -> String {
+    let s = s.trim();
+    for (open, close) in [('"', '"'), ('`', '`'), ('[', ']')] {
+        if s.len() >= 2 && s.starts_with(open) && s.ends_with(close) {
+            let inner = &s[1..s.len() - 1];
+            return inner.replace(&format!("{close}{close}"), &close.to_string());
+        }
+    }
+    s.to_string()
+}
+
+/// Unquote a schema segment, which carries a `<database>.<schema>` pair when a
+/// relation overrode its database. Each half is separately quotable, so
+/// stripping only the outer pair leaves `"Archive"."Sales"` as
+/// `Archive"."Sales` — a different key from the ingest's `archive.sales`, which
+/// silently splits the model and its native consumer into two nodes.
+///
+/// The halves go through `unquote_identifier`, which requires the quote at both
+/// ends, because this function sees both a warehouse SPELLING (from a `dbt://`
+/// annotation) and an already-DECODED identifier (from `table_asset_path`, whose
+/// callers ran `split_relation` or read the manifest) and cannot tell them apart.
+/// A lone `"` in a decoded name — `sa"les` — must survive: treated as opening a
+/// quote it would be dropped, filing the ingest's `sa"les` under `sales` while
+/// the annotation's `"sa""les"` decodes to `sa"les`, which is the split this
+/// canonicalization exists to prevent.
+fn unquote_schema_segment(s: &str) -> String {
+    let s = s.trim();
+    let mut parts: Vec<&str> = Vec::new();
+    let mut start = 0usize;
+    let mut quote: Option<char> = None;
+    let bytes: Vec<(usize, char)> = s.char_indices().collect();
+    let mut k = 0usize;
+    while k < bytes.len() {
+        let (i, c) = bytes[k];
+        match quote {
+            Some(q) => {
+                let close = if q == '[' { ']' } else { q };
+                if c == close {
+                    // Doubled: a literal delimiter, so the quote stays open.
+                    if bytes.get(k + 1).map(|(_, n)| *n) == Some(close) {
+                        k += 1;
+                    } else {
+                        quote = None;
+                    }
+                }
+            }
+            // Only a quote that OPENS the part can be a delimiter; one in the
+            // middle of a decoded identifier is part of the name.
+            None if (c == '"' || c == '`' || c == '[') && i == start => quote = Some(c),
+            // Only an UNQUOTED period separates the database from the schema;
+            // one inside an identifier is part of the name.
+            None if c == '.' => {
+                parts.push(&s[start..i]);
+                start = i + c.len_utf8();
+            }
+            None => {}
+        }
+        k += 1;
+    }
+    parts.push(&s[start..]);
+    parts
+        .into_iter()
+        .map(unquote_identifier)
+        .collect::<Vec<_>>()
+        .join(".")
+}
+
 // Tokenize a `key=value [key="quoted value"] ...` option string. Bare
 // values run until the next whitespace; quoted values consume until the
 // matching quote. Malformed pairs (missing `=` or empty key) are skipped
@@ -1555,11 +1687,11 @@ mod pipeline_annotation_tests {
         // objects and must never collapse to one identity.
         assert_eq!(
             parse_asset_syntax("s3:///exports/x", false),
-            Some((AssetKind::S3Object, "/exports/x"))
+            Some((AssetKind::S3Object, Cow::Borrowed("/exports/x")))
         );
         assert_eq!(
             parse_asset_syntax("s3://exports/x", false),
-            Some((AssetKind::S3Object, "exports/x"))
+            Some((AssetKind::S3Object, Cow::Borrowed("exports/x")))
         );
         assert_ne!(
             parse_asset_syntax("s3:///exports/x", false),
@@ -1569,28 +1701,181 @@ mod pipeline_annotation_tests {
         // The `// on` trigger annotation goes through the same function.
         assert_eq!(
             parse_asset_syntax("s3:///exports/x", true),
-            Some((AssetKind::S3Object, "/exports/x"))
+            Some((AssetKind::S3Object, Cow::Borrowed("/exports/x")))
         );
 
         assert_eq!(
             parse_asset_syntax("s3://secondary_storage/path/to/file.csv", false),
-            Some((AssetKind::S3Object, "secondary_storage/path/to/file.csv"))
+            Some((
+                AssetKind::S3Object,
+                Cow::Borrowed("secondary_storage/path/to/file.csv")
+            ))
         );
 
         // Hive-partition keys are preserved verbatim.
         assert_eq!(
             parse_asset_syntax("s3:///t/year=2024/month=01/f.parquet", false),
-            Some((AssetKind::S3Object, "/t/year=2024/month=01/f.parquet"))
+            Some((
+                AssetKind::S3Object,
+                Cow::Borrowed("/t/year=2024/month=01/f.parquet")
+            ))
         );
 
         // Non-S3 kinds also keep their suffix verbatim.
         assert_eq!(
             parse_asset_syntax("res://f/foo", false),
-            Some((AssetKind::Resource, "f/foo"))
+            Some((AssetKind::Resource, Cow::Borrowed("f/foo")))
         );
         assert_eq!(
             parse_asset_syntax("ducklake://analytics/orders", false),
-            Some((AssetKind::Ducklake, "analytics/orders"))
+            Some((AssetKind::Ducklake, Cow::Borrowed("analytics/orders")))
+        );
+    }
+
+    // A dbt mart and a native script reading the same warehouse table must land
+    // on ONE graph node. They only do if every spelling of the relation
+    // canonicalizes identically — dbt's manifest gives it pre-quoted, the
+    // annotation is hand-written, and the warehouses fold case in opposite
+    // directions. A regression here is invisible: both nodes still render, they
+    // just stop being the same node and the cross-boundary cascade never fires.
+    #[test]
+    fn table_paths_from_every_spelling_canonicalize_to_one_key() {
+        let canonical = Some((
+            AssetKind::Dbt,
+            Cow::Owned("main/analytics/orders".into()),
+        ));
+        for spelling in [
+            // Hand-written annotation.
+            "dbt://main/analytics/orders",
+            // dbt manifest `relation_name`, quoted (database segment already
+            // dropped by the ingest, which keys on the warehouse name instead).
+            "dbt://main/\"analytics\"/\"orders\"",
+            // Snowflake folds unquoted identifiers up, Postgres folds down.
+            "dbt://main/ANALYTICS/ORDERS",
+            "dbt://main/Analytics/Orders",
+            // BigQuery / Databricks backticks, SQL Server brackets.
+            "dbt://main/`analytics`/`orders`",
+            "dbt://main/[Analytics]/[Orders]",
+        ] {
+            assert_eq!(
+                parse_asset_syntax(spelling, false),
+                canonical,
+                "spelling {spelling} did not canonicalize"
+            );
+        }
+    }
+
+    // A relation that overrode its database carries `<database>.<schema>` in
+    // one segment, and each half can be quoted independently. Stripping only
+    // the outer pair leaves a key the manifest ingest never produces, so the
+    // model and a native script reading it become separate nodes.
+    #[test]
+    fn qualified_schema_segments_unquote_each_half() {
+        let canonical = Some((
+            AssetKind::Dbt,
+            Cow::Owned("main/archive.sales/orders".into()),
+        ));
+        for spelling in [
+            "dbt://main/archive.sales/orders",
+            "dbt://main/\"Archive\".\"Sales\"/\"Orders\"",
+            "dbt://main/`Archive`.`Sales`/`Orders`",
+            "dbt://main/[Archive].[Sales]/[Orders]",
+        ] {
+            assert_eq!(
+                parse_asset_syntax(spelling, false),
+                canonical,
+                "spelling {spelling} did not canonicalize"
+            );
+        }
+        // A period INSIDE one quoted identifier is part of the name, not a
+        // database qualifier.
+        assert_eq!(
+            parse_asset_syntax("dbt://main/\"sales.v2\"/orders", false),
+            Some((
+                AssetKind::Dbt,
+                Cow::Owned("main/sales.v2/orders".into())
+            ))
+        );
+    }
+
+    // Every dialect here escapes its own delimiter by doubling it, and the
+    // worker's `split_relation` decodes it — so a canonicalizer that did not
+    // would file the dbt model under `sales"east` and the native script reading
+    // it under `sales""east`, which is the split this key exists to prevent.
+    #[test]
+    fn a_doubled_delimiter_canonicalizes_like_the_relation_it_names() {
+        for (spelling, expected) in [
+            (
+                "dbt://main/\"sales\"\"east\"/\"orders\"",
+                "main/sales\"east/orders",
+            ),
+            (
+                "dbt://main/analytics/\"order\"\"s\"",
+                "main/analytics/order\"s",
+            ),
+            (
+                "dbt://main/`da``ta`/`orders`",
+                "main/da`ta/orders",
+            ),
+            (
+                "dbt://main/[my]]schema]/[orders]",
+                "main/my]schema/orders",
+            ),
+            // And in one half of a database-qualified segment.
+            (
+                "dbt://main/\"arch\"\"ive\".\"sales\"/orders",
+                "main/arch\"ive.sales/orders",
+            ),
+        ] {
+            assert_eq!(
+                parse_asset_syntax(spelling, false),
+                Some((AssetKind::Dbt, Cow::Owned(expected.into()))),
+                "spelling {spelling} did not canonicalize"
+            );
+        }
+        // The DECODED form has to land on the same key, in both halves: this
+        // function sees the warehouse's spelling from an annotation and an
+        // already-decoded identifier from the ingest, and cannot tell them
+        // apart. A lone delimiter treated as opening a quote would be dropped —
+        // `sa"les` filed as `sales` — and the two derivations would split.
+        for (decoded, spelled) in [
+            ("dbt://main/sa\"les/orders", "dbt://main/\"sa\"\"les\"/orders"),
+            ("dbt://main/analytics/order\"s", "dbt://main/analytics/\"order\"\"s\""),
+            (
+                "dbt://main/arch\"ive.sales/orders",
+                "dbt://main/\"arch\"\"ive\".\"sales\"/orders",
+            ),
+        ] {
+            assert_eq!(
+                parse_asset_syntax(decoded, false),
+                parse_asset_syntax(spelled, false),
+                "the decoded and quoted spellings of {decoded} disagree"
+            );
+        }
+    }
+
+    #[test]
+    fn table_canonicalization_leaves_the_warehouse_name_case_alone() {
+        // The warehouse-name prefix is spelled as the workspace configures it
+        // and is case-sensitive; only the two identifier segments are folded.
+        assert_eq!(
+            parse_asset_syntax("dbt://MyWarehouse/Sales/Orders", false),
+            Some((
+                AssetKind::Dbt,
+                Cow::Owned("MyWarehouse/sales/orders".into())
+            ))
+        );
+        // A database-qualified schema keeps its own case rules: the whole
+        // segment folds, dot included.
+        assert_eq!(
+            parse_asset_syntax("dbt://main/PROD.Sales/Orders", false),
+            Some((AssetKind::Dbt, Cow::Owned("main/prod.sales/orders".into())))
+        );
+        // Too few segments to be a relation: left alone rather than reshaped
+        // into something that looks well-formed.
+        assert_eq!(
+            parse_asset_syntax("dbt://Orders", false),
+            Some((AssetKind::Dbt, Cow::Owned("Orders".into())))
         );
     }
 
diff --git a/backend/parsers/windmill-parser/tests/pipeline_annotations_parity.rs b/backend/parsers/windmill-parser/tests/pipeline_annotations_parity.rs
index 1936f7ff70..9493a78606 100644
--- a/backend/parsers/windmill-parser/tests/pipeline_annotations_parity.rs
+++ b/backend/parsers/windmill-parser/tests/pipeline_annotations_parity.rs
@@ -110,6 +110,7 @@ fn kind_str(k: AssetKind) -> &'static str {
         AssetKind::Ducklake => "ducklake",
         AssetKind::DataTable => "datatable",
         AssetKind::Volume => "volume",
+        AssetKind::Dbt => "dbt",
     }
 }
 
diff --git a/backend/summarized_schema.txt b/backend/summarized_schema.txt
index b47a6556cd..96ce7811a2 100644
--- a/backend/summarized_schema.txt
+++ b/backend/summarized_schema.txt
@@ -3,7 +3,7 @@
 ## ENUMs
 action_kind: create, update, delete, execute
 asset_access_type: r, w, rw
-asset_kind: s3object, resource, variable, ducklake, datatable
+asset_kind: s3object, resource, variable, ducklake, datatable, table
 asset_usage_kind: script, flow, job
 authentication_method: none, windmill, api_key, basic_http, custom_script, signature
 autoscaling_event_type: full_scaleout, scalein, scaleout
@@ -19,6 +19,7 @@ job_status: success, failure, canceled, skipped
 job_trigger_kind: webhook, http, websocket, kafka, email, nats, schedule, app, ui, postgres, sqs, gcp, mqtt, nextcloud, ci_test
 log_mode: standalone, server, worker, agent, indexer, mcp
 login_type: password, github
+materialization_status: running, materialized, failed
 message_type: user, assistant, tool
 metric_kind: scalar_int, scalar_float, timeseries_int, timeseries_float
 mqtt_client_version: v3, v5
@@ -26,7 +27,7 @@ native_trigger_service: nextcloud
 request_type: sync, async, sync_sse
 runnable_type: ScriptHash, ScriptPath, FlowPath
 script_kind: script, trigger, failure, command, approval, preprocessor
-script_lang: python3, deno, go, bash, postgresql, nativets, bun, mysql, bigquery, snowflake, graphql, powershell, mssql, php, bunnative, rust, ansible, csharp, oracledb, nu, java, duckdb, ruby, rlang
+script_lang: python3, deno, go, bash, postgresql, nativets, bun, mysql, bigquery, snowflake, graphql, powershell, mssql, php, bunnative, rust, ansible, csharp, oracledb, nu, java, duckdb, ruby, rlang, dbt
 trigger_kind: webhook, http, websocket, kafka, email, nats, postgres, sqs, mqtt, gcp, default_email, nextcloud
 trigger_mode: enabled, disabled, suspended
 workspace_key_kind: cloud
@@ -65,6 +66,16 @@ ci_test_reference: workspace_id(char), test_script_path(char), test_script_hash(
 concurrency_settings: hash(bigint), concurrency_key(char), concurrent_limit(int), concurrency_time_window_s(int)
 config: name(char), config(jsonb)
 custom_concurrency_key_ended: key(char), ended_at(ts)
+dbt_edge: workspace_id(char), script_path(char), script_hash(bigint), job_id(uuid), parent_unique_id(text), child_unique_id(text), ingested_at(ts)
+  FK: (workspace_id) -> workspace(id), (workspace_id, script_hash) -> script(workspace_id, hash)
+dbt_graph_snapshot: workspace_id(char), script_path(char), script_hash(bigint), job_id(uuid), digest(text), relation_root_at_last_ingest(text), ingested_at(ts)
+  FK: (workspace_id) -> workspace(id), (workspace_id, script_hash) -> script(workspace_id, hash)
+dbt_node: workspace_id(char), script_path(char), script_hash(bigint), job_id(uuid), unique_id(text), resource_type(text), name(text), asset_path(text), materialized(text), materialize_strategy(text), unique_key(text), tags(text[]), description(text), test_kind(text), test_column(text), test_args(jsonb), severity(text), attached_node(text), columns(jsonb), freshness(jsonb), raw_code(text), original_file_path(text), ingested_at(ts)
+  FK: (workspace_id) -> workspace(id), (workspace_id, script_hash) -> script(workspace_id, hash)
+dbt_run_progress: workspace_id(char), job_id(uuid), asset_kind(asset_kind), asset_path(char), status(materialization_status), row_count(bigint), error(text), updated_at(ts)
+  FK: (workspace_id) -> workspace(id)
+dbt_run_state: workspace_id(char), script_path(char), permissioned_as(char), identity(text), args(jsonb), run_results(text), job_id(uuid), retryable(bool), updated_at(ts)
+  FK: (workspace_id) -> workspace(id)
 debounce_key: key(char), job_id(uuid), previous_job_id(uuid), first_started_at(ts), debounced_times(int)
 debounce_stale_data: job_id(uuid), to_relock(text[])
 debouncing_settings: hash(bigint), debounce_key(char), debounce_delay_s(int), max_total_debouncing_time(int), max_total_debounces_amount(int), debounce_args_to_accumulate(text[])
@@ -204,7 +215,7 @@ workspace_protection_rule: workspace_id(char), name(char), rules(int), bypass_gr
   FK: (workspace_id) -> workspace(id)
 workspace_runnable_dependencies: flow_path(char), runnable_path(char), script_hash(bigint), runnable_is_flow(bool), workspace_id(char), app_path(char)
   FK: (app_path, workspace_id) -> app(path, workspace_id) | (flow_path, workspace_id) -> flow(path, workspace_id)
-workspace_settings: workspace_id(char), slack_team_id(char), slack_name(char), slack_command_script(char), slack_email(char), customer_id(char), plan(char), webhook(text), ai_config(jsonb), large_file_storage(jsonb), git_sync(jsonb), default_app(char), default_scripts(jsonb), deploy_ui(jsonb), mute_critical_alerts(bool), color(char), operator_settings(jsonb), teams_command_script(text), teams_team_id(text), teams_team_name(text), git_app_installations(jsonb), ducklake(jsonb), slack_oauth_client_id(char), slack_oauth_client_secret(char), datatable(jsonb), teams_team_guid(text), auto_invite(jsonb), error_handler(jsonb), success_handler(jsonb), public_app_execution_limit_per_minute(int)
+workspace_settings: workspace_id(char), slack_team_id(char), slack_name(char), slack_command_script(char), slack_email(char), customer_id(char), plan(char), webhook(text), ai_config(jsonb), large_file_storage(jsonb), git_sync(jsonb), default_app(char), default_scripts(jsonb), deploy_ui(jsonb), mute_critical_alerts(bool), color(char), operator_settings(jsonb), teams_command_script(text), teams_team_id(text), teams_team_name(text), git_app_installations(jsonb), ducklake(jsonb), slack_oauth_client_id(char), slack_oauth_client_secret(char), datatable(jsonb), teams_team_guid(text), auto_invite(jsonb), error_handler(jsonb), success_handler(jsonb), public_app_execution_limit_per_minute(int), dbt_warehouses(jsonb)
   FK: (workspace_id) -> workspace(id)
 zombie_job_counter: job_id(uuid), counter(int)
   FK: (job_id) -> v2_job(id)
diff --git a/backend/windmill-api-assets/Cargo.toml b/backend/windmill-api-assets/Cargo.toml
index c75715a3ac..62bc3d9c8d 100644
--- a/backend/windmill-api-assets/Cargo.toml
+++ b/backend/windmill-api-assets/Cargo.toml
@@ -21,3 +21,7 @@ serde.workspace = true
 serde_json.workspace = true
 sqlx.workspace = true
 tracing.workspace = true
+uuid.workspace = true
+
+[dev-dependencies]
+tokio = { workspace = true }
diff --git a/backend/windmill-api-assets/src/lib.rs b/backend/windmill-api-assets/src/lib.rs
index 3a2bf83097..940b610113 100644
--- a/backend/windmill-api-assets/src/lib.rs
+++ b/backend/windmill-api-assets/src/lib.rs
@@ -605,9 +605,16 @@ async fn list_favorites(
 // frontend aggregates into nodes and edges.
 
 #[derive(Deserialize)]
-struct GraphQuery {
+pub struct GraphQuery {
     pub asset_kinds: Option<String>,
     pub folder: Option<String>,
+    /// Render a dbt project as a given deployed version rather than as it is
+    /// now. A run page passes the version its job ran, so an old run shows the
+    /// models, SQL and `ref()` lineage of that deploy instead of today's.
+    /// Absent — the usual case — means the newest live version per path.
+    /// Hex, like every other script-hash parameter — `ScriptHash` deserializes
+    /// it, so the run page can pass `job.script_hash` verbatim.
+    pub dbt_script_hash: Option<windmill_common::scripts::ScriptHash>,
 }
 
 #[derive(Serialize, Debug)]
@@ -629,6 +636,68 @@ struct GraphAssetNode {
     // `AssetGraphAssetNode.derived_from`.
     #[serde(skip_serializing_if = "Option::is_none")]
     derived_from: Option<String>,
+    // Set on a `dbt://` asset produced (or, for a source, consumed) by a dbt
+    // script: which dbt node it is and what dbt says about it. A dbt project is
+    // one runnable node with many model assets, so per-model metadata belongs
+    // here rather than on the script (docs/dbt-runtime.md, decision 15).
+    // Lockstep with TS `AssetGraphAssetNode.dbt`.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    dbt: Option<DbtAssetProvenance>,
+}
+
+#[derive(Serialize, Debug, Clone)]
+struct DbtAssetProvenance {
+    unique_id: String,
+    // `model` | `snapshot` | `seed` | `source` — a source is read, not written,
+    // and the canvas distinguishes them.
+    resource_type: String,
+    // dbt's own word (`table`, `view`, `incremental`, `snapshot`), kept because
+    // `view` and `ephemeral` have no Windmill write-strategy analogue.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    materialized: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    materialize_strategy: Option<String>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    tags: Vec<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    description: Option<String>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    data_tests: Vec<DbtDataTest>,
+    /// Declared column metadata (name -> description). NOT column lineage —
+    /// `manifest.json` carries none (docs/dbt-runtime.md, decision 14).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    columns: Option<serde_json::Value>,
+    /// A source's declared freshness policy, for the staleness chip.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    freshness: Option<serde_json::Value>,
+    /// The model's SQL as written. Read-only in Windmill — the file lives in
+    /// the repo at the pinned commit, and this is a copy taken at deploy.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    raw_code: Option<String>,
+    /// Its path inside the repo, e.g. `models/staging/stg_orders.sql`.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    original_file_path: Option<String>,
+}
+
+#[derive(Serialize, Debug, Clone, PartialEq)]
+struct DbtDataTest {
+    // `unique` | `not_null` | `accepted_values` | `relationships` — the four
+    // generic tests, one-for-one with the `// data_test` kinds — or a package
+    // test's namespaced name (`dbt_utils.accepted_range`).
+    kind: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    column: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    args: Option<serde_json::Value>,
+    // Lowercased. dbt's own severity decides whether a failure fails the run,
+    // so the canvas shows it rather than assuming every test is blocking.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    severity: Option<String>,
+}
+
+#[derive(Serialize, Debug, Clone)]
+struct DbtRunnableProvenance {
+    model_count: usize,
 }
 
 #[derive(Serialize, Debug)]
@@ -691,6 +760,11 @@ struct GraphRunnableNode {
     // signature list. Lockstep with TS `AssetGraphRunnableNode.macros`.
     #[serde(skip_serializing_if = "Vec::is_empty", default)]
     macros: Vec<MacroInfo>,
+    // Set on a `ScriptLang::Dbt` script: it owns a whole dbt project, so the
+    // node says how many models it materializes rather than pretending to be a
+    // single-output script. Lockstep with TS `AssetGraphRunnableNode.dbt`.
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    dbt: Option<DbtRunnableProvenance>,
 }
 
 // One macro of a `// macros` library, as surfaced on its graph node.
@@ -831,7 +905,7 @@ struct TestEdge {
 }
 
 #[derive(Serialize, Debug)]
-struct AssetGraphResponse {
+pub struct AssetGraphResponse {
     assets: Vec<GraphAssetNode>,
     runnables: Vec<GraphRunnableNode>,
     edges: Vec<GraphEdge>,
@@ -840,6 +914,27 @@ struct AssetGraphResponse {
     macro_edges: Vec<MacroEdge>,
     #[serde(skip_serializing_if = "Vec::is_empty", default)]
     test_edges: Vec<TestEdge>,
+    /// `ref()` lineage BETWEEN two dbt models. Without it every model hangs off
+    /// the one dbt runnable, which reads as a flat source-to-model fan-out
+    /// instead of the project's actual shape.
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    dbt_edges: Vec<DbtLineageEdge>,
+    /// The job whose snapshot the dbt half was resolved from, when one was
+    /// asked for and found. A run page polls the graph while its job runs
+    /// because a dynamic descriptor's snapshot is written mid-run, and this is
+    /// what tells it to stop: without it the page cannot distinguish "the
+    /// snapshot has not been written yet" from "this run has none", and either
+    /// polls forever or gives up before the ingest.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    dbt_snapshot_job: Option<uuid::Uuid>,
+}
+
+/// One `ref()`/`source()` edge, in the terms the canvas draws: the two
+/// relations, not dbt's node ids.
+#[derive(Serialize, Debug, PartialEq, Eq, PartialOrd, Ord)]
+struct DbtLineageEdge {
+    from_asset_path: String,
+    to_asset_path: String,
 }
 
 async fn asset_graph(
@@ -849,15 +944,75 @@ async fn asset_graph(
     Extension(db): Extension<windmill_common::DB>,
     Query(q): Query<GraphQuery>,
 ) -> JsonResult<AssetGraphResponse> {
-    let mut tx = user_db.begin(&authed).await?;
+    // `None`: pinning the graph to one run is job-scoped and this endpoint is
+    // authorized as `assets:read`. See `asset_graph_for`.
+    asset_graph_for(&authed, &w_id, user_db, db, q, None).await
+}
 
-    let kind_filter: Option<Vec<AssetKind>> = q.asset_kinds.as_ref().map(|s| {
-        s.split(',')
-            .filter_map(|k| {
-                serde_json::from_value::<AssetKind>(Value::String(k.trim().into())).ok()
-            })
-            .collect()
-    });
+/// A run the caller is already authorized to read, and the deployed version it
+/// ran. Path and hash come from the job row rather than the query, so a graph
+/// cannot be pointed at one project's version while claiming another's run.
+pub struct PinnedRun {
+    pub job_id: uuid::Uuid,
+    pub script_path: String,
+    pub script_hash: i64,
+}
+
+/// The asset graph, optionally as one run saw it.
+///
+/// AUTHORIZES NOTHING BY ITSELF. Every caller owes it two checks, because the
+/// answer is workspace asset data reached through a route whose own URL segment
+/// decides the scope domain: `assets:read` always, and `require_job_read_access`
+/// for the job when passing `Some(pinned)` — which is then taken as already
+/// done, since the pinned path and hash come from that job's row.
+pub async fn asset_graph_for(
+    authed: &ApiAuthed,
+    w_id: &str,
+    user_db: UserDB,
+    db: windmill_common::DB,
+    q: GraphQuery,
+    pinned: Option<PinnedRun>,
+) -> JsonResult<AssetGraphResponse> {
+    let dbt_job_id = pinned.as_ref().map(|p| p.job_id);
+    // The version is the job's own, not the caller's `dbt_script_hash`.
+    let dbt_script_hash = pinned
+        .as_ref()
+        .map(|p| p.script_hash)
+        .or(q.dbt_script_hash.map(|h| h.0));
+    // Set only for a pinned run, where it lets `live` resolve without reading
+    // `script`: a share-link viewer is entitled to the run but usually has no
+    // grant on the script, and RLS there would empty the graph. `raw_code` has
+    // its own `script` check, so the body stays hidden either way.
+    let pinned_path = pinned.as_ref().map(|p| p.script_path.as_str());
+    let w_id = w_id.to_string();
+    let mut tx = user_db.begin(authed).await?;
+    // Built once: a scoped token's `scripts:read` paths decide whether a dbt
+    // node's SQL body may be returned, independently of the `assets:read` scope
+    // that authorizes this endpoint.
+    let dbt_source_scope = build_scope_path_predicate(authed, "scripts", "read");
+
+    // REFUSED, not dropped: a caller that asks for a kind this server does not
+    // know has asked for something, and answering with the other kinds returns a
+    // graph missing exactly what they came for — silently. That is how a rename
+    // of one kind emptied three callers' graphs with nothing logged.
+    let kind_filter: Option<Vec<AssetKind>> = q
+        .asset_kinds
+        .as_ref()
+        .map(|s| {
+            s.split(',')
+                .map(|k| {
+                    serde_json::from_value::<AssetKind>(Value::String(k.trim().into())).map_err(
+                        |_| {
+                            windmill_common::error::Error::BadRequest(format!(
+                                "`{}` is not an asset kind",
+                                k.trim()
+                            ))
+                        },
+                    )
+                })
+                .collect::<Result<Vec<_>, _>>()
+        })
+        .transpose()?;
     let kind_filter_ref = kind_filter.as_deref();
 
     let folder_filter = q.folder.as_deref().map(|f| format!("f/{}/%", f));
@@ -1066,6 +1221,218 @@ async fn asset_graph(
     .fetch_all(&mut *tx)
     .await?;
 
+    // dbt provenance. A dbt script is one runnable node whose models are many
+    // `dbt://` asset nodes (decision 15), so the per-model metadata has to
+    // hang off the assets, not off the script. It describes the RELATION, not a
+    // producer: several dbt scripts (different selections of one project) can
+    // materialize the same model, and the producer edges already name them.
+    //
+    // Scoped to the relations this graph actually renders, so a workspace with
+    // many dbt projects does not pay for all of them on every request. Not
+    // scoped by the script's folder: an out-of-folder dbt script still has to
+    // explain a model an in-scope consumer reads, same as macro definitions.
+    // Tests come along via `attached_node` — they carry no `asset_path` of
+    // their own.
+    let dbt_rows = sqlx::query!(
+        r#"WITH live AS (
+             -- The graph is stored per deployed VERSION, so this endpoint — which
+             -- describes the project as it is now — takes the newest live one per
+             -- path. Resolved once here rather than per row: a correlated lookup
+             -- on every node is what makes these queries fall over.
+             SELECT * FROM (
+               SELECT DISTINCT ON (s.path) s.path, s.hash
+                 FROM script s
+                WHERE $5::text IS NULL AND s.workspace_id = $1 AND s.language = 'dbt'
+                  AND ($3::bigint IS NULL OR s.hash = $3)
+                  -- A pinned version may be archived by now; that is precisely
+                  -- the case a historical run needs, so the liveness filter
+                  -- applies only when picking the current one.
+                  AND ($3::bigint IS NOT NULL OR (s.deleted = false AND s.archived = false))
+                ORDER BY s.path, s.created_at DESC
+             ) cur
+             UNION ALL
+             -- A pinned run names its own version, so `script` is not consulted:
+             -- under RLS it would answer for the CALLER's grants on the project,
+             -- emptying the graph for a share-link viewer who is entitled to the
+             -- run but not the script.
+             SELECT $5::text, $3::bigint WHERE $5::text IS NOT NULL
+           ),
+           -- The run's own snapshot when it left one, the version's graph
+           -- otherwise. A static descriptor never snapshots, so all of its runs
+           -- fall through to the same rows. Existence comes from the marker, not
+           -- from a node row: a dynamic run that disabled every model has a
+           -- snapshot whose graph is legitimately empty.
+           chosen AS (
+             -- No visibility check on the job here: reaching this with a job at
+             -- all means the caller passed `require_job_read_access` for it, and
+             -- re-deciding it under plain RLS can only DISAGREE with that answer
+             -- — silently, by falling back to the deployed graph rather than
+             -- erroring. A share-link viewer is entitled to the run and would be
+             -- shown a different run's model set. See `asset_graph_for`.
+             SELECT CASE WHEN $4::uuid IS NOT NULL AND EXISTS (
+                      SELECT 1 FROM dbt_graph_snapshot g
+                       WHERE g.workspace_id = $1 AND g.job_id = $4)
+                    THEN $4::uuid
+                    ELSE '00000000-0000-0000-0000-000000000000'::uuid END AS job_id
+           ),
+           scoped AS (
+             SELECT n.script_path, n.unique_id FROM dbt_node n
+              JOIN live l ON l.path = n.script_path AND l.hash = n.script_hash
+              JOIN chosen ch ON ch.job_id = n.job_id
+              WHERE n.workspace_id = $1 AND n.asset_path IS NOT NULL
+                -- Unpinned, the scope is the relations in view: `asset` says
+                -- which of them this folder touches. Pinned, that table is the
+                -- WRONG scope — it holds one row set per path, describing the
+                -- current deploy, so a model this version had and the current one
+                -- dropped would be filtered out of its own run's graph. The
+                -- pinned version's nodes are the scope.
+                AND ($3::bigint IS NOT NULL OR n.asset_path IN (
+                  SELECT path FROM asset
+                   WHERE workspace_id = $1 AND kind = 'dbt'
+                     AND ($2::text IS NULL OR usage_path LIKE $2)))
+           )
+           SELECT n.script_path AS "script_path!", n.unique_id AS "unique_id!",
+                  n.resource_type AS "resource_type!", n.name AS "name!", n.asset_path,
+                  n.materialized, n.materialize_strategy, n.tags AS "tags!", n.description,
+                  n.test_kind, n.test_column, n.test_args, n.severity, n.attached_node,
+                  n.columns, n.freshness,
+                  n.raw_code, n.original_file_path,
+                  -- Whether the caller may read the project this row describes.
+                  -- The query deliberately reaches outside the requested folder
+                  -- so an in-scope consumer can explain the relation it reads,
+                  -- and `dbt_node` carries no RLS of its own; the relation's
+                  -- SHAPE is fine to answer that way, everything the project's
+                  -- author WROTE is not. Applied in Rust, over one predicate, so
+                  -- the fields it covers are named in one place. This runs in the
+                  -- authed transaction, so `script`'s RLS answers it. Matched on
+                  -- the HASH as well: `extra_perms` is per row, so a path
+                  -- recreated with narrower ones leaves the archived version
+                  -- readable, and a path-only probe would answer for THAT grant
+                  -- while returning this version's source.
+                  EXISTS (
+                      SELECT 1 FROM script sc
+                       WHERE sc.workspace_id = n.workspace_id AND sc.path = n.script_path
+                         AND sc.hash = n.script_hash
+                  ) AS "script_visible!"
+             FROM dbt_node n
+             JOIN live l ON l.path = n.script_path AND l.hash = n.script_hash
+             -- Every join onto `dbt_node` needs this, not just the scoping CTE:
+             -- `job_id` is part of the key, so without it each model comes back
+             -- once per retained snapshot plus once for the version's graph.
+             JOIN chosen ch ON ch.job_id = n.job_id
+            WHERE n.workspace_id = $1
+              -- Joined on BOTH columns: a dbt `unique_id` is project-local, so
+              -- two projects with the same model name would otherwise pull each
+              -- other's rows.
+              AND (EXISTS (SELECT 1 FROM scoped s
+                            WHERE s.script_path = n.script_path
+                              AND s.unique_id = n.unique_id)
+                   OR EXISTS (SELECT 1 FROM scoped s
+                               WHERE s.script_path = n.script_path
+                                 AND s.unique_id = n.attached_node))
+            ORDER BY n.script_path, n.unique_id"#,
+        &w_id,
+        folder_filter.as_deref(),
+        dbt_script_hash,
+        dbt_job_id,
+        pinned_path,
+    )
+    .fetch_all(&mut *tx)
+    .await?;
+
+    // `ref()` lineage between two models, resolved to the relations they
+    // produce. Joined to `dbt_node` on both key columns because a dbt
+    // `unique_id` is only unique within its project.
+    let dbt_edge_rows = sqlx::query!(
+        r#"WITH live AS (
+             SELECT * FROM (
+               SELECT DISTINCT ON (s.path) s.path, s.hash
+                 FROM script s
+                WHERE $5::text IS NULL AND s.workspace_id = $1 AND s.language = 'dbt'
+                  AND ($3::bigint IS NULL OR s.hash = $3)
+                  AND ($3::bigint IS NOT NULL OR (s.deleted = false AND s.archived = false))
+                ORDER BY s.path, s.created_at DESC
+             ) cur
+             UNION ALL
+             SELECT $5::text, $3::bigint WHERE $5::text IS NOT NULL
+           ),
+           -- The run's own snapshot when it left one, the version's graph
+           -- otherwise. A static descriptor never snapshots, so all of its runs
+           -- fall through to the same rows. Existence comes from the marker, not
+           -- from a node row: a dynamic run that disabled every model has a
+           -- snapshot whose graph is legitimately empty.
+           chosen AS (
+             -- No visibility check on the job here: reaching this with a job at
+             -- all means the caller passed `require_job_read_access` for it, and
+             -- re-deciding it under plain RLS can only DISAGREE with that answer
+             -- — silently, by falling back to the deployed graph rather than
+             -- erroring. A share-link viewer is entitled to the run and would be
+             -- shown a different run's model set. See `asset_graph_for`.
+             SELECT CASE WHEN $4::uuid IS NOT NULL AND EXISTS (
+                      SELECT 1 FROM dbt_graph_snapshot g
+                       WHERE g.workspace_id = $1 AND g.job_id = $4)
+                    THEN $4::uuid
+                    ELSE '00000000-0000-0000-0000-000000000000'::uuid END AS job_id
+           )
+           SELECT p.asset_path AS "from_path!", c.asset_path AS "to_path!"
+             FROM dbt_edge e
+             JOIN live l ON l.path = e.script_path AND l.hash = e.script_hash
+             JOIN chosen ch ON ch.job_id = e.job_id
+             JOIN dbt_node p ON p.workspace_id = e.workspace_id
+                            AND p.script_path = e.script_path
+                            AND p.script_hash = e.script_hash
+                            AND p.job_id = ch.job_id
+                            AND p.unique_id = e.parent_unique_id
+             JOIN dbt_node c ON c.workspace_id = e.workspace_id
+                            AND c.script_path = e.script_path
+                            AND c.script_hash = e.script_hash
+                            AND c.job_id = ch.job_id
+                            AND c.unique_id = e.child_unique_id
+            WHERE e.workspace_id = $1
+              AND p.asset_path IS NOT NULL AND c.asset_path IS NOT NULL
+              -- Tests attach to their model as a badge, not as a lineage edge.
+              AND c.resource_type <> 'test'
+              -- Scoped by the RELATIONS, like the node provenance above, not by
+              -- the producing script's folder: two tables consumed in this
+              -- folder but produced by a dbt project outside it would otherwise
+              -- both render with their `ref()` edge missing.
+              -- Same as the node scope: pinned, `asset` describes the CURRENT
+              -- deploy, so gating on it drops the edges of models this version
+              -- had and a later one removed. The pinned version's own edges are
+              -- the answer.
+              AND ($3::bigint IS NOT NULL OR EXISTS (
+                SELECT 1 FROM asset a
+                 WHERE a.workspace_id = $1 AND a.kind = 'dbt'
+                   AND a.path = c.asset_path
+                   AND ($2::text IS NULL OR a.usage_path LIKE $2)))"#,
+        &w_id,
+        folder_filter.as_deref(),
+        dbt_script_hash,
+        dbt_job_id,
+        pinned_path,
+    )
+    .fetch_all(&mut *tx)
+    .await?;
+
+    // The same predicate `chosen` applies, answered once for the caller: it is
+    // what lets a run page stop polling. No `v2_job` recheck, for the reason
+    // `chosen` gives — disagreeing with the route's decision here would leave a
+    // share-link viewer with the right graph and a null marker, polling it 40
+    // times over.
+    let dbt_snapshot_job = match dbt_job_id {
+        Some(job) => {
+            sqlx::query_scalar!(
+                "SELECT g.job_id FROM dbt_graph_snapshot g
+              WHERE g.workspace_id = $1 AND g.job_id = $2
+              LIMIT 1",
+                &w_id,
+                job,
+            )
+            .fetch_optional(&mut *tx)
+            .await?
+        }
+        None => None,
+    };
     tx.commit().await?;
 
     // Parse each pipeline member's body once into its badge annotations, keyed
@@ -1110,6 +1477,138 @@ async fn asset_graph(
             (r.path.clone(), lineage)
         })
         .collect();
+    // Model → its provenance, and script → how many models it owns. Tests are
+    // folded onto the model they are attached to, which is what makes dbt's
+    // four generic tests render through the existing data-test node.
+    let mut dbt_by_asset_path: std::collections::HashMap<String, DbtAssetProvenance> =
+        Default::default();
+    let mut dbt_model_count: std::collections::HashMap<String, usize> = Default::default();
+    // Which relations each dbt script actually BUILDS. The sidecar also holds a
+    // row for a parent kept only to anchor a cross-selection edge, which the
+    // script reads rather than materializes — counting those would make a script
+    // selecting one mart claim the staging models upstream of it, and the badge
+    // says "materializes N models".
+    let dbt_writes: std::collections::HashSet<(&str, &str)> = rows
+        .iter()
+        .filter(|r| {
+            r.asset_kind == AssetKind::Dbt
+                && matches!(r.access_type.as_deref(), Some("w") | Some("rw"))
+        })
+        .map(|r| (r.usage_path.as_str(), r.asset_path.as_str()))
+        .collect();
+    // Keyed by (script_path, unique_id) — the sidecar's own primary key — since
+    // a dbt `unique_id` is only unique within its project.
+    let dbt_asset_path_by_unique_id: std::collections::HashMap<(&str, &str), &str> = dbt_rows
+        .iter()
+        .filter_map(|r| {
+            Some((
+                (r.script_path.as_str(), r.unique_id.as_str()),
+                r.asset_path.as_deref()?,
+            ))
+        })
+        .collect();
+    for r in &dbt_rows {
+        let Some(asset_path) = r.asset_path.as_deref() else {
+            continue;
+        };
+        if r.resource_type != "source" && dbt_writes.contains(&(r.script_path.as_str(), asset_path))
+        {
+            *dbt_model_count.entry(r.script_path.clone()).or_default() += 1;
+        }
+        // What the project's author WROTE — the model's SQL, its path in the
+        // repo, the prose and labels around it — as opposed to the shape of the
+        // relation it produces. RLS says whether the caller may see the script,
+        // but not whether a scoped token may: this endpoint is authorized as
+        // `assets:read`, so a token deliberately narrowed to it would otherwise
+        // read a project outside its `scripts:read` paths. Both answers gate the
+        // same set of fields, because a share-link viewer entitled to the RUN is
+        // not thereby entitled to the documentation of a project they cannot
+        // open.
+        let source_allowed = r.script_visible && dbt_source_scope(&r.script_path);
+        let candidate = DbtAssetProvenance {
+            raw_code: r.raw_code.clone().filter(|_| source_allowed),
+            original_file_path: r.original_file_path.clone().filter(|_| source_allowed),
+            unique_id: r.unique_id.clone(),
+            resource_type: r.resource_type.clone(),
+            materialized: r.materialized.clone(),
+            materialize_strategy: r.materialize_strategy.clone(),
+            tags: if source_allowed {
+                r.tags.clone()
+            } else {
+                vec![]
+            },
+            description: r.description.clone().filter(|_| source_allowed),
+            data_tests: vec![],
+            columns: r.columns.clone().filter(|_| source_allowed),
+            freshness: r.freshness.clone().filter(|_| source_allowed),
+        };
+        // One relation can carry rows from several projects — typically a model
+        // in one and a source declaring it in another. The producer describes
+        // the relation and the source only names it, so which one wins must not
+        // depend on script-path ordering. The source's freshness policy is
+        // still worth keeping, so it fills in rather than overwrites.
+        let existing = dbt_by_asset_path
+            .entry(asset_path.to_string())
+            .or_insert_with(|| candidate.clone());
+        if existing.unique_id == candidate.unique_id {
+            continue;
+        }
+        let wins = match (
+            existing.resource_type.as_str(),
+            candidate.resource_type.as_str(),
+        ) {
+            ("source", t) if t != "source" => true,
+            (t, "source") if t != "source" => false,
+            // Two rows of the same nature: pick by id so the graph does not
+            // change shape between requests.
+            _ => candidate.unique_id < existing.unique_id,
+        };
+        let freshness = existing
+            .freshness
+            .clone()
+            .or_else(|| candidate.freshness.clone());
+        if wins {
+            *existing = candidate;
+        }
+        existing.freshness = freshness;
+    }
+    // Tests fold onto the model they assert, which is what makes dbt's four
+    // generic tests render through the existing data-test node. A separate pass
+    // because rows arrive in `unique_id` order, so a test can precede its model.
+    for r in &dbt_rows {
+        if r.resource_type != "test" {
+            continue;
+        }
+        let Some(target) = r
+            .attached_node
+            .as_deref()
+            .and_then(|n| dbt_asset_path_by_unique_id.get(&(r.script_path.as_str(), n)))
+        else {
+            continue;
+        };
+        let Some(entry) = dbt_by_asset_path.get_mut(*target) else {
+            continue;
+        };
+        let test = DbtDataTest {
+            kind: r.test_kind.clone().unwrap_or_else(|| r.name.clone()),
+            column: r.test_column.clone(),
+            // The test's kind and column are the badge's shape, already spelled
+            // out by its `unique_id`. Its arguments are authored data — an
+            // `accepted_values` list is a column's domain — so they follow the
+            // same gate as the model's own source.
+            args: r
+                .test_args
+                .clone()
+                .filter(|_| r.script_visible && dbt_source_scope(&r.script_path)),
+            // dbt-core 1.x echoes the author's casing, 2.x uppercases; fold so
+            // the badge reads the same whichever engine deployed the script.
+            severity: r.severity.as_deref().map(|s| s.to_ascii_lowercase()),
+        };
+        if !entry.data_tests.contains(&test) {
+            entry.data_tests.push(test);
+        }
+    }
+
     let last_success_by_path: std::collections::HashMap<String, chrono::DateTime<chrono::Utc>> =
         last_success_rows
             .into_iter()
@@ -1132,6 +1631,17 @@ async fn asset_graph(
 
     let mut edges = Vec::with_capacity(rows.len());
     let mut asset_set: std::collections::HashSet<(AssetKind, String)> = Default::default();
+    // Pinned to a version, the relations come from that version's own nodes. The
+    // `asset` rows above are path-keyed — one set per script, always the current
+    // deploy — so a model this version had and a later one dropped would be
+    // missing from its own run's graph.
+    if dbt_script_hash.is_some() {
+        for r in &dbt_rows {
+            if let Some(p) = r.asset_path.as_deref() {
+                asset_set.insert((AssetKind::Dbt, p.to_string()));
+            }
+        }
+    }
     let mut runnable_set: std::collections::HashSet<(AssetUsageKind, String)> = Default::default();
 
     // Every pipeline member in scope goes into the graph, even when the parser
@@ -1491,6 +2001,9 @@ async fn asset_graph(
                 })
                 .flatten(),
             derived_from: scd2_current_base.get(&(kind, path.clone())).cloned(),
+            dbt: (kind == AssetKind::Dbt)
+                .then(|| dbt_by_asset_path.get(&path).cloned())
+                .flatten(),
             kind,
             path,
         })
@@ -1562,6 +2075,10 @@ async fn asset_graph(
                     .flatten()
                     .cloned()
                     .unwrap_or_default(),
+                dbt: (usage_kind == AssetUsageKind::Script)
+                    .then(|| dbt_model_count.get(&path))
+                    .flatten()
+                    .map(|n| DbtRunnableProvenance { model_count: *n }),
                 path,
                 usage_kind,
             }
@@ -1569,6 +2086,22 @@ async fn asset_graph(
         .collect();
     runnables.sort_by(|a, b| a.path.cmp(&b.path));
 
+    // Only between relations this graph actually renders — an edge to a node
+    // that is not here has nothing to draw.
+    let rendered: std::collections::HashSet<&str> =
+        assets.iter().map(|a| a.path.as_str()).collect();
+    let mut dbt_edges: Vec<DbtLineageEdge> = dbt_edge_rows
+        .into_iter()
+        .filter(|r| {
+            r.from_path != r.to_path
+                && rendered.contains(r.from_path.as_str())
+                && rendered.contains(r.to_path.as_str())
+        })
+        .map(|r| DbtLineageEdge { from_asset_path: r.from_path, to_asset_path: r.to_path })
+        .collect();
+    dbt_edges.sort();
+    dbt_edges.dedup();
+
     Ok(Json(AssetGraphResponse {
         assets,
         runnables,
@@ -1576,6 +2109,8 @@ async fn asset_graph(
         triggers,
         macro_edges,
         test_edges,
+        dbt_edges,
+        dbt_snapshot_job,
     }))
 }
 
diff --git a/backend/windmill-api-assets/tests/dbt_pinned_graph.rs b/backend/windmill-api-assets/tests/dbt_pinned_graph.rs
new file mode 100644
index 0000000000..d5e1418b78
--- /dev/null
+++ b/backend/windmill-api-assets/tests/dbt_pinned_graph.rs
@@ -0,0 +1,348 @@
+//! What a caller who cannot see a dbt script gets from a run of it.
+//!
+//! The share-link case: `require_job_read_access` has already let them through
+//! to the job, so `asset_graph_for` is handed the run — but the project itself
+//! is not theirs to read. The graph's SHAPE must survive that and its model SQL
+//! must not, and the two are decided by different predicates. Resolving the
+//! version from the caller's `script` access instead of from the job emptied the
+//! whole dbt half, and every later fix in this area re-touched one of the two.
+
+use sqlx::{Pool, Postgres};
+use windmill_api_assets::{asset_graph_for, GraphQuery, PinnedRun};
+use windmill_api_auth::ApiAuthed;
+use windmill_common::db::UserDB;
+
+const WS: &str = "test-workspace";
+const PATH: &str = "f/private/proj";
+const HASH: i64 = 42;
+
+/// A member of the workspace with no grant on `f/private` — the reason someone
+/// is sent a share link in the first place.
+fn outsider() -> ApiAuthed {
+    ApiAuthed {
+        email: "outsider@windmill.dev".to_string(),
+        username: "outsider".to_string(),
+        is_admin: false,
+        is_operator: false,
+        groups: vec![],
+        folders: vec![],
+        scopes: None,
+        username_override: None,
+        username_override_is_token_label: false,
+        is_session_token: false,
+        token_prefix: None,
+        read_only: false,
+    }
+}
+
+async fn seed(db: &Pool<Postgres>, job: uuid::Uuid) {
+    sqlx::query!(
+        "INSERT INTO folder (workspace_id, name, display_name, owners, extra_perms)
+         VALUES ($1, 'private', 'private', '{}', '{}')",
+        WS
+    )
+    .execute(db)
+    .await
+    .unwrap();
+    sqlx::query!(
+        "INSERT INTO script (workspace_id, hash, path, summary, description, content,
+                             created_by, language, lock)
+         VALUES ($1, $2, $3, '', '', 'profile: {}', 'test-user', 'dbt', '')",
+        WS,
+        HASH,
+        PATH,
+    )
+    .execute(db)
+    .await
+    .unwrap();
+    sqlx::query!(
+        "INSERT INTO dbt_graph_snapshot (workspace_id, script_path, script_hash, job_id, digest)
+         VALUES ($1, $2, $3, $4, 'd')",
+        WS,
+        PATH,
+        HASH,
+        job
+    )
+    .execute(db)
+    .await
+    .unwrap();
+    sqlx::query!(
+        r#"INSERT INTO dbt_node (workspace_id, script_path, script_hash, job_id, unique_id,
+                                 resource_type, name, asset_path, raw_code, tags, description,
+                                 columns, freshness)
+           VALUES ($1, $2, $3, $4, 'model.p.orders', 'model', 'orders',
+                   'u/a/wh/analytics/orders', 'select 1', '{finance}', 'daily order facts',
+                   '{"order_id": {"description": "natural key"}}'::jsonb,
+                   '{"warn_after": {"count": 12, "period": "hour"}}'::jsonb)"#,
+        WS,
+        PATH,
+        HASH,
+        job
+    )
+    .execute(db)
+    .await
+    .unwrap();
+    // A test node, for the arguments it carries: `accepted_values` spells out a
+    // column's domain.
+    sqlx::query!(
+        r#"INSERT INTO dbt_node (workspace_id, script_path, script_hash, job_id, unique_id,
+                                 resource_type, name, tags, test_kind, test_column, test_args,
+                                 attached_node)
+           VALUES ($1, $2, $3, $4, 'test.p.accepted_values_orders_status', 'test',
+                   'accepted_values_orders_status', '{}', 'accepted_values', 'status',
+                   '{"values": ["gold", "silver"]}'::jsonb, 'model.p.orders')"#,
+        WS,
+        PATH,
+        HASH,
+        job
+    )
+    .execute(db)
+    .await
+    .unwrap();
+}
+
+/// Everything on a node that the project's author wrote, rather than the shape
+/// of the relation it produces.
+const AUTHORED: [&str; 5] = [
+    "select 1",
+    "daily order facts",
+    "finance",
+    "natural key",
+    "gold",
+];
+
+fn query() -> GraphQuery {
+    GraphQuery { asset_kinds: Some("dbt".to_string()), folder: None, dbt_script_hash: None }
+}
+
+/// Pinned to a run they are entitled to, the outsider gets the model — and
+/// nothing its author wrote. Both halves matter: dropping the first is the blank
+/// Models panel under working progress rows, dropping the second hands the
+/// project's source and documentation to anyone holding a link.
+#[sqlx::test(migrations = "../migrations", fixtures("base"))]
+async fn a_pinned_run_survives_no_access_to_its_script(db: Pool<Postgres>) {
+    let job = uuid::Uuid::from_u128(7);
+    seed(&db, job).await;
+
+    let pinned = PinnedRun { job_id: job, script_path: PATH.to_string(), script_hash: HASH };
+    let res = asset_graph_for(
+        &outsider(),
+        WS,
+        UserDB::new(db.clone()),
+        db.clone(),
+        query(),
+        Some(pinned),
+    )
+    .await
+    .unwrap();
+    let body = serde_json::to_value(&res.0).unwrap();
+
+    let nodes = body["dbt_nodes"]
+        .as_array()
+        .or(body["assets"].as_array())
+        .unwrap();
+    assert!(
+        !nodes.is_empty(),
+        "a run the caller may read must render, whatever their access to the project: {body}"
+    );
+    assert_eq!(
+        body["dbt_snapshot_job"],
+        serde_json::json!(job),
+        "and the marker must agree with it, or the page polls the graph 40 times"
+    );
+    for authored in AUTHORED {
+        assert!(
+            !body.to_string().contains(authored),
+            "`{authored}` is the project's, and stays behind access to it: {body}"
+        );
+    }
+    assert!(
+        body.to_string().contains("u/a/wh/analytics/orders"),
+        "while the relation the run wrote is what the page is for: {body}"
+    );
+
+    // The same read by someone who may open the project: the gate has to be the
+    // caller's access, not a field this endpoint stopped serving.
+    let seen = asset_graph_for(
+        &ApiAuthed { is_admin: true, ..outsider() },
+        WS,
+        UserDB::new(db.clone()),
+        db.clone(),
+        query(),
+        Some(PinnedRun { job_id: job, script_path: PATH.to_string(), script_hash: HASH }),
+    )
+    .await
+    .unwrap();
+    let seen = serde_json::to_value(&seen.0).unwrap().to_string();
+    for authored in AUTHORED {
+        assert!(
+            seen.contains(authored),
+            "`{authored}` renders for a reader of the project: {seen}"
+        );
+    }
+}
+
+/// Unpinned, the same caller sees nothing of the project: the workspace graph
+/// answers for their own access, and this one is not theirs. This is the half
+/// that must NOT be relaxed by making the pinned case work.
+#[sqlx::test(migrations = "../migrations", fixtures("base"))]
+async fn without_a_run_the_same_caller_sees_no_dbt_nodes(db: Pool<Postgres>) {
+    let job = uuid::Uuid::from_u128(7);
+    seed(&db, job).await;
+
+    let res = asset_graph_for(
+        &outsider(),
+        WS,
+        UserDB::new(db.clone()),
+        db.clone(),
+        query(),
+        None,
+    )
+    .await
+    .unwrap();
+    let body = serde_json::to_value(&res.0).unwrap();
+    assert!(
+        !body.to_string().contains("orders"),
+        "an unpinned graph is the caller's own view of the workspace: {body}"
+    );
+}
+
+/// Archiving retires the script; it must not retire the runs that already
+/// happened. The pinned read resolves versions through a CTE that skips archived
+/// rows, so nothing about the CURRENT workspace graph depends on the sidecar
+/// surviving — which is exactly why deleting it looks safe and is not.
+#[sqlx::test(migrations = "../migrations", fixtures("base"))]
+async fn archiving_the_script_leaves_its_finished_runs_renderable(db: Pool<Postgres>) {
+    let job = uuid::Uuid::from_u128(7);
+    seed(&db, job).await;
+    sqlx::query!(
+        "UPDATE script SET archived = true WHERE workspace_id = $1 AND hash = $2",
+        WS,
+        HASH
+    )
+    .execute(&db)
+    .await
+    .unwrap();
+
+    let admin = ApiAuthed { is_admin: true, ..outsider() };
+    let pinned = PinnedRun { job_id: job, script_path: PATH.to_string(), script_hash: HASH };
+    let res = asset_graph_for(
+        &admin,
+        WS,
+        UserDB::new(db.clone()),
+        db.clone(),
+        query(),
+        Some(pinned),
+    )
+    .await
+    .unwrap();
+    assert!(
+        serde_json::to_value(&res.0)
+            .unwrap()
+            .to_string()
+            .contains("orders"),
+        "a completed run of an archived version still renders its models"
+    );
+
+    let now = asset_graph_for(
+        &admin,
+        WS,
+        UserDB::new(db.clone()),
+        db.clone(),
+        query(),
+        None,
+    )
+    .await
+    .unwrap();
+    assert!(
+        !serde_json::to_value(&now.0)
+            .unwrap()
+            .to_string()
+            .contains("model.p.orders"),
+        "while the workspace graph, which describes what is live, drops it"
+    );
+}
+
+/// `extra_perms` is a grant on a ROW, so a path recreated with narrower ones
+/// leaves the old version readable to whoever the old row named. The source
+/// probe therefore has to name the version it is about to return: matched on
+/// the path alone, that stale grant answered for the pinned version's SQL and
+/// handed a viewer the body of a project they were never given.
+#[sqlx::test(migrations = "../migrations", fixtures("base"))]
+async fn an_old_grant_at_the_same_path_does_not_expose_a_newer_version(db: Pool<Postgres>) {
+    const V2: i64 = 43;
+    let v1_job = uuid::Uuid::from_u128(7);
+    let v2_job = uuid::Uuid::from_u128(8);
+    seed(&db, v1_job).await;
+
+    // The version the outsider WAS granted, archived — the shape the grant
+    // outlives the deploy in.
+    sqlx::query!(
+        r#"UPDATE script SET archived = true, extra_perms = '{"u/outsider": true}'::jsonb
+            WHERE workspace_id = $1 AND hash = $2"#,
+        WS,
+        HASH
+    )
+    .execute(&db)
+    .await
+    .unwrap();
+
+    // The version they were not.
+    sqlx::query!(
+        "INSERT INTO script (workspace_id, hash, path, summary, description, content,
+                             created_by, language, lock)
+         VALUES ($1, $2, $3, '', '', 'profile: {}', 'test-user', 'dbt', '')",
+        WS,
+        V2,
+        PATH,
+    )
+    .execute(&db)
+    .await
+    .unwrap();
+    sqlx::query!(
+        "INSERT INTO dbt_graph_snapshot (workspace_id, script_path, script_hash, job_id, digest)
+         VALUES ($1, $2, $3, $4, 'd2')",
+        WS,
+        PATH,
+        V2,
+        v2_job
+    )
+    .execute(&db)
+    .await
+    .unwrap();
+    sqlx::query!(
+        "INSERT INTO dbt_node (workspace_id, script_path, script_hash, job_id, unique_id,
+                               resource_type, name, asset_path, raw_code, tags)
+         VALUES ($1, $2, $3, $4, 'model.p.orders', 'model', 'orders',
+                 'u/a/wh/analytics/orders', 'select 2', '{}')",
+        WS,
+        PATH,
+        V2,
+        v2_job
+    )
+    .execute(&db)
+    .await
+    .unwrap();
+
+    let pinned = PinnedRun { job_id: v2_job, script_path: PATH.to_string(), script_hash: V2 };
+    let res = asset_graph_for(
+        &outsider(),
+        WS,
+        UserDB::new(db.clone()),
+        db.clone(),
+        query(),
+        Some(pinned),
+    )
+    .await
+    .unwrap();
+    let body = serde_json::to_value(&res.0).unwrap().to_string();
+
+    assert!(
+        body.contains("orders"),
+        "the run they were given still renders its models: {body}"
+    );
+    assert!(
+        !body.contains("select 2"),
+        "but not the SQL of a version their grant never covered: {body}"
+    );
+}
diff --git a/backend/windmill-api-assets/tests/fixtures/base.sql b/backend/windmill-api-assets/tests/fixtures/base.sql
new file mode 100644
index 0000000000..412fa1029f
--- /dev/null
+++ b/backend/windmill-api-assets/tests/fixtures/base.sql
@@ -0,0 +1,146 @@
+-- used for backend automated testing
+-- https://docs.rs/sqlx/latest/sqlx/attr.test.html
+
+INSERT INTO workspace
+            (id,               name,             owner)
+     VALUES ('test-workspace', 'test-workspace', 'test-user');
+
+INSERT INTO usr(workspace_id, email, username, is_admin, role) VALUES
+	('test-workspace', 'test@windmill.dev', 'test-user', true, 'Admin');
+
+INSERT INTO workspace_key(workspace_id, kind, key) VALUES
+	('test-workspace', 'cloud', 'test-key');
+
+
+INSERT INTO workspace_settings (workspace_id) VALUES
+	('test-workspace');
+
+INSERT INTO group_ (workspace_id, name, summary, extra_perms) VALUES
+	('test-workspace', 'all', 'All users', '{}');
+
+INSERT INTO password(email, password_hash, login_type, super_admin, verified, name, username)
+    VALUES ('test@windmill.dev', 'not-a-real-hash', 'password', true, true, 'Test User', 'test-user');
+
+INSERT INTO password(email, password_hash, login_type, super_admin, verified, name)
+    VALUES ('test2@windmill.dev', 'not-a-real-hash', 'password', false, true, 'Test User 2');
+
+INSERT INTO password(email, password_hash, login_type, super_admin, verified, name)
+    VALUES ('test3@windmill.dev', 'not-a-real-hash', 'password', false, true, 'Test User 3');
+
+INSERT INTO usr(workspace_id, email, username, is_admin, role) VALUES
+	('test-workspace', 'test2@windmill.dev', 'test-user-2', false, 'User');
+
+INSERT INTO usr(workspace_id, email, username, is_admin, role) VALUES
+	('test-workspace', 'test3@windmill.dev', 'test-user-3', false, 'User');
+
+insert INTO token(token_hash, token_prefix, token, email, label, super_admin) VALUES (encode(sha256('SECRET_TOKEN'::bytea), 'hex'), 'SECRET_TOK', 'SECRET_TOKEN', 'test@windmill.dev', 'test token', true);
+insert INTO token(token_hash, token_prefix, token, email, label, super_admin) VALUES (encode(sha256('SECRET_TOKEN_2'::bytea), 'hex'), 'SECRET_TOK', 'SECRET_TOKEN_2', 'test2@windmill.dev', 'test token 2', false);
+insert INTO token(token_hash, token_prefix, token, email, label, super_admin) VALUES (encode(sha256('SECRET_TOKEN_3'::bytea), 'hex'), 'SECRET_TOK', 'SECRET_TOKEN_3', 'test3@windmill.dev', 'test token 3', false);
+
+GRANT ALL PRIVILEGES ON TABLE workspace_key TO windmill_admin;
+GRANT ALL PRIVILEGES ON TABLE workspace_key TO windmill_user;
+
+CREATE FUNCTION "notify_insert_on_completed_job" ()
+RETURNS TRIGGER AS $$
+BEGIN
+    PERFORM pg_notify('completed', NEW.id::text);
+    RETURN NEW;
+END;
+$$ LANGUAGE PLPGSQL;
+
+  CREATE TRIGGER "notify_insert_on_completed_job"
+ AFTER INSERT ON "v2_job_completed"
+    FOR EACH ROW
+EXECUTE FUNCTION "notify_insert_on_completed_job" ();
+
+
+CREATE FUNCTION "notify_queue" ()
+RETURNS TRIGGER AS $$
+BEGIN
+    PERFORM pg_notify('queued', NEW.id::text);
+    RETURN NEW;
+END;
+$$ LANGUAGE PLPGSQL;
+
+  CREATE TRIGGER "notify_queue_after_insert"
+ AFTER INSERT ON "v2_job_queue"
+    FOR EACH ROW
+EXECUTE FUNCTION "notify_queue" ();
+
+  CREATE TRIGGER "notify_queue_after_flow_status_update"
+ AFTER UPDATE ON "v2_job_status"
+    FOR EACH ROW
+            WHEN (NEW.flow_status IS DISTINCT FROM OLD.flow_status)
+EXECUTE FUNCTION "notify_queue" ();
+
+-- Apply phase 4:
+DROP FUNCTION IF EXISTS v2_job_after_update CASCADE;
+DROP FUNCTION IF EXISTS v2_job_completed_before_insert CASCADE;
+DROP FUNCTION IF EXISTS v2_job_completed_before_update CASCADE;
+DROP FUNCTION IF EXISTS v2_job_queue_after_insert CASCADE;
+DROP FUNCTION IF EXISTS v2_job_queue_before_insert CASCADE;
+DROP FUNCTION IF EXISTS v2_job_queue_before_update CASCADE;
+DROP FUNCTION IF EXISTS v2_job_runtime_before_insert CASCADE;
+DROP FUNCTION IF EXISTS v2_job_runtime_before_update CASCADE;
+DROP FUNCTION IF EXISTS v2_job_status_before_insert CASCADE;
+DROP FUNCTION IF EXISTS v2_job_status_before_update CASCADE;
+
+DROP VIEW IF EXISTS completed_job, completed_job_view, job, queue, queue_view CASCADE;
+
+ALTER TABLE v2_job_queue
+    DROP COLUMN IF EXISTS __parent_job CASCADE,
+    DROP COLUMN IF EXISTS __created_by CASCADE,
+    DROP COLUMN IF EXISTS __script_hash CASCADE,
+    DROP COLUMN IF EXISTS __script_path CASCADE,
+    DROP COLUMN IF EXISTS __args CASCADE,
+    DROP COLUMN IF EXISTS __logs CASCADE,
+    DROP COLUMN IF EXISTS __raw_code CASCADE,
+    DROP COLUMN IF EXISTS __canceled CASCADE,
+    DROP COLUMN IF EXISTS __last_ping CASCADE,
+    DROP COLUMN IF EXISTS __job_kind CASCADE,
+    DROP COLUMN IF EXISTS __env_id CASCADE,
+    DROP COLUMN IF EXISTS __schedule_path CASCADE,
+    DROP COLUMN IF EXISTS __permissioned_as CASCADE,
+    DROP COLUMN IF EXISTS __flow_status CASCADE,
+    DROP COLUMN IF EXISTS __raw_flow CASCADE,
+    DROP COLUMN IF EXISTS __is_flow_step CASCADE,
+    DROP COLUMN IF EXISTS __language CASCADE,
+    DROP COLUMN IF EXISTS __same_worker CASCADE,
+    DROP COLUMN IF EXISTS __raw_lock CASCADE,
+    DROP COLUMN IF EXISTS __pre_run_error CASCADE,
+    DROP COLUMN IF EXISTS __email CASCADE,
+    DROP COLUMN IF EXISTS __visible_to_owner CASCADE,
+    DROP COLUMN IF EXISTS __mem_peak CASCADE,
+    DROP COLUMN IF EXISTS __root_job CASCADE,
+    DROP COLUMN IF EXISTS __leaf_jobs CASCADE,
+    DROP COLUMN IF EXISTS __concurrent_limit CASCADE,
+    DROP COLUMN IF EXISTS __concurrency_time_window_s CASCADE,
+    DROP COLUMN IF EXISTS __timeout CASCADE,
+    DROP COLUMN IF EXISTS __flow_step_id CASCADE,
+    DROP COLUMN IF EXISTS __cache_ttl CASCADE;
+
+LOCK TABLE v2_job_queue IN ACCESS EXCLUSIVE MODE;
+ALTER TABLE v2_job_completed
+    DROP COLUMN IF EXISTS __parent_job CASCADE,
+    DROP COLUMN IF EXISTS __created_by CASCADE,
+    DROP COLUMN IF EXISTS __created_at CASCADE,
+    DROP COLUMN IF EXISTS __success CASCADE,
+    DROP COLUMN IF EXISTS __script_hash CASCADE,
+    DROP COLUMN IF EXISTS __script_path CASCADE,
+    DROP COLUMN IF EXISTS __args CASCADE,
+    DROP COLUMN IF EXISTS __logs CASCADE,
+    DROP COLUMN IF EXISTS __raw_code CASCADE,
+    DROP COLUMN IF EXISTS __canceled CASCADE,
+    DROP COLUMN IF EXISTS __job_kind CASCADE,
+    DROP COLUMN IF EXISTS __env_id CASCADE,
+    DROP COLUMN IF EXISTS __schedule_path CASCADE,
+    DROP COLUMN IF EXISTS __permissioned_as CASCADE,
+    DROP COLUMN IF EXISTS __raw_flow CASCADE,
+    DROP COLUMN IF EXISTS __is_flow_step CASCADE,
+    DROP COLUMN IF EXISTS __language CASCADE,
+    DROP COLUMN IF EXISTS __is_skipped CASCADE,
+    DROP COLUMN IF EXISTS __raw_lock CASCADE,
+    DROP COLUMN IF EXISTS __email CASCADE,
+    DROP COLUMN IF EXISTS __visible_to_owner CASCADE,
+    DROP COLUMN IF EXISTS __tag CASCADE,
+    DROP COLUMN IF EXISTS __priority CASCADE;
diff --git a/backend/windmill-api-auth/src/lib.rs b/backend/windmill-api-auth/src/lib.rs
index cc7fdcb167..d92c3a5f2d 100644
--- a/backend/windmill-api-auth/src/lib.rs
+++ b/backend/windmill-api-auth/src/lib.rs
@@ -1338,7 +1338,11 @@ mod tests {
             // A label-less token: the job WM_TOKEN, and any token created without one.
             None,
         ] {
-            assert_eq!(kind_of(label).as_deref(), Some("webhook"), "label {label:?}");
+            assert_eq!(
+                kind_of(label).as_deref(),
+                Some("webhook"),
+                "label {label:?}"
+            );
         }
     }
 
@@ -1347,8 +1351,10 @@ mod tests {
     #[test]
     fn a_real_trigger_wins_over_the_token_fallback() {
         let authed = ApiAuthed::default();
-        let schedule =
-            TriggerMetadata::new(Some("u/alice/nightly".to_string()), JobTriggerKind::Schedule);
+        let schedule = TriggerMetadata::new(
+            Some("u/alice/nightly".to_string()),
+            JobTriggerKind::Schedule,
+        );
 
         let kept = authed.trigger_or_fallback(Some(schedule)).unwrap();
         assert_eq!(kept.trigger_kind.to_string(), "schedule");
diff --git a/backend/windmill-api-integration-tests/tests/workspaces.rs b/backend/windmill-api-integration-tests/tests/workspaces.rs
index 851dcbb4cd..e9eeb88996 100644
--- a/backend/windmill-api-integration-tests/tests/workspaces.rs
+++ b/backend/windmill-api-integration-tests/tests/workspaces.rs
@@ -964,3 +964,46 @@ async fn test_get_imports(db: Pool<Postgres>) -> anyhow::Result<()> {
 
     Ok(())
 }
+
+/// A dbt project names a warehouse and nothing else, so the workspace setting is
+/// the only place the connection is decided. Two things have to hold for that to
+/// work at all: the setting round-trips as the MAP the resolver reads (an
+/// envelope stored verbatim makes every warehouse name unresolvable), and the
+/// route that serves the name to a worker with no database stays job-scoped.
+#[sqlx::test(migrations = "../migrations", fixtures("base"))]
+async fn test_dbt_warehouses(db: Pool<Postgres>) -> anyhow::Result<()> {
+    initialize_tracing().await;
+    let server = ApiServer::start(db.clone()).await?;
+    let port = server.addr.port();
+    let base = format!("http://localhost:{port}/api/w/test-workspace");
+
+    let resp = authed(client().post(format!("{base}/workspaces/edit_dbt_warehouses")))
+        .json(&json!({
+            "dbt_warehouses": { "main": { "resource_path": "u/admin/wh", "target": "prod" } }
+        }))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(resp.status(), 200);
+
+    let resp = authed(client().get(format!("{base}/workspaces/get_settings")))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(resp.status(), 200);
+    let settings = resp.json::<serde_json::Value>().await?;
+    assert_eq!(
+        settings["dbt_warehouses"],
+        json!({ "main": { "resource_path": "u/admin/wh", "target": "prod" } })
+    );
+
+    // A user token is not a job token: the warehouses a workspace configures are
+    // a running job's business, not a browsable list.
+    let resp = authed(client().get(format!("{base}/dbt/warehouse/main")))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(resp.status(), 400);
+
+    Ok(())
+}
diff --git a/backend/windmill-api-scripts/src/asset_inference.rs b/backend/windmill-api-scripts/src/asset_inference.rs
index 5debb0d271..9c503ae1ae 100644
--- a/backend/windmill-api-scripts/src/asset_inference.rs
+++ b/backend/windmill-api-scripts/src/asset_inference.rs
@@ -42,6 +42,13 @@ fn parse_assets_for_lang(
         #[cfg(feature = "python")]
         ScriptLang::Python3 => windmill_parser_py_asset::parse_assets(content),
         ScriptLang::Ansible => windmill_parser_yaml::parse_assets(content),
+        // dbt is the one language whose assets are not a function of the script
+        // content: they come from `manifest.json`, which needs a clone of the
+        // project's repo and a dbt invocation. The deploy-time dependency job
+        // does that parse and writes the `asset` rows itself
+        // (`dbt_executor::dbt_dep`), so returning None here is what keeps this
+        // path from clobbering them with an empty list.
+        ScriptLang::Dbt => return None,
         _ => return None,
     };
     match parsed {
diff --git a/backend/windmill-api-scripts/src/scripts.rs b/backend/windmill-api-scripts/src/scripts.rs
index 57e2cef3c3..2d4f1c72b8 100644
--- a/backend/windmill-api-scripts/src/scripts.rs
+++ b/backend/windmill-api-scripts/src/scripts.rs
@@ -804,7 +804,20 @@ async fn is_noop_deploy_against_parent(
     if content != &parent.content {
         return Ok(false);
     }
-    if normalize_optional_text(lock.as_deref()) != normalize_optional_text(parent.lock.as_deref()) {
+    // A dbt lock is DERIVED, never supplied: the request carries none — the CLI
+    // sends `lock: undefined` and this route discards any anyway — while a
+    // deployed parent carries what its dependency job wrote. Comparing them makes
+    // every unchanged push a new version, a fresh dependency job and the sync
+    // activity `skip_if_noop` exists to prevent. The parent must actually hold
+    // one, or a deploy whose dependency job failed could never be retried by
+    // pushing the same project again.
+    if matches!(language, ScriptLang::Dbt) {
+        if normalize_optional_text(parent.lock.as_deref()).is_empty() {
+            return Ok(false);
+        }
+    } else if normalize_optional_text(lock.as_deref())
+        != normalize_optional_text(parent.lock.as_deref())
+    {
         return Ok(false);
     }
     if summary != &parent.summary {
@@ -853,7 +866,22 @@ async fn is_noop_deploy_against_parent(
     if on_behalf_of_email != &parent.on_behalf_of_email {
         return Ok(false);
     }
-    if !schema_opt_eq(schema.as_ref(), parent.schema.as_ref()) {
+    // Both of a dbt script's derived fields are compared as they WOULD BE STORED,
+    // not as they arrived: the schema comes from the descriptor and the clients
+    // cannot derive it (`windmill-parser-wasm` has no dbt arm), so they send the
+    // previous version's or none at all. Comparing what they sent makes every
+    // unchanged push differ.
+    let dbt_schema = matches!(language, ScriptLang::Dbt)
+        .then(|| windmill_parser_yaml::dbt_arg_schema(content).ok())
+        .flatten()
+        .and_then(|v| serde_json::value::to_raw_value(&v).ok())
+        .map(|v| Schema(sqlx::types::Json(v)));
+    let effective_schema = if matches!(language, ScriptLang::Dbt) {
+        dbt_schema.as_ref()
+    } else {
+        schema.as_ref()
+    };
+    if !schema_opt_eq(effective_schema, parent.schema.as_ref()) {
         return Ok(false);
     }
     if !json_serialize_eq(assets, &parent.assets) {
@@ -1185,6 +1213,25 @@ async fn create_script_internal<'c>(
         .as_ref()
         .map(|v| v.perms.clone())
         .unwrap_or(json!({}));
+    // A dbt lock names a manifest digest and engine versions that only a
+    // dependency job can determine, and that job is also what publishes the
+    // script's manifest graph. Honouring a supplied one would skip it, leaving
+    // the script with no graph — including on the UI paths that round-trip an
+    // existing lock, like rename and unarchive.
+    if matches!(ns.language, ScriptLang::Dbt) {
+        ns.lock = None;
+        // A codebase is a bundle of JS/TS sources; a dbt script's project is
+        // its modules. Accepting one takes the branch below that stands in for
+        // lock generation, which would suppress the very job that parses the
+        // project and publishes the graph.
+        if ns.codebase.is_some() {
+            return Err(Error::BadRequest(
+                "a dbt script has no codebase: its project is its modules, the \
+                 `<script>__dbt/` folder the CLI syncs"
+                    .to_string(),
+            ));
+        }
+    }
     let lock = if ns.codebase.is_some() {
         Some(String::new())
     } else if !(
@@ -1202,6 +1249,7 @@ async fn create_script_internal<'c>(
             || ns.language == ScriptLang::Ruby
             || ns.language == ScriptLang::Rlang
             || ns.language == ScriptLang::Powershell
+            || ns.language == ScriptLang::Dbt
         // for related places search: ADD_NEW_LANG
     ) {
         Some(String::new())
@@ -1238,6 +1286,23 @@ async fn create_script_internal<'c>(
         ns.language.clone()
     };
 
+    // The dbt run form's arguments come from the descriptor, and only the
+    // server can read them: both the browser and the CLI infer schemas through
+    // `windmill-parser-wasm`, whose published package has no dbt arm, so they
+    // send whatever the previous version had (nothing, for a new script).
+    if matches!(lang, ScriptLang::Dbt) {
+        match windmill_parser_yaml::dbt_arg_schema(&ns.content) {
+            Ok(schema) => {
+                ns.schema = serde_json::value::to_raw_value(&schema)
+                    .ok()
+                    .map(|v| Schema(sqlx::types::Json(v)));
+            }
+            // A descriptor that does not parse fails later with a better
+            // message than a schema error would give.
+            Err(e) => tracing::warn!("could not derive the dbt schema for {}: {e:#}", ns.path),
+        }
+    }
+
     let validate_schema = should_validate_schema(&ns.content, &ns.language);
 
     let (auto_kind, has_preprocessor) = if matches!(ns.kind, Some(ScriptKind::Preprocessor)) {
@@ -1476,7 +1541,11 @@ async fn create_script_internal<'c>(
         } else {
             None
         };
-    let in_pipeline = pipeline_annotations.in_pipeline;
+    // dbt is deliberately not a pipeline member: that membership carries an
+    // editor whose premise is that the transforms are authored in it, and a dbt
+    // project is authored in a local `dbt run` loop. Its models reach the shared
+    // graph as `dbt://` assets either way (docs/dbt-runtime.md).
+    let in_pipeline = pipeline_annotations.in_pipeline && ns.language != ScriptLang::Dbt;
     // `// trigger all` → AND join barrier (else OR, the default).
     let pipeline_join_all = !pipeline_annotations.join_mode.is_any();
     // Script-level `// debounce <dur>` default; a per-`// on debounce=`
@@ -2073,16 +2142,52 @@ async fn create_script_internal<'c>(
     // stale `// on` edges keep matching producers (and would trigger a script
     // later recreated at that path with no annotation, P1) and its producer
     // rows keep it lingering in the asset graph.
+    // The dbt GRAPH is deliberately not cleared when a path stops being a dbt
+    // script, nor on the rename below. It is keyed by version, and every graph
+    // query joins it on `(path, hash)` through a `language = 'dbt'` CTE — so an
+    // old version's rows can never attach to whatever lives at that path now,
+    // while its own finished runs still render from them. Clearing by path
+    // would empty those run pages for good.
+    if ns.language != ScriptLang::Dbt {
+        // The saved retry state does go: nothing regenerates it, it is keyed by
+        // path alone, and it carries one user's failed invocation and its
+        // arguments. No dbt version is live at this path any more to resume it.
+        windmill_common::dbt_manifest::clear_dbt_run_state(&mut tx, &w_id, &ns.path).await?;
+    }
     if let Some(ref old) = p_path_opt {
         if old != &ns.path {
             clear_script_triggers(&mut *tx, &w_id, old, AssetUsageKind::Script).await?;
             clear_static_asset_usage(&mut *tx, &w_id, old, AssetUsageKind::Script).await?;
+            // The saved retry state travels rather than being cleared: nothing
+            // regenerates it, so dropping it would throw away a resumable
+            // failure for what is only a rename. Only while the destination is
+            // still dbt — a rename that also converts the language would
+            // otherwise reinstate at the new path the state the branch above
+            // just cleared, leaving one user's arguments and results under a
+            // path no dbt script occupies.
+            if ns.language == ScriptLang::Dbt {
+                windmill_common::dbt_manifest::move_dbt_run_state(&mut tx, &w_id, old, &ns.path)
+                    .await?;
+            } else {
+                windmill_common::dbt_manifest::clear_dbt_run_state(&mut tx, &w_id, old).await?;
+            }
         }
     }
     for spec in &pipeline_triggers {
         let Some((trigger_kind, trigger_ref)) = trigger_spec_to_row(spec) else {
             continue;
         };
+        // A `dbt://` subscription can never fire: dbt is the only producer of a
+        // warehouse relation (`// materialize` takes DuckLake targets only) and a
+        // dbt run does not dispatch. Refusing beats persisting a row that draws a
+        // cascade arrow on the canvas and then never wakes anything.
+        if trigger_ref.starts_with("dbt://") {
+            return Err(Error::BadRequest(format!(
+                "`{trigger_ref}` cannot be subscribed to: a dbt run does not trigger downstream \
+                 runs, and nothing else writes a warehouse relation. Declare the read without \
+                 `on` to keep the lineage edge, or schedule this script."
+            )));
+        }
         // Effective debounce for this edge: per-`// on debounce=` wins,
         // else the script-level `// debounce` default. Debounce only
         // applies to asset-cascade edges; other trigger kinds get none.
@@ -3183,6 +3288,12 @@ async fn archive_script_by_path(
     .map_err(|e| Error::internal_err(format!("archiving script in {w_id}: {e:#}")))?;
 
     clear_static_asset_usage(&mut *tx, &w_id, path, AssetUsageKind::Script).await?;
+    // The graph stays: the pinned read resolves versions through a CTE that
+    // already skips archived rows, so it stops answering for current relations
+    // either way, while deleting it would empty the Models panel of every
+    // completed run of the project. Retry state does go — nothing may resume a
+    // script that is no longer live.
+    windmill_common::dbt_manifest::clear_dbt_run_state(&mut tx, &w_id, path).await?;
     // Pipeline event hygiene: an archived script must not be triggered by
     // anything. Wipe declared `// on ...` edges (asset-event subscribers
     // look these up).
@@ -3265,6 +3376,14 @@ async fn archive_script_by_hash(
 
     check_scopes(&authed, || format!("scripts:write:{}", &script.path))?;
     clear_static_asset_usage_by_script_hash(&mut *tx, &w_id, hash).await?;
+    // The version's graph stays: its finished runs still render from it, and
+    // the live-version CTE already skips archived rows. Deletion clears it.
+    windmill_common::dbt_manifest::clear_dbt_run_state_if_path_retired(
+        &mut tx,
+        &w_id,
+        &script.path,
+    )
+    .await?;
     // Pipeline event hygiene: archived scripts must not be triggered by
     // anything. Wipe declared `// on ...` edges.
     clear_script_triggers(&mut *tx, &w_id, &script.path, AssetUsageKind::Script).await?;
@@ -3329,6 +3448,14 @@ async fn delete_script_by_hash(
     check_scopes(&authed, || format!("scripts:write:{}", &script.path))?;
 
     clear_static_asset_usage_by_script_hash(&mut *tx, &w_id, hash).await?;
+    windmill_common::dbt_manifest::clear_dbt_manifest_version(&mut tx, &w_id, &script.path, hash.0)
+        .await?;
+    windmill_common::dbt_manifest::clear_dbt_run_state_if_path_retired(
+        &mut tx,
+        &w_id,
+        &script.path,
+    )
+    .await?;
     // Pipeline event hygiene: a deleted script must not be triggered by
     // anything. Wipe declared `// on ...` edges. Idempotent — safe even if
     // the script was never a pipeline member.
@@ -3413,6 +3540,12 @@ async fn delete_script_by_path(
     .fetch_all(&mut *tx)
     .await?;
 
+    // Before the DELETE: both are keyed on the path with no script foreign key,
+    // so anything left behind here would attach itself to whatever is created
+    // at this path next.
+    windmill_common::dbt_manifest::clear_dbt_manifest(&mut tx, &w_id, path).await?;
+    windmill_common::dbt_manifest::clear_dbt_run_state(&mut tx, &w_id, path).await?;
+
     let script = sqlx::query_scalar!(
         "DELETE FROM script WHERE path = $1 AND workspace_id = $2 RETURNING path",
         path,
@@ -3576,6 +3709,12 @@ async fn delete_scripts_bulk(
         }
     }
 
+    // Same reason as the single-path delete: neither has a foreign key.
+    for p in &request.paths {
+        windmill_common::dbt_manifest::clear_dbt_manifest(&mut tx, &w_id, p).await?;
+        windmill_common::dbt_manifest::clear_dbt_run_state(&mut tx, &w_id, p).await?;
+    }
+
     let mut deleted_paths = sqlx::query_scalar!(
         "DELETE FROM script WHERE workspace_id = $1 AND path = ANY($2) RETURNING path",
         w_id,
diff --git a/backend/windmill-api-users/src/users.rs b/backend/windmill-api-users/src/users.rs
index d680d4306f..522758178a 100644
--- a/backend/windmill-api-users/src/users.rs
+++ b/backend/windmill-api-users/src/users.rs
@@ -2805,6 +2805,20 @@ async fn impersonate(
             "impersonate_username is required".to_string(),
         ));
     }
+    // This route writes its own row rather than going through the `create_token`
+    // handler, so it repeats that handler's guard: impersonation names its
+    // subject in `impersonate_email`, and a server-minted label — which
+    // `username_override_from_label` trusts to name the entity acting — would
+    // attribute this token's jobs to a third identity.
+    if new_token
+        .label
+        .as_deref()
+        .is_some_and(windmill_common::auth::is_server_minted_label)
+    {
+        return Err(Error::BadRequest(
+            "label collides with a reserved system-token namespace".to_string(),
+        ));
+    }
 
     let impersonated = new_token.impersonate_email.unwrap();
 
diff --git a/backend/windmill-api-workspaces/src/workspaces.rs b/backend/windmill-api-workspaces/src/workspaces.rs
index 1577cf18a8..0c4808fd99 100644
--- a/backend/windmill-api-workspaces/src/workspaces.rs
+++ b/backend/windmill-api-workspaces/src/workspaces.rs
@@ -123,6 +123,7 @@ pub fn workspaced_service() -> Router {
             "/edit_large_file_storage_config",
             post(edit_large_file_storage_config),
         )
+        .route("/edit_dbt_warehouses", post(edit_dbt_warehouses))
         .route("/edit_ducklake_config", post(edit_ducklake_config))
         .route("/list_ducklakes", get(list_ducklakes))
         .route("/list_datatables", get(list_datatables))
@@ -277,6 +278,9 @@ pub struct WorkspaceSettings {
     pub webhook: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub ai_config: Option<serde_json::Value>,
+    /// Pointers to the resources dbt scripts run against by default.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub dbt_warehouses: Option<serde_json::Value>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub large_file_storage: Option<serde_json::Value>,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -909,6 +913,7 @@ async fn get_settings(
             plan,
             webhook,
             ai_config,
+            dbt_warehouses,
             large_file_storage,
             datatable,
             ducklake,
@@ -1738,6 +1743,95 @@ async fn edit_webhook(
     Ok(format!("Edit webhook for workspace {}", &w_id))
 }
 
+/// A warehouse's resource, checked at the one place a warehouse is written.
+///
+/// Same grammar as any Windmill resource path, with the `$res:` prefix optional
+/// because the storage configs are inconsistent about it. Traversal and control
+/// characters are refused here rather than at the far end: an unusable path
+/// stored now surfaces as every dbt run in the workspace failing later, with
+/// nothing pointing back at the settings page that accepted it.
+fn validate_dbt_resource_path(name: &str, path: &str) -> Result<()> {
+    let bare = path.strip_prefix("$res:").unwrap_or(path);
+    let parts: Vec<&str> = bare.split('/').collect();
+    let ok = (bare.starts_with("f/") || bare.starts_with("u/"))
+        && parts.len() >= 3
+        && parts
+            .iter()
+            .all(|p| !p.is_empty() && *p != "." && *p != "..")
+        // `resource.path` is VARCHAR(255), so a longer path names a resource that
+        // cannot exist.
+        && bare.chars().count() <= 255
+        && !bare.chars().any(|c| c.is_control() || "?#%\\ ".contains(c));
+    if !ok {
+        return Err(Error::BadRequest(format!(
+            "the dbt warehouse `{name}` names `{path}`, which is not a resource path \
+             (`f/<folder>/<name>` or `u/<user>/<name>`, optionally prefixed with `$res:`)"
+        )));
+    }
+    Ok(())
+}
+
+#[derive(serde::Deserialize, serde::Serialize)]
+struct DbtWarehouseConfig {
+    resource_path: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    target: Option<String>,
+}
+
+#[derive(serde::Deserialize)]
+struct EditDbtWarehouses {
+    /// Typed rather than free JSON: a shape the resolver cannot read (a list, a
+    /// number where a config belongs) would be accepted here and then fail every
+    /// dbt run in the workspace, far from the request that caused it.
+    dbt_warehouses: Option<std::collections::HashMap<String, DbtWarehouseConfig>>,
+}
+
+/// The workspace's dbt warehouses, by name, each a POINTER to a resource rather
+/// than credentials — like `large_file_storage`. A dbt project can then carry no
+/// connection at all, and the resource keeps its own ACL. Admin-only, because it
+/// decides what every dbt script in the workspace reaches.
+async fn edit_dbt_warehouses(
+    authed: ApiAuthed,
+    Extension(db): Extension<DB>,
+    Path(w_id): Path<String>,
+    ApiAuthed { is_admin, username, .. }: ApiAuthed,
+    Json(new_config): Json<EditDbtWarehouses>,
+) -> Result<String> {
+    require_admin(is_admin, &username)?;
+    let new_config = new_config.dbt_warehouses;
+    if let Some(map) = new_config.as_ref() {
+        for (name, cfg) in map.iter() {
+            windmill_common::workspaces::validate_dbt_warehouse_name(name)?;
+            validate_dbt_resource_path(name, &cfg.resource_path)?;
+        }
+    }
+    let new_config = new_config
+        .map(|m| serde_json::to_value(m))
+        .transpose()
+        .map_err(|e| Error::internal_err(format!("serializing the dbt warehouses: {e}")))?;
+    let mut tx = db.begin().await?;
+    audit_log(
+        &mut *tx,
+        &authed,
+        "workspaces.edit_dbt_warehouses",
+        ActionKind::Update,
+        &w_id,
+        Some(&authed.email),
+        Some([("dbt_warehouses", format!("{new_config:?}").as_str())].into()),
+    )
+    .await?;
+    let value = new_config.filter(|v| !v.is_null());
+    sqlx::query!(
+        "UPDATE workspace_settings SET dbt_warehouses = $1 WHERE workspace_id = $2",
+        value,
+        &w_id
+    )
+    .execute(&mut *tx)
+    .await?;
+    tx.commit().await?;
+    Ok("Updated the workspace's dbt warehouses".to_string())
+}
+
 async fn edit_large_file_storage_config(
     authed: ApiAuthed,
     Extension(db): Extension<DB>,
@@ -2415,6 +2509,16 @@ mod tests {
         assert!(!json_text_has_nul_escape(&nul_json(0)));
     }
 
+    #[test]
+    fn dbt_resource_path_length_bound() {
+        let at_limit = format!("f/dbt/{}", "a".repeat(255 - "f/dbt/".len()));
+        assert_eq!(at_limit.chars().count(), 255);
+        assert!(validate_dbt_resource_path("main", &at_limit).is_ok());
+        // The `$res:` prefix is not stored, so it does not count against the column.
+        assert!(validate_dbt_resource_path("main", &format!("$res:{at_limit}")).is_ok());
+        assert!(validate_dbt_resource_path("main", &format!("{at_limit}a")).is_err());
+    }
+
     #[test]
     fn nul_escape_ignores_clean_values() {
         assert!(!json_text_has_nul_escape(
@@ -5202,6 +5306,12 @@ async fn clone_workspace_data(
     // Clone scripts with new hashes
     clone_scripts(tx, source_workspace_id, target_workspace_id).await?;
 
+    // Clone the dbt graph sidecars. After `clone_scripts`, which keeps each
+    // script's hash: these key on it, and a static descriptor never re-ingests,
+    // so a fork without them shows dbt scripts with no models until someone
+    // redeploys.
+    clone_dbt_graph(tx, source_workspace_id, target_workspace_id).await?;
+
     // 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?;
@@ -5536,6 +5646,7 @@ async fn update_workspace_settings(
             ai_config = source_ws.ai_config,
             large_file_storage = source_ws.large_file_storage,
             ducklake = source_ws.ducklake,
+            dbt_warehouses = source_ws.dbt_warehouses,
             datatable = source_ws.datatable,
             git_app_installations = source_ws.git_app_installations
         FROM workspace_settings source_ws
@@ -5831,6 +5942,64 @@ async fn clone_scripts(
     Ok(())
 }
 
+/// The parsed dbt graph a deployed script carries: its models, their SQL and
+/// tests, and the `ref()` lineage between them.
+///
+/// Keyed on (workspace_id, script_path, script_hash), and the fork keeps every
+/// script's hash, so each row moves across as itself.
+///
+/// The DEPLOYED graph only (`job_id` all-zero). A per-run snapshot is keyed to a
+/// job in the source workspace, which nothing in the fork can ask for, so
+/// copying them adds another workspace's run history — `raw_code` and all — to
+/// every fork transaction to be reclaimed later by the age sweep.
+async fn clone_dbt_graph(
+    tx: &mut Transaction<'_, Postgres>,
+    source_workspace_id: &str,
+    target_workspace_id: &str,
+) -> Result<()> {
+    sqlx::query!(
+        "INSERT INTO dbt_node (workspace_id, script_path, script_hash, job_id, unique_id,
+            resource_type, name, asset_path, materialized, materialize_strategy, unique_key,
+            tags, description, test_kind, test_column, test_args, severity, attached_node,
+            columns, freshness, raw_code, original_file_path, ingested_at)
+         SELECT $2, script_path, script_hash, job_id, unique_id,
+            resource_type, name, asset_path, materialized, materialize_strategy, unique_key,
+            tags, description, test_kind, test_column, test_args, severity, attached_node,
+            columns, freshness, raw_code, original_file_path, ingested_at
+         FROM dbt_node
+         WHERE workspace_id = $1 AND job_id = '00000000-0000-0000-0000-000000000000'",
+        source_workspace_id,
+        target_workspace_id
+    )
+    .execute(&mut **tx)
+    .await?;
+    sqlx::query!(
+        "INSERT INTO dbt_edge (workspace_id, script_path, script_hash, job_id,
+            parent_unique_id, child_unique_id, ingested_at)
+         SELECT $2, script_path, script_hash, job_id, parent_unique_id, child_unique_id,
+            ingested_at
+         FROM dbt_edge
+         WHERE workspace_id = $1 AND job_id = '00000000-0000-0000-0000-000000000000'",
+        source_workspace_id,
+        target_workspace_id
+    )
+    .execute(&mut **tx)
+    .await?;
+    sqlx::query!(
+        "INSERT INTO dbt_graph_snapshot (workspace_id, script_path, script_hash, job_id,
+            digest, relation_root_at_last_ingest, ingested_at)
+         SELECT $2, script_path, script_hash, job_id, digest, relation_root_at_last_ingest,
+            ingested_at
+         FROM dbt_graph_snapshot
+         WHERE workspace_id = $1 AND job_id = '00000000-0000-0000-0000-000000000000'",
+        source_workspace_id,
+        target_workspace_id
+    )
+    .execute(&mut **tx)
+    .await?;
+    Ok(())
+}
+
 async fn clone_ci_test_references(
     tx: &mut Transaction<'_, Postgres>,
     source_workspace_id: &str,
diff --git a/backend/windmill-api-workspaces/src/workspaces_extra.rs b/backend/windmill-api-workspaces/src/workspaces_extra.rs
index 663626d5ed..13397b4c8d 100644
--- a/backend/windmill-api-workspaces/src/workspaces_extra.rs
+++ b/backend/windmill-api-workspaces/src/workspaces_extra.rs
@@ -108,7 +108,7 @@ pub(crate) async fn change_workspace_id(
     // Duplicate workspace settings (keep copy in old workspace for reference)
     info!("Duplicating workspace_settings table");
     sqlx::query!(
-        "INSERT INTO workspace_settings (workspace_id, slack_team_id, slack_name, slack_command_script, slack_email, customer_id, plan, webhook, ai_config, large_file_storage, git_sync, default_app, default_scripts, deploy_ui, mute_critical_alerts, color, operator_settings, teams_command_script, teams_team_id, teams_team_name, git_app_installations, ducklake, slack_oauth_client_id, slack_oauth_client_secret, datatable, teams_team_guid, auto_invite, error_handler, success_handler, public_app_execution_limit_per_minute, error_handler_fallback_to_instance_alerts) SELECT $1, slack_team_id, slack_name, slack_command_script, slack_email, customer_id, plan, webhook, ai_config, large_file_storage, git_sync, default_app, default_scripts, deploy_ui, mute_critical_alerts, color, operator_settings, teams_command_script, teams_team_id, teams_team_name, git_app_installations, ducklake, slack_oauth_client_id, slack_oauth_client_secret, datatable, teams_team_guid, auto_invite, error_handler, success_handler, public_app_execution_limit_per_minute, error_handler_fallback_to_instance_alerts FROM workspace_settings WHERE workspace_id = $2",
+        "INSERT INTO workspace_settings (workspace_id, slack_team_id, slack_name, slack_command_script, slack_email, customer_id, plan, webhook, ai_config, large_file_storage, git_sync, default_app, default_scripts, deploy_ui, mute_critical_alerts, color, operator_settings, teams_command_script, teams_team_id, teams_team_name, git_app_installations, ducklake, dbt_warehouses, slack_oauth_client_id, slack_oauth_client_secret, datatable, teams_team_guid, auto_invite, error_handler, success_handler, public_app_execution_limit_per_minute, error_handler_fallback_to_instance_alerts) SELECT $1, slack_team_id, slack_name, slack_command_script, slack_email, customer_id, plan, webhook, ai_config, large_file_storage, git_sync, default_app, default_scripts, deploy_ui, mute_critical_alerts, color, operator_settings, teams_command_script, teams_team_id, teams_team_name, git_app_installations, ducklake, dbt_warehouses, slack_oauth_client_id, slack_oauth_client_secret, datatable, teams_team_guid, auto_invite, error_handler, success_handler, public_app_execution_limit_per_minute, error_handler_fallback_to_instance_alerts FROM workspace_settings WHERE workspace_id = $2",
         &rw.new_id,
         &old_id
     )
@@ -743,6 +743,30 @@ pub(crate) async fn change_workspace_id(
     .execute(&mut *tx)
     .await?;
 
+    // The dbt graph tables key on (workspace_id, script_hash) and follow the
+    // script update by cascade. These two key on the JOB, so they follow the
+    // jobs that moved — only queued ones do — the way `job_perms` just did.
+    // Moving them wholesale would strand a completed run's retry state in a
+    // workspace its job is not in, which reads as "no resumable run".
+    info!("Updating dbt run state tables for migrated jobs");
+    sqlx::query!(
+        "UPDATE dbt_run_state SET workspace_id = $1
+         WHERE workspace_id = $2 AND job_id IN (SELECT id FROM v2_job WHERE workspace_id = $1)",
+        &rw.new_id,
+        &old_id
+    )
+    .execute(&mut *tx)
+    .await?;
+
+    sqlx::query!(
+        "UPDATE dbt_run_progress SET workspace_id = $1
+         WHERE workspace_id = $2 AND job_id IN (SELECT id FROM v2_job WHERE workspace_id = $1)",
+        &rw.new_id,
+        &old_id
+    )
+    .execute(&mut *tx)
+    .await?;
+
     info!("Updating token table");
     sqlx::query!(
         "UPDATE token SET workspace_id = $1 WHERE workspace_id = $2",
diff --git a/backend/windmill-api/build.rs b/backend/windmill-api/build.rs
index 768df207fb..59ac12bc2b 100644
--- a/backend/windmill-api/build.rs
+++ b/backend/windmill-api/build.rs
@@ -2,8 +2,8 @@ fn main() {
     // rust-embed requires the embedded folder to exist at compile time.
     // When building without a prior frontend build, create the directory
     // so the derive macro doesn't panic.
-    let dir = std::env::var("FRONTEND_BUILD_DIR")
-        .unwrap_or_else(|_| "../../frontend/build/".to_string());
+    let dir =
+        std::env::var("FRONTEND_BUILD_DIR").unwrap_or_else(|_| "../../frontend/build/".to_string());
     let path = std::path::Path::new(&dir);
     if !path.exists() {
         std::fs::create_dir_all(path).ok();
diff --git a/backend/windmill-api/openapi.yaml b/backend/windmill-api/openapi.yaml
index dbe4c867af..522d08e116 100644
--- a/backend/windmill-api/openapi.yaml
+++ b/backend/windmill-api/openapi.yaml
@@ -3688,6 +3688,8 @@ paths:
                     $ref: "#/components/schemas/LargeFileStorage"
                   ducklake:
                     $ref: "#/components/schemas/DucklakeSettings"
+                  dbt_warehouses:
+                    $ref: "#/components/schemas/DbtWarehouses"
                   datatable:
                     $ref: "#/components/schemas/DataTableSettings"
                   git_sync:
@@ -4514,6 +4516,112 @@ paths:
             application/json:
               schema: {}
 
+  /w/{workspace}/workspaces/edit_dbt_warehouses:
+    post:
+      summary: edit the workspace's dbt warehouses
+      operationId: editDbtWarehouses
+      tags:
+        - workspace
+      parameters:
+        - $ref: "#/components/parameters/WorkspaceId"
+      requestBody:
+        description: dbt warehouses, by name
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                dbt_warehouses:
+                  $ref: "#/components/schemas/DbtWarehouses"
+      responses:
+        "200":
+          description: status
+          content:
+            application/json:
+              schema: {}
+
+  /w/{workspace}/dbt/run_progress:
+    post:
+      summary: record the running job's settled dbt nodes
+      description: >-
+        Job-scoped: needs a job token, and the job is taken from the token rather
+        than the body. For workers with no database access.
+      operationId: recordDbtRunProgress
+      tags:
+        - dbt
+      parameters:
+        - $ref: "#/components/parameters/WorkspaceId"
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: array
+              items:
+                type: object
+                properties:
+                  asset_path:
+                    type: string
+                  status:
+                    type: string
+                  row_count:
+                    type: integer
+                  error:
+                    type: string
+                required:
+                  - asset_path
+                  - status
+      responses:
+        "200":
+          description: recorded
+
+  /w/{workspace}/dbt/warehouse/{name}:
+    get:
+      summary: resolve a dbt warehouse to the connection it names
+      description: >-
+        Job-scoped: needs a job token, because the response carries the
+        warehouse's credentials. dbt is unpermissioned by design, so a running
+        job reaches any warehouse the workspace configures.
+      operationId: getDbtWarehouse
+      tags:
+        - dbt
+      parameters:
+        - $ref: "#/components/parameters/WorkspaceId"
+        - name: name
+          in: path
+          required: true
+          schema:
+            type: string
+      responses:
+        "200":
+          description: the connection the warehouse names
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/DbtWarehouseConnection"
+
+  /w/{workspace}/dbt/warehouse_exists/{name}:
+    get:
+      summary: check that a dbt warehouse is configured, without resolving it
+      description: >-
+        Job-scoped: needs a job token. For a project bringing its own
+        `profiles.yml`, which names a warehouse only to say where its assets
+        belong and never opens the connection.
+      operationId: dbtWarehouseExists
+      tags:
+        - dbt
+      parameters:
+        - $ref: "#/components/parameters/WorkspaceId"
+        - name: name
+          in: path
+          required: true
+          schema:
+            type: string
+      responses:
+        "200":
+          description: the warehouse is configured
+
   /w/{workspace}/workspaces/list_ducklakes:
     get:
       summary: list ducklakes
@@ -14748,6 +14856,7 @@ paths:
                         - ducklake
                         - datatable
                         - volume
+                        - dbt
                     asset_path:
                       type: string
                     outcome:
@@ -14838,6 +14947,7 @@ paths:
                         - ducklake
                         - datatable
                         - volume
+                        - dbt
                     asset_path:
                       type: string
                     created_at:
@@ -22918,170 +23028,22 @@ paths:
           description: Scope the graph to runnables in a single folder
           schema:
             type: string
+        - name: dbt_script_hash
+          in: query
+          description: >
+            Render the dbt half of the graph as one version of a dbt script had
+            it, rather than as the currently deployed one. Given this, `folder`
+            no longer scopes the dbt nodes: the pinned version's own models and
+            lineage are the answer, including models a later deploy removed.
+          schema:
+            type: string
       responses:
         "200":
           description: asset graph nodes, lineage edges and trigger edges
           content:
             application/json:
               schema:
-                type: object
-                required: [assets, runnables, edges, triggers]
-                properties:
-                  assets:
-                    type: array
-                    items:
-                      type: object
-                      required: [kind, path]
-                      properties:
-                        kind:
-                          $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:
-                      type: object
-                      required: [path, usage_kind]
-                      properties:
-                        path:
-                          type: string
-                        usage_kind:
-                          $ref: "#/components/schemas/AssetUsageKind"
-                        in_pipeline:
-                          type: boolean
-                          description: True iff the script is a pipeline member (deployed with `// pipeline`). Omitted when false.
-                        macros:
-                          type: array
-                          description: Macros this script provides to the workspace registry (deployed `// macros` library). Omitted when empty.
-                          items:
-                            type: object
-                            required: [name, params, is_table]
-                            properties:
-                              name:
-                                type: string
-                              params:
-                                type: string
-                                description: verbatim parameter list
-                              is_table:
-                                type: boolean
-                  edges:
-                    type: array
-                    items:
-                      type: object
-                      required:
-                        [runnable_path, runnable_kind, asset_kind, asset_path]
-                      properties:
-                        runnable_path:
-                          type: string
-                        runnable_kind:
-                          $ref: "#/components/schemas/AssetUsageKind"
-                        asset_kind:
-                          $ref: "#/components/schemas/AssetKind"
-                        asset_path:
-                          type: string
-                        access_type:
-                          $ref: "#/components/schemas/AssetUsageAccessType"
-                  triggers:
-                    type: array
-                    items:
-                      oneOf:
-                        - type: object
-                          description: Asset trigger edge (`// on <asset>`)
-                          required:
-                            [
-                              trigger_kind,
-                              asset_kind,
-                              asset_path,
-                              runnable_kind,
-                              runnable_path,
-                            ]
-                          properties:
-                            trigger_kind:
-                              type: string
-                              enum: [asset]
-                            asset_kind:
-                              $ref: "#/components/schemas/AssetKind"
-                            asset_path:
-                              type: string
-                            runnable_kind:
-                              $ref: "#/components/schemas/AssetUsageKind"
-                            runnable_path:
-                              type: string
-                        - type: object
-                          description: Native trigger edge (schedule, email, kafka, ...). `path` is the trigger row's path.
-                          required:
-                            [trigger_kind, path, runnable_kind, runnable_path]
-                          properties:
-                            trigger_kind:
-                              type: string
-                              enum:
-                                - schedule
-                                - email
-                                - kafka
-                                - mqtt
-                                - nats
-                                - postgres
-                                - sqs
-                                - gcp
-                            path:
-                              type: string
-                            runnable_kind:
-                              $ref: "#/components/schemas/AssetUsageKind"
-                            runnable_path:
-                              type: string
-                  macro_edges:
-                    type: array
-                    description: Macro-library → consumer edges (deploy-recorded call detection plus `// use`). Omitted when empty.
-                    items:
-                      type: object
-                      required: [lib_path, consumer_path, macro_names, via_use]
-                      properties:
-                        lib_path:
-                          type: string
-                        consumer_path:
-                          type: string
-                        macro_names:
-                          type: array
-                          items:
-                            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
+                $ref: "#/components/schemas/AssetGraph"
 
   /w/{workspace}/assets/macros:
     get:
@@ -23167,6 +23129,144 @@ paths:
                 items:
                   $ref: "#/components/schemas/MaterializedPartition"
 
+  /w/{workspace}/jobs/dbt_resumable/{id}:
+    get:
+      summary: Whether a dbt retry by this caller would resume this run
+      description: >
+        One failed run is saved per script per execution principal, so a `retry`
+        resumes that one — not necessarily the run being looked at. Answers about
+        THIS run alone: its own id when a retry submitted by this caller would
+        resume it, null otherwise (a later run holds the state, the run left
+        nothing to rebuild, or the caller's runs execute as another principal).
+        Authorized through the job, like `run_progress`.
+      operationId: getDbtResumable
+      tags:
+        - job
+      parameters:
+        - $ref: "#/components/parameters/WorkspaceId"
+        - name: id
+          in: path
+          required: true
+          description: The job whose script and principal decide the saved failure
+          schema:
+            type: string
+            format: uuid
+      responses:
+        "200":
+          description: this job's id when a retry would resume it, or null
+          content:
+            application/json:
+              schema:
+                type: string
+                format: uuid
+                nullable: true
+
+  /w/{workspace}/jobs/dbt_resumable_script/p/{path}:
+    get:
+      summary: Which run a dbt retry of this script would resume for the caller
+      description: >
+        A `retry` requires `dbt_retry_job`, and the run form has no job id to
+        hand. Returns the one the caller's own retry would land on — the saved
+        failure for the principal the run would execute as, which is the script's
+        author for an `on_behalf_of` script and the caller otherwise — and only
+        when that run is one the caller may read. Null when there is nothing to
+        resume, or nothing this caller may be told about.
+      operationId: getDbtResumableForScript
+      tags:
+        - job
+      parameters:
+        - $ref: "#/components/parameters/WorkspaceId"
+        - $ref: "#/components/parameters/Path"
+      responses:
+        "200":
+          description: the job id a retry would resume, or null
+          content:
+            application/json:
+              schema:
+                type: string
+                format: uuid
+                nullable: true
+
+  /w/{workspace}/jobs/dbt_graph/{id}:
+    get:
+      summary: Get the asset graph as one run saw it
+      description: >
+        The workspace asset graph with its dbt half pinned to what a single run
+        built. Only a dynamic descriptor (a `{{ }}` placeholder in `vars`) leaves a
+        per-run snapshot; without one for this job the pinned version's own graph
+        answers, so a run page may use this route unconditionally. Authorized
+        through the job, the same gate as `run_progress` — pinning to a run is
+        job-scoped, which is why `assets/graph` cannot do it.
+      operationId: getDbtRunGraph
+      tags:
+        - job
+      parameters:
+        - $ref: "#/components/parameters/WorkspaceId"
+        - name: id
+          in: path
+          required: true
+          description: The job whose graph to render
+          schema:
+            type: string
+            format: uuid
+        - name: asset_kinds
+          in: query
+          description: Filter by asset kinds (comma-separated list)
+          schema:
+            type: string
+        - name: folder
+          in: query
+          description: Scope the graph to runnables in a single folder
+          schema:
+            type: string
+        - name: dbt_script_hash
+          in: query
+          description: >
+            Fallback only, for a job that names no deployed script — a preview or
+            a flow. For a script job the version comes from the job row itself,
+            so this is ignored: which deploy's models, SQL and `ref()` lineage
+            are shown is not the caller's to choose.
+          schema:
+            type: string
+      responses:
+        "200":
+          description: asset graph nodes, lineage edges and trigger edges
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/AssetGraph"
+
+  /w/{workspace}/jobs/run_progress/{id}:
+    get:
+      summary: List the per-relation progress one job has recorded so far
+      description: >
+        Live materialization state for the relations a single job writes, keyed by
+        relation. Polled while a run is in flight so a graph can move a node as its
+        model completes. Authorized through the job, so a caller who may not read it
+        is refused rather than told the run has no progress. An empty list means the
+        job exists and has recorded nothing yet, or is unknown to this workspace.
+      operationId: getRunProgress
+      tags:
+        - job
+      parameters:
+        - $ref: "#/components/parameters/WorkspaceId"
+        - name: id
+          in: path
+          required: true
+          description: The job whose per-relation progress to read
+          schema:
+            type: string
+            format: uuid
+      responses:
+        "200":
+          description: per-relation status for this run
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  $ref: "#/components/schemas/AssetProgress"
+
   /w/{workspace}/assets/partitions_in_range:
     get:
       summary: List expected partitions of a ducklake asset in a date range with their materialization status (enterprise)
@@ -24400,6 +24500,256 @@ components:
         enum: [script, flow]
 
   schemas:
+    AssetGraph:
+      type: object
+      required: [assets, runnables, edges, triggers]
+      properties:
+        assets:
+          type: array
+          items:
+            type: object
+            required: [kind, path]
+            properties:
+              kind:
+                $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.
+              dbt:
+                $ref: "#/components/schemas/DbtAssetProvenance"
+        runnables:
+          type: array
+          items:
+            type: object
+            required: [path, usage_kind]
+            properties:
+              path:
+                type: string
+              usage_kind:
+                $ref: "#/components/schemas/AssetUsageKind"
+              in_pipeline:
+                type: boolean
+                description: True iff the script is a pipeline member (deployed with `// pipeline`). Omitted when false.
+              macros:
+                type: array
+                description: Macros this script provides to the workspace registry (deployed `// macros` library). Omitted when empty.
+                items:
+                  type: object
+                  required: [name, params, is_table]
+                  properties:
+                    name:
+                      type: string
+                    params:
+                      type: string
+                      description: verbatim parameter list
+                    is_table:
+                      type: boolean
+              dbt:
+                type: object
+                description: Set on a `dbt` script, which owns a whole project rather than a single output. Omitted otherwise.
+                required: [model_count]
+                properties:
+                  model_count:
+                    type: integer
+        edges:
+          type: array
+          items:
+            type: object
+            required:
+              [runnable_path, runnable_kind, asset_kind, asset_path]
+            properties:
+              runnable_path:
+                type: string
+              runnable_kind:
+                $ref: "#/components/schemas/AssetUsageKind"
+              asset_kind:
+                $ref: "#/components/schemas/AssetKind"
+              asset_path:
+                type: string
+              access_type:
+                $ref: "#/components/schemas/AssetUsageAccessType"
+        triggers:
+          type: array
+          items:
+            oneOf:
+              - type: object
+                description: Asset trigger edge (`// on <asset>`)
+                required:
+                  [
+                    trigger_kind,
+                    asset_kind,
+                    asset_path,
+                    runnable_kind,
+                    runnable_path,
+                  ]
+                properties:
+                  trigger_kind:
+                    type: string
+                    enum: [asset]
+                  asset_kind:
+                    $ref: "#/components/schemas/AssetKind"
+                  asset_path:
+                    type: string
+                  runnable_kind:
+                    $ref: "#/components/schemas/AssetUsageKind"
+                  runnable_path:
+                    type: string
+              - type: object
+                description: Native trigger edge (schedule, email, kafka, ...). `path` is the trigger row's path.
+                required:
+                  [trigger_kind, path, runnable_kind, runnable_path]
+                properties:
+                  trigger_kind:
+                    type: string
+                    enum:
+                      - schedule
+                      - email
+                      - kafka
+                      - mqtt
+                      - nats
+                      - postgres
+                      - sqs
+                      - gcp
+                  path:
+                    type: string
+                  runnable_kind:
+                    $ref: "#/components/schemas/AssetUsageKind"
+                  runnable_path:
+                    type: string
+        macro_edges:
+          type: array
+          description: Macro-library → consumer edges (deploy-recorded call detection plus `// use`). Omitted when empty.
+          items:
+            type: object
+            required: [lib_path, consumer_path, macro_names, via_use]
+            properties:
+              lib_path:
+                type: string
+              consumer_path:
+                type: string
+              macro_names:
+                type: array
+                items:
+                  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
+        dbt_edges:
+          type: array
+          description: >-
+            `ref()` lineage BETWEEN two dbt models, in the terms the canvas draws
+            — the relations, not dbt's node ids. Without it every model hangs off
+            the one dbt runnable and the project reads as a flat fan-out.
+            Omitted when empty.
+          items:
+            type: object
+            required: [from_asset_path, to_asset_path]
+            properties:
+              from_asset_path:
+                type: string
+              to_asset_path:
+                type: string
+        dbt_snapshot_job:
+          type: string
+          format: uuid
+          description: >-
+            The job whose own snapshot the dbt half was resolved from, when one
+            was asked for and found. A run page polls the graph while its job
+            runs, because a dynamic descriptor's snapshot is written mid-run, and
+            this is what tells it to stop. Omitted when the answer came from the
+            version's deployed graph.
+    DbtAssetProvenance:
+      type: object
+      description: >-
+        What dbt says about the model, snapshot, seed or source that produces (or,
+        for a source, is read at) this relation. A dbt project is one runnable
+        node with many model assets, so per-model metadata belongs here rather
+        than on the script.
+      required: [unique_id, resource_type]
+      properties:
+        unique_id:
+          type: string
+          description: dbt's own node id, e.g. `model.jaffle_shop.customers`.
+        resource_type:
+          type: string
+          enum: [model, snapshot, seed, source]
+        materialized:
+          type: string
+          description: dbt's own word (`table`, `view`, `incremental`, `snapshot`).
+        materialize_strategy:
+          type: string
+          description: The Windmill write strategy it maps to, absent for `view` and `ephemeral`, which have none.
+        tags:
+          type: array
+          items:
+            type: string
+        description:
+          type: string
+        data_tests:
+          type: array
+          items:
+            type: object
+            required: [kind]
+            properties:
+              kind:
+                type: string
+                description: One of the four generic tests, or a package test's namespaced name (`dbt_utils.accepted_range`).
+              column:
+                type: string
+              args:
+                type: object
+                additionalProperties: true
+              severity:
+                type: string
+                description: Lowercased. dbt's severity decides whether a failure fails the run.
+        columns:
+          type: object
+          additionalProperties: true
+          description: Declared column metadata (name -> description). NOT column lineage — `manifest.json` carries none.
+        freshness:
+          type: object
+          additionalProperties: true
+          description: A source's declared freshness policy, for the staleness chip.
+        raw_code:
+          type: string
+          description: The model's SQL as written, at the deploy this graph belongs to. Omitted when the caller cannot read the script.
+        original_file_path:
+          type: string
+          description: Its path inside the dbt project, e.g. `models/staging/stg_orders.sql`.
     # NOTE: Not so many generators and validators support this format:
     # $ref: "../../openflow.openapi.yaml#/components/schemas"
     # This is why it is better to inline each of schemas for better compat
@@ -27086,6 +27436,7 @@ components:
           rlang,
           duckdb,
           bunnative,
+          dbt,
           # for related places search: ADD_NEW_LANG
         ]
 
@@ -31210,6 +31561,32 @@ components:
       required:
         - region_name
 
+    DbtWarehouses:
+      type: object
+      description: >-
+        Warehouses a dbt project may run against, by name. `main` is the one a
+        project gets when its descriptor names none. Each entry points at a
+        resource; it never holds credentials.
+      additionalProperties:
+        type: object
+        properties:
+          resource_path:
+            type: string
+          target:
+            type: string
+        required:
+          - resource_path
+
+    DbtWarehouseConnection:
+      type: object
+      properties:
+        value:
+          description: the resolved resource, rendered into profiles.yml
+        target:
+          type: string
+      required:
+        - value
+
     LargeFileStorage:
       type: object
       properties:
@@ -32373,6 +32750,26 @@ components:
         - ducklake
         - datatable
         - volume
+        - dbt
+    AssetProgress:
+      type: object
+      required: [asset_kind, asset_path, status]
+      properties:
+        asset_kind:
+          $ref: "#/components/schemas/AssetKind"
+        asset_path:
+          type: string
+        status:
+          type: string
+          enum: [running, materialized, failed]
+        row_count:
+          type: integer
+          format: int64
+          nullable: true
+        error:
+          type: string
+          nullable: true
+
     MaterializedPartition:
       type: object
       required: [asset_kind, asset_path, partition, status, materialized_at]
diff --git a/backend/windmill-api/src/ai_skills.rs b/backend/windmill-api/src/ai_skills.rs
index 6deb8dc58f..11d99d55da 100644
--- a/backend/windmill-api/src/ai_skills.rs
+++ b/backend/windmill-api/src/ai_skills.rs
@@ -7,13 +7,13 @@
  */
 
 use crate::db::{ApiAuthed, DB};
-use std::collections::HashSet;
 use axum::{
     extract::{Extension, Json, Path},
     routing::{delete, get, post},
     Router,
 };
 use serde::{Deserialize, Serialize};
+use std::collections::HashSet;
 use windmill_audit::audit_oss::audit_log;
 use windmill_audit::ActionKind;
 use windmill_common::{
diff --git a/backend/windmill-api/src/dbt.rs b/backend/windmill-api/src/dbt.rs
new file mode 100644
index 0000000000..8891834c2f
--- /dev/null
+++ b/backend/windmill-api/src/dbt.rs
@@ -0,0 +1,211 @@
+use axum::{
+    extract::Path,
+    routing::{get, post},
+    Extension, Json, Router,
+};
+use windmill_common::{
+    db::UserDB,
+    error::{Error, Result},
+    workspaces::{dbt_warehouse_resource, DbtWarehouseConnection},
+    DB,
+};
+
+use crate::db::{ApiAuthed, OptJobAuthed};
+use windmill_api_auth::{is_no_auth, Tokened};
+
+pub fn workspaced_service() -> Router {
+    Router::new()
+        .route("/warehouse/{name}", get(get_warehouse))
+        .route("/warehouse_exists/{name}", get(warehouse_exists))
+        .route("/run_progress", post(record_run_progress))
+}
+
+async fn get_warehouse(
+    OptJobAuthed { job_id, authed }: OptJobAuthed,
+    Tokened { token }: Tokened,
+    Extension(db): Extension<DB>,
+    Extension(_user_db): Extension<UserDB>,
+    Path((w_id, name)): Path<(String, String)>,
+) -> Result<Json<DbtWarehouseConnection>> {
+    // Scoped to a running DBT job, and the reason it must stay that way: the
+    // response carries the warehouse's credentials. A dbt job already holds them
+    // in its rendered `profiles.yml`, so serving them changes nothing for it —
+    // but every script job's token carries a job id too, and any other language
+    // asking for them would be reading a credential it was never given.
+    // In no-auth mode every request is the synthetic superadmin and carries no
+    // job, so the scoping below has nothing to check. Refusing there would make
+    // dbt unusable on an instance that has deliberately turned auth off, and
+    // there is no credential boundary left to protect.
+    let Some(job_id) = job_id else {
+        if is_no_auth() {
+            // Validated here too, so all three paths agree on what a name may be
+            // rather than one of them accepting whatever the URL carried.
+            windmill_common::workspaces::validate_dbt_warehouse_name(&name)?;
+            let (resource_path, target) = dbt_warehouse_resource(&db, &w_id, &name).await?;
+            let value = windmill_store::resources::get_resource_value_interpolated_internal(
+                &windmill_common::db::DbWithOptAuthed::<ApiAuthed>::from_authed(
+                    &authed,
+                    db.clone(),
+                    None,
+                ),
+                &w_id,
+                &resource_path,
+                None,
+                Some(&token),
+                false,
+            )
+            .await?
+            .ok_or_else(|| {
+                Error::NotFound(format!(
+                    "the dbt warehouse `{name}` points at `{resource_path}`, which does not exist"
+                ))
+            })?;
+            return Ok(Json(DbtWarehouseConnection { value, target }));
+        }
+        return Err(Error::BadRequest(
+            "this route resolves a dbt warehouse for a running job and needs a job token"
+                .to_string(),
+        ));
+    };
+    let is_dbt = sqlx::query_scalar!(
+        "SELECT script_lang = 'dbt' FROM v2_job WHERE id = $1 AND workspace_id = $2",
+        job_id,
+        &w_id
+    )
+    .fetch_optional(&db)
+    .await?
+    .flatten()
+    .unwrap_or(false);
+    if !is_dbt {
+        return Err(Error::NotAuthorized(
+            "only a dbt job may resolve a dbt warehouse".to_string(),
+        ));
+    }
+    windmill_common::workspaces::validate_dbt_warehouse_name(&name)?;
+    let (resource_path, target) = dbt_warehouse_resource(&db, &w_id, &name).await?;
+    // Interpolated AGAINST THE JOB, so a warehouse whose resource carries
+    // `$WM_TOKEN` or another `$WM_*` renders what the job would see rather than
+    // the literal placeholder. Unchecked (no `user_db`) because dbt warehouses
+    // are unpermissioned by design; uncached because a job-context value must
+    // not be served to the next job.
+    let value = windmill_store::resources::get_resource_value_interpolated_internal(
+        &windmill_common::db::DbWithOptAuthed::<ApiAuthed>::from_authed(&authed, db.clone(), None),
+        &w_id,
+        &resource_path,
+        Some(job_id),
+        Some(&token),
+        false,
+    )
+    .await?
+    .ok_or_else(|| {
+        Error::NotFound(format!(
+            "the dbt warehouse `{name}` points at `{resource_path}`, which does not exist"
+        ))
+    })?;
+    Ok(Json(DbtWarehouseConnection { value, target }))
+}
+
+/// A settled node's state, for a worker that cannot write the database.
+///
+/// The job is taken from the TOKEN, never the body: a job may report its own
+/// progress and no one else's.
+///
+/// NO no-auth branch, unlike its two siblings: they need only the warehouse
+/// NAME, which the URL carries, while this needs the job — and the job lives in
+/// the token's JWT claims, which the no-auth path never decodes. So on a
+/// no-auth instance an agent worker's per-model rows do not appear. The run is
+/// unaffected: the worker treats a failed post as a display problem and builds
+/// the models regardless. Taking the job from the body instead would hand any
+/// caller another job's run page.
+async fn record_run_progress(
+    OptJobAuthed { job_id, .. }: OptJobAuthed,
+    Extension(db): Extension<DB>,
+    Path(w_id): Path<String>,
+    Json(rows): Json<Vec<windmill_common::dbt_manifest::DbtRunProgressRequest>>,
+) -> Result<()> {
+    let Some(job_id) = job_id else {
+        return Err(Error::BadRequest(
+            "this route records a running job's dbt progress and needs a job token".to_string(),
+        ));
+    };
+    // A DBT job's, like its sibling above. Writing nothing secret, but a row
+    // keyed to another language's job is a run-page entry for a run that has no
+    // models, and the two routes disagreeing on who may call them is how one of
+    // them ends up wrong later.
+    let is_dbt = sqlx::query_scalar!(
+        "SELECT script_lang = 'dbt' FROM v2_job WHERE id = $1 AND workspace_id = $2",
+        job_id,
+        &w_id
+    )
+    .fetch_optional(&db)
+    .await?
+    .flatten()
+    .unwrap_or(false);
+    if !is_dbt {
+        return Err(Error::NotAuthorized(
+            "only a dbt job may record dbt run progress".to_string(),
+        ));
+    }
+    // The agent's own sweep: these rows have no job foreign key, and the
+    // worker-side prune runs only where the pool is reachable, so an
+    // agent-only workspace would accumulate one row per model forever.
+    windmill_common::dbt_manifest::prune_run_progress(&db, &w_id).await;
+    // A run's nodes arrive together; the writes are local to this server, so the
+    // loop that would have been a round trip each is a statement each.
+    for req in &rows {
+        windmill_common::dbt_manifest::record_run_progress(
+            &db,
+            &w_id,
+            &job_id,
+            &req.asset_path,
+            req.status,
+            req.row_count,
+            req.error.as_deref(),
+        )
+        .await;
+    }
+    Ok(())
+}
+
+/// Whether the workspace configures this warehouse. NOTHING is resolved.
+///
+/// A project that brings its own `profiles.yml` names a warehouse to say where
+/// its assets belong and never opens it, so the answer it needs is a yes/no —
+/// decrypting a connection for that would hand out a credential the run has no
+/// use for.
+async fn warehouse_exists(
+    OptJobAuthed { job_id, .. }: OptJobAuthed,
+    Extension(db): Extension<DB>,
+    Path((w_id, name)): Path<(String, String)>,
+) -> Result<()> {
+    // A DBT job's token, like both siblings. No-auth mode carries no job at all,
+    // and there the whole instance is unauthenticated.
+    if !is_no_auth() {
+        let Some(job_id) = job_id else {
+            return Err(Error::BadRequest(
+                "this route answers for a running job and needs a job token".to_string(),
+            ));
+        };
+        let is_dbt = sqlx::query_scalar!(
+            "SELECT script_lang = 'dbt' FROM v2_job WHERE id = $1 AND workspace_id = $2",
+            job_id,
+            &w_id
+        )
+        .fetch_optional(&db)
+        .await?
+        .flatten()
+        .unwrap_or(false);
+        if !is_dbt {
+            return Err(Error::NotAuthorized(
+                "only a dbt job may ask about a dbt warehouse".to_string(),
+            ));
+        }
+    }
+    windmill_common::workspaces::validate_dbt_warehouse_name(&name)?;
+    // Mapped to a bare yes/no: the resolver's miss lists every warehouse the
+    // workspace configures, which is a useful hint to an admin editing settings
+    // and a needless disclosure to a job that only asked about one name.
+    windmill_common::workspaces::dbt_warehouse_exists(&db, &w_id, &name)
+        .await
+        .map_err(|_| Error::NotFound(format!("no dbt warehouse named `{name}` in this workspace")))
+}
diff --git a/backend/windmill-api/src/jobs.rs b/backend/windmill-api/src/jobs.rs
index e21d196aca..13b02837ac 100644
--- a/backend/windmill-api/src/jobs.rs
+++ b/backend/windmill-api/src/jobs.rs
@@ -134,6 +134,13 @@ pub fn workspaced_service() -> Router {
         ServiceBuilder::new().layer(axum::middleware::from_fn(add_webhook_allowed_origin));
 
     Router::new()
+        .route("/run_progress/{id}", get(get_run_progress))
+        .route("/dbt_graph/{id}", get(get_dbt_run_graph))
+        .route("/dbt_resumable/{id}", get(get_dbt_resumable))
+        .route(
+            "/dbt_resumable_script/p/{*script_path}",
+            get(get_dbt_resumable_for_script),
+        )
         .route(
             "/run/f/{*script_path}",
             post(run_flow_by_path)
@@ -805,6 +812,315 @@ async fn get_scheduled_for(
     Ok(Json(scheduled_for.timestamp_millis()))
 }
 
+/// Per-relation progress of one job, for a graph that moves while it runs.
+///
+/// The worker records these as it goes -- `running` when a model starts,
+/// `materialized` or `failed` when it ends -- but nothing rendered them: the
+/// asset graph carries a relation's identity, not what a particular run is doing
+/// to it. A retry rewrites the same rows, so a node moves back to `running` and
+/// on to its new outcome without anything extra here.
+#[derive(Serialize, Debug)]
+struct AssetProgress {
+    asset_kind: windmill_common::assets::AssetKind,
+    asset_path: String,
+    status: String,
+    row_count: Option<i64>,
+    error: Option<String>,
+}
+
+/// The asset graph as one run saw it. Pinning to a job needs the full job-read
+/// contract, so it lives on `require_job_read_access` here rather than as a
+/// parameter on `/assets/graph`. See docs/dbt-runtime.md.
+async fn get_dbt_run_graph(
+    authed: ApiAuthed,
+    OptViewToken(view_token): OptViewToken,
+    Extension(db): Extension<DB>,
+    Extension(user_db): Extension<UserDB>,
+    Path((w_id, job_id)): Path<(String, Uuid)>,
+    Query(q): Query<windmill_api_assets::GraphQuery>,
+) -> error::JsonResult<windmill_api_assets::AssetGraphResponse> {
+    // The scope domain comes from the URL segment, so `/jobs` asks a scoped token
+    // for `jobs:read` alone while the body returned is asset data. Both are
+    // required: the job gate below reaches this run, this reaches assets at all.
+    check_scopes(&authed, || "assets:read".to_string())?;
+    let job = sqlx::query!(
+        "SELECT created_by, runnable_path,
+                CASE WHEN kind = 'script' THEN runnable_id END AS script_hash
+           FROM v2_job WHERE id = $1 AND workspace_id = $2",
+        job_id,
+        &w_id
+    )
+    .fetch_optional(&db)
+    .await?;
+    // No such job: answer the unpinned graph rather than 404, so a run page whose
+    // job has aged out of retention still draws the deployed version instead of
+    // an error. Reachable only with `assets:read`, which is exactly what
+    // `/assets/graph` would have cost for the same answer.
+    let Some(job) = job else {
+        return windmill_api_assets::asset_graph_for(&authed, &w_id, user_db, db, q, None).await;
+    };
+    require_job_read_access(
+        &db,
+        &user_db,
+        &authed,
+        &w_id,
+        &job_id,
+        &job.created_by,
+        view_token.as_deref(),
+    )
+    .await?;
+    // A preview or flow job names no deployed version, so there is no graph to
+    // pin to and the workspace one answers.
+    let pinned =
+        job.runnable_path
+            .zip(job.script_hash)
+            .map(|(path, hash)| windmill_api_assets::PinnedRun {
+                job_id,
+                script_path: path,
+                script_hash: hash,
+            });
+    windmill_api_assets::asset_graph_for(&authed, &w_id, user_db, db, q, pinned).await
+}
+
+/// Whether a `dbt retry` submitted by this caller would resume THIS run.
+///
+/// One failure is saved per script per execution principal, so a page showing an
+/// older failed run cannot tell whether resuming would reach it or a later one —
+/// and offering it there would submit a retry the worker refuses. Answers about
+/// this run alone: the id when it is the one, `null` otherwise, so no other run's
+/// id leaves through a page that only needs a yes or no.
+async fn get_dbt_resumable(
+    authed: ApiAuthed,
+    OptViewToken(view_token): OptViewToken,
+    Extension(db): Extension<DB>,
+    Extension(user_db): Extension<UserDB>,
+    Path((w_id, job_id)): Path<(String, Uuid)>,
+) -> error::JsonResult<Option<Uuid>> {
+    let Some(job) = sqlx::query!(
+        "SELECT created_by, runnable_path FROM v2_job
+          WHERE id = $1 AND workspace_id = $2",
+        job_id,
+        &w_id
+    )
+    .fetch_optional(&db)
+    .await?
+    else {
+        return Ok(Json(None));
+    };
+    require_job_read_access(
+        &db,
+        &user_db,
+        &authed,
+        &w_id,
+        &job_id,
+        &job.created_by,
+        view_token.as_deref(),
+    )
+    .await?;
+    let Some(script_path) = job.runnable_path else {
+        return Ok(Json(None));
+    };
+    // The CALLER's principal, not the one this run executed as: a retry is a new
+    // job submitted by whoever is reading, so a run of Alice's that Bob may read
+    // is not one Bob's retry could resume.
+    let Some(permissioned_as) = dbt_retry_principal(&user_db, &authed, &w_id, &script_path).await?
+    else {
+        return Ok(Json(None));
+    };
+    let resumable = resumable_run(&db, &w_id, &script_path, &permissioned_as).await?;
+    Ok(Json(resumable.filter(|id| *id == job_id)))
+}
+
+/// Which run a `dbt retry` of this SCRIPT would resume for this caller, if any.
+///
+/// The run form asks: `dbt_retry_job` is required for a retry and a job id is not
+/// something to type from memory.
+async fn get_dbt_resumable_for_script(
+    authed: ApiAuthed,
+    Extension(db): Extension<DB>,
+    Extension(user_db): Extension<UserDB>,
+    Path((w_id, script_path)): Path<(String, StripPath)>,
+) -> error::JsonResult<Option<Uuid>> {
+    // The cutoff `require_job_read_access` applies for the sibling routes, which
+    // this one cannot reach through: user-authored app JS holds an app-embed
+    // token, confined to the jobs it launched, and this answers with a job id.
+    if windmill_api_auth::scopes::has_app_embed_sentinel(authed.scopes.as_deref()) {
+        return Ok(Json(None));
+    }
+    let path = script_path.to_path();
+    let Some(permissioned_as) = dbt_retry_principal(&user_db, &authed, &w_id, path).await? else {
+        return Ok(Json(None));
+    };
+    let Some(job_id) = resumable_run(&db, &w_id, path, &permissioned_as).await? else {
+        return Ok(Json(None));
+    };
+    // Only a run this caller may READ. Everyone running an `on_behalf_of` script
+    // shares one principal, so the saved failure can be a run of the owner's that
+    // this caller cannot open — and answering with its id would be this endpoint
+    // handing over what to resume, when resuming republishes that run's
+    // arguments. Whoever can read the run keeps the prefill, which is the case
+    // the form exists for.
+    let Some(created_by) = sqlx::query_scalar!(
+        "SELECT created_by FROM v2_job WHERE id = $1 AND workspace_id = $2",
+        job_id,
+        &w_id
+    )
+    .fetch_optional(&db)
+    .await?
+    else {
+        return Ok(Json(None));
+    };
+    if require_job_read_access(&db, &user_db, &authed, &w_id, &job_id, &created_by, None)
+        .await
+        .is_err()
+    {
+        return Ok(Json(None));
+    }
+    Ok(Json(Some(job_id)))
+}
+
+/// The identity a run of this script submitted by this caller would execute as,
+/// which is the key `dbt_run_state` is saved under — the author for an
+/// `on_behalf_of` script and the caller otherwise, the same choice
+/// `run_script_by_path` makes. `None` when the caller cannot see the script.
+async fn dbt_retry_principal(
+    user_db: &UserDB,
+    authed: &ApiAuthed,
+    w_id: &str,
+    path: &str,
+) -> error::Result<Option<String>> {
+    // Through the user db: which of a script's runs you could resume is for
+    // whoever can see the script.
+    let mut tx = user_db.clone().begin(authed).await?;
+    let script = sqlx::query!(
+        "SELECT created_by, on_behalf_of_email FROM script
+          WHERE path = $1 AND workspace_id = $2 AND archived = false AND deleted = false
+          ORDER BY created_at DESC LIMIT 1",
+        path,
+        w_id
+    )
+    .fetch_optional(&mut *tx)
+    .await?;
+    tx.commit().await?;
+    Ok(script.map(|s| {
+        if s.on_behalf_of_email.is_some() {
+            username_to_permissioned_as(&s.created_by)
+        } else {
+            username_to_permissioned_as(&authed.username)
+        }
+    }))
+}
+
+/// The saved failure for this script and principal, when there is one to resume.
+/// A run that left nothing retryable is saved too — so a retry can say the run
+/// succeeded rather than that nothing is saved — but it is not resumable.
+async fn resumable_run(
+    db: &DB,
+    w_id: &str,
+    path: &str,
+    permissioned_as: &str,
+) -> error::Result<Option<Uuid>> {
+    Ok(sqlx::query_scalar!(
+        "SELECT job_id FROM dbt_run_state
+          WHERE workspace_id = $1 AND script_path = $2 AND permissioned_as = $3 AND retryable",
+        w_id,
+        path,
+        permissioned_as
+    )
+    .fetch_optional(db)
+    .await?
+    .flatten())
+}
+
+/// Lives with the job routes, not the asset ones, because it is job-scoped and
+/// `require_job_read_access` is what gates it: `materialized_partition` has no
+/// RLS, and RLS alone would not enforce a scoped token's tag filter or the
+/// app-embed cutoff, which that helper adds on top.
+async fn get_run_progress(
+    authed: ApiAuthed,
+    // A shared run page carries its access in this token, not in the caller's
+    // own grants: without it a share-link viewer gets the graph and is refused
+    // the progress that colours it.
+    OptViewToken(view_token): OptViewToken,
+    Extension(db): Extension<DB>,
+    Extension(user_db): Extension<UserDB>,
+    Path((w_id, job_id)): Path<(String, Uuid)>,
+) -> error::JsonResult<Vec<AssetProgress>> {
+    let created_by = sqlx::query_scalar!(
+        "SELECT created_by FROM v2_job WHERE id = $1 AND workspace_id = $2",
+        job_id,
+        &w_id
+    )
+    .fetch_optional(&db)
+    .await?;
+    let Some(created_by) = created_by else {
+        return Ok(Json(vec![]));
+    };
+    require_job_read_access(
+        &db,
+        &user_db,
+        &authed,
+        &w_id,
+        &job_id,
+        &created_by,
+        view_token.as_deref(),
+    )
+    .await?;
+    let mut tx = user_db.begin(&authed).await?;
+    // `dbt_run_progress`, not `materialized_partition`: the latter is keyed by
+    // relation and its `job_id` names only the last writer, so two runs of one
+    // project building the same models would take rows from each other and this
+    // response would lose nodes.
+    let rows = sqlx::query!(
+        "SELECT asset_kind AS \"asset_kind: windmill_common::assets::AssetKind\", asset_path,
+                status::text AS \"status!\", row_count, error
+           FROM dbt_run_progress
+          WHERE workspace_id = $1 AND job_id = $2",
+        w_id,
+        job_id
+    )
+    .fetch_all(&mut *tx)
+    .await?;
+    // An agent worker reaches the database only through the API, and records its
+    // outcomes with the shared `record_materialization`, which writes the
+    // relation-keyed table alone. Falling back to it there keeps those runs
+    // showing progress; it is the racy source, but an agent run that has no rows
+    // of its own is strictly better served by it than by nothing.
+    let rows = if rows.is_empty() {
+        sqlx::query!(
+            "SELECT asset_kind AS \"asset_kind: windmill_common::assets::AssetKind\", asset_path,
+                    status::text AS \"status!\", row_count, error
+               FROM materialized_partition
+              WHERE workspace_id = $1 AND job_id = $2",
+            w_id,
+            job_id
+        )
+        .fetch_all(&mut *tx)
+        .await?
+        .into_iter()
+        .map(|r| AssetProgress {
+            asset_kind: r.asset_kind,
+            asset_path: r.asset_path,
+            status: r.status,
+            row_count: r.row_count,
+            error: r.error,
+        })
+        .collect::<Vec<_>>()
+    } else {
+        rows.into_iter()
+            .map(|r| AssetProgress {
+                asset_kind: r.asset_kind,
+                asset_path: r.asset_path,
+                status: r.status,
+                row_count: r.row_count,
+                error: r.error,
+            })
+            .collect::<Vec<_>>()
+    };
+    tx.commit().await?;
+    Ok(Json(rows))
+}
+
 async fn get_flow_job_debug_info(
     OptViewToken(view_token): OptViewToken,
     OptAuthed(opt_authed): OptAuthed,
diff --git a/backend/windmill-api/src/lib.rs b/backend/windmill-api/src/lib.rs
index fdac9b27ad..2cc3c00283 100644
--- a/backend/windmill-api/src/lib.rs
+++ b/backend/windmill-api/src/lib.rs
@@ -79,6 +79,7 @@ mod capture;
 mod concurrency_groups;
 mod db;
 mod db_health;
+mod dbt;
 mod docs;
 mod drafts;
 
@@ -570,6 +571,7 @@ pub async fn run_server(
                             "/concurrency_groups",
                             concurrency_groups::workspaced_service(),
                         )
+                        .nest("/dbt", dbt::workspaced_service())
                         .nest("/drafts", drafts::workspaced_service())
                         .nest("/embeddings", embeddings::workspaced_service())
                         .nest("/favorites", favorite::workspaced_service())
diff --git a/backend/windmill-api/src/mcp/auto_generated_endpoints.rs b/backend/windmill-api/src/mcp/auto_generated_endpoints.rs
index 71becbf9c3..762140c981 100644
--- a/backend/windmill-api/src/mcp/auto_generated_endpoints.rs
+++ b/backend/windmill-api/src/mcp/auto_generated_endpoints.rs
@@ -701,7 +701,7 @@ Creates a new version of an existing script when called with the same path and t
                 },
                 "language": {
                         "type": "string",
-                        "description": "Possible values: python3, deno, go, bash, powershell, postgresql, mysql, bigquery, snowflake, mssql, oracledb, graphql, nativets, bun, php, rust, ansible, csharp, nu, java, ruby, rlang, duckdb, bunnative"
+                        "description": "Possible values: python3, deno, go, bash, powershell, postgresql, mysql, bigquery, snowflake, mssql, oracledb, graphql, nativets, bun, php, rust, ansible, csharp, nu, java, ruby, rlang, duckdb, bunnative, dbt"
                 },
                 "kind": {
                         "type": "string",
@@ -1210,7 +1210,7 @@ Creates a new version of an existing script when called with the same path and t
                 },
                 "language": {
                         "type": "string",
-                        "description": "Possible values: python3, deno, go, bash, powershell, postgresql, mysql, bigquery, snowflake, mssql, oracledb, graphql, nativets, bun, php, rust, ansible, csharp, nu, java, ruby, rlang, duckdb, bunnative"
+                        "description": "Possible values: python3, deno, go, bash, powershell, postgresql, mysql, bigquery, snowflake, mssql, oracledb, graphql, nativets, bun, php, rust, ansible, csharp, nu, java, ruby, rlang, duckdb, bunnative, dbt"
                 },
                 "tag": {
                         "type": "string"
@@ -1242,7 +1242,7 @@ Creates a new version of an existing script when called with the same path and t
                                         },
                                         "language": {
                                                 "type": "string",
-                                                "description": "Possible values: python3, deno, go, bash, powershell, postgresql, mysql, bigquery, snowflake, mssql, oracledb, graphql, nativets, bun, php, rust, ansible, csharp, nu, java, ruby, rlang, duckdb, bunnative"
+                                                "description": "Possible values: python3, deno, go, bash, powershell, postgresql, mysql, bigquery, snowflake, mssql, oracledb, graphql, nativets, bun, php, rust, ansible, csharp, nu, java, ruby, rlang, duckdb, bunnative, dbt"
                                         },
                                         "lock": {
                                                 "type": "string",
diff --git a/backend/windmill-api/src/workspaces_export.rs b/backend/windmill-api/src/workspaces_export.rs
index 968a752af5..41a4ac31f7 100644
--- a/backend/windmill-api/src/workspaces_export.rs
+++ b/backend/windmill-api/src/workspaces_export.rs
@@ -740,11 +740,30 @@ pub(crate) async fn tarball_workspace(
                 ScriptLang::Java => "java",
                 ScriptLang::Ruby => "rb",
                 ScriptLang::Rlang => "r",
+                // A dbt script's content path is not `<path>.<ext>` — it is the
+                // descriptor inside the project folder, built below.
+                ScriptLang::Dbt => "",
                 // for related places search: ADD_NEW_LANG
             };
-            archive
-                .write_to_archive(&script.content, &format!("{}.{}", script.path, ext))
-                .await?;
+            if script.language == ScriptLang::Dbt {
+                // The descriptor belongs inside the project it configures, and
+                // is OPTIONAL: an unmodified dbt project is already a complete
+                // script. Writing an empty one would put a Windmill file in a
+                // directory that had none, so a project that names no descriptor
+                // exports without one.
+                if !script.content.trim().is_empty() {
+                    archive
+                        .write_to_archive(
+                            &script.content,
+                            &format!("{}__dbt/wm_dbt.yaml", script.path),
+                        )
+                        .await?;
+                }
+            } else {
+                archive
+                    .write_to_archive(&script.content, &format!("{}.{}", script.path, ext))
+                    .await?;
+            }
 
             let metadata = ScriptMetadata {
                 summary: script.summary,
diff --git a/backend/windmill-common/src/assets.rs b/backend/windmill-common/src/assets.rs
index d6a4156f38..117b41632a 100644
--- a/backend/windmill-common/src/assets.rs
+++ b/backend/windmill-common/src/assets.rs
@@ -175,6 +175,10 @@ fn is_write_access(access: Option<AssetUsageAccessType>) -> bool {
 /// producers). Resource / datatable / volume reads stay explicit-`// on`:
 /// a config/lookup read cascading is more often surprising than wanted.
 fn is_auto_trigger_kind(kind: AssetKind) -> bool {
+    // `Dbt` is deliberately NOT here. dbt is the only thing that can produce a
+    // warehouse relation (`// materialize` takes DuckLake targets only) and a dbt
+    // run does not dispatch, so a derived `dbt://` edge could never fire — it
+    // would draw a cascade arrow into a script nothing can wake.
     matches!(kind, AssetKind::Ducklake | AssetKind::S3Object)
 }
 
@@ -647,6 +651,7 @@ pub fn asset_kind_from_parser(parser_kind: windmill_parser::asset_parser::AssetK
         windmill_parser::asset_parser::AssetKind::Ducklake => AssetKind::Ducklake,
         windmill_parser::asset_parser::AssetKind::DataTable => AssetKind::DataTable,
         windmill_parser::asset_parser::AssetKind::Volume => AssetKind::Volume,
+        windmill_parser::asset_parser::AssetKind::Dbt => AssetKind::Dbt,
     }
 }
 
diff --git a/backend/windmill-common/src/cache.rs b/backend/windmill-common/src/cache.rs
index c5af3bfc1a..3c385da79f 100644
--- a/backend/windmill-common/src/cache.rs
+++ b/backend/windmill-common/src/cache.rs
@@ -699,7 +699,23 @@ pub mod script {
             Ok(RawScript {
                 content: r.content,
                 lock: r.lock,
-                modules: r.modules.and_then(|v| serde_json::from_value(v).ok()),
+                modules: r.modules.and_then(|v| match serde_json::from_value(v) {
+                    Ok(modules) => Some(modules),
+                    // Not fatal: a script whose `modules` column cannot be read
+                    // still runs, just without its own files. But the result is
+                    // then cached under the script's hash, which never changes,
+                    // so the degraded run is what every later one gets too --
+                    // and for dbt "no modules" means no project at all. Say so
+                    // loudly, or the only symptom is a script that behaves as
+                    // if its files were never there.
+                    Err(err) => {
+                        tracing::error!(
+                            "Script {hash} has modules that cannot be deserialized, \
+                             running it without them: {err:#}"
+                        );
+                        None
+                    }
+                }),
                 meta: Some(ScriptMetadata {
                     language: r.language,
                     envs: r.envs,
@@ -1085,7 +1101,12 @@ const _: () = {
             let content = src.get_utf8("code.txt")?;
             let lock = src.get_utf8("lock.txt").ok();
             let meta = src.get_json("info.json").ok();
-            Ok(Self { content, lock, meta, modules: None })
+            // Required, even when empty: a script's modules are part of what it
+            // IS, so an entry without them must fail to import and be refetched
+            // rather than serve the script stripped of its own files.
+            let modules: Option<std::collections::HashMap<String, ScriptModule>> =
+                src.get_json("modules.json")?;
+            Ok(Self { content, lock, meta, modules })
         }
     }
 
@@ -1101,6 +1122,7 @@ const _: () = {
             if let Some(lock) = self.lock.as_ref() {
                 dst.put("lock.txt", lock.as_bytes())?;
             }
+            dst.put("modules.json", serde_json::to_vec(&self.modules)?)?;
             Ok(())
         }
     }
@@ -1312,6 +1334,38 @@ mod tests {
         assert!(leftover.is_empty(), "temp files must be renamed/cleaned up");
     }
 
+    // The first fetch of a script goes to the database, every later one to this
+    // directory. A module lost in between makes a worker restart silently start
+    // running the script without its own files — for dbt, without its project.
+    #[test]
+    fn a_scripts_modules_survive_the_file_system_cache() {
+        use crate::scripts::ScriptModule;
+        let dir = tempfile::tempdir().unwrap();
+        let root = dir.path();
+
+        let data = ScriptData {
+            code: "profile: {}".to_string(),
+            lock: None,
+            modules: Some(std::collections::HashMap::from([(
+                "dbt_project.yml".to_string(),
+                ScriptModule {
+                    content: "name: p".to_string(),
+                    language: ScriptLang::Dbt,
+                    lock: None,
+                },
+            )])),
+        };
+        data.export(&root).unwrap();
+        let back = ScriptData::resolve(RawScript::import(&root).unwrap()).unwrap();
+        assert_eq!(back.modules.unwrap()["dbt_project.yml"].content, "name: p");
+
+        // An entry written before modules were cached has no `modules.json`.
+        // It must fail to import so the caller refetches, rather than serving a
+        // script stripped of its files for as long as the directory lives.
+        std::fs::remove_file(root.join("modules.json")).unwrap();
+        assert!(RawScript::import(&root).is_err());
+    }
+
     #[test]
     fn flow_data_extras_preserves_notes_and_groups() {
         let raw = serde_json::value::to_raw_value(&json!({
diff --git a/backend/windmill-common/src/client.rs b/backend/windmill-common/src/client.rs
index b454585dbe..7907cd6ea1 100644
--- a/backend/windmill-common/src/client.rs
+++ b/backend/windmill-common/src/client.rs
@@ -115,6 +115,59 @@ impl AuthedClient {
         }
     }
 
+    /// Whether the workspace configures this dbt warehouse. Resolves nothing.
+    pub async fn dbt_warehouse_exists(&self, name: &str) -> anyhow::Result<()> {
+        let url = format!(
+            "{}/api/w/{}/dbt/warehouse_exists/{}",
+            self.base_internal_url, self.workspace, name
+        );
+        let response = self.get(&url, vec![]).await?;
+        match response.status().as_u16() {
+            200u16 => Ok(()),
+            _ => Err(anyhow::anyhow!(response.text().await.unwrap_or_default())),
+        }
+    }
+
+    /// Record a run's settled dbt nodes, for a worker with no database.
+    ///
+    /// Posted with the JOB's token, not the agent's: the route takes the job
+    /// from the token, and the agent's own credential only authenticates
+    /// against the agent surface.
+    pub async fn record_dbt_run_progress(
+        &self,
+        req: &[crate::dbt_manifest::DbtRunProgressRequest],
+    ) -> anyhow::Result<()> {
+        let url = format!(
+            "{}/api/w/{}/dbt/run_progress",
+            self.base_internal_url, self.workspace
+        );
+        let response = self
+            .force_client
+            .as_ref()
+            .unwrap_or(&HTTP_CLIENT)
+            .post(&url)
+            .header(
+                reqwest::header::AUTHORIZATION,
+                reqwest::header::HeaderValue::from_str(&format!("Bearer {}", self.token))?,
+            )
+            .json(req)
+            .send()
+            .await?;
+        match response.status().as_u16() {
+            200u16 => Ok(()),
+            _ => Err(anyhow::anyhow!(response.text().await.unwrap_or_default())),
+        }
+    }
+
+    /// Where a dbt warehouse name points, for a worker with no database.
+    pub async fn get_dbt_warehouse<T: DeserializeOwned>(&self, name: &str) -> anyhow::Result<T> {
+        let url = format!(
+            "{}/api/w/{}/dbt/warehouse/{}",
+            self.base_internal_url, self.workspace, name
+        );
+        make_basic_get_request(self, &url, None, Some("decoding the dbt warehouse ref")).await
+    }
+
     pub async fn get_completed_job_result<T: DeserializeOwned>(
         &self,
         path: &str,
diff --git a/backend/windmill-common/src/dbt_manifest.rs b/backend/windmill-common/src/dbt_manifest.rs
new file mode 100644
index 0000000000..7dfc796cfb
--- /dev/null
+++ b/backend/windmill-common/src/dbt_manifest.rs
@@ -0,0 +1,1696 @@
+//! Reading dbt's `target/manifest.json` into the asset graph.
+//!
+//! The manifest is dbt's own parsed project: every model, snapshot, seed,
+//! source and test, with the physical relation each resolves to and the
+//! `ref()`/`source()` edges between them. Ingesting it is what makes dbt models
+//! first-class assets rather than an opaque job (docs/dbt-runtime.md).
+//!
+//! Two things this module is deliberate about:
+//!
+//! * **Asset identity is the physical relation.** A model becomes
+//!   `dbt://<warehouse>/<schema>/<name>`: the scheme names dbt, which is the
+//!   only thing that creates one, but the PATH is the relation and never dbt's
+//!   own `unique_id`. Two projects meet at a handoff — one materializes a mart,
+//!   the next declares it a `source` — where `model.a.orders` and
+//!   `source.b.analytics.orders` differ but the relation does not, so keying on
+//!   the node id would leave each project an island; a native script reading the
+//!   same table would form no edge either. A dbt run does not trigger those
+//!   readers (decision 11, "No cascade from dbt"); sharing the node is what makes
+//!   the lineage one graph.
+//! * **The warehouse is identified by its workspace NAME**, matching the way
+//!   `ducklake://main.orders` names a lake. Connection details (host, account)
+//!   are never part of the key: the same warehouse is reachable under several
+//!   hostnames, and credential material has no business in an asset key. The
+//!   warehouse names the default database too, so relations in it need no
+//!   qualification; one that OVERRODE its database qualifies its schema segment
+//!   (`table_asset_path`), since two same-named relations in different databases
+//!   are not the same table. The accepted consequence is documented in
+//!   docs/dbt-runtime.md — two resources pointing at one physical warehouse do
+//!   not unify.
+//!
+//! # Mutator contract
+//!
+//! Every `pub` mutator in this module — the manifest ones
+//! (`replace_dbt_manifest`, `clear_dbt_manifest`, `clear_dbt_manifest_version`),
+//! the snapshot sweep, and the retry-state ones (`move_dbt_run_state`,
+//! `clear_dbt_run_state`, `clear_dbt_run_state_if_path_retired`) — takes the
+//! workspace and the script to act on as plain arguments and enforces nothing:
+//! **the caller must already have verified write access to that script**,
+//! exactly like the sibling `assets::replace_static_asset_usage` each is called
+//! next to. The retry-state ones destroy a resumable failure and move saved
+//! invocation arguments between paths, so an unauthorized caller there hands one
+//! principal's arguments to another. A user-scoped
+//! transaction is not enforcement here — `dbt_node` and `dbt_edge` carry no RLS
+//! policy and grant `windmill_user` full access, deliberately, because the
+//! writer is the dependency job rather than a request.
+//!
+//! Every caller today satisfies it through the route that owns the script:
+//! `windmill-api-scripts::scripts` clears and moves from the create, archive,
+//! rename and delete handlers, each behind a `scripts:write:<path>` scope check
+//! plus that route's own owner or admin requirement; the worker replaces from
+//! the dependency job of the very script being deployed, and saves retry state
+//! for the script it just ran. A new call site that cannot name where it
+//! authorized is a bug.
+
+use std::collections::{BTreeMap, HashMap};
+
+use serde::{Deserialize, Serialize};
+use sqlx::{Postgres, Transaction};
+use windmill_parser::asset_parser::canonicalize_table_asset_path;
+
+use crate::assets::{AssetKind, AssetUsageAccessType, AssetWithAltAccessType};
+use crate::error::Result;
+
+#[derive(Deserialize, Debug, Default)]
+pub struct Manifest {
+    #[serde(default)]
+    pub metadata: ManifestMetadata,
+    #[serde(default)]
+    pub nodes: BTreeMap<String, ManifestNode>,
+    #[serde(default)]
+    pub sources: BTreeMap<String, ManifestNode>,
+    #[serde(default)]
+    pub parent_map: BTreeMap<String, Vec<String>>,
+}
+
+#[derive(Deserialize, Debug, Default)]
+pub struct ManifestMetadata {
+    #[serde(default)]
+    pub dbt_version: String,
+    #[serde(default)]
+    pub adapter_type: String,
+    #[serde(default)]
+    pub project_name: String,
+}
+
+#[derive(Deserialize, Debug, Default)]
+pub struct ManifestNode {
+    #[serde(default)]
+    pub resource_type: String,
+    #[serde(default)]
+    pub name: String,
+    #[serde(default)]
+    pub alias: Option<String>,
+    /// Sources only: the PHYSICAL table name. `name` is the logical one
+    /// `source()` refers to, and the two differ whenever a source is declared
+    /// with an `identifier`. Sources have no `alias`.
+    #[serde(default)]
+    pub identifier: Option<String>,
+    #[serde(default)]
+    pub schema: Option<String>,
+    /// dbt's resolved database (BigQuery's project, Snowflake's database). A
+    /// model can override it per node, so it is part of identity.
+    #[serde(default)]
+    pub database: Option<String>,
+    /// dbt leaves this null exactly for nodes with no physical relation:
+    /// ephemeral models (inlined as CTEs) and tests.
+    #[serde(default)]
+    pub relation_name: Option<String>,
+    #[serde(default)]
+    pub description: Option<String>,
+    #[serde(default)]
+    pub tags: Vec<String>,
+    #[serde(default)]
+    pub config: NodeConfig,
+    #[serde(default)]
+    pub test_metadata: Option<TestMetadata>,
+    #[serde(default)]
+    pub column_name: Option<String>,
+    #[serde(default)]
+    pub attached_node: Option<String>,
+    #[serde(default)]
+    pub columns: BTreeMap<String, ManifestColumn>,
+    #[serde(default)]
+    pub freshness: Option<serde_json::Value>,
+    /// The model's SQL as written, `{{ ref() }}` and all. `dbt parse` fills
+    /// this; `compiled_code` needs a `dbt compile`, which no phase here runs.
+    #[serde(default)]
+    pub raw_code: Option<String>,
+    /// Its path inside the dbt project, e.g. `models/staging/stg_orders.sql`.
+    #[serde(default)]
+    pub original_file_path: Option<String>,
+}
+
+#[derive(Deserialize, Debug, Default)]
+pub struct NodeConfig {
+    #[serde(default)]
+    pub materialized: Option<String>,
+    /// dbt allows a list for composite keys; only a single-column key maps onto
+    /// a Windmill `merge`/`scd2` strategy, so a composite one is left unmapped.
+    #[serde(default)]
+    pub unique_key: Option<serde_json::Value>,
+    #[serde(default)]
+    pub severity: Option<String>,
+}
+
+#[derive(Deserialize, Debug, Default)]
+pub struct ManifestColumn {
+    #[serde(default)]
+    pub description: Option<String>,
+}
+
+#[derive(Deserialize, Debug, Default)]
+pub struct TestMetadata {
+    #[serde(default)]
+    pub name: String,
+    #[serde(default)]
+    pub kwargs: serde_json::Value,
+    #[serde(default)]
+    pub namespace: Option<String>,
+}
+
+/// A content digest of the graph a row set describes.
+///
+/// Covers every stored field of the nodes, their `ref()` edges and the root the
+/// relations resolved under — more than the graph draws, which errs toward
+/// storing a snapshot rather than suppressing one that differs.
+fn graph_digest(ingested: &IngestedManifest, relation_root: &str) -> String {
+    use sha2::{Digest, Sha256};
+    // SHA-256, not `DefaultHasher`: this is written to the database and compared on
+    // later runs, possibly by a worker on another toolchain, and `DefaultHasher` is
+    // explicitly not stable across Rust releases. A drifting hash would store a full
+    // snapshot every run, looking exactly like the suppression never working.
+    let mut h = Sha256::new();
+    // Delimited and serialized, both parts the same way: `{:?}` renames a field
+    // with the struct, changing every digest once for nothing, and unseparated
+    // parts let one part's tail read as the next part's head.
+    h.update(relation_root.as_bytes());
+    h.update(b"\0");
+    h.update(
+        serde_json::to_string(&ingested.nodes)
+            .unwrap_or_default()
+            .as_bytes(),
+    );
+    h.update(b"\0");
+    h.update(
+        serde_json::to_string(&ingested.edges)
+            .unwrap_or_default()
+            .as_bytes(),
+    );
+    format!("{:x}", h.finalize())
+}
+
+/// The `job_id` of a graph that belongs to a deployed VERSION rather than to one
+/// run: what a static descriptor writes at deploy and all of its runs read.
+///
+/// A sentinel rather than NULL because `job_id` is part of the primary key, and
+/// Postgres does not treat two NULLs as the same key — every re-ingest would
+/// insert a new row set instead of replacing one.
+pub const DEPLOYED_GRAPH: uuid::Uuid = uuid::Uuid::nil();
+
+/// How many deploys of one script keep their graph.
+///
+/// A version's graph is what its own finished runs render from, so it cannot
+/// expire on a clock — a run page is as old as its job. It is bounded by COUNT
+/// instead: the newest deploys keep theirs and older ones are dropped, which
+/// makes growth `versions x models` per path rather than unbounded in time. A CI
+/// deploying on every commit would otherwise add a full model set per commit and
+/// nothing would ever reclaim it.
+///
+/// Generous on purpose. Losing a graph empties that version's run pages, so the
+/// bound exists to stop unbounded growth, not to be reached in normal use.
+pub const DEPLOYED_GRAPH_VERSIONS_KEPT: i64 = 50;
+
+/// How long a run's graph snapshot outlives it. Only dynamic descriptors write
+/// one, and the run page is the only reader.
+pub const RUN_GRAPH_RETENTION_DAYS: i32 = 30;
+
+/// Drop the run snapshots older than the retention window, across the instance.
+///
+/// How long a run's progress rows outlive it.
+///
+/// They exist for the run page, which reads them live and — for a run that left
+/// no `run_results.json`, cancelled or killed — afterwards. Bounded by age and
+/// swept by the writes themselves, so no background job has to know this table.
+const RUN_PROGRESS_RETENTION_DAYS: i32 = 30;
+
+/// Drop progress rows older than the retention above.
+///
+/// Called from EVERY writer, like `prune_dbt_run_graphs`: these rows carry no
+/// job foreign key on purpose, so nothing else reclaims them, and a writer that
+/// skips this is a configuration with no sweep at all — an agent-only workspace
+/// writes them exclusively through the API.
+///
+/// See the mutator contract above: this authorizes nothing.
+pub async fn prune_run_progress(db: &crate::DB, w_id: &str) {
+    let res = sqlx::query!(
+        "DELETE FROM dbt_run_progress
+          WHERE workspace_id = $1 AND updated_at < now() - make_interval(days => $2)",
+        w_id,
+        RUN_PROGRESS_RETENTION_DAYS,
+    )
+    .execute(db)
+    .await;
+    if let Err(e) = res {
+        tracing::warn!("pruning dbt run progress: {e:#}");
+    }
+}
+
+/// Called by everything that writes them — a run, a deploy, and the endpoint an
+/// agent worker publishes through — so this table needs no background sweep, the
+/// same shape `dbt_run_progress` uses. A writer that does not call it is a
+/// configuration with no sweep at all: an agent-only project is deployed once and
+/// never runs where the pool is reachable.
+///
+/// Also drops the deploy graphs of the running script beyond
+/// `DEPLOYED_GRAPH_VERSIONS_KEPT`, which is the only reclamation those have.
+///
+/// See the mutator contract above: this authorizes nothing.
+pub async fn prune_dbt_run_graphs(
+    db: &sqlx::Pool<Postgres>,
+    // The script this run belongs to. The version sweep is scoped to it rather
+    // than run instance-wide: unscoped it seq-scans every version of every
+    // script on the instance, on every dbt run, and past the keep-count is a
+    // rare state — so nearly every execution paid for it to reclaim nothing.
+    script_path: &str,
+    workspace_id: &str,
+) -> Result<()> {
+    // Markers first, then the rows they stand for: a marker outliving its nodes
+    // would report a snapshot the reader then finds empty, which is the very
+    // confusion the marker exists to remove. All three share one age predicate,
+    // so a row and its marker expire together.
+    sqlx::query!(
+        "DELETE FROM dbt_graph_snapshot
+          WHERE job_id <> '00000000-0000-0000-0000-000000000000'
+            AND ingested_at < now() - make_interval(days => $1)",
+        RUN_GRAPH_RETENTION_DAYS,
+    )
+    .execute(db)
+    .await?;
+    // Bounded by age on BOTH sides, and the sentinel spelled as a literal so the
+    // partial indexes apply: a bound parameter cannot be proven to match the
+    // index predicate, which turned this into a whole-table scan on every run.
+    sqlx::query!(
+        "DELETE FROM dbt_node
+          WHERE job_id <> '00000000-0000-0000-0000-000000000000'
+            AND ingested_at < now() - make_interval(days => $1)",
+        RUN_GRAPH_RETENTION_DAYS,
+    )
+    .execute(db)
+    .await?;
+    sqlx::query!(
+        "DELETE FROM dbt_edge
+          WHERE job_id <> '00000000-0000-0000-0000-000000000000'
+            AND ingested_at < now() - make_interval(days => $1)",
+        RUN_GRAPH_RETENTION_DAYS,
+    )
+    .execute(db)
+    .await?;
+    // In ONE transaction with the orphan sweep: a restart in the gap leaves graph
+    // rows whose marker is gone, and since the sweep runs only when a marker went,
+    // every later call computes `retired == 0` and skips them for good.
+    let mut tx = db.begin().await?;
+    // Ordered by the script's own `created_at`, so "newest" is the newest deploy
+    // and not the newest ingest: a late-finishing job must not promote an old
+    // version. Scoped to one (workspace, path), which the path index serves.
+    let retired = sqlx::query!(
+        "WITH keep AS (
+           SELECT hash FROM script
+            WHERE workspace_id = $2 AND path = $3 AND language = 'dbt'
+            ORDER BY created_at DESC LIMIT $1
+         )
+         DELETE FROM dbt_graph_snapshot g
+          WHERE g.workspace_id = $2 AND g.script_path = $3
+            AND g.job_id = '00000000-0000-0000-0000-000000000000'
+            AND NOT EXISTS (SELECT 1 FROM keep k WHERE k.hash = g.script_hash)",
+        DEPLOYED_GRAPH_VERSIONS_KEPT,
+        workspace_id,
+        script_path,
+    )
+    .execute(&mut *tx)
+    .await?
+    .rows_affected();
+    // Only when a marker actually went: these two are the complement of every
+    // partial index here — all of them `WHERE job_id <> DEPLOYED` — and past the
+    // keep-count is rare, so the ordinary run should pay for neither.
+    if retired > 0 {
+        for table in ["dbt_node", "dbt_edge"] {
+            sqlx::query(&format!(
+                "DELETE FROM {table} t
+                  WHERE t.workspace_id = $1 AND t.script_path = $2
+                    AND t.job_id = '00000000-0000-0000-0000-000000000000'
+                    AND NOT EXISTS (SELECT 1 FROM dbt_graph_snapshot g
+                                     WHERE g.workspace_id = t.workspace_id
+                                       AND g.script_path = t.script_path
+                                       AND g.script_hash = t.script_hash
+                                       AND g.job_id = t.job_id)"
+            ))
+            .bind(workspace_id)
+            .bind(script_path)
+            .execute(&mut *tx)
+            .await?;
+        }
+    }
+    tx.commit().await?;
+    Ok(())
+}
+
+/// Longest model body kept for display. Generous for a hand-written model and
+/// small enough that a generated one cannot bloat the sidecar.
+const MAX_SQL_BYTES: usize = 32 * 1024;
+
+fn truncate_sql(code: &str) -> String {
+    if code.len() <= MAX_SQL_BYTES {
+        return code.to_string();
+    }
+    // On a char boundary, so the result stays valid UTF-8.
+    let mut end = MAX_SQL_BYTES;
+    while end > 0 && !code.is_char_boundary(end) {
+        end -= 1;
+    }
+    format!("{}\n-- … truncated by Windmill …", &code[..end])
+}
+
+/// One ingested dbt node, ready to be written to `dbt_node`.
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
+#[serde(default)]
+pub struct IngestedNode {
+    pub unique_id: String,
+    pub resource_type: String,
+    pub name: String,
+    pub asset_path: Option<String>,
+    pub materialized: Option<String>,
+    pub materialize_strategy: Option<String>,
+    pub unique_key: Option<String>,
+    pub tags: Vec<String>,
+    pub description: Option<String>,
+    pub test_kind: Option<String>,
+    pub test_column: Option<String>,
+    pub test_args: Option<serde_json::Value>,
+    pub severity: Option<String>,
+    pub attached_node: Option<String>,
+    pub columns: Option<serde_json::Value>,
+    pub freshness: Option<serde_json::Value>,
+    /// The transform itself, for the graph to render. The copy taken at
+    /// deploy: the file itself is in the script's module bundle.
+    pub raw_code: Option<String>,
+    pub original_file_path: Option<String>,
+}
+
+// Serde: an agent worker cannot write these tables directly, so it posts the
+// whole manifest to the server, which stores it with the same function the SQL
+// path uses.
+#[derive(Debug, Default, Serialize, Deserialize)]
+// `default`: these cross the wire for an agent worker, and a field the serializer
+// skips must not make the whole manifest unparseable on the other side.
+#[serde(default)]
+pub struct IngestedManifest {
+    pub nodes: Vec<IngestedNode>,
+    pub edges: Vec<(String, String)>,
+    /// The `asset` rows the owning script produces (models) and consumes
+    /// (sources) — what the lineage graph is drawn from.
+    pub assets: Vec<AssetWithAltAccessType>,
+    pub dbt_version: String,
+    pub adapter_type: String,
+}
+
+/// dbt's `materialized` mapped onto Windmill's write strategy.
+///
+/// The mapping is exact for the four strategies Windmill has, and deliberately
+/// `None` where dbt has no analogue: `view` produces a relation but performs no
+/// write, and `ephemeral` produces no relation at all.
+pub fn materialize_strategy_for(materialized: &str, has_unique_key: bool) -> Option<String> {
+    match materialized {
+        "table" | "seed" => Some("replace".to_string()),
+        // Any `unique_key` makes it a merge — including a composite one, whose
+        // columns `single_unique_key` cannot name. Reporting `append` for those
+        // would describe an upsert as an insert-only write.
+        "incremental" | "microbatch" => Some(match has_unique_key {
+            true => "merge".to_string(),
+            false => "append".to_string(),
+        }),
+        "snapshot" => Some("scd2".to_string()),
+        _ => None,
+    }
+}
+
+/// Whether dbt declared any `unique_key`, composite or not.
+fn has_unique_key(v: Option<&serde_json::Value>) -> bool {
+    match v {
+        Some(serde_json::Value::String(s)) => !s.is_empty(),
+        Some(serde_json::Value::Array(a)) => !a.is_empty(),
+        _ => false,
+    }
+}
+
+fn single_unique_key(v: Option<&serde_json::Value>) -> Option<String> {
+    match v {
+        Some(serde_json::Value::String(s)) if !s.is_empty() => Some(s.clone()),
+        // A composite key has no single-column analogue; leave it unmapped
+        // rather than silently picking the first column.
+        _ => None,
+    }
+}
+
+/// `dbt://` path of the relation a node resolves to, or `None` when it has
+/// none. Assembles the parts; `table_asset_path` owns the spelling.
+fn asset_path_for(
+    node: &ManifestNode,
+    warehouse: &str,
+    default_database: Option<&str>,
+) -> Option<String> {
+    node.relation_name.as_ref()?;
+    // `schema` is dbt's RESOLVED schema; `config.schema` is only the suffix
+    // `generate_schema_name` combines with the target's (`schema: snapshots` under
+    // `analytics` lands in `analytics_snapshots`). Keying on the config value names
+    // a relation that does not exist, invisibly, until nothing links.
+    let schema = node.schema.as_deref()?;
+    // `identifier` for a source, `alias` for a model; `name` only when neither
+    // is set. Using `name` for a source declared `name: orders, identifier:
+    // raw_orders` would key the asset on a relation that does not exist, so no
+    // native script reading `raw_orders` could ever join it.
+    let name = node
+        .identifier
+        .as_deref()
+        .or(node.alias.as_deref())
+        .unwrap_or(&node.name);
+    table_asset_path(
+        warehouse,
+        node.database.as_deref(),
+        schema,
+        name,
+        default_database,
+    )
+}
+
+/// `asset.path`'s column width. A `dbt://` key is the only asset path assembled
+/// from warehouse identifiers rather than from a Windmill path, so it is the
+/// only one that can outgrow the column.
+pub const MAX_ASSET_PATH_LEN: usize = 255;
+
+/// The one derivation of a `dbt://` path from a relation's parts.
+///
+/// Three call sites need it and they MUST agree: the manifest ingest (which
+/// creates the graph node), the live progress events, and the end-of-run
+/// settlement (which both record status against it). A site that derives it
+/// differently records progress against a path no node has, and nothing looks
+/// broken — the run succeeds, the graph just never moves.
+///
+/// The resource names the warehouse and its default database, so a relation in
+/// that database uses the plain three-segment spelling. One that overrode its
+/// database is genuinely elsewhere and qualifies its schema segment as
+/// `<database>.<schema>`, so two same-named relations cannot collapse. A project
+/// that owns its `profiles.yml` reports its target's database the same way, so
+/// both kinds of project spell one relation identically; only where a target
+/// leaves its database implicit does every relation qualify, because assuming
+/// they all share a database is what would collapse them.
+pub fn table_asset_path(
+    warehouse: &str,
+    database: Option<&str>,
+    schema: &str,
+    name: &str,
+    default_database: Option<&str>,
+) -> Option<String> {
+    let qualified = match database.map(str::trim).filter(|d| !d.is_empty()) {
+        Some(db) if !default_database.is_some_and(|d| d.eq_ignore_ascii_case(db)) => {
+            format!("{db}.{schema}")
+        }
+        _ => schema.to_string(),
+    };
+    // `/` is the segment boundary, and `canonicalize_table_asset_path` recovers
+    // the components from the LAST two — so an identifier carrying one (legal
+    // when quoted) moves that boundary: `("a/b", "c")` and `("a", "b/c")` both
+    // spell `<warehouse>/a/b/c` and two relations share one node, one lineage
+    // and one progress row. Refused rather than encoded: the `dbt://` spelling
+    // is a contract (docs/dbt-runtime.md, decision 11) that annotations and the
+    // frontend parse too. The relation keeps its manifest row and gets no asset,
+    // exactly as an over-long one does.
+    if qualified.contains('/') || name.contains('/') {
+        return None;
+    }
+    let path = canonicalize_table_asset_path(&format!("{warehouse}/{qualified}/{name}"));
+    // The bound lives HERE because all three derivations must agree, and it is
+    // the column's: `asset.path` is VARCHAR(255), counted in CHARACTERS, and a
+    // `dbt://` key is the only asset path assembled from warehouse identifiers
+    // rather than from a Windmill path. Over it, the relation keeps its manifest
+    // row and gets no asset — the alternative is Postgres rejecting the insert
+    // and taking the graph down, or one swallowed `value too long` per node.
+    (path.chars().count() <= MAX_ASSET_PATH_LEN).then_some(path)
+}
+
+/// Parse a `manifest.json` into rows, edges and asset usages.
+///
+/// `warehouse` is the workspace warehouse's NAME, which the profile
+/// target points at, e.g. `main`.
+/// `selected` is the node set the descriptor's `select`/`exclude` resolves to,
+/// as reported by dbt itself (`dbt ls`). `None` means the whole project. It
+/// scopes what this script is recorded as owning: a script that builds only
+/// `tag:nightly` must not register as the producer of every other model, or the
+/// graph shows it owning models it never touches. Running several scripts
+/// with different selections is the intended shape (docs/dbt-runtime.md,
+/// decision 6), and this is what makes them compose.
+pub fn ingest_manifest(
+    manifest: &Manifest,
+    warehouse: &str,
+    // The profile target's database. Nodes in it use the plain three-segment
+    // spelling; a node that overrode it qualifies its schema segment.
+    default_database: Option<&str>,
+    selected: Option<&std::collections::HashSet<String>>,
+) -> IngestedManifest {
+    let mut out = IngestedManifest {
+        dbt_version: manifest.metadata.dbt_version.clone(),
+        adapter_type: manifest.metadata.adapter_type.clone(),
+        ..Default::default()
+    };
+    let mut assets: HashMap<(AssetKind, String), AssetUsageAccessType> = HashMap::new();
+
+    // A source is this script's input only if something it builds reads it, or a
+    // narrowly-selected script claims reads on tables it never touches. Without a
+    // selection it builds everything, and a source nothing reads is still not an
+    // input. The same set answers the cross-config question below.
+    let direct_parents: std::collections::HashSet<&str> = {
+        let mut out = std::collections::HashSet::new();
+        let mut queue: Vec<&str> = manifest
+            .parent_map
+            .iter()
+            .filter(|(child, _)| selected.is_none_or(|sel| sel.contains(child.as_str())))
+            // Only what the script BUILDS establishes a dependency. Selecting a
+            // model also selects its tests, and a `relationships` test depends
+            // on the model it points at — so counting test parents would make a
+            // staging-only script subscribe to a mart it merely asserts against.
+            .filter(|(child, _)| {
+                manifest
+                    .nodes
+                    .get(*child)
+                    .is_some_and(|n| n.resource_type != "test")
+            })
+            .flat_map(|(_, parents)| parents.iter().map(|p| p.as_str()))
+            .collect();
+        let mut seen: std::collections::HashSet<&str> = queue.iter().copied().collect();
+        while let Some(parent) = queue.pop() {
+            // An ephemeral model is inlined as a CTE, so it produces nothing to
+            // depend on — but whatever IT reads is still this script's real
+            // input. Stopping at it loses the subscription entirely, and the
+            // model then shows no upstream edge to its actual source.
+            let is_ephemeral = manifest
+                .nodes
+                .get(parent)
+                .is_some_and(|n| n.relation_name.is_none());
+            if !is_ephemeral {
+                out.insert(parent);
+                continue;
+            }
+            for grandparent in manifest.parent_map.get(parent).into_iter().flatten() {
+                if seen.insert(grandparent.as_str()) {
+                    queue.push(grandparent.as_str());
+                }
+            }
+        }
+        out
+    };
+    for (unique_id, node) in manifest.nodes.iter().chain(manifest.sources.iter()) {
+        // Whether this script BUILDS the node, as opposed to depending on it. Direct
+        // parents are kept either way, because an edge needs both endpoints: drop
+        // one and the `ref()` reaching it has nothing to point at, leaving two
+        // relations with no line between them.
+        let is_selected = selected.is_none_or(|sel| sel.contains(unique_id.as_str()));
+        let keep = match node.resource_type.as_str() {
+            "source" => direct_parents.contains(unique_id.as_str()),
+            _ => is_selected || direct_parents.contains(unique_id.as_str()),
+        };
+        if !keep {
+            continue;
+        }
+        let asset_path = asset_path_for(node, warehouse, default_database);
+        let materialized = node
+            .config
+            .materialized
+            .clone()
+            .or(match node.resource_type.as_str() {
+                // Sources and seeds carry no `materialized` of their own but their
+                // physical nature is fixed.
+                "source" => Some("source".to_string()),
+                _ => None,
+            });
+        let unique_key = single_unique_key(node.config.unique_key.as_ref());
+        let test = node.test_metadata.as_ref();
+        out.nodes.push(IngestedNode {
+            unique_id: unique_id.clone(),
+            resource_type: node.resource_type.clone(),
+            name: node.name.clone(),
+            asset_path: asset_path.clone(),
+            materialize_strategy: materialized.as_deref().and_then(|m| {
+                materialize_strategy_for(m, has_unique_key(node.config.unique_key.as_ref()))
+            }),
+            materialized,
+            unique_key,
+            tags: node.tags.clone(),
+            description: node.description.clone().filter(|d| !d.is_empty()),
+            // A package's test keeps its own name (`dbt_utils.accepted_range`)
+            // so it is legible rather than silently dropped for not being one
+            // of the four generic kinds.
+            test_kind: test.map(|t| match t.namespace.as_deref() {
+                Some(ns) if !ns.is_empty() => format!("{ns}.{}", t.name),
+                _ => t.name.clone(),
+            }),
+            test_column: node.column_name.clone(),
+            test_args: test.map(|t| t.kwargs.clone()),
+            severity: node.config.severity.clone(),
+            attached_node: node.attached_node.clone(),
+            columns: (!node.columns.is_empty()).then(|| {
+                serde_json::json!(node
+                    .columns
+                    .iter()
+                    .map(|(k, v)| (k.clone(), v.description.clone().unwrap_or_default()))
+                    .collect::<BTreeMap<_, _>>())
+            }),
+            freshness: node.freshness.clone(),
+            // The transform the graph renders. Capped: a project can hold
+            // thousands of models and this is duplicated per deploy, so a
+            // pathological file is truncated rather than allowed to bloat the
+            // sidecar. Tests carry generated SQL nobody reads — skipped.
+            raw_code: (node.resource_type != "test")
+                .then(|| node.raw_code.clone())
+                .flatten()
+                .filter(|c| !c.trim().is_empty())
+                .map(|c| truncate_sql(&c)),
+            original_file_path: node.original_file_path.clone().filter(|p| !p.is_empty()),
+        });
+
+        // The dbt script writes what it materializes and reads its sources.
+        // Internal `ref()`s between its own models are lineage inside the
+        // project, not usages of the script — modelling them as reads would
+        // make the script depend on its own output.
+        let Some(path) = asset_path else { continue };
+        let access = match node.resource_type.as_str() {
+            // A parent kept only to anchor an edge is read, not written: this
+            // script's selection does not build it, and claiming the write would
+            // make two scripts splitting one project both own the same relation.
+            "model" | "snapshot" | "seed" if is_selected => AssetUsageAccessType::W,
+            "model" | "snapshot" | "seed" => AssetUsageAccessType::R,
+            "source" => AssetUsageAccessType::R,
+            _ => continue,
+        };
+        let key = (AssetKind::Dbt, path);
+        let merged = match (assets.get(&key), access) {
+            (Some(AssetUsageAccessType::R), AssetUsageAccessType::W)
+            | (Some(AssetUsageAccessType::W), AssetUsageAccessType::R) => AssetUsageAccessType::RW,
+            (Some(existing), _) => *existing,
+            (None, a) => a,
+        };
+        assets.insert(key, merged);
+    }
+
+    out.nodes.sort_by(|a, b| a.unique_id.cmp(&b.unique_id));
+
+    let kept: std::collections::HashSet<&str> =
+        out.nodes.iter().map(|n| n.unique_id.as_str()).collect();
+    // An ephemeral model is inlined as a CTE, so it is a node with no relation
+    // and nothing to draw. Its edges are still real lineage though: dropping
+    // `A -> E` and `E -> B` loses the `A -> B` the reader needs. Walk through
+    // ephemeral parents to the nearest ones that do have a relation.
+    let is_ephemeral = |id: &str| {
+        manifest
+            .nodes
+            .get(id)
+            .is_some_and(|n| n.relation_name.is_none() && n.resource_type != "test")
+    };
+    let physical_parents = |child: &str| -> Vec<String> {
+        let mut out = Vec::new();
+        let mut seen = std::collections::HashSet::new();
+        let mut queue: Vec<&str> = manifest
+            .parent_map
+            .get(child)
+            .into_iter()
+            .flatten()
+            .map(|p| p.as_str())
+            .collect();
+        while let Some(p) = queue.pop() {
+            if !seen.insert(p.to_string()) {
+                continue;
+            }
+            if is_ephemeral(p) {
+                queue.extend(
+                    manifest
+                        .parent_map
+                        .get(p)
+                        .into_iter()
+                        .flatten()
+                        .map(|g| g.as_str()),
+                );
+            } else if kept.contains(p) {
+                out.push(p.to_string());
+            }
+        }
+        out
+    };
+    for child in manifest.parent_map.keys() {
+        if !kept.contains(child.as_str()) || is_ephemeral(child) {
+            continue;
+        }
+        for parent in physical_parents(child) {
+            out.edges.push((parent, child.clone()));
+        }
+    }
+    out.edges.sort();
+
+    let mut assets: Vec<_> = assets.into_iter().collect();
+    assets.sort_by(|(a, _), (b, _)| a.cmp(b));
+    out.assets = assets
+        .into_iter()
+        .map(|((kind, path), access)| AssetWithAltAccessType {
+            path,
+            kind,
+            access_type: Some(access),
+            alt_access_type: None,
+            columns: None,
+        })
+        .collect();
+    out
+}
+
+/// Replace the stored manifest of one dbt script. Wipe-and-reinsert per ingest,
+/// so a model deleted upstream disappears from the graph on the next deploy.
+///
+/// See the mutator contract above: this authorizes nothing.
+pub async fn replace_dbt_manifest(
+    tx: &mut Transaction<'_, Postgres>,
+    workspace_id: &str,
+    script_path: &str,
+    // The deployed version this graph describes. Rows are keyed by it, so two
+    // versions of one path coexist and an old run can still be shown the project
+    // as it was when it ran.
+    script_hash: i64,
+    // The run this graph is a snapshot of, for a dynamic descriptor whose model
+    // set depends on its arguments. `None` is the version's own graph as
+    // deployed — what a static descriptor writes once and all of its runs read.
+    job_id: Option<uuid::Uuid>,
+    ingested: &IngestedManifest,
+    // Where the profile put these relations, so a later run can tell whether the
+    // resource has moved since — see the migration.
+    relation_root: &str,
+) -> Result<()> {
+    let job_id = job_id.unwrap_or(DEPLOYED_GRAPH);
+    let digest = graph_digest(ingested, relation_root);
+    if job_id != DEPLOYED_GRAPH {
+        // A snapshot earns its storage only by DIFFERING from the version's graph.
+        // Marking a descriptor dynamic is conservative — a `{{ }}` in `vars` says
+        // the arguments feed dbt, not that they change which models exist — so the
+        // usual dynamic run duplicates a picture the read falls back to anyway.
+        let deployed = sqlx::query_scalar!(
+            "SELECT digest FROM dbt_graph_snapshot
+              WHERE workspace_id = $1 AND script_path = $2 AND script_hash = $3
+                AND job_id = $4",
+            workspace_id,
+            script_path,
+            script_hash,
+            DEPLOYED_GRAPH,
+        )
+        .fetch_optional(&mut **tx)
+        .await?;
+        if deployed.as_deref() == Some(digest.as_str()) {
+            return Ok(());
+        }
+    }
+    // Scoped to THIS version AND this run: wiping the path would take every
+    // other version's graph with it, and wiping the version would take every
+    // other run's snapshot — both are what keying exists to prevent.
+    sqlx::query!(
+        "DELETE FROM dbt_node WHERE workspace_id = $1 AND script_path = $2
+           AND script_hash = $3 AND job_id = $4",
+        workspace_id,
+        script_path,
+        script_hash,
+        job_id
+    )
+    .execute(&mut **tx)
+    .await?;
+    sqlx::query!(
+        "DELETE FROM dbt_edge WHERE workspace_id = $1 AND script_path = $2
+           AND script_hash = $3 AND job_id = $4",
+        workspace_id,
+        script_path,
+        script_hash,
+        job_id
+    )
+    .execute(&mut **tx)
+    .await?;
+    // The marker, before the rows: a graph with no nodes at all is a legitimate
+    // answer for a dynamic run that disabled every model, and the reader must be
+    // able to tell it from a run that stored nothing.
+    sqlx::query!(
+        "INSERT INTO dbt_graph_snapshot
+           (workspace_id, script_path, script_hash, job_id, digest, ingested_at)
+         VALUES ($1, $2, $3, $4, $5, now())
+         ON CONFLICT (workspace_id, script_path, script_hash, job_id)
+         DO UPDATE SET digest = EXCLUDED.digest, ingested_at = now()",
+        workspace_id,
+        script_path,
+        script_hash,
+        job_id,
+        digest
+    )
+    .execute(&mut **tx)
+    .await?;
+
+    // Batched: a manifest carries a row per model, test, seed and snapshot, and
+    // one awaited statement each made publication scale with database latency
+    // while holding this transaction. Chunked because Postgres binds at most
+    // 65535 parameters per statement.
+    for chunk in ingested.nodes.chunks(NODE_INSERT_CHUNK) {
+        let mut q = sqlx::QueryBuilder::new(
+            "INSERT INTO dbt_node (workspace_id, script_path, script_hash, job_id, unique_id, \
+             resource_type, name, asset_path, materialized, materialize_strategy, unique_key, \
+             tags, description, test_kind, test_column, test_args, severity, attached_node, \
+             columns, freshness, raw_code, original_file_path) ",
+        );
+        q.push_values(chunk, |mut b, n| {
+            b.push_bind(workspace_id)
+                .push_bind(script_path)
+                .push_bind(script_hash)
+                .push_bind(job_id)
+                .push_bind(&n.unique_id)
+                .push_bind(&n.resource_type)
+                .push_bind(&n.name)
+                .push_bind(&n.asset_path)
+                .push_bind(&n.materialized)
+                .push_bind(&n.materialize_strategy)
+                .push_bind(&n.unique_key)
+                .push_bind(&n.tags)
+                .push_bind(&n.description)
+                .push_bind(&n.test_kind)
+                .push_bind(&n.test_column)
+                .push_bind(&n.test_args)
+                .push_bind(&n.severity)
+                .push_bind(&n.attached_node)
+                .push_bind(&n.columns)
+                .push_bind(&n.freshness)
+                .push_bind(&n.raw_code)
+                .push_bind(&n.original_file_path);
+        });
+        q.build().execute(&mut **tx).await?;
+    }
+
+    for chunk in ingested.edges.chunks(EDGE_INSERT_CHUNK) {
+        let mut q = sqlx::QueryBuilder::new(
+            "INSERT INTO dbt_edge (workspace_id, script_path, script_hash, job_id, \
+             parent_unique_id, child_unique_id) ",
+        );
+        q.push_values(chunk, |mut b, (parent, child)| {
+            b.push_bind(workspace_id)
+                .push_bind(script_path)
+                .push_bind(script_hash)
+                .push_bind(job_id)
+                .push_bind(parent)
+                .push_bind(child);
+        });
+        q.push(" ON CONFLICT DO NOTHING");
+        q.build().execute(&mut **tx).await?;
+    }
+    Ok(())
+}
+
+/// Rows per statement, chosen so 22 columns stay under Postgres's 65535-bind
+/// ceiling with room to spare.
+const NODE_INSERT_CHUNK: usize = 2000;
+/// Six columns, so the same ceiling allows far more.
+const EDGE_INSERT_CHUNK: usize = 8000;
+
+/// Clear one VERSION's graph, the unit the archive and delete routes act on:
+/// both target a single `hash`, and the other versions of the path stay live
+/// and keep needing their own models, SQL and lineage. The path-wide sibling
+/// below is for the case where a path stops being a dbt script at all.
+///
+/// See the mutator contract above: this authorizes nothing.
+pub async fn clear_dbt_manifest_version(
+    tx: &mut Transaction<'_, Postgres>,
+    workspace_id: &str,
+    script_path: &str,
+    script_hash: i64,
+) -> Result<()> {
+    sqlx::query!(
+        "DELETE FROM dbt_node WHERE workspace_id = $1 AND script_path = $2 AND script_hash = $3",
+        workspace_id,
+        script_path,
+        script_hash
+    )
+    .execute(&mut **tx)
+    .await?;
+    sqlx::query!(
+        "DELETE FROM dbt_edge WHERE workspace_id = $1 AND script_path = $2 AND script_hash = $3",
+        workspace_id,
+        script_path,
+        script_hash
+    )
+    .execute(&mut **tx)
+    .await?;
+    // The marker too, and every job's: a marker left standing for rows that are
+    // gone is read as a snapshot, and its digest still answers the suppression
+    // check — so an identical run would write nothing and then render an empty
+    // graph.
+    sqlx::query!(
+        "DELETE FROM dbt_graph_snapshot
+          WHERE workspace_id = $1 AND script_path = $2 AND script_hash = $3",
+        workspace_id,
+        script_path,
+        script_hash
+    )
+    .execute(&mut **tx)
+    .await?;
+    Ok(())
+}
+
+/// Drop every version of one path's graph, for the routes that retire the whole
+/// path — archive-by-path, delete-by-path and the bulk delete.
+///
+/// NOT for a rename, nor for a path whose newest version stops being dbt:
+/// every graph query joins on `(path, hash)` through a `language = 'dbt'` CTE,
+/// so an old version's rows cannot attach to whatever lives at that path next,
+/// and its own finished runs still render from them.
+///
+/// See the mutator contract above: this authorizes nothing.
+pub async fn clear_dbt_manifest(
+    tx: &mut Transaction<'_, Postgres>,
+    workspace_id: &str,
+    script_path: &str,
+) -> Result<()> {
+    sqlx::query!(
+        "DELETE FROM dbt_node WHERE workspace_id = $1 AND script_path = $2",
+        workspace_id,
+        script_path
+    )
+    .execute(&mut **tx)
+    .await?;
+    sqlx::query!(
+        "DELETE FROM dbt_edge WHERE workspace_id = $1 AND script_path = $2",
+        workspace_id,
+        script_path
+    )
+    .execute(&mut **tx)
+    .await?;
+    sqlx::query!(
+        "DELETE FROM dbt_graph_snapshot WHERE workspace_id = $1 AND script_path = $2",
+        workspace_id,
+        script_path
+    )
+    .execute(&mut **tx)
+    .await?;
+    Ok(())
+}
+
+/// Move a dbt script's saved retry state to its new path.
+///
+/// Keyed by path like the sidecar, but unlike the sidecar it is not
+/// regenerated by anything: the deploy re-ingests a manifest, while these are
+/// the results of a run that already happened. Clearing on rename would throw
+/// away a resumable failure for a cosmetic change, so it travels instead.
+///
+/// See the mutator contract above: this authorizes nothing.
+pub async fn move_dbt_run_state(
+    tx: &mut Transaction<'_, Postgres>,
+    workspace_id: &str,
+    old_path: &str,
+    new_path: &str,
+) -> Result<()> {
+    // The destination may already hold state from a script that lived there
+    // before; the incoming row is the newer truth for this project.
+    sqlx::query!(
+        "DELETE FROM dbt_run_state WHERE workspace_id = $1 AND script_path = $2",
+        workspace_id,
+        new_path
+    )
+    .execute(&mut **tx)
+    .await?;
+    sqlx::query!(
+        "UPDATE dbt_run_state SET script_path = $3 WHERE workspace_id = $1 AND script_path = $2",
+        workspace_id,
+        old_path,
+        new_path
+    )
+    .execute(&mut **tx)
+    .await?;
+    Ok(())
+}
+
+/// Drop the saved retry state, but only once NO live version of the path is
+/// left.
+///
+/// `dbt_run_state`'s key is the path and the principal — one saved run per script
+/// per identity it executes as, not
+/// one per version — so archiving or deleting a single version must not take it
+/// with them: the live version's `dbt retry` would be refused and the
+/// partial-failure resume lost. It does not need to be version-scoped either,
+/// because `identity` already refuses a resume whose project, warehouse or
+/// engine moved.
+///
+/// See the mutator contract above: this authorizes nothing.
+pub async fn clear_dbt_run_state_if_path_retired(
+    tx: &mut Transaction<'_, Postgres>,
+    workspace_id: &str,
+    script_path: &str,
+) -> Result<()> {
+    sqlx::query!(
+        "DELETE FROM dbt_run_state WHERE workspace_id = $1 AND script_path = $2
+           AND NOT EXISTS (SELECT 1 FROM script
+                            WHERE workspace_id = $1 AND path = $2
+                              AND deleted = false AND archived = false)",
+        workspace_id,
+        script_path
+    )
+    .execute(&mut **tx)
+    .await?;
+    Ok(())
+}
+
+/// Drop a dbt script's saved retry state.
+///
+/// Archive and delete: `run_results` is not small, the invocation arguments it
+/// carries are the user's, and a script later created at the same path would
+/// otherwise inherit a stranger's resumable failure.
+///
+/// See the mutator contract above: this authorizes nothing.
+pub async fn clear_dbt_run_state(
+    tx: &mut Transaction<'_, Postgres>,
+    workspace_id: &str,
+    script_path: &str,
+) -> Result<()> {
+    sqlx::query!(
+        "DELETE FROM dbt_run_state WHERE workspace_id = $1 AND script_path = $2",
+        workspace_id,
+        script_path
+    )
+    .execute(&mut **tx)
+    .await?;
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // Captured from a real `dbt parse` (dbt-core 1.12 / postgres); the same
+    // shape is emitted by dbt-core 2.0 (manifest schema v12 in both).
+    const MANIFEST: &str = r#"{
+      "metadata": {"dbt_version": "1.12.0", "adapter_type": "postgres", "project_name": "jaffle_shop"},
+      "nodes": {
+        "model.jaffle_shop.customers": {
+          "resource_type": "model", "name": "customers", "alias": "customers",
+          "schema": "jaffle_dbt", "relation_name": "\"wh\".\"jaffle_dbt\".\"customers\"",
+          "tags": ["nightly"], "config": {"materialized": "table"},
+          "columns": {"customer_id": {"description": "pk"}},
+          "raw_code": "select * from {{ ref('stg_customers') }}",
+          "original_file_path": "models/customers.sql"
+        },
+        "model.jaffle_shop.orders_daily": {
+          "resource_type": "model", "name": "orders_daily", "alias": "orders_daily",
+          "schema": "jaffle_dbt", "relation_name": "\"wh\".\"jaffle_dbt\".\"orders_daily\"",
+          "config": {"materialized": "incremental", "unique_key": "order_id"}
+        },
+        "model.jaffle_shop.order_events": {
+          "resource_type": "model", "name": "order_events", "alias": "order_events",
+          "schema": "jaffle_dbt", "database": "archive",
+          "relation_name": "\"archive\".\"jaffle_dbt\".\"order_events\"",
+          "config": {"materialized": "incremental"}
+        },
+        "model.jaffle_shop.composite_key": {
+          "resource_type": "model", "name": "composite_key", "alias": "composite_key",
+          "schema": "jaffle_dbt", "database": "wh",
+          "relation_name": "\"wh\".\"jaffle_dbt\".\"composite_key\"",
+          "config": {"materialized": "incremental", "unique_key": ["a", "b"]}
+        },
+        "model.jaffle_shop.stg_customers": {
+          "resource_type": "model", "name": "stg_customers", "alias": "stg_customers",
+          "schema": "jaffle_dbt", "relation_name": "\"wh\".\"jaffle_dbt\".\"stg_customers\"",
+          "config": {"materialized": "view"}
+        },
+        "test.jaffle_shop.relationships_orders_daily_customer_id.ab": {
+          "resource_type": "test", "name": "relationships_orders_daily_customer_id",
+          "column_name": "customer_id", "attached_node": "model.jaffle_shop.orders_daily",
+          "config": {"materialized": "test", "severity": "ERROR"},
+          "test_metadata": {"name": "relationships",
+                            "kwargs": {"to": "ref('stg_customers')", "field": "customer_id"},
+                            "namespace": null}
+        },
+        "model.jaffle_shop.ephemeral_helper": {
+          "resource_type": "model", "name": "ephemeral_helper", "schema": "jaffle_dbt",
+          "relation_name": null, "config": {"materialized": "ephemeral"}
+        },
+        "snapshot.jaffle_shop.customers_snapshot": {
+          "resource_type": "snapshot", "name": "customers_snapshot", "alias": "customers_snapshot",
+          "schema": "jaffle_dbt_snapshots",
+          "relation_name": "\"wh\".\"jaffle_dbt_snapshots\".\"customers_snapshot\"",
+          "config": {"materialized": "snapshot", "unique_key": "customer_id",
+                     "schema": "snapshots"}
+        },
+        "test.jaffle_shop.unique_customers_customer_id.c5": {
+          "resource_type": "test", "name": "unique_customers_customer_id",
+          "column_name": "customer_id", "attached_node": "model.jaffle_shop.customers",
+          "config": {"materialized": "test", "severity": "ERROR"},
+          "test_metadata": {"name": "unique", "kwargs": {"column_name": "customer_id"}, "namespace": null}
+        },
+        "test.jaffle_shop.accepted_values_orders_daily_status.14": {
+          "resource_type": "test", "name": "accepted_values_orders_daily_status",
+          "column_name": "status", "attached_node": "model.jaffle_shop.orders_daily",
+          "config": {"materialized": "test", "severity": "ERROR"},
+          "test_metadata": {"name": "accepted_values",
+                            "kwargs": {"values": ["completed"], "column_name": "status"},
+                            "namespace": null}
+        },
+        "test.jaffle_shop.dbt_utils_accepted_range_customers_n_orders__0.cb": {
+          "resource_type": "test", "name": "dbt_utils_accepted_range_customers_n_orders__0",
+          "column_name": "n_orders", "attached_node": "model.jaffle_shop.customers",
+          "config": {"materialized": "test", "severity": "warn"},
+          "test_metadata": {"name": "accepted_range", "kwargs": {"min_value": 0},
+                            "namespace": "dbt_utils"}
+        }
+      },
+      "sources": {
+        "source.jaffle_shop.jaffle_raw.raw_orders": {
+          "resource_type": "source", "name": "orders", "identifier": "raw_orders",
+          "schema": "jaffle_raw",
+          "relation_name": "\"wh\".\"jaffle_raw\".\"raw_orders\"",
+          "freshness": {"warn_after": {"count": 1000, "period": "day"}}
+        }
+      },
+      "parent_map": {
+        "model.jaffle_shop.customers": ["model.jaffle_shop.orders_daily"],
+        "model.jaffle_shop.orders_daily": ["source.jaffle_shop.jaffle_raw.raw_orders"],
+        "model.jaffle_shop.stg_customers": ["source.jaffle_shop.jaffle_raw.raw_customers"],
+        "test.jaffle_shop.relationships_orders_daily_customer_id.ab":
+          ["model.jaffle_shop.orders_daily", "model.jaffle_shop.stg_customers"]
+      }
+    }"#;
+
+    fn ingested() -> IngestedManifest {
+        let m: Manifest = serde_json::from_str(MANIFEST).unwrap();
+        ingest_manifest(&m, "main", Some("wh"), None)
+    }
+
+    fn node<'a>(i: &'a IngestedManifest, id: &str) -> &'a IngestedNode {
+        i.nodes.iter().find(|n| n.unique_id == id).unwrap()
+    }
+
+    // dbt's four materializations must land on Windmill's four write
+    // strategies, or the graph shows a model's write semantics wrong.
+    #[test]
+    fn materializations_map_onto_write_strategies() {
+        let i = ingested();
+        for (id, expected) in [
+            ("model.jaffle_shop.customers", Some("replace")),
+            ("model.jaffle_shop.orders_daily", Some("merge")),
+            ("model.jaffle_shop.order_events", Some("append")),
+            // A composite key is still an upsert; only its columns are
+            // unmappable, so `unique_key` stays NULL while the strategy is merge.
+            ("model.jaffle_shop.composite_key", Some("merge")),
+            ("snapshot.jaffle_shop.customers_snapshot", Some("scd2")),
+            // `ephemeral` is inlined as a CTE and writes nothing; `view`
+            // produces a relation but performs no write. Neither has a
+            // strategy, and inventing one would misreport the model.
+            ("model.jaffle_shop.ephemeral_helper", None),
+        ] {
+            assert_eq!(
+                node(&i, id).materialize_strategy.as_deref(),
+                expected,
+                "{id}"
+            );
+        }
+    }
+
+    // The four dbt generic tests are the four `// data_test` kinds. Package
+    // tests keep their namespaced name instead of being dropped.
+    #[test]
+    fn generic_tests_carry_their_kind_column_and_severity() {
+        let i = ingested();
+        let unique = node(&i, "test.jaffle_shop.unique_customers_customer_id.c5");
+        assert_eq!(unique.test_kind.as_deref(), Some("unique"));
+        assert_eq!(unique.test_column.as_deref(), Some("customer_id"));
+        assert_eq!(
+            unique.attached_node.as_deref(),
+            Some("model.jaffle_shop.customers")
+        );
+        assert_eq!(unique.severity.as_deref(), Some("ERROR"));
+
+        let av = node(
+            &i,
+            "test.jaffle_shop.accepted_values_orders_daily_status.14",
+        );
+        assert_eq!(av.test_kind.as_deref(), Some("accepted_values"));
+        assert_eq!(av.test_args.as_ref().unwrap()["values"][0], "completed");
+
+        let pkg = node(
+            &i,
+            "test.jaffle_shop.dbt_utils_accepted_range_customers_n_orders__0.cb",
+        );
+        assert_eq!(pkg.test_kind.as_deref(), Some("dbt_utils.accepted_range"));
+        // dbt-core 1.x echoes the author's casing, 2.x uppercases it — readers
+        // must compare case-insensitively.
+        assert_eq!(pkg.severity.as_deref(), Some("warn"));
+    }
+
+    // A source's `name` is what `source()` refers to; its `identifier` is the
+    // table. Keying on the logical name would name a relation that does not
+    // exist, so nothing reading the real one could ever join it.
+    #[test]
+    fn sources_key_on_their_identifier_not_their_logical_name() {
+        let i = ingested();
+        assert_eq!(
+            node(&i, "source.jaffle_shop.jaffle_raw.raw_orders")
+                .asset_path
+                .as_deref(),
+            Some("main/jaffle_raw/raw_orders")
+        );
+    }
+
+    // The whole reason for `dbt://`: a model's key is the physical relation,
+    // so a native script reading the same table lands on the same node.
+    // Identifiers are canonicalized, and the database appears only when a model
+    // overrode the target's.
+    #[test]
+    fn models_become_table_assets_keyed_on_the_warehouse() {
+        let i = ingested();
+        assert_eq!(
+            node(&i, "model.jaffle_shop.customers")
+                .asset_path
+                .as_deref(),
+            Some("main/jaffle_dbt/customers")
+        );
+        // `order_events` overrode its database. Dropping that would collapse it
+        // onto a same-named relation in the target's own database, merging their
+        // lineage and cascading into each other's consumers.
+        assert_eq!(
+            node(&i, "model.jaffle_shop.order_events")
+                .asset_path
+                .as_deref(),
+            Some("main/archive.jaffle_dbt/order_events")
+        );
+        // `config.schema` on the snapshot is the custom SUFFIX (`snapshots`);
+        // the relation actually lives in the resolved `jaffle_dbt_snapshots`.
+        // Keying on the config value would name a table that does not exist.
+        assert_eq!(
+            node(&i, "snapshot.jaffle_shop.customers_snapshot")
+                .asset_path
+                .as_deref(),
+            Some("main/jaffle_dbt_snapshots/customers_snapshot")
+        );
+        // No physical relation, no asset: nothing to key a `dbt://` path on.
+        assert_eq!(
+            node(&i, "model.jaffle_shop.ephemeral_helper").asset_path,
+            None
+        );
+        assert_eq!(
+            node(&i, "test.jaffle_shop.unique_customers_customer_id.c5").asset_path,
+            None
+        );
+    }
+
+    // `/` is what separates the segments a `dbt://` key is read back by, and a
+    // quoted identifier may legally contain one — so two different relations
+    // would spell the same key and share a node, its lineage and its progress.
+    #[test]
+    fn a_relation_whose_identifier_carries_a_separator_gets_no_key() {
+        // The collision: `schema="a/b", name="c"` against `schema="a", name="b/c"`.
+        assert_eq!(table_asset_path("main", None, "a/b", "c", None), None);
+        assert_eq!(table_asset_path("main", None, "a", "b/c", None), None);
+        // A qualifying database is part of the same segment, so it counts too.
+        assert_eq!(
+            table_asset_path("main", Some("d/b"), "s", "t", Some("other")),
+            None
+        );
+        assert_eq!(
+            table_asset_path("main", None, "a", "c", None).as_deref(),
+            Some("main/a/c")
+        );
+    }
+
+    // Models are what the script produces; sources are what it consumes. Get
+    // this backwards and the cascade either never fires or fires on itself.
+    #[test]
+    fn script_writes_its_models_and_reads_its_sources() {
+        let i = ingested();
+        let got: Vec<(String, Option<AssetUsageAccessType>)> = i
+            .assets
+            .iter()
+            .map(|a| {
+                assert_eq!(a.kind, AssetKind::Dbt);
+                (a.path.clone(), a.access_type)
+            })
+            .collect();
+        assert_eq!(
+            got,
+            vec![
+                (
+                    "main/archive.jaffle_dbt/order_events".into(),
+                    Some(AssetUsageAccessType::W)
+                ),
+                (
+                    "main/jaffle_dbt/composite_key".into(),
+                    Some(AssetUsageAccessType::W)
+                ),
+                (
+                    "main/jaffle_dbt/customers".into(),
+                    Some(AssetUsageAccessType::W)
+                ),
+                (
+                    "main/jaffle_dbt/orders_daily".into(),
+                    Some(AssetUsageAccessType::W)
+                ),
+                (
+                    "main/jaffle_dbt/stg_customers".into(),
+                    Some(AssetUsageAccessType::W)
+                ),
+                (
+                    "main/jaffle_dbt_snapshots/customers_snapshot".into(),
+                    Some(AssetUsageAccessType::W)
+                ),
+                (
+                    "main/jaffle_raw/raw_orders".into(),
+                    Some(AssetUsageAccessType::R)
+                ),
+            ]
+        );
+    }
+
+    // Splitting a project across scripts only composes if the seam still draws:
+    // a script selecting a model whose parent another script builds must keep
+    // that parent as an endpoint, or the two relations sit on the graph with no
+    // line between them and the lineage silently stops at the selection border.
+    #[test]
+    fn a_parent_outside_the_selection_still_anchors_its_edge() {
+        let m: Manifest = serde_json::from_str(MANIFEST).unwrap();
+        // `customers` depends on `orders_daily`, which this script does not build.
+        let sel: std::collections::HashSet<String> = ["model.jaffle_shop.customers".to_string()]
+            .into_iter()
+            .collect();
+        let i = ingest_manifest(&m, "main", Some("wh"), Some(&sel));
+        let owned: Vec<&str> = i
+            .assets
+            .iter()
+            .filter(|a| a.access_type == Some(AssetUsageAccessType::W))
+            .map(|a| a.path.as_str())
+            .collect();
+        // The parent is NOT claimed as a write: the other script builds it.
+        assert_eq!(owned, vec!["main/jaffle_dbt/customers"]);
+        let reads: Vec<&str> = i
+            .assets
+            .iter()
+            .filter(|a| a.access_type == Some(AssetUsageAccessType::R))
+            .map(|a| a.path.as_str())
+            .collect();
+        assert!(
+            reads.contains(&"main/jaffle_dbt/orders_daily"),
+            "the unselected parent is an input, got {reads:?}"
+        );
+        assert!(
+            i.edges.contains(&(
+                "model.jaffle_shop.orders_daily".to_string(),
+                "model.jaffle_shop.customers".to_string()
+            )),
+            "the cross-selection edge must survive, got {:?}",
+            i.edges
+        );
+    }
+
+    // A script that builds a subset must not register as the producer of the
+    // whole project: two scripts splitting one project would each claim all of it.
+    #[test]
+    fn selection_scopes_what_the_script_owns() {
+        let m: Manifest = serde_json::from_str(MANIFEST).unwrap();
+        let sel: std::collections::HashSet<String> = ["model.jaffle_shop.orders_daily".to_string()]
+            .into_iter()
+            .collect();
+        let i = ingest_manifest(&m, "main", Some("wh"), Some(&sel));
+        let owned: Vec<&str> = i
+            .assets
+            .iter()
+            .filter(|a| a.access_type == Some(AssetUsageAccessType::W))
+            .map(|a| a.path.as_str())
+            .collect();
+        assert_eq!(owned, vec!["main/jaffle_dbt/orders_daily"]);
+        // The source the selected model reads is kept — that is how the graph
+        // knows the input. A source only unselected models read is NOT, or the
+        // script would subscribe to tables it never touches.
+        let reads: Vec<&str> = i
+            .assets
+            .iter()
+            .filter(|a| a.access_type == Some(AssetUsageAccessType::R))
+            .map(|a| a.path.as_str())
+            .collect();
+        assert_eq!(reads, vec!["main/jaffle_raw/raw_orders"]);
+        // Edges to nodes this script does not own are dropped with them.
+        assert_eq!(
+            i.edges,
+            vec![(
+                "source.jaffle_shop.jaffle_raw.raw_orders".to_string(),
+                "model.jaffle_shop.orders_daily".to_string()
+            )]
+        );
+    }
+
+    // The graph renders a model by its own SQL, so the ingest has to carry it —
+    // and a test's generated body is noise nobody reads.
+    #[test]
+    fn models_carry_their_sql_and_tests_do_not() {
+        let i = ingested();
+        let m = node(&i, "model.jaffle_shop.customers");
+        assert!(
+            m.raw_code.as_deref().is_some_and(|c| !c.is_empty()),
+            "{:?}",
+            m.raw_code
+        );
+        assert_eq!(
+            m.original_file_path.as_deref(),
+            Some("models/customers.sql")
+        );
+        let t = i.nodes.iter().find(|n| n.resource_type == "test").unwrap();
+        assert_eq!(t.raw_code, None);
+    }
+
+    // A read is an upstream edge, so a source no model reads must not
+    // become one — otherwise loading an unused table dispatches the whole dbt
+    // script. This holds for the unselected, whole-project case too, which is
+    // the common one.
+    #[test]
+    fn a_source_nothing_reads_is_not_an_input() {
+        let mut v: serde_json::Value = serde_json::from_str(MANIFEST).unwrap();
+        v["sources"]["source.jaffle_shop.jaffle_raw.unused"] = serde_json::json!({
+            "resource_type": "source", "name": "unused", "identifier": "unused",
+            "schema": "jaffle_raw", "relation_name": "\"wh\".\"jaffle_raw\".\"unused\""
+        });
+        let m: Manifest = serde_json::from_value(v).unwrap();
+        let i = ingest_manifest(&m, "main", Some("wh"), None);
+        let reads: Vec<&str> = i
+            .assets
+            .iter()
+            .filter(|a| a.access_type == Some(AssetUsageAccessType::R))
+            .map(|a| a.path.as_str())
+            .collect();
+        assert!(
+            !reads.contains(&"main/jaffle_raw/unused"),
+            "unused source registered as a read: {reads:?}"
+        );
+        assert!(reads.contains(&"main/jaffle_raw/raw_orders"), "{reads:?}");
+    }
+
+    // Splitting a project across scripts only composes if the downstream one
+    // reads what the upstream one writes: without that read there is no edge
+    // so the seam between two scripts splitting one project still draws.
+    #[test]
+    fn a_selected_script_reads_the_upstream_models_another_script_builds() {
+        let m: Manifest = serde_json::from_str(MANIFEST).unwrap();
+        // `customers` is selected; its parent `orders_daily` is built elsewhere.
+        let sel: std::collections::HashSet<String> = ["model.jaffle_shop.customers".to_string()]
+            .into_iter()
+            .collect();
+        let i = ingest_manifest(&m, "main", Some("wh"), Some(&sel));
+        let by_access = |t: AssetUsageAccessType| -> Vec<&str> {
+            i.assets
+                .iter()
+                .filter(|a| a.access_type == Some(t))
+                .map(|a| a.path.as_str())
+                .collect()
+        };
+        assert_eq!(
+            by_access(AssetUsageAccessType::W),
+            vec!["main/jaffle_dbt/customers"]
+        );
+        assert_eq!(
+            by_access(AssetUsageAccessType::R),
+            vec!["main/jaffle_dbt/orders_daily"]
+        );
+
+        // Selecting a model also selects its tests, and the `relationships`
+        // test on orders_daily points at stg_customers. A script that only
+        // builds staging models must not end up subscribed to the mart it is
+        // merely asserted against.
+        let staging: std::collections::HashSet<String> = [
+            "model.jaffle_shop.stg_customers".to_string(),
+            "test.jaffle_shop.relationships_orders_daily_customer_id.ab".to_string(),
+        ]
+        .into_iter()
+        .collect();
+        let i = ingest_manifest(&m, "main", Some("wh"), Some(&staging));
+        assert!(
+            !i.assets.iter().any(|a| a.path.ends_with("/orders_daily")),
+            "a test's dependency must not become a read: {:?}",
+            i.assets.iter().map(|a| &a.path).collect::<Vec<_>>()
+        );
+    }
+
+    // An ephemeral parent is inlined as a CTE and produces nothing to depend on,
+    // but what IT reads is still the selected model's real input — stopping
+    // there loses the edge and the model shows no upstream.
+    #[test]
+    fn dependencies_traverse_through_ephemeral_parents() {
+        let m: Manifest = serde_json::from_str(
+            r#"{"nodes":{
+              "model.p.mart":{"resource_type":"model","name":"mart","alias":"mart",
+                "schema":"s","database":"wh","relation_name":"\"wh\".\"s\".\"mart\"",
+                "config":{"materialized":"table"}},
+              "model.p.helper":{"resource_type":"model","name":"helper","schema":"s",
+                "relation_name":null,"config":{"materialized":"ephemeral"}},
+              "model.p.base":{"resource_type":"model","name":"base","alias":"base",
+                "schema":"s","database":"wh","relation_name":"\"wh\".\"s\".\"base\"",
+                "config":{"materialized":"view"}}},
+              "parent_map":{"model.p.mart":["model.p.helper"],
+                            "model.p.helper":["model.p.base"]}}"#,
+        )
+        .unwrap();
+        let sel: std::collections::HashSet<String> =
+            ["model.p.mart".to_string()].into_iter().collect();
+        let i = ingest_manifest(&m, "main", Some("wh"), Some(&sel));
+        let reads: Vec<&str> = i
+            .assets
+            .iter()
+            .filter(|a| a.access_type == Some(AssetUsageAccessType::R))
+            .map(|a| a.path.as_str())
+            .collect();
+        assert_eq!(reads, vec!["main/s/base"]);
+    }
+
+    // `A -> ephemeral -> B` must still read as `A -> B`: the ephemeral node has
+    // no relation to draw, but the lineage it carries is real, and dropping both
+    // of its edges leaves the reader with none.
+    #[test]
+    fn lineage_contracts_through_ephemeral_models() {
+        let m: Manifest = serde_json::from_str(
+            r#"{"nodes":{
+              "model.p.a":{"resource_type":"model","name":"a","alias":"a","schema":"s",
+                "database":"wh","relation_name":"\"wh\".\"s\".\"a\"",
+                "config":{"materialized":"view"}},
+              "model.p.e":{"resource_type":"model","name":"e","schema":"s",
+                "relation_name":null,"config":{"materialized":"ephemeral"}},
+              "model.p.b":{"resource_type":"model","name":"b","alias":"b","schema":"s",
+                "database":"wh","relation_name":"\"wh\".\"s\".\"b\"",
+                "config":{"materialized":"table"}}},
+              "parent_map":{"model.p.e":["model.p.a"],"model.p.b":["model.p.e"]}}"#,
+        )
+        .unwrap();
+        let i = ingest_manifest(&m, "main", Some("wh"), None);
+        assert_eq!(
+            i.edges,
+            vec![("model.p.a".to_string(), "model.p.b".to_string())]
+        );
+    }
+
+    #[test]
+    fn ref_edges_come_from_the_parent_map() {
+        let i = ingested();
+        assert_eq!(
+            i.edges,
+            vec![
+                (
+                    "model.jaffle_shop.orders_daily".to_string(),
+                    "model.jaffle_shop.customers".to_string()
+                ),
+                // A test's own edges are kept — the graph renders them — even
+                // though they do not make the script depend on what they assert.
+                (
+                    "model.jaffle_shop.orders_daily".to_string(),
+                    "test.jaffle_shop.relationships_orders_daily_customer_id.ab".to_string()
+                ),
+                (
+                    "model.jaffle_shop.stg_customers".to_string(),
+                    "test.jaffle_shop.relationships_orders_daily_customer_id.ab".to_string()
+                ),
+                (
+                    "source.jaffle_shop.jaffle_raw.raw_orders".to_string(),
+                    "model.jaffle_shop.orders_daily".to_string()
+                ),
+            ]
+        );
+    }
+
+    /// The whole manifest crosses the wire when an agent worker publishes its
+    /// graph, so what `ingest_manifest` produces has to survive its own
+    /// serializer. A field skipped when empty and required on the way back makes
+    /// every publish a 422 — invisible to a normal worker, which writes the rows
+    /// directly.
+    #[test]
+    fn an_ingested_manifest_survives_the_agent_wire() {
+        let manifest: Manifest = serde_json::from_str(
+            r#"{"nodes":{"model.p.customers":{
+                 "resource_type":"model","name":"customers","alias":"customers",
+                 "schema":"analytics","database":"wh",
+                 "relation_name":"\"wh\".\"analytics\".\"customers\""}},
+               "parent_map":{"model.p.customers":[]}}"#,
+        )
+        .unwrap();
+        let ingested = ingest_manifest(&manifest, "main", Some("wh"), None);
+        assert!(!ingested.assets.is_empty(), "fixture must produce an asset");
+
+        let wire = serde_json::to_value(&ingested).unwrap();
+        let back: IngestedManifest = serde_json::from_value(wire.clone())
+            .unwrap_or_else(|e| panic!("agent publish would 422: {e}\npayload: {wire}"));
+        assert_eq!(back.nodes.len(), ingested.nodes.len());
+        assert_eq!(back.assets.len(), ingested.assets.len());
+        assert_eq!(back.assets[0].path, ingested.assets[0].path);
+    }
+}
+
+/// Record one model's state for THIS RUN.
+///
+/// NO AUTHORIZATION: writes whatever `w_id`/`job_id` it is given. Callers MUST
+/// already have established that the job is theirs — the API route takes the id
+/// from the token rather than the body for exactly this reason — and MUST pass a
+/// job that belongs to that workspace.
+///
+/// Alongside `record_materialization`, never instead of it: that table holds the
+/// current state of a relation, one row, and its `job_id` is only the last
+/// writer — two runs of a project building the same models overwrite each
+/// other's. The run page needs what THIS job did, so it gets its own rows.
+///
+/// Shared with the API because an agent worker has no database and posts its
+/// settled outcomes to a route that calls this same function — two spellings of
+/// the row would drift.
+pub async fn record_run_progress(
+    db: &crate::DB,
+    w_id: &str,
+    job_id: &uuid::Uuid,
+    asset_path: &str,
+    status: crate::materialization::MaterializationStatus,
+    row_count: Option<i64>,
+    error: Option<&str>,
+) {
+    let res = sqlx::query!(
+        "INSERT INTO dbt_run_progress
+           (workspace_id, job_id, asset_kind, asset_path, status, row_count, error, updated_at)
+         VALUES ($1, $2, 'dbt', $3, $4, $5, $6, now())
+         ON CONFLICT (workspace_id, job_id, asset_kind, asset_path)
+         DO UPDATE SET status = EXCLUDED.status, row_count = EXCLUDED.row_count,
+                       error = EXCLUDED.error, updated_at = now()",
+        w_id,
+        job_id,
+        asset_path,
+        status as crate::materialization::MaterializationStatus,
+        row_count,
+        error,
+    )
+    .execute(db)
+    .await;
+    if let Err(e) = res {
+        // Progress is a display, not the run: a failure here must not fail a
+        // build that is otherwise fine.
+        tracing::warn!("recording dbt run progress for {asset_path}: {e:#}");
+    }
+}
+
+/// One settled node, posted by a worker that has no database.
+#[derive(serde::Serialize, serde::Deserialize)]
+pub struct DbtRunProgressRequest {
+    pub asset_path: String,
+    pub status: crate::materialization::MaterializationStatus,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub row_count: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
diff --git a/backend/windmill-common/src/global_settings.rs b/backend/windmill-common/src/global_settings.rs
index 6fb435cd71..c9b5a46989 100644
--- a/backend/windmill-common/src/global_settings.rs
+++ b/backend/windmill-common/src/global_settings.rs
@@ -123,7 +123,8 @@ pub const GITHUB_APP_WEBHOOK_BASE_URL_SETTING: &str = "github_app_webhook_base_u
 /// reconcile logs.
 pub fn validate_webhook_base_url(value: &str) -> Result<(), String> {
     let value = value.trim();
-    let url = url::Url::parse(value).map_err(|e| format!("must be an absolute http(s) URL: {e}"))?;
+    let url =
+        url::Url::parse(value).map_err(|e| format!("must be an absolute http(s) URL: {e}"))?;
     if !url.username().is_empty() || url.password().is_some() {
         return Err(
             "must not embed a username or password: the receiver URL is stored in workspace settings, where it is readable by workspace admins".to_string(),
diff --git a/backend/windmill-common/src/instance_config.rs b/backend/windmill-common/src/instance_config.rs
index 41b5cfd5e3..f47875bc8b 100644
--- a/backend/windmill-common/src/instance_config.rs
+++ b/backend/windmill-common/src/instance_config.rs
@@ -1320,7 +1320,9 @@ pub async fn sync_global_settings_declarative(
                 serde_json::Value::Object(_) => "an object",
                 _ => "a non-string value",
             };
-            return Err(anyhow::anyhow!("{webhook_key} must be a URL string, got {kind}"));
+            return Err(anyhow::anyhow!(
+                "{webhook_key} must be a URL string, got {kind}"
+            ));
         }
     }
 
diff --git a/backend/windmill-common/src/lib.rs b/backend/windmill-common/src/lib.rs
index 30a5edad32..0b1f5a0ef0 100644
--- a/backend/windmill-common/src/lib.rs
+++ b/backend/windmill-common/src/lib.rs
@@ -29,6 +29,7 @@ use sqlx::{Acquire, Postgres};
 pub mod agent_workers;
 pub mod apps;
 pub mod assets;
+pub mod dbt_manifest;
 pub mod audit;
 pub mod auth;
 #[cfg(feature = "benchmark")]
diff --git a/backend/windmill-common/src/worker.rs b/backend/windmill-common/src/worker.rs
index 226d74cf47..acc474c868 100644
--- a/backend/windmill-common/src/worker.rs
+++ b/backend/windmill-common/src/worker.rs
@@ -305,6 +305,7 @@ lazy_static::lazy_static! {
         "ruby".to_string(),
         "rlang".to_string(),
         "duckdb".to_string(),
+        "dbt".to_string(),
         // for related places search: ADD_NEW_LANG
         "dependency".to_string(),
         "flow".to_string(),
diff --git a/backend/windmill-common/src/workspaces.rs b/backend/windmill-common/src/workspaces.rs
index 2af5afaf77..ded6c35ae3 100644
--- a/backend/windmill-common/src/workspaces.rs
+++ b/backend/windmill-common/src/workspaces.rs
@@ -2477,4 +2477,134 @@ mod tests {
         assert!(msg.contains("staging"), "{msg}");
         assert!(msg.contains("tab=windmill_data_tables"), "{msg}");
     }
+
+    #[test]
+    fn test_dbt_warehouse_name_length_bound() {
+        assert!(validate_dbt_warehouse_name(&"a".repeat(MAX_DBT_WAREHOUSE_NAME_LEN)).is_ok());
+        assert!(validate_dbt_warehouse_name(&"a".repeat(MAX_DBT_WAREHOUSE_NAME_LEN + 1)).is_err());
+    }
+}
+
+/// Whether a workspace configures this warehouse, without resolving it.
+///
+/// For the one caller that needs the NAME and nothing else: a project bringing
+/// its own `profiles.yml` names a warehouse to say where its assets belong, and
+/// decrypting a connection it will never open to answer that would be waste.
+///
+/// NO AUTHORIZATION, like the resolver it delegates to: it reads workspace
+/// settings for whatever `w_id` it is given, so callers MUST already be scoped
+/// to that workspace.
+pub async fn dbt_warehouse_exists(db: &DB, w_id: &str, warehouse: &str) -> Result<()> {
+    dbt_warehouse_resource(db, w_id, warehouse)
+        .await
+        .map(|_| ())
+}
+
+/// The longest warehouse name a workspace may configure.
+///
+/// It is the first segment of every `dbt://<warehouse>/<schema>/<name>` key, and
+/// those land in `asset.path`, a VARCHAR(255). A name near that width would push
+/// ordinary relations past the column, and the ingest's own bound would then
+/// skip them — a graph quietly missing models. 64 leaves room for two 63-char
+/// identifiers, which is Postgres's own limit; warehouses that allow longer ones
+/// still rely on that ingest bound as the backstop.
+pub const MAX_DBT_WAREHOUSE_NAME_LEN: usize = 64;
+
+/// A warehouse name is a URL path segment for a worker with no database, so a
+/// name that could re-cut the path (or the query) is refused — at every place a
+/// name enters, not only where one is written, since a descriptor names one too.
+pub fn validate_dbt_warehouse_name(name: &str) -> Result<()> {
+    if name.is_empty()
+        || !name
+            .chars()
+            .all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-')
+    {
+        return Err(Error::BadRequest(format!(
+            "`{name}` is not a usable dbt warehouse name: use letters, digits, `_` and `-`"
+        )));
+    }
+    if name.chars().count() > MAX_DBT_WAREHOUSE_NAME_LEN {
+        return Err(Error::BadRequest(format!(
+            "`{name}` is too long for a dbt warehouse name (max {MAX_DBT_WAREHOUSE_NAME_LEN}): it \
+             prefixes every asset path this warehouse's models are keyed on"
+        )));
+    }
+    Ok(())
+}
+
+/// A dbt warehouse's resolved connection: the value a `profiles.yml` is rendered
+/// from, and the target the workspace names for it.
+///
+/// Carries CREDENTIALS. dbt is unpermissioned by design (docs/dbt-runtime.md,
+/// Decision 24), so this is served to a running job rather than gated on the
+/// runner's access to the resource — but it must never reach a route a user can
+/// browse.
+#[derive(serde::Serialize, serde::Deserialize)]
+pub struct DbtWarehouseConnection {
+    pub value: serde_json::Value,
+    /// Omitted rather than null when absent, so the wire shape matches the
+    /// schema generated clients validate against.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<String>,
+}
+
+/// The warehouse a dbt project runs against, by name — `main` when the
+/// descriptor names none.
+///
+/// NO AUTHORIZATION: reads workspace settings for whatever `w_id` it is given.
+/// Callers MUST already be scoped to that workspace — a running job, or a route
+/// that checked its token. What it returns is a POINTER; resolving it is a
+/// separate step, and dbt warehouses are unpermissioned there (Decision 24), so
+/// the pointer is not the last line of defence. A descriptor cannot name a
+/// resource at all, which is what makes the workspace the only place a
+/// warehouse is configured — and
+/// what lets asset identity key on the NAME (`dbt://main/analytics/orders`),
+/// one spelling every project on that warehouse shares.
+pub async fn dbt_warehouse_resource(
+    db: &DB,
+    w_id: &str,
+    warehouse: &str,
+) -> Result<(String, Option<String>)> {
+    let cfg = sqlx::query_scalar!(
+        "SELECT dbt_warehouses FROM workspace_settings WHERE workspace_id = $1",
+        w_id
+    )
+    .fetch_optional(db)
+    .await?
+    .flatten()
+    .unwrap_or(serde_json::Value::Null);
+    let entry = cfg.get(warehouse).cloned().ok_or_else(|| {
+        let configured = cfg
+            .as_object()
+            .map(|o| o.keys().cloned().collect::<Vec<_>>())
+            .unwrap_or_default();
+        Error::NotFound(if configured.is_empty() {
+            format!(
+                "no dbt warehouse is configured for this workspace — an admin adds one under \
+                 Settings → dbt, and a project reaches it by name (`{warehouse}` here)"
+            )
+        } else {
+            format!(
+                "dbt warehouse `{warehouse}` is not configured for this workspace (configured: \
+                 {})",
+                configured.join(", ")
+            )
+        })
+    })?;
+    let path = entry
+        .get("resource_path")
+        .and_then(|p| p.as_str())
+        .ok_or_else(|| {
+            Error::internal_err(format!(
+                "dbt warehouse `{warehouse}` names no resource_path"
+            ))
+        })?;
+    // Stored with or without the prefix, like the storage configs; the caller
+    // resolves a bare path.
+    let path = path.strip_prefix("$res:").unwrap_or(path).to_string();
+    let target = entry
+        .get("target")
+        .and_then(|t| t.as_str())
+        .map(|t| t.to_string());
+    Ok((path, target))
 }
diff --git a/backend/windmill-common/tests/dbt_graph_storage.rs b/backend/windmill-common/tests/dbt_graph_storage.rs
new file mode 100644
index 0000000000..73a3320456
--- /dev/null
+++ b/backend/windmill-common/tests/dbt_graph_storage.rs
@@ -0,0 +1,345 @@
+//! The dbt graph's storage invariants, against a real database.
+//!
+//! Every defect found in this area across review was DB-shaped — which row set
+//! a read resolves to, which rows a clear takes, whether a snapshot exists at
+//! all — and none of it is reachable from a unit test on a pure function. These
+//! pin the answers that took several rounds to settle.
+
+use sqlx::{Pool, Postgres};
+use windmill_common::dbt_manifest::{
+    clear_dbt_manifest, clear_dbt_manifest_version, prune_dbt_run_graphs, replace_dbt_manifest,
+    IngestedManifest, IngestedNode, DEPLOYED_GRAPH, DEPLOYED_GRAPH_VERSIONS_KEPT,
+};
+
+const WS: &str = "test-workspace";
+const PATH: &str = "f/test/proj";
+
+async fn deploy_script(db: &Pool<Postgres>, hash: i64) {
+    sqlx::query!(
+        "INSERT INTO script (workspace_id, hash, path, summary, description, content, created_by,
+                             language, lock)
+         VALUES ($1, $2, $3, '', '', 'profile: {}', 'test-user', 'dbt', '')",
+        WS,
+        hash,
+        PATH,
+    )
+    .execute(db)
+    .await
+    .unwrap();
+}
+
+fn manifest(names: &[&str]) -> IngestedManifest {
+    IngestedManifest {
+        nodes: names
+            .iter()
+            .map(|n| IngestedNode {
+                unique_id: format!("model.p.{n}"),
+                resource_type: "model".to_string(),
+                name: n.to_string(),
+                asset_path: Some(format!("u/a/wh/s/{n}")),
+                raw_code: Some(format!("select 1 as {n}")),
+                ..Default::default()
+            })
+            .collect(),
+        // Chained, so the edge insert actually runs: `ref()` lineage is in every
+        // real project, and a fixture with no edges leaves that statement
+        // unexecuted by every test in this file.
+        edges: names
+            .windows(2)
+            .map(|w| (format!("model.p.{}", w[0]), format!("model.p.{}", w[1])))
+            .collect(),
+        ..Default::default()
+    }
+}
+
+/// Edges for one version, so a test can assert the batched insert ran at all.
+async fn edges_for(db: &Pool<Postgres>, hash: i64) -> i64 {
+    sqlx::query_scalar!(
+        "SELECT count(*) FROM dbt_edge WHERE workspace_id = $1 AND script_hash = $2",
+        WS,
+        hash
+    )
+    .fetch_one(db)
+    .await
+    .unwrap()
+    .unwrap_or(0)
+}
+
+async fn nodes_for(db: &Pool<Postgres>, hash: i64, job: uuid::Uuid) -> i64 {
+    sqlx::query_scalar!(
+        "SELECT count(*) FROM dbt_node WHERE workspace_id = $1 AND script_hash = $2 AND job_id = $3",
+        WS,
+        hash,
+        job
+    )
+    .fetch_one(db)
+    .await
+    .unwrap()
+    .unwrap_or(0)
+}
+
+async fn markers_for_path(db: &Pool<Postgres>) -> i64 {
+    sqlx::query_scalar!(
+        "SELECT count(*) FROM dbt_graph_snapshot WHERE workspace_id = $1 AND script_path = $2",
+        WS,
+        PATH
+    )
+    .fetch_one(db)
+    .await
+    .unwrap()
+    .unwrap_or(0)
+}
+
+async fn markers(db: &Pool<Postgres>, hash: i64) -> i64 {
+    sqlx::query_scalar!(
+        "SELECT count(*) FROM dbt_graph_snapshot WHERE workspace_id = $1 AND script_hash = $2",
+        WS,
+        hash
+    )
+    .fetch_one(db)
+    .await
+    .unwrap()
+    .unwrap_or(0)
+}
+
+/// A run whose graph matches the version's stores nothing. Marking a descriptor
+/// dynamic is conservative — a `{{ }}` in `vars` says the arguments reach dbt,
+/// not that they change which models exist — so the usual dynamic run resolves
+/// to exactly the deployed graph, and storing a copy per run is what filled the
+/// table with an unchanging picture.
+#[sqlx::test(migrations = "../migrations", fixtures("base"))]
+async fn an_identical_run_stores_no_snapshot(db: Pool<Postgres>) {
+    deploy_script(&db, 1).await;
+    let m = manifest(&["a", "b"]);
+    let job = uuid::Uuid::from_u128(7);
+
+    let mut tx = db.begin().await.unwrap();
+    replace_dbt_manifest(&mut tx, WS, PATH, 1, None, &m, "root")
+        .await
+        .unwrap();
+    replace_dbt_manifest(&mut tx, WS, PATH, 1, Some(job), &m, "root")
+        .await
+        .unwrap();
+    tx.commit().await.unwrap();
+
+    assert_eq!(nodes_for(&db, 1, DEPLOYED_GRAPH).await, 2);
+    assert_eq!(
+        nodes_for(&db, 1, job).await,
+        0,
+        "identical run must not snapshot"
+    );
+    assert_eq!(markers(&db, 1).await, 1, "and leaves no marker of its own");
+}
+
+/// A run whose model set differs keeps its own, and the version's is untouched:
+/// this is what lets an older run page render the project that run built.
+#[sqlx::test(migrations = "../migrations", fixtures("base"))]
+async fn a_differing_run_keeps_its_own_snapshot(db: Pool<Postgres>) {
+    deploy_script(&db, 1).await;
+    let job = uuid::Uuid::from_u128(7);
+
+    let mut tx = db.begin().await.unwrap();
+    replace_dbt_manifest(&mut tx, WS, PATH, 1, None, &manifest(&["a"]), "root")
+        .await
+        .unwrap();
+    replace_dbt_manifest(
+        &mut tx,
+        WS,
+        PATH,
+        1,
+        Some(job),
+        &manifest(&["a", "b"]),
+        "root",
+    )
+    .await
+    .unwrap();
+    tx.commit().await.unwrap();
+
+    assert_eq!(nodes_for(&db, 1, DEPLOYED_GRAPH).await, 1);
+    assert_eq!(nodes_for(&db, 1, job).await, 2);
+}
+
+/// A dynamic run can disable every model. That empty graph is an answer, and it
+/// has to be distinguishable from a run that stored nothing — otherwise the run
+/// page falls back to the deployed models and shows what the run never built.
+#[sqlx::test(migrations = "../migrations", fixtures("base"))]
+async fn an_empty_run_graph_is_still_a_snapshot(db: Pool<Postgres>) {
+    deploy_script(&db, 1).await;
+    let job = uuid::Uuid::from_u128(7);
+
+    let mut tx = db.begin().await.unwrap();
+    replace_dbt_manifest(&mut tx, WS, PATH, 1, None, &manifest(&["a"]), "root")
+        .await
+        .unwrap();
+    replace_dbt_manifest(
+        &mut tx,
+        WS,
+        PATH,
+        1,
+        Some(job),
+        &IngestedManifest::default(),
+        "root",
+    )
+    .await
+    .unwrap();
+    tx.commit().await.unwrap();
+
+    assert_eq!(nodes_for(&db, 1, job).await, 0);
+    let marker = sqlx::query_scalar!(
+        "SELECT count(*) FROM dbt_graph_snapshot WHERE workspace_id = $1 AND job_id = $2",
+        WS,
+        job
+    )
+    .fetch_one(&db)
+    .await
+    .unwrap()
+    .unwrap_or(0);
+    assert_eq!(marker, 1, "an empty graph still has a marker");
+}
+
+/// Archiving or deleting ONE version must leave every other version's graph
+/// alone: the routes act on a single hash, and the other versions stay live and
+/// keep needing their own models, SQL and lineage.
+#[sqlx::test(migrations = "../migrations", fixtures("base"))]
+async fn clearing_one_version_leaves_the_others(db: Pool<Postgres>) {
+    deploy_script(&db, 1).await;
+    deploy_script(&db, 2).await;
+    let mut tx = db.begin().await.unwrap();
+    replace_dbt_manifest(&mut tx, WS, PATH, 1, None, &manifest(&["a"]), "root")
+        .await
+        .unwrap();
+    replace_dbt_manifest(&mut tx, WS, PATH, 2, None, &manifest(&["a", "b"]), "root")
+        .await
+        .unwrap();
+    tx.commit().await.unwrap();
+
+    let mut tx = db.begin().await.unwrap();
+    clear_dbt_manifest_version(&mut tx, WS, PATH, 1)
+        .await
+        .unwrap();
+    tx.commit().await.unwrap();
+
+    assert_eq!(nodes_for(&db, 1, DEPLOYED_GRAPH).await, 0);
+    assert_eq!(markers(&db, 1).await, 0, "the marker goes with the rows");
+    assert_eq!(
+        nodes_for(&db, 2, DEPLOYED_GRAPH).await,
+        2,
+        "the other version survives"
+    );
+    assert_eq!(markers(&db, 2).await, 1);
+    // The lineage is stored and cleared with its nodes. Asserted here because
+    // this is where two versions coexist: it pins the batched edge insert
+    // against a real database as well as the version scoping.
+    assert_eq!(edges_for(&db, 1).await, 0, "the cleared version's edges go");
+    assert_eq!(edges_for(&db, 2).await, 1, "the other version keeps its own");
+}
+
+/// The path-wide clear is for the routes that retire the whole path, and it has
+/// to take the markers too — a marker standing for rows that are gone is read
+/// as a snapshot, and its digest still answers the suppression check.
+#[sqlx::test(migrations = "../migrations", fixtures("base"))]
+async fn clearing_the_path_takes_markers_with_it(db: Pool<Postgres>) {
+    deploy_script(&db, 1).await;
+    deploy_script(&db, 2).await;
+    let mut tx = db.begin().await.unwrap();
+    replace_dbt_manifest(&mut tx, WS, PATH, 1, None, &manifest(&["a"]), "root")
+        .await
+        .unwrap();
+    replace_dbt_manifest(&mut tx, WS, PATH, 2, None, &manifest(&["b"]), "root")
+        .await
+        .unwrap();
+    clear_dbt_manifest(&mut tx, WS, PATH).await.unwrap();
+    tx.commit().await.unwrap();
+
+    assert_eq!(markers(&db, 1).await, 0);
+    assert_eq!(markers(&db, 2).await, 0);
+    assert_eq!(nodes_for(&db, 1, DEPLOYED_GRAPH).await, 0);
+}
+
+/// The sweep ages out run snapshots and never a version's own graph, which is
+/// what its runs render from for as long as the version exists.
+#[sqlx::test(migrations = "../migrations", fixtures("base"))]
+async fn the_sweep_takes_old_snapshots_and_spares_the_version(db: Pool<Postgres>) {
+    deploy_script(&db, 1).await;
+    let old = uuid::Uuid::from_u128(7);
+    let recent = uuid::Uuid::from_u128(8);
+
+    let mut tx = db.begin().await.unwrap();
+    replace_dbt_manifest(&mut tx, WS, PATH, 1, None, &manifest(&["a"]), "root")
+        .await
+        .unwrap();
+    replace_dbt_manifest(
+        &mut tx,
+        WS,
+        PATH,
+        1,
+        Some(old),
+        &manifest(&["a", "b"]),
+        "root",
+    )
+    .await
+    .unwrap();
+    replace_dbt_manifest(
+        &mut tx,
+        WS,
+        PATH,
+        1,
+        Some(recent),
+        &manifest(&["a", "c"]),
+        "root",
+    )
+    .await
+    .unwrap();
+    tx.commit().await.unwrap();
+
+    // Age one snapshot past the window, rows and marker together.
+    for t in ["dbt_node", "dbt_edge", "dbt_graph_snapshot"] {
+        sqlx::query(&format!(
+            "UPDATE {t} SET ingested_at = now() - interval '400 days' WHERE job_id = $1"
+        ))
+        .bind(old)
+        .execute(&db)
+        .await
+        .unwrap();
+    }
+
+    prune_dbt_run_graphs(&db, PATH, WS).await.unwrap();
+
+    assert_eq!(nodes_for(&db, 1, old).await, 0, "the aged snapshot goes");
+    assert_eq!(nodes_for(&db, 1, recent).await, 2, "the recent one stays");
+    assert_eq!(
+        nodes_for(&db, 1, DEPLOYED_GRAPH).await,
+        1,
+        "and a version's own graph is never swept"
+    );
+}
+
+/// A version's graph cannot expire on a clock — a run page is as old as its job
+/// — so growth is bounded by deploy COUNT instead. The newest deploys keep
+/// theirs; past that the oldest are reclaimed, which is what stops a CI that
+/// deploys on every commit from adding a model set per commit forever.
+#[sqlx::test(migrations = "../migrations", fixtures("base"))]
+async fn only_the_newest_deploys_keep_their_graph(db: Pool<Postgres>) {
+    let over = DEPLOYED_GRAPH_VERSIONS_KEPT + 3;
+    for h in 1..=over {
+        deploy_script(&db, h).await;
+        let mut tx = db.begin().await.unwrap();
+        replace_dbt_manifest(&mut tx, WS, PATH, h, None, &manifest(&["a"]), "root")
+            .await
+            .unwrap();
+        tx.commit().await.unwrap();
+    }
+    assert_eq!(markers_for_path(&db).await, over, "every deploy stored one");
+
+    prune_dbt_run_graphs(&db, PATH, WS).await.unwrap();
+
+    assert_eq!(
+        markers_for_path(&db).await,
+        DEPLOYED_GRAPH_VERSIONS_KEPT,
+        "the bound holds"
+    );
+    // The newest is always among them: losing the live version's graph would
+    // empty the page of every run of it.
+    assert_eq!(nodes_for(&db, over, DEPLOYED_GRAPH).await, 1);
+    assert_eq!(nodes_for(&db, 1, DEPLOYED_GRAPH).await, 0, "the oldest is reclaimed");
+}
diff --git a/backend/windmill-queue/src/asset_dispatch.rs b/backend/windmill-queue/src/asset_dispatch.rs
index abafdbc54e..0fd5af9f6d 100644
--- a/backend/windmill-queue/src/asset_dispatch.rs
+++ b/backend/windmill-queue/src/asset_dispatch.rs
@@ -66,7 +66,7 @@ use windmill_common::error::{self, Result};
 use windmill_common::get_latest_deployed_hash_for_path;
 use windmill_common::jobs::{JobKind, JobPayload, JobTriggerKind};
 use windmill_common::partition::PARTITION_ARG;
-use windmill_common::scripts::ScriptHash;
+use windmill_common::scripts::{ScriptHash, ScriptLang};
 use windmill_common::triggers::TriggerMetadata;
 use windmill_common::users::{get_email_from_permissioned_as, username_to_permissioned_as};
 use windmill_common::worker::to_raw_value;
@@ -245,6 +245,18 @@ async fn try_dispatch(db: &DB, job: &MiniCompletedJob) -> Result<DispatchResult>
     if job.parent_job.is_some() && !is_native_retry_attempt(db, job).await? {
         return Ok(DispatchResult::default());
     }
+    // A dbt run records the relations it builds, so it looks like a producer
+    // here — but dbt does not trigger downstream runs. Its own DAG is dbt's to
+    // order; the only thing a cascade would add is waking Windmill scripts that
+    // read a mart, and nothing outside dbt can declare a `dbt://` write, so
+    // that edge exists in one direction only. Cascading from a project whose
+    // per-run selection can build any subset of itself needs a per-run write set
+    // to be correct, which is a design worth doing deliberately rather than
+    // inferring. Until then dbt materializes and reports; it does not dispatch.
+    if job.script_lang == Some(ScriptLang::Dbt) {
+        return Ok(DispatchResult::default());
+    }
+
     let runnable_path = match job.runnable_path.as_deref() {
         Some(p) if !p.is_empty() => p,
         _ => return Ok(DispatchResult::default()),
@@ -263,6 +275,7 @@ async fn try_dispatch(db: &DB, job: &MiniCompletedJob) -> Result<DispatchResult>
         return Ok(DispatchResult::default());
     };
 
+
     let args = fetch_args(db, &job.workspace_id, job.id).await?;
     if read_skip_arg(args.as_ref()) {
         return Ok(DispatchResult::default());
diff --git a/backend/windmill-types/src/assets.rs b/backend/windmill-types/src/assets.rs
index fb624382c4..463a365b06 100644
--- a/backend/windmill-types/src/assets.rs
+++ b/backend/windmill-types/src/assets.rs
@@ -14,6 +14,18 @@ pub enum AssetKind {
     Ducklake,
     DataTable,
     Volume,
+    /// A warehouse relation a dbt project builds or reads,
+    /// `dbt://<warehouse>/<schema>/<name>`, where `<warehouse>` is the name the
+    /// workspace configures it under.
+    ///
+    /// The SCHEME names the producer — dbt is the only thing that creates one —
+    /// while the PATH stays the physical relation, because that is what two
+    /// projects agree on: a mart one builds is a `source` the next reads, and
+    /// their dbt `unique_id`s differ (`model.a.orders` vs
+    /// `source.b.analytics.orders`) where the relation does not
+    /// (docs/dbt-runtime.md, decision 11). A dbt run does not trigger that
+    /// reader — the shared node is lineage, not a cascade edge.
+    Dbt,
 }
 
 impl AssetKind {
@@ -28,6 +40,7 @@ impl AssetKind {
             AssetKind::Ducklake => Some("ducklake://"),
             AssetKind::DataTable => Some("datatable://"),
             AssetKind::Volume => Some("volume://"),
+            AssetKind::Dbt => Some("dbt://"),
             AssetKind::Variable => None,
         }
     }
diff --git a/backend/windmill-types/src/scripts.rs b/backend/windmill-types/src/scripts.rs
index 5e5c7f313e..8deec500a5 100644
--- a/backend/windmill-types/src/scripts.rs
+++ b/backend/windmill-types/src/scripts.rs
@@ -66,6 +66,7 @@ pub enum ScriptLang {
     Java,
     Ruby,
     Rlang,
+    Dbt,
     // for related places search: ADD_NEW_LANG
 }
 
@@ -96,6 +97,7 @@ impl ScriptLang {
             ScriptLang::Java => "java",
             ScriptLang::Ruby => "ruby",
             ScriptLang::Rlang => "rlang",
+            ScriptLang::Dbt => "dbt",
             // for related places search: ADD_NEW_LANG
         }
     }
@@ -134,7 +136,7 @@ impl ScriptLang {
         use ScriptLang::*;
         match self {
             Nativets | Bun | Bunnative | Deno | Go | Php | CSharp | Java => "//",
-            Python3 | Bash | Powershell | Graphql | Ansible | Nu | Ruby | Rlang => "#",
+            Python3 | Bash | Powershell | Graphql | Ansible | Nu | Ruby | Rlang | Dbt => "#",
             Postgresql | Mysql | Bigquery | Snowflake | Mssql | OracleDB | DuckDb => "--",
             Rust => "//!",
             // for related places search: ADD_NEW_LANG
@@ -170,6 +172,7 @@ impl FromStr for ScriptLang {
             "java" => ScriptLang::Java,
             "ruby" => ScriptLang::Ruby,
             "rlang" => ScriptLang::Rlang,
+            "dbt" => ScriptLang::Dbt,
             // for related places search: ADD_NEW_LANG
             language => return Err(anyhow::anyhow!("{} is currently not supported", language)),
         };
diff --git a/backend/windmill-worker/Cargo.toml b/backend/windmill-worker/Cargo.toml
index f4659f7d82..90b15fd1b5 100644
--- a/backend/windmill-worker/Cargo.toml
+++ b/backend/windmill-worker/Cargo.toml
@@ -82,6 +82,7 @@ tokio.workspace = true
 tokio-stream.workspace = true
 serde.workspace = true
 serde_json.workspace = true
+serde_yml.workspace = true
 futures.workspace = true
 async-recursion.workspace = true
 async-trait.workspace = true
diff --git a/backend/windmill-worker/nsjail/run.dbt.config.proto b/backend/windmill-worker/nsjail/run.dbt.config.proto
new file mode 100644
index 0000000000..192a12b3a5
--- /dev/null
+++ b/backend/windmill-worker/nsjail/run.dbt.config.proto
@@ -0,0 +1,138 @@
+name: "dbt run project"
+
+mode: ONCE
+hostname: "dbt"
+log_level: ERROR
+time_limit: {TIMEOUT}
+
+{RLIMIT_AS}
+rlimit_cpu: 1000
+rlimit_fsize: 1000
+rlimit_nofile: 10000
+
+cwd: "{PROJECT_DIR}"
+
+# The warehouse is remote for every adapter but DuckDB, so the network stays.
+clone_newnet: false
+clone_newuser: {CLONE_NEWUSER}
+
+skip_setsid: true
+keep_caps: false
+keep_env: true
+mount_proc: true
+
+mount {
+    src: "/bin"
+    dst: "/bin"
+    is_bind: true
+}
+
+mount {
+    src: "/lib"
+    dst: "/lib"
+    is_bind: true
+}
+
+mount {
+    src: "/lib64"
+    dst: "/lib64"
+    is_bind: true
+    mandatory: false
+}
+
+mount {
+    src: "/usr"
+    dst: "/usr"
+    is_bind: true
+}
+
+mount {
+    src: "/dev/null"
+    dst: "/dev/null"
+    is_bind: true
+    rw: true
+}
+
+mount {
+    src: "/dev/random"
+    dst: "/dev/random"
+    is_bind: true
+}
+
+mount {
+    src: "/dev/urandom"
+    dst: "/dev/urandom"
+    is_bind: true
+}
+
+mount {
+    dst: "/dev/shm"
+    fstype: "tmpfs"
+    rw: true
+    is_bind: false
+}
+
+{TMP_MOUNT_BLOCK}
+
+# The job's own directory: the project, the rendered profile, the artifacts
+# dbt writes and the logs the progress reporter tails all live under it.
+mount {
+    src: "{JOB_DIR}"
+    dst: "{JOB_DIR}"
+    is_bind: true
+    rw: true
+}
+
+# The engine and the interpreter it was built against, read-only: a project
+# must not be able to rewrite the dbt it is run by, or the one the next job
+# on this worker will be.
+mount {
+    src: "{ENGINE_DIR}"
+    dst: "{ENGINE_DIR}"
+    is_bind: true
+}
+
+mount {
+    src: "{PY_INSTALL_DIR}"
+    dst: "{PY_INSTALL_DIR}"
+    is_bind: true
+    mandatory: false
+}
+
+mount {
+    src: "/etc"
+    dst: "/etc"
+    is_bind: true
+}
+
+# Container runtimes bind exactly these 3 files as separate submounts over
+# /etc; nsjail's ro remount of /etc is non-recursive so they stay writable.
+# Load-bearing -- do not remove as redundant with the /etc bind above.
+mount {
+    src: "/etc/resolv.conf"
+    dst: "/etc/resolv.conf"
+    is_bind: true
+    mandatory: false
+}
+
+mount {
+    src: "/etc/hosts"
+    dst: "/etc/hosts"
+    is_bind: true
+    mandatory: false
+}
+
+mount {
+    src: "/etc/ssl/certs"
+    dst: "/etc/ssl/certs"
+    is_bind: true
+    mandatory: false
+}
+
+{SHARED_MOUNT}
+
+# The project's own environment. Set here rather than on the process that
+# execs nsjail: the loader honours `LD_PRELOAD` before the jail exists.
+{ENVARS}
+
+iface_no_lo: true
diff --git a/backend/windmill-worker/src/agent_workers.rs b/backend/windmill-worker/src/agent_workers.rs
index 5320c8ef6c..8dccf691fa 100644
--- a/backend/windmill-worker/src/agent_workers.rs
+++ b/backend/windmill-worker/src/agent_workers.rs
@@ -80,8 +80,6 @@ pub async fn get_datatable_resource_from_agent_http(
 
 /// Record a materialization outcome from an agent worker (no direct DB) via the
 /// API, so `materialized_partition` state lands the same as on a Sql worker.
-// Only called from the duckdb executor, which is itself `#[cfg(feature = "duckdb")]`.
-#[cfg(feature = "duckdb")]
 pub async fn record_materialization_from_agent_http(
     client: &HttpClient,
     w_id: &str,
diff --git a/backend/windmill-worker/src/ansible_executor.rs b/backend/windmill-worker/src/ansible_executor.rs
index d3e71d8fdb..5e151824f0 100644
--- a/backend/windmill-worker/src/ansible_executor.rs
+++ b/backend/windmill-worker/src/ansible_executor.rs
@@ -31,8 +31,9 @@ use crate::{
     bash_executor::BIN_BASH,
     common::{
         build_command_with_isolation, check_executor_binary_exists, get_reserved_variables,
-        read_and_check_result, render_nsjail_rlimit_as, resolve_nsjail_timeout,
-        resolve_nsjail_tmp_mount_block, start_child_process, transform_json, OccupancyMetrics,
+        interpolate_template, read_and_check_result, render_nsjail_rlimit_as,
+        resolve_nsjail_timeout, resolve_nsjail_tmp_mount_block, start_child_process,
+        transform_json, validate_relative_path, OccupancyMetrics,
     },
     handle_child::handle_child,
     is_sandboxing_enabled,
@@ -240,97 +241,6 @@ async fn prepare_socket_root(root: &str, stale_after: std::time::Duration) {
     }
 }
 
-lazy_static::lazy_static! {
-    static ref TEMPLATE_RE: regex::Regex = regex::Regex::new(r"\{\{\s*([A-Za-z_][A-Za-z0-9_]*)\s*\}\}").unwrap();
-}
-
-/// Substitute `{{ arg_name }}` placeholders with values from `args`.
-/// Strings are used raw; numbers/bools are stringified. Other types are rejected.
-fn interpolate_template(
-    template: &str,
-    args: Option<&HashMap<String, Box<RawValue>>>,
-    field_name: &str,
-) -> error::Result<String> {
-    let mut last_err: Option<error::Error> = None;
-    let result = TEMPLATE_RE.replace_all(template, |caps: &regex::Captures| {
-        let name = &caps[1];
-        let raw = args.and_then(|a| a.get(name));
-        let Some(raw) = raw else {
-            last_err = Some(error::Error::BadRequest(format!(
-                "`{}` references `{{{{ {} }}}}` but no such argument was provided",
-                field_name, name
-            )));
-            return String::new();
-        };
-        let json: serde_json::Value = match serde_json::from_str(raw.get()) {
-            Ok(v) => v,
-            Err(e) => {
-                last_err = Some(error::Error::BadRequest(format!(
-                    "`{}` could not parse argument `{}` as JSON: {e}",
-                    field_name, name
-                )));
-                return String::new();
-            }
-        };
-        match json {
-            serde_json::Value::String(s) => s,
-            serde_json::Value::Number(n) => n.to_string(),
-            serde_json::Value::Bool(b) => b.to_string(),
-            serde_json::Value::Null => {
-                last_err = Some(error::Error::BadRequest(format!(
-                    "`{}` references `{{{{ {} }}}}` but the argument is null",
-                    field_name, name
-                )));
-                String::new()
-            }
-            _ => {
-                last_err = Some(error::Error::BadRequest(format!(
-                    "`{}` references `{{{{ {} }}}}` but the argument is not a primitive (string/number/bool)",
-                    field_name, name
-                )));
-                String::new()
-            }
-        }
-    });
-    if let Some(e) = last_err {
-        return Err(e);
-    }
-    Ok(result.into_owned())
-}
-
-/// Reject absolute paths and `..` segments to prevent escaping the cloned repo directory.
-fn validate_relative_path(path: &str, field_name: &str) -> error::Result<()> {
-    let trimmed = path.trim();
-    if trimmed.is_empty() {
-        return Err(error::Error::BadRequest(format!(
-            "`{}` resolved to an empty path",
-            field_name
-        )));
-    }
-    let p = std::path::Path::new(trimmed);
-    for component in p.components() {
-        match component {
-            // RootDir catches leading `/` or `\`; Prefix catches Windows drive
-            // letters and UNC paths. `Path::is_absolute()` alone misses
-            // RootDir-only paths on Windows (e.g. `/etc/passwd`).
-            std::path::Component::RootDir | std::path::Component::Prefix(_) => {
-                return Err(error::Error::BadRequest(format!(
-                    "`{}` must be a relative path inside the cloned repo, got: {}",
-                    field_name, trimmed
-                )));
-            }
-            std::path::Component::ParentDir => {
-                return Err(error::Error::BadRequest(format!(
-                    "`{}` must not contain `..` segments, got: {}",
-                    field_name, trimmed
-                )));
-            }
-            _ => {}
-        }
-    }
-    Ok(())
-}
-
 async fn clone_repo(
     repo: &GitRepo,
     job_dir: &str,
diff --git a/backend/windmill-worker/src/common.rs b/backend/windmill-worker/src/common.rs
index 743b2acda4..cd493d969e 100644
--- a/backend/windmill-worker/src/common.rs
+++ b/backend/windmill-worker/src/common.rs
@@ -2339,3 +2339,95 @@ mod tests {
         assert!(result.is_err());
     }
 }
+
+lazy_static::lazy_static! {
+    static ref TEMPLATE_RE: regex::Regex =
+        regex::Regex::new(r"\{\{\s*([A-Za-z_][A-Za-z0-9_]*)\s*\}\}").unwrap();
+}
+
+/// Substitute `{{ arg_name }}` placeholders with values from `args`.
+/// Strings are used raw; numbers/bools are stringified. Other types are rejected.
+pub(crate) fn interpolate_template(
+    template: &str,
+    args: Option<&HashMap<String, Box<RawValue>>>,
+    field_name: &str,
+) -> error::Result<String> {
+    let mut last_err: Option<error::Error> = None;
+    let result = TEMPLATE_RE.replace_all(template, |caps: &regex::Captures| {
+        let name = &caps[1];
+        let raw = args.and_then(|a| a.get(name));
+        let Some(raw) = raw else {
+            last_err = Some(error::Error::BadRequest(format!(
+                "`{}` references `{{{{ {} }}}}` but no such argument was provided",
+                field_name, name
+            )));
+            return String::new();
+        };
+        let json: serde_json::Value = match serde_json::from_str(raw.get()) {
+            Ok(v) => v,
+            Err(e) => {
+                last_err = Some(error::Error::BadRequest(format!(
+                    "`{}` could not parse argument `{}` as JSON: {e}",
+                    field_name, name
+                )));
+                return String::new();
+            }
+        };
+        match json {
+            serde_json::Value::String(s) => s,
+            serde_json::Value::Number(n) => n.to_string(),
+            serde_json::Value::Bool(b) => b.to_string(),
+            serde_json::Value::Null => {
+                last_err = Some(error::Error::BadRequest(format!(
+                    "`{}` references `{{{{ {} }}}}` but the argument is null",
+                    field_name, name
+                )));
+                String::new()
+            }
+            _ => {
+                last_err = Some(error::Error::BadRequest(format!(
+                    "`{}` references `{{{{ {} }}}}` but the argument is not a primitive (string/number/bool)",
+                    field_name, name
+                )));
+                String::new()
+            }
+        }
+    });
+    if let Some(e) = last_err {
+        return Err(e);
+    }
+    Ok(result.into_owned())
+}
+
+/// Reject absolute paths and `..` segments to prevent escaping the cloned repo directory.
+pub(crate) fn validate_relative_path(path: &str, field_name: &str) -> error::Result<()> {
+    let trimmed = path.trim();
+    if trimmed.is_empty() {
+        return Err(error::Error::BadRequest(format!(
+            "`{}` resolved to an empty path",
+            field_name
+        )));
+    }
+    let p = std::path::Path::new(trimmed);
+    for component in p.components() {
+        match component {
+            // RootDir catches leading `/` or `\`; Prefix catches Windows drive
+            // letters and UNC paths. `Path::is_absolute()` alone misses
+            // RootDir-only paths on Windows (e.g. `/etc/passwd`).
+            std::path::Component::RootDir | std::path::Component::Prefix(_) => {
+                return Err(error::Error::BadRequest(format!(
+                    "`{}` must be a relative path inside the cloned repo, got: {}",
+                    field_name, trimmed
+                )));
+            }
+            std::path::Component::ParentDir => {
+                return Err(error::Error::BadRequest(format!(
+                    "`{}` must not contain `..` segments, got: {}",
+                    field_name, trimmed
+                )));
+            }
+            _ => {}
+        }
+    }
+    Ok(())
+}
diff --git a/backend/windmill-worker/src/csharp_executor.rs b/backend/windmill-worker/src/csharp_executor.rs
index 944236cf2b..132936a807 100644
--- a/backend/windmill-worker/src/csharp_executor.rs
+++ b/backend/windmill-worker/src/csharp_executor.rs
@@ -27,8 +27,8 @@ use windmill_queue::CanceledBy;
 use crate::{
     common::{
         build_command_with_isolation, check_executor_binary_exists, create_args_and_out_file,
-        get_reserved_variables, read_result, resolve_nsjail_timeout, resolve_nsjail_tmp_mount_block,
-        start_child_process, DEV_CONF_NSJAIL,
+        get_reserved_variables, read_result, resolve_nsjail_timeout,
+        resolve_nsjail_tmp_mount_block, start_child_process, DEV_CONF_NSJAIL,
     },
     get_proxy_envs_for_lang,
     handle_child::handle_child,
diff --git a/backend/windmill-worker/src/dbt_engine.rs b/backend/windmill-worker/src/dbt_engine.rs
new file mode 100644
index 0000000000..6ee8325ddf
--- /dev/null
+++ b/backend/windmill-worker/src/dbt_engine.rs
@@ -0,0 +1,771 @@
+//! Provisioning the three dbt engines on a worker.
+//!
+//! No engine ships in a Windmill image. `dbt-core-1x` and `dbt-core-2x` are
+//! Apache 2.0 and an operator may pre-stage either (`DBT_BUNDLED_DIR`); the
+//! Fusion engine is **never bundled**. Its license grants only a
+//! non-transferable, non-sublicensable redistribution right and forbids
+//! interposing on Provider-to-End-User communication, which is exactly what
+//! shipping it inside a job runner would do. The mitigation is that the user's
+//! own instance fetches it from dbt Labs on first use, so Windmill never
+//! redistributes it (docs/dbt-runtime.md, decision 1).
+//!
+//! Everything lands in a worker-global cache keyed by engine and version, so
+//! the fetch happens once per worker rather than once per job.
+
+use std::path::{Path, PathBuf};
+use std::process::Stdio;
+
+use tokio::process::Command;
+use uuid::Uuid;
+use windmill_common::error::{self, Error};
+use windmill_common::worker::{write_file, Connection, ROOT_CACHE_NOMOUNT_DIR};
+use windmill_parser_yaml::DbtEngine;
+use windmill_queue::append_logs;
+
+use crate::dbt_executor::digest;
+use crate::dbt_profiles::DbtAdapter;
+use crate::handle_child::{get_mem_peak, run_future_with_polling_update_job_poller, JobCtx};
+
+lazy_static::lazy_static! {
+    pub static ref DBT_CACHE_DIR: String = format!("{}dbt", *ROOT_CACHE_NOMOUNT_DIR);
+    /// Where an operator may pre-stage an Apache-2.0 engine in a derived image.
+    /// A persistent image path, unlike the runtime caches, which are a fresh
+    /// volume at start — which is the whole reason it is a separate directory.
+    static ref DBT_BUNDLED_DIR: String =
+        std::env::var("DBT_BUNDLED_DIR").unwrap_or_else(|_| "/usr/local/dbt".to_string());
+    static ref UV_PATH: String =
+        std::env::var("UV_PATH").unwrap_or_else(|_| "/usr/local/bin/uv".to_string());
+    /// Bounds on the dbt-core the 1.x engine resolves. A RANGE, not a pin: the
+    /// adapter decides which core it can take, and several cap below the newest
+    /// (dbt-oracle and dbt-databricks below 1.12), so pinning core independently
+    /// makes those projects unprovisionable. The floor is the CLI this runtime
+    /// invokes -- 1.7 rejects `--target` on `parse`, so resolving down to it
+    /// produces a working venv that then fails on flags, which is worse than
+    /// not resolving at all.
+    ///
+    /// Every static in this group is env-overridable per instance, so an
+    /// operator can move an engine without waiting on a release.
+    static ref DBT_CORE_1X_FLOOR: String =
+        std::env::var("DBT_CORE_1X_FLOOR").unwrap_or_else(|_| "1.8".to_string());
+    static ref DBT_CORE_1X_CEILING: String =
+        std::env::var("DBT_CORE_1X_CEILING").unwrap_or_else(|_| "2.0.0".to_string());
+    /// Reported as the engine version only when the installed `dist-info` cannot
+    /// be read. It pins no install and is not in the cache key -- the resolved
+    /// range is -- so it must not be mistaken for the version that gets used.
+    static ref DBT_CORE_1X_VERSION: String =
+        std::env::var("DBT_CORE_1X_VERSION").unwrap_or_else(|_| "1.12.0".to_string());
+    /// Pinned, not ranged: the Rust engine ships its adapters in the binary, so
+    /// there is no adapter resolution to accommodate.
+    static ref DBT_CORE_2X_VERSION: String =
+        std::env::var("DBT_CORE_2X_VERSION").unwrap_or_else(|_| "2.0.0-alpha.5".to_string());
+    static ref DBT_PYTHON_VERSION: String =
+        std::env::var("DBT_PYTHON_VERSION").unwrap_or_else(|_| "3.12".to_string());
+    /// Where the Fusion engine is fetched from. Never a Windmill-hosted mirror:
+    /// the point of runtime fetch is that the binary comes from dbt Labs.
+    static ref DBT_FUSION_INSTALL_URL: String = std::env::var("DBT_FUSION_INSTALL_URL")
+        .unwrap_or_else(|_| "https://public.cdn.getdbt.com/fs/install/install.sh".to_string());
+}
+
+pub struct ProvisionedEngine {
+    /// Absolute path of the dbt binary to invoke.
+    pub bin: PathBuf,
+    /// The engine's own directory — the ONLY part of the cache a sandboxed job
+    /// may see. Its siblings hold other workspaces' package trees, which are
+    /// scoped by cache key, not by permissions.
+    pub root: PathBuf,
+    pub version: String,
+    pub engine: DbtEngine,
+    /// The adapter version this venv resolved, for dbt-core 1.x where the
+    /// adapter is a separate package that versions independently of core.
+    /// `None` for the Rust engines, which ship their adapters in the binary.
+    pub adapter_version: Option<String>,
+}
+
+/// Ensure the engine is present on this worker and return how to invoke it.
+pub async fn provision_engine(
+    engine: DbtEngine,
+    adapter: DbtAdapter,
+    // What makes the lockfile a lockfile: without it a script silently changes dbt
+    // version when the instance upgrades or lands on a different worker. `None` for
+    // a deploy, which is what writes the pin.
+    pinned_version: Option<&str>,
+    pinned_adapter_version: Option<&str>,
+    job_id: &Uuid,
+    w_id: &str,
+    conn: &Connection,
+    ctx: &mut JobCtx<'_>,
+) -> error::Result<ProvisionedEngine> {
+    let pinned_version = checked_version(pinned_version, "engine_version")?;
+    let pinned_adapter_version = checked_version(pinned_adapter_version, "adapter_version")?;
+    tokio::fs::create_dir_all(&*DBT_CACHE_DIR).await.ok();
+    match engine {
+        DbtEngine::DbtCore1x => {
+            provision_core_1x(
+                adapter,
+                pinned_version,
+                pinned_adapter_version,
+                job_id,
+                w_id,
+                conn,
+                ctx,
+            )
+            .await
+        }
+        DbtEngine::DbtCore2x => provision_core_2x(pinned_version, job_id, w_id, conn, ctx).await,
+        DbtEngine::Fusion => provision_fusion(pinned_version, job_id, w_id, conn, ctx).await,
+    }
+}
+
+/// A version out of the lockfile, which is CALLER DATA: a preview run submits
+/// its own `lock` alongside its content, so nothing about this string has been
+/// through a deploy.
+///
+/// It is interpolated into the engine cache path and into a pip requirement,
+/// and provisioning runs on the host rather than inside the dbt jail — a
+/// `../..` in it would download an archive and extract it anywhere the worker
+/// can write. Accepted only as a plain version token, which every version any
+/// of the three engines publishes already is.
+fn checked_version<'a>(v: Option<&'a str>, field: &str) -> error::Result<Option<&'a str>> {
+    if let Some(v) = v {
+        let plain = v.len() <= 64
+            && v.starts_with(|c: char| c.is_ascii_alphanumeric())
+            && v.chars()
+                .all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | '_' | '+'));
+        if !plain {
+            return Err(Error::BadRequest(format!(
+                "the lockfile's `{field}` is not a version: expected a token of letters, digits, \
+                 `.`, `-`, `_` or `+` starting with a letter or digit, got `{v}`"
+            )));
+        }
+    }
+    Ok(v)
+}
+
+/// A uv venv per (dbt version, adapter): the adapter is a separate pip package
+/// and installing every adapter into one venv would make their transitive
+/// dependency sets fight.
+async fn provision_core_1x(
+    adapter: DbtAdapter,
+    pinned_version: Option<&str>,
+    pinned_adapter_version: Option<&str>,
+    job_id: &Uuid,
+    w_id: &str,
+    conn: &Connection,
+    ctx: &mut JobCtx<'_>,
+) -> error::Result<ProvisionedEngine> {
+    if adapter.pip_package().is_empty() {
+        return Err(Error::BadRequest(format!(
+            "the {} adapter has no dbt-core 1.x package: it exists only inside the Fusion \
+             engine. Set `engine: fusion` to use it",
+            adapter.name()
+        )));
+    }
+    // A RANGE, not an `==`. A locked version still pins exactly, because that
+    // one was resolved for this adapter in the first place.
+    let version_spec = match pinned_version {
+        Some(v) => format!("dbt-core=={v}"),
+        None => format!(
+            "dbt-core>={},<{}",
+            DBT_CORE_1X_FLOOR.as_str(),
+            DBT_CORE_1X_CEILING.as_str()
+        ),
+    };
+    let version = pinned_version
+        .map(str::to_string)
+        .unwrap_or_else(|| DBT_CORE_1X_VERSION.clone());
+    // The adapter is in the cache key: pinning core alone would let a rebuilt
+    // cache resolve a newer adapter than the deploy did, which changes runtime
+    // behavior under a lockfile that claims to prevent exactly that.
+    let adapter_spec = match pinned_adapter_version {
+        Some(v) => format!("{}=={v}", adapter.pip_package()),
+        None => adapter.pip_package().to_string(),
+    };
+    let dir = PathBuf::from(&*DBT_CACHE_DIR).join(format!(
+        "core1x-{}-{}",
+        digest(&version_spec),
+        digest(&adapter_spec)
+    ));
+    let bin = dir.join("bin").join("dbt");
+    if bin.exists() {
+        let adapter_version = installed_adapter_version(&dir, adapter).await;
+        return Ok(ProvisionedEngine {
+            root: dir.clone(),
+            bin,
+            // What the resolver actually chose, so the lock pins the version
+            // this adapter can take rather than the one we asked for.
+            version: installed_package_version(&dir, "dbt_core")
+                .await
+                .unwrap_or(version),
+            engine: DbtEngine::DbtCore1x,
+            adapter_version,
+        });
+    }
+
+    append_logs(
+        job_id,
+        w_id,
+        format!(
+            "\nProvisioning {version_spec} with {}...\n",
+            adapter.pip_package()
+        ),
+        conn,
+    )
+    .await;
+    // Build beside the target and rename, so two jobs racing on one worker cannot
+    // observe a half-installed venv through `bin.exists()`. `--relocatable` makes
+    // the rename safe: without it uv bakes the staging path into every shebang and
+    // the moved venv's `dbt` fails with ENOENT.
+    let staging_guard = Scratch::new(staging_path(&dir, job_id));
+    let staging = staging_guard.path().to_path_buf();
+    tokio::fs::remove_dir_all(&staging).await.ok();
+    run_tool(
+        Command::new(UV_PATH.as_str())
+            // The interpreter goes in Windmill's own cache rather than the
+            // worker user's home: a sandboxed job can only see the paths that
+            // are mounted into it, and this is one of them.
+            .env("UV_PYTHON_INSTALL_DIR", crate::PY_INSTALL_DIR.as_str())
+            .args([
+                "venv",
+                "--relocatable",
+                "--python",
+                DBT_PYTHON_VERSION.as_str(),
+            ])
+            .arg(&staging),
+        "uv venv",
+        job_id,
+        w_id,
+        conn,
+        ctx,
+    )
+    .await?;
+    run_tool(
+        Command::new(UV_PATH.as_str())
+            .env("UV_PYTHON_INSTALL_DIR", crate::PY_INSTALL_DIR.as_str())
+            .env("VIRTUAL_ENV", &staging)
+            .args(["pip", "install", &version_spec, &adapter_spec]),
+        "uv pip install",
+        job_id,
+        w_id,
+        conn,
+        ctx,
+    )
+    .await
+    .map_err(|e| {
+        // The common cause is an adapter with no release for this dbt-core
+        // range: dbt-mysql, for one, has not shipped past `~=1.7`. uv reports
+        // that as a resolver dump, which does not say what to do about it.
+        Error::ExecutionErr(format!(
+            "{e}\n\ninstalling the {} adapter: it must have a release compatible with \
+             {version_spec}, which is the dbt-core CLI this engine invokes. If the adapter has \
+             not kept up, use `engine: dbt-core-2x` or `engine: fusion`",
+            adapter.name()
+        ))
+    })?;
+    match tokio::fs::rename(&staging, &dir).await {
+        Ok(()) => staging_guard.keep(),
+        // Lost the race: the winner's venv is equivalent, so use it. The guard
+        // removes ours.
+        Err(_) if bin.exists() => {}
+        Err(e) => return Err(Error::internal_err(format!("installing dbt-core: {e}"))),
+    }
+    let adapter_version = installed_adapter_version(&dir, adapter).await;
+    let version = installed_package_version(&dir, "dbt_core")
+        .await
+        .unwrap_or(version);
+    Ok(
+        ProvisionedEngine {
+            root: dir,
+            bin,
+            version,
+            engine: DbtEngine::DbtCore1x,
+            adapter_version,
+        },
+    )
+}
+
+/// The adapter version a venv actually resolved, read from its dist-info so a
+/// deploy can lock it and later runs can ask for the same one.
+async fn installed_adapter_version(dir: &Path, adapter: DbtAdapter) -> Option<String> {
+    installed_package_version(dir, &adapter.pip_package().replace('-', "_")).await
+}
+
+/// The version of an installed distribution, read from its `.dist-info`.
+async fn installed_package_version(dir: &Path, dist: &str) -> Option<String> {
+    let prefix = format!("{dist}-");
+    let mut entries = tokio::fs::read_dir(dir.join("lib")).await.ok()?;
+    while let Ok(Some(py)) = entries.next_entry().await {
+        let mut pkgs = tokio::fs::read_dir(py.path().join("site-packages"))
+            .await
+            .ok()?;
+        while let Ok(Some(e)) = pkgs.next_entry().await {
+            let name = e.file_name().to_string_lossy().to_string();
+            if let Some(rest) = name.strip_prefix(&prefix) {
+                if let Some(v) = rest.strip_suffix(".dist-info") {
+                    return Some(v.to_string());
+                }
+            }
+        }
+    }
+    None
+}
+
+async fn provision_core_2x(
+    pinned_version: Option<&str>,
+    job_id: &Uuid,
+    w_id: &str,
+    conn: &Connection,
+    ctx: &mut JobCtx<'_>,
+) -> error::Result<ProvisionedEngine> {
+    let version = pinned_version
+        .map(str::to_string)
+        .unwrap_or_else(|| DBT_CORE_2X_VERSION.clone());
+    // No Windmill image ships an engine, so this is the operator's own
+    // pre-stage: `DBT_BUNDLED_DIR` populated in a derived image, for an
+    // air-gapped instance or a fleet that should not fetch per worker. Checked
+    // before the cache because it is read-only and shared, where the cache is a
+    // per-worker volume.
+    let bundled = PathBuf::from(&*DBT_BUNDLED_DIR)
+        .join(format!("core2x-{version}"))
+        .join("dbt-sa-cli");
+    if bundled.exists() {
+        return Ok(ProvisionedEngine {
+            root: bundled.parent().map(Path::to_path_buf).unwrap_or_default(),
+            bin: bundled,
+            version,
+            engine: DbtEngine::DbtCore2x,
+            adapter_version: None,
+        });
+    }
+    let dir = PathBuf::from(&*DBT_CACHE_DIR).join(format!("core2x-{version}"));
+    let bin = dir.join("dbt-sa-cli");
+    if bin.exists() {
+        return Ok(ProvisionedEngine {
+            root: dir.clone(),
+            bin,
+            version,
+            engine: DbtEngine::DbtCore2x,
+            adapter_version: None,
+        });
+    }
+    let target = format!("{}-unknown-linux-gnu", std::env::consts::ARCH);
+    let url = format!(
+        "https://github.com/dbt-labs/dbt-core/releases/download/v{version}/dbt-core-{version}-{target}.tar.gz"
+    );
+    append_logs(
+        job_id,
+        w_id,
+        format!("\nFetching dbt-core {version}...\n"),
+        conn,
+    )
+    .await;
+    fetch_and_extract(&url, &dir, "dbt-sa-cli", job_id, w_id, conn, ctx).await?;
+    Ok(ProvisionedEngine {
+        root: dir,
+        bin,
+        version,
+        engine: DbtEngine::DbtCore2x,
+        adapter_version: None,
+    })
+}
+
+/// Fusion is fetched from dbt Labs at runtime and cached — see the module docs
+/// for why it must never be baked into an image.
+async fn provision_fusion(
+    pinned_version: Option<&str>,
+    job_id: &Uuid,
+    w_id: &str,
+    conn: &Connection,
+    ctx: &mut JobCtx<'_>,
+) -> error::Result<ProvisionedEngine> {
+    // Version-keyed like the other two: one shared `fusion` directory means a
+    // run landing on a clean worker fetches whatever is current rather than
+    // what the deploy locked.
+    let dir = PathBuf::from(&*DBT_CACHE_DIR).join(match pinned_version {
+        Some(v) => format!("fusion-{v}"),
+        None => "fusion".to_string(),
+    });
+    // The installer places the binary directly in the directory `--to` names.
+    let bin = dir.join("dbt");
+    if bin.exists() {
+        return Ok(ProvisionedEngine {
+            root: dir.clone(),
+            bin,
+            version: fusion_version(&dir).await,
+            engine: DbtEngine::Fusion,
+            adapter_version: None,
+        });
+    }
+    append_logs(
+        job_id,
+        w_id,
+        "\nFetching the dbt Fusion engine from dbt Labs (not bundled with Windmill; \
+         subject to the dbt Fusion engine license agreement)...\n"
+            .to_string(),
+        conn,
+    )
+    .await;
+    let script = fetch_under_job(
+        "the Fusion installer",
+        async {
+            let net =
+                |e: reqwest::Error| Error::internal_err(format!("fetching the installer: {e}"));
+            Ok(windmill_common::utils::HTTP_CLIENT
+                .get(&*DBT_FUSION_INSTALL_URL)
+                .send()
+                .await
+                .and_then(|r| r.error_for_status())
+                .map_err(net)?
+                .text()
+                .await
+                .map_err(net)?)
+        },
+        job_id,
+        w_id,
+        conn,
+        ctx,
+    )
+    .await?;
+    // Install into a per-job sibling and rename, like the other two engines:
+    // pointing the installer straight at the shared cache lets a second job
+    // observe `bin/dbt` and execute it while the first is still writing.
+    let staging_guard = Scratch::new(staging_path(&dir, job_id));
+    let staging = staging_guard.path().to_path_buf();
+    tokio::fs::remove_dir_all(&staging).await.ok();
+    let script_guard =
+        Scratch::new(std::env::temp_dir().join(format!("wm-fusion-install-{job_id}.sh")));
+    let tmp = script_guard.path().to_path_buf();
+    write_file(
+        tmp.parent().unwrap().to_str().unwrap(),
+        tmp.file_name().unwrap().to_str().unwrap(),
+        &script,
+    )?;
+    // `--to` and `--version` are the installer's own flags (`install.sh
+    // --help`); it takes no positional arguments and ignores unknown ones, so
+    // an approximation here fails by silently installing the latest release
+    // into the user's $HOME instead of the cache.
+    let mut install = Command::new("sh");
+    install.arg(&tmp).arg("--to").arg(&staging);
+    if let Some(v) = pinned_version {
+        install.args(["--version", v]);
+    } else {
+        install.arg("--update");
+    }
+    run_tool(&mut install, "fusion install", job_id, w_id, conn, ctx).await?;
+    drop(script_guard);
+    if !staging.join("dbt").exists() {
+        return Err(Error::internal_err(
+            "the Fusion installer did not produce a dbt binary".to_string(),
+        ));
+    }
+    if tokio::fs::rename(&staging, &dir).await.is_ok() {
+        staging_guard.keep();
+    } else {
+        if !bin.exists() {
+            return Err(Error::internal_err(
+                "could not install the Fusion engine".to_string(),
+            ));
+        }
+    }
+    Ok(ProvisionedEngine {
+        root: dir.clone(),
+        bin,
+        version: fusion_version(&dir).await,
+        engine: DbtEngine::Fusion,
+        adapter_version: None,
+    })
+}
+
+/// From the binary itself: the installer writes no version file, and a pinned
+/// directory name would only echo back what was asked for rather than what was
+/// installed.
+async fn fusion_version(dir: &Path) -> String {
+    Command::new(dir.join("dbt"))
+        .arg("--version")
+        .output()
+        .await
+        .ok()
+        .filter(|o| o.status.success())
+        .and_then(|o| {
+            String::from_utf8_lossy(&o.stdout)
+                .split_whitespace()
+                .nth(1)
+                .map(|v| v.to_string())
+        })
+        .unwrap_or_else(|| "unknown".to_string())
+}
+
+/// A sibling of `dir` to build in before renaming into place. Appended to the
+/// whole file name rather than via `with_extension`, which would eat everything
+/// after the version's last dot.
+/// A per-job path removed on drop unless the install claimed it.
+///
+/// Provisioning is a sequence of fallible awaits — a download, an installer, an
+/// extraction — and each one can also be cancelled. Cleaning up after the `?`
+/// only covers the paths someone remembered, so a run of failed or cancelled
+/// first-use installs accumulates venvs and tarballs until the worker's disk is
+/// gone. Dropping is the one exit every path takes.
+struct Scratch(Option<PathBuf>);
+
+impl Scratch {
+    fn new(path: PathBuf) -> Self {
+        Scratch(Some(path))
+    }
+
+    fn path(&self) -> &Path {
+        self.0.as_deref().unwrap_or(Path::new(""))
+    }
+
+    /// The install succeeded and moved it: stop owning it.
+    fn keep(mut self) {
+        self.0 = None;
+    }
+}
+
+impl Drop for Scratch {
+    fn drop(&mut self) {
+        let Some(p) = self.0.take() else {
+            return;
+        };
+        let remove = move || {
+            let _ = std::fs::remove_dir_all(&p);
+            let _ = std::fs::remove_file(&p);
+        };
+        // Off the runtime thread: this removes thousands of files and `Drop` runs
+        // inside the job future, so doing it synchronously stalls every other job
+        // on that thread. Detached because a `Drop` cannot await.
+        match tokio::runtime::Handle::try_current() {
+            Ok(handle) => {
+                handle.spawn_blocking(remove);
+            }
+            // No runtime to hand it to (a test, or shutdown): do it here rather
+            // than leave the directory behind.
+            Err(_) => remove(),
+        }
+    }
+}
+
+fn staging_path(dir: &Path, job_id: &Uuid) -> PathBuf {
+    let name = dir.file_name().unwrap_or_default().to_string_lossy();
+    dir.with_file_name(format!("{name}.staging-{job_id}"))
+}
+
+/// Fetch under the job's cancellation and timeout. The shared `HTTP_CLIENT`
+/// sets no request timeout, so a stalled release download would otherwise hold
+/// the worker for as long as the connection stays open.
+async fn fetch_under_job<T, F>(
+    what: &str,
+    fetch: F,
+    job_id: &Uuid,
+    w_id: &str,
+    conn: &Connection,
+    ctx: &mut JobCtx<'_>,
+) -> error::Result<T>
+where
+    F: std::future::Future<Output = error::Result<T>>,
+{
+    run_future_with_polling_update_job_poller(
+        *job_id,
+        ctx.timeout(),
+        conn,
+        ctx.mem_peak,
+        ctx.canceled_by,
+        async move {
+            fetch
+                .await
+                .map_err(|e| Error::internal_err(format!("fetching {what}: {e}")))
+        },
+        ctx.worker_name,
+        w_id,
+        &mut Some(ctx.occupancy_metrics),
+        Box::pin(futures::stream::once(async { 0 })),
+    )
+    .await
+}
+
+async fn fetch_and_extract(
+    url: &str,
+    dir: &Path,
+    expected_bin: &str,
+    job_id: &Uuid,
+    w_id: &str,
+    conn: &Connection,
+    ctx: &mut JobCtx<'_>,
+) -> error::Result<()> {
+    let tarball_guard = Scratch::new(std::env::temp_dir().join(format!("wm-dbt-{job_id}.tar.gz")));
+    let tarball = tarball_guard.path().to_path_buf();
+    // STREAMED to disk, never held whole: an engine archive is ~290 MB, this
+    // runs in the shared worker process rather than the job's subprocess, and
+    // several cold jobs provision at once — buffering would multiply that until
+    // the worker dies, taking every job on it along.
+    fetch_under_job(
+        url,
+        async {
+            use futures::StreamExt;
+            use tokio::io::AsyncWriteExt;
+            let net = |e: reqwest::Error| Error::internal_err(format!("fetching {url}: {e}"));
+            let mut resp = windmill_common::utils::HTTP_CLIENT
+                .get(url)
+                .send()
+                .await
+                .and_then(|r| r.error_for_status())
+                .map_err(net)?
+                .bytes_stream();
+            let mut file = tokio::fs::File::create(&tarball)
+                .await
+                .map_err(|e| Error::internal_err(format!("writing {url}: {e}")))?;
+            while let Some(chunk) = resp.next().await {
+                let chunk = chunk.map_err(net)?;
+                file.write_all(&chunk)
+                    .await
+                    .map_err(|e| Error::internal_err(format!("writing {url}: {e}")))?;
+            }
+            file.flush()
+                .await
+                .map_err(|e| Error::internal_err(format!("writing {url}: {e}")))?;
+            Ok(())
+        },
+        job_id,
+        w_id,
+        conn,
+        ctx,
+    )
+    .await?;
+    let staging_guard = Scratch::new(staging_path(dir, job_id));
+    let staging = staging_guard.path().to_path_buf();
+    tokio::fs::create_dir_all(&staging)
+        .await
+        .map_err(|e| Error::internal_err(format!("creating {staging:?}: {e}")))?;
+    run_tool(
+        Command::new("tar")
+            .arg("xzf")
+            .arg(&tarball)
+            .arg("-C")
+            .arg(&staging)
+            // The release tarballs wrap the binary in a versioned directory.
+            .args(["--strip-components", "1"]),
+        "tar",
+        job_id,
+        w_id,
+        conn,
+        ctx,
+    )
+    .await?;
+    drop(tarball_guard);
+    if !staging.join(expected_bin).exists() {
+        return Err(Error::internal_err(format!(
+            "{url} did not contain the expected `{expected_bin}` binary"
+        )));
+    }
+    if tokio::fs::rename(&staging, dir).await.is_ok() {
+        staging_guard.keep();
+    } else {
+        if !dir.join(expected_bin).exists() {
+            return Err(Error::internal_err(format!("could not install {url}")));
+        }
+    }
+    Ok(())
+}
+
+/// Run a provisioning command to completion. Provisioning happens inside the
+/// job that needs the engine, so it runs under that job's cancellation and
+/// timeout: a cold `uv pip install` or Fusion download is the longest thing a
+/// dbt job does, and a cancel that could not reach it would hold the worker
+/// slot for the rest of the install. Its output is not streamed to the job log
+/// — these are worker-level setup steps with no node to attribute progress to,
+/// and failures surface with the tool's own stderr.
+async fn run_tool(
+    cmd: &mut Command,
+    name: &str,
+    job_id: &Uuid,
+    w_id: &str,
+    conn: &Connection,
+    ctx: &mut JobCtx<'_>,
+) -> error::Result<()> {
+    let child = cmd
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        // The wait future owns the child, so cancellation dropping that future
+        // is what terminates the install — dropping it alone would not.
+        .kill_on_drop(true)
+        .spawn()
+        .map_err(|e| Error::internal_err(format!("{name} could not be started: {e}")))?;
+    let pid = child.id();
+    let out = run_future_with_polling_update_job_poller(
+        *job_id,
+        ctx.timeout(),
+        conn,
+        ctx.mem_peak,
+        ctx.canceled_by,
+        async move {
+            child
+                .wait_with_output()
+                .await
+                .map_err(|e| Error::internal_err(format!("{name} failed: {e}")))
+        },
+        ctx.worker_name,
+        w_id,
+        &mut Some(ctx.occupancy_metrics),
+        Box::pin(futures::stream::unfold((), move |_| async move {
+            Some((get_mem_peak(pid, false).await, ()))
+        })),
+    )
+    .await?;
+    if !out.status.success() {
+        return Err(Error::internal_err(format!(
+            "{name} failed: {}",
+            String::from_utf8_lossy(&out.stderr)
+        )));
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod core1x_tests {
+    use super::*;
+
+    // Several adapters cap dbt-core below what this runtime would ask for
+    // (dbt-mysql ~=1.7, dbt-oracle and dbt-databricks below 1.12) and
+    // dbt-salesforce has no 1.x package at all, so pinning core independently made
+    // those projects fail at provisioning. The install names a ceiling instead.
+    #[test]
+    fn every_adapter_either_names_a_package_or_is_fusion_only() {
+        for a in DbtAdapter::ALL {
+            if matches!(a, DbtAdapter::Salesforce) {
+                continue;
+            }
+            assert!(
+                !a.pip_package().is_empty(),
+                "{} must name a pip package for dbt-core 1.x",
+                a.name()
+            );
+        }
+        // Fusion has it built in, and there is no package to install.
+        assert!(DbtAdapter::Salesforce.pip_package().is_empty());
+        assert_eq!(DbtAdapter::Salesforce.name(), "salesforce");
+    }
+
+    /// A preview submits its own lockfile, so this string reaches a path join
+    /// and a pip requirement straight from the caller, on the host and outside
+    /// the jail.
+    #[test]
+    fn a_lockfile_version_cannot_leave_the_cache_directory() {
+        for v in ["1.12.0", "2.0.0-alpha.5", "2.0.0-preview.202"] {
+            assert_eq!(checked_version(Some(v), "engine_version").unwrap(), Some(v));
+        }
+        for v in [
+            "../../../../etc",
+            "1.0/../..",
+            "..",
+            ".ssh",
+            "-rf",
+            "1.0 --index-url=http://x",
+            "1.0\n",
+        ] {
+            assert!(
+                checked_version(Some(v), "engine_version").is_err(),
+                "`{v}` must be refused before it reaches a path"
+            );
+        }
+        assert!(checked_version(None, "engine_version").unwrap().is_none());
+    }
+}
diff --git a/backend/windmill-worker/src/dbt_executor.rs b/backend/windmill-worker/src/dbt_executor.rs
new file mode 100644
index 0000000000..58c8d4c76c
--- /dev/null
+++ b/backend/windmill-worker/src/dbt_executor.rs
@@ -0,0 +1,5572 @@
+//! Running a dbt project as a Windmill job.
+//!
+//! One `dbt build` per job, not one job per model. That is the shape
+//! astronomer-cosmos arrived at with `ExecutionMode.WATCHER` after per-model
+//! Airflow tasks proved roughly 6x slower on a real project; dbt's own
+//! threading provides the parallelism and Windmill provides the observability
+//! (docs/dbt-runtime.md). Per-model status comes from dbt's JSON event stream
+//! while the run is in flight, and the structured job result comes from
+//! `run_results.json` at the end.
+
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+use std::process::Stdio;
+
+use serde::{Deserialize, Serialize};
+use serde_json::value::RawValue;
+use sha2::{Digest, Sha256};
+use tokio::process::Command;
+use uuid::Uuid;
+use windmill_common::client::AuthedClient;
+use windmill_common::error::{self, Error};
+use windmill_common::materialization::{
+    record_materialization, MaterializationStatus, RecordMaterializationRequest,
+};
+use windmill_common::worker::{to_raw_value, write_file, Connection};
+use windmill_parser_yaml::{
+    parse_dbt_descriptor, DbtDescriptor, DbtTestBehavior, DBT_COMMANDS, DBT_COMMAND_ARG,
+    DBT_COMMAND_LABEL, DBT_DEFAULT_WAREHOUSE,
+};
+use windmill_queue::{append_logs, CanceledBy, MiniPulledJob};
+
+use crate::common::{
+    render_nsjail_rlimit_as, resolve_nsjail_timeout, resolve_nsjail_tmp_mount_block,
+};
+use crate::common::{start_child_process, OccupancyMetrics};
+use crate::dbt_engine::{provision_engine, ProvisionedEngine, DBT_CACHE_DIR};
+use crate::dbt_profiles::{ensure_adapter_licensed, render_profile, DbtAdapter};
+use crate::handle_child::{
+    get_mem_peak, handle_child, run_future_with_polling_update_job_poller, JobCtx, JobDeadline,
+};
+use crate::worker::write_module_files;
+use crate::{
+    is_sandboxing_enabled, GIT_PATH, NSJAIL_DBT_RLIMIT_AS_MB, NSJAIL_PATH, PATH_ENV, PROXY_ENVS,
+    TZ_ENV,
+};
+
+/// The profile name Windmill renders into `profiles.yml`. dbt takes the profile
+/// to use from `dbt_project.yml`, so the rendered file must answer to whatever
+/// name the project declares — resolved from the project file, with this as the
+/// fallback for the (invalid) case where it declares none.
+const FALLBACK_PROFILE_NAME: &str = "windmill";
+
+/// Written to the script's lockfile at deploy.
+#[derive(Serialize, Deserialize, Debug, Clone, Default)]
+pub struct DbtDependencyLocks {
+    /// The `<schema>/<database>` the profile resolved to at deploy. The
+    /// resource is re-read on every run, so a schema or catalog changed on it
+    /// afterwards moves every relation the project builds — and the stored
+    /// graph, which still names the old ones, has to be re-ingested.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub profile_relation_root: Option<String>,
+    /// dbt-core 1.x only: its adapter is a separate package versioning
+    /// independently of core, so pinning core alone still lets a rebuilt cache
+    /// resolve different runtime behavior.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub adapter_version: Option<String>,
+    /// Digest of the `package-lock.yml` produced at deploy. Package trees are
+    /// worker-local, so a cache miss on another worker must prove it resolved
+    /// the same dependencies before it may run this script version.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub package_lock_digest: Option<String>,
+    pub manifest_digest: String,
+    pub engine: String,
+    pub engine_version: String,
+}
+
+/// Per-node outcome, from `run_results.json`.
+#[derive(Serialize, Debug, Clone)]
+pub struct DbtNodeResult {
+    pub unique_id: String,
+    /// dbt's own status word, verbatim (`success`, `error`, `partial success`,
+    /// `no-op`, …). Kept because it is what the log and dbt's docs say, but it
+    /// is dbt's vocabulary to change — read `outcome` to make a decision.
+    pub status: String,
+    /// The same result in Windmill's terms, which is the stable half of this
+    /// contract: `passed` | `failed` | `warned` | `skipped` | `no_op` |
+    /// `unknown`. A dbt release that renames a status, or adds one, moves
+    /// `status` and leaves this alone.
+    pub outcome: &'static str,
+    pub execution_time: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub rows_affected: Option<i64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub relation_name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    /// Test nodes: how many rows violated the assertion.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub failures: Option<i64>,
+}
+
+/// The job result. Partial failure is dbt's normal case, so the result has to
+/// be legible without reading the log: which models succeeded, which failed,
+/// which tests failed and at what severity.
+#[derive(Serialize, Debug)]
+pub struct DbtRunResult {
+    pub engine: String,
+    pub engine_version: String,
+    pub command: String,
+    pub totals: DbtTotals,
+    pub nodes: Vec<DbtNodeResult>,
+    /// The arguments this invocation ran with, as SUBMITTED — a `$var:` stays a
+    /// reference, so no resolved value (and no secret) is published.
+    ///
+    /// Present because a `dbt retry` restores the failed run's arguments inside
+    /// the worker and they are never written back to the retry job: its own
+    /// args are just `{"dbt_command": "retry"}`. Anything that needs to act on
+    /// what the run actually used — the row preview, which is a `dbt show` of
+    /// the same project — cannot get them from the job.
+    #[serde(skip_serializing_if = "std::collections::HashMap::is_empty")]
+    pub invocation_args: std::collections::HashMap<String, Box<RawValue>>,
+}
+
+#[derive(Serialize, Debug, Default)]
+pub struct DbtTotals {
+    pub total: usize,
+    pub success: usize,
+    pub error: usize,
+    pub warn: usize,
+    pub skipped: usize,
+}
+
+#[derive(Deserialize, Debug)]
+struct RunResults {
+    #[serde(default)]
+    results: Vec<RunResultNode>,
+}
+
+#[derive(Deserialize, Debug)]
+struct RunResultNode {
+    unique_id: String,
+    status: String,
+    #[serde(default)]
+    execution_time: Option<f64>,
+    #[serde(default)]
+    adapter_response: serde_json::Value,
+    #[serde(default)]
+    relation_name: Option<String>,
+    #[serde(default)]
+    message: Option<String>,
+    #[serde(default)]
+    failures: Option<i64>,
+}
+
+pub(crate) async fn handle_dbt_job(
+    requirements_o: Option<&String>,
+    job_dir: &str,
+    worker_name: &str,
+    job: &MiniPulledJob,
+    mem_peak: &mut i32,
+    canceled_by: &mut Option<CanceledBy>,
+    conn: &Connection,
+    client: &AuthedClient,
+    inner_content: &str,
+    envs: HashMap<String, String>,
+    occupancy_metrics: &mut OccupancyMetrics,
+    modules: Option<&HashMap<String, windmill_common::scripts::ScriptModule>>,
+) -> error::Result<Box<RawValue>> {
+    let descriptor = parse_dbt_descriptor(inner_content)?;
+    let locks: Option<DbtDependencyLocks> = requirements_o
+        .map(|s| {
+            serde_json::from_str(s)
+                .map_err(|e| Error::internal_err(format!("reading the dbt lockfile: {e}")))
+        })
+        .transpose()?;
+
+    // Through `build_args_map`, like every other executor: dbt cannot resolve a
+    // `$var:` / `$res:` / `$encrypted:` reference, so passing one raw sends the
+    // literal string to `--vars` — a placeholder holding a schema or an `enabled`
+    // flag would then build a different slice of the project than was asked for.
+    let args = flatten_command(
+        crate::common::build_args_map(job, client, conn)
+            .await?
+            .unwrap_or_else(|| job.args.as_ref().map(|a| a.0.clone()).unwrap_or_default()),
+    )?;
+    // As submitted, command block and all: this is what the state saves and the
+    // result publishes, and both describe an invocation of this script, not one
+    // executor's view of it.
+    let raw_args = job.args.as_ref().map(|a| a.0.clone()).unwrap_or_default();
+    let inv = Invocation { args: args.clone(), raw_args, envs: envs.clone(), strict: true };
+    // One wall clock for the whole job. A dbt job is a sequence of
+    // subprocesses — provision, deps, parse, ls, build, then the
+    // `after_all` tests — and each would otherwise resolve the job's full
+    // timeout for itself.
+    let deadline = JobDeadline::start(conn, &job.workspace_id, job.id, job.timeout).await;
+    // Built once and reborrowed into every phase. The five fields travel
+    // together through the whole executor, so passing them apart means each new
+    // phase grows another five parameters and another copy of this literal.
+    let mut ctx = JobCtx { mem_peak, canceled_by, occupancy_metrics, worker_name, deadline };
+    // From EVERY dbt run, not from the progress reporter: that reporter runs only
+    // for engines emitting node events, so hanging the prune off it leaves a
+    // Fusion-only or dbt-core-2x instance accumulating rows nothing deletes.
+    if let Connection::Sql(pool) = conn {
+        let (pool, prune_w_id) = (pool.clone(), job.workspace_id.clone());
+        let prune_path = job.runnable_path.clone().unwrap_or_default();
+        tokio::spawn(async move {
+            windmill_common::dbt_manifest::prune_run_progress(&pool, &prune_w_id).await;
+            if let Err(e) =
+                windmill_common::dbt_manifest::prune_dbt_run_graphs(&pool, &prune_path, &prune_w_id)
+                    .await
+            {
+                tracing::warn!("pruning dbt run graph snapshots: {e:#}");
+            }
+        });
+    }
+    let prepared = prepare_project(
+        &descriptor,
+        inner_content,
+        locks.as_ref(),
+        job_dir,
+        &job.id,
+        &job.workspace_id,
+        job.runnable_path.as_deref().unwrap_or_default(),
+        job.runnable_id.map(|h| h.0),
+        conn,
+        client,
+        &mut ctx,
+        &envs,
+        modules,
+    )
+    .await;
+    // A preparation failure leaves the saved run alone: nothing up to here — the
+    // bundle, `dbt deps`, the engine, the profile — touches a relation, so the
+    // previous run's failures still describe the warehouse. Only an interrupted
+    // BUILD invalidates that, which the save at the end of the job decides.
+    let mut prepared = prepared?;
+
+    // A `vars` override drives `enabled`, alias, schema, database and
+    // materialization, so the run's models are not the deployed graph's: it
+    // snapshots under its own job id. Re-asked below for a retry, which submits
+    // only `dbt_command` until the failed run's arguments are restored.
+    prepared.graph_refresh.add_caller_args(&descriptor, &args)?;
+
+    let command = match arg_str(&args, "dbt_command")? {
+        // An allowlist, not a passthrough: the value becomes the dbt subcommand,
+        // and running a script needs weaker permission than editing it — so an
+        // unchecked arg would let a runner invoke `clean` or `seed` on the
+        // descriptor's warehouse.
+        Some(c) if DBT_COMMANDS.contains(&c.as_str()) => c,
+        Some(c) => {
+            return Err(Error::BadRequest(format!(
+                "`dbt_command` must be one of {}, got `{c}`",
+                DBT_COMMANDS.join(", ")
+            )))
+        }
+        None => windmill_parser_yaml::default_dbt_command(&descriptor).to_string(),
+    };
+    // `dbt retry` resumes from the previous run's `run_results.json`, which is what
+    // makes one-job-per-invocation defensible. Each attempt gets a fresh job dir, so
+    // that state is restored along with the ARGUMENTS it ran with: dbt reuses the
+    // failed invocation's selection and vars, so every phase must agree with them.
+    let mut restored_results_digest: Option<String> = None;
+    let inv = if command == "retry" {
+        // Read BEFORE the restore replaces the arguments. A retry must name the run
+        // it resumes: only the latest failure of this script is kept, so an unnamed
+        // one would mean "whatever failed last" and quietly resume a different run
+        // than the caller was looking at.
+        let expected = arg_str(&inv.args, "dbt_retry_job")?.filter(|s| !s.trim().is_empty());
+        let Some(expected) = expected else {
+            return Err(Error::BadRequest(
+                "a `retry` needs `dbt_retry_job`, the id of the run to resume. Open that run and \
+                 use `Resume this run`, or pass its id: only the latest failure of this script is \
+                 kept, so a retry names which one it means"
+                    .to_string(),
+            ));
+        };
+        // Parsed, not compared as text: the saved run is a `uuid`, and an id
+        // that differs only in case or in braces names the same run.
+        let expected = Uuid::parse_str(expected.trim()).map_err(|_| {
+            Error::BadRequest(format!(
+                "`dbt_retry_job` must be the id of the run to resume, got `{expected}`"
+            ))
+        })?;
+        let restored = restore_run_state(
+            &prepared,
+            &job.workspace_id,
+            &job.permissioned_as,
+            &inv,
+            expected,
+            conn,
+        )
+        .await?;
+        restored_results_digest = Some(restored.results_digest.clone());
+        // Restored args are the ones SUBMITTED, so the references they carry are
+        // resolved again now — against this caller's access, not the original's.
+        let inv = Invocation {
+            args: flatten_command(
+                crate::common::transform_json(client, &job.workspace_id, &restored.args, job, conn)
+                    .await?
+                    .unwrap_or_else(|| restored.args.clone()),
+            )?,
+            raw_args: restored.args,
+            ..inv
+        };
+        // Compared only now that they are resolved: a `$var:` whose value moved
+        // selects a different node set, so the saved failures no longer describe
+        // what a retry would build. Refused rather than resumed, since which
+        // graph it would use depends on which worker it lands on.
+        if let Some(saved) = restored.args_digest.as_deref() {
+            if saved != inv.resolved_args_digest() {
+                return Err(Error::BadRequest(
+                    "the values this run's arguments resolve to have changed since the run \
+                     being retried, so its failures no longer describe what a retry would \
+                     build; run the script normally instead"
+                        .to_string(),
+                ));
+            }
+        }
+        // The restored arguments decide this retry's graph, and RESOLVED ones: a
+        // saved `select` spelled `$res:` is a string until resolved, so reading the
+        // raw form refuses the retry as "must be a list of strings" for a reference
+        // that resolves to the very list the failed run built with.
+        prepared
+            .graph_refresh
+            .add_caller_args(&descriptor, &inv.args)?;
+        if restored.needs_parse {
+            // After the resolution above, so the manifest describes the project
+            // the build is about to retry.
+            run_dbt_parse(
+                &prepared,
+                &descriptor,
+                &inv,
+                &mut ctx,
+                &job.id,
+                &job.workspace_id,
+                conn,
+            )
+            .await?;
+        }
+        inv
+    } else {
+        inv
+    };
+
+    // Ingested BEFORE the build, from a `dbt parse` with this run's vars, so the
+    // models shown are the ones about to be built. Rows are keyed by path, version
+    // AND job so no two runs collide; the path-keyed `asset` usage belongs to one
+    // version, which `claim_graph_publication` arbitrates (docs/dbt-runtime.md).
+    if prepared.graph_refresh.needed() && !windmill_parser_yaml::dbt::is_read_only_command(&command)
+    {
+        // A parse and an ingest write no relation either, so a failure in either
+        // leaves the saved run as accurate as the preparation exits above do.
+        if command != "retry" {
+            run_dbt_parse(
+                &prepared,
+                &descriptor,
+                &inv,
+                &mut ctx,
+                &job.id,
+                &job.workspace_id,
+                conn,
+            )
+            .await?;
+        }
+        // For a retry the restored manifest already describes the invocation
+        // being resumed, so only the ingest runs — with that invocation's
+        // arguments, which the selection resolver needs to interpolate.
+        ingest_from_run(&prepared, &descriptor, &inv, &mut ctx, job, conn).await?;
+    }
+
+    // A read-only command prints rows to stdout, so it is captured rather than
+    // streamed, and nothing below applies: nothing was built, so there is no graph
+    // to publish, no materialization, no test phase and nothing to retry.
+    if windmill_parser_yaml::dbt::is_read_only_command(&command) {
+        return run_show(
+            &prepared,
+            &descriptor,
+            &inv,
+            &mut ctx,
+            &job.id,
+            &job.workspace_id,
+            conn,
+        )
+        .await;
+    }
+
+    let mut run = run_dbt(
+        &prepared,
+        &command,
+        &descriptor,
+        &inv,
+        job,
+        conn,
+        &mut ctx,
+        true,
+    )
+    .await;
+
+    // `after_all` is two invocations, models then tests, and each REWRITES
+    // `run_results.json` — so the model results are read before the test phase
+    // overwrites them, or the job reports tests alone and nothing settles the
+    // models' materializations.
+    let mut results = read_run_results(&prepared.project_dir).await;
+
+    // In-job node retry: rebuilding only the failed and skipped nodes, while the
+    // previous attempt's `run_results.json` is still in the job directory. Never on
+    // an agent worker, which cannot read `v2_job_queue` — the wait below would be
+    // uninterruptible, so a cancelled job would hold its slot and then start dbt.
+    let node_retry = descriptor
+        .retry_failed_nodes
+        .filter(|_| matches!(conn, Connection::Sql(_)));
+    let mut retries_left = node_retry.map(|p| p.attempts()).unwrap_or(0);
+    if let Some(policy) = node_retry.filter(|_| run.is_err()) {
+        retry_failed_nodes(
+            policy,
+            &prepared,
+            &descriptor,
+            &inv,
+            job,
+            conn,
+            &mut ctx,
+            &mut run,
+            &mut results,
+            &mut retries_left,
+        )
+        .await;
+    }
+    // A `retry` whose saved results were tests alone IS the test phase: dbt reran
+    // exactly those tests, so running the suite after it would execute every test
+    // a second time and report each one twice. `test_behavior: after_all` is how
+    // `run_results.json` comes to hold tests alone.
+    let retry_was_the_test_phase = command == "retry"
+        && !results.is_empty()
+        && results
+            .iter()
+            .all(|n| n.unique_id.starts_with("test.") || n.unique_id.starts_with("unit_test."));
+    // `retry` counts as the model phase too: a run that failed midway and was
+    // retried to success would otherwise return green having never tested.
+    if run.is_ok()
+        && matches!(descriptor.test_behavior, DbtTestBehavior::AfterAll)
+        && matches!(command.as_str(), "build" | "retry")
+        && !retry_was_the_test_phase
+    {
+        run = run_dbt(
+            &prepared,
+            "test",
+            &descriptor,
+            &inv,
+            job,
+            conn,
+            &mut ctx,
+            // The tests must be scoped exactly like the models were: testing
+            // the whole project would assert against models this script never
+            // builds, the same failure the ingest-side scoping fixes.
+            true,
+        )
+        .await;
+        // Merged, not appended: the model phase and the test phase can name the
+        // same node, and a duplicate would double its totals and collide as a key
+        // in the result table.
+        merge_results(&mut results, read_run_results(&prepared.project_dir).await);
+        // The same policy applies to a failing test. `dbt retry` redoes test
+        // nodes, and the descriptor promises to retry the ones that failed —
+        // retrying the model phase alone would exempt the failure mode
+        // `test_behavior: after_all` exists to produce.
+        if let Some(policy) = node_retry.filter(|_| run.is_err()) {
+            retry_failed_nodes(
+                policy,
+                &prepared,
+                &descriptor,
+                &inv,
+                job,
+                conn,
+                &mut ctx,
+                &mut run,
+                &mut results,
+                &mut retries_left,
+            )
+            .await;
+        }
+    }
+
+    // Best-effort: losing the state costs a retry, not the run that just
+    // finished. Logged rather than dropped — without it the only symptom is
+    // `dbt retry` reporting nothing to resume, which reads as a bug in retry.
+    if let Err(e) = save_run_state(
+        &prepared,
+        &job.workspace_id,
+        &job.permissioned_as,
+        job.visible_to_owner,
+        &job.id,
+        &inv,
+        restored_results_digest.as_deref(),
+        conn,
+    )
+    .await
+    {
+        tracing::warn!("dbt: could not save retry state for job {}: {e:#}", job.id);
+    }
+    let reconciled = reconcile_materializations(&prepared, &results, job, conn, client).await;
+    terminalize_running_relations(job, &reconciled, conn).await;
+
+    let result = build_result(&prepared, &command, results, &inv);
+    match run {
+        Ok(()) => Ok(to_raw_value(&result)),
+        Err(e) => {
+            // dbt's exit code already honors each test's own `severity`: a
+            // failing `warn` test leaves the run successful. Overriding that
+            // would make the same project behave differently on Windmill than
+            // it does locally, which is the promise this feature is built on.
+            append_logs(
+                &job.id,
+                &job.workspace_id,
+                format!("\n{}\n", render_failures(&result)),
+                conn,
+            )
+            .await;
+            Err(Error::ExecutionErr(format!(
+                "{e}\n\n{}",
+                serde_json::to_string_pretty(&result).unwrap_or_default()
+            )))
+        }
+    }
+}
+
+/// Deploy-time lock: materialise the script's project and parse it, so its
+/// models land in the asset graph before it has ever run.
+///
+/// This is the one place where dbt does not fit the shape every other language
+/// uses. `parse_assets_for_lang` is a pure function of the script content, and
+/// dbt's assets are not derivable from the descriptor — they need the project
+/// on disk and a dbt invocation. So the dependency job, which already runs on a
+/// worker with the engine available, does the parse and writes the `asset` rows
+/// itself; `parse_assets_for_lang` returns `None` for dbt and leaves them
+/// alone. That also makes redeploy the graph-refresh mechanism, with no
+/// separate concept (docs/dbt-runtime.md, decision 12).
+#[allow(clippy::too_many_arguments)]
+pub(crate) async fn dbt_dep(
+    content: &str,
+    // The project this dependency job is deploying: a dependency job has no
+    // generic module-writing step, so the executor materialises them.
+    modules: Option<&HashMap<String, windmill_common::scripts::ScriptModule>>,
+    job_id: &Uuid,
+    mem_peak: &mut i32,
+    canceled_by: &mut Option<CanceledBy>,
+    job_dir: &str,
+    db: &sqlx::Pool<sqlx::Postgres>,
+    worker_name: &str,
+    w_id: &str,
+    script_path: &str,
+    occupancy_metrics: &mut OccupancyMetrics,
+    token: &str,
+    base_internal_url: &str,
+) -> error::Result<String> {
+    let descriptor = parse_dbt_descriptor(content)?;
+    // A DEPLOY writes a whole node set of its own, `raw_code` included, so it
+    // has to reclaim as well: hung off runs alone, a project redeployed on every
+    // push by CI and run nightly kept one full graph per push until the next
+    // run, and one deployed but never run kept them for good.
+    {
+        let (pool, prune_w_id) = (db.clone(), w_id.to_string());
+        let prune_path = script_path.to_string();
+        tokio::spawn(async move {
+            if let Err(e) =
+                windmill_common::dbt_manifest::prune_dbt_run_graphs(&pool, &prune_path, &prune_w_id)
+                    .await
+            {
+                tracing::warn!("pruning dbt graphs at deploy: {e:#}");
+            }
+        });
+    }
+    // The script's own `envs`, exactly as a run gets them. A project can drive a
+    // model's schema, alias or `enabled` from `env_var()`, so parsing with an
+    // empty environment would record one relation at deploy and build another
+    // at run time — with no per-run refresh to correct it.
+    let envs = script_envs(db, job_id, w_id).await;
+    let conn = Connection::Sql(db.clone());
+    let client = AuthedClient::new(
+        base_internal_url.to_string(),
+        w_id.to_string(),
+        token.to_string(),
+        None,
+    );
+    // A dependency job carries no per-job timeout of its own, but its phases
+    // still share one wall clock rather than each getting the instance-wide
+    // one.
+    let deadline = JobDeadline::start(&conn, w_id, *job_id, None).await;
+    let mut ctx = JobCtx { mem_peak, canceled_by, occupancy_metrics, worker_name, deadline };
+    let prepared = prepare_project(
+        &descriptor,
+        content,
+        None,
+        job_dir,
+        job_id,
+        w_id,
+        script_path,
+        deploying_script_hash(db, job_id).await,
+        &conn,
+        &client,
+        &mut ctx,
+        &envs,
+        modules,
+    )
+    .await?;
+
+    // A deploy has no job arguments, so it tolerates the `{{ }}` placeholders
+    // only a run can fill (see `Invocation::strict`). Its environment is the
+    // script's, matching what the run will parse with.
+    let inv = Invocation { envs: envs.clone(), strict: false, ..Default::default() };
+    run_dbt_parse(&prepared, &descriptor, &inv, &mut ctx, job_id, w_id, &conn).await?;
+
+    let selected =
+        resolve_selection(&prepared, &descriptor, &inv, &mut ctx, job_id, w_id, &conn).await?;
+    let manifest = read_manifest(&prepared.project_dir).await?;
+    let manifest_digest = digest(
+        &tokio::fs::read_to_string(
+            prepared
+                .project_dir
+                .join(ARTIFACTS_DIR)
+                .join("manifest.json"),
+        )
+        .await
+        .unwrap_or_default(),
+    );
+
+    // Two deploys of one path can run concurrently — nothing serializes
+    // dependency jobs. The GRAPH is keyed by version so both may write theirs;
+    // the path-keyed asset usages are claimed by the newest.
+    let publisher = match deploying_script_hash(db, job_id).await {
+        Some(hash) => GraphPublisher::Version(hash),
+        None => GraphPublisher::Unversioned,
+    };
+    let superseded = if let Some(warehouse) = prepared.warehouse.as_deref() {
+        let ingested = windmill_common::dbt_manifest::ingest_manifest(
+            &manifest,
+            warehouse,
+            prepared.default_database.as_deref(),
+            selected.as_ref(),
+        );
+        let published = persist_ingest(
+            db,
+            w_id,
+            script_path,
+            &ingested,
+            &prepared.relation_root(),
+            publisher,
+            None,
+            true,
+        )
+        .await?;
+        if published {
+            append_logs(
+                job_id,
+                w_id,
+                format!(
+                    "\nIngested {} dbt nodes and {} edges into the asset graph\n",
+                    ingested.nodes.len(),
+                    ingested.edges.len()
+                ),
+                &conn,
+            )
+            .await;
+        }
+        !published
+    } else {
+        // No warehouse identity, so nothing can be ingested — but this version's
+        // rows must still go, or a descriptor moved to its own profiles.yml keeps
+        // claiming relations it no longer describes.
+        let mut tx = db.begin().await?;
+        // Clearing is a publication too: an older job that no longer describes the
+        // script must not wipe a newer deploy's graph.
+        let published = claim_graph_publication(&mut tx, w_id, script_path, publisher).await?;
+        if published {
+            // This VERSION's rows, never the path's: what is given up is the
+            // path-keyed usage cleared below, while an older version's graph is
+            // what its own finished runs still render.
+            if let GraphPublisher::Version(hash) = publisher {
+                windmill_common::dbt_manifest::clear_dbt_manifest_version(
+                    &mut tx,
+                    w_id,
+                    script_path,
+                    hash,
+                )
+                .await?;
+            }
+            windmill_common::assets::replace_static_asset_usage(&mut tx, w_id, script_path, &[])
+                .await?;
+            tx.commit().await?;
+            append_logs(
+                job_id,
+                w_id,
+                "\nNo asset-graph ingest: the descriptor names no `profile.warehouse` beside \
+                 its own `profile.profiles_yml`, so there is no warehouse identity to key \
+                 `dbt://` assets on. Any previously ingested nodes for this script have been \
+                 cleared.\n"
+                    .to_string(),
+                &conn,
+            )
+            .await;
+        }
+        !published
+    };
+    if superseded {
+        append_logs(
+            job_id,
+            w_id,
+            "\nA newer version of this script was deployed while this job ran, so the asset \
+             graph was left describing that one.\n"
+                .to_string(),
+            &conn,
+        )
+        .await;
+    }
+
+    serde_json::to_string_pretty(&DbtDependencyLocks {
+        manifest_digest,
+        profile_relation_root: Some(prepared.relation_root()),
+        engine: prepared.engine.engine.as_str().to_string(),
+        engine_version: prepared.engine.version.clone(),
+        adapter_version: prepared.engine.adapter_version.clone(),
+        package_lock_digest: prepared.package_lock_digest.clone(),
+    })
+    .map_err(|e| Error::internal_err(format!("serializing the dbt lockfile: {e}")))
+}
+
+/// The `envs` of the script this dependency job is deploying, in the same shape
+/// a run receives them. Empty when the version cannot be resolved — a raw
+/// dependency job has no script row.
+async fn script_envs(
+    db: &sqlx::Pool<sqlx::Postgres>,
+    job_id: &Uuid,
+    w_id: &str,
+) -> HashMap<String, String> {
+    let Some(hash) = deploying_script_hash(db, job_id).await else {
+        return HashMap::new();
+    };
+    let envs = sqlx::query_scalar!(
+        "SELECT envs FROM script WHERE workspace_id = $1 AND hash = $2",
+        w_id,
+        hash
+    )
+    .fetch_optional(db)
+    .await
+    .ok()
+    .flatten()
+    .flatten();
+    crate::worker::build_envs(envs.as_ref()).unwrap_or_default()
+}
+
+/// The script version this dependency job is deploying. `None` for a raw
+/// dependency job (the CLI's lock generation), which has no script row.
+async fn deploying_script_hash(db: &sqlx::Pool<sqlx::Postgres>, job_id: &Uuid) -> Option<i64> {
+    sqlx::query_scalar!("SELECT runnable_id FROM v2_job WHERE id = $1", job_id)
+        .fetch_optional(db)
+        .await
+        .ok()
+        .flatten()
+        .flatten()
+}
+
+/// Why a run re-ingests its graph instead of trusting the deployed version's —
+/// and, since the reasons differ in WHOSE graph the result is, what becomes of
+/// it.
+///
+/// A model set this RUN decides — a caller's override, or a descriptor dynamic by
+/// construction — is stored under the job id so the run page shows what it built,
+/// leaving the script's ownership alone: those schemas and aliases would otherwise
+/// stand as the script's until the next deploy.
+///
+/// A moved PROFILE is the one that republishes, because every later run of this
+/// version resolves there too. Publishing is also what ENDS a drift: the check
+/// reads back the published root, so a run that saw a move and did not republish
+/// leaves the next one seeing the same move.
+#[derive(Clone, Copy, Default)]
+pub struct GraphRefresh {
+    /// This run's models are not the deployed descriptor's: a `{{ }}`
+    /// placeholder in `vars` or a `$var:` in `env` (re-resolved every run), or
+    /// an invocation that overrode `vars`. Vars steer `enabled`, alias, schema,
+    /// database and materialization, so the deployed graph names another run's
+    /// relations.
+    per_run_models: bool,
+    /// The profile resolves somewhere other than where the published usages
+    /// point. The relations moved for the VERSION, not for one invocation.
+    profile_drift: bool,
+}
+
+impl GraphRefresh {
+    /// Whether this run parses and ingests a graph of its own at all.
+    fn needed(&self) -> bool {
+        self.per_run_models || self.profile_drift
+    }
+
+    /// The job to key this graph under, or `None` to write the version's own.
+    ///
+    /// Only a DRIFT alone writes the version's: the move is permanent, and
+    /// storing it per run would leave every later run — which no longer detects
+    /// a drift, because this one published the new root — reading the pre-move
+    /// rows. A run whose models are its own goes under the job id, in both
+    /// directions: written as the version's, a narrowing selection would drop
+    /// every model this invocation left out, and a widening one would add models
+    /// that version never had.
+    fn snapshot_job(&self, job_id: uuid::Uuid) -> Option<uuid::Uuid> {
+        self.per_run_models.then_some(job_id)
+    }
+
+    /// Whether this ingest also becomes what the script owns.
+    ///
+    /// Exactly when it wrote the VERSION's graph and the caller scoped nothing.
+    /// The workspace graph takes an asset's relations from the `asset` rows and
+    /// its models, SQL, tests and `ref()` lineage from that version's
+    /// `dbt_node`/`dbt_edge`, so publishing relations the version's graph does
+    /// not name leaves those assets with no model behind them — a placeholder
+    /// that moves an alias would empty the current graph of everything dbt
+    /// contributes to it.
+    ///
+    /// So a run that stored a snapshot of its own publishes nothing, which
+    /// leaves two cases settled elsewhere and deliberately: an override's
+    /// relations are a one-off and are meant not to stand as the script's, and a
+    /// dynamic descriptor at a moved profile keeps its ownership at the deploy's
+    /// relations until a redeploy — every run of it still shows its own models,
+    /// and it re-parses regardless, so the undetected-forever drift costs it
+    /// nothing it was not already paying.
+    ///
+    /// The exact complement of `snapshot_job`, which is what lets the agent
+    /// worker's payload carry one `per_run` bit and no second flag: decouple the
+    /// two and that wire format stops describing this decision.
+    fn publishes_ownership(&self) -> bool {
+        !self.per_run_models
+    }
+
+    /// Fold in what this invocation's own arguments say about its model set.
+    fn add_caller_args(
+        &mut self,
+        descriptor: &DbtDescriptor,
+        args: &HashMap<String, Box<RawValue>>,
+    ) -> error::Result<()> {
+        if has_vars_override(args) {
+            self.per_run_models = true;
+        }
+        // A caller's selection is not necessarily a SUBSET of the deployed one:
+        // deployed `select: ["tag:nightly"]`, overridden with `["*"]`, builds models
+        // the deployed graph never had — and those are the ones whose progress, SQL
+        // and lineage the run page would otherwise have nothing to draw.
+        if selection_is_overridden(descriptor, args)? {
+            self.per_run_models = true;
+        }
+        Ok(())
+    }
+}
+
+pub struct PreparedProject {
+    pub project_dir: PathBuf,
+    pub profiles_dir: PathBuf,
+    pub engine: ProvisionedEngine,
+    /// Why this run's graph is its own rather than the deployed version's, if
+    /// it is.
+    pub graph_refresh: GraphRefresh,
+    /// Digest of the project's own files: the identity of the code that runs.
+    /// It keys the package cache (a `local:` dependency's content appears in no
+    /// manifest) and gates retry state, so a project edited between attempts
+    /// cannot resume the old one.
+    pub project_digest: String,
+    /// Resolution produced by `dbt deps` at deploy. The package cache is local
+    /// to one worker; this makes a cache miss on another worker fail closed if
+    /// an unlocked range or mutable Git revision has moved meanwhile.
+    pub package_lock_digest: Option<String>,
+    /// The workspace warehouse's NAME, the `<warehouse>` component of every
+    /// `dbt://` asset this project produces. `None` when the project brings its
+    /// own `profiles.yml` and names no warehouse, in which case there is no
+    /// stable warehouse identity to key assets on.
+    pub warehouse: Option<String>,
+    /// The descriptor's `profile.target`, passed as `--target` so it applies to
+    /// a project-owned `profiles.yml` as well as a rendered one.
+    pub target: Option<String>,
+    /// The profile target's database. Nodes that override it qualify their
+    /// `dbt://` schema segment so two databases cannot collapse onto one node.
+    pub default_database: Option<String>,
+    /// The profile target's schema, for the drift check against the lockfile.
+    pub default_schema: Option<String>,
+    pub script_path: String,
+    pub env: Vec<(String, String)>,
+    /// The descriptor body, kept so an ingest can re-read its `# on` / `# mute`
+    /// annotations without threading the content through every caller.
+    pub descriptor_content: String,
+    /// The descriptor's `env`, resolved, in a stable order. Feeds run identity;
+    /// `env` itself is not usable there because it carries per-job values.
+    pub descriptor_env: std::collections::BTreeMap<String, String>,
+    /// The invocation's own environment (the script's `envs`), in a stable
+    /// order. Every phase gets it, `dbt deps` included: `packages.yml` can
+    /// resolve a private package URL through `env_var()`, and a phase that saw
+    /// a different environment from the one the cache key was built on would
+    /// populate that key with the wrong tree.
+    pub invocation_env: Vec<(String, String)>,
+    /// Digest of the above. Keys the package cache alongside the descriptor's
+    /// environment; digested because the values are resolved secrets.
+    pub invocation_env_digest: u64,
+    /// Written nsjail profile for this job, when the worker sandboxes jobs.
+    /// `None` means the phases run unsandboxed, exactly as before.
+    pub sandbox_config: Option<SandboxProfile>,
+    /// One-way digest of the rendered profile — the resolved connection, not
+    /// just the names it exposes. A resource repointed from one warehouse to
+    /// another that happens to use the same database and schema names is
+    /// invisible to `relation_root`, and a retry would then execute the saved
+    /// failures against a warehouse where the successful nodes do not exist.
+    pub profile_digest: String,
+}
+
+impl PreparedProject {
+    /// Where this run's relations live: the resolved schema and database. Drift
+    /// here since the deploy means the stored graph names relations that no
+    /// longer exist.
+    fn relation_root(&self) -> String {
+        format!(
+            "{}|{}",
+            self.default_schema.as_deref().unwrap_or(""),
+            self.default_database.as_deref().unwrap_or(""),
+        )
+    }
+
+    /// The environment `dbt_project.yml`'s own `env_var()` calls render
+    /// against: the two the run gives dbt, in the order the child receives
+    /// them. `HOME` is left out on purpose — it is Windmill's, not the
+    /// project's, and it differs on every attempt.
+    fn template_env(&self) -> HashMap<String, String> {
+        self.descriptor_env
+            .iter()
+            .map(|(k, v)| (k.clone(), v.clone()))
+            .chain(self.invocation_env.iter().cloned())
+            .collect()
+    }
+
+    /// A digest of the DESCRIPTOR's resolved environment, for `run_identity`.
+    /// Digested rather than listed: the values are resolved secrets.
+    ///
+    /// Only the descriptor's own entries. `env` additionally carries `HOME`,
+    /// set to this job's directory, which differs on every attempt — hashing it
+    /// would make a retry reject its own predecessor every time.
+    fn env_digest(&self) -> String {
+        stable_digest(
+            self.descriptor_env
+                .iter()
+                .flat_map(|(k, v)| [k.as_str(), v.as_str()]),
+        )
+    }
+
+    /// Everything that decides which relations a run produces, which is what a
+    /// retry has to match before it may resume a saved `run_results.json`: same
+    /// project files, same warehouse and target, same engine. Identity only,
+    /// never credentials — the profile is digested, and the digest is one-way.
+    ///
+    /// Anything omitted here is something a redeploy could change while a stale
+    /// `run_results.json` stays eligible, so `dbt retry` would resume one
+    /// project's failures inside another. The descriptor's resolved environment
+    /// is in it because `env_var()` can drive a model's schema, database, alias
+    /// or `enabled`.
+    fn run_identity(&self) -> String {
+        // The descriptor whole, not field by field, or the next field added to it
+        // is silently left out. And the RESOLVED engine and adapter versions: an
+        // unchanged project redeployed after a release resolves a newer dbt, whose
+        // retry would otherwise feed one version's `run_results.json` to another.
+        format!(
+            "{}|{}|{}|{}|{}|{}|{}|{}|{}",
+            self.project_digest,
+            self.package_lock_digest.as_deref().unwrap_or(""),
+            self.engine.engine.as_str(),
+            self.engine.version,
+            self.engine.adapter_version.as_deref().unwrap_or(""),
+            digest(&self.descriptor_content),
+            self.env_digest(),
+            self.relation_root(),
+            self.profile_digest,
+        )
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(crate) async fn prepare_project(
+    descriptor: &DbtDescriptor,
+    descriptor_content: &str,
+    locks: Option<&DbtDependencyLocks>,
+    job_dir: &str,
+    job_id: &Uuid,
+    w_id: &str,
+    // Keys the per-script retry-state cache. Passed in rather than patched onto
+    // the result afterwards: an empty value silently shares one state directory
+    // across every dbt script in the workspace, so a retry resumes another
+    // project's run_results.json.
+    script_path: &str,
+    // The version this job runs, which is the one whose stored graph the drift
+    // check below must read. `None` for a preview, which has no stored graph.
+    script_hash: Option<i64>,
+    conn: &Connection,
+    client: &AuthedClient,
+    ctx: &mut JobCtx<'_>,
+    // The invocation's own environment (script-level `envs`). Needed here
+    // because under a sandbox it must travel in the jail profile rather than
+    // on the process that execs nsjail.
+    invocation_env: &HashMap<String, String>,
+    // The script's files: the dbt project itself.
+    modules: Option<&HashMap<String, windmill_common::scripts::ScriptModule>>,
+) -> error::Result<PreparedProject> {
+    // The project IS this script's files. Nothing is fetched: the bundle is the
+    // project. A dependency job has no generic module-writing step, so it does
+    // the writing here; a run rewrites the same bytes, which costs nothing next
+    // to the dbt invocations that follow.
+    if let Some(modules) = modules {
+        write_module_files(job_dir, modules, None).await?;
+    }
+    let project_dir = PathBuf::from(job_dir);
+    if !project_dir.join("dbt_project.yml").exists() {
+        return Err(Error::BadRequest(
+            "this dbt script carries no project: `dbt_project.yml` was not found. Copy a dbt \
+             project into its `<script>__dbt/` folder and push it (`wmill sync push`)"
+                .to_string(),
+        ));
+    }
+    // Vars drive `enabled`, alias, schema, database and materialization, so a
+    // placeholder var or a `$var:` env value (re-resolved every run) makes the
+    // deploy-time graph a guess and each run re-ingests its own manifest.
+    let has_placeholder = |v: &str| v.contains("{{");
+    let graph_refresh = GraphRefresh {
+        per_run_models: descriptor
+            .vars
+            .values()
+            .flat_map(windmill_parser_yaml::dbt::string_leaves)
+            .any(has_placeholder)
+            || descriptor.env.values().any(|v| v.starts_with("$var:")),
+        ..Default::default()
+    };
+
+    let resolved_env = resolve_env(descriptor, client).await?;
+    reject_reserved_env(
+        resolved_env.iter().map(|(k, _)| k),
+        "the descriptor's `env`",
+    )?;
+    reject_reserved_env(invocation_env.keys(), "the script's environment variables")?;
+    // `PreparedProject::template_env`, before there is one.
+    let template_env: HashMap<String, String> = resolved_env
+        .iter()
+        .cloned()
+        .chain(invocation_env.iter().map(|(k, v)| (k.clone(), v.clone())))
+        .collect();
+
+    let (profiles_dir, warehouse, adapter, default_database, default_schema, profile_digest) =
+        write_profiles(descriptor, &project_dir, job_dir, client, &template_env).await?;
+    // The lockfile's version, when it pinned one for this same engine — a
+    // descriptor edited to another engine invalidates the pin.
+    let pinned_version = locks
+        .filter(|l| l.engine == descriptor.engine().as_str())
+        .map(|l| l.engine_version.as_str())
+        .filter(|v| !v.is_empty());
+    let engine = provision_engine(
+        descriptor.engine(),
+        adapter,
+        pinned_version,
+        locks
+            .filter(|l| l.engine == descriptor.engine().as_str())
+            .and_then(|l| l.adapter_version.as_deref())
+            .filter(|v| !v.is_empty()),
+        job_id,
+        w_id,
+        conn,
+        &mut *ctx,
+    )
+    .await?;
+
+    let descriptor_env: std::collections::BTreeMap<String, String> =
+        resolved_env.iter().cloned().collect();
+    let mut env = resolved_env;
+    // Both engines write their profile-independent state under the project;
+    // pinning it inside the job dir keeps a job from touching a shared $HOME.
+    env.push(("HOME".to_string(), job_dir.to_string()));
+
+    // The engines are provisioned per (version, adapter) under one cache root,
+    // and mounting that root rather than the resolved engine directory keeps
+    // the profile identical for every job on this worker.
+    let sandbox_config: Option<SandboxProfile> = if is_sandboxing_enabled() {
+        let nsjail_timeout = resolve_nsjail_timeout(conn, w_id, *job_id, ctx.timeout()).await;
+        // A SIBLING of the job directory: that directory is mounted read-write
+        // into the jail, and every phase re-reads this file.
+        let sandbox_dir = PathBuf::from(format!("{job_dir}.dbt-sandbox"));
+        tokio::fs::create_dir_all(&sandbox_dir).await.map_err(|e| {
+            Error::internal_err(format!("could not create the dbt sandbox dir: {e}"))
+        })?;
+        write_file(
+            &sandbox_dir.to_string_lossy(),
+            SANDBOX_PROFILE_NAME,
+            &NSJAIL_CONFIG_RUN_DBT_CONTENT
+                .replace(
+                    "{RLIMIT_AS}",
+                    &render_nsjail_rlimit_as(NSJAIL_DBT_RLIMIT_AS_MB.as_deref(), 4096),
+                )
+                .replace("{JOB_DIR}", &escape_textproto(job_dir))
+                .replace(
+                    "{PROJECT_DIR}",
+                    &escape_textproto(&project_dir.to_string_lossy()),
+                )
+                // The engine's own directory, NOT the cache root: its siblings
+                // are other workspaces' package trees, kept apart by cache key
+                // rather than by permissions.
+                .replace(
+                    "{ENGINE_DIR}",
+                    &escape_textproto(&engine.root.to_string_lossy()),
+                )
+                .replace(
+                    "{PY_INSTALL_DIR}",
+                    &escape_textproto(&crate::PY_INSTALL_DIR),
+                )
+                .replace("{CLONE_NEWUSER}", &(!*crate::DISABLE_NUSER).to_string())
+                // Both environments the child needs: the descriptor's and the
+                // invocation's. Neither may sit on the launcher.
+                .replace(
+                    "{ENVARS}",
+                    &jail_envars(
+                        env.iter()
+                            .map(|(k, v)| (k.clone(), v.clone()))
+                            .chain(invocation_env.iter().map(|(k, v)| (k.clone(), v.clone())))
+                            .collect::<Vec<_>>()
+                            .as_slice(),
+                    ),
+                )
+                .replace("{SHARED_MOUNT}", "")
+                .replace(
+                    "{TMP_MOUNT_BLOCK}",
+                    &resolve_nsjail_tmp_mount_block(job_dir).await,
+                )
+                .replace("{TIMEOUT}", &nsjail_timeout),
+        )
+        // Fail the job rather than fall back: a `None` here means every
+        // project-controlled phase would run unsandboxed on a worker configured
+        // to isolate them, and a project can make this write fail on purpose by
+        // filling the job filesystem first.
+        .map_err(|e| {
+            Error::internal_err(format!("could not write the dbt sandbox profile: {e}"))
+        })?;
+        Some(SandboxProfile(sandbox_dir.join(SANDBOX_PROFILE_NAME)))
+    } else {
+        None
+    };
+
+    let project_digest = project_digest(modules);
+
+    // Sorted so the digest depends on the values rather than on map ordering.
+    let sorted_invocation_env = {
+        let mut v: Vec<(String, String)> = invocation_env
+            .iter()
+            .map(|(k, val)| (k.clone(), val.clone()))
+            .collect();
+        v.sort();
+        v
+    };
+    let mut prepared = PreparedProject {
+        project_digest,
+        package_lock_digest: locks.and_then(|l| l.package_lock_digest.clone()),
+        invocation_env: sorted_invocation_env.clone(),
+        invocation_env_digest: {
+            use std::hash::{Hash, Hasher};
+            let mut h = std::collections::hash_map::DefaultHasher::new();
+            for (k, v) in &sorted_invocation_env {
+                k.hash(&mut h);
+                v.hash(&mut h);
+            }
+            h.finish()
+        },
+        sandbox_config,
+        profile_digest,
+        project_dir,
+        profiles_dir,
+        engine,
+        graph_refresh,
+        warehouse,
+        target: descriptor.profile.target.clone(),
+        descriptor_content: descriptor_content.to_string(),
+        descriptor_env,
+
+        default_database,
+        default_schema,
+        script_path: script_path.to_string(),
+        env,
+    };
+    // A moved profile relocates every relation, so the stored graph names ones that
+    // no longer exist. Compared against the root recorded beside THIS VERSION's
+    // graph: not the deploy lock, which A→B→A matches while the graph sits at B,
+    // and not the newest ingest of any job, which a matching run never writes.
+    match conn {
+        Connection::Sql(db) => {
+            if let Some(stored) = sqlx::query_scalar!(
+                "SELECT relation_root_at_last_ingest FROM dbt_graph_snapshot
+                  WHERE workspace_id = $1 AND script_path = $2 AND script_hash = $3
+                    AND job_id = '00000000-0000-0000-0000-000000000000'",
+                w_id,
+                script_path,
+                script_hash,
+            )
+            .fetch_optional(db)
+            .await?
+            .flatten()
+            {
+                if stored != prepared.relation_root() {
+                    prepared.graph_refresh.profile_drift = true;
+                }
+            }
+        }
+        // An agent cannot READ the stored root, but publishing settles what the
+        // comparison asks: it re-ingests what it parsed. Under its own job id,
+        // since it cannot tell a moved profile from an unmoved one and must not
+        // overwrite the version's graph on a guess.
+        Connection::Http(_) => prepared.graph_refresh.per_run_models = true,
+    }
+    prepared.package_lock_digest =
+        install_packages(&prepared, locks.is_some(), &mut *ctx, job_id, w_id, conn).await?;
+    Ok(prepared)
+}
+/// Identity of the project's own files: what the run reproduces, and what a
+/// retry must match to be allowed to resume.
+///
+/// Sorted, so it depends on the files rather than on map ordering: a digest
+/// that moved between two runs of one project would evict the package cache
+/// every time and reject every retry. Every caller must pass the bundle; an
+/// empty one collapses every project in the workspace onto one digest, which
+/// silently lets a retry resume a DIFFERENT project's `run_results.json`.
+fn project_digest(
+    modules: Option<&HashMap<String, windmill_common::scripts::ScriptModule>>,
+) -> String {
+    let mut names: Vec<&String> = modules.map(|m| m.keys().collect()).unwrap_or_default();
+    names.sort();
+    let mut h = Sha256::new();
+    for name in names {
+        h.update(name.as_bytes());
+        h.update([0u8]);
+        if let Some(m) = modules.and_then(|m| m.get(name)) {
+            h.update(m.content.as_bytes());
+        }
+        h.update([0u8]);
+    }
+    format!("{:x}", h.finalize())[..32].to_string()
+}
+
+/// Resolve `$var:<path>` values in the descriptor's `env`. This is the only way
+/// a project using its own `profiles.yml` can get a secret into
+/// `{{ env_var() }}` without writing it into versioned script content.
+async fn resolve_env(
+    descriptor: &DbtDescriptor,
+    client: &AuthedClient,
+) -> error::Result<Vec<(String, String)>> {
+    let mut out = Vec::with_capacity(descriptor.env.len());
+    for (k, v) in &descriptor.env {
+        let value = match v.strip_prefix("$var:") {
+            Some(path) => client.get_variable_value(path.trim()).await.map_err(|e| {
+                Error::NotFound(format!("variable {path} not found for `env.{k}`: {e:#}"))
+            })?,
+            None => v.clone(),
+        };
+        out.push((k.clone(), value));
+    }
+    Ok(out)
+}
+
+async fn package_lock_digest(project_dir: &Path) -> error::Result<Option<String>> {
+    match tokio::fs::read_to_string(project_dir.join("package-lock.yml")).await {
+        Ok(lock) => Ok(Some(digest(&lock))),
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(None),
+        Err(e) => Err(Error::internal_err(format!(
+            "reading the dbt package lock: {e}"
+        ))),
+    }
+}
+
+fn package_cache_key(base: &str, lock_digest: &str) -> String {
+    digest(&format!("{base}\nresolved-lock\n{lock_digest}"))
+}
+
+/// Resolve or restore `dbt_packages/`, proving the tree matches the dependency
+/// resolution recorded when this script version was deployed.
+///
+/// dbt re-resolves ranges and mutable git revisions on every `dbt deps`; the deploy
+/// is the only place that happens here, so runs of one version cannot disagree about
+/// what they installed. A project that wants a newer version deploys again — nothing
+/// expires a tree by age, which would re-resolve mid-run and then be refused below
+/// for differing from the pin.
+async fn install_packages(
+    p: &PreparedProject,
+    require_pinned_resolution: bool,
+    ctx: &mut JobCtx<'_>,
+    job_id: &Uuid,
+    w_id: &str,
+    conn: &Connection,
+) -> error::Result<Option<String>> {
+    // A hit skips `dbt deps`, so the key covers what determines the tree: declared
+    // packages, a committed lock, and a `local:` dependency's content (no manifest
+    // holds it; the project digest stands in). Workspace too — `dbt deps` fetches
+    // private git packages, and a shared tree would run one workspace's for another.
+    let mut key = format!(
+        "{w_id}\n{}\n{}\n{:x}\n",
+        p.project_digest,
+        p.env_digest(),
+        p.invocation_env_digest,
+    );
+    let mut declares_packages = false;
+    for f in ["packages.yml", "dependencies.yml", "package-lock.yml"] {
+        let path = p.project_dir.join(f);
+        if !path.exists() {
+            continue;
+        }
+        declares_packages |= f != "package-lock.yml";
+        key.push_str(f);
+        key.push('\n');
+        key.push_str(&tokio::fs::read_to_string(&path).await.unwrap_or_default());
+    }
+    if !declares_packages {
+        return Ok(None);
+    }
+    // A committed `package-lock.yml` keys the lookup but is not the answer: dbt
+    // rewrites it when the `sha1_hash` it recorded for `packages.yml` stops
+    // matching, so holding the deploy to it would refuse the first deploy after a
+    // package is added, with no way out. The deploy records what dbt resolved.
+    let project_lock_digest = package_lock_digest(&p.project_dir).await?;
+    let expected_lock_digest = p
+        .package_lock_digest
+        .as_deref()
+        .or(project_lock_digest.as_deref());
+    if require_pinned_resolution && expected_lock_digest.is_none() {
+        return Err(Error::BadRequest(
+            "this script's lock predates deployment-pinned dbt dependencies; redeploy the project"
+                .to_string(),
+        ));
+    }
+    // Where `dbt deps` actually writes. `packages-install-path` is a project
+    // setting, and assuming the default means a project that moved it gets no
+    // cache at all: the publish finds nothing to copy and every job resolves
+    // its dependencies over the network again.
+    let target = p
+        .project_dir
+        .join(packages_install_path(&p.project_dir, &p.template_env()).await?);
+    let cached = expected_lock_digest.map(|lock| {
+        PathBuf::from(&*DBT_CACHE_DIR)
+            .join("packages")
+            .join(package_cache_key(&key, lock))
+    });
+    if let Some(cached) = cached.as_ref().filter(|cached| cached.exists()) {
+        let restored = copy_dir_watched(
+            cached,
+            &target,
+            "restoring cached dbt_packages",
+            ctx,
+            job_id,
+            w_id,
+            conn,
+        )
+        .await;
+        // A tree that went missing between `exists()` and the copy is a cache MISS,
+        // not a failed job: `dbt deps` resolves it again. Falling through costs a
+        // fetch; failing costs the run.
+        if restored.is_ok() {
+            append_logs(
+                job_id,
+                w_id,
+                "\nReusing cached dbt_packages\n".to_string(),
+                conn,
+            )
+            .await;
+            return Ok(expected_lock_digest.map(str::to_string));
+        }
+        tokio::fs::remove_dir_all(&target).await.ok();
+        append_logs(
+            job_id,
+            w_id,
+            "\nCached dbt_packages went away mid-restore; resolving them again\n".to_string(),
+            conn,
+        )
+        .await;
+    }
+    run_prep_command(
+        p,
+        dbt_command(p, &["deps"]),
+        "dbt deps",
+        ctx,
+        job_id,
+        w_id,
+        conn,
+    )
+    .await?;
+    let resolved_lock_digest = package_lock_digest(&p.project_dir).await?.ok_or_else(|| {
+        Error::ExecutionErr(
+            "`dbt deps` completed without producing package-lock.yml; Windmill cannot pin this \
+             dependency resolution across workers"
+                .to_string(),
+        )
+    })?;
+    // Against the PIN alone. Only a run has a resolution to be held to; the deploy
+    // is where one is established, so it accepts what dbt resolved and records it.
+    if let Some(pinned) = p.package_lock_digest.as_deref() {
+        if pinned != resolved_lock_digest {
+            return Err(Error::BadRequest(
+                "this project's dbt dependencies resolve differently here from the resolution \
+                 recorded when this script version was deployed; redeploy to accept the new one"
+                    .to_string(),
+            ));
+        }
+    }
+    if target.exists() {
+        let cached = PathBuf::from(&*DBT_CACHE_DIR)
+            .join("packages")
+            .join(package_cache_key(&key, &resolved_lock_digest));
+        publish_to_cache(&target, &cached, ctx, job_id, w_id, conn).await;
+    }
+    Ok(Some(resolved_lock_digest))
+}
+
+/// Copy `from` into a sibling of `cached`, then move it into place.
+///
+/// The rename is the point. The copy creates its destination and then fills it,
+/// so a concurrent job on the same host — worker processes share
+/// `DBT_CACHE_DIR` — would see `cached` exist and restore a half-written
+/// package tree. Worse, a copy interrupted by cancellation or disk pressure
+/// would leave that tree in place for every later job, so a transient failure
+/// becomes permanent. Staging keeps it under a name nothing looks up.
+/// Same pattern as the engine provisioning; best-effort, since losing the race
+/// only means the next job repopulates.
+async fn publish_to_cache(
+    from: &Path,
+    cached: &Path,
+    ctx: &mut JobCtx<'_>,
+    job_id: &Uuid,
+    w_id: &str,
+    conn: &Connection,
+) {
+    let Some(parent) = cached.parent() else {
+        return;
+    };
+    if tokio::fs::create_dir_all(parent).await.is_err() {
+        return;
+    }
+    let name = cached.file_name().unwrap_or_default().to_string_lossy();
+    let staging = cached.with_file_name(format!("{name}.staging-{job_id}"));
+    tokio::fs::remove_dir_all(&staging).await.ok();
+    if copy_dir_watched(
+        from,
+        &staging,
+        "caching dbt_packages",
+        ctx,
+        job_id,
+        w_id,
+        conn,
+    )
+    .await
+    .is_err()
+        || strip_git_remotes(&staging).await.is_err()
+        || tokio::fs::rename(&staging, cached).await.is_err()
+    {
+        tokio::fs::remove_dir_all(&staging).await.ok();
+    }
+}
+
+/// Drop the origin remotes from a `dbt_packages` tree on its way into the cache.
+///
+/// `dbt deps` clones `git:` packages and leaves each one's `.git` behind, with
+/// the URL it was given in `.git/config` — and for token auth that URL *is* the
+/// credential, since `packages.yml` renders it from `env_var()`. The cache is
+/// worker-global and outlives the job, so copying the tree verbatim would leave
+/// a live token readable by every later job on the host. Restores never fetch,
+/// so no remote is needed.
+async fn strip_git_remotes(dir: &Path) -> std::io::Result<()> {
+    let mut entries = tokio::fs::read_dir(dir).await?;
+    while let Some(e) = entries.next_entry().await? {
+        strip_git_remote(&e.path()).await?;
+    }
+    Ok(())
+}
+
+async fn strip_git_remote(dir: &Path) -> std::io::Result<()> {
+    let config = dir.join(".git").join("config");
+    if !config.exists() {
+        return Ok(());
+    }
+    let content = tokio::fs::read_to_string(&config).await?;
+    let mut out = String::with_capacity(content.len());
+    let mut in_remote = false;
+    for line in content.lines() {
+        let trimmed = line.trim_start();
+        if trimmed.starts_with('[') {
+            in_remote = trimmed.starts_with("[remote ");
+        }
+        if !in_remote {
+            out.push_str(line);
+            out.push('\n');
+        }
+    }
+    tokio::fs::write(&config, out).await
+}
+
+/// Write `profiles.yml`, either rendered from a Windmill resource or taken from
+/// the project itself. Both paths are supported (decision 8): the workspace
+/// warehouse is the ergonomic one, the project's own file is what makes an
+/// existing repo run unchanged.
+async fn write_profiles(
+    descriptor: &DbtDescriptor,
+    project_dir: &Path,
+    job_dir: &str,
+    client: &AuthedClient,
+    template_env: &HashMap<String, String>,
+) -> error::Result<(
+    PathBuf,
+    Option<String>,
+    DbtAdapter,
+    Option<String>,
+    Option<String>,
+    String,
+)> {
+    // The workspace's warehouse, always: a descriptor names one by NAME or takes
+    // `main`, and cannot name a resource at all. The NAME is what asset identity
+    // keys on, so every project on one warehouse shares its nodes while the
+    // credential stays a workspace setting only an admin writes.
+    let warehouse = descriptor
+        .profile
+        .warehouse
+        .as_deref()
+        .unwrap_or(DBT_DEFAULT_WAREHOUSE);
+
+    let declared = descriptor
+        .profile
+        .adapter
+        .as_deref()
+        .map(|t| {
+            DbtAdapter::from_resource_type(t).ok_or_else(|| {
+                Error::BadRequest(format!(
+                    "`profile.type: {t}` is not a supported dbt adapter (postgres, redshift, \
+                     mysql, duckdb, clickhouse, snowflake, bigquery, databricks, salesforce, \
+                     mssql, oracle)"
+                ))
+            })
+        })
+        .transpose()?;
+
+    if let Some(own) = descriptor.profile.profiles_yml.as_deref() {
+        crate::common::validate_relative_path(own, "profile.profiles_yml")?;
+        let path = project_dir.join(own);
+        let dir = path
+            .parent()
+            .ok_or_else(|| Error::BadRequest("profile.profiles_yml has no parent".to_string()))?
+            .to_path_buf();
+        // Read from the project's own file even when the descriptor declares a type:
+        // the file is what dbt connects with. Licensing is why it cannot be a hint —
+        // the Rust engines carry every adapter, so a descriptor claiming `postgres`
+        // over a `sqlserver` target would pass the CE check and connect anyway. A
+        // templated `type` is refused outright rather than taken from the
+        // descriptor, for the same reason: the claim cannot be checked against
+        // what dbt will render.
+        let target = adapter_from_profiles_yml(
+            &path,
+            &project_profile_name(project_dir, template_env).await,
+            descriptor.profile.target.as_deref(),
+        )
+        .await?;
+        let actual = target.adapter;
+        if let Some(declared) = declared.filter(|d| *d != actual) {
+            return Err(Error::BadRequest(format!(
+                "`profile.type: {}` disagrees with `{}`, whose target uses `{}`. dbt connects \
+                 with the file, so remove `profile.type` or correct it",
+                declared.name(),
+                own,
+                actual.name(),
+            )));
+        }
+        let adapter = actual;
+        ensure_adapter_licensed(adapter)?;
+        // The target's own database and schema, read from the file dbt connects
+        // with. A relation that sits in them is then spelled plainly, exactly as
+        // a workspace-warehouse project spells it, and one that overrides them
+        // qualifies. Where the file leaves them implicit they stay `None` and
+        // every relation qualifies, since assuming two share a database is what
+        // would collapse distinct relations onto a single node.
+        let profile_digest = digest(&tokio::fs::read_to_string(&path).await.unwrap_or_default());
+        // Identity only when the descriptor NAMES a warehouse: defaulting to
+        // `main` would key a self-hosted profile's assets onto the workspace
+        // warehouse it never connected to.
+        //
+        // The name is still resolved, because a name that matches no configured
+        // warehouse is not identity, it is a typo that would strand this
+        // project's models on a node nothing else reaches.
+        let identity = match descriptor.profile.warehouse.as_deref() {
+            Some(named) => {
+                windmill_common::workspaces::validate_dbt_warehouse_name(named)?;
+                // Only that it EXISTS: this project connects through its own
+                // file, so the connection behind the name is never opened and
+                // pulling it here would decrypt a credential for a string
+                // comparison.
+                client.dbt_warehouse_exists(named).await.map_err(|e| {
+                    Error::BadRequest(format!(
+                        "`profile.warehouse: {named}` is where this project's assets belong, so \
+                         it must name a warehouse this workspace configures: {e}"
+                    ))
+                })?;
+                Some(named.to_string())
+            }
+            None => None,
+        };
+        return Ok((
+            dir,
+            identity,
+            adapter,
+            target.database,
+            target.schema,
+            profile_digest,
+        ));
+    }
+
+    let resolved = resolve_warehouse(warehouse, client).await?;
+    let workspace_target = resolved.target;
+    let value = resolved.value;
+    let adapter = declared
+        .or_else(|| DbtAdapter::infer_from_resource(&value))
+        .ok_or_else(|| {
+            Error::BadRequest(format!(
+                "could not tell which dbt adapter the `{warehouse}` warehouse needs; \
+                 set `profile.type` in the descriptor"
+            ))
+        })?;
+    ensure_adapter_licensed(adapter)?;
+    let profile_name = project_profile_name(project_dir, template_env).await;
+    // The workspace's warehouse may name the target too, so a project that carries
+    // no connection still gets `{{ target }}` right.
+    let target = descriptor
+        .profile
+        .target
+        .as_deref()
+        .or(workspace_target.as_deref())
+        .unwrap_or("default");
+    let dir = PathBuf::from(job_dir).join("dbt_profiles");
+    tokio::fs::create_dir_all(&dir)
+        .await
+        .map_err(|e| Error::internal_err(format!("creating the profiles dir: {e}")))?;
+    let rendered = render_profile(
+        adapter,
+        &value,
+        &profile_name,
+        target,
+        descriptor.threads,
+        descriptor.profile.schema.as_deref(),
+        &dir,
+    )?;
+    write_file(dir.to_str().unwrap(), "profiles.yml", &rendered.yaml)?;
+    if let Some(pem) = rendered.root_certificate_pem.as_deref() {
+        write_file(
+            dir.to_str().unwrap(),
+            crate::dbt_profiles::ROOT_CERT_FILENAME,
+            pem,
+        )?;
+    }
+    let profile_digest = profile_identity_digest(
+        &rendered.yaml,
+        &dir,
+        rendered.root_certificate_pem.as_deref(),
+        &client.token,
+    );
+    Ok((
+        dir,
+        Some(warehouse.to_string()),
+        adapter,
+        rendered.database,
+        rendered.schema,
+        profile_digest,
+    ))
+}
+
+/// Where a workspace warehouse name points: its resource path and, if the
+/// workspace names one, its target.
+async fn resolve_warehouse(
+    warehouse: &str,
+    client: &AuthedClient,
+) -> error::Result<windmill_common::workspaces::DbtWarehouseConnection> {
+    // The descriptor supplies this name, so it is checked HERE too, not only
+    // where settings are written: it reaches the route as a URL path segment,
+    // and `../../resources/get_value/...` would resolve to another route.
+    windmill_common::workspaces::validate_dbt_warehouse_name(warehouse)?;
+    // Through the API even when this worker holds the database, because the
+    // route is where a resource is interpolated against the job — `$WM_TOKEN`
+    // and its kin resolve there and nowhere the worker can reach.
+    client
+        .get_dbt_warehouse(warehouse)
+        .await
+        .map_err(|e| Error::BadRequest(format!("resolving the dbt warehouse `{warehouse}`: {e}")))
+}
+
+/// Identifies the connection a rendered profile describes, for run identity.
+///
+/// Two things in the rendered text belong to the ATTEMPT rather than the
+/// connection, and hashing either as-is makes a retry reject its own
+/// predecessor — it compares identities and finds a different one every time:
+///
+/// * the per-job profiles dir, spelled out when a private CA is configured
+///   (`sslrootcert`). The certificate is part of the connection, so it is
+///   hashed in place of its path.
+/// * the job's own token, where the warehouse resource interpolates `$WM_TOKEN`
+///   (a warehouse reached through an OIDC or on-behalf flow does). Every
+///   attempt is a new job with a new token.
+fn profile_identity_digest(
+    yaml: &str,
+    profiles_dir: &Path,
+    root_cert_pem: Option<&str>,
+    job_token: &str,
+) -> String {
+    let normalized = yaml.replace(profiles_dir.to_str().unwrap_or_default(), "$PROFILES_DIR");
+    let normalized = if job_token.is_empty() {
+        normalized
+    } else {
+        normalized.replace(job_token, "$WM_TOKEN")
+    };
+    digest(&format!(
+        "{}\n{}",
+        normalized,
+        root_cert_pem.unwrap_or_default()
+    ))
+}
+
+async fn adapter_from_profiles_yml(
+    path: &Path,
+    profile_name: &str,
+    target: Option<&str>,
+) -> error::Result<ProfileTarget> {
+    let content = tokio::fs::read_to_string(path)
+        .await
+        .map_err(|e| Error::BadRequest(format!("could not read {}: {e}", path.display())))?;
+    let v: serde_yml::Value = serde_yml::from_str(&content)
+        .map_err(|e| Error::BadRequest(format!("could not parse {}: {e}", path.display())))?;
+    // The profile the project names and the target actually in use, not the
+    // first `type:` in the file: a `profiles.yml` may define several profiles
+    // and several targets, and provisioning the wrong adapter installs the
+    // wrong package and license-checks the wrong warehouse.
+    let outputs = v
+        .get(profile_name)
+        .and_then(|p| p.get("outputs"))
+        .ok_or_else(|| {
+            Error::BadRequest(format!(
+                "{} declares no profile named `{profile_name}` (the name in dbt_project.yml)",
+                path.display()
+            ))
+        })?;
+    let target = target
+        .or_else(|| {
+            v.get(profile_name)
+                .and_then(|p| p.get("target"))
+                .and_then(|t| t.as_str())
+        })
+        .ok_or_else(|| {
+            Error::BadRequest(format!(
+                "{} names no default target for `{profile_name}`; set `profile.target`",
+                path.display()
+            ))
+        })?;
+    // dbt renders the profile through Jinja before reading it; Windmill does not,
+    // so a templated `target:` — `{{ env_var('DBT_TARGET', 'prod') }}`, which is
+    // how a repo carries one profile across environments — is a name no output
+    // has. Where the profile defines exactly one output there is nothing to
+    // choose and it is taken; otherwise the descriptor has to say which.
+    let templated_target = target.contains("{{");
+    let out = if templated_target {
+        let only = outputs
+            .as_mapping()
+            .filter(|m| m.len() == 1)
+            .and_then(|m| m.values().next());
+        only.ok_or_else(|| {
+            Error::BadRequest(format!(
+                "{} selects its target with a template (`{target}`), which dbt renders and \
+                 Windmill does not, and defines several outputs. Set `profile.target` in the \
+                 descriptor to say which one this script runs",
+                path.display()
+            ))
+        })?
+    } else {
+        outputs.get(target).ok_or_else(|| {
+            Error::BadRequest(format!(
+                "{} has no `{target}` target under `{profile_name}`",
+                path.display()
+            ))
+        })?
+    };
+    let declared_type = out
+        .get("type")
+        .and_then(|t| t.as_str())
+        .filter(|t| !t.contains("{{"));
+    let adapter = match declared_type {
+        Some(t) => DbtAdapter::from_resource_type(t)
+            .ok_or_else(|| Error::BadRequest(format!("unsupported dbt adapter `{t}`")))?,
+        // REFUSED, not guessed. dbt renders the template and Windmill does not,
+        // so the descriptor's word is the only thing left — and it is worth
+        // nothing here: `profile.type: postgres` over a target resolving to
+        // `sqlserver` would pass the CE check while dbt runs the licensed
+        // adapter it bundles. A `target` may be templated (it only picks an
+        // output); the `type` inside that output may not.
+        None => {
+            return Err(Error::BadRequest(format!(
+                "{} does not state its adapter as a literal `type` — templated, or absent. \
+                 Windmill cannot resolve it, and the adapter decides both the engine and the \
+                 licence, so spell it literally in the target",
+                path.display()
+            )))
+        }
+    };
+    // The target's own database and schema, read with the same keys the renderer
+    // writes. A project that owns its profile then spells its `dbt://` paths
+    // identically to one on a workspace warehouse, which is what lets the two
+    // meet on the same node when they are on the same relation.
+    let (database_key, schema_key) = adapter.target_identity_keys();
+    let read = |k: &str| {
+        out.get(k)
+            .and_then(|v| v.as_str())
+            .map(|v| v.to_string())
+            .filter(|v| !v.is_empty() && !v.contains("{{"))
+    };
+    Ok(ProfileTarget { adapter, database: read(database_key), schema: read(schema_key) })
+}
+
+/// What a project-owned `profiles.yml` target says, for the two things Windmill
+/// needs from a file it did not write: which adapter to provision, and how to
+/// spell the relations it will produce.
+#[derive(Debug)]
+struct ProfileTarget {
+    adapter: DbtAdapter,
+    database: Option<String>,
+    schema: Option<String>,
+}
+
+lazy_static::lazy_static! {
+    /// `{{ env_var('NAME') }}` / `{{ env_var("NAME", "default") }}`.
+    static ref ENV_VAR_CALL: regex::Regex = regex::Regex::new(
+        r#"\{\{\s*env_var\(\s*['"]([^'"]+)['"]\s*(?:,\s*['"]([^'"]*)['"]\s*)?\)\s*\}\}"#
+    )
+    .unwrap();
+}
+
+/// dbt renders `env_var()` in `dbt_project.yml` as well, so a setting Windmill
+/// reads out of that file has to be rendered against the environment the run
+/// hands dbt. Left as written, Windmill acts on the template and dbt acts on the
+/// value, and the two never name the same profile or the same directory.
+///
+/// Only `env_var` is rendered — the one Jinja call dbt documents for this file.
+/// An expression that resolves to nothing is left verbatim so dbt reports it.
+fn render_env_vars(value: &str, env: &HashMap<String, String>) -> String {
+    ENV_VAR_CALL
+        .replace_all(value, |caps: &regex::Captures| {
+            env.get(&caps[1])
+                .cloned()
+                .or_else(|| caps.get(2).map(|d| d.as_str().to_string()))
+                .unwrap_or_else(|| caps[0].to_string())
+        })
+        .into_owned()
+}
+
+/// dbt takes the profile to use from `dbt_project.yml`, so a rendered
+/// `profiles.yml` has to answer to that name rather than one of our choosing.
+async fn project_profile_name(project_dir: &Path, env: &HashMap<String, String>) -> String {
+    let Ok(content) = tokio::fs::read_to_string(project_dir.join("dbt_project.yml")).await else {
+        return FALLBACK_PROFILE_NAME.to_string();
+    };
+    serde_yml::from_str::<serde_yml::Value>(&content)
+        .ok()
+        .and_then(|v| {
+            v.get("profile")
+                .and_then(|p| p.as_str())
+                .map(|s| render_env_vars(s, env))
+        })
+        .unwrap_or_else(|| FALLBACK_PROFILE_NAME.to_string())
+}
+
+/// Where the project has `dbt deps` install its packages, defaulting to dbt's
+/// own `dbt_packages`.
+///
+/// REFUSED rather than replaced when it escapes the project: dbt reads
+/// `dbt_project.yml` itself, so substituting a safe path here would only move
+/// Windmill's cache — dbt would still install to the escaping one, writing
+/// outside the job directory and leaving the cache watching a directory nothing
+/// fills.
+async fn packages_install_path(
+    project_dir: &Path,
+    env: &HashMap<String, String>,
+) -> error::Result<String> {
+    const DEFAULT: &str = "dbt_packages";
+    let Ok(content) = tokio::fs::read_to_string(project_dir.join("dbt_project.yml")).await else {
+        return Ok(DEFAULT.to_string());
+    };
+    let declared = serde_yml::from_str::<serde_yml::Value>(&content)
+        .ok()
+        .and_then(|v| {
+            v.get("packages-install-path")
+                .and_then(|p| p.as_str())
+                .map(|s| {
+                    render_env_vars(s, env)
+                        .trim()
+                        .trim_start_matches("./")
+                        .to_string()
+                })
+        })
+        .filter(|s| !s.is_empty());
+    let Some(declared) = declared else {
+        return Ok(DEFAULT.to_string());
+    };
+    if !Path::new(&declared)
+        .components()
+        .all(|c| matches!(c, std::path::Component::Normal(_)))
+    {
+        return Err(Error::BadRequest(format!(
+            "`packages-install-path: {declared}` in dbt_project.yml points outside the \
+             project; it must be a path within it, such as `dbt_packages`"
+        )));
+    }
+    Ok(declared)
+}
+
+/// The nsjail profile a sandboxed dbt phase runs under.
+const NSJAIL_CONFIG_RUN_DBT_CONTENT: &str = include_str!("../nsjail/run.dbt.config.proto");
+
+/// Build the command for a dbt phase, inside the job's sandbox when the worker
+/// has one configured.
+///
+/// Every phase is project-controlled — `dbt deps` fetches packages the project
+/// names, `parse` and `build` render project macros, and a DuckDB profile
+/// reads and writes local files — so they are the project's code, not
+/// Windmill's, and the same isolation every other executor applies has to
+/// apply here.
+///
+/// The invocation's environment must NOT reach the launcher under a sandbox:
+/// what this returns is the process that execs nsjail, and those values come
+/// from caller-controlled script metadata — an `LD_PRELOAD` naming a library
+/// from the project bundle would be loaded by the dynamic linker as the worker,
+/// before isolation exists. The jail profile carries them to the child instead
+/// (see `sandbox_config`).
+pub(crate) fn dbt_command(p: &PreparedProject, args: &[&str]) -> Command {
+    let mut cmd = match p.sandbox_config.as_ref().map(|c| c.path()) {
+        Some(config) => {
+            let mut nsjail = Command::new(NSJAIL_PATH.as_str());
+            nsjail
+                .arg("--config")
+                .arg(config)
+                .arg("--")
+                .arg(&p.engine.bin);
+            nsjail
+        }
+        None => Command::new(&p.engine.bin),
+    };
+    // The rendered profile is written with this target as its only output, but
+    // a project-owned `profiles.yml` has its own default — silently building
+    // `dev` when the descriptor asked for `prod` writes to the wrong warehouse.
+    if let Some(target) = p.target.as_deref() {
+        cmd.args(["--target", target]);
+    }
+    cmd.current_dir(&p.project_dir)
+        .env_clear()
+        .envs(PROXY_ENVS.clone())
+        .env("PATH", PATH_ENV.as_str())
+        .env("TZ", TZ_ENV.as_str())
+        .env("GIT_PATH", GIT_PATH.as_str());
+    // Both environments belong to the child. Under a sandbox they reach it through
+    // the jail profile instead: set here, they would reach the dynamic loader that
+    // execs nsjail itself, so an `LD_PRELOAD` from the project would run as the
+    // worker, before any isolation exists.
+    if p.sandbox_config.is_none() {
+        cmd.envs(p.env.iter().map(|(k, v)| (k.as_str(), v.as_str())));
+        cmd.envs(
+            p.invocation_env
+                .iter()
+                .map(|(k, v)| (k.as_str(), v.as_str())),
+        );
+    }
+    cmd.args(args)
+        .arg("--profiles-dir")
+        .arg(&p.profiles_dir)
+        // Every artifact this runtime reads is found by path, so the location is
+        // Windmill's to decide and not the project's `target-path`. An env var
+        // because `dbt deps` rejects `--target-path`, and set last so neither
+        // environment above can displace it.
+        .env("DBT_TARGET_PATH", ARTIFACTS_DIR);
+    cmd
+}
+
+/// The project's environment, as jail directives rather than launcher
+/// environment. `keep_env` passes nsjail's own environment through, so these
+/// are added on top of the Windmill-controlled ones the launcher carries.
+fn jail_envars(env: &[(String, String)]) -> String {
+    env.iter()
+        .map(|(k, v)| format!("envar: \"{}={}\"", escape_textproto(k), escape_textproto(v)))
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+const SANDBOX_PROFILE_NAME: &str = "dbt.nsjail.config.proto";
+
+/// The written nsjail profile, kept OUTSIDE every path the jailed child can
+/// reach and removed when the job ends.
+///
+/// It cannot live in the job directory: the jail mounts that read-write, and
+/// each phase launches a fresh `nsjail --config` against this file — so a
+/// project able to write files during `build` (a DuckDB one can, through
+/// `shellfs`) could rewrite the profile and have the `after_all` test phase
+/// start with mounts of its choosing. A sibling of the job directory is not
+/// mounted at all, so the child never sees it.
+pub struct SandboxProfile(PathBuf);
+
+impl SandboxProfile {
+    fn path(&self) -> &Path {
+        &self.0
+    }
+}
+
+impl Drop for SandboxProfile {
+    fn drop(&mut self) {
+        let _ = std::fs::remove_dir_all(self.0.parent().unwrap_or(&self.0));
+    }
+}
+
+/// Escape a value for a protobuf text-format string literal.
+///
+/// Every path and environment value interpolated into the jail profile is
+/// caller-influenced — a repository directory is named by whoever wrote the
+/// repo — and a bare `"` or newline would close the string and let the rest be
+/// read as further directives, including host bind mounts.
+fn escape_textproto(s: &str) -> String {
+    let mut out = String::with_capacity(s.len());
+    for c in s.chars() {
+        match c {
+            '\\' => out.push_str("\\\\"),
+            '"' => out.push_str("\\\""),
+            '\n' => out.push_str("\\n"),
+            '\r' => out.push_str("\\r"),
+            '\t' => out.push_str("\\t"),
+            c if (c as u32) < 0x20 || c as u32 == 0x7f => {
+                out.push_str(&format!("\\x{:02x}", c as u32))
+            }
+            c => out.push(c),
+        }
+    }
+    out
+}
+
+/// Environment this runtime owns. A project setting one of these would redirect
+/// where dbt writes the artifacts Windmill reads by path — the graph, the
+/// per-node results, the retry state — so a run could succeed while Windmill
+/// records nothing. Refused rather than silently stripped, so the descriptor's
+/// author is told.
+const RESERVED_ENV_KEYS: &[&str] = &["DBT_TARGET_PATH", "DBT_PROFILES_DIR", "DBT_PROJECT_DIR"];
+
+fn reject_reserved_env<'a>(
+    env: impl IntoIterator<Item = &'a String>,
+    source: &str,
+) -> error::Result<()> {
+    for k in env {
+        if RESERVED_ENV_KEYS.iter().any(|r| r.eq_ignore_ascii_case(k)) {
+            return Err(Error::BadRequest(format!(
+                "`{k}` is set by Windmill and cannot be overridden from {source}: it decides \
+                 where dbt writes the artifacts this runtime reads"
+            )));
+        }
+    }
+    Ok(())
+}
+
+/// Fixed artifact directory, relative to the project root: `dbt_project.yml`
+/// may point `target-path` anywhere, and this runtime reads every artifact by
+/// path. Relative rather than absolute so it stays inside whatever sandbox the
+/// project runs in.
+pub const ARTIFACTS_DIR: &str = "wm_target";
+
+/// Take one attempt from the job's budget, returning its 1-based number, or
+/// `None` when nothing is left.
+///
+/// Claiming and counting are one operation because they are the retry loop's
+/// only bound: separating them is how the budget stops being spent and the loop
+/// reissues `dbt retry` until the job's deadline instead of `attempts` times.
+/// Claimed before the guards that can decline an attempt, which is harmless —
+/// each of those breaks out rather than looping again.
+fn claim_attempt(remaining: &mut u32, total: u32) -> Option<u32> {
+    if *remaining == 0 {
+        return None;
+    }
+    let attempt = total - *remaining + 1;
+    *remaining -= 1;
+    Some(attempt)
+}
+
+/// The descriptor's `retry_failed_nodes` policy, applied to whichever phase just
+/// failed. `dbt retry` rebuilds only the failed and skipped nodes, so a
+/// transient warehouse error costs those rather than the whole project.
+///
+/// Called after the model phase and again after the `after_all` test phase: a
+/// failing test is a failed node too. `remaining` is the budget for the WHOLE
+/// job, not per phase — each attempt is a real dbt invocation holding a worker
+/// slot, so a model phase that spent them all leaves none for the tests.
+#[allow(clippy::too_many_arguments)]
+async fn retry_failed_nodes(
+    policy: windmill_parser_yaml::dbt::DbtNodeRetry,
+    prepared: &PreparedProject,
+    descriptor: &DbtDescriptor,
+    inv: &Invocation,
+    job: &MiniPulledJob,
+    conn: &Connection,
+    ctx: &mut JobCtx<'_>,
+    run: &mut error::Result<()>,
+    results: &mut Vec<DbtNodeResult>,
+    remaining: &mut u32,
+) {
+    let total = policy.attempts();
+    while let Some(attempt) = claim_attempt(remaining, total) {
+        // A cancelled or timed-out job must not start another warehouse
+        // write: its failure is not the transient kind this retries, and
+        // the slot is supposed to be going away. The wait itself re-checks,
+        // since a cancel most likely arrives during it.
+        if !current_results_are_retryable(prepared).await {
+            break;
+        }
+        if !sleep_before_retry(policy.delay_seconds, &job.id, conn, ctx.deadline).await {
+            break;
+        }
+        append_logs(
+            &job.id,
+            &job.workspace_id,
+            format!("\nRetrying the nodes that failed (attempt {attempt} of {total})\n"),
+            conn,
+        )
+        .await;
+        *run = run_dbt(
+            prepared, "retry", descriptor, inv, job, conn, &mut *ctx,
+            // `dbt retry` reuses the previous invocation's selection; adding
+            // one would narrow what it resumes.
+            false,
+        )
+        .await;
+        // A retry's `run_results.json` describes only the nodes it redid, so
+        // it OVERLAYS the previous attempt's rather than replacing it. The
+        // job's result has to be every node this job touched.
+        merge_results(results, read_run_results(&prepared.project_dir).await);
+        if run.is_ok() {
+            break;
+        }
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn run_dbt(
+    p: &PreparedProject,
+    command: &str,
+    descriptor: &DbtDescriptor,
+    inv: &Invocation,
+    job: &MiniPulledJob,
+    conn: &Connection,
+    ctx: &mut JobCtx<'_>,
+    with_selection: bool,
+) -> error::Result<()> {
+    let mut cmd = dbt_command(p, &[command]);
+    // The console stays human-readable and goes straight to the job log; the
+    // machine-readable copy goes to a file the progress reporter tails, so
+    // neither purpose degrades the other.
+    let log_dir = p.project_dir.join("logs");
+    cmd.arg("--log-path")
+        .arg(&log_dir)
+        .args(["--log-format-file", "json"])
+        .args(["--log-level-file", p.engine.engine.progress_log_level()]);
+
+    if with_selection && command != "retry" {
+        add_selection(&mut cmd, descriptor, inv)?;
+    }
+    // The model phase of `after_all` — and every phase of `none` — builds
+    // everything the selection names EXCEPT tests. `dbt run` would be the
+    // obvious command but covers models only, silently skipping seeds and
+    // snapshots the descriptor selected.
+    if command == "build" && !matches!(descriptor.test_behavior, DbtTestBehavior::Build) {
+        cmd.args([
+            "--exclude-resource-type",
+            "test",
+            "--exclude-resource-type",
+            "unit_test",
+        ]);
+    }
+    if command != "retry" {
+        add_vars(&mut cmd, descriptor, inv)?;
+        if let Some(t) = descriptor.threads {
+            cmd.args(["--threads", &t.to_string()]);
+        }
+        let full_refresh = arg_bool(&inv.args, "full_refresh")?.unwrap_or(descriptor.full_refresh);
+        if full_refresh && command != "test" {
+            cmd.arg("--full-refresh");
+        }
+    }
+
+    tokio::fs::remove_file(log_dir.join("dbt.log")).await.ok();
+    // `handle_child` reads the job log off these pipes. Without them the child
+    // inherits the worker's stdio and handle_child waits on streams that never
+    // arrive, so the job hangs instead of running.
+    cmd.stdout(Stdio::piped()).stderr(Stdio::piped());
+    let child = start_child_process(cmd, p.engine.bin.to_string_lossy().as_ref(), false).await?;
+    let progress = spawn_progress_reporter(p, job, conn, log_dir.join("dbt.log"));
+    let res = handle_child(
+        &job.id,
+        conn,
+        ctx.mem_peak,
+        ctx.canceled_by,
+        child,
+        false,
+        ctx.worker_name,
+        &job.workspace_id,
+        &format!("dbt {command}"),
+        // What is left of the job's wall clock: `dbt build` follows the whole
+        // preparation sequence, and the `after_all` tests follow it.
+        ctx.timeout(),
+        false,
+        &mut Some(&mut *ctx.occupancy_metrics),
+        None,
+        None,
+    )
+    .await;
+    if let Some(h) = progress {
+        h.abort();
+    }
+    res.map(|_| ())
+}
+
+/// Tail dbt's JSON event file and record each node's status as it finishes, so
+/// the asset graph shows the run advancing rather than a single opaque job.
+///
+/// Only `dbt-core-1x` emits these events today: dbt-core 2.0.0-alpha.5 accepts
+/// `--log-format-file json` but still writes a text log, so its runs surface
+/// per-model state from `run_results.json` when the invocation ends. The
+/// reporter is a no-op there rather than a second, format-sniffing code path.
+fn spawn_progress_reporter(
+    p: &PreparedProject,
+    job: &MiniPulledJob,
+    conn: &Connection,
+    log_file: PathBuf,
+) -> Option<tokio::task::JoinHandle<()>> {
+    let Connection::Sql(db) = conn else {
+        // Agent workers reach the DB only through the API, and tailing a log to
+        // POST every event would spend a request per node. Their per-model state
+        // is settled from `run_results.json` when the run ends instead: recorded
+        // in full, but arriving at the end rather than live.
+        return None;
+    };
+    if !p.engine.engine.emits_node_events() {
+        // Nothing to read: those engines write a text file log, so tailing it
+        // would burn a task per run for no events.
+        return None;
+    }
+    let (db, w_id, job_id) = (db.clone(), job.workspace_id.clone(), job.id);
+    let warehouse = p.warehouse.clone()?;
+    let default_database = p.default_database.clone();
+    Some(tokio::spawn(async move {
+        use tokio::io::{AsyncReadExt, AsyncSeekExt};
+        let mut offset = 0u64;
+        let mut tail = LogTail::default();
+        loop {
+            tokio::time::sleep(std::time::Duration::from_millis(500)).await;
+            let Ok(mut f) = tokio::fs::File::open(&log_file).await else {
+                continue;
+            };
+            // dbt truncates/rotates its log; a shrunk file means the offsets
+            // from the previous incarnation are meaningless, and keeping them
+            // would silence the tailer for the rest of the run.
+            let len = f.metadata().await.map(|m| m.len()).unwrap_or(0);
+            if len < offset {
+                offset = 0;
+                tail = LogTail::default();
+            }
+            if len == offset {
+                continue;
+            }
+            // Seek rather than re-read: a long run's log grows without bound
+            // and reading it whole every tick is quadratic in its size.
+            if f.seek(std::io::SeekFrom::Start(offset)).await.is_err() {
+                continue;
+            }
+            // BOUNDED, and heap-allocated: this reader runs in the worker
+            // process, outside the jailed child's memory limit, so reading a
+            // whole tail a macro can make arbitrarily large would take down
+            // every job on the worker. What is left waits for the next tick.
+            let mut buf = Vec::new();
+            if (&mut f)
+                .take(LOG_TICK_MAX_BYTES)
+                .read_to_end(&mut buf)
+                .await
+                .is_err()
+            {
+                continue;
+            }
+            offset += buf.len() as u64;
+            let chunk = tail.push(&String::from_utf8_lossy(&buf));
+            for line in chunk.lines() {
+                let Some(ev) = parse_node_event(line, &warehouse, default_database.as_deref())
+                else {
+                    continue;
+                };
+                windmill_common::dbt_manifest::record_run_progress(
+                    &db,
+                    &w_id,
+                    &job_id,
+                    &ev.asset_path,
+                    ev.status,
+                    ev.row_count,
+                    ev.error.as_deref(),
+                )
+                .await;
+                let _ = record_materialization(
+                    &db,
+                    &w_id,
+                    ev.asset_kind,
+                    &ev.asset_path,
+                    &ev.partition,
+                    ev.status,
+                    None,
+                    ev.row_count,
+                    ev.job_id.or(Some(job_id)),
+                    ev.error.as_deref(),
+                )
+                .await;
+            }
+        }
+    }))
+}
+
+/// How much of dbt's log one tick of the tailer takes, and how long one event
+/// may be. Both bound what the WORKER process holds: the reader lives there,
+/// not in the jailed child, and a macro can print anything into a log line.
+const LOG_TICK_MAX_BYTES: u64 = 1 << 20;
+const LOG_LINE_MAX_BYTES: usize = 256 * 1024;
+
+/// Complete lines out of a log read in chunks.
+///
+/// A tick can land mid-write, leaving a trailing partial line; it is held over
+/// rather than dropping the event it belongs to — unless it grows past
+/// `LOG_LINE_MAX_BYTES`, which no node event does, and then it is discarded
+/// through its next newline so the events after it still arrive.
+#[derive(Default)]
+struct LogTail {
+    carry: String,
+    /// Inside an over-long line: everything up to its end is dropped.
+    skipping: bool,
+}
+
+impl LogTail {
+    fn push(&mut self, chunk: &str) -> String {
+        if self.skipping {
+            match chunk.find('\n') {
+                Some(i) => {
+                    self.skipping = false;
+                    self.carry.push_str(&chunk[i + 1..]);
+                }
+                None => return String::new(),
+            }
+        } else {
+            // Appended BEFORE looking for the last newline: a line spanning
+            // three reads would otherwise have its middle fragment replace the
+            // first, and the reassembled line would be invalid JSON.
+            self.carry.push_str(chunk);
+        }
+        let complete_upto = self.carry.rfind('\n').map(|i| i + 1).unwrap_or(0);
+        let complete = self.carry[..complete_upto].to_string();
+        self.carry.drain(..complete_upto);
+        if self.carry.len() > LOG_LINE_MAX_BYTES {
+            self.carry.clear();
+            self.skipping = true;
+        }
+        complete
+    }
+}
+
+/// One `node_info`-carrying dbt log event turned into the materialization
+/// record the asset graph reads. `None` for events that are not per-node, and
+/// for nodes with no physical relation (tests, ephemeral models).
+fn parse_node_event(
+    line: &str,
+    warehouse: &str,
+    default_database: Option<&str>,
+) -> Option<RecordMaterializationRequest> {
+    let line = line.trim();
+    if !line.starts_with('{') {
+        return None;
+    }
+    let v: serde_json::Value = serde_json::from_str(line).ok()?;
+    let info = v.get("data")?.get("node_info")?;
+    let rel = info.get("node_relation")?;
+    let schema = rel.get("schema")?.as_str()?;
+    let alias = rel.get("alias")?.as_str()?;
+    let database = rel.get("database").and_then(|d| d.as_str());
+    if rel
+        .get("relation_name")
+        .and_then(|r| r.as_str())
+        .unwrap_or("")
+        .is_empty()
+    {
+        return None;
+    }
+    let status = match classify_status(info.get("node_status")?.as_str()?) {
+        DbtNodeOutcome::Started => MaterializationStatus::Running,
+        DbtNodeOutcome::Passed => MaterializationStatus::Materialized,
+        DbtNodeOutcome::Failed => MaterializationStatus::Failed,
+        // `warn` is a passing test at reduced severity, and a node that never
+        // built says nothing about the relation's state; none is a
+        // materialization.
+        DbtNodeOutcome::Warn
+        | DbtNodeOutcome::Skipped
+        | DbtNodeOutcome::NoOp
+        | DbtNodeOutcome::Unknown => return None,
+    };
+    // `None` when the derived key would not fit `asset.path`; the node keeps its
+    // manifest row and this run records no materialization for it, rather than
+    // one swallowed `value too long` per node per run.
+    let path = windmill_common::dbt_manifest::table_asset_path(
+        warehouse,
+        database,
+        schema,
+        alias,
+        default_database,
+    )?;
+    Some(RecordMaterializationRequest {
+        asset_kind: windmill_common::assets::AssetKind::Dbt,
+        asset_path: path,
+        partition: windmill_common::materialization::UNPARTITIONED.to_string(),
+        status,
+        snapshot_id: None,
+        row_count: None,
+        job_id: None,
+        error: v
+            .get("info")
+            .and_then(|i| i.get("msg"))
+            .and_then(|m| m.as_str())
+            .filter(|_| status == MaterializationStatus::Failed)
+            .map(|s| s.to_string()),
+        schema: None,
+    })
+}
+
+/// Settle each model's materialization record from `run_results.json` once the
+/// invocation ends.
+///
+/// This is what the live event tailer cannot do: the events carry no row count,
+/// and the Rust engines do not emit them at all (dbt-core 2.0.0-alpha.5 accepts
+/// `--log-format-file json` but still writes a text log). So the same records
+/// the tailer has been updating are re-stated here from the authoritative
+/// artifact, which both fills in `row_count` and gives those engines per-model
+/// state — just at the end of the run rather than during it.
+///
+/// Returns the relations it settled, and the ones the run reported but left
+/// untouched (`no-op`, `warn`, `skipped`). The two need opposite treatment
+/// afterwards, which is why they come back apart.
+async fn reconcile_materializations(
+    p: &PreparedProject,
+    results: &[DbtNodeResult],
+    job: &MiniPulledJob,
+    conn: &Connection,
+    client: &AuthedClient,
+) -> Reconciled {
+    let mut out = Reconciled::default();
+    // One batch for an agent worker's per-model state; empty on a Sql worker,
+    // which writes each row directly.
+    let mut progress: Vec<windmill_common::dbt_manifest::DbtRunProgressRequest> = vec![];
+    let Some(warehouse) = p.warehouse.as_deref() else {
+        return out;
+    };
+    for r in results {
+        let Some(path) = asset_path_of_relation(
+            r.relation_name.as_deref(),
+            warehouse,
+            p.default_database.as_deref(),
+        ) else {
+            continue;
+        };
+        let status = match classify_status(&r.status) {
+            DbtNodeOutcome::Passed => MaterializationStatus::Materialized,
+            DbtNodeOutcome::Failed => MaterializationStatus::Failed,
+            // Tests and nodes that built nothing say nothing about a relation's
+            // state — but the tailer may already have written `running` for one,
+            // so they are reported for the caller to clear rather than settle.
+            _ => {
+                out.untouched.push(path);
+                continue;
+            }
+        };
+        out.settled.push(path.clone());
+        let error = (status == MaterializationStatus::Failed)
+            .then(|| r.message.as_deref())
+            .flatten();
+        // An agent worker has no direct DB, so its outcomes go through the API —
+        // otherwise a successful agent run leaves every model with no recorded
+        // status or row count.
+        let recorded = match conn {
+            Connection::Sql(db) => {
+                windmill_common::dbt_manifest::record_run_progress(
+                    db,
+                    &job.workspace_id,
+                    &job.id,
+                    &path,
+                    status,
+                    r.rows_affected,
+                    error,
+                )
+                .await;
+                record_materialization(
+                    db,
+                    &job.workspace_id,
+                    windmill_common::assets::AssetKind::Dbt,
+                    &path,
+                    windmill_common::materialization::UNPARTITIONED,
+                    status,
+                    None,
+                    r.rows_affected,
+                    Some(job.id),
+                    error,
+                )
+                .await
+                .map_err(|e| e.to_string())
+            }
+            Connection::Http(http) => {
+                // Progress too, not only the materialization: the live reporter
+                // needs a database and does not run here, so these settled
+                // outcomes are the only per-model state an agent's run page ever
+                // gets. COLLECTED, not sent: one round trip per model would run
+                // after dbt has already finished, and a large project has
+                // hundreds. Posted once below.
+                progress.push(windmill_common::dbt_manifest::DbtRunProgressRequest {
+                    asset_path: path.clone(),
+                    status,
+                    row_count: r.rows_affected,
+                    error: error.map(|e| e.to_string()),
+                });
+                crate::agent_workers::record_materialization_from_agent_http(
+                    http,
+                    &job.workspace_id,
+                    &RecordMaterializationRequest {
+                        asset_kind: windmill_common::assets::AssetKind::Dbt,
+                        asset_path: path.clone(),
+                        partition: windmill_common::materialization::UNPARTITIONED.to_string(),
+                        status,
+                        snapshot_id: None,
+                        row_count: r.rows_affected,
+                        job_id: Some(job.id),
+                        error: error.map(|e| e.to_string()),
+                        schema: None,
+                    },
+                )
+                .await
+                .map_err(|e| e.to_string())
+            }
+        };
+        if let Err(e) = recorded {
+            tracing::warn!("recording the materialization of {path} failed: {e}");
+        }
+    }
+    if !progress.is_empty() {
+        if let Err(e) = client.record_dbt_run_progress(&progress).await {
+            // A display, not the run: the models are built either way.
+            tracing::warn!(
+                "recording dbt run progress for {} nodes: {e:#}",
+                progress.len()
+            );
+        }
+    }
+    out
+}
+
+/// What `reconcile_materializations` did, split by what has to happen next.
+#[derive(Default)]
+struct Reconciled {
+    /// Given a terminal status by this run.
+    settled: Vec<String>,
+    /// Reported by this run but not built — `no-op`, `warn`, `skipped`.
+    untouched: Vec<String>,
+}
+
+/// Leave no relation of this job's on `running`.
+///
+/// The live tailer writes `running` when a model starts, and two things can
+/// leave it there. A node that ends `no-op`, `warn` or `skipped` built nothing,
+/// so there is no outcome to record — its row is DELETED, which is what the
+/// finished run's own result says about it too (`relationOutcome` colours it
+/// nothing), so the live view and the settled view agree. And a cancellation or
+/// a timeout means dbt never wrote `run_results.json` for the node in flight, so
+/// it is reported nowhere — that one is FAILED, because the run ended without
+/// finishing it.
+///
+/// A killed worker reaches none of this and leaves its rows `running` in both
+/// tables until the retention sweep takes them; recovering those belongs to
+/// whatever reclaims the job, not here.
+///
+/// Only the SQL path can strand a row: `spawn_progress_reporter` returns `None`
+/// for an agent worker and for the engines that emit no node events, so nothing
+/// there writes `running` in the first place.
+async fn terminalize_running_relations(
+    job: &MiniPulledJob,
+    reconciled: &Reconciled,
+    conn: &Connection,
+) {
+    let Connection::Sql(db) = conn else {
+        return;
+    };
+    if let Err(e) = sqlx::query!(
+        "DELETE FROM materialized_partition
+          WHERE workspace_id = $1 AND job_id = $2 AND status = 'running'
+            AND asset_path = ANY($3)",
+        job.workspace_id,
+        job.id,
+        &reconciled.untouched
+    )
+    .execute(db)
+    .await
+    {
+        tracing::warn!("clearing the models {} left untouched: {e}", job.id);
+    }
+    let accounted: Vec<String> = reconciled
+        .settled
+        .iter()
+        .chain(reconciled.untouched.iter())
+        .cloned()
+        .collect();
+    if let Err(e) = sqlx::query!(
+        "UPDATE materialized_partition
+            SET status = 'failed',
+                error = COALESCE(error, 'the run ended before this model finished')
+          WHERE workspace_id = $1 AND job_id = $2 AND status = 'running'
+            AND NOT (asset_path = ANY($3))",
+        job.workspace_id,
+        job.id,
+        &accounted
+    )
+    .execute(db)
+    .await
+    {
+        tracing::warn!("settling the models left running by {}: {e}", job.id);
+    }
+    // The run page reads `dbt_run_progress`, so both closing writes have to land
+    // there too. Without them a cancelled or killed run — which leaves no
+    // `run_results.json`, so the page falls back to this poll — shows every
+    // in-flight model still spinning for as long as the row is retained.
+    if let Err(e) = sqlx::query!(
+        "DELETE FROM dbt_run_progress
+          WHERE workspace_id = $1 AND job_id = $2 AND status = 'running'
+            AND asset_path = ANY($3)",
+        job.workspace_id,
+        job.id,
+        &reconciled.untouched
+    )
+    .execute(db)
+    .await
+    {
+        tracing::warn!("clearing the progress rows {} left untouched: {e}", job.id);
+    }
+    if let Err(e) = sqlx::query!(
+        "UPDATE dbt_run_progress
+            SET status = 'failed',
+                error = COALESCE(error, 'the run ended before this model finished')
+          WHERE workspace_id = $1 AND job_id = $2 AND status = 'running'
+            AND NOT (asset_path = ANY($3))",
+        job.workspace_id,
+        job.id,
+        &accounted
+    )
+    .execute(db)
+    .await
+    {
+        tracing::warn!("settling the progress rows left running by {}: {e}", job.id);
+    }
+}
+
+/// `"db"."schema"."name"` from dbt into the `dbt://` path of the relation,
+/// through the same derivation the manifest ingest and the live events use.
+fn asset_path_of_relation(
+    relation_name: Option<&str>,
+    warehouse: &str,
+    default_database: Option<&str>,
+) -> Option<String> {
+    let parts = split_relation(relation_name?);
+    let (database, schema, name) = match parts.as_slice() {
+        [db, schema, name] => (Some(db.as_str()), schema.as_str(), name.as_str()),
+        [schema, name] => (None, schema.as_str(), name.as_str()),
+        _ => return None,
+    };
+    windmill_common::dbt_manifest::table_asset_path(
+        warehouse,
+        database,
+        schema,
+        name,
+        default_database,
+    )
+}
+
+/// Split `"db"."schema"."name"` on the separators BETWEEN identifiers only.
+///
+/// A period inside a quoted identifier is part of the name — `"analytics.v2"`
+/// is one schema, not two — and splitting on every period discards the relation
+/// entirely, so the model silently records no status at all.
+fn split_relation(rel: &str) -> Vec<String> {
+    let mut parts = Vec::new();
+    let mut current = String::new();
+    let mut quote: Option<char> = None;
+    let mut chars = rel.chars().peekable();
+    while let Some(c) = chars.next() {
+        match quote {
+            Some(q) => {
+                let close = if q == '[' { ']' } else { q };
+                if c == close {
+                    // Doubled is how these dialects escape their delimiter: one
+                    // literal character, not the end of the identifier. Dropping
+                    // it renames the relation, so the run records progress
+                    // against a key no node has.
+                    if chars.peek() == Some(&close) {
+                        chars.next();
+                        current.push(close);
+                    } else {
+                        quote = None;
+                    }
+                } else {
+                    current.push(c);
+                }
+            }
+            None if c == '"' || c == '`' || c == '[' => quote = Some(c),
+            None if c == '.' => parts.push(std::mem::take(&mut current)),
+            None => current.push(c),
+        }
+    }
+    parts.push(current);
+    parts.into_iter().map(|p| p.trim().to_string()).collect()
+}
+
+/// Ceiling on a preview's captured output, enforced as `run_capturing` reads.
+/// `--limit` bounds how many rows dbt returns, not how big they are — a single
+/// column can hold a megabyte — so the row clamp is not a memory bound on its
+/// own. This also bounds what a preview can store in `v2_job_completed.result`.
+const SHOW_MAX_OUTPUT_BYTES: usize = 8 * 1024 * 1024;
+
+/// Ceiling on `dbt ls`, whose output is one line per selected node. Generous
+/// against the largest real projects, and there only so a runaway cannot be
+/// unbounded.
+const LS_MAX_OUTPUT_BYTES: usize = 8 * 1024 * 1024;
+
+/// The `--limit` a `show` runs with, from the run's argument.
+///
+/// Clamped, not merely defaulted: the rows are read out of dbt's stdout, so this
+/// argument decides how much a caller can make the worker hold — and running a
+/// script needs only run permission. `SHOW_MAX_OUTPUT_BYTES` is the backstop for
+/// rows that are individually large; this keeps an ordinary preview from
+/// reaching it. Zero and negatives fall back to the default rather than reaching
+/// dbt, where `--limit 0` means something else.
+/// Whether a `show` selector can name at most one node, syntactically.
+///
+/// dbt splits a selector on WHITESPACE into a union and applies commas within
+/// each member, so the `,resource_type:model` intersection `run_show` appends
+/// binds to the last member only. More than one member therefore leaves the
+/// others unconstrained — and a seed among them is dispatched through dbt's
+/// seed runner, which writes its relation from the one command this runtime
+/// calls read-only.
+///
+/// Graph operators and wildcards are refused for the plainer reason: they
+/// resolve to a set, and `show` previews one relation.
+fn show_selects_one_node(model: &str) -> bool {
+    model.split_whitespace().count() == 1 && !model.contains(['+', '*', '@'])
+}
+
+fn show_limit(requested: Option<i64>) -> i64 {
+    let max = windmill_parser_yaml::dbt::DBT_SHOW_MAX_LIMIT as i64;
+    requested
+        .filter(|l| *l > 0)
+        .map(|l| l.min(max))
+        .unwrap_or(windmill_parser_yaml::dbt::DBT_SHOW_DEFAULT_LIMIT as i64)
+}
+
+/// `dbt show`: SELECT from the selected node and return its rows. dbt prints one
+/// document per selected node and the result is a single preview, so a selection
+/// naming several returns the first — which is what the argument's description
+/// tells the caller.
+///
+/// Captured rather than streamed, for the same reason `dbt ls` is: the job-log
+/// writer is what `NO_LOGS_AT_ALL` discards, and these rows ARE the result, not
+/// commentary about it.
+async fn run_show(
+    p: &PreparedProject,
+    descriptor: &DbtDescriptor,
+    inv: &Invocation,
+    ctx: &mut JobCtx<'_>,
+    job_id: &Uuid,
+    w_id: &str,
+    conn: &Connection,
+) -> error::Result<Box<RawValue>> {
+    // ONE node, named by the run. Not `add_selection`: the descriptor's selectors
+    // narrow a BUILD, and applying them here would preview whatever they happen
+    // to resolve to first. dbt's own failure for an empty selection carries no
+    // message at all, so the refusal has to be this one.
+    let Some(model) = arg_str(&inv.args, "model")? else {
+        return Err(Error::BadRequest(
+            "`show` previews one model's rows, so it needs `model` to name one — `stg_orders`, \
+             or any dbt selector that resolves to a single MODEL (a seed, test or \
+             snapshot is not previewable)"
+                .to_string(),
+        ));
+    };
+    let model = model.trim();
+    // ONE union member, because the intersection below binds to the LAST one:
+    // dbt splits a selector on whitespace into a union and applies commas within
+    // each member, so `my_seed safe_model,resource_type:model` still selects the
+    // seed — and dbt dispatches a selected SEED through its seed runner, which
+    // LOADS it. That writes a relation through a path recording no
+    // materialization, no graph and no retry state, from the one command this
+    // runtime advertises as read-only. Graph operators are refused for the same
+    // reason they are refused above: they resolve to a set, and `show` previews
+    // one relation.
+    if !show_selects_one_node(model) {
+        return Err(Error::BadRequest(format!(
+            "`show` previews ONE model's rows, so `model` must name exactly one — got \
+             `{model}`. A selector naming several (spaces), or a graph operator (`+`, \
+             `@`) or wildcard (`*`), resolves to a set: run `build` with it instead"
+        )));
+    }
+    let mut cmd = dbt_command(p, &["show"]);
+    add_vars(&mut cmd, descriptor, inv)?;
+    // Intersected with `resource_type:model`, because `show` is only read-only
+    // for models: dbt dispatches a selected SEED through its seed runner and
+    // loads it, which would write a relation through a path that records no
+    // materialization and no graph. A comma is dbt's own intersection, the same
+    // one `package:` already uses here, so a seed simply selects nothing. Sound
+    // only because the check above left exactly one union member for it to bind.
+    cmd.args(["--select", &format!("{model},resource_type:model")]);
+    let limit = show_limit(arg_i64(&inv.args, "limit")?);
+    cmd.args(["--output", "json", "--limit", &limit.to_string()]);
+    let stdout = run_capturing(
+        cmd,
+        "dbt show",
+        ctx,
+        job_id,
+        w_id,
+        conn,
+        SHOW_MAX_OUTPUT_BYTES,
+    )
+    .await?;
+    // dbt frames the rows as `{"node": …, "show": [ … ]}`, pretty-printed, with a
+    // banner before and a deprecation summary after — so neither "the line starting
+    // with `{`" nor "first `{` to the end" parses. A streaming deserializer stops at
+    // the first complete document and ignores the rest.
+    let mut from = 0;
+    while let Some(rel) = stdout[from..].find('{') {
+        let at = from + rel;
+        let mut docs =
+            serde_json::Deserializer::from_str(&stdout[at..]).into_iter::<serde_json::Value>();
+        if let Some(Ok(v)) = docs.next() {
+            if v.get("show").is_some() {
+                return Ok(to_raw_value(&v));
+            }
+        }
+        from = at + 1;
+    }
+    Err(Error::ExecutionErr(format!(
+        "dbt show returned no rows to parse. Output was:\n{}",
+        stdout.chars().take(2000).collect::<String>()
+    )))
+}
+
+async fn read_run_results(project_dir: &Path) -> Vec<DbtNodeResult> {
+    let Ok(content) =
+        tokio::fs::read_to_string(project_dir.join(ARTIFACTS_DIR).join("run_results.json")).await
+    else {
+        return vec![];
+    };
+    let Ok(rr) = serde_json::from_str::<RunResults>(&content) else {
+        return vec![];
+    };
+    rr.results
+        .into_iter()
+        .map(|r| DbtNodeResult {
+            unique_id: r.unique_id,
+            outcome: classify_status(&r.status).as_result_word(),
+            status: r.status,
+            execution_time: r.execution_time,
+            rows_affected: r
+                .adapter_response
+                .get("rows_affected")
+                .and_then(|v| v.as_i64())
+                // Adapters report -1 for statements with no row count.
+                .filter(|v| *v >= 0),
+            relation_name: r.relation_name,
+            message: r.message,
+            failures: r.failures,
+        })
+        .collect()
+}
+
+fn build_result(
+    p: &PreparedProject,
+    command: &str,
+    nodes: Vec<DbtNodeResult>,
+    inv: &Invocation,
+) -> DbtRunResult {
+    let mut totals = DbtTotals { total: nodes.len(), ..Default::default() };
+    for n in &nodes {
+        match classify_status(&n.status) {
+            DbtNodeOutcome::Passed => totals.success += 1,
+            DbtNodeOutcome::Warn => totals.warn += 1,
+            DbtNodeOutcome::Skipped | DbtNodeOutcome::NoOp => totals.skipped += 1,
+            _ => totals.error += 1,
+        }
+    }
+    DbtRunResult {
+        engine: p.engine.engine.as_str().to_string(),
+        engine_version: p.engine.version.clone(),
+        command: command.to_string(),
+        totals,
+        nodes,
+        invocation_args: inv.raw_args.clone(),
+    }
+}
+
+fn render_failures(r: &DbtRunResult) -> String {
+    let failed: Vec<&DbtNodeResult> = r
+        .nodes
+        .iter()
+        .filter(|n| {
+            matches!(
+                classify_status(&n.status),
+                DbtNodeOutcome::Failed | DbtNodeOutcome::Warn | DbtNodeOutcome::Unknown
+            )
+        })
+        .collect();
+    if failed.is_empty() {
+        return "dbt failed before any node ran".to_string();
+    }
+    let mut out = format!("{} dbt node(s) did not succeed:\n", failed.len());
+    for n in failed {
+        out.push_str(&format!(
+            "  {} [{}]{}{}\n",
+            n.unique_id,
+            n.status,
+            n.failures
+                .map(|f| format!(" {f} failing row(s)"))
+                .unwrap_or_default(),
+            n.message
+                .as_deref()
+                .map(|m| format!(": {m}"))
+                .unwrap_or_default(),
+        ));
+    }
+    out
+}
+
+/// Refresh the stored graph from the manifest this run produced.
+async fn ingest_from_run(
+    p: &PreparedProject,
+    descriptor: &DbtDescriptor,
+    inv: &Invocation,
+    ctx: &mut JobCtx<'_>,
+    job: &MiniPulledJob,
+    conn: &Connection,
+) -> error::Result<()> {
+    // No warehouse identity means there is no graph that could go stale.
+    let Some(warehouse) = p.warehouse.as_deref() else {
+        return Ok(());
+    };
+    let Some(script_path) = job.runnable_path.as_deref() else {
+        return Ok(());
+    };
+    let manifest = read_manifest(&p.project_dir).await?;
+    // The run's own arguments: resolving the selection with empty vars could
+    // filter this run's manifest by a different node set than it built.
+    let selected =
+        resolve_selection(p, descriptor, inv, ctx, &job.id, &job.workspace_id, conn).await?;
+    let ingested = windmill_common::dbt_manifest::ingest_manifest(
+        &manifest,
+        warehouse,
+        p.default_database.as_deref(),
+        selected.as_ref(),
+    );
+    // Only a run whose models are its own snapshots per run. A static
+    // descriptor at a moved profile re-ingests the VERSION's graph, since the
+    // move outlives the run; one that neither drifted nor overrode anything
+    // re-ingests the same graph its deploy wrote and stores nothing.
+    let snapshot_job = p.graph_refresh.snapshot_job(job.id);
+    match conn {
+        Connection::Sql(db) => {
+            persist_ingest(
+                db,
+                &job.workspace_id,
+                script_path,
+                &ingested,
+                &p.relation_root(),
+                job.runnable_id
+                    .map(|h| GraphPublisher::Version(h.0))
+                    .unwrap_or(GraphPublisher::Unversioned),
+                snapshot_job,
+                p.graph_refresh.publishes_ownership(),
+            )
+            .await?;
+        }
+        // An agent worker reaches these tables only through the API. Publishing
+        // is the whole of what it needs: a worker that can replace the graph
+        // never has to establish that the stored one still describes its
+        // profile, because it stores what it just parsed.
+        Connection::Http(client) => {
+            client
+                .post::<_, serde_json::Value>(
+                    &format!("/api/agent_workers/dbt_graph/{}", job.workspace_id),
+                    None,
+                    // Only the job id: the server reads the path and version
+                    // from the job it verified, so this cannot name another
+                    // script's graph.
+                    &serde_json::json!({
+                        "job_id": job.id,
+                        "per_run": snapshot_job.is_some(),
+                        "relation_root": p.relation_root(),
+                        "manifest": ingested,
+                    }),
+                )
+                .await
+                .map_err(|e| {
+                    Error::internal_err(format!("publishing dbt graph from an agent worker: {e:#}"))
+                })?;
+        }
+    }
+    // Synchronously, not through the notify poller: the ingest just rewrote this
+    // script's `asset` rows and the poll is seconds away, so anything in this
+    // process reading the producer map meanwhile would see the pre-refresh copy.
+    // The `notify_event` the transaction emitted still reaches every other process.
+    windmill_queue::asset_dispatch::ASSET_PRODUCER_WRITES_CACHE.remove(&job.workspace_id);
+    Ok(())
+}
+
+/// Who is publishing a graph, which decides whether it may.
+#[derive(Clone, Copy)]
+enum GraphPublisher {
+    /// The script version this job belongs to, whether it is deploying that
+    /// version or running it. Publishes while the version is still the newest
+    /// for the path: a slow deploy — or a long run — of an older version
+    /// finishing later would otherwise describe code no longer deployed.
+    Version(i64),
+    /// No version behind the job: a preview, or a raw dependency job whose
+    /// `script_path` is chosen by a caller who needs only `jobs:run`. Never
+    /// publishes, so a run-only principal cannot rewrite another script's
+    /// graph.
+    Unversioned,
+}
+
+/// Replace this script's graph, unless a newer version of it has been deployed.
+///
+/// Write one ingest: the sidecar rows and the `asset` usages the manifest
+/// implies. No subscriptions — a `dbt://` one could never fire.
+///
+/// Returns whether this job was still the one entitled to the path-keyed half —
+/// false once a newer version has superseded it, or once the version is gone.
+async fn persist_ingest(
+    db: &sqlx::Pool<sqlx::Postgres>,
+    w_id: &str,
+    script_path: &str,
+    ingested: &windmill_common::dbt_manifest::IngestedManifest,
+    relation_root: &str,
+    publisher: GraphPublisher,
+    // Set for a RUN whose model set depends on its own arguments: that graph is
+    // a snapshot of this run and must not overwrite what another run of the same
+    // version saw. A deploy passes `None` and writes the version's own graph, as
+    // does a run that found the profile moved — that move is the version's.
+    run_snapshot: Option<uuid::Uuid>,
+    // Whether this ingest also becomes what the SCRIPT owns: the path-keyed
+    // `asset` usages, and the relation root the drift check reads back. False
+    // for a graph the caller's own arguments scoped (`GraphRefresh`).
+    publish_ownership: bool,
+) -> error::Result<bool> {
+    let GraphPublisher::Version(script_hash) = publisher else {
+        // No version to attribute the graph to — an inline or preview run, which
+        // deploys nothing and must not touch what a deploy wrote.
+        return Ok(false);
+    };
+    let mut tx = db.begin().await?;
+    // Deletion only soft-updates `script`, so re-inserting would republish model
+    // SQL a user deleted. NOT `archived`: every redeploy archives the parent, and
+    // treating that as deletion would deny v1 the graph its own runs render. An
+    // explicit archive still waits on `FOR UPDATE` and clears afterwards.
+    let deleted = sqlx::query_scalar!(
+        "SELECT deleted FROM script WHERE workspace_id = $1 AND hash = $2 FOR UPDATE",
+        w_id,
+        script_hash,
+    )
+    .fetch_optional(&mut *tx)
+    .await?
+    .unwrap_or(true);
+    if deleted {
+        return Ok(false);
+    }
+    // Written without regard to NEWER versions: the rows are keyed by this one, so
+    // an older deploy finishing late overwrites nothing and its own runs still
+    // render.
+    windmill_common::dbt_manifest::replace_dbt_manifest(
+        &mut tx,
+        w_id,
+        script_path,
+        script_hash,
+        run_snapshot,
+        ingested,
+        relation_root,
+    )
+    .await?;
+    // Beside the graph just written, not the ownership below: this is the root the
+    // STORED VERSION GRAPH describes. Hung off publication, a version that cannot
+    // claim the path records nothing and compares against a stale root forever.
+    // Only the DEPLOYED row: a run's own snapshot left its root as it was.
+    if run_snapshot.is_none() {
+        sqlx::query!(
+            "UPDATE dbt_graph_snapshot SET relation_root_at_last_ingest = $4
+          WHERE workspace_id = $1 AND script_path = $2 AND script_hash = $3
+            AND job_id = '00000000-0000-0000-0000-000000000000'",
+            w_id,
+            script_path,
+            script_hash,
+            relation_root,
+        )
+        .execute(&mut *tx)
+        .await?;
+    }
+    // What follows is keyed by PATH, so it belongs to the newest version alone: an
+    // older deploy, or a run whose `vars`/`select` describe one invocation, stops
+    // here. Publishing either as ownership would leave the workspace graph wrong
+    // until the next deploy, since a static descriptor never ingests again.
+    if !publish_ownership {
+        tx.commit().await?;
+        return Ok(true);
+    }
+    if !claim_graph_publication(&mut tx, w_id, script_path, publisher).await? {
+        tx.commit().await?;
+        return Ok(false);
+    }
+    windmill_common::assets::replace_static_asset_usage(
+        &mut tx,
+        w_id,
+        script_path,
+        &ingested.assets,
+    )
+    .await?;
+    // A `dbt://` subscription can never fire, so none are derived from the
+    // manifest. The delete stays to clear what earlier versions wrote, which would
+    // otherwise keep drawing cascade arrows that wake nothing.
+    sqlx::query!(
+        "DELETE FROM script_trigger
+          WHERE workspace_id = $1 AND runnable_kind = 'script' AND runnable_path = $2
+            AND trigger_kind = 'asset' AND trigger_ref LIKE 'dbt://%'",
+        w_id,
+        script_path,
+    )
+    .execute(&mut *tx)
+    .await?;
+    tx.commit().await?;
+    Ok(true)
+}
+
+/// Serialize publishers for one script path and confirm this job's version is
+/// still the newest. Both happen inside the caller's transaction, so a newer
+/// publisher either commits before this check sees it, or waits behind it and
+/// overwrites afterwards — which is the correct order either way.
+///
+/// Only the PATH-keyed writes need this. The graph itself is keyed by version,
+/// so two deploys of one path write disjoint rows and neither can lose.
+async fn claim_graph_publication(
+    tx: &mut sqlx::Transaction<'_, sqlx::Postgres>,
+    w_id: &str,
+    script_path: &str,
+    publisher: GraphPublisher,
+) -> error::Result<bool> {
+    let mine = match publisher {
+        GraphPublisher::Unversioned => return Ok(false),
+        GraphPublisher::Version(hash) => hash,
+    };
+    sqlx::query!(
+        "SELECT pg_advisory_xact_lock(hashtext($1))",
+        format!("dbt_graph:{w_id}:{script_path}")
+    )
+    .execute(&mut **tx)
+    .await?;
+    // Not `get_latest_script_hash`: its `lock IS NOT NULL` predicate names the
+    // PREVIOUS version while this one is being deployed, so every deploy would
+    // look superseded.
+    let latest = sqlx::query_scalar!(
+        "SELECT hash FROM script WHERE workspace_id = $1 AND path = $2 \
+           AND deleted = false AND archived = false \
+         ORDER BY created_at DESC LIMIT 1",
+        w_id,
+        script_path
+    )
+    .fetch_optional(&mut **tx)
+    .await?;
+    // No live version left means the script was archived or deleted while this
+    // job ran, and the deploy path has already cleared its graph. Publishing now
+    // would put the asset, provenance and subscription rows back with nothing
+    // left to remove them, so a missing row is a refusal, not a free pass.
+    Ok(latest.is_some_and(|latest| latest == mine))
+}
+
+/// The node set the descriptor's selection resolves to, or `None` when it
+/// selects everything.
+///
+/// Resolved by asking dbt (`dbt ls`) rather than by interpreting the selector
+/// string: the grammar is dbt's, it is large, and reimplementing it is a
+/// standing source of divergence — the mistake Cosmos's manifest path had to
+/// make and keeps paying for.
+async fn resolve_selection(
+    p: &PreparedProject,
+    descriptor: &DbtDescriptor,
+    inv: &Invocation,
+    ctx: &mut JobCtx<'_>,
+    job_id: &Uuid,
+    w_id: &str,
+    conn: &Connection,
+) -> error::Result<Option<std::collections::HashSet<String>>> {
+    if !has_selection(descriptor, inv)? {
+        return Ok(None);
+    }
+    let mut cmd = dbt_command(p, &["ls"]);
+    // A project whose models call `var()` without a default fails to parse
+    // without these, so the selection resolver needs them exactly as the run
+    // does. Placeholders that only a run can fill are dropped rather than
+    // failing the deploy.
+    add_vars(&mut cmd, descriptor, inv)?;
+    // Spelled out rather than `all`, which dbt-core 2.x rejects — and `unit_test`
+    // is its own type, so omitting it resolves a unit-test selection to the empty
+    // set. All three engines accept every value here.
+    for t in ["model", "source", "seed", "snapshot", "test", "unit_test"] {
+        cmd.args(["--resource-type", t]);
+    }
+    cmd.args(["--output", "json", "--quiet"]);
+    add_selection(&mut cmd, descriptor, inv)?;
+    // Captured directly, not through `handle_child`: its `pipe_stdout` path goes
+    // through the job-log writer, which `NO_LOGS_AT_ALL` discards — the selection
+    // would resolve to the empty set and the ingest would wipe the script's assets
+    // while dbt went on building the descriptor's models.
+    let stdout = run_capturing(cmd, "dbt ls", ctx, job_id, w_id, conn, LS_MAX_OUTPUT_BYTES).await?;
+    let mut set = std::collections::HashSet::new();
+    for line in stdout.lines() {
+        let line = line.trim();
+        if !line.starts_with('{') {
+            continue;
+        }
+        if let Ok(v) = serde_json::from_str::<serde_json::Value>(line) {
+            if let Some(id) = v.get("unique_id").and_then(|x| x.as_str()) {
+                set.insert(id.to_string());
+            }
+        }
+    }
+    if set.is_empty() {
+        // A selection that matches nothing would be ingested as "this script
+        // owns no relations", wiping its graph and cascade edges — the same
+        // outcome a failed capture produces, and indistinguishable from it.
+        // Refuse rather than silently un-wire the script.
+        return Err(Error::ExecutionErr(
+            "the descriptor's `select`/`exclude` matched no dbt nodes; fix the selection rather \
+             than deploying a script that owns nothing"
+                .to_string(),
+        ));
+    }
+    Ok(Some(set))
+}
+
+/// A failed command's stderr is quoted back to the user, so it is bounded — and
+/// what is kept is the TAIL, because dbt prints its error summary last.
+const CAPTURE_MAX_STDERR_BYTES: usize = 64 * 1024;
+
+/// Run a command for its stdout under the job's cancellation and timeout.
+/// The same poller `handle_child` uses drives them, so a cancel or a deadline
+/// drops the wait future — which owns the child, and `kill_on_drop` then
+/// terminates it. Dropping a wait future does NOT by itself kill a process, so
+/// without that flag the child would outlive the job.
+///
+/// Reads the pipes incrementally against `max_stdout_bytes` rather than
+/// `wait_with_output`, which would buffer whatever the child chose to write
+/// before any ceiling could apply: the point of the ceiling is that the worker
+/// never holds more than it, so it has to be enforced while reading. Both pipes
+/// are drained concurrently because a child that fills the one nobody reads
+/// blocks forever.
+async fn run_capturing(
+    mut cmd: Command,
+    name: &str,
+    ctx: &mut JobCtx<'_>,
+    job_id: &Uuid,
+    w_id: &str,
+    conn: &Connection,
+    max_stdout_bytes: usize,
+) -> error::Result<String> {
+    use tokio::io::AsyncReadExt;
+
+    let mut child = cmd
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .kill_on_drop(true)
+        .spawn()
+        .map_err(|e| Error::internal_err(format!("{name} could not be started: {e}")))?;
+    let pid = child.id();
+    let mut stdout_pipe = child
+        .stdout
+        .take()
+        .ok_or_else(|| Error::internal_err(format!("{name} has no stdout")))?;
+    let mut stderr_pipe = child
+        .stderr
+        .take()
+        .ok_or_else(|| Error::internal_err(format!("{name} has no stderr")))?;
+
+    let out = run_future_with_polling_update_job_poller(
+        *job_id,
+        ctx.timeout(),
+        conn,
+        ctx.mem_peak,
+        ctx.canceled_by,
+        async move {
+            let mut stdout: Vec<u8> = Vec::new();
+            let mut stderr: Vec<u8> = Vec::new();
+            // On the heap, not the stack: these live across the `select!`, so an
+            // array would be baked into this future's state, and the future is
+            // then moved into the job poller and boxed several layers deep. Two
+            // 16 KB arrays there overflow the worker thread's stack.
+            let mut out_buf = vec![0u8; 16 * 1024];
+            let mut err_buf = vec![0u8; 16 * 1024];
+            let (mut out_open, mut err_open) = (true, true);
+            while out_open || err_open {
+                tokio::select! {
+                    r = stdout_pipe.read(&mut out_buf[..]), if out_open => match r {
+                        Ok(0) => out_open = false,
+                        Ok(n) => {
+                            if stdout.len() + n > max_stdout_bytes {
+                                // Killed here rather than left to `kill_on_drop`
+                                // so the child is gone before the error unwinds,
+                                // not merely once this future is dropped.
+                                let _ = child.kill().await;
+                                return Err(Error::ExecutionErr(format!(
+                                    "{name} produced more than {} MB of output. Narrow the \
+                                     selection, or query the relation from a SQL script.",
+                                    max_stdout_bytes / 1024 / 1024
+                                )));
+                            }
+                            stdout.extend_from_slice(&out_buf[..n]);
+                        }
+                        Err(e) => return Err(Error::internal_err(format!("{name} failed: {e}"))),
+                    },
+                    r = stderr_pipe.read(&mut err_buf[..]), if err_open => match r {
+                        Ok(0) => err_open = false,
+                        Ok(n) => {
+                            stderr.extend_from_slice(&err_buf[..n]);
+                            if stderr.len() > CAPTURE_MAX_STDERR_BYTES {
+                                let excess = stderr.len() - CAPTURE_MAX_STDERR_BYTES;
+                                stderr.drain(..excess);
+                            }
+                        }
+                        Err(_) => err_open = false,
+                    },
+                }
+            }
+            let status = child
+                .wait()
+                .await
+                .map_err(|e| Error::internal_err(format!("{name} failed: {e}")))?;
+            Ok((status, stdout, stderr))
+        },
+        ctx.worker_name,
+        w_id,
+        &mut Some(ctx.occupancy_metrics),
+        Box::pin(futures::stream::unfold((), move |_| async move {
+            Some((get_mem_peak(pid, false).await, ()))
+        })),
+    )
+    .await?;
+    let (status, stdout, stderr) = out;
+    if !status.success() {
+        return Err(Error::ExecutionErr(format!(
+            "{name} failed: {}",
+            String::from_utf8_lossy(&stderr)
+        )));
+    }
+    Ok(String::from_utf8_lossy(&stdout).to_string())
+}
+
+/// Run a preparation command through the same child handler the build uses, so
+/// cancellation and the job timeout apply to it too.
+async fn run_prep_command(
+    p: &PreparedProject,
+    mut cmd: Command,
+    name: &str,
+    ctx: &mut JobCtx<'_>,
+    job_id: &Uuid,
+    w_id: &str,
+    conn: &Connection,
+) -> error::Result<()> {
+    cmd.stdout(Stdio::piped()).stderr(Stdio::piped());
+    let child = start_child_process(cmd, p.engine.bin.to_string_lossy().as_ref(), false).await?;
+    handle_child(
+        job_id,
+        conn,
+        ctx.mem_peak,
+        ctx.canceled_by,
+        child,
+        false,
+        ctx.worker_name,
+        w_id,
+        name,
+        ctx.timeout(),
+        false,
+        &mut Some(ctx.occupancy_metrics),
+        None,
+        None,
+    )
+    .await
+    .map(|_| ())
+}
+
+/// `dbt parse`, which writes the manifest without touching the
+/// warehouse. Both the deploy and a per-run graph refresh need the manifest
+/// before anything else happens.
+async fn run_dbt_parse(
+    p: &PreparedProject,
+    descriptor: &DbtDescriptor,
+    inv: &Invocation,
+    ctx: &mut JobCtx<'_>,
+    job_id: &Uuid,
+    w_id: &str,
+    conn: &Connection,
+) -> error::Result<()> {
+    let mut cmd = dbt_command(p, &["parse"]);
+    add_vars(&mut cmd, descriptor, inv)?;
+    run_prep_command(p, cmd, "dbt parse", ctx, job_id, w_id, conn).await
+}
+
+pub(crate) async fn read_manifest(
+    project_dir: &Path,
+) -> error::Result<windmill_common::dbt_manifest::Manifest> {
+    let path = project_dir.join(ARTIFACTS_DIR).join("manifest.json");
+    let content = tokio::fs::read_to_string(&path)
+        .await
+        .map_err(|e| Error::internal_err(format!("dbt produced no manifest.json: {e}")))?;
+    serde_json::from_str(&content)
+        .map_err(|e| Error::internal_err(format!("could not parse manifest.json: {e}")))
+}
+
+/// `dbt retry` reads `run_results.json` from the previous invocation, and
+/// Windmill gives each attempt a fresh job dir — so this is where the last one
+/// is kept. It is a fast path over `dbt_run_state`, which any worker of the
+/// group can read; only an agent worker, which cannot reach that table, is
+/// limited to what its own disk holds.
+///
+/// Keyed by principal as well, matching `dbt_run_state`. An agent worker never
+/// reads that table, so this cache is the whole boundary there: without it one
+/// principal's saved `select` and `vars` are restorable by the next.
+fn state_dir(w_id: &str, script_path: &str, permissioned_as: &str) -> PathBuf {
+    PathBuf::from(&*DBT_CACHE_DIR)
+        .join("state")
+        .join(digest(&format!("{w_id}/{script_path}/{permissioned_as}")))
+}
+
+/// Forget any saved retry state for this principal and script.
+///
+/// Called where an invocation ran the BUILD and left nothing resumable —
+/// cancelled, timed out, dead before dbt wrote `run_results.json` — because the
+/// warehouse is then no longer what the previous run's failures describe, and a
+/// `dbt retry` would rebuild against a state that moved under it. Also where the
+/// run is hidden from the script's owners, which keeps no state at all. A
+/// failure BEFORE the build touches no relation and leaves the saved run alone.
+async fn invalidate_run_state(
+    w_id: &str,
+    script_path: &str,
+    permissioned_as: &str,
+    conn: &Connection,
+) {
+    if script_path.is_empty() {
+        return;
+    }
+    if let Connection::Sql(db) = conn {
+        let _ = sqlx::query!(
+            "DELETE FROM dbt_run_state
+              WHERE workspace_id = $1 AND script_path = $2 AND permissioned_as = $3",
+            w_id,
+            script_path,
+            permissioned_as,
+        )
+        .execute(db)
+        .await
+        .inspect_err(|e| {
+            tracing::warn!("dbt: could not clear retry state for {script_path}: {e:#}")
+        });
+    }
+    let dir = state_dir(w_id, script_path, permissioned_as);
+    if let Err(e) = tokio::fs::remove_file(dir.join(CURRENT_GENERATION)).await {
+        if e.kind() != std::io::ErrorKind::NotFound {
+            tracing::warn!("dbt: could not drop local retry state for {script_path}: {e:#}");
+        }
+    }
+    // The generations too, not only the pointer. `prune_old_generations` otherwise
+    // runs at the tail of a successful SAVE, so a script whose last run went green
+    // stranded the failed run's directory, each holding a `manifest.json` that
+    // grows with the project. Keeps only what a retry may already be copying.
+    prune_old_generations(&dir, "").await;
+}
+
+async fn save_run_state(
+    p: &PreparedProject,
+    w_id: &str,
+    // Part of the state's key: a retry replaces the caller's arguments with
+    // these, so another principal must not be able to restore them.
+    permissioned_as: &str,
+    // A HIDDEN run keeps no state: the key is the principal, which every caller of
+    // an `on_behalf_of` script shares, and a retry publishes the arguments it
+    // restored — so that retry would be the one way to see a run they cannot read.
+    // A visible run discloses nothing they could not already read.
+    visible_to_owner: bool,
+    // Names this run's generation directory, so two runs of one script stage into
+    // their own and cannot publish a mixture of each other's artifacts.
+    job_id: &Uuid,
+    inv: &Invocation,
+    // Digest of the `run_results.json` a retry restored, when this run is one.
+    restored_results_digest: Option<&str>,
+    conn: &Connection,
+) -> error::Result<()> {
+    if p.script_path.is_empty() {
+        return Ok(());
+    }
+    // The previous run's state goes with it: this invocation happened, so those
+    // failures are no longer what last ran here.
+    if !visible_to_owner {
+        invalidate_run_state(w_id, &p.script_path, permissioned_as, conn).await;
+        return Ok(());
+    }
+    let identity = format!(
+        "{}|{}{ARGS_DIGEST_TAG}{}",
+        p.run_identity(),
+        inv.env_digest(),
+        inv.resolved_args_digest()
+    );
+    // As SUBMITTED, not resolved: `build_args_map` turns `$var:` and `$res:` into
+    // plaintext and this row outlives the job, so persisting the resolved value
+    // would leave a secret in the database and let a retry replay it after the
+    // grant was revoked. The restore resolves again, under whoever retries.
+    let args: HashMap<String, String> = inv
+        .raw_args
+        .iter()
+        .map(|(k, v)| (k.clone(), v.get().to_string()))
+        .collect();
+    // The durable copy, so a retry works from any worker of the group. Only
+    // `run_results.json`: the manifest is a pure function of what `identity`
+    // already pins, so the resuming worker re-derives it with a `dbt parse`.
+    let results =
+        tokio::fs::read_to_string(p.project_dir.join(ARTIFACTS_DIR).join("run_results.json"))
+            .await
+            .ok();
+    // No `run_results.json` means nothing resumable happened — cancelled, timed
+    // out, dead before dbt wrote one. The previous run's state must not stay
+    // authoritative, or `dbt retry` resumes ITS failed nodes, which are not what
+    // last ran here. Both copies go, so neither answers for the other.
+    let Some(results) = results else {
+        invalidate_run_state(w_id, &p.script_path, permissioned_as, conn).await;
+        return Ok(());
+    };
+    // A retry that ended before dbt rewrote the file leaves what the restore put
+    // there. Republishing dates the PREVIOUS attempt's failures to this job, so the
+    // next retry rebuilds nodes this one already redid — appending to an
+    // incremental model twice. As above: nothing resumable happened here.
+    if restored_results_digest == Some(digest(&results).as_str()) {
+        invalidate_run_state(w_id, &p.script_path, permissioned_as, conn).await;
+        return Ok(());
+    }
+    let mut durable_err = None;
+    if let Connection::Sql(db) = conn {
+        {
+            // Only while a live dbt version stays at this path — the test
+            // `clear_dbt_run_state_if_path_retired` retires state by, plus the
+            // language, since a rename leaves the old path archived rather than
+            // deleted and a path can come back as another language. A job already
+            // running finishes after those move or clear the row: writing then
+            // strands a failure where the script no longer is.
+            durable_err = sqlx::query!(
+                "INSERT INTO dbt_run_state (workspace_id, script_path, permissioned_as, identity, args, run_results, job_id, retryable, updated_at)
+                 SELECT $1::varchar, $2::varchar, $7::varchar, $3::text, $4::jsonb, $5::text, $6::uuid, $8::boolean, now()
+                  WHERE EXISTS (SELECT 1 FROM script
+                                 WHERE workspace_id = $1 AND path = $2
+                                   AND deleted = false AND archived = false
+                                   AND language = 'dbt')
+                 ON CONFLICT (workspace_id, script_path, permissioned_as) DO UPDATE SET
+                   identity = EXCLUDED.identity, args = EXCLUDED.args,
+                   run_results = EXCLUDED.run_results, job_id = EXCLUDED.job_id,
+                   retryable = EXCLUDED.retryable, updated_at = now()",
+                w_id,
+                &p.script_path,
+                identity,
+                serde_json::to_value(&args).unwrap_or_default(),
+                results,
+                job_id,
+                permissioned_as,
+                // Read back by the API to decide whether anything may offer a
+                // resume; the restore re-checks the results themselves, which is
+                // what tells a retry the run succeeded rather than that no state
+                // exists.
+                has_retryable_node(&results),
+            )
+            .execute(db)
+            .await
+            .err();
+        }
+    }
+    // A failed durable write leaves this generation unpublished locally too:
+    // `restore` takes a local one only when the row names it, so publishing what no
+    // row records would have this worker reject its own newest state. The previous
+    // run's goes with it, since resuming it would rebuild the wrong nodes.
+    if let Some(e) = durable_err {
+        invalidate_run_state(w_id, &p.script_path, permissioned_as, conn).await;
+        return Err(e.into());
+    }
+    let dir = state_dir(w_id, &p.script_path, permissioned_as);
+    let generation = format!("gen-{job_id}");
+    // Giving up leaves the PREVIOUS generation's pointer in place, which is
+    // harmless where a durable row exists — `restore` falls back to it. An agent
+    // worker has no row, so that pointer is all a retry reads, and it would answer
+    // for a run that is not the last one to have happened here.
+    let abandon_local = || async {
+        if matches!(conn, Connection::Http(_)) {
+            invalidate_run_state(w_id, &p.script_path, permissioned_as, conn).await;
+        }
+        Ok(())
+    };
+    let staging = dir.join(&generation);
+    tokio::fs::remove_dir_all(&staging).await.ok();
+    if tokio::fs::create_dir_all(&staging).await.is_err() {
+        return abandon_local().await;
+    }
+    for f in ["run_results.json", "manifest.json"] {
+        if tokio::fs::copy(p.project_dir.join(ARTIFACTS_DIR).join(f), staging.join(f))
+            .await
+            .is_err()
+        {
+            tokio::fs::remove_dir_all(&staging).await.ok();
+            return abandon_local().await;
+        }
+    }
+    // What produced it, environment included: a moved ref, a repointed profile or
+    // a changed script variable makes the saved results describe relations a retry
+    // would not produce. The arguments come back too, since `dbt retry` reuses the
+    // original invocation's selection and vars rather than this job's.
+    let state = SavedRunState { identity, args };
+    if tokio::fs::write(
+        staging.join("state.json"),
+        serde_json::to_vec(&state).unwrap_or_default(),
+    )
+    .await
+    .is_err()
+    {
+        tokio::fs::remove_dir_all(&staging).await.ok();
+        return abandon_local().await;
+    }
+    // Publishing is one rename over the pointer file. A reader either sees the
+    // previous generation's name or this one's, never a directory being
+    // rebuilt under it.
+    let pointer_staging = dir.join(format!(".{generation}.pointer"));
+    if tokio::fs::write(&pointer_staging, generation.as_bytes())
+        .await
+        .is_err()
+        || tokio::fs::rename(&pointer_staging, dir.join(CURRENT_GENERATION))
+            .await
+            .is_err()
+    {
+        tokio::fs::remove_file(&pointer_staging).await.ok();
+        tokio::fs::remove_dir_all(&staging).await.ok();
+        return abandon_local().await;
+    }
+    prune_old_generations(&dir, &generation).await;
+    Ok(())
+}
+
+/// Names the generation directory a retry reads. Replaced by rename, so it is
+/// always one name or the other.
+const CURRENT_GENERATION: &str = "current";
+
+/// How long a superseded generation stays readable. A retry that has already
+/// read the pointer is still copying out of that directory, so it cannot be
+/// removed the moment the next run publishes.
+const GENERATION_GRACE_SECS: u64 = 3600;
+
+/// How many superseded generations may sit inside the grace period at once.
+/// Each holds a manifest and a results copy, and the grace is a whole hour: a
+/// burst of runs would otherwise accumulate that many copies, and nothing after
+/// the burst comes back to remove them.
+const GENERATION_KEEP: usize = 4;
+
+async fn prune_old_generations(dir: &Path, keep: &str) {
+    let Ok(mut entries) = tokio::fs::read_dir(dir).await else {
+        return;
+    };
+    let now = std::time::SystemTime::now();
+    let mut young: Vec<(std::time::SystemTime, PathBuf)> = Vec::new();
+    while let Ok(Some(e)) = entries.next_entry().await {
+        let name = e.file_name().to_string_lossy().to_string();
+        if !name.starts_with("gen-") || name == keep {
+            continue;
+        }
+        let modified = e.metadata().await.ok().and_then(|m| m.modified().ok());
+        let stale = modified
+            .and_then(|t| now.duration_since(t).ok())
+            .is_some_and(|age| age.as_secs() > GENERATION_GRACE_SECS);
+        if stale {
+            tokio::fs::remove_dir_all(e.path()).await.ok();
+        } else if let Some(t) = modified {
+            young.push((t, e.path()));
+        }
+    }
+    // Oldest first, so what goes is what a retry is least likely to still be
+    // copying out of.
+    young.sort_by_key(|(t, _)| *t);
+    let excess = young.len().saturating_sub(GENERATION_KEEP);
+    for (_, path) in young.into_iter().take(excess) {
+        tokio::fs::remove_dir_all(path).await.ok();
+    }
+}
+
+/// Everything a dbt invocation is parameterized by. One struct because every
+/// command in a run — `parse`, `ls`, `build` — must see the SAME arguments and
+/// environment: a difference between any two of them means the graph describes
+/// something other than what was built, silently.
+#[derive(Clone, Default)]
+pub struct Invocation {
+    pub args: HashMap<String, Box<RawValue>>,
+    /// The args as SUBMITTED, before `$var:` / `$res:` / `$encrypted:` were
+    /// resolved. This is what run state persists: saving `args` would write the
+    /// resolved plaintext into `dbt_run_state` and the worker's `state.json`,
+    /// and a later `retry` would replay another caller's secret — after the
+    /// grant was revoked or the value rotated. The reference outlives the run;
+    /// what it pointed at must not.
+    pub raw_args: HashMap<String, Box<RawValue>>,
+    pub envs: HashMap<String, String>,
+    /// A run must fail on a `{{ }}` placeholder it cannot fill; a deploy, which
+    /// has no arguments at all, tolerates them. Declared rather than inferred
+    /// from the argument count: a run submitted with `{}` is still a run, and
+    /// treating it as a deploy would blank its placeholders and build against
+    /// an unintended schema or alias.
+    pub strict: bool,
+}
+
+impl Invocation {
+    /// Digest of the RESOLVED arguments, for retry identity.
+    ///
+    /// The saved arguments are the ones submitted, so a `$var:` in them is
+    /// re-resolved on retry — and a value that changed since the failed run
+    /// selects a different set of nodes, or an `enabled`/`schema`/`alias` that
+    /// moves the relations. Without this in the identity that retry is accepted,
+    /// and which graph it uses then depends on WHERE it lands: a worker holding
+    /// the local snapshot replays the saved manifest, while a database restore
+    /// reparses with the new value. Placement must not decide that.
+    ///
+    /// Values are the user's, and can be secrets, so they are hashed.
+    fn resolved_args_digest(&self) -> String {
+        let mut sorted: Vec<(&String, &Box<RawValue>)> = self.args.iter().collect();
+        sorted.sort_by(|a, b| a.0.cmp(b.0));
+        stable_digest(sorted.iter().flat_map(|(k, v)| [k.as_str(), v.get()]))
+    }
+
+    /// Digest of the script-level environment, for retry identity. Values are
+    /// secrets, so they are hashed rather than stored.
+    fn env_digest(&self) -> String {
+        let mut sorted: Vec<(&String, &String)> = self.envs.iter().collect();
+        sorted.sort();
+        stable_digest(sorted.iter().flat_map(|(k, v)| [k.as_str(), v.as_str()]))
+    }
+}
+
+/// A digest that survives a toolchain upgrade.
+///
+/// These values are written into `dbt_run_state.identity` and compared by a
+/// later worker, possibly built with a different Rust release —
+/// `DefaultHasher`'s output is explicitly not stable across those, so a bump
+/// would refuse every saved failure as a different project. Each part is
+/// length-prefixed so no split of the same bytes can collide.
+fn stable_digest<'a>(parts: impl Iterator<Item = &'a str>) -> String {
+    use sha2::{Digest, Sha256};
+    let mut h = Sha256::new();
+    for p in parts {
+        h.update((p.len() as u64).to_be_bytes());
+        h.update(p.as_bytes());
+    }
+    format!("{:x}", h.finalize())
+}
+
+/// Whether the invocation overrides the descriptor's `vars`, which decides
+/// whether its graph is its own rather than the deployed one.
+fn has_vars_override(args: &HashMap<String, Box<RawValue>>) -> bool {
+    args.get("vars")
+        .is_some_and(|r| !matches!(r.get().trim(), "" | "null" | "{}"))
+}
+
+/// The saved identity, split at the point resolution happens.
+///
+/// The project, warehouse, engine and env can be checked before anything is
+/// restored. The resolved-arguments digest cannot: the retry REQUEST carries
+/// only `dbt_command`, and the arguments to compare are the saved ones after
+/// this caller has re-resolved them — which happens later, in `handle_dbt_job`.
+/// Comparing the whole string up front would refuse every retry.
+fn split_identity(identity: &str) -> (&str, Option<&str>) {
+    // Tagged, not positional. The previous format was `<identity>|<env>`, so
+    // taking "everything after the last `|`" reads a pre-upgrade row's env
+    // digest as an arguments digest, leaves `<identity>` as the prefix, and
+    // rejects every saved failure on the instance as a different project.
+    match identity.rsplit_once(ARGS_DIGEST_TAG) {
+        Some((prefix, args)) => (prefix, Some(args)),
+        None => (identity, None),
+    }
+}
+
+/// Separates the resolved-arguments digest from the rest of a saved identity.
+/// A row written before it existed simply does not contain this.
+const ARGS_DIGEST_TAG: &str = "|args=";
+
+/// What an invocation was, so a later `dbt retry` can prove it is resuming the
+/// same thing rather than replaying failures somewhere else.
+#[derive(Serialize, Deserialize, Debug, Default)]
+struct SavedRunState {
+    /// Project digest, warehouse and engine — everything that decides which
+    /// relations the restored `run_results.json` describes.
+    identity: String,
+    /// The invocation's job arguments, as raw JSON per key. `dbt retry` reuses
+    /// the original selection and vars, so refreshing the graph for it needs
+    /// these rather than the retry request's.
+    args: HashMap<String, String>,
+}
+
+/// The durable half of the restore: the worker-local generation is gone (or this
+/// is another worker of the group), so the state comes from the database.
+///
+/// `run_results.json` is all that is stored. `dbt retry` also reads
+/// `manifest.json`, which is far larger and grows with the project, so it has to
+/// be re-derived with a `dbt parse` — sound because `identity` pins the project
+/// digest, the warehouse and the engine, which is everything the manifest is a
+/// function of. That parse is the caller's, on resolved arguments.
+async fn restore_from_db(
+    p: &PreparedProject,
+    w_id: &str,
+    permissioned_as: &str,
+    inv: &Invocation,
+    // The run the caller named. Re-checked here rather than trusted from the
+    // caller's earlier read: another invocation can replace the row in between,
+    // and the row this restore actually reads must still be that run.
+    expected_job: Uuid,
+    conn: &Connection,
+    no_state: Error,
+) -> error::Result<RestoredRun> {
+    let Connection::Sql(db) = conn else {
+        // An agent worker reaches the database only through the API, and this
+        // state is not exposed there.
+        return Err(no_state);
+    };
+    // The principal IS the boundary, and deliberately: a retry resumes what last
+    // ran as this identity, not what this caller ran. Adding a caller check needs an
+    // identity the worker does not have — `created_by` is a display name a token
+    // label supplies — and resuming grants nothing a caller entitled to run the
+    // script lacks. What it does add, the resumed arguments echoed in the result,
+    // and the one sharing shape where that crosses a line, are in docs/dbt-runtime.md.
+    let Some(row) = sqlx::query!(
+        "SELECT identity, args, run_results, job_id FROM dbt_run_state
+         WHERE workspace_id = $1 AND script_path = $2 AND permissioned_as = $3",
+        w_id,
+        &p.script_path,
+        permissioned_as
+    )
+    .fetch_optional(db)
+    .await?
+    else {
+        return Err(no_state);
+    };
+    if row.job_id != Some(expected_job) {
+        return Err(wrong_run(
+            expected_job,
+            row.job_id.map(|j| j.to_string()).as_deref(),
+            "for this script",
+        ));
+    }
+    let (saved_prefix, saved_args_digest) = split_identity(&row.identity);
+    if saved_prefix != format!("{}|{}", p.run_identity(), inv.env_digest()) {
+        return Err(different_project());
+    }
+    let saved_args_digest = saved_args_digest.map(str::to_string);
+    if !has_retryable_node(&row.run_results) {
+        return Err(nothing_to_retry());
+    }
+    let target = p.project_dir.join(ARTIFACTS_DIR);
+    tokio::fs::create_dir_all(&target).await.ok();
+    tokio::fs::write(target.join("run_results.json"), &row.run_results)
+        .await
+        .map_err(|e| Error::internal_err(format!("restoring run_results.json: {e}")))?;
+    // No manifest came with the row, so one has to be re-derived — but not here:
+    // these arguments are as SUBMITTED, and a `$var:` in them shapes the graph
+    // only once resolved. The caller resolves, then parses.
+    Ok(RestoredRun {
+        args: restored_args(row.args),
+        needs_parse: true,
+        args_digest: saved_args_digest,
+        results_digest: digest(&row.run_results),
+    })
+}
+
+/// Job arguments as stored, each value a raw JSON string.
+fn restored_args(args: serde_json::Value) -> HashMap<String, Box<RawValue>> {
+    serde_json::from_value::<HashMap<String, String>>(args)
+        .unwrap_or_default()
+        .into_iter()
+        .filter_map(|(k, v)| Some((k, RawValue::from_string(v).ok()?)))
+        .collect()
+}
+
+fn different_project() -> Error {
+    Error::BadRequest(
+        "the last dbt run was of a different project, warehouse or engine, so its failures do \
+         not describe this one; run the script normally instead"
+            .to_string(),
+    )
+}
+
+/// A retry named a run other than the one whose failure is held. Both ids are
+/// spelled out: only one failure is kept per script per principal, so a later run
+/// replaces it, and without the held id "that is not the one" reads as a bug.
+fn wrong_run(asked: Uuid, held: Option<&str>, held_where: &str) -> Error {
+    Error::BadRequest(match held {
+        Some(held) => format!(
+            "you asked to resume run {asked}, but the failure saved {held_where} is run {held}; \
+             only the most recent one is kept. Open {held} to retry that one, or run the script \
+             normally"
+        ),
+        None => format!(
+            "you asked to resume run {asked}, but no failure is saved {held_where}; run the \
+             script normally to rebuild"
+        ),
+    })
+}
+
+fn nothing_to_retry() -> Error {
+    Error::BadRequest(
+        "the last dbt run succeeded, so there is nothing to retry: `dbt retry` resumes the \
+         previous run's failed and skipped nodes. Run the script normally to rebuild"
+            .to_string(),
+    )
+}
+
+/// The previous invocation, restored.
+pub struct RestoredRun {
+    /// ITS arguments, as submitted, which is what the graph refresh for a retry
+    /// must use — still unresolved, so the caller resolves before using them.
+    pub args: HashMap<String, Box<RawValue>>,
+    /// Whether a `dbt parse` still owes a `manifest.json`. The local snapshot
+    /// carries one — unless it was pruned mid-restore; the database row never
+    /// does.
+    pub needs_parse: bool,
+    /// The resolved-arguments digest the saved run had, checked once the caller
+    /// has re-resolved those arguments.
+    pub args_digest: Option<String>,
+    /// Digest of the `run_results.json` this restore put in the job directory.
+    /// A retry that ends before dbt rewrites that file — cancelled, timed out —
+    /// leaves it there unchanged, and saving it would republish the PREVIOUS
+    /// attempt's failures as the newest state, so the retry after this one would
+    /// redo nodes this one already rebuilt.
+    pub results_digest: String,
+}
+
+/// Which worker-local generation a restore may use, if any.
+///
+/// The pointer is a fast path over the database row and is accepted only when it
+/// names the run that row does. An agent has no row — so for it the pointer is
+/// all there is, and its own name is the only thing that can answer "is this the
+/// run you asked to resume", which is why the check below is not the caller's.
+fn chosen_generation(
+    local: Option<String>,
+    conn: &Connection,
+    latest_job: Option<Uuid>,
+    expected_job: Uuid,
+) -> error::Result<Option<String>> {
+    let generation = match (local, conn, latest_job) {
+        (Some(g), Connection::Http(_), _) => Some(g),
+        (Some(g), _, Some(id)) if g.trim() == format!("gen-{id}") => Some(g),
+        _ => None,
+    };
+    if let Some(g) = generation.as_ref() {
+        if g.trim() != format!("gen-{expected_job}") {
+            return Err(wrong_run(
+                expected_job,
+                Some(g.trim().trim_start_matches("gen-")),
+                "on this worker",
+            ));
+        }
+    }
+    Ok(generation)
+}
+
+/// Restore the previous invocation. The `dbt parse` a database restore needs is
+/// left to the caller so it runs on RESOLVED arguments: a `$var:` reference
+/// shapes the graph only once it has a value, and parsing with the reference
+/// verbatim would hand the build a manifest of a different project than the one
+/// it goes on to build.
+async fn restore_run_state(
+    p: &PreparedProject,
+    w_id: &str,
+    permissioned_as: &str,
+    inv: &Invocation,
+    // The run the caller means to resume, which a retry always names.
+    expected_job: Uuid,
+    conn: &Connection,
+) -> error::Result<RestoredRun> {
+    if p.script_path.is_empty() {
+        // A preview has no path to key state on, and an empty key is the one
+        // that used to be shared by every dbt script in the workspace.
+        return Err(Error::BadRequest(
+            "`dbt_command: retry` needs a deployed script; a preview run has no state to \
+             resume from"
+                .to_string(),
+        ));
+    }
+    let dir = state_dir(w_id, &p.script_path, permissioned_as);
+    // Resolved ONCE, with everything read out of the generation it names.
+    // Generations are immutable, so arguments, manifest and results describe one
+    // invocation; resolving per file could pair one run's arguments with another's
+    // results.
+    let no_state = || {
+        Error::BadRequest(
+            "no previous dbt run to retry from. `dbt retry` resumes from the \
+             `run_results.json` the failed run left behind; run the script normally to rebuild"
+                .to_string(),
+        )
+    };
+    // The row is the authoritative latest state, written by whichever worker ran
+    // last, while `current` names only what THIS one saw — preferring local would
+    // let a retry on an idle worker resume an older invocation. The local snapshot
+    // is a fast path only when it names that same run: it already holds a manifest.
+    let saved_state = match conn {
+        Connection::Sql(db) => {
+            sqlx::query_scalar!(
+                "SELECT job_id FROM dbt_run_state
+              WHERE workspace_id = $1 AND script_path = $2 AND permissioned_as = $3",
+                w_id,
+                &p.script_path,
+                permissioned_as
+            )
+            .fetch_optional(db)
+            .await?
+        }
+        // An agent worker cannot read it; its local copy is all there is.
+        Connection::Http(_) => None,
+    };
+    let latest_job = saved_state.flatten();
+    if let Some(saved) = latest_job {
+        if expected_job != saved {
+            return Err(wrong_run(
+                expected_job,
+                Some(&saved.to_string()),
+                "for this script",
+            ));
+        }
+    }
+    // Authoritative including when it says nothing: no row means the last
+    // invocation left nothing resumable, and a local generation that outlived it
+    // would resurrect a run the newer one replaced. An agent worker has no such
+    // authority to consult, so its local copy stands.
+    let local = tokio::fs::read_to_string(dir.join(CURRENT_GENERATION))
+        .await
+        .ok();
+    let generation = chosen_generation(local, conn, latest_job, expected_job)?;
+    let Some(generation) = generation else {
+        return restore_from_db(
+            p,
+            w_id,
+            permissioned_as,
+            inv,
+            expected_job,
+            conn,
+            no_state(),
+        )
+        .await;
+    };
+    let snapshot = dir.join(generation.trim());
+    // The local generation is a fast path over the row for this same run, so one
+    // pruned out from under this restore falls back to the row rather than
+    // reporting nothing to resume. An agent worker has no row and gets that
+    // report, which is then true.
+    let Ok(saved_results) = tokio::fs::read_to_string(snapshot.join("run_results.json")).await
+    else {
+        return restore_from_db(
+            p,
+            w_id,
+            permissioned_as,
+            inv,
+            expected_job,
+            conn,
+            no_state(),
+        )
+        .await;
+    };
+    // dbt builds a retry's graph from the error, fail and skipped nodes alone, so
+    // retrying an all-green run selects nothing and builds nothing. Refused
+    // rather than reported as a successful run of nothing.
+    if !has_retryable_node(&saved_results) {
+        return Err(nothing_to_retry());
+    }
+    let Some(saved) = tokio::fs::read_to_string(snapshot.join("state.json"))
+        .await
+        .ok()
+        .and_then(|s| serde_json::from_str::<SavedRunState>(&s).ok())
+    else {
+        return restore_from_db(
+            p,
+            w_id,
+            permissioned_as,
+            inv,
+            expected_job,
+            conn,
+            no_state(),
+        )
+        .await;
+    };
+    let (saved_prefix, saved_args_digest) = split_identity(&saved.identity);
+    if saved_prefix != format!("{}|{}", p.run_identity(), inv.env_digest()) {
+        return Err(different_project());
+    }
+    let saved_args_digest = saved_args_digest.map(str::to_string);
+    let target = p.project_dir.join(ARTIFACTS_DIR);
+    tokio::fs::create_dir_all(&target).await.ok();
+    // From the bytes already read, not by copying the file again: a burst of saves
+    // can prune this generation mid-restore, and a `dbt retry` whose
+    // `run_results.json` went missing rebuilds nothing and reports success. The
+    // manifest has no such copy, so a failure there falls back to a `dbt parse`.
+    tokio::fs::write(target.join("run_results.json"), &saved_results)
+        .await
+        .map_err(|e| {
+            Error::internal_err(format!("could not restore the previous run's results: {e}"))
+        })?;
+    let needs_parse = tokio::fs::copy(snapshot.join("manifest.json"), target.join("manifest.json"))
+        .await
+        .is_err();
+    // The generation was chosen from a row read before the file work above. A run
+    // finishing in that window publishes a newer one, and resuming the superseded
+    // generation redoes nodes it has already rebuilt — appending to an incremental
+    // model twice. Re-read and refuse rather than resume what is no longer the last
+    // failure here.
+    if let Connection::Sql(db) = conn {
+        let still = sqlx::query_scalar!(
+            "SELECT job_id FROM dbt_run_state
+              WHERE workspace_id = $1 AND script_path = $2 AND permissioned_as = $3",
+            w_id,
+            &p.script_path,
+            permissioned_as
+        )
+        .fetch_optional(db)
+        .await?
+        .flatten();
+        if still != latest_job {
+            return Err(Error::BadRequest(
+                "another run of this script finished while this retry was starting, so its saved \
+                 failures are no longer the last ones; retry again to resume those"
+                    .to_string(),
+            ));
+        }
+    }
+    Ok(RestoredRun {
+        args: saved
+            .args
+            .into_iter()
+            .filter_map(|(k, v)| Some((k, RawValue::from_string(v).ok()?)))
+            .collect(),
+        needs_parse,
+        args_digest: saved_args_digest,
+        results_digest: digest(&saved_results),
+    })
+}
+
+/// Wait between retries, giving up if the job is cancelled or runs out of time.
+///
+/// Returns whether the retry should still happen. A plain sleep would hold the
+/// worker slot for the whole delay after a cancel and then start another dbt
+/// process on the far side of it.
+///
+/// The cancellation is READ FROM THE DATABASE each second rather than from
+/// `canceled_by`: that is only written by the job poller, which runs alongside a
+/// child process and so is not running here. Re-reading it would report the
+/// state as of the failed attempt and miss every cancel issued during the wait,
+/// which is the whole window this exists to cover.
+async fn sleep_before_retry(
+    delay_seconds: u64,
+    job_id: &Uuid,
+    conn: &Connection,
+    deadline: JobDeadline,
+) -> bool {
+    let mut left = delay_seconds;
+    loop {
+        if deadline.is_expired() || job_is_canceled(job_id, conn).await {
+            return false;
+        }
+        if left == 0 {
+            return true;
+        }
+        let step = left.min(1);
+        tokio::time::sleep(std::time::Duration::from_secs(step)).await;
+        left -= step;
+    }
+}
+
+/// Whether the job has been cancelled, as of now.
+///
+/// Only reachable with a database: the automatic retry that calls this is
+/// refused on an agent worker precisely because it could not answer here.
+async fn job_is_canceled(job_id: &Uuid, conn: &Connection) -> bool {
+    let Connection::Sql(db) = conn else {
+        return false;
+    };
+    sqlx::query_scalar!(
+        "SELECT canceled_by IS NOT NULL AS \"canceled!\" FROM v2_job_queue WHERE id = $1",
+        job_id
+    )
+    .fetch_optional(db)
+    .await
+    .map(|v| v == Some(true))
+    .unwrap_or(false)
+}
+
+/// Whether the artifacts in the job directory still name something to retry.
+async fn current_results_are_retryable(p: &PreparedProject) -> bool {
+    match tokio::fs::read_to_string(p.project_dir.join(ARTIFACTS_DIR).join("run_results.json"))
+        .await
+    {
+        Ok(s) => has_retryable_node(&s),
+        Err(_) => false,
+    }
+}
+
+/// Overlay a retry's results onto the attempt they resumed.
+///
+/// dbt writes only the nodes it redid, so replacing the accumulated results
+/// would drop every node that succeeded before the retry — the job would then
+/// report a handful of nodes and settle materializations for no others.
+fn merge_results(into: &mut Vec<DbtNodeResult>, from: Vec<DbtNodeResult>) {
+    for node in from {
+        match into.iter_mut().find(|n| n.unique_id == node.unique_id) {
+            Some(existing) => *existing = node,
+            None => into.push(node),
+        }
+    }
+}
+
+/// What a dbt node's status means, in the three terms this runtime acts on.
+///
+/// Every site classifies through here: dbt-core 1.x echoes the author's casing
+/// where 2.x uppercases, so comparing statuses inline gives each site its own
+/// answer for the same node.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum DbtNodeOutcome {
+    Started,
+    Passed,
+    Failed,
+    /// `warn`: a test failed under a severity that does not fail the run. The
+    /// relation is untouched, but the node is worth showing.
+    Warn,
+    /// `skipped`: dbt did not run the node, usually because an upstream one
+    /// failed. Says nothing about the relation, and `dbt retry` redoes it.
+    Skipped,
+    /// `no-op`: the node ran and had nothing to do (an empty microbatch, a model
+    /// with no rows to build). Tallied with `skipped` — nothing was built — but
+    /// NOT retryable: dbt's own retry set is error / fail / skipped.
+    NoOp,
+    /// A status this dbt version spells some way we do not know. Counted as an
+    /// error rather than silently passing, but never used to settle a relation.
+    Unknown,
+}
+
+impl DbtNodeOutcome {
+    /// The word this outcome is published as in a job's result. Stable by
+    /// contract: a dbt release may rename its own status, and this must not
+    /// move with it.
+    fn as_result_word(&self) -> &'static str {
+        match self {
+            // A finished node is never `Started`; it is spelled here so the
+            // match stays exhaustive rather than falling into `unknown`.
+            DbtNodeOutcome::Started => "started",
+            DbtNodeOutcome::Passed => "passed",
+            DbtNodeOutcome::Failed => "failed",
+            DbtNodeOutcome::Warn => "warned",
+            DbtNodeOutcome::Skipped => "skipped",
+            DbtNodeOutcome::NoOp => "no_op",
+            DbtNodeOutcome::Unknown => "unknown",
+        }
+    }
+}
+
+fn classify_status(status: &str) -> DbtNodeOutcome {
+    match status.trim().to_ascii_lowercase().as_str() {
+        "started" => DbtNodeOutcome::Started,
+        "success" | "pass" => DbtNodeOutcome::Passed,
+        // `partial success` builds the relation and then fails its tests: the
+        // node is a failure, and the relation it wrote is real but suspect.
+        "error" | "fail" | "runtime error" | "partial success" => DbtNodeOutcome::Failed,
+        "warn" => DbtNodeOutcome::Warn,
+        "skipped" => DbtNodeOutcome::Skipped,
+        "no-op" => DbtNodeOutcome::NoOp,
+        _ => DbtNodeOutcome::Unknown,
+    }
+}
+
+/// Whether a saved `run_results.json` holds anything `dbt retry` would redo.
+///
+/// The rule is dbt's own: `error`, `fail` and `skipped`. A `partial success`
+/// counts too — dbt spells that for a node that built but whose tests failed,
+/// and its retry redoes the node.
+///
+/// Tests count too, and they are the common case: with
+/// `test_behavior: after_all` a failing test is the whole of
+/// `run_results.json`, so requiring a relation-writing node would refuse the
+/// retry exactly when it is wanted.
+fn has_retryable_node(run_results: &str) -> bool {
+    serde_json::from_str::<RunResults>(run_results)
+        .map(|r| {
+            r.results.iter().any(|n| {
+                matches!(
+                    classify_status(&n.status),
+                    DbtNodeOutcome::Failed | DbtNodeOutcome::Skipped
+                )
+            })
+        })
+        // Unreadable results are not "nothing to retry": let dbt decide rather
+        // than refusing a retry the user may well need.
+        .unwrap_or(true)
+}
+
+/// Append `--vars` if the descriptor (or the run) declares any.
+fn add_vars(cmd: &mut Command, descriptor: &DbtDescriptor, inv: &Invocation) -> error::Result<()> {
+    let vars = resolved_vars(descriptor, &inv.args, inv.strict)?;
+    if !vars.is_empty() {
+        cmd.args(["--vars", &serde_json::to_string(&vars).unwrap_or_default()]);
+    }
+    Ok(())
+}
+
+/// `strict` is the difference between the two callers. A run MUST fail on a
+/// placeholder it cannot fill — silently substituting an empty string would let
+/// the job build the wrong slice and report success. A deploy has no arguments
+/// at all, so the same placeholder is expected there; the var still has to be
+/// *defined* or a project calling `var("run_date")` without its own default
+/// cannot be parsed, but its value is irrelevant to the graph.
+fn resolved_vars(
+    descriptor: &DbtDescriptor,
+    args: &HashMap<String, Box<RawValue>>,
+    strict: bool,
+) -> error::Result<serde_json::Map<String, serde_json::Value>> {
+    let mut out = serde_json::Map::new();
+    for (k, v) in &descriptor.vars {
+        out.insert(
+            k.clone(),
+            interpolate_value(v, args, &format!("vars.{k}"), strict)?,
+        );
+    }
+    // The run argument overrides; it never carries the descriptor's own values
+    // back (its signature default is empty), so this cannot clobber what was
+    // just interpolated above.
+    if let Some(raw) = args.get("vars").filter(|r| r.get().trim() != "null") {
+        // A wrong-typed override is refused rather than ignored: argument-schema
+        // validation is opt-in, so silently running the descriptor's own vars
+        // could build against a different schema or alias than the caller asked
+        // for — the same reason `select`/`exclude` reject theirs.
+        match serde_json::from_str(raw.get()) {
+            Ok(serde_json::Value::Object(m)) => out.extend(m),
+            _ => {
+                return Err(Error::BadRequest(
+                    "`vars` must be an object mapping dbt var names to values".to_string(),
+                ))
+            }
+        }
+    }
+    Ok(out)
+}
+
+/// Substitute `{{ arg }}` in every string leaf, leaving numbers, booleans and
+/// structure exactly as the descriptor spelled them.
+fn interpolate_value(
+    v: &serde_json::Value,
+    args: &HashMap<String, Box<RawValue>>,
+    field: &str,
+    strict: bool,
+) -> error::Result<serde_json::Value> {
+    Ok(match v {
+        serde_json::Value::String(s) => {
+            match crate::common::interpolate_template(s, Some(args), field) {
+                // A var whose ENTIRE value is one placeholder takes the
+                // argument's own type: `"{{ strict }}"` given `false` must reach
+                // dbt as a boolean, since "false" is truthy in Jinja. Embedded in
+                // text it stays a string, which is what interpolation means.
+                Ok(v) => match sole_placeholder(s).and_then(|name| args.get(name)) {
+                    Some(raw) => {
+                        serde_json::from_str(raw.get()).unwrap_or(serde_json::Value::String(v))
+                    }
+                    None => serde_json::Value::String(v),
+                },
+                Err(e) if strict => return Err(e),
+                Err(_) => serde_json::Value::String(String::new()),
+            }
+        }
+        serde_json::Value::Array(a) => serde_json::Value::Array(
+            a.iter()
+                .map(|x| interpolate_value(x, args, field, strict))
+                .collect::<error::Result<_>>()?,
+        ),
+        serde_json::Value::Object(o) => serde_json::Value::Object(
+            o.iter()
+                .map(|(k, x)| Ok((k.clone(), interpolate_value(x, args, field, strict)?)))
+                .collect::<error::Result<_>>()?,
+        ),
+        other => other.clone(),
+    })
+}
+
+/// The argument name when a value is exactly one `{{ placeholder }}` and
+/// nothing else.
+fn sole_placeholder(s: &str) -> Option<&str> {
+    let inner = s.trim().strip_prefix("{{")?.strip_suffix("}}")?.trim();
+    (!inner.is_empty()
+        && !inner.contains("{{")
+        && inner.chars().all(|c| c.is_ascii_alphanumeric() || c == '_'))
+    .then_some(inner)
+}
+
+/// One job argument, absent when unset or JSON `null` — a schema-less run sends
+/// the key with a null rather than omitting it, and both mean "not given".
+///
+/// A wrong TYPE is an error rather than an absence: argument-schema validation
+/// is opt-in, so `dbt_command: 1` read as unset would run the default command
+/// and `full_refresh: "false"` would still full-refresh, the caller silently
+/// getting something other than what they asked for.
+fn arg<T: serde::de::DeserializeOwned>(
+    args: &HashMap<String, Box<RawValue>>,
+    k: &str,
+    expected: &str,
+) -> error::Result<Option<T>> {
+    let Some(raw) = args.get(k).filter(|r| r.get().trim() != "null") else {
+        return Ok(None);
+    };
+    serde_json::from_str::<T>(raw.get())
+        .map(Some)
+        .map_err(|e| Error::BadRequest(format!("`{k}` must be {expected}: {e}")))
+}
+
+/// The run's arguments with the command block spread over them, its variant
+/// `label` under `dbt_command`.
+///
+/// A run submits one `command` argument whose `oneOf` variant IS the command, so
+/// an override belongs to the command that takes it. Every reader below wants a
+/// single map, and the block is spread here rather than at each of them so the
+/// two shapes never both reach one. `raw_args` keeps the submitted shape: it is
+/// what the state saves and the result publishes.
+///
+/// A block that is present must NAME a command: dropping a malformed one would
+/// leave no command at all, which reads as "the descriptor's default" — so
+/// `{"command": "show"}` would build the project the caller meant to preview.
+/// Argument-schema validation is opt-in, so this is the only check a direct
+/// request passes through.
+fn flatten_command(
+    mut args: HashMap<String, Box<RawValue>>,
+) -> error::Result<HashMap<String, Box<RawValue>>> {
+    let Some(block) = args.remove(DBT_COMMAND_ARG) else {
+        return Ok(args);
+    };
+    // `null` is how a schema-less run sends "not given", like every other
+    // argument, and means the descriptor's own command.
+    if block.get().trim() == "null" {
+        return Ok(args);
+    }
+    let malformed = || {
+        Error::BadRequest(format!(
+            "`{DBT_COMMAND_ARG}` must be an object naming what to run, e.g. \
+             `{{\"{DBT_COMMAND_LABEL}\": \"{}\"}}` — one of {}",
+            DBT_COMMANDS[0],
+            DBT_COMMANDS.join(", ")
+        ))
+    };
+    let mut fields = serde_json::from_str::<HashMap<String, Box<RawValue>>>(block.get())
+        .map_err(|_| malformed())?;
+    if arg_str(&fields, DBT_COMMAND_LABEL)?.is_none() {
+        return Err(malformed());
+    }
+    let label = fields.remove(DBT_COMMAND_LABEL);
+    for (k, v) in fields {
+        // A placeholder of the same name would otherwise be overwritten by the
+        // block — they are reserved for exactly that reason.
+        args.insert(k, v);
+    }
+    // LAST, and from the variant's label alone: a block carrying a `dbt_command`
+    // of its own would otherwise land on the same key, and which command ran
+    // would be map iteration order — the malformed check above, arrived at from
+    // the other side.
+    if let Some(label) = label {
+        args.insert("dbt_command".to_string(), label);
+    }
+    Ok(args)
+}
+
+/// Empty reads as absent: it is what an untouched text field sends.
+fn arg_str(args: &HashMap<String, Box<RawValue>>, k: &str) -> error::Result<Option<String>> {
+    Ok(arg::<String>(args, k, "a string")?.filter(|s| !s.is_empty()))
+}
+
+fn arg_bool(args: &HashMap<String, Box<RawValue>>, k: &str) -> error::Result<Option<bool>> {
+    arg(args, k, "a boolean")
+}
+
+fn arg_i64(args: &HashMap<String, Box<RawValue>>, k: &str) -> error::Result<Option<i64>> {
+    arg(args, k, "a whole number")
+}
+
+/// The selectors a given invocation runs with: the descriptor's, unless the
+/// run overrode them. Shared by the build and by the resolver that decides
+/// which nodes the run claims, which must agree — a resolver reading the
+/// descriptor while dbt builds an override filters the graph by a set the run
+/// never built.
+///
+/// Selectors are dbt's grammar and are passed verbatim — reimplementing it is a
+/// standing source of divergence (docs/dbt-runtime.md).
+fn add_selection(
+    cmd: &mut Command,
+    descriptor: &DbtDescriptor,
+    inv: &Invocation,
+) -> error::Result<()> {
+    for s in effective_select(descriptor, inv)? {
+        cmd.args(["--select", &s]);
+    }
+    for s in effective_exclude(descriptor, inv)? {
+        cmd.args(["--exclude", &s]);
+    }
+    if let Some(sel) = effective_selector(descriptor, inv)? {
+        cmd.args(["--selector", sel]);
+    }
+    Ok(())
+}
+
+/// Whether this invocation chose its own `select`/`exclude`.
+///
+/// DIFFERENT from the descriptor's, not merely present: `parse_dbt_sig` gives
+/// both fields the descriptor's own value as their default and the generated
+/// run form posts a default back for every field the caller left untouched, so
+/// every run from the UI, a schedule, a webhook or a flow step carries them.
+/// Reading that echo as a choice is wrong in two ways at once — it drops the
+/// descriptor's `--selector` from those runs (building the whole project), and
+/// it marks their graph caller-scoped so a moved profile never republishes and
+/// never settles. Both decisions ask this one question.
+///
+/// A run that wants the whole project despite a descriptor selector names a
+/// selection that differs — `["*"]`.
+fn selection_is_overridden(
+    descriptor: &DbtDescriptor,
+    args: &HashMap<String, Box<RawValue>>,
+) -> error::Result<bool> {
+    let differs = |key: &str, from: &Vec<String>| -> error::Result<bool> {
+        Ok(arg_list(args, key)?.is_some_and(|v| &v != from))
+    };
+    Ok(differs("select", &descriptor.select)? || differs("exclude", &descriptor.exclude)?)
+}
+
+/// The descriptor's named selector, unless this run named its own selection.
+///
+/// dbt resolves `--selector` INSTEAD of `--select`, so passing both makes the
+/// descriptor win: a preview asked for one model would return the descriptor's
+/// nodes, and a run asked for a subset would build something else. A run naming
+/// its own selection therefore replaces the descriptor's selector entirely.
+fn effective_selector<'a>(
+    descriptor: &'a DbtDescriptor,
+    inv: &Invocation,
+) -> error::Result<Option<&'a str>> {
+    if selection_is_overridden(descriptor, &inv.args)? {
+        return Ok(None);
+    }
+    Ok(descriptor.selector.as_deref())
+}
+
+fn effective_select(descriptor: &DbtDescriptor, inv: &Invocation) -> error::Result<Vec<String>> {
+    Ok(arg_list(&inv.args, "select")?.unwrap_or_else(|| descriptor.select.clone()))
+}
+
+fn effective_exclude(descriptor: &DbtDescriptor, inv: &Invocation) -> error::Result<Vec<String>> {
+    Ok(arg_list(&inv.args, "exclude")?.unwrap_or_else(|| descriptor.exclude.clone()))
+}
+
+/// Whether an invocation selects a subset at all, from whichever of the
+/// descriptor's fields and the run's arguments end up in force.
+fn has_selection(descriptor: &DbtDescriptor, inv: &Invocation) -> error::Result<bool> {
+    Ok(!effective_select(descriptor, inv)?.is_empty()
+        || !effective_exclude(descriptor, inv)?.is_empty()
+        || effective_selector(descriptor, inv)?.is_some())
+}
+
+/// An explicitly supplied list, including an empty one — `[]` is how a run asks
+/// for the whole project where the descriptor named a selection, so it must not
+/// read as "absent" and fall back to that selection.
+///
+/// A malformed one is an error rather than an absence: argument-schema
+/// validation is opt-in, so treating `"stg_orders"` as unset would silently run
+/// the descriptor's broader selection instead of the one the caller asked for.
+fn arg_list(args: &HashMap<String, Box<RawValue>>, k: &str) -> error::Result<Option<Vec<String>>> {
+    let Some(raw) = args.get(k) else {
+        return Ok(None);
+    };
+    if raw.get().trim() == "null" {
+        return Ok(None);
+    }
+    serde_json::from_str::<Vec<String>>(raw.get())
+        .map(Some)
+        .map_err(|e| Error::BadRequest(format!("`{k}` must be a list of strings: {e}")))
+}
+
+pub(crate) fn digest(s: &str) -> String {
+    let mut h = Sha256::new();
+    h.update(s.as_bytes());
+    format!("{:x}", h.finalize())[..32].to_string()
+}
+
+/// Copy a package tree, bounded by the job.
+///
+/// The tree is the project's, so its size is not ours to assume: run it under
+/// the poller like every other phase, or a cancelled or timed-out job keeps its
+/// worker slot until `cp` finishes on its own.
+async fn copy_dir_watched(
+    from: &Path,
+    to: &Path,
+    label: &str,
+    ctx: &mut JobCtx<'_>,
+    job_id: &Uuid,
+    w_id: &str,
+    conn: &Connection,
+) -> error::Result<()> {
+    tokio::fs::create_dir_all(to)
+        .await
+        .map_err(|e| Error::internal_err(format!("creating {to:?}: {e}")))?;
+    let mut cmd = Command::new("cp");
+    cmd.arg("-a").arg(format!("{}/.", from.display())).arg(to);
+    cmd.stdout(Stdio::piped()).stderr(Stdio::piped());
+    let child = start_child_process(cmd, "cp", false).await?;
+    handle_child(
+        job_id,
+        conn,
+        ctx.mem_peak,
+        ctx.canceled_by,
+        child,
+        false,
+        ctx.worker_name,
+        w_id,
+        label,
+        ctx.timeout(),
+        false,
+        &mut Some(ctx.occupancy_metrics),
+        None,
+        None,
+    )
+    .await
+    .map(|_| ())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn node_events_become_materialization_records() {
+        let started = r#"{"data":{"node_info":{"node_status":"started","materialized":"table",
+            "node_relation":{"alias":"Customers","schema":"Analytics",
+            "relation_name":"\"wh\".\"Analytics\".\"Customers\""}}},
+            "info":{"name":"LogStartLine","msg":"start"}}"#;
+        let ev = parse_node_event(started, "f/prod/wh", Some("wh")).unwrap();
+        assert_eq!(ev.status, MaterializationStatus::Running);
+        // Same canonicalization as the manifest ingest, or a run would record
+        // progress against a key no graph node has.
+        assert_eq!(ev.asset_path, "f/prod/wh/analytics/customers");
+
+        let failed = r#"{"data":{"node_info":{"node_status":"error",
+            "node_relation":{"alias":"c","schema":"a","relation_name":"\"w\".\"a\".\"c\""}}},
+            "info":{"name":"LogModelResult","msg":"boom"}}"#;
+        let ev = parse_node_event(failed, "f/prod/wh", Some("wh")).unwrap();
+        assert_eq!(ev.status, MaterializationStatus::Failed);
+        assert_eq!(ev.error.as_deref(), Some("boom"));
+    }
+
+    // `[]` against a descriptor that names a selection is how a run asks for the
+    // whole project. Reading it as "absent" would fall back to the descriptor's
+    // and build a different model set than the run asked for.
+    #[test]
+    fn an_empty_override_widens_a_descriptor_selection() {
+        let descriptor =
+            DbtDescriptor { select: vec!["tag:nightly".to_string()], ..Default::default() };
+        let cleared = Invocation {
+            args: [(
+                "select".to_string(),
+                serde_json::value::RawValue::from_string("[]".to_string()).unwrap(),
+            )]
+            .into_iter()
+            .collect(),
+            ..Default::default()
+        };
+        assert!(has_selection(&descriptor, &Invocation::default()).unwrap());
+        assert!(!has_selection(&descriptor, &cleared).unwrap());
+        // A wrong-typed override is refused rather than read as absent, which
+        // would silently run the descriptor's broader selection.
+        let malformed = Invocation {
+            args: [(
+                "select".to_string(),
+                serde_json::value::RawValue::from_string("\"stg_orders\"".to_string()).unwrap(),
+            )]
+            .into_iter()
+            .collect(),
+            ..Default::default()
+        };
+        assert!(has_selection(&descriptor, &malformed).is_err());
+    }
+
+    // Compared in two halves because resolution happens between them: the prefix
+    // is checkable up front, the digest only once the caller has re-resolved the
+    // saved arguments. Comparing the whole string up front refuses every retry,
+    // whose request carries only `dbt_command`.
+    #[test]
+    fn the_identity_splits_at_the_resolved_arguments() {
+        let (prefix, args) = split_identity("proj|wh|engine|deadbeef|args=c0ffee");
+        assert_eq!(prefix, "proj|wh|engine|deadbeef");
+        assert_eq!(args, Some("c0ffee"));
+        // Profile targets and other identity inputs are user-controlled. A
+        // literal `args=` inside one must stay in the identity prefix.
+        let (prefix, args) = split_identity("proj|target=blue|args=warehouse|deadbeef|args=c0ffee");
+        assert_eq!(prefix, "proj|target=blue|args=warehouse|deadbeef");
+        assert_eq!(args, Some("c0ffee"));
+        // A PRE-UPGRADE row, which ends in the env digest and has plenty of
+        // `|` in it. Splitting on the last one would take that digest for an
+        // arguments digest and make every saved failure unretryable.
+        let (prefix, args) = split_identity("proj|wh|engine|deadbeef");
+        assert_eq!(prefix, "proj|wh|engine|deadbeef");
+        assert_eq!(args, None);
+    }
+
+    #[test]
+    // dbt resolves `--selector` INSTEAD of `--select`, so a descriptor selector
+    // left on alongside an explicit selection makes the descriptor win: a preview
+    // of one model returns another's rows.
+    fn a_runs_own_selection_replaces_the_descriptor_selector() {
+        let descriptor =
+            DbtDescriptor { selector: Some("nightly".to_string()), ..Default::default() };
+        let selects = |v: &str| Invocation {
+            args: [(
+                "select".to_string(),
+                serde_json::value::RawValue::from_string(v.to_string()).unwrap(),
+            )]
+            .into_iter()
+            .collect(),
+            ..Default::default()
+        };
+        assert_eq!(
+            effective_selector(&descriptor, &Invocation::default()).unwrap(),
+            Some("nightly")
+        );
+        assert_eq!(
+            effective_selector(&descriptor, &selects(r#"["stg_orders"]"#)).unwrap(),
+            None
+        );
+        // The generated form posts the descriptor's own `[]` back for a field nobody
+        // touched, so that is not an override: reading it as one drops the selector
+        // from every UI, schedule and webhook run and builds the whole project.
+        // `["*"]` is how a run asks for that on purpose.
+        assert_eq!(
+            effective_selector(&descriptor, &selects("[]")).unwrap(),
+            Some("nightly")
+        );
+        assert!(has_selection(&descriptor, &selects("[]")).unwrap());
+        assert_eq!(
+            effective_selector(&descriptor, &selects(r#"["*"]"#)).unwrap(),
+            None
+        );
+    }
+
+    // A retry runs in a new job directory, and a profile with a private CA
+    // names that directory in `sslrootcert`. Hashing the rendered text as-is
+    // would make every such retry look like a different warehouse and reject
+    // its own predecessor's state.
+    #[test]
+    fn profile_identity_ignores_the_job_dir_but_not_the_connection() {
+        let yaml = |dir: &str, host: &str| {
+            format!("host: \"{host}\"\nsslrootcert: \"{dir}/server-ca.pem\"\n")
+        };
+        let first = profile_identity_digest(
+            &yaml("/tmp/windmill/w/job-1/profiles", "wh.internal"),
+            Path::new("/tmp/windmill/w/job-1/profiles"),
+            Some("PEM"),
+            "",
+        );
+        let retry = profile_identity_digest(
+            &yaml("/tmp/windmill/w/job-2/profiles", "wh.internal"),
+            Path::new("/tmp/windmill/w/job-2/profiles"),
+            Some("PEM"),
+            "",
+        );
+        assert_eq!(first, retry);
+
+        let repointed = profile_identity_digest(
+            &yaml("/tmp/windmill/w/job-2/profiles", "other.internal"),
+            Path::new("/tmp/windmill/w/job-2/profiles"),
+            Some("PEM"),
+            "",
+        );
+        let recerted = profile_identity_digest(
+            &yaml("/tmp/windmill/w/job-2/profiles", "wh.internal"),
+            Path::new("/tmp/windmill/w/job-2/profiles"),
+            Some("OTHER PEM"),
+            "",
+        );
+        assert_ne!(first, repointed);
+        assert_ne!(first, recerted);
+    }
+
+    // The warehouse's resource may interpolate `$WM_TOKEN`, so the rendered
+    // profile carries the ATTEMPT's token. A retry is a new job with a new one,
+    // and without normalizing it the saved run is never recognized as its own.
+    #[test]
+    fn profile_identity_ignores_the_attempts_token() {
+        let yaml = |tok: &str| format!("host: \"wh\"\npassword: \"{tok}\"\n");
+        let dir = Path::new("/tmp/windmill/w/job-1/profiles");
+        assert_eq!(
+            profile_identity_digest(&yaml("tok-first"), dir, None, "tok-first"),
+            profile_identity_digest(&yaml("tok-retry"), dir, None, "tok-retry")
+        );
+        // A password that is NOT the job's token is the connection, and changing
+        // it must still read as a different warehouse.
+        assert_ne!(
+            profile_identity_digest(&yaml("static-a"), dir, None, "tok-first"),
+            profile_identity_digest(&yaml("static-b"), dir, None, "tok-retry")
+        );
+    }
+
+    // The jail profile is protobuf text format, and the project path and the
+    // descriptor's environment land inside string literals. An unescaped quote or
+    // newline closes the literal and lets the rest be read as further directives —
+    // extra host bind mounts, for one.
+    #[test]
+    fn jail_values_cannot_close_their_string_and_add_directives() {
+        let hostile = "proj\"\nmount {\n src: \"/\"\n dst: \"/host\"\n}\n#";
+        let escaped = escape_textproto(hostile);
+        assert!(!escaped.contains('\n'), "{escaped}");
+        // Every quote that survives is escaped, so none of them terminates the
+        // literal.
+        let mut chars = escaped.chars().peekable();
+        let mut prev = None;
+        while let Some(c) = chars.next() {
+            if c == '"' {
+                assert_eq!(prev, Some('\\'), "unescaped quote in {escaped}");
+            }
+            // A doubled backslash is a literal one, so it does not escape what
+            // follows it.
+            prev = if c == '\\' && prev == Some('\\') {
+                None
+            } else {
+                Some(c)
+            };
+        }
+
+        let envars = jail_envars(&[("LD_PRELOAD".to_string(), hostile.to_string())]);
+        assert_eq!(envars.lines().count(), 1, "{envars}");
+        assert!(envars.starts_with("envar: \"LD_PRELOAD="), "{envars}");
+    }
+
+    // THREE sites derive a `dbt://` key: the manifest ingest, the live events and
+    // the end-of-run settlement. One deriving it differently records progress
+    // against a path no node has — the run still succeeds and the graph never
+    // moves. Nothing else catches that.
+    #[test]
+    fn all_three_key_derivations_agree() {
+        use windmill_common::dbt_manifest::{ingest_manifest, Manifest};
+        let manifest: Manifest = serde_json::from_str(
+            r#"{"nodes":{"model.p.customers":{
+                 "resource_type":"model","name":"customers","alias":"Customers",
+                 "schema":"Analytics","database":"Archive",
+                 "relation_name":"\"Archive\".\"Analytics\".\"Customers\""}}}"#,
+        )
+        .unwrap();
+        let ingested = ingest_manifest(&manifest, "f/prod/wh", Some("wh"), None);
+        let from_manifest = ingested.nodes[0].asset_path.clone().unwrap();
+
+        let relation = "\"Archive\".\"Analytics\".\"Customers\"";
+        let from_results = asset_path_of_relation(Some(relation), "f/prod/wh", Some("wh")).unwrap();
+        let live = r#"{"data":{"node_info":{"node_status":"success",
+            "node_relation":{"alias":"Customers","schema":"Analytics","database":"Archive",
+            "relation_name":"\"Archive\".\"Analytics\".\"Customers\""}}},
+            "info":{"name":"LogModelResult","msg":"ok"}}"#;
+        let from_events = parse_node_event(live, "f/prod/wh", Some("wh"))
+            .unwrap()
+            .asset_path;
+
+        // The model overrode its database, so all three must qualify.
+        assert_eq!(from_manifest, "f/prod/wh/archive.analytics/customers");
+        assert_eq!(from_results, from_manifest);
+        assert_eq!(from_events, from_manifest);
+
+        // And in the target's own database, all three drop it.
+        let plain = "\"wh\".\"Analytics\".\"Customers\"";
+        assert_eq!(
+            asset_path_of_relation(Some(plain), "f/prod/wh", Some("wh")).unwrap(),
+            "f/prod/wh/analytics/customers"
+        );
+        // A test node has no relation of its own.
+        assert_eq!(asset_path_of_relation(None, "f/prod/wh", Some("wh")), None);
+
+        // A period INSIDE a quoted identifier is part of the name. Splitting on
+        // every period yields four parts and discards the relation, so the model
+        // records no status at all — invisible except as a graph that never
+        // moves.
+        assert_eq!(
+            asset_path_of_relation(
+                Some("\"wh\".\"analytics.v2\".\"orders\""),
+                "f/prod/wh",
+                Some("wh")
+            ),
+            Some("f/prod/wh/analytics.v2/orders".to_string())
+        );
+        // A doubled delimiter is that delimiter, literally: the manifest keeps
+        // the real spelling, so dropping the pair here records the run's
+        // progress against a key no node has.
+        assert_eq!(
+            split_relation("\"wh\".\"schema\".\"a\"\"b\""),
+            vec!["wh", "schema", "a\"b"]
+        );
+        assert_eq!(
+            split_relation("[db].[my]]schema].[t]"),
+            vec!["db", "my]schema", "t"]
+        );
+    }
+
+    // dbt vars are typed and Jinja treats the string "false" as truthy, so a var
+    // that IS a placeholder carries the argument's own type through, while one
+    // embedded in text stays the string it interpolates to.
+    #[test]
+    fn placeholder_vars_keep_the_arguments_type() {
+        use windmill_parser_yaml::parse_dbt_descriptor;
+        let d = parse_dbt_descriptor(
+            "vars:\n  strict: \"{{ strict }}\"\n  n: \"{{ n }}\"\n  label: \"run-{{ name }}\"\n",
+        )
+        .unwrap();
+        let args: HashMap<String, Box<RawValue>> =
+            [("strict", "false"), ("n", "7"), ("name", "\"nightly\"")]
+                .into_iter()
+                .map(|(k, v)| (k.to_string(), RawValue::from_string(v.to_string()).unwrap()))
+                .collect();
+        let vars = resolved_vars(&d, &args, true).unwrap();
+        assert_eq!(vars["strict"], serde_json::json!(false));
+        assert_eq!(vars["n"], serde_json::json!(7));
+        assert_eq!(vars["label"], serde_json::json!("run-nightly"));
+    }
+
+    // The digest gates the retry state and keys the package cache, so a value
+    // that depends on map ordering would evict and reject on every run, and one
+    // that ignores content would let an edited project resume the previous
+    // attempt's failures against models it no longer builds.
+    #[test]
+    fn the_project_digest_is_content_addressed_and_order_free() {
+        use windmill_common::scripts::{ScriptLang, ScriptModule};
+        let m = |pairs: &[(&str, &str)]| {
+            pairs
+                .iter()
+                .map(|(k, v)| {
+                    (
+                        k.to_string(),
+                        ScriptModule {
+                            content: v.to_string(),
+                            language: ScriptLang::Dbt,
+                            lock: None,
+                        },
+                    )
+                })
+                .collect::<HashMap<_, _>>()
+        };
+        let a = m(&[("models/a.sql", "select 1"), ("dbt_project.yml", "name: p")]);
+        let b = m(&[("dbt_project.yml", "name: p"), ("models/a.sql", "select 1")]);
+        assert_eq!(project_digest(Some(&a)), project_digest(Some(&b)));
+        let edited = m(&[("models/a.sql", "select 2"), ("dbt_project.yml", "name: p")]);
+        assert_ne!(project_digest(Some(&a)), project_digest(Some(&edited)));
+        // A file renamed with the same body is a different project too: the
+        // separators keep `ab|c` from digesting the same as `a|bc`.
+        let renamed = m(&[("models/b.sql", "select 1"), ("dbt_project.yml", "name: p")]);
+        assert_ne!(project_digest(Some(&a)), project_digest(Some(&renamed)));
+    }
+
+    // A project that owns its `profiles.yml` has to spell its relations the way
+    // a workspace-warehouse project does, or the same physical table becomes two
+    // nodes — `main/analytics/orders` for one and `main/prod.analytics/orders`
+    // for the other — and the lineage they exist to share never connects.
+    #[tokio::test]
+    async fn a_project_owned_profile_reports_its_target_database() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("profiles.yml");
+        std::fs::write(
+            &path,
+            "jaffle:\n  target: prod\n  outputs:\n    prod:\n      type: snowflake\n\
+             \x20     database: prod\n      schema: analytics\n",
+        )
+        .unwrap();
+        let t = adapter_from_profiles_yml(&path, "jaffle", None)
+            .await
+            .unwrap();
+        assert_eq!(t.adapter, DbtAdapter::Snowflake);
+        assert_eq!(t.database.as_deref(), Some("prod"));
+        assert_eq!(t.schema.as_deref(), Some("analytics"));
+        // Spelled plainly, exactly as a rendered profile on the same relation.
+        assert_eq!(
+            windmill_common::dbt_manifest::table_asset_path(
+                "main",
+                Some("prod"),
+                "analytics",
+                "orders",
+                t.database.as_deref(),
+            )
+            .as_deref(),
+            Some("main/analytics/orders")
+        );
+    }
+
+    // dbt renders `profiles.yml` through Jinja; Windmill reads it raw. A repo that
+    // carries one profile across environments selects its target with `env_var`,
+    // and refusing that would refuse the unmodified-project path this exists for.
+    #[tokio::test]
+    async fn a_templated_target_takes_the_only_output() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("profiles.yml");
+        std::fs::write(
+            &path,
+            "jaffle:\n  target: \"{{ env_var('DBT_TARGET', 'prod') }}\"\n  outputs:\n\
+             \x20   prod:\n      type: snowflake\n      database: prod\n      schema: analytics\n",
+        )
+        .unwrap();
+        let t = adapter_from_profiles_yml(&path, "jaffle", None)
+            .await
+            .unwrap();
+        assert_eq!(t.adapter, DbtAdapter::Snowflake);
+        assert_eq!(t.database.as_deref(), Some("prod"));
+    }
+
+    // With several outputs the template names none of them, so the descriptor
+    // has to choose rather than Windmill guessing which environment to run.
+    #[tokio::test]
+    async fn a_templated_target_with_several_outputs_asks_for_one() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("profiles.yml");
+        std::fs::write(
+            &path,
+            "jaffle:\n  target: \"{{ env_var('DBT_TARGET') }}\"\n  outputs:\n\
+             \x20   prod:\n      type: snowflake\n    dev:\n      type: snowflake\n",
+        )
+        .unwrap();
+        let e = adapter_from_profiles_yml(&path, "jaffle", None)
+            .await
+            .unwrap_err()
+            .to_string();
+        assert!(e.contains("profile.target"), "{e}");
+    }
+
+    // A target that leaves its database to dbt's own defaults says nothing, and
+    // guessing one would collapse relations that are genuinely apart.
+    #[tokio::test]
+    async fn an_implicit_database_stays_unknown() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("profiles.yml");
+        std::fs::write(
+            &path,
+            "jaffle:\n  target: dev\n  outputs:\n    dev:\n      type: postgres\n\
+             \x20     dbname: \"{{ env_var('DB') }}\"\n",
+        )
+        .unwrap();
+        let t = adapter_from_profiles_yml(&path, "jaffle", None)
+            .await
+            .unwrap();
+        assert_eq!(t.database, None);
+    }
+
+    #[tokio::test]
+    async fn package_cache_identity_includes_the_resolved_lock() {
+        let dir = tempfile::tempdir().unwrap();
+        std::fs::write(
+            dir.path().join("package-lock.yml"),
+            "packages:\n  - package: dbt-labs/dbt_utils\n    version: 1.3.0\n",
+        )
+        .unwrap();
+        let first = package_lock_digest(dir.path()).await.unwrap().unwrap();
+        std::fs::write(
+            dir.path().join("package-lock.yml"),
+            "packages:\n  - package: dbt-labs/dbt_utils\n    version: 1.4.0\n",
+        )
+        .unwrap();
+        let second = package_lock_digest(dir.path()).await.unwrap().unwrap();
+
+        assert_ne!(first, second);
+        assert_ne!(
+            package_cache_key("same project and environment", &first),
+            package_cache_key("same project and environment", &second)
+        );
+    }
+
+    // The path is project-controlled and both cache copies are rooted at it, so
+    // an absolute or `..`-bearing value would read and write outside the job.
+    #[tokio::test]
+    async fn a_projects_packages_path_cannot_escape_the_project() {
+        let dir = tempfile::tempdir().unwrap();
+        let root = dir.path();
+        let write = |yml: &str| std::fs::write(root.join("dbt_project.yml"), yml).unwrap();
+        let none = HashMap::new();
+
+        write("name: p\n");
+        assert_eq!(
+            packages_install_path(root, &none).await.unwrap(),
+            "dbt_packages"
+        );
+        write("name: p\npackages-install-path: ./vendor\n");
+        assert_eq!(packages_install_path(root, &none).await.unwrap(), "vendor");
+        // Unset and empty are the default; an escaping one is refused rather
+        // than replaced, since dbt reads the file itself and would honour it.
+        write("name: p\npackages-install-path: \"\"\n");
+        assert_eq!(
+            packages_install_path(root, &none).await.unwrap(),
+            "dbt_packages"
+        );
+        for escape in ["/etc", "../../etc", "a/../../b"] {
+            write(&format!("name: p\npackages-install-path: \"{escape}\"\n"));
+            assert!(
+                packages_install_path(root, &none).await.is_err(),
+                "{escape} must not be honoured"
+            );
+        }
+        // An escaping value the ENVIRONMENT supplies is refused just the same:
+        // rendering happens before the check, not after it.
+        write("name: p\npackages-install-path: \"{{ env_var('D') }}\"\n");
+        let escaping = HashMap::from([("D".to_string(), "../out".to_string())]);
+        assert!(packages_install_path(root, &escaping).await.is_err());
+    }
+
+    // dbt renders `env_var()` in `dbt_project.yml`, so the profile it looks up
+    // and the directory `dbt deps` fills are the RENDERED ones. Reading the
+    // template instead leaves a project that runs everywhere else unable to find
+    // its profile, and its package cache watching a directory nothing fills.
+    #[tokio::test]
+    async fn a_projects_settings_are_rendered_with_the_runs_environment() {
+        let dir = tempfile::tempdir().unwrap();
+        let root = dir.path();
+        std::fs::write(
+            root.join("dbt_project.yml"),
+            "name: p\nprofile: \"{{ env_var('DBT_PROFILE', 'analytics') }}\"\n\
+             packages-install-path: \"{{ env_var('PKGS', 'vendor') }}\"\n",
+        )
+        .unwrap();
+
+        let none = HashMap::new();
+        assert_eq!(project_profile_name(root, &none).await, "analytics");
+        assert_eq!(packages_install_path(root, &none).await.unwrap(), "vendor");
+
+        let set = HashMap::from([
+            ("DBT_PROFILE".to_string(), "prod".to_string()),
+            ("PKGS".to_string(), "deps".to_string()),
+        ]);
+        assert_eq!(project_profile_name(root, &set).await, "prod");
+        assert_eq!(packages_install_path(root, &set).await.unwrap(), "deps");
+
+        // Neither set nor defaulted: left verbatim, so dbt reports it rather
+        // than Windmill inventing a name.
+        std::fs::write(
+            root.join("dbt_project.yml"),
+            "name: p\nprofile: \"{{ env_var('DBT_PROFILE') }}\"\n",
+        )
+        .unwrap();
+        assert_eq!(
+            project_profile_name(root, &none).await,
+            "{{ env_var('DBT_PROFILE') }}"
+        );
+    }
+
+    // A retry rewrites `run_results.json` with only the nodes it redid, so the
+    // job's own result has to be the union: replacing would drop every node that
+    // succeeded before it, and nothing would settle their materializations.
+    #[test]
+    fn a_retrys_results_overlay_the_attempt_they_resumed() {
+        let node = |id: &str, status: &str| DbtNodeResult {
+            outcome: classify_status(status).as_result_word(),
+            unique_id: id.to_string(),
+            status: status.to_string(),
+            execution_time: None,
+            rows_affected: None,
+            relation_name: None,
+            message: None,
+            failures: None,
+        };
+        let mut acc = vec![
+            node("model.p.a", "success"),
+            node("model.p.b", "error"),
+            node("model.p.c", "skipped"),
+        ];
+        merge_results(
+            &mut acc,
+            vec![node("model.p.b", "success"), node("model.p.c", "success")],
+        );
+        assert_eq!(acc.len(), 3, "the untouched node must survive the retry");
+        let by = |id: &str| acc.iter().find(|n| n.unique_id == id).unwrap();
+        assert_eq!(by("model.p.a").status, "success");
+        assert_eq!(by("model.p.b").status, "success");
+        assert_eq!(by("model.p.c").status, "success");
+        // A node the retry introduces is kept rather than dropped.
+        merge_results(&mut acc, vec![node("test.p.d", "fail")]);
+        assert_eq!(acc.len(), 4);
+    }
+
+    // `--limit` decides how much of dbt's stdout the worker buffers, and any
+    // caller who may run the script may set it.
+    #[test]
+    fn only_a_single_node_may_be_shown() {
+        // What the run page sends: one model, package-qualified.
+        assert!(show_selects_one_node("stg_orders,package:slow_shop"));
+        assert!(show_selects_one_node("stg_orders"));
+        // A union: the intersection would bind to `safe_model` alone, leaving
+        // `my_seed` selected — and a selected seed is LOADED, not shown.
+        assert!(!show_selects_one_node("my_seed safe_model"));
+        assert!(!show_selects_one_node("my_seed  safe_model,resource_type:model"));
+        // Resolve to a set rather than to one relation.
+        assert!(!show_selects_one_node("stg_orders+"));
+        assert!(!show_selects_one_node("+stg_orders"));
+        assert!(!show_selects_one_node("stg_*"));
+        assert!(!show_selects_one_node("@stg_orders"));
+    }
+
+    #[test]
+    fn a_show_limit_is_clamped_to_the_ceiling() {
+        let max = windmill_parser_yaml::dbt::DBT_SHOW_MAX_LIMIT as i64;
+        let default = windmill_parser_yaml::dbt::DBT_SHOW_DEFAULT_LIMIT as i64;
+        assert_eq!(show_limit(Some(i64::MAX)), max, "an enormous ask is capped");
+        assert_eq!(show_limit(Some(max + 1)), max);
+        assert_eq!(show_limit(Some(5)), 5, "a modest ask is honoured");
+        assert_eq!(show_limit(None), default);
+        // `--limit 0` means something else to dbt, and a negative is nonsense.
+        assert_eq!(show_limit(Some(0)), default);
+        assert_eq!(show_limit(Some(-1)), default);
+    }
+
+    // The loop this feeds is bounded by nothing else: stop spending the budget
+    // and a failing job reissues `dbt retry` until its deadline.
+    #[test]
+    fn an_attempt_is_claimed_from_the_budget_exactly_once() {
+        let mut remaining = 3;
+        let mut claimed = vec![];
+        // Bounded by this `for`, never by `claim_attempt`: a regression that
+        // stops spending the budget has to fail an assertion here, and must not
+        // be able to allocate until the machine dies. `from_fn(..).collect()`
+        // would do the latter.
+        for _ in 0..10 {
+            match claim_attempt(&mut remaining, 3) {
+                Some(n) => claimed.push(n),
+                None => break,
+            }
+        }
+        assert_eq!(claimed, vec![1, 2, 3], "numbered in order, one per attempt");
+        assert_eq!(remaining, 0);
+        assert_eq!(
+            claim_attempt(&mut remaining, 3),
+            None,
+            "a spent budget grants no more"
+        );
+        let mut none = 0;
+        assert_eq!(claim_attempt(&mut none, 0), None);
+    }
+
+    // A second `dbt test` after a tests-only retry runs every test twice and
+    // reports each one twice — duplicate ids in the result table, doubled totals.
+    #[test]
+    fn merging_two_phases_keeps_one_row_per_node() {
+        let n = |id: &str, status: &str| DbtNodeResult {
+            outcome: classify_status(status).as_result_word(),
+            unique_id: id.to_string(),
+            status: status.to_string(),
+            execution_time: None,
+            rows_affected: None,
+            relation_name: None,
+            message: None,
+            failures: None,
+        };
+        let mut results = vec![n("model.p.m", "success"), n("test.p.t", "fail")];
+        // The test phase re-reports the same test, now passing.
+        merge_results(&mut results, vec![n("test.p.t", "pass")]);
+        assert_eq!(results.len(), 2, "a node re-reported must not duplicate");
+        assert_eq!(
+            results
+                .iter()
+                .find(|r| r.unique_id == "test.p.t")
+                .unwrap()
+                .status,
+            "pass",
+            "the later phase's outcome wins"
+        );
+    }
+
+    // `partial success` is a node that built and then failed its tests. Read as
+    // "says nothing about the relation", it left the model on `Running` — the
+    // tailer writes that when the node starts and nothing after it moves the
+    // record, so a finished job showed a model still building.
+    #[test]
+    fn partial_success_settles_the_relation_as_failed() {
+        assert_eq!(classify_status("partial success"), DbtNodeOutcome::Failed);
+        // The engines disagree on casing: 1.x echoes the author's, 2.x
+        // uppercases. Every classifier folds, or they disagree with each other.
+        for spelling in ["PARTIAL SUCCESS", " Partial Success ", "ERROR", "Pass"] {
+            assert_ne!(
+                classify_status(spelling),
+                DbtNodeOutcome::Unknown,
+                "{spelling} must classify"
+            );
+        }
+        assert_eq!(classify_status("success"), DbtNodeOutcome::Passed);
+        assert_eq!(classify_status("started"), DbtNodeOutcome::Started);
+        assert_eq!(classify_status("warn"), DbtNodeOutcome::Warn);
+        assert_eq!(classify_status("skipped"), DbtNodeOutcome::Skipped);
+        // `no-op` is not `skipped`: nothing was built either way, but dbt's
+        // retry set is error / fail / skipped, so a retry must not redo it.
+        assert_eq!(classify_status("no-op"), DbtNodeOutcome::NoOp);
+    }
+
+    #[test]
+    fn a_retry_needs_something_to_retry() {
+        let results = |statuses: &[&str]| {
+            format!(
+                r#"{{"results":[{}]}}"#,
+                statuses
+                    .iter()
+                    .map(|s| format!(r#"{{"unique_id":"model.p.m","status":"{s}"}}"#))
+                    .collect::<Vec<_>>()
+                    .join(",")
+            )
+        };
+        assert!(!has_retryable_node(&results(&["success"])));
+        assert!(!has_retryable_node(&results(&["success", "pass"])));
+        assert!(!has_retryable_node(r#"{"results":[]}"#));
+        for retryable in ["error", "fail", "skipped", "partial success"] {
+            assert!(
+                has_retryable_node(&results(&["success", retryable])),
+                "{retryable} must be retryable"
+            );
+        }
+        // Failed TESTS alone are retryable: `test_behavior: after_all` is exactly
+        // how `run_results.json` comes to describe tests alone.
+        let tests_only = r#"{"results":[
+            {"unique_id":"test.p.not_null_orders_id.ab","status":"fail"},
+            {"unique_id":"test.p.unique_orders_id.cd","status":"error"}]}"#;
+        assert!(has_retryable_node(tests_only));
+        // A passing test-only run still has nothing to retry.
+        let tests_passed = r#"{"results":[
+            {"unique_id":"test.p.not_null_orders_id.ab","status":"pass"}]}"#;
+        assert!(!has_retryable_node(tests_passed));
+        // Unreadable results let dbt decide rather than refusing a retry the
+        // user may well need.
+        assert!(has_retryable_node("not json"));
+    }
+
+    /// An interrupted BUILD leaves the warehouse in a state the previous run's
+    /// failures no longer describe, so that state has to go — including its local
+    /// generation, which a retry landing back on this worker reads first.
+    #[tokio::test]
+    async fn invalidating_run_state_drops_the_local_generation() {
+        let dir = state_dir("ws", "f/a/one", "u/alice");
+        tokio::fs::create_dir_all(&dir).await.unwrap();
+        tokio::fs::write(dir.join(CURRENT_GENERATION), b"gen-old")
+            .await
+            .unwrap();
+
+        let http = Connection::Http(windmill_common::worker::HttpClient {
+            client: reqwest_middleware::ClientBuilder::new(reqwest::Client::new()).build(),
+            base_internal_url: String::new(),
+        });
+        invalidate_run_state("ws", "f/a/one", "u/alice", &http).await;
+
+        assert!(
+            !dir.join(CURRENT_GENERATION).exists(),
+            "the pointer a retry reads must be gone"
+        );
+    }
+
+    /// The tailer runs in the WORKER process, outside the jailed child's memory
+    /// limit, and a dbt macro decides how long a log line is. An unbounded line
+    /// must be dropped rather than held, and the events after it must still
+    /// arrive — a tailer that stops reporting is a run with a blank graph.
+    #[test]
+    fn an_oversized_log_line_is_dropped_without_stopping_the_tailer() {
+        let mut tail = LogTail::default();
+        let event = |name: &str| format!(r#"{{"info":{{"name":"{name}"}}}}"#);
+
+        // A line split across reads is reassembled, not dropped.
+        assert_eq!(tail.push("{\"a\":1"), "");
+        assert_eq!(tail.push(",\"b\":2}\n"), "{\"a\":1,\"b\":2}\n");
+
+        // One that never ends is discarded, in bounded memory, ...
+        let huge = "x".repeat(LOG_LINE_MAX_BYTES / 2 + 1);
+        assert_eq!(tail.push(&huge), "");
+        assert_eq!(tail.push(&huge), "");
+        assert!(tail.carry.is_empty(), "the over-long line is not held");
+        assert_eq!(tail.push(&huge), "", "still inside that line");
+
+        // ... through its end, after which the next events come through.
+        let resumed = tail.push(&format!("tail-of-the-huge-line\n{}\n", event("ok")));
+        assert_eq!(resumed, format!("{}\n", event("ok")));
+        assert_eq!(
+            tail.push(&format!("{}\n", event("next"))),
+            format!("{}\n", event("next"))
+        );
+    }
+
+    /// A command block that names nothing must not read as "no command given":
+    /// that is the descriptor's default, so a mistyped `show` would BUILD the
+    /// project — the one direction a read-only command must never fail in.
+    /// Argument-schema validation is opt-in, so this is the only check between a
+    /// direct request and the engine.
+    #[test]
+    fn a_command_block_that_names_no_command_is_refused() {
+        let args = |json: &str| {
+            serde_json::from_str::<HashMap<String, Box<RawValue>>>(json).expect("test payload")
+        };
+        for payload in [
+            r#"{"command": "show"}"#,
+            r#"{"command": {}}"#,
+            r#"{"command": {"select": ["a"]}}"#,
+            r#"{"command": {"label": null}}"#,
+            r#"{"command": {"label": ""}}"#,
+            r#"{"command": []}"#,
+        ] {
+            let err = flatten_command(args(payload))
+                .expect_err("a block naming no command must not fall back to the default");
+            assert!(
+                err.to_string().contains("naming what to run"),
+                "{payload}: {err}"
+            );
+        }
+        // Absent and `null` both mean "the descriptor's own command", which is
+        // what an empty run submits.
+        for payload in ["{}", r#"{"command": null}"#] {
+            let out = flatten_command(args(payload)).expect(payload);
+            assert!(!out.contains_key("dbt_command"), "{payload}");
+        }
+        // A named one spreads, its label under the name every reader uses.
+        let out = flatten_command(args(r#"{"command": {"label": "show", "limit": 3}}"#)).unwrap();
+        assert_eq!(
+            arg_str(&out, "dbt_command").unwrap().as_deref(),
+            Some("show")
+        );
+        assert_eq!(arg_i64(&out, "limit").unwrap(), Some(3));
+        assert!(!out.contains_key(DBT_COMMAND_ARG));
+        // The variant's label decides, not map iteration order: a block carrying a
+        // `dbt_command` of its own lands on the same key.
+        let both = flatten_command(args(
+            r#"{"command": {"label": "show", "dbt_command": "build"}}"#,
+        ))
+        .unwrap();
+        assert_eq!(
+            arg_str(&both, "dbt_command").unwrap().as_deref(),
+            Some("show")
+        );
+    }
+
+    /// An agent reaches no database, so the row that answers "is this the run you
+    /// asked to resume" is not there — only the generation the worker itself
+    /// wrote. Unchecked, a retry naming one failed run resumes whichever failed
+    /// last on that worker, which is what the run page's two retry actions would
+    /// otherwise do from any older run.
+    #[test]
+    fn an_agent_refuses_a_generation_the_caller_did_not_name() {
+        let http = Connection::Http(windmill_common::worker::HttpClient {
+            client: reqwest_middleware::ClientBuilder::new(reqwest::Client::new()).build(),
+            base_internal_url: String::new(),
+        });
+        let saved = uuid::Uuid::new_v4();
+        let asked_for = uuid::Uuid::new_v4();
+        let local = || Some(format!("gen-{saved}"));
+
+        let err = chosen_generation(local(), &http, None, asked_for)
+            .expect_err("a generation the caller did not name must not be resumed");
+        assert!(
+            err.to_string().contains(&saved.to_string())
+                && err.to_string().contains(&asked_for.to_string()),
+            "the refusal names both the run asked for and the one held, got: {err}"
+        );
+
+        assert_eq!(
+            chosen_generation(local(), &http, None, saved).unwrap(),
+            local(),
+            "the run it does hold still resumes"
+        );
+    }
+
+    /// Why a run re-ingests decides what becomes of the result. Drift is the one
+    /// that MUST publish: the check reads back the published root, so a drifted
+    /// run that only snapshots leaves the next run detecting the same move, and
+    /// the asset rows naming the schema the project no longer builds into.
+    #[test]
+    fn what_a_refresh_publishes_depends_on_why_it_happened() {
+        let job = uuid::Uuid::new_v4();
+        let arg = |k: &str, v: &str| {
+            HashMap::from([(k.to_string(), RawValue::from_string(v.to_string()).unwrap())])
+        };
+        let descriptor = DbtDescriptor::default();
+
+        // A moved profile relocates the VERSION's relations: its own graph, and
+        // the ownership that answers the next drift check.
+        let drift = GraphRefresh { profile_drift: true, ..Default::default() };
+        assert!(drift.needed());
+        assert_eq!(drift.snapshot_job(job), None);
+        assert!(drift.publishes_ownership());
+
+        // A dynamic descriptor: this run's graph, under its own job id — and
+        // nothing published, because the `asset` rows and the version's nodes
+        // must describe one picture, and the version's are the deploy's.
+        let dynamic = GraphRefresh { per_run_models: true, ..Default::default() };
+        assert_eq!(dynamic.snapshot_job(job), Some(job));
+        assert!(!dynamic.publishes_ownership());
+
+        // A `vars` override: this run's graph, and only this run's.
+        let mut overridden = GraphRefresh::default();
+        overridden
+            .add_caller_args(&descriptor, &arg("vars", r#"{"day":"2026-07-29"}"#))
+            .unwrap();
+        assert!(overridden.needed());
+        assert_eq!(overridden.snapshot_job(job), Some(job));
+        assert!(!overridden.publishes_ownership());
+
+        // A caller's selection is not necessarily a subset of the deployed one —
+        // `["*"]` against `tag:nightly` builds models the deployed graph never had,
+        // which the run page would have nothing to draw. Under its own job id, so it
+        // neither becomes what the script owns nor replaces the version's graph.
+        let mut narrowed = GraphRefresh::default();
+        narrowed
+            .add_caller_args(&descriptor, &arg("select", r#"["stg_orders"]"#))
+            .unwrap();
+        assert!(narrowed.needed());
+        assert_eq!(narrowed.snapshot_job(job), Some(job));
+        assert!(!narrowed.publishes_ownership());
+
+        // The form posts the descriptor's own `select` back for every UI, schedule
+        // and webhook run. Reading that echo as a narrowing marks all of them
+        // caller-scoped, leaving a moved profile no run that could republish: it
+        // re-detects the same drift, and pays a `dbt parse` for it, forever.
+        let echoed =
+            DbtDescriptor { select: vec!["tag:nightly".to_string()], ..Default::default() };
+        let mut untouched = GraphRefresh { profile_drift: true, ..Default::default() };
+        untouched
+            .add_caller_args(&echoed, &arg("select", r#"["tag:nightly"]"#))
+            .unwrap();
+        assert!(untouched.publishes_ownership());
+        assert_eq!(untouched.snapshot_job(job), None);
+    }
+
+    // `dbt retry` restores the previous run's target/ from this directory, so two
+    // dbt scripts must not share one — a retry would resume another project's
+    // `run_results.json`, which an empty script_path is exactly how it happened.
+    #[test]
+    fn retry_state_is_per_script_and_principal() {
+        assert_ne!(
+            state_dir("ws", "f/a/one", "u"),
+            state_dir("ws", "f/a/two", "u")
+        );
+        assert_ne!(
+            state_dir("ws1", "f/a/one", "u"),
+            state_dir("ws2", "f/a/one", "u")
+        );
+        assert_eq!(
+            state_dir("ws", "f/a/one", "u"),
+            state_dir("ws", "f/a/one", "u")
+        );
+        // A retry replaces the caller's arguments with the saved ones, and an
+        // agent worker has no database row to fall back on: this separation is
+        // the only thing keeping one principal's `select`/`vars` from another.
+        assert_ne!(
+            state_dir("ws", "f/a/one", "u/alice"),
+            state_dir("ws", "f/a/one", "u/bob")
+        );
+    }
+
+    #[test]
+    fn events_without_a_relation_are_not_materializations() {
+        // A test node has no relation of its own.
+        let t = r#"{"data":{"node_info":{"node_status":"pass",
+            "node_relation":{"alias":"unique_c","schema":"a_audit","relation_name":""}}},
+            "info":{"name":"LogTestResult","msg":"ok"}}"#;
+        assert!(parse_node_event(t, "f/prod/wh", Some("wh")).is_none());
+        assert!(parse_node_event("Running with dbt=1.12.0", "f/prod/wh", Some("wh")).is_none());
+        // `skipped` says nothing about the relation's state.
+        let s = r#"{"data":{"node_info":{"node_status":"skipped",
+            "node_relation":{"alias":"c","schema":"a","relation_name":"\"w\".\"a\".\"c\""}}},
+            "info":{"name":"LogModelResult","msg":"skip"}}"#;
+        assert!(parse_node_event(s, "f/prod/wh", Some("wh")).is_none());
+    }
+}
diff --git a/backend/windmill-worker/src/dbt_profiles.rs b/backend/windmill-worker/src/dbt_profiles.rs
new file mode 100644
index 0000000000..3026779f06
--- /dev/null
+++ b/backend/windmill-worker/src/dbt_profiles.rs
@@ -0,0 +1,908 @@
+//! Rendering a `profiles.yml` from a Windmill warehouse resource, and the
+//! adapter package each warehouse needs.
+//!
+//! Only the fields dbt actually reads are emitted; anything the resource
+//! carries for other runtimes is ignored rather than guessed at. Credentials
+//! are written into the job dir, which is torn down with the job.
+
+use serde_json::Value;
+use windmill_common::error::{self, Error};
+
+/// Written beside `profiles.yml`, and named absolutely in `sslrootcert`: dbt
+/// runs with the project as its working directory and hands the path to the
+/// driver unchanged.
+pub const ROOT_CERT_FILENAME: &str = "server-ca.pem";
+
+/// The per-adapter facts, so each adapter states them together and a new one
+/// cannot inherit another's by omission. `PG` is the base every arm spreads
+/// from: most adapters differ from Postgres only in their name and package.
+struct AdapterSpec {
+    /// As a user would write it, for error messages.
+    name: &'static str,
+    /// dbt's own `type:` key in `profiles.yml`.
+    dbt_type: &'static str,
+    /// The dbt-core 1.x pip package; empty when the adapter is Fusion-only.
+    pip_package: &'static str,
+    default_port: i64,
+    database_key: &'static str,
+    requires_enterprise: bool,
+    /// Overrides `dbt_type` in the licensing error, where the product's own
+    /// spelling reads better than dbt's driver name.
+    display_name: Option<&'static str>,
+}
+
+impl AdapterSpec {
+    const PG: AdapterSpec = AdapterSpec {
+        name: "postgres",
+        dbt_type: "postgres",
+        pip_package: "dbt-postgres",
+        default_port: 5432,
+        database_key: "dbname",
+        requires_enterprise: false,
+        display_name: None,
+    };
+}
+
+/// The dbt adapter a Windmill resource type maps to (decision 9). The resource
+/// type name is the authority — connection details are never sniffed.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DbtAdapter {
+    Postgres,
+    Redshift,
+    Mysql,
+    Duckdb,
+    Clickhouse,
+    Snowflake,
+    Bigquery,
+    Databricks,
+    Salesforce,
+    Mssql,
+    OracleDB,
+}
+
+impl DbtAdapter {
+    pub fn from_resource_type(rt: &str) -> Option<Self> {
+        match rt {
+            "postgresql" | "postgres" => Some(DbtAdapter::Postgres),
+            "redshift" => Some(DbtAdapter::Redshift),
+            "mysql" => Some(DbtAdapter::Mysql),
+            "duckdb" => Some(DbtAdapter::Duckdb),
+            "clickhouse" => Some(DbtAdapter::Clickhouse),
+            "snowflake" | "snowflake_oauth" => Some(DbtAdapter::Snowflake),
+            "bigquery" | "gcp_service_account" => Some(DbtAdapter::Bigquery),
+            "databricks" => Some(DbtAdapter::Databricks),
+            "salesforce" => Some(DbtAdapter::Salesforce),
+            "ms_sql_server" | "mssql" | "sqlserver" | "fabric" => Some(DbtAdapter::Mssql),
+            "oracledb" | "oracle" => Some(DbtAdapter::OracleDB),
+            _ => None,
+        }
+    }
+
+    /// Everything that differs per adapter, in one place.
+    ///
+    /// Adding a warehouse is one arm here, and the match is exhaustive so the
+    /// compiler demands it. Spread across a method each, two of them carried a
+    /// `_ =>` default, so a new adapter silently inherited port 5432 and
+    /// `dbname` instead of failing to build.
+    fn spec(&self) -> &'static AdapterSpec {
+        match self {
+            DbtAdapter::Postgres => &AdapterSpec::PG,
+            DbtAdapter::Redshift => &AdapterSpec {
+                name: "redshift",
+                dbt_type: "redshift",
+                pip_package: "dbt-redshift",
+                default_port: 5439,
+                ..AdapterSpec::PG
+            },
+            DbtAdapter::Mysql => &AdapterSpec {
+                name: "mysql",
+                dbt_type: "mysql",
+                pip_package: "dbt-mysql",
+                default_port: 3306,
+                database_key: "schema",
+                ..AdapterSpec::PG
+            },
+            DbtAdapter::Duckdb => &AdapterSpec {
+                name: "duckdb",
+                dbt_type: "duckdb",
+                pip_package: "dbt-duckdb",
+                ..AdapterSpec::PG
+            },
+            DbtAdapter::Clickhouse => &AdapterSpec {
+                name: "clickhouse",
+                dbt_type: "clickhouse",
+                pip_package: "dbt-clickhouse",
+                ..AdapterSpec::PG
+            },
+            DbtAdapter::Snowflake => &AdapterSpec {
+                name: "snowflake",
+                dbt_type: "snowflake",
+                pip_package: "dbt-snowflake",
+                ..AdapterSpec::PG
+            },
+            DbtAdapter::Bigquery => &AdapterSpec {
+                name: "bigquery",
+                dbt_type: "bigquery",
+                pip_package: "dbt-bigquery",
+                ..AdapterSpec::PG
+            },
+            DbtAdapter::Databricks => &AdapterSpec {
+                name: "databricks",
+                dbt_type: "databricks",
+                pip_package: "dbt-databricks",
+                ..AdapterSpec::PG
+            },
+            // No dbt-core 1.x package exists for it; Fusion has it built in, and
+            // `provision_core_1x` refuses it by name rather than asking uv to
+            // install `""`. Pinned by
+            // `every_adapter_either_names_a_package_or_is_fusion_only`.
+            DbtAdapter::Salesforce => &AdapterSpec {
+                name: "salesforce",
+                dbt_type: "salesforce",
+                pip_package: "",
+                ..AdapterSpec::PG
+            },
+            DbtAdapter::Mssql => &AdapterSpec {
+                name: "mssql",
+                dbt_type: "sqlserver",
+                pip_package: "dbt-sqlserver",
+                requires_enterprise: true,
+                display_name: Some("Microsoft SQL server"),
+                ..AdapterSpec::PG
+            },
+            DbtAdapter::OracleDB => &AdapterSpec {
+                name: "oracle",
+                dbt_type: "oracle",
+                pip_package: "dbt-oracle",
+                requires_enterprise: true,
+                display_name: Some("Oracle DB"),
+                ..AdapterSpec::PG
+            },
+        }
+    }
+
+    /// Every adapter, for the tests that must cover all of them. The one list
+    /// there is: a second would be the thing that goes stale. Test-only, so a
+    /// release build does not carry a table nothing reads.
+    #[cfg(test)]
+    pub const ALL: &'static [DbtAdapter] = &[
+        DbtAdapter::Postgres,
+        DbtAdapter::Redshift,
+        DbtAdapter::Mysql,
+        DbtAdapter::Duckdb,
+        DbtAdapter::Clickhouse,
+        DbtAdapter::Snowflake,
+        DbtAdapter::Bigquery,
+        DbtAdapter::Databricks,
+        DbtAdapter::Salesforce,
+        DbtAdapter::Mssql,
+        DbtAdapter::OracleDB,
+    ];
+
+    /// Which dbt driver a resource needs, from the fields it carries — a
+    /// fallback for when the descriptor omits `profile.type`. It picks the
+    /// adapter only; asset identity is always the workspace warehouse's name,
+    /// never anything read here.
+    ///
+    /// Deliberately conservative about the host/port shapes. Windmill's
+    /// `ms_sql_server` and `oracledb` resources carry the same `host` +
+    /// `dbname`/`database` fields Postgres does, so a shape check cannot tell
+    /// them apart — and guessing Postgres for a SQL Server resource would
+    /// connect dbt-postgres to port 1433 instead of producing the licensing
+    /// error this design exists to give. So a bare host/database resource is
+    /// only Postgres when it carries something Postgres-specific, and is
+    /// otherwise `None`, which asks the user for `profile.type`.
+    pub fn infer_from_resource(v: &Value) -> Option<Self> {
+        let has = |k: &str| v.get(k).is_some_and(|x| !x.is_null());
+        if has("account_identifier") || has("warehouse") {
+            Some(DbtAdapter::Snowflake)
+        } else if has("http_path") {
+            Some(DbtAdapter::Databricks)
+        } else if has("project_id") && has("client_email") {
+            Some(DbtAdapter::Bigquery)
+        } else if has("dbname") && has("host") && (has("sslmode") || has("root_certificate_pem")) {
+            Some(DbtAdapter::Postgres)
+        } else {
+            None
+        }
+    }
+
+    /// dbt's own `type:` key in `profiles.yml`.
+    pub fn dbt_type(&self) -> &'static str {
+        self.spec().dbt_type
+    }
+
+    /// The adapter's name as a user would write it, for error messages.
+    pub fn name(&self) -> &'static str {
+        self.spec().name
+    }
+
+    /// The pip package providing this adapter for the dbt-core 1.x engine,
+    /// whose venv is provisioned on first use. The Rust engines ship their
+    /// adapters in the binary and never consult this. Empty means no such
+    /// package exists.
+    pub fn pip_package(&self) -> &'static str {
+        self.spec().pip_package
+    }
+
+    /// Only meaningful for the host/port adapters rendered from a resource.
+    fn default_port(&self) -> i64 {
+        self.spec().default_port
+    }
+
+    /// dbt spells the database differently per adapter.
+    fn database_key(&self) -> &'static str {
+        self.spec().database_key
+    }
+
+    /// The keys a target block spells its database and schema with, mirroring
+    /// what `render_profile` emits below.
+    ///
+    /// Read back when the PROJECT owns its `profiles.yml`. Windmill did not
+    /// write that file, but it still needs the target's database to spell
+    /// `dbt://` paths the way a rendered profile does: without it every relation
+    /// qualifies as `<db>.<schema>` while a workspace-warehouse project spells
+    /// the same table plainly, and the two never share a node.
+    pub fn target_identity_keys(&self) -> (&'static str, &'static str) {
+        match self {
+            DbtAdapter::Snowflake => ("database", "schema"),
+            DbtAdapter::Bigquery => ("project", "dataset"),
+            DbtAdapter::Databricks => ("catalog", "schema"),
+            _ => (self.database_key(), "schema"),
+        }
+    }
+
+    /// Whether this adapter needs an enterprise license.
+    ///
+    /// The boundary is not invented for dbt: it mirrors the two native script
+    /// languages that are still enterprise-gated. Every other warehouse dbt can
+    /// reach has a CE `ScriptLang`, so gating its dbt adapter would be stricter
+    /// than running the same query natively.
+    pub fn requires_enterprise(&self) -> bool {
+        self.spec().requires_enterprise
+    }
+
+    /// The name used in the licensing error, matching how the native languages
+    /// name themselves.
+    fn display_name(&self) -> &'static str {
+        let spec = self.spec();
+        spec.display_name.unwrap_or(spec.dbt_type)
+    }
+}
+
+/// Whether this build may use the enterprise-only adapters.
+///
+/// Two conditions, both required. `LICENSE_KEY_VALID` alone is not enough: the
+/// OSS variant of `ee_oss` initializes it to `true`, so reading it on a CE
+/// build would wave everything through. The `cfg` establishes it is an
+/// enterprise build; the atomic then reports whether that build's key actually
+/// verified.
+fn enterprise_licensed() -> bool {
+    #[cfg(feature = "enterprise")]
+    {
+        windmill_common::ee_oss::LICENSE_KEY_VALID.load(std::sync::atomic::Ordering::Relaxed)
+    }
+    #[cfg(not(feature = "enterprise"))]
+    {
+        false
+    }
+}
+
+/// Reject an enterprise-only adapter on an unlicensed build.
+///
+/// Unlike the native languages, this cannot be a compile-time gate: there is
+/// one dbt executor and the adapter is only known once the profile resolves. So
+/// it is checked at both deploy and run — and it says so plainly, rather than
+/// letting the run fail later with a connection error the user cannot act on.
+pub fn ensure_adapter_licensed(adapter: DbtAdapter) -> error::Result<()> {
+    if adapter.requires_enterprise() && !enterprise_licensed() {
+        return Err(Error::BadRequest(format!(
+            "{} is only available with an enterprise license",
+            adapter.display_name()
+        )));
+    }
+    Ok(())
+}
+
+fn s(v: &Value, k: &str) -> Option<String> {
+    v.get(k)
+        .and_then(|x| x.as_str())
+        .map(|x| x.to_string())
+        .filter(|x| !x.is_empty())
+}
+
+/// A resource's port, which may arrive as a JSON number or as a string —
+/// resources are user-supplied JSON and nothing coerces the field. Reading only
+/// `as_i64` sent `"5433"` to the adapter default, which connects to whatever
+/// listens there and reports nothing; a value that is present but not a port is
+/// refused rather than replaced.
+fn port_of(resource: &Value, default: i64) -> error::Result<i64> {
+    let bad = |v: &Value| {
+        Error::BadRequest(format!(
+            "resource `port` must be a number, got `{v}`; correct the resource"
+        ))
+    };
+    match resource.get("port") {
+        None | Some(Value::Null) => Ok(default),
+        Some(Value::Number(n)) => n.as_i64().ok_or_else(|| bad(&Value::Number(n.clone()))),
+        Some(Value::String(s)) if s.trim().is_empty() => Ok(default),
+        Some(Value::String(s)) => s
+            .trim()
+            .parse::<i64>()
+            .map_err(|_| bad(&Value::String(s.clone()))),
+        Some(other) => Err(bad(other)),
+    }
+}
+
+/// The rendered `profiles.yml` body plus the `(schema, database)` the target
+/// resolves to. The caller needs those two to spell the `dbt://` asset paths
+/// of models that do not override them.
+#[derive(Debug)]
+pub struct RenderedProfile {
+    pub yaml: String,
+    pub schema: Option<String>,
+    pub database: Option<String>,
+    /// A private CA the caller must write next to `profiles.yml`, under the
+    /// file name `sslrootcert` already points at. Returned rather than written
+    /// here so this stays a pure renderer.
+    pub root_certificate_pem: Option<String>,
+}
+
+/// Render a single-target `profiles.yml` for `profile_name`/`target`.
+///
+/// `threads` is the descriptor's, defaulted by dbt when absent. `schema` comes
+/// from the descriptor when set, else from the resource, else from dbt's own
+/// per-adapter default — dbt errors out clearly when it ends up missing, which
+/// is a better failure than a Windmill-invented default.
+pub fn render_profile(
+    adapter: DbtAdapter,
+    resource: &Value,
+    profile_name: &str,
+    target: &str,
+    threads: Option<u32>,
+    schema_override: Option<&str>,
+    // Where `profiles.yml` (and any root certificate) is written. dbt runs with
+    // the PROJECT as its working directory and hands `sslrootcert` to the
+    // driver unchanged, so a path relative to the profiles dir would be
+    // resolved against the project and never found.
+    profiles_dir: &std::path::Path,
+) -> error::Result<RenderedProfile> {
+    let mut out: Vec<(String, ProfileValue)> = vec![("type".into(), quoted(adapter.dbt_type()))];
+    let mut schema = schema_override.map(|x| x.to_string());
+    let database;
+
+    match adapter {
+        // Redshift and MySQL take the same host/port/user/password/database
+        // shape as Postgres in both dbt and Windmill's resource types, so one
+        // arm renders all three; only the default port and the database key
+        // differ.
+        DbtAdapter::Postgres | DbtAdapter::Redshift | DbtAdapter::Mysql => {
+            let host = s(resource, "host").ok_or_else(|| {
+                Error::BadRequest(format!("{} resource has no `host`", adapter.dbt_type()))
+            })?;
+            let dbname = s(resource, "dbname")
+                .or_else(|| s(resource, "database"))
+                .or_else(|| s(resource, "service_name"))
+                .ok_or_else(|| {
+                    Error::BadRequest(format!(
+                        "{} resource has no `dbname`/`database`",
+                        adapter.dbt_type()
+                    ))
+                })?;
+            out.push(("host".into(), quoted(&host)));
+            out.push((
+                "port".into(),
+                // dbt validates `port` against a JSON schema that demands an
+                // integer; a quoted scalar is rejected outright.
+                ProfileValue::Number(port_of(resource, adapter.default_port())?),
+            ));
+            out.push((adapter.database_key().into(), quoted(&dbname)));
+            database = Some(dbname.clone());
+            if let Some(u) = s(resource, "user") {
+                out.push(("user".into(), quoted(&u)));
+            }
+            if let Some(p) = s(resource, "password") {
+                out.push(("password".into(), quoted(&p)));
+            }
+            if let Some(m) = s(resource, "sslmode") {
+                out.push(("sslmode".into(), quoted(&m)));
+            }
+            // Under `verify-ca`/`verify-full` a resource's private CA is the
+            // only way the connection can succeed; without it libpq looks for a
+            // default certificate that is not there, and the same field is what
+            // identifies the resource as Postgres in the first place.
+            if s(resource, "root_certificate_pem").is_some() {
+                out.push((
+                    "sslrootcert".into(),
+                    quoted(&profiles_dir.join(ROOT_CERT_FILENAME).to_string_lossy()),
+                ));
+            }
+            schema = match adapter {
+                // Already emitted as the database key; reported back so the
+                // caller can spell `dbt://` paths with it.
+                DbtAdapter::Mysql => Some(dbname.clone()),
+                _ => schema
+                    .or_else(|| s(resource, "schema"))
+                    .or(Some("public".into())),
+            };
+        }
+        // Their Windmill resources do not carry what dbt needs — an `oracledb`
+        // resource has no host/service, dbt-sqlserver needs an ODBC `driver` the
+        // images lack — so a rendered profile could not connect. They go through
+        // the project's own `profiles.yml` instead.
+        DbtAdapter::Duckdb
+        | DbtAdapter::Clickhouse
+        | DbtAdapter::Salesforce
+        | DbtAdapter::Mssql
+        | DbtAdapter::OracleDB => {
+            return Err(Error::BadRequest(format!(
+                "the `{}` adapter has no Windmill resource mapping; point \
+                 `profile.profiles_yml` at the project's own profiles.yml instead",
+                adapter.dbt_type()
+            )));
+        }
+        DbtAdapter::Snowflake => {
+            let account = s(resource, "account_identifier")
+                .or_else(|| s(resource, "account"))
+                .ok_or_else(|| {
+                    Error::BadRequest("snowflake resource has no `account_identifier`".to_string())
+                })?;
+            out.push(("account".into(), quoted(&account)));
+            if let Some(u) = s(resource, "username").or_else(|| s(resource, "user")) {
+                out.push(("user".into(), quoted(&u)));
+            }
+            // Key-pair is Windmill's own snowflake resource shape; the
+            // `snowflake_oauth` type carries a token instead, which dbt only
+            // accepts alongside `authenticator: oauth` — without both, the
+            // profile renders with no credential at all and cannot connect.
+            if let Some(t) = s(resource, "token").or_else(|| s(resource, "access_token")) {
+                out.push(("authenticator".into(), quoted("oauth")));
+                out.push(("token".into(), quoted(&t)));
+            } else if let Some(k) = s(resource, "private_key") {
+                out.push(("private_key".into(), quoted(&k)));
+                if let Some(pp) = s(resource, "private_key_passphrase") {
+                    out.push(("private_key_passphrase".into(), quoted(&pp)));
+                }
+            } else if let Some(p) = s(resource, "password") {
+                out.push(("password".into(), quoted(&p)));
+            }
+            for k in ["warehouse", "role"] {
+                if let Some(v) = s(resource, k) {
+                    out.push((k.into(), quoted(&v)));
+                }
+            }
+            database = s(resource, "database");
+            if let Some(d) = database.clone() {
+                out.push(("database".into(), quoted(&d)));
+            }
+            schema = schema.or_else(|| s(resource, "schema"));
+        }
+        DbtAdapter::Bigquery => {
+            // Windmill's bigquery resource is the raw service-account JSON, so
+            // hand dbt the same document via `method: service-account-json`
+            // rather than re-deriving individual fields.
+            out.push(("method".into(), quoted("service-account-json")));
+            let project = s(resource, "project_id").ok_or_else(|| {
+                Error::BadRequest("bigquery resource has no `project_id`".to_string())
+            })?;
+            out.push(("project".into(), quoted(&project)));
+            database = Some(project);
+            // A service-account JSON has no dataset, so unless the resource was
+            // extended with one the descriptor must supply it — dbt rejects a
+            // BigQuery target without `dataset`, and failing here names the
+            // missing field instead.
+            schema = schema
+                .or_else(|| s(resource, "dataset"))
+                .or_else(|| s(resource, "schema"));
+            if schema.is_none() {
+                return Err(Error::BadRequest(
+                    "a BigQuery target needs a dataset; set `profile.schema` in the descriptor"
+                        .to_string(),
+                ));
+            }
+        }
+        DbtAdapter::Databricks => {
+            for (k, rk) in [
+                ("host", "host"),
+                ("http_path", "http_path"),
+                ("token", "token"),
+            ] {
+                let v = s(resource, rk).ok_or_else(|| {
+                    Error::BadRequest(format!("databricks resource has no `{rk}`"))
+                })?;
+                out.push((k.into(), quoted(&v)));
+            }
+            database = s(resource, "catalog");
+            if let Some(c) = database.clone() {
+                out.push(("catalog".into(), quoted(&c)));
+            }
+            schema = schema.or_else(|| s(resource, "schema"));
+        }
+    }
+
+    // dbt-mysql has no database/schema distinction: its `schema` key IS the
+    // database, already emitted above. Pushing the generic one too would put
+    // two `schema` keys in one target — an invalid profile, or one silently
+    // pointing at the wrong database.
+    if adapter != DbtAdapter::Mysql {
+        if let Some(sc) = schema.clone() {
+            // dbt-bigquery spells it `dataset`; every other adapter says
+            // `schema`. Emitting `schema` there produces a profile dbt rejects.
+            let key = match adapter {
+                DbtAdapter::Bigquery => "dataset",
+                _ => "schema",
+            };
+            out.push((key.into(), quoted(&sc)));
+        }
+    }
+    if let Some(t) = threads {
+        out.push(("threads".into(), ProfileValue::Number(t as i64)));
+    }
+
+    // Quoted, keys included. `profile_name` comes from the project's own
+    // `dbt_project.yml` and `target` from the descriptor, so both are the
+    // author's text: a name like `prod # x` silently truncates the mapping, and
+    // a newline in one opens a sibling key of the caller's choosing.
+    let (qp, qt) = (yaml_scalar(profile_name), yaml_scalar(target));
+    let mut yaml = format!("{qp}:\n  target: {qt}\n  outputs:\n    {qt}:\n");
+    for (k, v) in &out {
+        yaml.push_str(&format!("      {k}: {}\n", v.render()));
+    }
+    // The service-account document is a nested mapping, not a scalar.
+    if adapter == DbtAdapter::Bigquery {
+        yaml.push_str("      keyfile_json:\n");
+        let obj = resource
+            .as_object()
+            .ok_or_else(|| Error::BadRequest("bigquery resource is not an object".to_string()))?;
+        for (k, v) in obj {
+            if let Some(v) = v.as_str() {
+                yaml.push_str(&format!("        {}: {}\n", yaml_scalar(k), yaml_scalar(v)));
+            }
+        }
+    }
+
+    Ok(RenderedProfile {
+        yaml,
+        schema,
+        database,
+        root_certificate_pem: matches!(adapter, DbtAdapter::Postgres)
+            .then(|| s(resource, "root_certificate_pem"))
+            .flatten(),
+    })
+}
+
+/// One rendered `profiles.yml` value. Strings are always quoted so credential
+/// content cannot inject profile keys; numbers must NOT be, because dbt
+/// validates `port` and `threads` against a JSON schema that demands integers
+/// and rejects the quoted form outright.
+enum ProfileValue {
+    Str(String),
+    Number(i64),
+}
+
+impl ProfileValue {
+    fn render(&self) -> String {
+        match self {
+            ProfileValue::Str(s) => yaml_scalar(s),
+            ProfileValue::Number(n) => n.to_string(),
+        }
+    }
+}
+
+fn quoted(v: &str) -> ProfileValue {
+    ProfileValue::Str(v.to_string())
+}
+
+/// Emit a YAML scalar that survives any credential content. Always
+/// double-quoted with the two characters that can terminate or escape inside a
+/// double-quoted scalar escaped, so a password containing `#`, `:`, a newline
+/// or a quote cannot break out of its value and inject profile keys.
+fn yaml_scalar(v: &str) -> String {
+    let escaped = v
+        .replace('\\', "\\\\")
+        .replace('"', "\\\"")
+        .replace('\n', "\\n")
+        .replace('\r', "\\r");
+    format!("\"{escaped}\"")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn renders_postgres_target() {
+        let r = json!({"host": "db.internal", "port": 5433, "user": "u", "password": "p",
+                       "dbname": "warehouse", "sslmode": "require"});
+        let p = render_profile(
+            DbtAdapter::Postgres,
+            &r,
+            "wm",
+            "prod",
+            Some(8),
+            None,
+            std::path::Path::new("/tmp/p"),
+        )
+        .unwrap();
+        // Quoted: the profile name and target are the author's text, so they are
+        // rendered as scalars rather than as bare keys.
+        assert!(
+            p.yaml.contains("\"wm\":\n  target: \"prod\"\n"),
+            "{}",
+            p.yaml
+        );
+        assert!(p.yaml.contains("      type: \"postgres\"\n"));
+        // dbt's profile schema types these as integers, so they must not be
+        // quoted like the credential scalars around them.
+        assert!(p.yaml.contains("      port: 5433\n"));
+        assert!(p.yaml.contains("      threads: 8\n"));
+        assert_eq!(p.database.as_deref(), Some("warehouse"));
+        assert_eq!(p.schema.as_deref(), Some("public"));
+    }
+
+    #[test]
+    fn redshift_falls_back_to_its_own_port() {
+        // Redshift is rendered from the same host/port shape as Postgres but
+        // does not answer on Postgres's port.
+        let r = json!({"host": "cluster.redshift.amazonaws.com", "user": "u",
+                       "password": "p", "dbname": "warehouse"});
+        let p = render_profile(
+            DbtAdapter::Redshift,
+            &r,
+            "wm",
+            "prod",
+            None,
+            None,
+            std::path::Path::new("/tmp/p"),
+        )
+        .unwrap();
+        assert!(p.yaml.contains("      port: 5439\n"), "{}", p.yaml);
+    }
+
+    // A resource's private CA is the only way a `verify-full` connection can
+    // succeed, and `root_certificate_pem` is also what identifies the resource as
+    // Postgres — forwarding one and dropping the other is incoherent.
+    #[test]
+    fn postgres_forwards_its_root_certificate() {
+        let r = json!({"host": "h", "dbname": "d", "sslmode": "verify-full",
+                       "root_certificate_pem": "-----BEGIN CERTIFICATE-----\nx\n"});
+        let p = render_profile(
+            DbtAdapter::Postgres,
+            &r,
+            "wm",
+            "prod",
+            None,
+            None,
+            std::path::Path::new("/tmp/p"),
+        )
+        .unwrap();
+        // Absolute: dbt runs with the PROJECT as its cwd and hands this to the
+        // driver unchanged, so a profiles-relative path would never be found.
+        assert!(
+            p.yaml.contains(&format!(
+                "      sslrootcert: \"/tmp/p/{ROOT_CERT_FILENAME}\"\n"
+            )),
+            "{}",
+            p.yaml
+        );
+        assert_eq!(
+            p.root_certificate_pem.as_deref(),
+            Some("-----BEGIN CERTIFICATE-----\nx\n")
+        );
+        // No CA configured, no dangling sslrootcert pointing at a missing file.
+        let plain = json!({"host": "h", "dbname": "d", "sslmode": "require"});
+        let p = render_profile(
+            DbtAdapter::Postgres,
+            &plain,
+            "wm",
+            "prod",
+            None,
+            None,
+            std::path::Path::new("/tmp/p"),
+        )
+        .unwrap();
+        assert!(!p.yaml.contains("sslrootcert"));
+        assert_eq!(p.root_certificate_pem, None);
+    }
+
+    // `snowflake_oauth` maps to the Snowflake adapter, but its credential is a
+    // token, which dbt honors only with `authenticator: oauth`. Forwarding neither
+    // renders a profile with no credential at all.
+    #[test]
+    fn snowflake_oauth_renders_its_token() {
+        let r = json!({"account_identifier": "acc", "username": "u", "token": "tok",
+                       "database": "db", "warehouse": "wh"});
+        let p = render_profile(
+            DbtAdapter::Snowflake,
+            &r,
+            "wm",
+            "prod",
+            None,
+            None,
+            std::path::Path::new("/tmp/p"),
+        )
+        .unwrap();
+        assert!(
+            p.yaml.contains("      authenticator: \"oauth\"\n"),
+            "{}",
+            p.yaml
+        );
+        assert!(p.yaml.contains("      token: \"tok\"\n"));
+    }
+
+    // dbt rejects a BigQuery target with no dataset and a service-account JSON
+    // carries none, so the descriptor has to supply it — and naming the missing
+    // field beats a downstream dbt error.
+    #[test]
+    fn bigquery_requires_a_dataset() {
+        let r = json!({"project_id": "p", "client_email": "e", "private_key": "k"});
+        let err = render_profile(
+            DbtAdapter::Bigquery,
+            &r,
+            "wm",
+            "prod",
+            None,
+            None,
+            std::path::Path::new("/tmp/p"),
+        )
+        .unwrap_err()
+        .to_string();
+        assert!(err.contains("profile.schema"), "{err}");
+        let p = render_profile(
+            DbtAdapter::Bigquery,
+            &r,
+            "wm",
+            "prod",
+            None,
+            Some("marts"),
+            std::path::Path::new("/tmp/p"),
+        )
+        .unwrap();
+        // dbt-bigquery's key is `dataset`, not `schema`.
+        assert!(p.yaml.contains("      dataset: \"marts\"\n"), "{}", p.yaml);
+        assert!(!p.yaml.contains("      schema:"));
+        assert_eq!(p.schema.as_deref(), Some("marts"));
+    }
+
+    // A SQL Server resource has a Postgres resource's shape, so guessing Postgres
+    // points dbt-postgres at port 1433 instead of producing the licensing error.
+    #[test]
+    fn ambiguous_host_resources_decline_rather_than_guess() {
+        let mssql = json!({"host": "h", "dbname": "d", "user": "u", "password": "p"});
+        assert_eq!(DbtAdapter::infer_from_resource(&mssql), None);
+        let pg = json!({"host": "h", "dbname": "d", "sslmode": "require"});
+        assert_eq!(
+            DbtAdapter::infer_from_resource(&pg),
+            Some(DbtAdapter::Postgres)
+        );
+        let sf = json!({"account_identifier": "acc", "database": "d"});
+        assert_eq!(
+            DbtAdapter::infer_from_resource(&sf),
+            Some(DbtAdapter::Snowflake)
+        );
+    }
+
+    // dbt-mysql has no database/schema split: one `schema` key is the database, so
+    // emitting the generic one too yields a profile with two.
+    #[test]
+    fn mysql_emits_exactly_one_schema_key() {
+        let r = json!({"host": "h", "dbname": "sales", "user": "u"});
+        let p = render_profile(
+            DbtAdapter::Mysql,
+            &r,
+            "wm",
+            "dev",
+            None,
+            None,
+            std::path::Path::new("/tmp/p"),
+        )
+        .unwrap();
+        assert_eq!(p.yaml.matches("      schema:").count(), 1);
+        assert!(p.yaml.contains("      schema: \"sales\"\n"));
+        assert!(p.yaml.contains("      port: 3306\n"));
+        assert_eq!(p.schema.as_deref(), Some("sales"));
+    }
+
+    // The profile name is the project's own `dbt_project.yml`, the target the
+    // descriptor's — both the author's text, and both were mapping keys.
+    #[test]
+    fn a_profile_name_or_target_cannot_open_a_sibling_key() {
+        let rendered = render_profile(
+            DbtAdapter::Postgres,
+            &serde_json::json!({"host": "h", "user": "u", "password": "p", "dbname": "d"}),
+            "prod # hidden",
+            "dev\n  evil: yes",
+            None,
+            None,
+            std::path::Path::new("/tmp"),
+        )
+        .unwrap();
+        // Every occurrence is quoted, so neither the comment nor the newline is
+        // structure: the document still has exactly the keys we wrote.
+        assert!(
+            rendered.yaml.contains("\"prod # hidden\":"),
+            "{}",
+            rendered.yaml
+        );
+        assert!(
+            rendered.yaml.contains("\\n  evil: yes"),
+            "{}",
+            rendered.yaml
+        );
+        let v: serde_yml::Value = serde_yml::from_str(&rendered.yaml).expect("valid yaml");
+        let profile = v.get("prod # hidden").expect("profile is one key");
+        assert!(profile.get("evil").is_none());
+        assert!(v.get("evil").is_none());
+    }
+
+    // A credential is attacker-influenced text. Unquoted, a `\n` or `"` closes the
+    // scalar and the rest reads as further profile keys — a different `host`,
+    // silently redirecting the run at another warehouse.
+    #[test]
+    fn credentials_cannot_break_out_of_their_scalar() {
+        let r = json!({"host": "h", "dbname": "d",
+                       "password": "p\"\nhost: evil.example.com\n#"});
+        let p = render_profile(
+            DbtAdapter::Postgres,
+            &r,
+            "wm",
+            "dev",
+            None,
+            None,
+            std::path::Path::new("/tmp/p"),
+        )
+        .unwrap();
+        assert!(p
+            .yaml
+            .contains(r#"password: "p\"\nhost: evil.example.com\n#""#));
+        let parsed: serde_yml::Value = serde_yml::from_str(&p.yaml).unwrap();
+        assert_eq!(
+            parsed["wm"]["outputs"]["dev"]["host"].as_str(),
+            Some("h"),
+            "the injected host must not have won"
+        );
+    }
+
+    // A RUNTIME check, because one dbt executor serves every adapter. A refactor
+    // reaching for a bare `LICENSE_KEY_VALID` would silently let CE through, since
+    // the OSS variant initializes it to `true`.
+    #[test]
+    fn only_mssql_and_oracle_are_enterprise_gated() {
+        for a in [
+            DbtAdapter::Postgres,
+            DbtAdapter::Redshift,
+            DbtAdapter::Mysql,
+            DbtAdapter::Duckdb,
+            DbtAdapter::Clickhouse,
+            DbtAdapter::Snowflake,
+            DbtAdapter::Bigquery,
+            DbtAdapter::Databricks,
+            DbtAdapter::Salesforce,
+        ] {
+            assert!(!a.requires_enterprise(), "{a:?}");
+            assert!(ensure_adapter_licensed(a).is_ok(), "{a:?}");
+        }
+        for (a, name) in [
+            (DbtAdapter::Mssql, "Microsoft SQL server"),
+            (DbtAdapter::OracleDB, "Oracle DB"),
+        ] {
+            assert!(a.requires_enterprise(), "{a:?}");
+            match ensure_adapter_licensed(a) {
+                Ok(()) => assert!(
+                    enterprise_licensed(),
+                    "{a:?} was accepted without an enterprise license"
+                ),
+                Err(e) => {
+                    assert!(!enterprise_licensed(), "{a:?} rejected despite a license");
+                    // Naming the adapter is the point: the user must not be left
+                    // with a generic connection failure to diagnose.
+                    assert_eq!(
+                        e.to_string(),
+                        format!("Bad request: {name} is only available with an enterprise license")
+                    );
+                }
+            }
+        }
+    }
+}
diff --git a/backend/windmill-worker/src/handle_child.rs b/backend/windmill-worker/src/handle_child.rs
index 439a4a09a2..b2c9de8a9a 100644
--- a/backend/windmill-worker/src/handle_child.rs
+++ b/backend/windmill-worker/src/handle_child.rs
@@ -694,6 +694,68 @@ pub(crate) async fn get_mem_peak(pid: Option<u32>, nsjail: bool) -> i32 {
     }
 }
 
+/// The job state a command run outside the main script needs to stay
+/// cancellable. `dbt deps` can hang on an unreachable package endpoint and
+/// `dbt parse`/`ls` on a warehouse handshake, so running them detached would
+/// hold a worker slot past a cancel or a timeout.
+pub struct JobCtx<'a> {
+    pub mem_peak: &'a mut i32,
+    pub canceled_by: &'a mut Option<CanceledBy>,
+    pub occupancy_metrics: &'a mut OccupancyMetrics,
+    pub worker_name: &'a str,
+    pub deadline: JobDeadline,
+}
+
+impl JobCtx<'_> {
+    /// What is left of the job's wall clock, for the phase about to start.
+    pub fn timeout(&self) -> Option<i32> {
+        self.deadline.remaining_secs()
+    }
+}
+
+/// One wall clock for a job that runs several subprocesses in sequence.
+///
+/// Both `handle_child` and `run_future_with_polling_update_job_poller` resolve
+/// the timeout they are handed into a fresh duration, so handing each phase the
+/// job's full timeout lets a job with N phases run for N times it. Resolved
+/// once at the start, then spent down.
+#[derive(Clone, Copy)]
+pub struct JobDeadline(Option<Instant>);
+
+impl JobDeadline {
+    pub async fn start(
+        conn: &Connection,
+        w_id: &str,
+        job_id: Uuid,
+        custom_timeout: Option<i32>,
+    ) -> Self {
+        let (d, _, _) = resolve_job_timeout(conn, w_id, job_id, custom_timeout).await;
+        Self(Some(Instant::now() + d))
+    }
+
+    /// Whether the job's wall clock is already spent.
+    ///
+    /// Distinct from `remaining_secs`, which deliberately never reports zero:
+    /// an expired budget still has to hand the next phase a positive timeout so
+    /// the poller fires. A caller deciding whether to START more work needs the
+    /// honest answer.
+    pub fn is_expired(&self) -> bool {
+        self.0.is_some_and(|d| d <= Instant::now())
+    }
+
+    pub fn remaining_secs(&self) -> Option<i32> {
+        let deadline = self.0?;
+        // A non-positive timeout reads as "unset" downstream, so an expired
+        // budget must still ask for a positive one and let the poller fire.
+        Some(
+            deadline
+                .saturating_duration_since(Instant::now())
+                .as_secs()
+                .clamp(1, i32::MAX as u64) as i32,
+        )
+    }
+}
+
 pub async fn run_future_with_polling_update_job_poller<Fut, T, S>(
     job_id: Uuid,
     timeout: Option<i32>,
@@ -1029,3 +1091,19 @@ pub fn process_status(
         )));
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // A non-positive timeout means "unset" to `resolve_job_timeout`, so an
+    // exhausted budget that reported 0 would hand the next phase no deadline at
+    // all — the opposite of what running out of time should do.
+    #[test]
+    fn an_exhausted_budget_still_asks_for_a_positive_timeout() {
+        let spent = JobDeadline(Some(Instant::now() - Duration::from_secs(30)));
+        assert_eq!(spent.remaining_secs(), Some(1));
+        let left = JobDeadline(Some(Instant::now() + Duration::from_secs(120)));
+        assert!(matches!(left.remaining_secs(), Some(s) if (118..=120).contains(&s)));
+    }
+}
diff --git a/backend/windmill-worker/src/lib.rs b/backend/windmill-worker/src/lib.rs
index fe2fffb93e..8cb0551254 100644
--- a/backend/windmill-worker/src/lib.rs
+++ b/backend/windmill-worker/src/lib.rs
@@ -33,6 +33,9 @@ pub mod common;
 mod config;
 mod csharp_executor;
 
+mod dbt_engine;
+mod dbt_executor;
+mod dbt_profiles;
 #[cfg(feature = "private")]
 mod dedicated_worker_ee;
 mod dedicated_worker_oss;
diff --git a/backend/windmill-worker/src/php_executor.rs b/backend/windmill-worker/src/php_executor.rs
index 08a92b3641..1ede0933cb 100644
--- a/backend/windmill-worker/src/php_executor.rs
+++ b/backend/windmill-worker/src/php_executor.rs
@@ -20,8 +20,8 @@ use windmill_queue::{append_logs, CanceledBy};
 use crate::{
     common::{
         build_command_with_isolation, check_executor_binary_exists, create_args_and_out_file,
-        get_reserved_variables, read_result, resolve_nsjail_timeout, resolve_nsjail_tmp_mount_block,
-        start_child_process, MaybeLock, OccupancyMetrics,
+        get_reserved_variables, read_result, resolve_nsjail_timeout,
+        resolve_nsjail_tmp_mount_block, start_child_process, MaybeLock, OccupancyMetrics,
     },
     handle_child::handle_child,
     is_sandboxing_enabled, COMPOSER_CACHE_DIR, COMPOSER_PATH, DISABLE_NUSER, NSJAIL_PATH, PHP_PATH,
diff --git a/backend/windmill-worker/src/rust_executor.rs b/backend/windmill-worker/src/rust_executor.rs
index 5941e9db1c..bee5dc4b68 100644
--- a/backend/windmill-worker/src/rust_executor.rs
+++ b/backend/windmill-worker/src/rust_executor.rs
@@ -23,8 +23,8 @@ use windmill_queue::{append_logs, CanceledBy};
 use crate::{
     common::{
         build_command_with_isolation, check_executor_binary_exists, create_args_and_out_file,
-        get_reserved_variables, read_result, resolve_nsjail_timeout, resolve_nsjail_tmp_mount_block,
-        start_child_process, OccupancyMetrics, DEV_CONF_NSJAIL,
+        get_reserved_variables, read_result, resolve_nsjail_timeout,
+        resolve_nsjail_tmp_mount_block, start_child_process, OccupancyMetrics, DEV_CONF_NSJAIL,
     },
     get_proxy_envs_for_lang,
     handle_child::handle_child,
diff --git a/backend/windmill-worker/src/worker.rs b/backend/windmill-worker/src/worker.rs
index ccac9a3731..08bb085059 100644
--- a/backend/windmill-worker/src/worker.rs
+++ b/backend/windmill-worker/src/worker.rs
@@ -361,6 +361,8 @@ lazy_static::lazy_static! {
         std::env::var("NSJAIL_PY_RLIMIT_AS_MB").ok();
     pub static ref NSJAIL_ANSIBLE_RLIMIT_AS_MB: Option<String> =
         std::env::var("NSJAIL_ANSIBLE_RLIMIT_AS_MB").ok();
+    pub static ref NSJAIL_DBT_RLIMIT_AS_MB: Option<String> =
+        std::env::var("NSJAIL_DBT_RLIMIT_AS_MB").ok();
 
     // pub static ref DISABLE_NSJAIL: bool = false;
     pub static ref DISABLE_NSJAIL: bool = std::env::var("DISABLE_NSJAIL")
@@ -5865,6 +5867,30 @@ mount {{
                 .await
             }
         }
+        ScriptLang::Dbt => {
+            if run_inline {
+                return Err(Error::internal_err(
+                    "Inline execution is not yet supported for this language".to_string(),
+                ));
+            }
+            Box::pin(crate::dbt_executor::handle_dbt_job(
+                lock.as_ref(),
+                job_dir,
+                worker_name,
+                job,
+                mem_peak,
+                canceled_by,
+                conn,
+                client,
+                &code,
+                envs,
+                occupancy_metrics,
+                // The project's identity is derived from these, so the dbt
+                // executor needs them even though they are already on disk.
+                modules.as_ref(),
+            ))
+            .await
+        }
         // for related places search: ADD_NEW_LANG
         _ => panic!("unreachable, language is not supported: {language:#?}"),
     };
@@ -6002,6 +6028,7 @@ pub fn parse_sig_of_lang(
             ScriptLang::Rlang => Some(windmill_parser_r::parse_r_signature(code)?),
             #[cfg(not(feature = "rlang"))]
             ScriptLang::Rlang => None,
+            ScriptLang::Dbt => Some(windmill_parser_yaml::parse_dbt_sig(code)?),
             // for related places search: ADD_NEW_LANG
         }
     } else {
diff --git a/backend/windmill-worker/src/worker_lockfiles.rs b/backend/windmill-worker/src/worker_lockfiles.rs
index 6c6f8ffd77..1b317602c3 100644
--- a/backend/windmill-worker/src/worker_lockfiles.rs
+++ b/backend/windmill-worker/src/worker_lockfiles.rs
@@ -169,6 +169,7 @@ pub async fn handle_dependency_job(
         base_internal_url,
         token,
         script_path,
+        script_data.modules.as_ref(),
         occupancy_metrics,
         &raw_workspace_dependencies_o,
         None,
@@ -195,52 +196,63 @@ pub async fn handle_dependency_job(
             let (deployment_message, parent_path) =
                 get_deployment_msg_and_parent_path_from_args(job.args.clone());
 
-            // Generate lockfiles for module files (if any)
-            let updated_modules = if let Some(modules) = &script_data.modules {
-                let mut updated = modules.clone();
-                for (module_path, module) in updated.iter_mut() {
-                    if module.content.is_empty() {
-                        continue;
-                    }
-                    match capture_dependency_job(
-                        &job.id,
-                        &module.language,
-                        &module.content,
-                        mem_peak,
-                        canceled_by,
-                        job_dir,
-                        db,
-                        worker_name,
-                        &job.workspace_id,
-                        worker_dir,
-                        base_internal_url,
-                        token,
-                        script_path,
-                        occupancy_metrics,
-                        &raw_workspace_dependencies_o,
-                        module.lock.as_deref(),
-                        triggered_by_relative_import,
-                        script_path,
-                        None,
-                        "script",
-                        &None,
-                    )
-                    .await
-                    {
-                        Ok(lock) => {
-                            module.lock = Some(lock);
+            // Generate lockfiles for module files (if any).
+            //
+            // Not for dbt: a dbt script's modules are its dbt project, not
+            // helper code with dependencies of its own. The parent lock above
+            // already ran `dbt deps` and `dbt parse` over the whole project,
+            // which is the one dependency pass it has. Locking each file
+            // separately would re-materialise the bundle and re-invoke dbt once
+            // per file, so a project of N files pays N project-sized passes and
+            // a large one times the deploy out.
+            let per_module_locks = job.script_lang != Some(ScriptLang::Dbt);
+            let updated_modules =
+                if let Some(modules) = script_data.modules.as_ref().filter(|_| per_module_locks) {
+                    let mut updated = modules.clone();
+                    for (module_path, module) in updated.iter_mut() {
+                        if module.content.is_empty() {
+                            continue;
                         }
-                        Err(e) => {
-                            tracing::warn!(
-                                "Failed to generate lockfile for module {module_path}: {e}"
-                            );
+                        match capture_dependency_job(
+                            &job.id,
+                            &module.language,
+                            &module.content,
+                            mem_peak,
+                            canceled_by,
+                            job_dir,
+                            db,
+                            worker_name,
+                            &job.workspace_id,
+                            worker_dir,
+                            base_internal_url,
+                            token,
+                            script_path,
+                            script_data.modules.as_ref(),
+                            occupancy_metrics,
+                            &raw_workspace_dependencies_o,
+                            module.lock.as_deref(),
+                            triggered_by_relative_import,
+                            script_path,
+                            None,
+                            "script",
+                            &None,
+                        )
+                        .await
+                        {
+                            Ok(lock) => {
+                                module.lock = Some(lock);
+                            }
+                            Err(e) => {
+                                tracing::warn!(
+                                    "Failed to generate lockfile for module {module_path}: {e}"
+                                );
+                            }
                         }
                     }
-                }
-                Some(updated)
-            } else {
-                None
-            };
+                    Some(updated)
+                } else {
+                    None
+                };
 
             // We do not create new row for this update
             // That means we can keep current hash and just update lock
@@ -1438,6 +1450,8 @@ async fn lock_modules(
                 "{}/flow",
                 &path.clone().unwrap_or_else(|| job_path.to_string())
             ),
+            // An inline flow step has no module bundle of its own.
+            None,
             occupancy_metrics,
             raw_workspace_dependencies_o,
             lock.as_deref(),
@@ -1957,6 +1971,7 @@ async fn lock_modules_app(
                                 base_internal_url,
                                 token,
                                 &format!("{}/app", job.runnable_path()),
+                                None,
                                 occupancy_metrics,
                                 &None,
                                 existing_lock,
@@ -2697,6 +2712,9 @@ async fn capture_dependency_job(
     base_internal_url: &str,
     token: &str,
     script_path: &str,
+    // A dbt script's project rides in its modules; the dbt dependency job
+    // materialises them itself, having no generic module-writing step.
+    modules: Option<&std::collections::HashMap<String, windmill_common::scripts::ScriptModule>>,
     occupancy_metrics: &mut OccupancyMetrics,
     raw_workspace_dependencies_o: &Option<RawWorkspaceDependencies>,
     existing_lock: Option<&str>,
@@ -2843,6 +2861,24 @@ async fn capture_dependency_job(
                 .await?
             }
         }
+        ScriptLang::Dbt => {
+            crate::dbt_executor::dbt_dep(
+                job_raw_code,
+                modules,
+                job_id,
+                mem_peak,
+                canceled_by,
+                job_dir,
+                db,
+                worker_name,
+                w_id,
+                script_path,
+                occupancy_metrics,
+                token,
+                base_internal_url,
+            )
+            .await?
+        }
         ScriptLang::Go => {
             install_go_dependencies(
                 job_id,
diff --git a/cli/bun.lock b/cli/bun.lock
index f43fa66869..998724a4b6 100644
--- a/cli/bun.lock
+++ b/cli/bun.lock
@@ -32,7 +32,8 @@
         "windmill-parser-wasm-ruby": "1.526.1",
         "windmill-parser-wasm-rust": "1.647.1",
         "windmill-parser-wasm-ts": "1.695.0",
-        "windmill-parser-wasm-yaml": "1.593.0",
+        "windmill-parser-wasm-yaml": "1.770.0",
+        "windmill-yaml-validator": "1.1.1",
         "ws": "8.18.0",
         "yaml": "^2.7.0",
       },
@@ -148,6 +149,14 @@
 
     "@jsr/std__text": ["@jsr/std__text@1.0.17", "https://npm.jsr.io/~/11/@jsr/std__text/1.0.17.tgz", { "dependencies": { "@jsr/std__regexp": "^1.0.1" } }, "sha512-oZsihl1bcTy1Ixzven8rin8kjChj1zDJWqgpS0oSMGCJDzyB365gtIfAvcMmji+M+FcIWo3goDXfHcFYt+k/kg=="],
 
+    "@stoplight/ordered-object-literal": ["@stoplight/ordered-object-literal@1.0.5", "", {}, "sha512-COTiuCU5bgMUtbIFBuyyh2/yVVzlr5Om0v5utQDgBCuQUOPgU1DwoffkTfg4UBQOvByi5foF4w4T+H9CoRe5wg=="],
+
+    "@stoplight/types": ["@stoplight/types@14.1.1", "", { "dependencies": { "@types/json-schema": "^7.0.4", "utility-types": "^3.10.0" } }, "sha512-/kjtr+0t0tjKr+heVfviO9FrU/uGLc+QNX3fHJc19xsCNYqU7lVhaXxDmEID9BZTjG+/r9pK9xP/xU02XGg65g=="],
+
+    "@stoplight/yaml": ["@stoplight/yaml@4.3.0", "", { "dependencies": { "@stoplight/ordered-object-literal": "^1.0.5", "@stoplight/types": "^14.1.1", "@stoplight/yaml-ast-parser": "0.0.50", "tslib": "^2.2.0" } }, "sha512-JZlVFE6/dYpP9tQmV0/ADfn32L9uFarHWxfcRhReKUnljz1ZiUM5zpX+PH8h5CJs6lao3TuFqnPm9IJJCEkE2w=="],
+
+    "@stoplight/yaml-ast-parser": ["@stoplight/yaml-ast-parser@0.0.50", "", {}, "sha512-Pb6M8TDO9DtSVla9yXSTAxmo9GVEouq5P40DWXdOie69bXogZTkgvopCq+yEvTMA0F6PEvdJmbtTV3ccIp11VQ=="],
+
     "@sveltejs/acorn-typescript": ["@sveltejs/acorn-typescript@1.0.11", "", { "peerDependencies": { "acorn": "^8.9.0" } }, "sha512-LFuZUkjJ9iF7JZye/aG5XM0SFcQ5VyL0oVX4WJ9dc0Va3R3s0OauX1BESVCb+YN/ol8TAfqGDDAQsTG627Y5kw=="],
 
     "@types/bun": ["@types/bun@1.3.9", "", { "dependencies": { "bun-types": "1.3.9" } }, "sha512-KQ571yULOdWJiMH+RIWIOZ7B2RXQGpL1YQrBtLIV3FqDcCu6FsbFUBwhdKUlCKUpS3PJDsHlJ1QKlpxoVR+xtw=="],
@@ -156,6 +165,8 @@
 
     "@types/estree": ["@types/estree@1.0.8", "", {}, "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w=="],
 
+    "@types/json-schema": ["@types/json-schema@7.0.15", "", {}, "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA=="],
+
     "@types/node": ["@types/node@22.19.11", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-BH7YwL6rA93ReqeQS1c4bsPpcfOmJasG+Fkr6Y59q83f9M1WcBRHR2vM+P9eOisYRcN3ujQoiZY8uk5W+1WL8w=="],
 
     "@types/tar-stream": ["@types/tar-stream@3.1.4", "", { "dependencies": { "@types/node": "*" } }, "sha512-921gW0+g29mCJX0fRvqeHzBlE/XclDaAG0Ousy1LCghsOhvaKacDeRGEVzQP9IPfKn8Vysy7FEXAIxycpc/CMg=="],
@@ -270,12 +281,16 @@
 
     "text-decoder": ["text-decoder@1.2.7", "", { "dependencies": { "b4a": "^1.6.4" } }, "sha512-vlLytXkeP4xvEq2otHeJfSQIRyWxo/oZGEbXrtEEF9Hnmrdly59sUbzZ/QgyWuLYHctCHxFF4tRQZNQ9k60ExQ=="],
 
+    "tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
     "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
 
     "undici-types": ["undici-types@6.21.0", "", {}, "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ=="],
 
     "util-deprecate": ["util-deprecate@1.0.2", "", {}, "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="],
 
+    "utility-types": ["utility-types@3.11.0", "", {}, "sha512-6Z7Ma2aVEWisaL6TvBCy7P8rm2LQoPv6dJ7ecIaIixHcwfbJ0x7mWdbcwlIM5IGQxPZSFYeqRCqlOOeKoJYMkw=="],
+
     "windmill-parser-wasm-asset": ["windmill-parser-wasm-asset@1.753.0", "", {}, "sha512-zpJhjvcU8EWRoOJzas/nRGKjGdQnvzeB9GOxP+Mdmnk8BFk3uehsmHS2Krxyjo36fUrCHqobbnffEqf0g3LIGg=="],
 
     "windmill-parser-wasm-csharp": ["windmill-parser-wasm-csharp@1.510.1", "", {}, "sha512-qm09YmnbeYHLwYn1jUnObVzPhYO9NZKMlIO7nlo7zPJBXqksgG5fK/KCtwGw9rChrnz+DsvM9wP5FhrwRLMtwQ=="],
@@ -302,7 +317,9 @@
 
     "windmill-parser-wasm-ts": ["windmill-parser-wasm-ts@1.695.0", "", {}, "sha512-9EFxeRZWmfb7EyhSlcG7dzTTKETPRYAvpRlxxLkhhtI5I219wFgI7kwrMpz4stXHJj/aqBknVv66NQHRstSJmw=="],
 
-    "windmill-parser-wasm-yaml": ["windmill-parser-wasm-yaml@1.593.0", "", {}, "sha512-Gyx4aR2jsJYuDrD3mCNTmz7LWOQQXPw5yKNCC1xRgUOPfjsD/tINAFfsBLwVOSmlQQcFZO+wHm4KtDtXOcnGVw=="],
+    "windmill-parser-wasm-yaml": ["windmill-parser-wasm-yaml@1.770.0", "", {}, "sha512-RngxbcKYYFt3MHYqdYTzbtH6EMPfqJtY4/mqRqfLUie4cE9mmOBa9X9M3VEFVo53CD1dCRa9wJKZmeJzE5We5Q=="],
+
+    "windmill-yaml-validator": ["windmill-yaml-validator@1.1.1", "", { "dependencies": { "@stoplight/yaml": "^4.3.0", "ajv": "^8.17.1" } }, "sha512-CVgAwEoBdJhF39q2N012QffhlGPRIyIWd8gj7NnfG+/lMWgH2k5CBLtKIt6cPF8Bxz+6DGC3st1ARSsecDtbTg=="],
 
     "ws": ["ws@8.18.0", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": ">=5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-8VbfWfHLbbwu3+N6OKsOMpBdT4kXPDDB9cJk2bJ6mh9ucxdlnNvH1e+roYkKmN9Nxw2yjz7VzeO9oOz2zJ04Pw=="],
 
diff --git a/cli/package.json b/cli/package.json
index 7f3ba944f0..e39bafdac2 100644
--- a/cli/package.json
+++ b/cli/package.json
@@ -42,7 +42,8 @@
     "windmill-parser-wasm-ruby": "1.526.1",
     "windmill-parser-wasm-rust": "1.647.1",
     "windmill-parser-wasm-ts": "1.695.0",
-    "windmill-parser-wasm-yaml": "1.593.0",
+    "windmill-parser-wasm-yaml": "1.770.0",
+    "windmill-yaml-validator": "1.1.1",
     "ws": "8.18.0",
     "yaml": "^2.7.0"
   },
diff --git a/cli/src/commands/dev/dev.ts b/cli/src/commands/dev/dev.ts
index f588f5841d..00a6f72f0e 100644
--- a/cli/src/commands/dev/dev.ts
+++ b/cli/src/commands/dev/dev.ts
@@ -20,7 +20,19 @@ import {
   SyncOptions,
   mergeConfigWithConfigFile,
 } from "../../core/conf.ts";
-import { exts, removeExtensionToPath } from "../script/script.ts";
+import {
+  exts,
+  hasScriptExt,
+  readModulesFromDisk,
+  removeExtensionToPath,
+} from "../script/script.ts";
+import type { ScriptModule } from "../../../gen/types.gen.ts";
+import {
+  DBT_DESCRIPTOR_NAME,
+  DBT_MODULE_SUFFIX,
+  getScriptBasePathFromModulePath,
+  isDbtModulePath,
+} from "../../utils/resource_folders.ts";
 import { inferContentTypeFromFilePath } from "../../utils/script_common.ts";
 import { OpenFlow } from "../../../gen/types.gen.ts";
 import { FlowFile } from "../flow/flow.ts";
@@ -108,7 +120,7 @@ function findFlowFolderPrefix(cpath: string): string | undefined {
   return undefined;
 }
 
-async function listWorkspacePaths(): Promise<WmPathItem[]> {
+export async function listWorkspacePaths(): Promise<WmPathItem[]> {
   // Walk first, capturing each item's metadata file path. Then read summaries in
   // parallel — one tree pass plus N file reads is faster than a serialized walk.
   const items: (WmPathItem & { _metaPath?: string })[] = [];
@@ -136,6 +148,19 @@ async function listWorkspacePaths(): Promise<WmPathItem[]> {
           items.push({ path: stripFolderSuffix(childRel, APP_SUFFIXES), kind: "raw_app" });
           continue;
         }
+        // A dbt script IS the project directory: its descriptor is optional, so
+        // there may be no file here to recognize it by. Not descended into
+        // either — the project's own `.sql` models would otherwise each be
+        // listed as a script of their own.
+        if (entry.name.endsWith(DBT_MODULE_SUFFIX)) {
+          const base = childRel.slice(0, -DBT_MODULE_SUFFIX.length);
+          items.push({
+            path: base,
+            kind: "script",
+            _metaPath: childAbs.slice(0, -DBT_MODULE_SUFFIX.length) + ".script.yaml",
+          });
+          continue;
+        }
         await walk(childAbs, childRel);
       } else if (entry.isFile()) {
         const matchedExt = exts.find((ext) => entry.name.endsWith(ext));
@@ -282,12 +307,40 @@ export async function dev(opts: GlobalOptions & SyncOptions & DevOpts) {
 
   const flowMetadataFile = getMetadataFileName("flow", "yaml");
   async function loadPaths(pathsToLoad: string[]) {
-    const paths = pathsToLoad.filter((p) =>
-      exts.some(
-        (ext) => p.endsWith(ext)
-          || p.endsWith(".flow/" + flowMetadataFile)
-          || p.endsWith("__flow/" + flowMetadataFile)
-      )
+    // A change ANYWHERE inside a dbt project is a change to that script: the
+    // bundle is the project, so the whole thing is re-read and rebroadcast.
+    // Treating the file as a script of its own would drop the edit — a bare
+    // `.sql` has no language to infer, and a `.yml` or `.csv` is filtered out
+    // below — leaving the browser previewing the snapshot taken at startup.
+    const rest: string[] = [];
+    const dbtProjects = new Set<string>();
+    for (const raw of pathsToLoad) {
+      const rel = (await realpath(raw).catch(() => raw))
+        .replace(base + SEP, "")
+        .replaceAll("\\", "/");
+      const wmPath = isDbtModulePath(rel)
+        ? getScriptBasePathFromModulePath(rel)
+        : undefined;
+      // Every project in the batch, and each only once: a save-all or a
+      // `git checkout` touches many files at once, and returning on the first
+      // would drop both the other projects and whatever else changed with them.
+      if (wmPath) dbtProjects.add(wmPath);
+      else rest.push(raw);
+    }
+    for (const wmPath of dbtProjects) {
+      const edit = await loadWmPath(wmPath);
+      if (edit) {
+        log.info("Updated " + wmPath + " (dbt project)");
+        broadcastChanges(edit);
+      }
+    }
+    if (rest.length === 0) return;
+    pathsToLoad = rest;
+    const paths = pathsToLoad.filter(
+      (p) =>
+        hasScriptExt(p) ||
+        p.endsWith(".flow/" + flowMetadataFile) ||
+        p.endsWith("__flow/" + flowMetadataFile)
     );
     if (paths.length == 0) {
       return;
@@ -380,6 +433,10 @@ export async function dev(opts: GlobalOptions & SyncOptions & DevOpts) {
     tag?: string;
     lock?: string;
     temp_script_refs?: Record<string, string>;
+    /** The bundle the dev page forwards to a preview run. A dbt project cannot
+     *  run without it: the worker looks for `dbt_project.yml` in the bundle and
+     *  refuses the job when it is not there. */
+    modules?: Record<string, ScriptModule>;
   };
 
   type LastEditFlow = {
@@ -441,8 +498,23 @@ export async function dev(opts: GlobalOptions & SyncOptions & DevOpts) {
     for (const ext of exts) {
       const filePath = wmPath + ext;
       try {
-        await access(filePath);
-        const content = await readTextFile(filePath);
+        // A dbt project's descriptor is optional, so what says "this is a dbt
+        // script" is the project beside it. Requiring the descriptor to exist
+        // would list such a project in the picker and then refuse to load it.
+        const isAbsentDbtDescriptor =
+          ext === "__dbt/" + DBT_DESCRIPTOR_NAME &&
+          !(await access(filePath).then(
+            () => true,
+            () => false
+          )) &&
+          (await access(wmPath + DBT_MODULE_SUFFIX + "/dbt_project.yml").then(
+            () => true,
+            () => false
+          ));
+        if (!isAbsentDbtDescriptor) {
+          await access(filePath);
+        }
+        const content = isAbsentDbtDescriptor ? "" : await readTextFile(filePath);
         const lang = inferContentTypeFromFilePath(filePath, opts.defaultTs);
         const typed = (await parseMetadataFile(removeExtensionToPath(filePath), undefined))?.payload;
         const edit: LastEditScript = {
@@ -453,6 +525,18 @@ export async function dev(opts: GlobalOptions & SyncOptions & DevOpts) {
           tag: typed?.tag,
           lock: typed?.lock,
           temp_script_refs: tempScriptRefs,
+          // Read VERBATIM for dbt, the way push does: the project's `.sql` and
+          // `.yml` files are dbt's, and inferring a language for each would
+          // drop the ones that are not Windmill scripts.
+          modules:
+            lang === "dbt"
+              ? await readModulesFromDisk(
+                  wmPath + DBT_MODULE_SUFFIX,
+                  opts.defaultTs,
+                  true,
+                  true
+                )
+              : undefined,
         };
         currentLastEdit = edit;
         return edit;
diff --git a/cli/src/commands/generate-metadata/generate-metadata.ts b/cli/src/commands/generate-metadata/generate-metadata.ts
index 7eab79b52d..9680c6abda 100644
--- a/cli/src/commands/generate-metadata/generate-metadata.ts
+++ b/cli/src/commands/generate-metadata/generate-metadata.ts
@@ -22,7 +22,7 @@ import {
   FSFSElement,
   ignoreF,
 } from "../sync/sync.ts";
-import { exts } from "../script/script.ts";
+import { hasScriptExt } from "../script/script.ts";
 import { isFolderResourcePathAnyFormat, isScriptModulePath, isModuleEntryPoint, scriptPathToRemotePath } from "../../utils/resource_folders.ts";
 import { listSyncCodebases, SyncCodebase } from "../../utils/codebase.ts";
 import {
@@ -51,7 +51,7 @@ async function walkLocalScripts(
   const elems = await elementsToMap(
     await FSFSElement(process.cwd(), codebases, false),
     (p, isD) =>
-      (!isD && !exts.some((ext) => p.endsWith(ext))) ||
+      (!isD && !hasScriptExt(p)) ||
       ignore(p, isD) ||
       isFolderResourcePathAnyFormat(p) ||
       // Datatable migration `.sql` files aren't Windmill scripts.
@@ -221,7 +221,7 @@ function categorizeLocalFiles(
     ) {
       appPaths.push(p);
     } else if (
-      exts.some((ext) => p.endsWith(ext)) &&
+      hasScriptExt(p) &&
       !isFolderResourcePathAnyFormat(p) &&
       // Datatable migration `.sql` files aren't Windmill scripts.
       !isDatatableMigrationPath(p) &&
diff --git a/cli/src/commands/pipeline/docs.ts b/cli/src/commands/pipeline/docs.ts
index abee64cbf3..1ae38d5e71 100644
--- a/cli/src/commands/pipeline/docs.ts
+++ b/cli/src/commands/pipeline/docs.ts
@@ -17,11 +17,12 @@ import { colors } from "@cliffy/ansi/colors";
 import { GlobalOptions } from "../../types.ts";
 import {
   type AssetGraph,
+  hideDbtRunnables,
   buildLocalPipelineGraph,
   workspaceRoot,
 } from "./localGraph.ts";
 
-const ASSET_KINDS = "s3object,ducklake,datatable,volume";
+const ASSET_KINDS = "s3object,ducklake,datatable,volume,dbt";
 
 function assetUri(kind: string, p: string): string {
   const prefix = kind === "s3object" ? "s3" : kind;
@@ -39,7 +40,7 @@ async function fetchDeployedGraph(
   if (!res.ok) {
     throw new Error(`GET assets/graph -> ${res.status}: ${await res.text()}`);
   }
-  return (await res.json()) as AssetGraph;
+  return hideDbtRunnables((await res.json()) as AssetGraph);
 }
 
 // Render the pipeline graph as a markdown document.
diff --git a/cli/src/commands/pipeline/localGraph.ts b/cli/src/commands/pipeline/localGraph.ts
index bb51cd98eb..5f9e713f42 100644
--- a/cli/src/commands/pipeline/localGraph.ts
+++ b/cli/src/commands/pipeline/localGraph.ts
@@ -63,6 +63,10 @@ export type GraphRunnable = {
   // `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 }[];
+  // Set by the deployed graph on a dbt script: it owns a whole project, so the
+  // node counts models rather than reading as a single-output script. Never set
+  // locally — a dbt descriptor has no asset parser here.
+  dbt?: { model_count: number };
 };
 export type GraphEdge = {
   runnable_kind: string;
@@ -229,6 +233,7 @@ function commentPrefix(language: string): string {
     language === "ansible" ||
     language === "ruby" ||
     language === "rlang" ||
+    language === "dbt" ||
     language === "nu" ||
     language === "powershell"
   )
@@ -342,7 +347,11 @@ function normalizeRetry(retry: ParseAssetsRaw["retry"]): ParseAssetsRaw["retry"]
 // Read-asset kinds whose read auto-derives a cascade trigger edge inside a
 // `// pipeline`. Mirror of backend `is_auto_trigger_kind` (windmill-common
 // assets.rs) / frontend `AUTO_TRIGGER_KINDS` (resolveGraph.ts) — ducklake
-// tables and s3 objects only; resource/datatable/volume stay explicit-`// on`.
+// tables and s3 objects; resource/datatable/volume/table stay explicit-`// on`.
+// A local graph out of step with that set shows an edge the deploy will not
+// cascade along, and the generated pipeline docs then describe the wrong DAG.
+// `table` is excluded everywhere: a dbt run does not dispatch, and nothing else
+// writes a warehouse relation.
 const AUTO_TRIGGER_KINDS = new Set(["ducklake", "s3object"]);
 
 // Asset-URI prefixes accepted by `// mute <asset>`, in lockstep with the
@@ -550,6 +559,75 @@ export async function collectScripts(
   return out;
 }
 
+// The structural minimum the dbt filter needs. Declared instead of taking
+// `AssetGraph` so the bounded-cascade view of the same payload (`BCGraph`, a
+// narrower shape over identical JSON) passes through without a cast.
+type DbtFilterableGraph = {
+  runnables: { path: string; usage_kind: string; dbt?: unknown }[];
+  edges: { runnable_kind: string; runnable_path: string }[];
+  triggers: { runnable_kind: string; runnable_path: string }[];
+  macro_edges?: { lib_path: string; consumer_path: string }[];
+  test_edges?: {
+    producer_kind: string;
+    producer_path: string;
+    runnable_kind: string;
+    runnable_path: string;
+  }[];
+};
+
+/**
+ * The pipeline's view of a deployed graph whose folder also holds a dbt project.
+ *
+ * `/assets/graph` is asset-usage driven, not membership driven: it lists every
+ * script that reads or writes a relation, so a dbt script appears there like any
+ * producer. That is right for the endpoint — the node is what attributes a
+ * relation to what builds it — but a dbt project is not a pipeline, so it must
+ * not be rendered as one of its scripts. Mirrors the frontend's
+ * `hideDbtRunnables`; the local builder drops these nodes at the source.
+ *
+ * Its relations stay: they are what a downstream pipeline script reads.
+ */
+export function hideDbtRunnables<G extends DbtFilterableGraph>(graph: G): G {
+  // Keyed by `(usage_kind, path)`, the graph's identity for a runnable — a
+  // script and a flow may share a path, and keying on path alone would take the
+  // flow's node, edges and triggers down with the dbt script's.
+  const key = (usage_kind: string, path: string) => `${usage_kind}:${path}`;
+  const dbtKeys = new Set(
+    (graph.runnables ?? [])
+      .filter((r) => r.dbt)
+      .map((r) => key(r.usage_kind, r.path)),
+  );
+  if (dbtKeys.size === 0) return graph;
+  const kept = (usage_kind: string, path: string) =>
+    !dbtKeys.has(key(usage_kind, path));
+  return {
+    ...graph,
+    runnables: graph.runnables.filter((r) => kept(r.usage_kind, r.path)),
+    edges: graph.edges.filter((e) => kept(e.runnable_kind, e.runnable_path)),
+    triggers: graph.triggers.filter((t) =>
+      kept(t.runnable_kind, t.runnable_path),
+    ),
+    // A macro library is a script; a dbt script defines no macros, so neither
+    // end can be a flow.
+    ...(graph.macro_edges
+      ? {
+          macro_edges: graph.macro_edges.filter(
+            (m) => kept("script", m.lib_path) && kept("script", m.consumer_path),
+          ),
+        }
+      : {}),
+    ...(graph.test_edges
+      ? {
+          test_edges: graph.test_edges.filter(
+            (t) =>
+              kept(t.producer_kind, t.producer_path) &&
+              kept(t.runnable_kind, t.runnable_path),
+          ),
+        }
+      : {}),
+  };
+}
+
 // Build the full pipeline asset-graph from local files in `f/<folder>/`.
 // Only `// pipeline` scripts become graph nodes (pipeline membership), mirroring
 // the deployed graph endpoint. Returns the graph plus the in-pipeline scripts'
@@ -617,6 +695,11 @@ export async function buildLocalPipelineGraph(args: {
       });
       continue;
     }
+    // A dbt project is not a data pipeline: the deploy never marks a dbt script
+    // `auto_kind='pipeline'` and the pipeline canvas drops its node, so the
+    // local graph must not invent one. Its models don't belong here either —
+    // they come from the manifest the deploy derives, not from the descriptor.
+    if (s.language === "dbt") 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);
diff --git a/cli/src/commands/pipeline/pipeline.ts b/cli/src/commands/pipeline/pipeline.ts
index 0738283fba..8d46119e14 100644
--- a/cli/src/commands/pipeline/pipeline.ts
+++ b/cli/src/commands/pipeline/pipeline.ts
@@ -24,6 +24,7 @@ import {
 } from "./boundedCascade.ts";
 import {
   type AssetGraph,
+  hideDbtRunnables,
   type GraphTrigger,
   type LocalScript,
   buildLocalPipelineGraph,
@@ -96,7 +97,7 @@ async function list(opts: GlobalOptions & { json?: boolean }) {
   }
 }
 
-const ASSET_KINDS = "s3object,ducklake,datatable,volume";
+const ASSET_KINDS = "s3object,ducklake,datatable,volume,dbt";
 
 function assetUri(kind: string, path: string): string {
   const prefix = kind === "s3object" ? "s3" : kind;
@@ -132,8 +133,10 @@ async function show(
   } else {
     const workspace = await resolveWorkspace(opts);
     await requireLogin(opts);
-    graph = await apiGet<AssetGraph>(
-      `/w/${workspace.workspaceId}/assets/graph?folder=${encodeURIComponent(f)}&asset_kinds=${ASSET_KINDS}`,
+    graph = hideDbtRunnables(
+      await apiGet<AssetGraph>(
+        `/w/${workspace.workspaceId}/assets/graph?folder=${encodeURIComponent(f)}&asset_kinds=${ASSET_KINDS}`,
+      ),
     );
     enrich = (nativeByScript, roots) => enrichRootMarkers(workspace.workspaceId, graph, nativeByScript, roots);
   }
@@ -612,8 +615,10 @@ async function run(
       }
     }
   } else {
-    graph = await apiGet<BCGraph>(
-      `/w/${workspace.workspaceId}/assets/graph?folder=${encodeURIComponent(f)}&asset_kinds=${ASSET_KINDS}`,
+    graph = hideDbtRunnables(
+      await apiGet<BCGraph>(
+        `/w/${workspace.workspaceId}/assets/graph?folder=${encodeURIComponent(f)}&asset_kinds=${ASSET_KINDS}`,
+      ),
     );
     // Recover marker-only `data_upload`/`webhook`/`email` triggers the graph
     // endpoint can't emit, so input-only entrypoints are cut here as they are
diff --git a/cli/src/commands/script/script.ts b/cli/src/commands/script/script.ts
index c699e3d58f..c933f881b6 100644
--- a/cli/src/commands/script/script.ts
+++ b/cli/src/commands/script/script.ts
@@ -71,10 +71,19 @@ import {
   isScriptModulePath,
   buildModuleFolderPath,
   getModuleFolderSuffix,
+  dbtGeneratedDirs,
+  isUnderGeneratedDir,
+  isLocalSecretFile,
+  moduleFileExclusion,
+  oversizedModuleFileError,
+  MAX_MODULE_BYTES,
   isModuleEntryPoint,
   getScriptBasePathFromModulePath,
   scriptPathToRemotePath,
   isRawAppPath,
+  DBT_DESCRIPTOR_NAME,
+  isDbtDescriptorPath,
+  isMissingDbtDescriptor,
 } from "../../utils/resource_folders.ts";
 
 export interface ScriptFile {
@@ -159,9 +168,18 @@ async function push(opts: PushOptions, filePath: string) {
     return;
   }
 
-  const fstat = await stat(filePath);
-  if (!fstat.isFile()) {
-    throw new Error("file path must refer to a file.");
+  // A dbt project's descriptor is optional, so the one content path a
+  // descriptor-less project has is deliberately not on disk. The project beside
+  // it is what says the script is real.
+  const absentDescriptor = await stat(filePath).then(
+    () => false,
+    (e) => isMissingDbtDescriptor(filePath, e)
+  );
+  if (!absentDescriptor) {
+    const fstat = await stat(filePath);
+    if (!fstat.isFile()) {
+      throw new Error("file path must refer to a file.");
+    }
   }
 
   if (filePath.endsWith(".script.json") || filePath.endsWith(".script.yaml")) {
@@ -174,7 +192,7 @@ async function push(opts: PushOptions, filePath: string) {
 
   // Warn about metadata state before pushing
   try {
-    const content = await readTextFile(filePath);
+    const content = await readScriptContent(filePath);
     const remotePath = removeExtensionToPath(filePath).replaceAll(SEP, "/");
     const contentHash = await computePushMetadataHash(filePath, content);
     const conf = await readLockfile();
@@ -272,7 +290,7 @@ const MODULE_ENTRY_META_RE = /([\\/])script\.(yaml|json|lock)$/;
  * `__mod/`, so this only narrows it to the metadata extensions: a `script.yaml`
  * nested deeper in the module tree is a module file, not the script's metadata.
  */
-function isModuleEntryMetadata(p: string): boolean {
+export function isModuleEntryMetadata(p: string): boolean {
   return isModuleEntryPoint(p) && MODULE_ENTRY_META_RE.test(p);
 }
 
@@ -335,7 +353,7 @@ export async function handleFile(
     // standalone scripts — pushed via pushRawApp, not here.
     !isRawAppPath(path) &&
     (!isScriptModulePath(path) || moduleEntryPoint) &&
-    exts.some((exts) => path.endsWith(exts))
+    hasScriptExt(path)
   ) {
     if (alreadySynced.includes(path)) {
       return true;
@@ -345,6 +363,15 @@ export async function handleFile(
     alreadySynced.push(path);
     const remotePath = scriptPathToRemotePath(path);
 
+    // Before anything is written: this path may also be a dbt project's, and
+    // pushing here would deploy this file over it.
+    const collidingProject = await collidingDbtProject(
+      removeExtensionToPath(path)
+    );
+    if (collidingProject) {
+      throw dbtPathCollisionError(collidingProject, path);
+    }
+
     const language = inferContentTypeFromFilePath(path, opts?.defaultTs);
 
     const codebase =
@@ -479,7 +506,7 @@ export async function handleFile(
     } catch {
       log.debug(`Script ${remotePath} does not exist on remote`);
     }
-    const content = await readTextFile(path);
+    const content = await readScriptContent(path);
 
     if (opts?.skipScriptsMetadata) {
       // if (codebase) {
@@ -499,8 +526,14 @@ export async function handleFile(
     const scriptBasePath = moduleEntryPoint
       ? getScriptBasePathFromModulePath(path)!
       : path.substring(0, path.indexOf("."));
-    const moduleFolderPath = scriptBasePath + getModuleFolderSuffix();
-    const modules = await readModulesFromDisk(moduleFolderPath, opts?.defaultTs, moduleEntryPoint);
+    const isDbt = language === "dbt";
+    const moduleFolderPath = scriptBasePath + getModuleFolderSuffix(language);
+    const modules = await readModulesFromDisk(
+      moduleFolderPath,
+      opts?.defaultTs,
+      moduleEntryPoint,
+      isDbt,
+    );
 
     // A concurrent_limit of <= 0 means "concurrency disabled", not "zero slots" (which
     // would brick the runnable at the queue's concurrency gate). Emit it as omitted rather
@@ -518,7 +551,11 @@ export async function handleFile(
       path: remotePath.replaceAll(SEP, "/"),
       summary: typed?.summary ?? "",
       kind: typed?.kind,
-      lock: typed?.lock,
+      // A dbt lock pins a resolved commit and engine versions that only a
+      // dependency job can determine, and that job is also what publishes the
+      // script's manifest graph. Sending one suppresses that job, so the push
+      // would deploy a stale lock AND leave the graph unpublished.
+      lock: language === "dbt" ? undefined : typed?.lock,
       schema: typed?.schema,
       tag: typed?.tag,
       ws_error_handler_muted: typed?.ws_error_handler_muted,
@@ -679,6 +716,11 @@ export async function readModulesFromDisk(
   moduleFolderPath: string,
   defaultTs: "bun" | "deno" | undefined,
   folderLayout: boolean = false,
+  // A dbt project rides in its module folder as-is: `.sql` models (which the
+  // language inference below rejects as an ambiguous dialect), `.yml` schemas
+  // and `.csv` seeds are all part of the project and none is a Windmill script.
+  // Verbatim, or dbt receives a project missing exactly the files it needs.
+  verbatim: boolean = false,
 ): Promise<Record<string, ScriptModule> | undefined> {
   if (!fs.existsSync(moduleFolderPath) || !fs.statSync(moduleFolderPath).isDirectory()) {
     return undefined;
@@ -686,9 +728,18 @@ export async function readModulesFromDisk(
 
   const modules: Record<string, ScriptModule> = {};
 
+  const skipDirs = verbatim
+    ? dbtGeneratedDirs(moduleFolderPath)
+    : new Set<string>();
+
   // In folder layout mode, skip the entry point files (script.*, script.yaml, etc.)
   const isEntryPointFile = (name: string, isTopLevel: boolean) => {
-    if (!folderLayout || !isTopLevel) return false;
+    if (!isTopLevel) return false;
+    // A dbt project's descriptor is the script's CONTENT, so it must not also
+    // ride along as a module: the push would send the same text twice and dbt
+    // would find a stray file at its project root.
+    if (verbatim) return name === DBT_DESCRIPTOR_NAME;
+    if (!folderLayout) return false;
     return (
       name.startsWith("script.") ||
       name === "script.lock" ||
@@ -705,10 +756,63 @@ export async function readModulesFromDisk(
       const isTopLevel = relPrefix === "";
 
       if (entry.isDirectory()) {
+        // A configured `target-path` may be nested (`build/target`), so the
+        // comparison is on the project-relative path, not the entry name.
+        if (skipDirs.size > 0 && isUnderGeneratedDir(relPath, skipDirs)) continue;
         readDir(fullPath, relPath);
-      } else if (entry.isFile() && !entry.name.endsWith(".lock") && !isEntryPointFile(entry.name, isTopLevel)) {
-        // Skip lock files — they're handled as the `lock` field on ScriptModule
-        if (exts.some((ext) => entry.name.endsWith(ext))) {
+        // `.lock` is the script's own lockfile in a `__mod` bundle (the `lock`
+        // field on ScriptModule) — but a dbt project's files are its author's,
+        // and one may legitimately be named `uv.lock`. Dropping it would break
+        // the unmodified-project round trip this bundle exists to keep.
+      } else if (
+        entry.isFile() &&
+        (verbatim || !entry.name.endsWith(".lock")) &&
+        !isEntryPointFile(entry.name, isTopLevel)
+      ) {
+        if (verbatim) {
+          // Secrets stay on the machine that holds them. Skipped before the
+          // read, and loudly: a `.env` swept into the bundle is a credential
+          // stored in every version of the script and handed back on pull.
+          if (isLocalSecretFile(entry.name)) {
+            log.warn(
+              `Skipping ${relPath}: a local secrets file is not part of the dbt project — ` +
+                `dbt reads its values from the environment, so set them in the script's ` +
+                `environment variables or the descriptor's \`env\``,
+            );
+            continue;
+          }
+          // A dbt project's authored files are text. A binary one -- an image
+          // under `docs/`, a `.DS_Store`, a parquet seed -- would be read as
+          // mojibake and, if it carries a NUL, rejected by Postgres with an
+          // opaque `unsupported Unicode escape sequence`, which the push then
+          // reports as success. Skip it, loudly: dbt does not read it either.
+          //
+          // Asked BEFORE reading: the predicate only stats the file and reads
+          // its first 8 KB, so a multi-gigabyte seed next to the project costs
+          // that rather than being loaded whole just to be rejected.
+          const exclusion = moduleFileExclusion(fullPath);
+          if (exclusion !== undefined) {
+            // Over the limit but readable as text — a large seed CSV is the
+            // realistic case — is refused rather than skipped: dbt WOULD have
+            // read it, so shipping the project without it deploys something that
+            // compiles here and fails at run time with a missing relation.
+            if (exclusion === "oversized") {
+              throw oversizedModuleFileError(relPath, fs.statSync(fullPath).size);
+            }
+            log.warn(
+              `Skipping ${relPath}: not a text file, so it is not part of the dbt project the ` +
+                `bundle carries — dbt does not read it either`,
+            );
+            continue;
+          }
+          // `language` is a required field of the API type and is not used for
+          // these: the worker writes them to their relative path and dbt reads
+          // the tree.
+          modules[relPath] = {
+            content: fs.readFileSync(fullPath).toString("utf-8"),
+            language: "dbt" as ScriptModule["language"],
+          };
+        } else if (exts.some((ext) => entry.name.endsWith(ext))) {
           const content = readTextFileSync(fullPath);
           const language = inferContentTypeFromFilePath(entry.name, defaultTs);
 
@@ -889,6 +993,62 @@ async function createScript(
  */
 export class UnresolvableScriptContentFileError extends Error {}
 
+/**
+ * A path claimed by both a dbt project and an ordinary script.
+ *
+ * Its own class because the module push tolerates "no parent found" and must
+ * NOT tolerate this: swallowed, the command reports success while deploying
+ * nothing.
+ */
+export class DbtPathCollisionError extends UnresolvableScriptContentFileError {}
+
+/**
+ * The dbt project a path would collide with, if there is one.
+ *
+ * `<base>.py` and `<base>__dbt/` deploy to the SAME remote path, so whichever
+ * is pushed last wins and replaces the other's script. The descriptor is
+ * optional, so `dbt_project.yml` — not the descriptor — is what says a project
+ * is there. Asked on BOTH push paths: an ordinary file goes straight to
+ * `handleFile`, a model reaches its parent through `findContentFile`, and a
+ * guard on one of them leaves the other silently overwriting.
+ */
+export async function collidingDbtProject(
+  basePath: string
+): Promise<string | undefined> {
+  const project = basePath + "__dbt/dbt_project.yml";
+  return (await stat(project).then(() => true).catch(() => false))
+    ? project
+    : undefined;
+}
+
+export function dbtPathCollisionError(
+  project: string,
+  other: string
+): DbtPathCollisionError {
+  return new DbtPathCollisionError(
+    `${project} and ${other} deploy to the same path, so pushing either one ` +
+      `replaces the other's script. Keep one: move the dbt project to a path ` +
+      `of its own, or remove ${other}.`
+  );
+}
+
+
+/**
+ * A script's content, tolerating the one content file that may not exist: a dbt
+ * project's descriptor is optional, and absent means an empty descriptor.
+ */
+async function readScriptContent(filePath: string): Promise<string> {
+  try {
+    return await readTextFile(filePath);
+  } catch (e) {
+    // ONLY a missing file is an empty descriptor. A permission or I/O error on a
+    // descriptor that does exist would otherwise deploy the defaults — the
+    // `main` warehouse and the whole project — in place of what the file says.
+    if (isMissingDbtDescriptor(filePath, e)) return "";
+    throw e;
+  }
+}
+
 export async function findContentFile(filePath: string) {
   // Folder layout: __mod/script.yaml -> __mod/script.ts
   const isModuleFolderMeta = isModuleEntryMetadata(filePath);
@@ -924,6 +1084,20 @@ export async function findContentFile(filePath: string) {
   )
     .filter((x) => x.file)
     .map((x) => x.path);
+  // A dbt project's descriptor is OPTIONAL, so `dbt_project.yml` is what says a
+  // dbt script lives at this path — the descriptor is often absent from the
+  // candidates above while the project is perfectly real. Asked BEFORE the
+  // counts below: a project beside an ordinary script is not "one candidate",
+  // it is two scripts claiming one remote path, and returning the ordinary one
+  // deploys it OVER the dbt script on the next push of any model.
+  const dbtCandidate = toCandidate("__dbt/" + DBT_DESCRIPTOR_NAME);
+  const dbtProject = await collidingDbtProject(
+    dbtCandidate.slice(0, -("__dbt/" + DBT_DESCRIPTOR_NAME).length),
+  );
+  const nonDbtCandidates = validCandidates.filter((c) => c !== dbtCandidate);
+  if (dbtProject && nonDbtCandidates.length > 0) {
+    throw dbtPathCollisionError(dbtProject, nonDbtCandidates.join(", "));
+  }
   if (validCandidates.length > 1) {
     throw new UnresolvableScriptContentFileError(
       `Multiple script files found next to ${filePath}: ${validCandidates.join(", ")} — ` +
@@ -931,6 +1105,11 @@ export async function findContentFile(filePath: string) {
     );
   }
   if (validCandidates.length < 1) {
+    // Resolving to the absent descriptor keeps one content path for every
+    // caller; reading it yields an empty descriptor.
+    if (dbtProject) {
+      return dbtCandidate;
+    }
     throw new UnresolvableScriptContentFileError(
       `No script file found next to ${filePath} — a script cannot be deployed from its metadata alone. ` +
         `Add the matching script file (e.g. ${toCandidate(".ts")} or ${toCandidate(
@@ -999,6 +1178,10 @@ export function filePathExtensionFromContentType(
     return ".rb";
   } else if (language === "rlang") {
     return ".r";
+  } else if (language === "dbt") {
+    // Not an extension but a path suffix: a dbt script's content file lives
+    // inside the project folder, so `<base> + this` is where it belongs.
+    return "__dbt/" + DBT_DESCRIPTOR_NAME;
     // for related places search: ADD_NEW_LANG
   } else {
     throw new Error("Invalid language: " + language);
@@ -1031,12 +1214,28 @@ export const exts = [
   ".java",
   ".rb",
   ".r",
+  // Not an extension: a dbt script's content file is its descriptor, inside
+  // the project folder. `<base>.script.yaml` -> `<base>__dbt/wm_dbt.yaml`.
+  "__dbt/" + DBT_DESCRIPTOR_NAME,
   // for related places search: ADD_NEW_LANG
 ];
 
+/**
+ * Whether a path is a script's content file.
+ *
+ * Separators are normalized first: one "extension" is the path suffix
+ * `__dbt/wm_dbt.yaml`, which on Windows is spelled `__dbt\wm_dbt.yaml` and
+ * would match nothing — silently skipping every dbt project on that platform.
+ */
+export function hasScriptExt(p: string): boolean {
+  const norm = p.replaceAll("\\", "/");
+  return exts.some((ext) => norm.endsWith(ext));
+}
+
 export function removeExtensionToPath(path: string): string {
+  const norm = path.replaceAll("\\", "/");
   for (const ext of exts) {
-    if (path.endsWith(ext)) {
+    if (norm.endsWith(ext)) {
       return path.substring(0, path.length - ext.length);
     }
   }
@@ -1450,7 +1649,7 @@ export async function generateMetadata(
       await FSFSElement(process.cwd(), codebases, false),
       (p, isD) => {
         return (
-          (!isD && !exts.some((ext) => p.endsWith(ext))) ||
+          (!isD && !hasScriptExt(p)) ||
           ignore(p, isD) ||
           isFlowPath(p) ||
           isAppPath(p) ||
@@ -1569,9 +1768,17 @@ async function preview(
     return;
   }
 
-  const fstat = await stat(filePath);
-  if (!fstat.isFile()) {
-    throw new Error("file path must refer to a file.");
+  // Same as push: a descriptor-less dbt project's content path is deliberately
+  // absent, and the project beside it is what says the script is real.
+  const absentDescriptor = await stat(filePath).then(
+    () => false,
+    (e) => isMissingDbtDescriptor(filePath, e)
+  );
+  if (!absentDescriptor) {
+    const fstat = await stat(filePath);
+    if (!fstat.isFile()) {
+      throw new Error("file path must refer to a file.");
+    }
   }
 
   if (filePath.endsWith(".script.json") || filePath.endsWith(".script.yaml")) {
@@ -1582,15 +1789,23 @@ async function preview(
 
   const codebases = await listSyncCodebases(opts);
   const language = inferContentTypeFromFilePath(filePath, opts?.defaultTs);
-  const content = await readTextFile(filePath);
+  const content = await readScriptContent(filePath);
   const input = opts.data ? await resolve(opts.data) : {};
 
-  // Read modules from __mod/ folder if present
+  // Read modules from the bundle folder if present. Same suffix and same
+  // verbatim read as deploy: a dbt project lives in `__dbt/`, and parsing its
+  // files as scripts would drop the `dbt_project.yml` the executor looks for.
   const isFolderLayout = isModuleEntryPoint(filePath);
+  const isDbt = language === "dbt";
   const moduleFolderPath = isFolderLayout
     ? path.dirname(filePath)
-    : filePath.substring(0, filePath.indexOf(".")) + getModuleFolderSuffix();
-  const modules = await readModulesFromDisk(moduleFolderPath, opts?.defaultTs, isFolderLayout);
+    : filePath.substring(0, filePath.indexOf(".")) + getModuleFolderSuffix(language);
+  const modules = await readModulesFromDisk(
+    moduleFolderPath,
+    opts?.defaultTs,
+    isFolderLayout,
+    isDbt
+  );
 
   // Check if this is a codebase script
   const codebase =
diff --git a/cli/src/commands/sync/sync.ts b/cli/src/commands/sync/sync.ts
index a7a1fb6d4d..dcbee2337d 100644
--- a/cli/src/commands/sync/sync.ts
+++ b/cli/src/commands/sync/sync.ts
@@ -1,13 +1,27 @@
 import { requireLogin } from "../../core/auth.ts";
 import { fetchVersion, resolveWorkspace } from "../../core/context.ts";
-import { writeFile, readdir, stat, rm, copyFile, mkdir } from "node:fs/promises";
+import {
+  writeFile,
+  readdir,
+  stat,
+  rm,
+  copyFile,
+  mkdir,
+} from "node:fs/promises";
+import { existsSync } from "node:fs";
 import { colors } from "@cliffy/ansi/colors";
 import { Command } from "@cliffy/command";
 import { Confirm } from "@cliffy/prompt/confirm";
 import * as log from "../../core/log.ts";
 import * as path from "node:path";
 import { sep as SEP } from "node:path";
-import { stringify as yamlStringify, type DocumentOptions, type SchemaOptions, type CreateNodeOptions, type ToStringOptions } from "yaml";
+import {
+  stringify as yamlStringify,
+  type DocumentOptions,
+  type SchemaOptions,
+  type CreateNodeOptions,
+  type ToStringOptions,
+} from "yaml";
 import JSZip from "jszip";
 import { minimatch } from "minimatch";
 import { yamlParseContent } from "../../utils/yaml.ts";
@@ -39,13 +53,15 @@ import {
   exts,
   findContentFile,
   findResourceFile,
+  isModuleEntryMetadata,
   handleScriptMetadata,
   UnresolvableScriptContentFileError,
   removeExtensionToPath,
   filePathExtensionFromContentType,
+  hasScriptExt,
 } from "../script/script.ts";
 
-import { handleFile } from "../script/script.ts";
+import { DbtPathCollisionError, handleFile } from "../script/script.ts";
 import {
   deepEqual,
   fetchRemoteVersion,
@@ -101,15 +117,25 @@ import {
   MalformedLockfileError,
   workspaceDependenciesPathToLanguageAndFilename,
 } from "../../utils/metadata.ts";
-import { DoubleLinkedDependencyTree, uploadScripts } from "../../utils/dependency_tree.ts";
-import { OpenFlow, NativeServiceName, ScriptModule } from "../../../gen/types.gen.ts";
+import {
+  DoubleLinkedDependencyTree,
+  uploadScripts,
+} from "../../utils/dependency_tree.ts";
+import {
+  OpenFlow,
+  NativeServiceName,
+  ScriptModule,
+} from "../../../gen/types.gen.ts";
 import { pushResource } from "../resource/resource.ts";
 import {
   newPathAssigner,
   newRawAppPathAssigner,
   PathAssigner,
 } from "../../../windmill-utils-internal/src/path-utils/path-assigner.ts";
-import { extractInlineScripts as extractInlineScriptsForFlows, extractCurrentMapping } from "../../../windmill-utils-internal/src/inline-scripts/extractor.ts";
+import {
+  extractInlineScripts as extractInlineScriptsForFlows,
+  extractCurrentMapping,
+} from "../../../windmill-utils-internal/src/inline-scripts/extractor.ts";
 import { generateFlowLockInternal } from "../flow/flow_metadata.ts";
 import { isExecutionModeAnonymous } from "../app/app.ts";
 import {
@@ -134,10 +160,15 @@ import {
   getFolderSuffixWithSep,
   getNonDottedPaths,
   isScriptModulePath,
+  oversizedDbtFileError,
   getModuleFolderSuffix,
+  isDbtModulePath,
+  isDbtGeneratedPath,
   isModuleEntryPoint,
   getScriptBasePathFromModulePath,
   hasWrongFormatSuffix,
+  DBT_DESCRIPTOR_NAME,
+  isDbtDescriptorPath,
 } from "../../utils/resource_folders.ts";
 
 let branchDeprecationWarned = false;
@@ -156,12 +187,12 @@ function configKeyForItemKind(
       return "resources";
     case "variable":
       return "variables";
-      // case "schedule":
-      //   return "schedules";
-      // default:
-      //   return kind.endsWith("_trigger") ? "triggers" : null;
-    }
-    return null
+    // case "schedule":
+    //   return "schedules";
+    // default:
+    //   return kind.endsWith("_trigger") ? "triggers" : null;
+  }
+  return null;
 }
 
 // Fetch ws_specific items from the server and merge their paths into specificItems.
@@ -184,8 +215,11 @@ async function mergeWsSpecificFromServer(
     // 404 = endpoint not present on an older server: expected, log at debug.
     // Anything else (401/403/network) is a real failure that produces an
     // incomplete sync — surface it so the user notices.
-    const isApiError = err && typeof err === "object" &&
-      "name" in err && (err as { name: unknown }).name === "ApiError";
+    const isApiError =
+      err &&
+      typeof err === "object" &&
+      "name" in err &&
+      (err as { name: unknown }).name === "ApiError";
     const status = isApiError ? (err as { status?: number }).status : undefined;
     if (status === 404) {
       log.debug("listWsSpecific endpoint not available on server, skipping");
@@ -237,9 +271,7 @@ export function computeWsSpecificFlagOnlyPushes(
 ): Array<{ kind: string; serverPath: string; filePath: string }> {
   if (!localSpecificItems || serverItems === null) return [];
 
-  const serverSet = new Set(
-    serverItems.map((i) => `${i.item_kind}:${i.path}`),
-  );
+  const serverSet = new Set(serverItems.map((i) => `${i.item_kind}:${i.path}`));
 
   const out: Array<{ kind: string; serverPath: string; filePath: string }> = [];
   for (const filePath of Object.keys(localMap)) {
@@ -263,7 +295,10 @@ export function computeWsSpecificFlagOnlyPushes(
 
 // Resolve workspace name from a --branch override (git branch → workspace name).
 // Falls back to using the branch value as-is (backward compat: old key = branch name).
-function resolveWsNameFromBranch(opts: SyncOptions, branchName: string): string {
+function resolveWsNameFromBranch(
+  opts: SyncOptions,
+  branchName: string,
+): string {
   const match = findWorkspaceByGitBranch(opts.workspaces, branchName);
   return match ? match[0] : branchName;
 }
@@ -290,17 +325,23 @@ export function resolveWsNameForConfigFromFlags(
 }
 
 // Warn if --workspace overrides auto-detected branch or if workspace not in config.
-function warnWorkspaceOverride(opts: SyncOptions, wsNameForConfig: string | undefined): void {
+function warnWorkspaceOverride(
+  opts: SyncOptions,
+  wsNameForConfig: string | undefined,
+): void {
   if (!wsNameForConfig || !opts.workspaces) return;
 
   // Check if workspace exists in config
-  const wsEntry = (opts.workspaces as any)?.[wsNameForConfig] as WorkspaceEntryConfig | undefined;
+  const wsEntry = (opts.workspaces as any)?.[wsNameForConfig] as
+    WorkspaceEntryConfig | undefined;
   if (!wsEntry) {
-    const wsNames = Object.keys(opts.workspaces).filter((k) => k !== "commonSpecificItems");
+    const wsNames = Object.keys(opts.workspaces).filter(
+      (k) => k !== "commonSpecificItems",
+    );
     if (wsNames.length > 0) {
       log.warn(
         `⚠️  Workspace '${wsNameForConfig}' is not defined in the 'workspaces' section of wmill.yaml.\n` +
-        `   No workspace-specific overrides will be applied. Available workspaces: ${wsNames.join(", ")}`
+          `   No workspace-specific overrides will be applied. Available workspaces: ${wsNames.join(", ")}`,
       );
     }
     return;
@@ -310,11 +351,14 @@ function warnWorkspaceOverride(opts: SyncOptions, wsNameForConfig: string | unde
   if (isGitRepository()) {
     const currentBranch = getCurrentGitBranch();
     if (currentBranch) {
-      const autoMatch = findWorkspaceByGitBranch(opts.workspaces, currentBranch);
+      const autoMatch = findWorkspaceByGitBranch(
+        opts.workspaces,
+        currentBranch,
+      );
       if (autoMatch && autoMatch[0] !== wsNameForConfig) {
         log.info(
           `Current git branch '${currentBranch}' maps to workspace '${autoMatch[0]}', ` +
-          `but --workspace overrides to '${wsNameForConfig}'.`
+            `but --workspace overrides to '${wsNameForConfig}'.`,
         );
       }
     }
@@ -329,9 +373,14 @@ function resolveWsNameForFiles(_opts: SyncOptions, wsName: string): string {
 
 // After resolveWorkspace, infer the workspace config name from the resolved profile
 // by matching baseUrl + workspaceId against the workspaces config entries.
-function inferWsNameFromProfile(opts: SyncOptions, profile: { remote: string; workspaceId: string }): string | undefined {
+function inferWsNameFromProfile(
+  opts: SyncOptions,
+  profile: { remote: string; workspaceId: string },
+): string | undefined {
   if (!opts.workspaces) return undefined;
-  const wsNames = Object.keys(opts.workspaces).filter((k) => k !== "commonSpecificItems");
+  const wsNames = Object.keys(opts.workspaces).filter(
+    (k) => k !== "commonSpecificItems",
+  );
   for (const name of wsNames) {
     const entry = (opts.workspaces as any)[name] as WorkspaceEntryConfig;
     if (!entry?.baseUrl) continue;
@@ -364,7 +413,13 @@ async function resolveEffectiveSyncOptions(
   promotion?: string,
   workspaceNameOverride?: string,
 ): Promise<SyncOptions> {
-  return await getEffectiveSettings(localConfig, promotion, false, false, workspaceNameOverride);
+  return await getEffectiveSettings(
+    localConfig,
+    promotion,
+    false,
+    false,
+    workspaceNameOverride,
+  );
 }
 
 type DynFSElement = {
@@ -464,6 +519,27 @@ async function addCodebaseDigestIfRelevant(
   return content;
 }
 
+/**
+ * Whether a script's modules ARE a dbt project.
+ *
+ * Keyed on `dbt_project.yml` rather than on the descriptor: the descriptor is
+ * optional, so its absence says nothing, while a dbt project without
+ * `dbt_project.yml` is one dbt itself refuses to run.
+ *
+ * Its LANGUAGE decides, not its name. A dbt bundle is read verbatim and every
+ * file in it is stored as `dbt`; an ordinary modular script that happens to
+ * vendor a dbt project stores that same file as whatever its extension infers,
+ * and calling it dbt would lay the bundle out as `__dbt` and drop it on the
+ * next push.
+ */
+function isDbtModules(modules: unknown): boolean {
+  if (typeof modules !== "object" || modules === null) return false;
+  const marker = (modules as Record<string, { language?: string }>)[
+    "dbt_project.yml"
+  ];
+  return marker?.language === "dbt";
+}
+
 export async function FSFSElement(
   p: string,
   codebases: SyncCodebase[],
@@ -493,8 +569,14 @@ export async function FSFSElement(
         }
       },
       async getContentText(): Promise<string> {
-        const content = await readTextFile(localP);
         const itemPath = localP.substring(p.length + 1);
+        // BEFORE the read: an oversized dbt project file stays visible to the
+        // diff on purpose (so the push reports it rather than silently shipping
+        // an incomplete project), and buffering a multi-gigabyte seed to reach
+        // that error is what this refusal exists to avoid.
+        const oversized = oversizedDbtFileError(localP, itemPath);
+        if (oversized) throw oversized;
+        const content = await readTextFile(localP);
         const r = await addCodebaseDigestIfRelevant(
           itemPath,
           content,
@@ -527,9 +609,14 @@ function prioritizeName(name: string): string {
   return name;
 }
 
-export const yamlOptions: DocumentOptions & SchemaOptions & CreateNodeOptions & ToStringOptions = {
+export const yamlOptions: DocumentOptions &
+  SchemaOptions &
+  CreateNodeOptions &
+  ToStringOptions = {
   sortMapEntries: (a, b) => {
-    return prioritizeName(String(a.key)).localeCompare(prioritizeName(String(b.key)));
+    return prioritizeName(String(a.key)).localeCompare(
+      prioritizeName(String(b.key)),
+    );
   },
   aliasDuplicateObjects: false,
   singleQuote: true,
@@ -593,11 +680,15 @@ export function extractFieldsForRawApps(runnables: Record<string, any>) {
  * References the raw-app skill for complete documentation and includes instance-specific
  * data configuration (datatable, schema, whitelisted tables).
  */
-export function generateAgentsDocumentation(data: {
-  tables?: string[];
-  datatable?: string;
-  schema?: string;
-} | undefined): string {
+export function generateAgentsDocumentation(
+  data:
+    | {
+        tables?: string[];
+        datatable?: string;
+        schema?: string;
+      }
+    | undefined,
+): string {
   const tables = data?.tables ?? [];
   const defaultDatatable = data?.datatable;
   const defaultSchema = data?.schema;
@@ -612,15 +703,19 @@ This file contains **app-specific configuration** for this raw app instance.
 
 ## Data Configuration
 
-${defaultDatatable
-  ? `**Default Datatable:** \`${defaultDatatable}\`${defaultSchema ? ` | **Default Schema:** \`${defaultSchema}\`` : ''}`
-  : '**No default datatable configured.** Set \`data.datatable\` in \`raw_app.yaml\` to enable database access.'}
+${
+  defaultDatatable
+    ? `**Default Datatable:** \`${defaultDatatable}\`${defaultSchema ? ` | **Default Schema:** \`${defaultSchema}\`` : ""}`
+    : "**No default datatable configured.** Set \`data.datatable\` in \`raw_app.yaml\` to enable database access."
+}
 
 ### Whitelisted Tables
 
-${tables.length > 0
-  ? `These tables are accessible to this app:\n\n${tables.map(t => `- \`${t}\``).join('\n')}`
-  : `**No tables whitelisted.** Add tables to \`data.tables\` in \`raw_app.yaml\`.`}
+${
+  tables.length > 0
+    ? `These tables are accessible to this app:\n\n${tables.map((t) => `- \`${t}\``).join("\n")}`
+    : `**No tables whitelisted.** Add tables to \`data.tables\` in \`raw_app.yaml\`.`
+}
 
 ### Adding a Table
 
@@ -628,10 +723,10 @@ Edit \`raw_app.yaml\`:
 
 \`\`\`yaml
 data:
-  datatable: ${defaultDatatable || 'main'}
-  ${defaultSchema ? `schema: ${defaultSchema}\n  ` : ''}tables:
-${tables.length > 0 ? tables.map(t => `    - ${t}`).join('\n') : '    # Add tables here'}
-    - ${defaultDatatable || 'main'}/${defaultSchema ? defaultSchema + ':' : ''}new_table  # ← Add like this
+  datatable: ${defaultDatatable || "main"}
+  ${defaultSchema ? `schema: ${defaultSchema}\n  ` : ""}tables:
+${tables.length > 0 ? tables.map((t) => `    - ${t}`).join("\n") : "    # Add tables here"}
+    - ${defaultDatatable || "main"}/${defaultSchema ? defaultSchema + ":" : ""}new_table  # ← Add like this
 \`\`\`
 
 **Table reference formats:**
@@ -667,11 +762,15 @@ const rows = await sql\`SELECT * FROM table WHERE id = \${id}\`.fetch();
  * Generates a simple DATATABLES.md with just the current configuration summary.
  * The detailed schema information is generated by generate_datatables.ts command.
  */
-export function generateDatatablesDocumentation(data: {
-  tables?: string[];
-  datatable?: string;
-  schema?: string;
-} | undefined): string {
+export function generateDatatablesDocumentation(
+  data:
+    | {
+        tables?: string[];
+        datatable?: string;
+        schema?: string;
+      }
+    | undefined,
+): string {
   const tables = data?.tables ?? [];
   const defaultDatatable = data?.datatable;
   const defaultSchema = data?.schema;
@@ -685,15 +784,19 @@ Run \`wmill app generate-agents\` to refresh with current workspace schemas.
 
 ## Current Configuration
 
-${defaultDatatable
-  ? `**Default Datatable:** \`${defaultDatatable}\`${defaultSchema ? ` | **Default Schema:** \`${defaultSchema}\`` : ''}`
-  : '**No default datatable configured.**'}
+${
+  defaultDatatable
+    ? `**Default Datatable:** \`${defaultDatatable}\`${defaultSchema ? ` | **Default Schema:** \`${defaultSchema}\`` : ""}`
+    : "**No default datatable configured.**"
+}
 
 ## Whitelisted Tables
 
-${tables.length > 0
-  ? `${tables.map(t => `- \`${t}\``).join('\n')}`
-  : `*No tables whitelisted. Add tables to \`data.tables\` in \`raw_app.yaml\`.*`}
+${
+  tables.length > 0
+    ? `${tables.map((t) => `- \`${t}\``).join("\n")}`
+    : `*No tables whitelisted. Add tables to \`data.tables\` in \`raw_app.yaml\`.*`
+}
 
 ---
 
@@ -763,11 +866,17 @@ export function extractInlineScriptsForApps(
   return [];
 }
 
-type FileResourceTypeInfo = { format_extension: string | null; is_fileset: boolean };
+type FileResourceTypeInfo = {
+  format_extension: string | null;
+  is_fileset: boolean;
+};
 
 function parseFileResourceTypeMap(
   raw: Record<string, string | FileResourceTypeInfo>,
-): { formatExtMap: Record<string, string>; filesetMap: Record<string, boolean> } {
+): {
+  formatExtMap: Record<string, string>;
+  filesetMap: Record<string, boolean>;
+} {
   const formatExtMap: Record<string, string> = {};
   const filesetMap: Record<string, boolean> = {};
   for (const [k, v] of Object.entries(raw)) {
@@ -801,7 +910,9 @@ async function findFilesetResourceFile(changePath: string): Promise<string> {
       // not found, try next
     }
   }
-  throw new Error(`No resource metadata file found for fileset resource: ${changePath}`);
+  throw new Error(
+    `No resource metadata file found for fileset resource: ${changePath}`,
+  );
 }
 
 type FilesetPushResult =
@@ -873,9 +984,13 @@ function ZipFSElement(
             const content = await zip.files[filename].async("text");
             const parsed = JSON.parse(content);
             if (parsed.modules && Object.keys(parsed.modules).length > 0) {
-              _moduleScriptPaths.add(
-                filename.slice(0, -".script.json".length)
-              );
+              const base = filename.slice(0, -".script.json".length);
+              // A dbt script's modules ARE its dbt project, so it keeps the flat
+              // layout: only the project goes in the folder, which is what
+              // `--project-dir` expects and what makes the import a plain copy.
+              if (!isDbtModules(parsed.modules)) {
+                _moduleScriptPaths.add(base);
+              }
             }
           } catch {}
         }
@@ -928,7 +1043,7 @@ function ZipFSElement(
     let finalPath = transformPath();
 
     // Redirect content files for scripts with modules into __mod/ folder
-    if (kind == "other" && exts.some((ext) => p.endsWith(ext))) {
+    if (kind == "other" && hasScriptExt(p)) {
       const normalizedP = p.replace(/^\.[\\/]/, "");
       const moduleScripts = await getModuleScriptPaths();
       for (const basePath of moduleScripts) {
@@ -936,7 +1051,11 @@ function ZipFSElement(
           const ext = normalizedP.slice(basePath.length); // e.g., ".ts", ".py"
           const dir = path.dirname(finalPath);
           const base = path.basename(basePath);
-          finalPath = path.join(dir, base + getModuleFolderSuffix(), "script" + ext);
+          finalPath = path.join(
+            dir,
+            base + getModuleFolderSuffix(),
+            "script" + ext,
+          );
           break;
         }
       }
@@ -957,7 +1076,9 @@ function ZipFSElement(
             }
             let inlineScripts;
             try {
-              const assigner = newPathAssigner(defaultTs, { skipInlineScriptSuffix: getNonDottedPaths() });
+              const assigner = newPathAssigner(defaultTs, {
+                skipInlineScriptSuffix: getNonDottedPaths(),
+              });
               // Preserve original !inline filenames from the flow to avoid phantom renames
               const inlineMapping = extractCurrentMapping(
                 flow.value.modules as any,
@@ -971,27 +1092,40 @@ function ZipFSElement(
                 SEP,
                 defaultTs,
                 assigner,
-                { skipInlineScriptSuffix: getNonDottedPaths(), failOnInlineDirective: true },
+                {
+                  skipInlineScriptSuffix: getNonDottedPaths(),
+                  failOnInlineDirective: true,
+                },
               );
               if (flow.value.failure_module) {
-                inlineScripts.push(...extractInlineScriptsForFlows(
-                  [flow.value.failure_module],
-                  inlineMapping,
-                  SEP,
-                  defaultTs,
-                  assigner,
-                  { skipInlineScriptSuffix: getNonDottedPaths(), failOnInlineDirective: true },
-                ));
+                inlineScripts.push(
+                  ...extractInlineScriptsForFlows(
+                    [flow.value.failure_module],
+                    inlineMapping,
+                    SEP,
+                    defaultTs,
+                    assigner,
+                    {
+                      skipInlineScriptSuffix: getNonDottedPaths(),
+                      failOnInlineDirective: true,
+                    },
+                  ),
+                );
               }
               if (flow.value.preprocessor_module) {
-                inlineScripts.push(...extractInlineScriptsForFlows(
-                  [flow.value.preprocessor_module],
-                  inlineMapping,
-                  SEP,
-                  defaultTs,
-                  assigner,
-                  { skipInlineScriptSuffix: getNonDottedPaths(), failOnInlineDirective: true },
-                ));
+                inlineScripts.push(
+                  ...extractInlineScriptsForFlows(
+                    [flow.value.preprocessor_module],
+                    inlineMapping,
+                    SEP,
+                    defaultTs,
+                    assigner,
+                    {
+                      skipInlineScriptSuffix: getNonDottedPaths(),
+                      failOnInlineDirective: true,
+                    },
+                  ),
+                );
               }
             } catch (error) {
               log.error(
@@ -1040,7 +1174,9 @@ function ZipFSElement(
               inlineScripts = extractInlineScriptsForApps(
                 undefined,
                 app?.["value"],
-                newPathAssigner(defaultTs, { skipInlineScriptSuffix: getNonDottedPaths() }),
+                newPathAssigner(defaultTs, {
+                  skipInlineScriptSuffix: getNonDottedPaths(),
+                }),
                 (_, val) => val["name"],
                 false,
               );
@@ -1126,7 +1262,7 @@ function ZipFSElement(
                   isDirectory: false,
                   path: path.join(finalPath, filePath.substring(1)),
                   async *getChildren() {},
-                    async getContentText() {
+                  async getContentText() {
                     if (typeof content !== "string") {
                       throw new Error(
                         `Content of raw app file ${filePath} is not a string`,
@@ -1215,7 +1351,9 @@ function ZipFSElement(
 
               // Simplify fields for cleaner YAML output
               if (simplifiedRunnable.fields) {
-                simplifiedRunnable.fields = simplifyFields(simplifiedRunnable.fields);
+                simplifiedRunnable.fields = simplifyFields(
+                  simplifiedRunnable.fields,
+                );
               }
 
               yield {
@@ -1274,17 +1412,28 @@ function ZipFSElement(
               log.error(`Failed to parse script.yaml at path: ${p}`);
               throw error;
             }
-            const hasModules = parsed["modules"] && Object.keys(parsed["modules"]).length > 0;
+            const hasModules =
+              parsed["modules"] && Object.keys(parsed["modules"]).length > 0;
+            // A dbt script's module folder holds its dbt project and dbt's own
+            // files, so its lock stays outside like a plain script's — only the
+            // descriptor lives in there.
+            const isDbtScript = isDbtModules(parsed["modules"]);
             if (
               parsed["lock"] &&
               parsed["lock"] != "" &&
               parsed["codebase"] == undefined
             ) {
-              if (hasModules) {
+              if (hasModules && !isDbtScript) {
                 // Lock lives inside __mod/ folder as script.lock
-                const scriptBase = removeSuffix(removeSuffix(p.replaceAll(SEP, "/"), ".json"), ".script");
+                const scriptBase = removeSuffix(
+                  removeSuffix(p.replaceAll(SEP, "/"), ".json"),
+                  ".script",
+                );
                 parsed["lock"] =
-                  "!inline " + scriptBase + getModuleFolderSuffix() + "/script.lock";
+                  "!inline " +
+                  scriptBase +
+                  getModuleFolderSuffix() +
+                  "/script.lock";
               } else {
                 parsed["lock"] =
                   "!inline " +
@@ -1324,8 +1473,7 @@ function ZipFSElement(
               throw error;
             }
             const resourceType = parsed["resource_type"];
-            const formatExtension =
-              resourceTypeToFormatExtension[resourceType];
+            const formatExtension = resourceTypeToFormatExtension[resourceType];
             const isFileset = resourceTypeToIsFileset[resourceType] ?? false;
 
             if (isFileset) {
@@ -1390,18 +1538,24 @@ function ZipFSElement(
         throw error;
       }
       const lock = parsed["lock"];
-      const scriptModules: Record<string, ScriptModule> | undefined = parsed["modules"];
+      const scriptModules: Record<string, ScriptModule> | undefined =
+        parsed["modules"];
       const hasModules = scriptModules && Object.keys(scriptModules).length > 0;
+      // A dbt script's module folder is its dbt project, so the metadata and
+      // lock stay beside it — the descriptor is the one Windmill file that goes
+      // in, because it is the script's content.
+      const isDbt = isDbtModules(scriptModules);
 
       // Compute base path and module folder
       const metaExt = useYaml ? ".yaml" : ".json";
       const scriptBasePath = removeSuffix(
         removeSuffix(finalPath, metaExt),
-        ".script"
+        ".script",
       );
-      const moduleFolderPath = scriptBasePath + getModuleFolderSuffix();
+      const moduleFolderPath =
+        scriptBasePath + getModuleFolderSuffix(isDbt ? "dbt" : undefined);
 
-      if (hasModules) {
+      if (hasModules && !isDbt) {
         // Redirect metadata into __mod/script.yaml
         r[0].path = path.join(moduleFolderPath, "script" + metaExt);
       }
@@ -1409,9 +1563,10 @@ function ZipFSElement(
       if (lock && lock != "") {
         r.push({
           isDirectory: false,
-          path: hasModules
-            ? path.join(moduleFolderPath, "script.lock")
-            : removeSuffix(finalPath, metaExt) + ".lock",
+          path:
+            hasModules && !isDbt
+              ? path.join(moduleFolderPath, "script.lock")
+              : removeSuffix(finalPath, metaExt) + ".lock",
           async *getChildren() {},
           async getContentText() {
             return lock;
@@ -1438,7 +1593,7 @@ function ZipFSElement(
 
               // Yield the module lock file if present
               if (mod.lock) {
-                const baseName = relPath.replace(/\.[^.]+$/, '');
+                const baseName = relPath.replace(/\.[^.]+$/, "");
                 yield {
                   isDirectory: false,
                   path: path.join(moduleFolderPath, baseName + ".lock"),
@@ -1466,11 +1621,14 @@ function ZipFSElement(
         throw error;
       }
       const resourceType = parsed["resource_type"];
-      const formatExtension =
-        resourceTypeToFormatExtension[resourceType];
+      const formatExtension = resourceTypeToFormatExtension[resourceType];
       const isFileset = resourceTypeToIsFileset[resourceType] ?? false;
 
-      if (isFileset && typeof parsed["value"] === "object" && parsed["value"] !== null) {
+      if (
+        isFileset &&
+        typeof parsed["value"] === "object" &&
+        parsed["value"] !== null
+      ) {
         const filesetBasePath =
           removeSuffix(finalPath, ".resource.json") + ".fileset";
         // Push directory entry for the fileset
@@ -1478,7 +1636,9 @@ function ZipFSElement(
           isDirectory: true,
           path: filesetBasePath,
           async *getChildren() {
-            for (const [relPath, fileContent] of Object.entries(parsed["value"])) {
+            for (const [relPath, fileContent] of Object.entries(
+              parsed["value"],
+            )) {
               if (typeof fileContent === "string") {
                 yield {
                   isDirectory: false,
@@ -1654,9 +1814,15 @@ export async function elementsToMap(
     }
     const path = entry.path;
     // Include module files in the map so they're compared for changes,
-    // but they're pushed as part of their parent script via handleFile
+    // but they're pushed as part of their parent script via handleFile.
+    // `--skip-scripts` therefore covers them, and has to be applied here: the
+    // filters below are past this shortcut, so a changed module would push the
+    // parent script the flag asked to leave alone — every file of a dbt project
+    // is one of these.
     if (isScriptModulePath(path)) {
-      map[path] = await entry.getContentText();
+      if (!skips.skipScripts) {
+        map[path] = await entry.getContentText();
+      }
       continue;
     }
     if (
@@ -1665,6 +1831,10 @@ export async function elementsToMap(
       !isRawAppFile(path) &&
       !isWorkspaceDependencies(path)
     ) {
+      // The metadata format decides which of the two metadata twins is read,
+      // and drops the other. A dbt descriptor is not metadata and is not
+      // reached here: it lives inside the project folder, so the module branch
+      // above already took it, in both modes.
       if (json && path.endsWith(".yaml")) continue;
       if (!json && path.endsWith(".json")) continue;
 
@@ -1708,7 +1878,11 @@ export async function elementsToMap(
       }
     }
 
-    if (skips.skipResources && (isFileResource(path) || isFilesetResource(path))) continue;
+    if (
+      skips.skipResources &&
+      (isFileResource(path) || isFilesetResource(path))
+    )
+      continue;
 
     const ext = json ? ".json" : ".yaml";
     if (!skips.includeSchedules && path.endsWith(".schedule" + ext)) continue;
@@ -1831,17 +2005,38 @@ export async function elementsToMap(
 
   if (wrongFormatPaths.length > 0) {
     const isNonDotted = getNonDottedPaths();
-    const foundFormat = isNonDotted ? ".flow/.app/.raw_app" : "__flow/__app/__raw_app";
-    const expectedFormat = isNonDotted ? "__flow/__app/__raw_app" : ".flow/.app/.raw_app";
+    const foundFormat = isNonDotted
+      ? ".flow/.app/.raw_app"
+      : "__flow/__app/__raw_app";
+    const expectedFormat = isNonDotted
+      ? "__flow/__app/__raw_app"
+      : ".flow/.app/.raw_app";
     const configHint = isNonDotted
       ? "Either remove 'nonDottedPaths: true' from wmill.yaml, or rename these directories to use __flow/__app/__raw_app format."
       : "Either add 'nonDottedPaths: true' to wmill.yaml, or rename these directories to use .flow/.app/.raw_app format.";
     const pathList = wrongFormatPaths.map((p) => `  ${p}`).join("\n");
     throw new Error(
-      `Found ${wrongFormatPaths.length} directory(ies) using ${foundFormat} format, but wmill.yaml expects ${expectedFormat}:\n${pathList}\n${configHint}`
+      `Found ${wrongFormatPaths.length} directory(ies) using ${foundFormat} format, but wmill.yaml expects ${expectedFormat}:\n${pathList}\n${configHint}`,
     );
   }
 
+  // A dbt project's descriptor is optional, and the two sides spell "absent"
+  // differently: nothing on disk, and nothing in the export (which omits an
+  // empty one so a project that never named a descriptor never grows one).
+  // Left alone that reads as an addition on every push and a deletion on every
+  // pull, forever. Both sides are given the empty descriptor the absence means,
+  // so a descriptor-less project reaches a clean sync state.
+  for (const key of Object.keys(map)) {
+    // Normalized first: the local map's keys are built with `path.join`, so on
+    // Windows this reads `__dbt\\dbt_project.yml` and an unnormalized match
+    // would synthesize nothing — leaving exactly the perpetual push/pull diff
+    // above unguarded, on that platform only.
+    if (!key.replaceAll("\\", "/").endsWith("__dbt/dbt_project.yml")) continue;
+    const descriptor =
+      key.slice(0, -"dbt_project.yml".length) + DBT_DESCRIPTOR_NAME;
+    if (!(descriptor in map)) map[descriptor] = "";
+  }
+
   return map;
 }
 
@@ -1972,7 +2167,11 @@ export function canonicalizeCaseInsensitiveKeys(
       const lk = seg.toLowerCase();
       let entry = node.children.get(lk);
       if (!entry) {
-        entry = { canonical: seg, ambiguous: false, node: { children: new Map() } };
+        entry = {
+          canonical: seg,
+          ambiguous: false,
+          node: { children: new Map() },
+        };
         node.children.set(lk, entry);
       } else if (entry.canonical !== seg) {
         entry.ambiguous = true;
@@ -2146,7 +2345,9 @@ export function preservePendingScriptLocks(
       remoteParsed = isYaml
         ? yamlParseContent(metaKey, remote[metaKey])
         : JSON.parse(remote[metaKey]);
-      localParsed = isYaml ? yamlParseContent(metaKey, localMeta) : JSON.parse(localMeta);
+      localParsed = isYaml
+        ? yamlParseContent(metaKey, localMeta)
+        : JSON.parse(localMeta);
     } catch {
       continue;
     }
@@ -2160,7 +2361,8 @@ export function preservePendingScriptLocks(
 
     // The local side must reference an inline lock backed by a committed file.
     const localLock = localParsed["lock"];
-    if (typeof localLock !== "string" || !localLock.startsWith("!inline ")) continue;
+    if (typeof localLock !== "string" || !localLock.startsWith("!inline "))
+      continue;
 
     // Derive the lock-file key from the `!inline` reference itself, not from the
     // metadata path: a multi-module script keeps its lock at `…__mod/script.lock`,
@@ -2193,10 +2395,37 @@ async function compareDynFSElement(
 ): Promise<{ changes: Change[]; localMap: Record<string, string> }> {
   let [m1, m2] = els2
     ? await Promise.all([
-        elementsToMap(els1, ignore, json, skips, specificItems, branchOverride, isEls1Remote),
-        elementsToMap(els2, ignore, json, skips, specificItems, branchOverride, !isEls1Remote),
+        elementsToMap(
+          els1,
+          ignore,
+          json,
+          skips,
+          specificItems,
+          branchOverride,
+          isEls1Remote,
+        ),
+        elementsToMap(
+          els2,
+          ignore,
+          json,
+          skips,
+          specificItems,
+          branchOverride,
+          !isEls1Remote,
+        ),
       ])
-    : [await elementsToMap(els1, ignore, json, skips, specificItems, branchOverride, isEls1Remote), {}];
+    : [
+        await elementsToMap(
+          els1,
+          ignore,
+          json,
+          skips,
+          specificItems,
+          branchOverride,
+          isEls1Remote,
+        ),
+        {},
+      ];
 
   // Reconcile letter-case differences between the local tree and the
   // authoritative server casing. Only meaningful for an actual two-sided diff
@@ -2511,9 +2740,11 @@ const isNotWmillFile = (p: string, isDirectory: boolean) => {
     );
   }
 
-  // Files inside __mod/ folders are script module files — always valid wmill files
+  // Files inside a module folder belong to their parent script, so they are
+  // always valid wmill files — except the ones dbt generates, which are not
+  // part of the bundle and must not surface as items of their own.
   if (isScriptModulePath(p)) {
-    return false;
+    return isDbtGeneratedPath(p);
   }
 
   try {
@@ -2698,13 +2929,78 @@ interface ChangeTracker {
   rawApps: string[];
 }
 
+/// The script a module file belongs to, added to the tracker so its top hash is
+/// refreshed. Derived with `getScriptBasePathFromModulePath`, which normalizes
+/// separators: searching the raw path for `__dbt/` found nothing on Windows,
+/// where the folder is spelled `__dbt\`, so every model edit there was skipped.
+async function addModuleParentToChanged(p: string, tracker: ChangeTracker) {
+  // A folder layout's METADATA — `<base>__mod/script.yaml` — is an entry-point
+  // path too, and it is not a content file: pushed as one, the metadata pass
+  // asks `inferContentTypeFromFilePath` for the language of `.yaml` and aborts
+  // the whole command. It resolves to its content file like any other metadata.
+  if (isModuleEntryMetadata(p)) {
+    try {
+      const contentPath = await findContentFile(p);
+      if (contentPath && !tracker.scripts.includes(contentPath)) {
+        tracker.scripts.push(contentPath);
+      }
+    } catch {
+      // ignore — content file not found
+    }
+    return;
+  }
+  if (isModuleEntryPoint(p)) {
+    // Entry point (e.g. __mod/script.ts) IS the parent script content file.
+    if (!tracker.scripts.includes(p)) {
+      tracker.scripts.push(p);
+    }
+    return;
+  }
+  const scriptBasePath = getScriptBasePathFromModulePath(p);
+  if (scriptBasePath === undefined) {
+    return;
+  }
+  const push = async (candidate: string): Promise<boolean> => {
+    try {
+      const contentPath = await findContentFile(candidate);
+      if (contentPath && !tracker.scripts.includes(contentPath)) {
+        tracker.scripts.push(contentPath);
+      }
+      return contentPath != undefined;
+    } catch {
+      return false;
+    }
+  };
+  // A dbt script's metadata sits beside its folder; the descriptor is inside.
+  if (isDbtModulePath(p)) {
+    await push(scriptBasePath + ".script.yaml");
+    return;
+  }
+  // Folder layout first (`__mod/script.{ext}`), then flat.
+  if (!(await push(scriptBasePath + getModuleFolderSuffix() + "/script.yaml"))) {
+    await push(scriptBasePath + ".script.yaml");
+  }
+}
+
 async function addToChangedIfNotExists(p: string, tracker: ChangeTracker) {
   // Datatable migration .sql files are not scripts; they're synced via the
   // dedicated datatable_migration handler in the push loop.
   if (isDatatableMigrationPath(p)) {
     return;
   }
-  const isScript = exts.some((e) => p.endsWith(e)) && !isFileResource(p) && !isFilesetResource(p);
+  // Module files first, and whatever their extension: a dbt project authors
+  // `dbt_project.yml`, `packages.yml`, schema YAML and seed CSVs, none of which
+  // are Windmill script extensions — gated behind that test they never reached
+  // the tracker, so the top hash in `wmill-lock.yaml` (which covers the modules)
+  // stayed stale for exactly the files a dbt project is mostly made of.
+  if (isScriptModulePath(p)) {
+    await addModuleParentToChanged(p, tracker);
+    return;
+  }
+  const isScript =
+    hasScriptExt(p) &&
+    !isFileResource(p) &&
+    !isFilesetResource(p);
   if (isScript) {
     if (isFlowPath(p)) {
       const folder = extractFolderPath(p, "flow")!;
@@ -2721,37 +3017,6 @@ async function addToChangedIfNotExists(p: string, tracker: ChangeTracker) {
       if (!tracker.rawApps.includes(folder)) {
         tracker.rawApps.push(folder);
       }
-    } else if (isScriptModulePath(p)) {
-      if (isModuleEntryPoint(p)) {
-        // Entry point (e.g. __mod/script.ts) IS the parent script content file
-        if (!tracker.scripts.includes(p)) {
-          tracker.scripts.push(p);
-        }
-      } else {
-        // Module file changed — find the parent script content file
-        const moduleSuffix = getModuleFolderSuffix() + "/";
-        const idx = p.indexOf(moduleSuffix);
-        if (idx !== -1) {
-          const scriptBasePath = p.substring(0, idx);
-          // Try folder layout first: __mod/script.{ext}
-          try {
-            const contentPath = await findContentFile(scriptBasePath + getModuleFolderSuffix() + "/script.yaml");
-            if (contentPath && !tracker.scripts.includes(contentPath)) {
-              tracker.scripts.push(contentPath);
-            }
-          } catch {
-            // Fall back to flat layout: scriptBasePath.script.yaml
-            try {
-              const contentPath = await findContentFile(scriptBasePath + ".script.yaml");
-              if (contentPath && !tracker.scripts.includes(contentPath)) {
-                tracker.scripts.push(contentPath);
-              }
-            } catch {
-              // ignore — content file not found
-            }
-          }
-        }
-      }
     } else {
       if (!tracker.scripts.includes(p)) {
         tracker.scripts.push(p);
@@ -2769,7 +3034,7 @@ async function addToChangedIfNotExists(p: string, tracker: ChangeTracker) {
   }
 }
 
-async function buildTracker(changes: Change[]) {
+export async function buildTracker(changes: Change[]) {
   const tracker: ChangeTracker = {
     scripts: [],
     flows: [],
@@ -2788,7 +3053,7 @@ async function buildTracker(changes: Change[]) {
  * When a module file changes, find and push the parent script.
  * The parent script's handleFile will read the __mod/ folder and include all modules.
  */
-async function pushParentScriptForModule(
+export async function pushParentScriptForModule(
   modulePath: string,
   workspace: Workspace,
   alreadySynced: string[],
@@ -2797,11 +3062,82 @@ async function pushParentScriptForModule(
   rawWorkspaceDependencies: Record<string, string>,
   codebases: SyncCodebase[],
 ): Promise<void> {
-  const moduleSuffix = getModuleFolderSuffix() + "/";
-  const idx = modulePath.indexOf(moduleSuffix);
-  if (idx === -1) return;
-  const scriptBasePath = modulePath.substring(0, idx);
-  const moduleFolderPath = scriptBasePath + getModuleFolderSuffix();
+  const isDbt = isDbtModulePath(modulePath);
+  // Via the shared helper, which normalizes separators: a Windows path spells
+  // the folder `__dbt\\`, and searching the raw path for `__dbt/` would find
+  // nothing and silently return without deploying the parent — while the caller
+  // still records the file as synced.
+  const scriptBasePath = getScriptBasePathFromModulePath(modulePath);
+  if (scriptBasePath === undefined) return;
+  const moduleFolderPath =
+    scriptBasePath + getModuleFolderSuffix(isDbt ? "dbt" : undefined);
+
+  // A dbt project's descriptor sits INSIDE its folder (`__dbt/wm_dbt.yaml`) and
+  // is optional, so the project itself is what identifies the script.
+  if (isDbt) {
+    // Only the LOOKUP is tolerated: a module under no script's project is a
+    // stray file, not an error. Deploying it is not — swallowing that would let
+    // a module-only push report success while the remote project is unchanged.
+    // BEFORE the lookup, because the lookup succeeds whenever a descriptor is
+    // there: `dbt_project.yml` is what makes the bundle a project, and pushing
+    // without it replaces a healthy deployment with one whose dependency job
+    // fails for having no project at all.
+    const hasMetadata =
+      existsSync(scriptBasePath + ".script.yaml") ||
+      existsSync(scriptBasePath + ".script.json");
+    if (!existsSync(moduleFolderPath + "/dbt_project.yml")) {
+      if (hasMetadata) {
+        throw new Error(
+          `${moduleFolderPath} has no dbt_project.yml but ${scriptBasePath}.script.yaml ` +
+            `remains, so there is no dbt project left to push. Delete the metadata too to ` +
+            `archive the script, or restore the project.`
+        );
+      }
+      // Nothing local claims this script any more — neither project nor
+      // metadata — so it is archived like any other locally deleted item. The
+      // deletions arrive one file at a time, hence `alreadySynced`.
+      const remote = scriptBasePath.replaceAll(SEP, "/");
+      if (!alreadySynced.includes(remote)) {
+        alreadySynced.push(remote);
+        log.info(`Archiving script ${remote}`);
+        await wmill
+          .archiveScriptByPath({ workspace: workspace.workspaceId, path: remote })
+          .catch((e: any) => {
+            // Only "already gone" is the state we wanted. An auth, network or
+            // server failure must fail the push: swallowing it reports success
+            // while the project stays deployed, which is the thing this branch
+            // exists to prevent.
+            if (e?.status !== 404) throw e;
+            log.debug(`${remote} was already gone remotely`);
+          });
+      }
+      return;
+    }
+    let contentPath: string | undefined;
+    try {
+      contentPath = await findContentFile(scriptBasePath + ".script.yaml");
+    } catch (e) {
+      // A path claimed by two scripts is not a parent that cannot be found:
+      // swallowed here, `wmill sync push` reports success on a model edit that
+      // deployed nothing, and the collision stays invisible until the ordinary
+      // script overwrites the project.
+      if (e instanceof DbtPathCollisionError) throw e;
+      log.debug(`Could not find parent script for dbt module: ${modulePath}`);
+      return;
+    }
+    if (contentPath) {
+      await handleFile(
+        contentPath,
+        workspace,
+        alreadySynced,
+        message,
+        opts,
+        rawWorkspaceDependencies,
+        codebases,
+      );
+    }
+    return;
+  }
 
   // Try folder layout first: look for script.{ext} inside __mod/
   try {
@@ -3012,11 +3348,16 @@ export async function pull(
   let specificItems = getSpecificItemsForCurrentBranch(opts, wsNameForConfig);
 
   // Compute the workspace name for file naming (default to workspaceId)
-  let wsNameForFiles = wsNameForConfig ? resolveWsNameForFiles(opts, wsNameForConfig) : workspace.workspaceId;
+  let wsNameForFiles = wsNameForConfig
+    ? resolveWsNameForFiles(opts, wsNameForConfig)
+    : workspace.workspaceId;
 
   // Augment specificItems with server-side ws_specific entries
   const localSpecificItems = specificItems;
-  const wsSpecificMerge = await mergeWsSpecificFromServer(workspace.workspaceId, specificItems);
+  const wsSpecificMerge = await mergeWsSpecificFromServer(
+    workspace.workspaceId,
+    specificItems,
+  );
   specificItems = wsSpecificMerge.merged;
 
   // Merge CLI flags with resolved settings (CLI flags take precedence only for explicit overrides)
@@ -3163,7 +3504,8 @@ export async function pull(
     const conflicts = [];
 
     log.info(colors.gray(`Applying changes to files ...`));
-    for await (const change of changes) {
+    for await (const rawChange of changes) {
+      const change: Change = rawChange;
       // Determine if this file should be written to a workspace-specific path
       let targetPath = change.path;
       if (specificItems && isSpecificItem(change.path, specificItems)) {
@@ -3179,6 +3521,28 @@ export async function pull(
 
       const target = path.join(process.cwd(), targetPath);
       const stateTarget = path.join(process.cwd(), ".wmill", targetPath);
+      // An empty dbt descriptor is not a file: the remote spells "this project
+      // named no descriptor" as empty content, and writing that would put a
+      // Windmill file inside a project that has none. ABSENCE is the state to
+      // reach, so both copies are removed if present and their being missing —
+      // a project pulled for the first time — is the goal, not an error. The
+      // `.wmill` copy goes too, or the same change is reported on every pull.
+      //
+      // `force` covers the missing file and NOTHING else: a permission or
+      // read-only-filesystem failure has to surface, or the pull reports
+      // success while the old descriptor — its warehouse, its command, its
+      // arguments — is still what runs locally.
+      if (
+        isDbtDescriptorPath(change.path) &&
+        ((change.name === "added" && change.content === "") ||
+          (change.name === "edited" && change.after === ""))
+      ) {
+        await rm(target, { force: true });
+        if (opts.stateful) {
+          await rm(stateTarget, { force: true });
+        }
+        continue;
+      }
       if (change.name === "edited") {
         if (opts.stateful) {
           try {
@@ -3220,11 +3584,13 @@ export async function pull(
             // ignore
           }
         }
-        if (exts.some((e) => change.path.endsWith(e))) {
+        if (hasScriptExt(change.path)) {
           log.info(
             `Editing script content of ${targetPath}${
               targetPath !== change.path
-                ? colors.gray(` (workspace-specific override for ${change.path})`)
+                ? colors.gray(
+                    ` (workspace-specific override for ${change.path})`,
+                  )
                 : ""
             }`,
           );
@@ -3235,7 +3601,9 @@ export async function pull(
           log.info(
             `Editing ${changeTypeLabel(change.path)}${targetPath}${
               targetPath !== change.path
-                ? colors.gray(` (workspace-specific override for ${change.path})`)
+                ? colors.gray(
+                    ` (workspace-specific override for ${change.path})`,
+                  )
                 : ""
             }`,
           );
@@ -3253,7 +3621,9 @@ export async function pull(
           log.info(
             `Adding ${changeTypeLabel(change.path)}${targetPath}${
               targetPath !== change.path
-                ? colors.gray(` (workspace-specific override for ${change.path})`)
+                ? colors.gray(
+                    ` (workspace-specific override for ${change.path})`,
+                  )
                 : ""
             }`,
           );
@@ -3270,18 +3640,15 @@ export async function pull(
           await copyFile(target, stateTarget);
         }
       } else if (change.name === "deleted") {
-        try {
-          log.info(
-            `Deleting ${changeTypeLabel(change.path)}${change.path}`,
-          );
-          await rm(target);
-          if (opts.stateful) {
-            await rm(stateTarget);
-          }
-        } catch {
-          if (opts.stateful) {
-            await rm(stateTarget);
-          }
+        log.info(`Deleting ${changeTypeLabel(change.path)}${change.path}`);
+        // `force` on both: the goal is that neither copy exists, and a file
+        // already absent — a dbt project's optional descriptor is never written
+        // — is that goal, not an error. Anything else (permissions, a read-only
+        // mount) surfaces rather than leaving a file the sync believes is gone.
+        // The state copy goes too, or the same deletion replays on every sync.
+        await rm(target, { force: true });
+        if (opts.stateful) {
+          await rm(stateTarget, { force: true });
         }
       }
     }
@@ -3417,7 +3784,8 @@ export async function pull(
     try {
       // Dynamic import to avoid a circular dep between sync.ts and
       // generate-metadata.ts. Don't "clean up" to a static import.
-      const { rehashOnly } = await import("../generate-metadata/generate-metadata.ts");
+      const { rehashOnly } =
+        await import("../generate-metadata/generate-metadata.ts");
       // Reuse the local-side file list from the change-tracker so we don't
       // re-walk the filesystem. Apply the just-applied changes to derive the
       // post-pull state: localMap is pre-pull, but auto-fill needs to see
@@ -3436,7 +3804,7 @@ export async function pull(
         log.info(
           colors.gray(
             `Auto-filled ${total} missing lockfile entr${total === 1 ? "y" : "ies"} ` +
-            `(${filled.scripts} script, ${filled.flows} flow, ${filled.apps} app) from disk.`,
+              `(${filled.scripts} script, ${filled.flows} flow, ${filled.apps} app) from disk.`,
           ),
         );
       }
@@ -3524,17 +3892,14 @@ export async function gitDeploy(
   // the wm_deploy branch). Mirrors the hub script's `--promotion <branch>`.
   const promotion =
     useIndividualBranch && !opts.promotion
-      ? getCurrentGitBranch() ?? undefined
+      ? (getCurrentGitBranch() ?? undefined)
       : opts.promotion;
 
   await pull({
     ...opts,
     yes: true,
     skipBranchValidation: true,
-    extraIncludes: [
-      ...(opts.extraIncludes ?? []),
-      ...includes.extraIncludes,
-    ],
+    extraIncludes: [...(opts.extraIncludes ?? []), ...includes.extraIncludes],
     // Workspace-wide mode force-includes the deployed default-excluded kinds
     // (full mirror). Individual-branch/promotion mode forces nothing — these
     // keys stay ABSENT so pull resolves them from the promotion target's
@@ -3582,7 +3947,9 @@ function prettyChanges(
 
     const folderNote = folderDefaultAnnotations?.get(change.path);
     const extraNote = folderNote
-      ? colors.cyan(` (will be permissioned as ${folderNote} via folder default)`)
+      ? colors.cyan(
+          ` (will be permissioned as ${folderNote} via folder default)`,
+        )
       : "";
 
     if (change.name === "added") {
@@ -3727,14 +4094,12 @@ async function checkServerLockJobs(
     const pending = (queued as { script_path?: string }[]).filter((j) =>
       belongsToPush(j.script_path),
     ).length;
-    const failed = (
-      completed as { script_path?: string; result?: unknown }[]
-    )
+    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,
+        error: (j.result as { error?: { message?: string } } | undefined)?.error
+          ?.message,
       }));
     return { pending, failed };
   } catch {
@@ -3744,7 +4109,12 @@ async function checkServerLockJobs(
 }
 
 export async function push(
-  opts: GlobalOptions & SyncOptions & { repository?: string; branch?: string; acceptOverridingPermissionedAsWithSelf?: boolean },
+  opts: GlobalOptions &
+    SyncOptions & {
+      repository?: string;
+      branch?: string;
+      acceptOverridingPermissionedAsWithSelf?: boolean;
+    },
 ) {
   if ((opts as any).jsonOutput) log.setSilent(true);
   // Save original CLI options before merging with config file
@@ -3807,7 +4177,9 @@ export async function push(
   let specificItems = getSpecificItemsForCurrentBranch(opts, wsNameForConfig);
 
   // Compute the workspace name for file naming (default to workspaceId)
-  let wsNameForFiles = wsNameForConfig ? resolveWsNameForFiles(opts, wsNameForConfig) : workspace.workspaceId;
+  let wsNameForFiles = wsNameForConfig
+    ? resolveWsNameForFiles(opts, wsNameForConfig)
+    : workspace.workspaceId;
 
   // Keep the pre-merge specificItems so we can detect entries that are
   // flagged locally but not yet ws_specific on the server (post-merge would
@@ -3815,7 +4187,10 @@ export async function push(
   const localSpecificItems = specificItems;
 
   // Augment specificItems with server-side ws_specific entries
-  const wsSpecificMerge = await mergeWsSpecificFromServer(workspace.workspaceId, specificItems);
+  const wsSpecificMerge = await mergeWsSpecificFromServer(
+    workspace.workspaceId,
+    specificItems,
+  );
   specificItems = wsSpecificMerge.merged;
   const serverWsSpecificItems = wsSpecificMerge.serverItems;
 
@@ -3910,7 +4285,11 @@ export async function push(
     parseSyncBehavior(opts.syncBehavior) >= 1,
   );
 
-  const local = await FSFSElement(path.join(process.cwd(), ""), codebases, false);
+  const local = await FSFSElement(
+    path.join(process.cwd(), ""),
+    codebases,
+    false,
+  );
   const { changes, localMap } = await compareDynFSElement(
     local,
     remote,
@@ -4176,14 +4555,20 @@ export async function push(
     let triggerCount = 0;
     for await (const entry of readDirRecursiveWithIgnore(() => false, local)) {
       if (entry.isDirectory) continue;
-      if (!opts.includeSchedules && entry.path.endsWith(".schedule.yaml")) scheduleCount++;
-      if (!opts.includeTriggers && entry.path.endsWith("_trigger.yaml")) triggerCount++;
+      if (!opts.includeSchedules && entry.path.endsWith(".schedule.yaml"))
+        scheduleCount++;
+      if (!opts.includeTriggers && entry.path.endsWith("_trigger.yaml"))
+        triggerCount++;
     }
     if (scheduleCount > 0) {
-      skippedWarnings.push(`Skipping ${scheduleCount} schedule file(s). Use --include-schedules or set includeSchedules: true in wmill.yaml`);
+      skippedWarnings.push(
+        `Skipping ${scheduleCount} schedule file(s). Use --include-schedules or set includeSchedules: true in wmill.yaml`,
+      );
     }
     if (triggerCount > 0) {
-      skippedWarnings.push(`Skipping ${triggerCount} trigger file(s). Use --include-triggers or set includeTriggers: true in wmill.yaml`);
+      skippedWarnings.push(
+        `Skipping ${triggerCount} trigger file(s). Use --include-triggers or set includeTriggers: true in wmill.yaml`,
+      );
     }
     for (const warning of skippedWarnings) {
       log.warn(warning);
@@ -4312,7 +4697,18 @@ export async function push(
       `Run 'wmill folder add-missing' to create them locally, then push again.`;
     if (!userIsAdmin) {
       if (opts.jsonOutput) {
-        console.log(JSON.stringify({ success: false, error: "missing_folders", missing_folders: missingFolders, message: msg }, null, 2));
+        console.log(
+          JSON.stringify(
+            {
+              success: false,
+              error: "missing_folders",
+              missing_folders: missingFolders,
+              message: msg,
+            },
+            null,
+            2,
+          ),
+        );
       } else {
         log.error(msg);
       }
@@ -4345,9 +4741,7 @@ export async function push(
           : {}),
       })),
       total: changes.length,
-      ...(changes.length > 0
-        ? { warning: SYNC_PUSH_DESTRUCTIVE_WARNING }
-        : {}),
+      ...(changes.length > 0 ? { warning: SYNC_PUSH_DESTRUCTIVE_WARNING } : {}),
     };
     console.log(JSON.stringify(result, null, 2));
     return;
@@ -4358,7 +4752,10 @@ export async function push(
     let folderDefaultAnnotations: Map<string, string> | undefined;
     if (parseSyncBehavior(opts.syncBehavior) >= 1) {
       folderDefaultAnnotations = new Map();
-      const folderRulesCache = new Map<string, Array<{ path_glob: string; permissioned_as: string }>>();
+      const folderRulesCache = new Map<
+        string,
+        Array<{ path_glob: string; permissioned_as: string }>
+      >();
       for (const change of changes) {
         if (change.name !== "added") continue;
         const match = change.path.match(/^f\/([^/]+)\//);
@@ -4366,14 +4763,26 @@ export async function push(
         const folderName = match[1];
         if (!folderRulesCache.has(folderName)) {
           try {
-            const folder = await wmill.getFolder({ workspace: workspace.workspaceId, name: folderName });
-            folderRulesCache.set(folderName, (folder as any).default_permissioned_as ?? []);
+            const folder = await wmill.getFolder({
+              workspace: workspace.workspaceId,
+              name: folderName,
+            });
+            folderRulesCache.set(
+              folderName,
+              (folder as any).default_permissioned_as ?? [],
+            );
           } catch {
             folderRulesCache.set(folderName, []);
           }
         }
         const rules = folderRulesCache.get(folderName)!;
-        const remotePath = change.path.replace(/\.(script|schedule|http_trigger|websocket_trigger|kafka_trigger|nats_trigger|postgres_trigger|mqtt_trigger|amqp_trigger|sqs_trigger|gcp_trigger|azure_trigger|email_trigger)\.(yaml|json)$/, "").replace(/(\.flow|__flow)\/flow\.(yaml|json)$/, "").replace(/\.(app|raw_app)(\/app\.(yaml|json))?$/, "");
+        const remotePath = change.path
+          .replace(
+            /\.(script|schedule|http_trigger|websocket_trigger|kafka_trigger|nats_trigger|postgres_trigger|mqtt_trigger|amqp_trigger|sqs_trigger|gcp_trigger|azure_trigger|email_trigger)\.(yaml|json)$/,
+            "",
+          )
+          .replace(/(\.flow|__flow)\/flow\.(yaml|json)$/, "")
+          .replace(/\.(app|raw_app)(\/app\.(yaml|json))?$/, "");
         const relative = remotePath.slice(`f/${folderName}/`.length);
         if (!relative) continue;
         for (const rule of rules) {
@@ -4386,7 +4795,12 @@ export async function push(
     }
 
     if (!opts.jsonOutput) {
-      prettyChanges(changes, specificItems, wsNameForFiles, folderDefaultAnnotations);
+      prettyChanges(
+        changes,
+        specificItems,
+        wsNameForFiles,
+        folderDefaultAnnotations,
+      );
     }
 
     if (opts.dryRun) {
@@ -4400,7 +4814,9 @@ export async function push(
       const user = await wmill.whoami({ workspace: workspace.workspaceId });
       const userIsAdminOrDeployer =
         user.is_admin || (user.groups ?? []).includes("wm_deployers");
-      log.debug(`permissioned_as: user=${user.email}, is_admin=${user.is_admin}, groups=${JSON.stringify(user.groups)}, isAdminOrDeployer=${userIsAdminOrDeployer}`);
+      log.debug(
+        `permissioned_as: user=${user.email}, is_admin=${user.is_admin}, groups=${JSON.stringify(user.groups)}, isAdminOrDeployer=${userIsAdminOrDeployer}`,
+      );
       permissionedAsContext = {
         userCache: new Map(),
         userIsAdminOrDeployer,
@@ -4418,10 +4834,12 @@ export async function push(
         !!process.stdin.isTTY,
       );
     } else if (folderDefaultAnnotations && folderDefaultAnnotations.size > 0) {
-      log.warn(colors.yellow(
-        `This workspace has folder default_permissioned_as rules that affect ${folderDefaultAnnotations.size} item(s) being pushed, ` +
-        `but syncBehavior is not set in wmill.yaml. Add 'syncBehavior: v1' to enable ownership preservation on update and on_behalf_of stripping on pull.`
-      ));
+      log.warn(
+        colors.yellow(
+          `This workspace has folder default_permissioned_as rules that affect ${folderDefaultAnnotations.size} item(s) being pushed, ` +
+            `but syncBehavior is not set in wmill.yaml. Add 'syncBehavior: v1' to enable ownership preservation on update and on_behalf_of stripping on pull.`,
+        ),
+      );
     }
 
     // Reject malformed datatable migrations (duplicate timestamps, orphan downs)
@@ -4480,7 +4898,14 @@ export async function push(
     // Group changes by base path (before first dot)
     const groupedChanges = new Map<string, typeof changes>();
     for (const change of changes) {
-      const basePath = change.path.split(".")[0];
+      // A module file is pushed by pushing its parent script, so it belongs in
+      // that script's group. Left in a group of its own it gets its own
+      // `alreadySynced`, and a push touching several files of one bundle then
+      // deploys the script once per file: several versions in a row, of which
+      // only the last is the one the asset graph ends up describing.
+      const basePath =
+        getScriptBasePathFromModulePath(change.path) ??
+        change.path.split(".")[0];
       if (!groupedChanges.has(basePath)) {
         groupedChanges.set(basePath, []);
       }
@@ -4528,7 +4953,8 @@ export async function push(
     const effectiveParallelism = () =>
       folderPhaseRemaining > 0 ? 1 : parallelizationFactor;
     // Cache git branch at the start to avoid repeated execSync calls per change
-    const cachedWsNameForPush = wsNameForFiles || (isGitRepository() ? getCurrentGitBranch() : null);
+    const cachedWsNameForPush =
+      wsNameForFiles || (isGitRepository() ? getCurrentGitBranch() : null);
 
     // Datatable migrations are two files (.up.sql/.down.sql) for one record, so
     // dedupe upsert/delete by (datatable, version) across the whole push.
@@ -4668,13 +5094,19 @@ export async function push(
                   const currentBranch = cachedWsNameForPush;
                   let isFileResWsSpecific = false;
 
-                  if (currentBranch && isWorkspaceSpecificFile(resourceFilePath)) {
+                  if (
+                    currentBranch &&
+                    isWorkspaceSpecificFile(resourceFilePath)
+                  ) {
                     serverPath = fromWorkspaceSpecificPath(
                       resourceFilePath,
                       currentBranch,
                     );
                     isFileResWsSpecific = true;
-                  } else if (specificItems && isSpecificItem(change.path, specificItems)) {
+                  } else if (
+                    specificItems &&
+                    isSpecificItem(change.path, specificItems)
+                  ) {
                     isFileResWsSpecific = true;
                   }
 
@@ -4718,7 +5150,8 @@ export async function push(
 
               // Check if this is a branch-specific item and get the original workspace-specific path
               let originalWorkspaceSpecificPath: string | undefined;
-              const isWsSpecific = specificItems && isSpecificItem(change.path, specificItems);
+              const isWsSpecific =
+                specificItems && isSpecificItem(change.path, specificItems);
               if (isWsSpecific) {
                 originalWorkspaceSpecificPath = getWorkspaceSpecificPath(
                   change.path,
@@ -4805,7 +5238,11 @@ export async function push(
                 !isRawAppFile(change.path) &&
                 (change.path.endsWith(".script.json") ||
                   change.path.endsWith(".script.yaml") ||
-                  change.path.endsWith(".lock") ||
+                  // A `.lock` is the script's generated lockfile — except inside
+                  // a dbt bundle, where the project may author one (`uv.lock`).
+                  // Skipping it there would report the add on every push and
+                  // never apply it, because no state file is written either.
+                  (change.path.endsWith(".lock") && !isDbtModulePath(change.path)) ||
                   isFileResource(change.path))
               ) {
                 continue;
@@ -4845,7 +5282,8 @@ export async function push(
               // Determine the actual local file path for this change
               // For branch-specific items, we read from workspace-specific files but push to base server paths
               let localFilePath = change.path;
-              const isAddedWsSpecific = specificItems && isSpecificItem(change.path, specificItems);
+              const isAddedWsSpecific =
+                specificItems && isSpecificItem(change.path, specificItems);
               if (isAddedWsSpecific) {
                 const workspaceSpecificPath = getWorkspaceSpecificPath(
                   change.path,
@@ -4882,7 +5320,9 @@ export async function push(
                 await writeFile(stateTarget, change.content, "utf-8");
               }
             } else if (change.name === "deleted") {
-              if (change.path.endsWith(".lock")) {
+              // Same as the added branch: a dbt project's own `.lock` is one of
+              // its files, so deleting it has to reach the parent script.
+              if (change.path.endsWith(".lock") && !isDbtModulePath(change.path)) {
                 continue;
               }
               if (isScriptModulePath(change.path)) {
@@ -4942,8 +5382,13 @@ export async function push(
                       path: resourcePath,
                     });
                   } catch (e: any) {
-                    if (e?.status === 404 && deletedVarsResPaths.includes(resourcePath)) {
-                      log.debug(`Resource ${resourcePath} already deleted by linked variable`);
+                    if (
+                      e?.status === 404 &&
+                      deletedVarsResPaths.includes(resourcePath)
+                    ) {
+                      log.debug(
+                        `Resource ${resourcePath} already deleted by linked variable`,
+                      );
                     } else {
                       throw e;
                     }
@@ -4962,7 +5407,10 @@ export async function push(
                     // Metadata file deleted — delete the entire flow
                     await wmill.deleteFlowByPath({
                       workspace: workspaceId,
-                      path: removeSuffix(target, getDeleteSuffix("flow", "json")),
+                      path: removeSuffix(
+                        target,
+                        getDeleteSuffix("flow", "json"),
+                      ),
                     });
                   } else {
                     // Inline script file deleted within flow folder
@@ -5004,7 +5452,10 @@ export async function push(
                     // Metadata file deleted — delete the entire app
                     await wmill.deleteApp({
                       workspace: workspaceId,
-                      path: removeSuffix(target, getDeleteSuffix("app", "json")),
+                      path: removeSuffix(
+                        target,
+                        getDeleteSuffix("app", "json"),
+                      ),
                     });
                   } else {
                     // Inline script file deleted within app folder
@@ -5046,7 +5497,10 @@ export async function push(
                     // Delete the entire raw app
                     await wmill.deleteApp({
                       workspace: workspaceId,
-                      path: removeSuffix(target, getDeleteSuffix("raw_app", "json")),
+                      path: removeSuffix(
+                        target,
+                        getDeleteSuffix("raw_app", "json"),
+                      ),
                     });
                   } else {
                     const rawAppFolder = extractFolderPath(target, "raw_app");
@@ -5161,7 +5615,7 @@ export async function push(
                   const triggerInfo = extractNativeTriggerInfo(change.path);
                   if (!triggerInfo) {
                     throw new Error(
-                      `Invalid native trigger path: ${change.path}`
+                      `Invalid native trigger path: ${change.path}`,
                     );
                   }
                   await wmill.deleteNativeTrigger({
@@ -5179,8 +5633,13 @@ export async function push(
                       path: variablePath,
                     });
                   } catch (e: any) {
-                    if (e?.status === 404 && deletedVarsResPaths.includes(variablePath)) {
-                      log.debug(`Variable ${variablePath} already deleted by linked resource`);
+                    if (
+                      e?.status === 404 &&
+                      deletedVarsResPaths.includes(variablePath)
+                    ) {
+                      log.debug(
+                        `Variable ${variablePath} already deleted by linked resource`,
+                      );
                     } else {
                       throw e;
                     }
@@ -5291,10 +5750,14 @@ export async function push(
       log.warn(`Failed to push shared UI folder: ${e}`);
     }
     try {
-      await offerToRunNewMigrations(workspace.workspaceId, newDatatableMigrations, {
-        yes: opts.yes,
-        jsonOutput: opts.jsonOutput,
-      });
+      await offerToRunNewMigrations(
+        workspace.workspaceId,
+        newDatatableMigrations,
+        {
+          yes: opts.yes,
+          jsonOutput: opts.jsonOutput,
+        },
+      );
     } catch (e: any) {
       log.warn(
         `Failed to run new datatable migrations: ${e?.body ?? e?.message ?? e}`,
@@ -5428,7 +5891,10 @@ const command = new Command()
   .option("--json", "Use JSON instead of YAML")
   .option("--skip-variables", "Skip syncing variables (including secrets)")
   .option("--skip-secrets", "Skip syncing only secrets variables")
-  .option("--include-secrets", "Include secrets in sync (overrides skipSecrets in wmill.yaml)")
+  .option(
+    "--include-secrets",
+    "Include secrets in sync (overrides skipSecrets in wmill.yaml)",
+  )
   .option("--skip-resources", "Skip syncing  resources")
   .option("--skip-resource-types", "Skip syncing  resource types")
   .option("--skip-scripts", "Skip syncing scripts")
@@ -5484,7 +5950,10 @@ const command = new Command()
   .option("--json", "Use JSON instead of YAML")
   .option("--skip-variables", "Skip syncing variables (including secrets)")
   .option("--skip-secrets", "Skip syncing only secrets variables")
-  .option("--include-secrets", "Include secrets in sync (overrides skipSecrets in wmill.yaml)")
+  .option(
+    "--include-secrets",
+    "Include secrets in sync (overrides skipSecrets in wmill.yaml)",
+  )
   .option("--skip-resources", "Skip syncing  resources")
   .option("--skip-resource-types", "Skip syncing  resource types")
   .option("--skip-scripts", "Skip syncing scripts")
@@ -5538,7 +6007,10 @@ const command = new Command()
     "--locks-required",
     "Fail if scripts or flow inline scripts that need locks have no locks",
   )
-  .option("--auto-metadata", "Automatically regenerate stale metadata (locks and schemas) before pushing")
+  .option(
+    "--auto-metadata",
+    "Automatically regenerate stale metadata (locks and schemas) before pushing",
+  )
   .option(
     "--accept-overriding-permissioned-as-with-self",
     "Accept that items with a different permissioned_as will be updated with your own user",
diff --git a/cli/src/guidance/skills.gen.ts b/cli/src/guidance/skills.gen.ts
index 8583bcce76..8de578f10f 100644
--- a/cli/src/guidance/skills.gen.ts
+++ b/cli/src/guidance/skills.gen.ts
@@ -5380,7 +5380,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 for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')","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","bunnative","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 until stopped. The implicit iterator is the iteration counter, so 'flow_input.iter.value' equals 'flow_input.iter.index' (0, 1, 2, ...) and never carries state. To carry state across iterations, a step reads its own previous-iteration result via 'results.<its_own_id>' with a first-iteration fallback - the loop's stop_after_if must then be on that inner step (a plain single-step body with stop_after_if on the loop module does not resolve 'results' across iterations and never terminates); plain counters can instead be derived from 'flow_input.iter.index', which works in every configuration. stop_after_if is evaluated after each iteration - on the loop module 'result' is the last iteration's result","properties":{"modules":{"type":"array","description":"Steps to execute in each iteration","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)"},"description":{"type":"string","description":"Free-text description of the tool given to the AI to decide when and how to call it. Overrides the description auto-derived from the underlying script."},"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":["user_message"]},"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."},"agent":{"type":"string","description":"Path of a reusable \`ai_agent\` resource (hybrid linking). When set, the agent brain\\nconfig (provider/model/system prompt/etc.) and tool set are resolved at runtime from\\nthat resource; the module's input_transforms then only carry the flow-local inputs\\n(user_message/user_attachments).\\n"},"tool_inputs":{"type":"object","description":"Host-local wiring for an agent's tool inputs, keyed by tool id then input key. Binds the\\nreferenced agent's tools to this flow's context (flow_input/results) without mutating the\\nshared resource; overlaid onto the tools' input_transforms at runtime \\u2014 including when\\n\`agent\` is unset, since a step forked for editing keeps these overrides until it is saved\\nback or unlinked.\\n","additionalProperties":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}}},"parallel":{"type":"boolean","description":"If true, the agent can execute multiple tool calls in parallel"}},"required":["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 for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')","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","bunnative","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","dbt"]},"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 until stopped. The implicit iterator is the iteration counter, so 'flow_input.iter.value' equals 'flow_input.iter.index' (0, 1, 2, ...) and never carries state. To carry state across iterations, a step reads its own previous-iteration result via 'results.<its_own_id>' with a first-iteration fallback - the loop's stop_after_if must then be on that inner step (a plain single-step body with stop_after_if on the loop module does not resolve 'results' across iterations and never terminates); plain counters can instead be derived from 'flow_input.iter.index', which works in every configuration. stop_after_if is evaluated after each iteration - on the loop module 'result' is the last iteration's result","properties":{"modules":{"type":"array","description":"Steps to execute in each iteration","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)"},"description":{"type":"string","description":"Free-text description of the tool given to the AI to decide when and how to call it. Overrides the description auto-derived from the underlying script."},"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":["user_message"]},"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."},"agent":{"type":"string","description":"Path of a reusable \`ai_agent\` resource (hybrid linking). When set, the agent brain\\nconfig (provider/model/system prompt/etc.) and tool set are resolved at runtime from\\nthat resource; the module's input_transforms then only carry the flow-local inputs\\n(user_message/user_attachments).\\n"},"tool_inputs":{"type":"object","description":"Host-local wiring for an agent's tool inputs, keyed by tool id then input key. Binds the\\nreferenced agent's tools to this flow's context (flow_input/results) without mutating the\\nshared resource; overlaid onto the tools' input_transforms at runtime \\u2014 including when\\n\`agent\` is unset, since a step forked for editing keeps these overrides until it is saved\\nback or unlinked.\\n","additionalProperties":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}}},"parallel":{"type":"boolean","description":"If true, the agent can execute multiple tool calls in parallel"}},"required":["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.
diff --git a/cli/src/types.ts b/cli/src/types.ts
index 5e4e596297..6dd2e6ff77 100644
--- a/cli/src/types.ts
+++ b/cli/src/types.ts
@@ -5,6 +5,7 @@ import * as path from "node:path";
 import { sep as SEP } from "node:path";
 import { stringify as yamlStringify } from "yaml";
 import { yamlParseContent } from "./utils/yaml.ts";
+import { isDbtDescriptorPath } from "./utils/resource_folders.ts";
 import { pushApp } from "./commands/app/app.ts";
 import { pushFolder } from "./commands/folder/folder.ts";
 import { pushFlow } from "./commands/flow/flow.ts";
@@ -405,7 +406,11 @@ export function getTypeStrFromPath(
     parsed.ext == ".rb" ||
     parsed.ext == ".r" ||
     // for related places search: ADD_NEW_LANG
-    (parsed.ext == ".yml" && parsed.name.split(".").pop() == "playbook")
+    (parsed.ext == ".yml" && parsed.name.split(".").pop() == "playbook") ||
+    // A dbt descriptor is `<project>__dbt/wm_dbt.yaml`. Without this it reads
+    // as one of the CLI's own `.yaml` metadata files and a pull writes the
+    // script's metadata and lock but never its content.
+    isDbtDescriptorPath(p)
   ) {
     return "script";
   }
diff --git a/cli/src/utils/metadata.ts b/cli/src/utils/metadata.ts
index ebb35e9d33..1905121c3a 100644
--- a/cli/src/utils/metadata.ts
+++ b/cli/src/utils/metadata.ts
@@ -19,9 +19,10 @@ import {
   languageNeedsLock,
 } from "./script_common.ts";
 import { inferContentTypeFromFilePath } from "./script_common.ts";
-import { getModuleFolderSuffix, isModuleEntryPoint, scriptPathToRemotePath } from "./resource_folders.ts";
+import { dbtGeneratedDirs, isUnderGeneratedDir, isBundledModuleFile, getModuleFolderSuffix, isModuleEntryPoint, scriptPathToRemotePath } from "./resource_folders.ts";
 import { findCodebase, yamlOptions } from "../commands/sync/sync.ts";
 import { generateHash, readInlinePathSync, getHeaders, readTextFile, readTextFileSync } from "./utils.ts";
+import { DBT_DESCRIPTOR_NAME, isMissingDbtDescriptor } from "./resource_folders.ts";
 import { detectAuthGatewayChallenge } from "./http_guards.ts";
 
 import { SyncCodebase } from "./codebase.ts";
@@ -218,6 +219,13 @@ export async function generateScriptMetadataInternal(
 
   const language = inferContentTypeFromFilePath(scriptPath, opts.defaultTs);
 
+  // Whether the metadata and lock live INSIDE that folder. They do for a `__mod`
+  // bundle, whose folder is Windmill's. A dbt project's folder is dbt's, taken
+  // verbatim, so its companions stay beside it — writing them in would leave
+  // stray `script.yaml`/`script.lock` files in the deployed project and leave
+  // the metadata sync actually reads untouched.
+  const metadataInFolder = isFolderLayout && language !== "dbt";
+
   // For folder layout, parseMetadataFile is called with remotePath which
   // will find __mod/script.yaml via the folder layout fallback
   const metadataWithType = await parseMetadataFile(
@@ -225,8 +233,12 @@ export async function generateScriptMetadataInternal(
     undefined,
   );
 
-  // read script content
-  const scriptContent = await readTextFile(scriptPath);
+  // read script content — a dbt project's descriptor is optional, and absent
+  // means an empty descriptor rather than a script that cannot be pushed.
+  const scriptContent = await readTextFile(scriptPath).catch((e) => {
+    if (isMissingDbtDescriptor(scriptPath, e)) return "";
+    throw e;
+  });
   const metadataContent = await readTextFile(metadataWithType.path);
 
   const filteredRawWorkspaceDependencies = filterWorkspaceDependencies(
@@ -238,7 +250,8 @@ export async function generateScriptMetadataInternal(
   // Compute the module folder path early so we can include module hashes in stale check
   const moduleFolderPath = isFolderLayout
     ? path.dirname(scriptPath)
-    : scriptPath.substring(0, scriptPath.indexOf(".")) + getModuleFolderSuffix();
+    : scriptPath.substring(0, scriptPath.indexOf(".")) +
+      getModuleFolderSuffix(language);
 
   const hasModules = existsSync(moduleFolderPath) && statSync(moduleFolderPath).isDirectory();
 
@@ -250,7 +263,8 @@ export async function generateScriptMetadataInternal(
   let moduleHashes: Record<string, string> = {};
   if (hasModules) {
     moduleHashes = await computeModuleHashes(
-      moduleFolderPath, opts.defaultTs, tree ? {} : rawWorkspaceDependencies, isFolderLayout
+      moduleFolderPath, opts.defaultTs, tree ? {} : rawWorkspaceDependencies, isFolderLayout,
+      language === "dbt",
     );
   }
   const hasModuleHashes = Object.keys(moduleHashes).length > 0;
@@ -349,7 +363,7 @@ export async function generateScriptMetadataInternal(
 
     if (!hasCodebase) {
       const tempScriptRefs = tree?.getTempScriptRefs(remotePath);
-      const lockPathOverride = isFolderLayout
+      const lockPathOverride = metadataInFolder
         ? path.dirname(scriptPath) + "/script.lock"
         : undefined;
       await updateScriptLock(
@@ -366,8 +380,13 @@ export async function generateScriptMetadataInternal(
       metadataParsedContent.lock = "";
     }
 
-    // Generate locks for modules in __mod/ folder
-    if (hasModules) {
+    // Generate locks for modules in __mod/ folder.
+    //
+    // Never for a dbt bundle: its files are the project's own SQL and YAML, none
+    // of which is a Windmill script needing a lockfile, and writing `foo.lock`
+    // beside `foo.sql` puts our artifacts inside a tree we promise to round-trip
+    // byte-for-byte.
+    if (hasModules && language !== "dbt") {
       // Identify which modules changed by comparing per-module hashes
       let changedModules: string[] | undefined;
       if (hasModuleHashes) {
@@ -387,7 +406,7 @@ export async function generateScriptMetadataInternal(
       );
     }
   } else {
-    if (isFolderLayout) {
+    if (metadataInFolder) {
       metadataParsedContent.lock =
         "!inline " + remotePath.replaceAll(SEP, "/") + getModuleFolderSuffix() + "/script.lock";
     } else {
@@ -399,7 +418,7 @@ export async function generateScriptMetadataInternal(
   // Write metadata back to the correct path
   let metaPath: string;
   let newMetadataContent: string;
-  if (isFolderLayout) {
+  if (metadataInFolder) {
     if (metadataWithType.isJson) {
       metaPath = path.dirname(scriptPath) + "/script.json";
       newMetadataContent = JSON.stringify(metadataParsedContent);
@@ -765,15 +784,18 @@ async function updateScriptLock(
   tempScriptRefs?: Record<string, string>,
   lockPathOverride?: string,
 ): Promise<void> {
-  if (
-    !(
-      (workspaceDependenciesLanguages.some((l) => l.language == language) &&
-        language !== "powershell") ||
-      language == "deno" ||
-      language == "rust" ||
-      language == "ansible"
-    )
-  ) {
+  if (!languageNeedsLock(language)) {
+    // A dbt lock is written by the dependency job on a worker, from a real
+    // `dbt deps`/`dbt parse`, so there is nothing to generate here. Restore the
+    // reference to the file `wmill sync pull` wrote: the caller has already
+    // resolved it into the metadata, and leaving it resolved inlines the lock
+    // into the yaml on every run.
+    if (language === "dbt") {
+      const lockPath = lockPathOverride ?? remotePath + ".script.lock";
+      if (existsSync(lockPath)) {
+        metadataContent.lock = "!inline " + lockPath.replaceAll(SEP, "/");
+      }
+    }
     return;
   }
 
@@ -995,6 +1017,9 @@ export async function inferSchema(
   } else if (language === "rlang") {
     const { parse_r } = await loadParser("windmill-parser-wasm-r");
     inferedSchema = JSON.parse(parse_r(content));
+  } else if (language === "dbt") {
+    const { parse_dbt } = await loadParser("windmill-parser-wasm-yaml");
+    inferedSchema = JSON.parse(parse_dbt(content));
     // for related places search: ADD_NEW_LANG
   } else {
     throw new Error("Invalid language: " + language);
@@ -1368,8 +1393,15 @@ async function computeModuleHashes(
   defaultTs: "bun" | "deno" | undefined,
   rawWorkspaceDependencies: Record<string, string>,
   isFolderLayout: boolean,
+  // A dbt project's files are taken verbatim, so hash them the same way the
+  // push reads them: a `.sql` model has no inferable language, and dropping it
+  // here would leave an edited model looking up to date.
+  verbatim: boolean = false,
 ): Promise<Record<string, string>> {
   const hashes: Record<string, string> = {};
+  const skipDirs = verbatim
+    ? dbtGeneratedDirs(moduleFolderPath)
+    : new Set<string>();
 
   async function readDir(dirPath: string, relPrefix: string) {
     const entries = readdirSync(dirPath, { withFileTypes: true });
@@ -1379,15 +1411,31 @@ async function computeModuleHashes(
       const isTopLevel = relPrefix === "";
 
       if (entry.isDirectory()) {
+        // A configured `target-path` may be nested (`build/target`), so the
+        // comparison is on the project-relative path, not the entry name.
+        if (skipDirs.size > 0 && isUnderGeneratedDir(relPath, skipDirs)) continue;
         await readDir(fullPath, relPath);
+        // See the bundle builder: a verbatim (dbt) bundle carries a `.lock` the
+        // project authored, so the hash has to see it or a change to it would
+        // never be detected as a change.
       } else if (
         entry.isFile() &&
-        !entry.name.endsWith(".lock") &&
-        !(isFolderLayout && isTopLevel && entry.name.startsWith("script."))
+        (verbatim || !entry.name.endsWith(".lock")) &&
+        !(isFolderLayout && isTopLevel && entry.name.startsWith("script.")) &&
+        // The descriptor is the script's CONTENT, hashed as such: counting it
+        // here too would make one edit look like two changes.
+        !(verbatim && isTopLevel && entry.name === DBT_DESCRIPTOR_NAME)
       ) {
-        try {
-          inferContentTypeFromFilePath(entry.name, defaultTs);
-        } catch {
+        if (!verbatim) {
+          try {
+            inferContentTypeFromFilePath(entry.name, defaultTs);
+          } catch {
+            continue;
+          }
+        } else if (!isBundledModuleFile(fullPath)) {
+          // Hash only what the push actually sends. Hashing a file the bundle
+          // drops would make the script permanently stale: every check would
+          // see a change no push can ever resolve.
           continue;
         }
         const content = readTextFileSync(fullPath);
diff --git a/cli/src/utils/resource_folders.ts b/cli/src/utils/resource_folders.ts
index 653c443935..04ed260f07 100644
--- a/cli/src/utils/resource_folders.ts
+++ b/cli/src/utils/resource_folders.ts
@@ -8,6 +8,7 @@
  * (.flow, .app, .raw_app) or dunder-prefixed names (__flow, __app, __raw_app).
  */
 
+import { existsSync } from "node:fs";
 import * as log from "../core/log.ts";
 import { sep as SEP } from "node:path";
 import { yamlParseFile } from "./yaml.ts";
@@ -503,28 +504,323 @@ export function isFlowFolderMetadataFile(p: string): boolean {
  * to avoid confusion with file extensions.
  */
 const MODULE_SUFFIX = "__mod";
+/** dbt scripts carry a whole dbt project, not helper code. The folder says so,
+ *  and it is what a dbt developer points `--project-dir` at. */
+export const DBT_MODULE_SUFFIX = "__dbt";
+const MODULE_SUFFIXES = [MODULE_SUFFIX, DBT_MODULE_SUFFIX];
+
+/** A dbt project's descriptor, inside the project it configures and OPTIONAL:
+ *  an unmodified dbt project is already a complete Windmill script, and this
+ *  file only appears when one needs something Windmill-specific (run arguments,
+ *  a named warehouse, an engine pin). Its absence is an empty descriptor, never
+ *  a missing script. */
+export const DBT_DESCRIPTOR_NAME = "wm_dbt.yaml";
+
+/** Where a dbt script's descriptor lives, given its base path. */
+export function dbtDescriptorPath(scriptBasePath: string): string {
+  return scriptBasePath + DBT_MODULE_SUFFIX + "/" + DBT_DESCRIPTOR_NAME;
+}
+
+/** Whether an error is a dbt descriptor that simply is not there. */
+export function isMissingDbtDescriptor(filePath: string, e: unknown): boolean {
+  if ((e as { code?: string })?.code !== "ENOENT") return false;
+  const norm = filePath.replaceAll("\\", "/");
+  if (!isDbtDescriptorPath(norm)) return false;
+  // And the PROJECT is there. Absent both, this is not a descriptor-less
+  // project but a path that does not exist — a typo, or a project someone
+  // deleted — and treating it as an empty descriptor pushes `modules:
+  // undefined` over a deployed bundle, dropping it while reporting success.
+  return existsSync(
+    norm.slice(0, -DBT_DESCRIPTOR_NAME.length) + "dbt_project.yml"
+  );
+}
+
+/** Whether a path is a dbt descriptor, i.e. a dbt script's content file. */
+export function isDbtDescriptorPath(p: string): boolean {
+  const norm = normalizeSep(p);
+  const base = getScriptBasePathFromModulePath(norm);
+  return base !== undefined && norm === dbtDescriptorPath(base);
+}
 
 /**
- * Get the module folder suffix (always "__mod")
+ * Module folder suffix for a script: `__dbt` for a dbt project, `__mod`
+ * otherwise.
  */
-export function getModuleFolderSuffix(): string {
-  return MODULE_SUFFIX;
+export function getModuleFolderSuffix(language?: string): string {
+  return language === "dbt" ? DBT_MODULE_SUFFIX : MODULE_SUFFIX;
 }
 
 /**
  * Check if a path is inside a script module folder.
- * Matches patterns like: .../my_script__mod/...
+ * Matches patterns like: .../my_script__mod/... or .../my_project__dbt/...
  */
 export function isScriptModulePath(p: string): boolean {
-  return normalizeSep(p).includes(MODULE_SUFFIX + "/");
+  const n = normalizeSep(p);
+  return MODULE_SUFFIXES.some((suffix) => n.includes(suffix + "/"));
+}
+
+/** Per-file ceiling for a dbt project's bundle. Real dbt code is small (about
+ *  500 bytes median, 1.9 KB at p90 measured across dbt_utils), so this only
+ *  ever catches a committed dataset, which belongs in the warehouse rather than
+ *  in every version of the script. */
+export const MAX_MODULE_BYTES = 5 * 1024 * 1024;
+
+/**
+ * Whether a dbt project file is one the bundle carries.
+ *
+ * A dbt project's authored files are text. A binary one -- an image under
+ * `docs/`, a `.DS_Store`, a parquet seed -- would be read as mojibake and, if
+ * it carries a NUL, rejected by Postgres with an opaque `unsupported Unicode
+ * escape sequence`. Binary is detected the way `git` does it, by a NUL in the
+ * first 8000 bytes, rather than by extension, which `docs/` and stray dotfiles
+ * do not follow.
+ *
+ * The push, the staleness hash and the sync diff all ask this same question: a
+ * file one drops and another keeps is a change no push can ever resolve.
+ */
+export function isBundledModuleFile(fullPath: string): boolean {
+  return moduleFileExclusion(fullPath) === undefined;
+}
+
+/**
+ * WHY the bundle does not carry a file, when it does not.
+ *
+ * The two reasons are not interchangeable. `binary` is dbt's own leftovers and
+ * stray archives: nothing to say, so sync hides them. `oversized` is a file the
+ * project authored and dbt WOULD read — a large seed CSV — so it has to stay
+ * visible in the diff, or the push that reports the actionable size error never
+ * runs and the remote project is silently left incomplete.
+ */
+export function moduleFileExclusion(
+  fullPath: string,
+): "binary" | "oversized" | undefined {
+  // Size from `stat` and only the first 8 KB read: a project may sit next to a
+  // multi-gigabyte parquet seed or a stray archive, and reading one whole just
+  // to classify it would stall the sync or exhaust the CLI.
+  let size: number;
+  let fd: number;
+  try {
+    size = fs.statSync(fullPath).size;
+    fd = fs.openSync(fullPath, "r");
+  } catch {
+    // Unreadable is not the same as excluded. A pull asks this about files that
+    // do not exist locally yet, and answering "not carried" there would make
+    // sync ignore the whole incoming project and write nothing.
+    return undefined;
+  }
+  let binary: boolean;
+  try {
+    const head = Buffer.alloc(8000);
+    const read = fs.readSync(fd, head, 0, 8000, 0);
+    binary = head.subarray(0, read).includes(0);
+  } catch {
+    return undefined;
+  } finally {
+    fs.closeSync(fd);
+  }
+  if (binary) return "binary";
+  return size > MAX_MODULE_BYTES ? "oversized" : undefined;
+}
+
+/**
+ * The refusal an oversized dbt project file earns, raised WITHOUT reading it.
+ *
+ * dbt would have read the file, so deploying the project without it ships
+ * something that compiles here and fails at run time with a missing relation —
+ * hence an error rather than a skip. Every path that would otherwise load the
+ * body (the sync map, the push) asks first: a multi-gigabyte seed must not be
+ * buffered just to be refused.
+ */
+export function oversizedModuleFileError(relPath: string, size: number): Error {
+  return new Error(
+    `${relPath} is ${Math.ceil(size / 1024 / 1024)} MB, over the ` +
+      `${MAX_MODULE_BYTES / 1024 / 1024} MB per-file limit for a dbt project file. ` +
+      `Deploying without it would leave the project incomplete — shrink the file, or ` +
+      `keep it out of the project folder.`,
+  );
+}
+
+/**
+ * Refuse an oversized dbt project file before its content is read. `undefined`
+ * for everything else, including binary files the bundle merely drops.
+ */
+export function oversizedDbtFileError(
+  fullPath: string,
+  relPath: string,
+): Error | undefined {
+  if (!isDbtModulePath(relPath)) return undefined;
+  if (moduleFileExclusion(fullPath) !== "oversized") return undefined;
+  let size = 0;
+  try {
+    size = fs.statSync(fullPath).size;
+  } catch {
+    return undefined;
+  }
+  return oversizedModuleFileError(relPath, size);
+}
+
+/** Whether a path is inside a dbt project's module folder specifically: those
+ *  files are taken verbatim, with no language inference. */
+export function isDbtModulePath(p: string): boolean {
+  // The OUTERMOST boundary decides, like `getScriptBasePathFromModulePath`.
+  // Scanning anywhere in the path would call `foo__mod/vendor/x__dbt/a.ts` a dbt
+  // project file, and the push would then look for `foo.script.yaml` instead of
+  // the ordinary module entry point and skip the edit.
+  const norm = normalizeSep(p);
+  const base = getScriptBasePathFromModulePath(norm);
+  return base !== undefined && norm.startsWith(base + DBT_MODULE_SUFFIX + "/");
+}
+
+/** dbt writes these; a project authors them nowhere. Importing a stale
+ *  `target/` would ship a manifest this runtime then reads as the graph, and
+ *  `dbt_packages/` is a vendored copy the worker restores from its own cache. */
+const DBT_GENERATED_DIRS = ["target", "dbt_packages", "logs", ".git", ".venv", "__pycache__"];
+
+const dbtGeneratedDirsCache = new Map<
+  string,
+  { stamp: string; dirs: Set<string> }
+>();
+
+/** `{{ env_var('NAME') }}` / `{{ env_var("NAME", "default") }}`. */
+const DBT_ENV_VAR_CALL =
+  /\{\{\s*env_var\(\s*['"]([^'"]+)['"]\s*(?:,\s*['"]([^'"]*)['"]\s*)?\)\s*\}\}/g;
+
+/**
+ * Render `dbt_project.yml`'s own `env_var()` calls, which dbt allows there too.
+ * A directory setting left as its template names no directory on disk, so the
+ * generated tree it points at would be bundled as project source.
+ *
+ * Against `process.env`, because the CLI runs where the project was built: that
+ * is the environment dbt used to produce the tree being read.
+ */
+export function renderDbtEnvVars(value: string): string {
+  return value.replace(
+    DBT_ENV_VAR_CALL,
+    (whole, name: string, fallback: string | undefined) =>
+      process.env[name] ?? fallback ?? whole,
+  );
+}
+
+/**
+ * Files that keep a project's secrets next to it rather than in it: dbt reads
+ * none of them (`env_var()` takes the process environment), and the documented
+ * way into a bundle is `cp -r my-project/.`, which copies whatever the checkout
+ * holds — including the `.env` a `.gitignore` was keeping out of the repo.
+ */
+export function isLocalSecretFile(name: string): boolean {
+  return name === ".env" || name.startsWith(".env.") || name === ".envrc";
+}
+
+/**
+ * Directories to leave out of a dbt project's module bundle, as project-relative
+ * paths — `target-path` and friends may be nested (`build/target`).
+ *
+ * `target-path`, `packages-install-path` and `clean-targets` are configurable,
+ * so they are read from the project rather than assumed. Cached per project
+ * folder: this is called once per file of a sync.
+ */
+export function dbtGeneratedDirs(moduleFolderPath: string): Set<string> {
+  const projectFile = path.join(moduleFolderPath, "dbt_project.yml");
+  // Cached against the project file's identity, not merely its folder: `wmill
+  // dev` is a long-running process, so a `target-path` edited mid-session would
+  // otherwise keep excluding the old directory and start bundling the new one
+  // as project source. One entry per folder, replaced when the file changes.
+  let stamp = "";
+  try {
+    const st = fs.statSync(projectFile);
+    stamp = `${st.mtimeMs}:${st.size}`;
+  } catch {
+    // No project file yet: the defaults apply, and "absent" is its own stamp.
+  }
+  const cached = dbtGeneratedDirsCache.get(moduleFolderPath);
+  if (cached && cached.stamp === stamp) return cached.dirs;
+  const dirs = new Set<string>(DBT_GENERATED_DIRS);
+  const add = (raw: string) => {
+    const v = normalizeSep(renderDbtEnvVars(raw).trim().replace(/^["']|["']$/g, ""))
+      .replace(/^\.\//, "")
+      .replace(/\/+$/, "");
+    // A configured path that escapes the project is dbt's problem, not ours;
+    // ignoring it here just means those files stay in the bundle.
+    if (v && !v.startsWith("/") && !v.split("/").includes("..")) dirs.add(v);
+  };
+  try {
+    const projectYml = fs.readFileSync(projectFile, "utf-8");
+    for (const m of projectYml.matchAll(
+      /^\s*(?:target-path|packages-install-path)\s*:\s*([^\n#]+)/gm,
+    )) {
+      add(m[1]);
+    }
+    // `clean-targets` in either of dbt's two spellings: inline `[a, b]`, and the
+    // block form, whose entries are on the lines that follow.
+    const lines = projectYml.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+      const head = lines[i].match(/^\s*clean-targets\s*:\s*(.*)$/);
+      if (!head) continue;
+      const inline = head[1].match(/^\[([^\]]*)\]/);
+      if (inline) {
+        inline[1].split(",").forEach(add);
+        continue;
+      }
+      for (let j = i + 1; j < lines.length; j++) {
+        const item = lines[j].match(/^\s+-\s*([^\n#]+)$/);
+        if (!item) break;
+        add(item[1]);
+      }
+    }
+  } catch {
+    // No dbt_project.yml yet (a descriptor pushed before its project): the
+    // defaults still apply.
+  }
+  dbtGeneratedDirsCache.set(moduleFolderPath, { stamp, dirs });
+  return dirs;
+}
+
+/**
+ * Whether a project-relative path sits inside one of `dirs`. Compared segment
+ * by segment: `targetx/a` must not match a configured `target`.
+ */
+export function isUnderGeneratedDir(rel: string, dirs: Set<string>): boolean {
+  const n = normalizeSep(rel);
+  for (const d of dirs) {
+    if (n === d || n.startsWith(d + "/")) return true;
+  }
+  return false;
+}
+
+/**
+ * Whether a path under a `__dbt/` folder is one dbt generated rather than one
+ * the project authors. Those never belong to the bundle, so sync must not offer
+ * them as items of their own either.
+ */
+export function isDbtGeneratedPath(p: string): boolean {
+  const n = normalizeSep(p);
+  // Anchored on the outermost boundary, like every other helper here. Matching
+  // `__dbt/` anywhere would call `foo__mod/vendor/x__dbt/target/a.ts` generated
+  // dbt output, and `ignoreF` would then exclude an ordinary module file so a
+  // module-only edit never deploys its parent script.
+  if (!isDbtModulePath(n)) return false;
+  const base = getScriptBasePathFromModulePath(n)!;
+  const projectRoot = base + DBT_MODULE_SUFFIX;
+  const rel = n.slice(projectRoot.length + 1);
+  if (isUnderGeneratedDir(rel, dbtGeneratedDirs(projectRoot))) {
+    return true;
+  }
+  // Not generated, but not carried either: the bundle drops it, so the diff
+  // must not keep offering it as a pending change. An OVERSIZED one is the
+  // exception — see `moduleFileExclusion`: hiding it here is what would make an
+  // edit to a large seed report no change at all.
+  return (
+    isLocalSecretFile(n.slice(n.lastIndexOf("/") + 1)) ||
+    moduleFileExclusion(p) === "binary"
+  );
 }
 
 /**
  * Build the module folder path from a script's base path (without extension).
- * e.g., "f/my_script" -> "f/my_script__mod"
+ * e.g., "f/my_script" -> "f/my_script__mod", or "__dbt" for a dbt project.
  */
-export function buildModuleFolderPath(scriptBasePath: string): string {
-  return scriptBasePath + MODULE_SUFFIX;
+export function buildModuleFolderPath(scriptBasePath: string, language?: string): string {
+  return scriptBasePath + getModuleFolderSuffix(language);
 }
 
 /**
@@ -533,10 +829,21 @@ export function buildModuleFolderPath(scriptBasePath: string): string {
  */
 export function isModuleEntryPoint(p: string): boolean {
   const norm = normalizeSep(p);
+  // Anchored on the OUTERMOST module boundary, like
+  // `getScriptBasePathFromModulePath`. Scanning for `__mod/` alone would match a
+  // `legacy__mod/` directory nested inside a dbt project — dbt owns those names
+  // verbatim — and call its `script.ts` this script's entry point.
+  const base = getScriptBasePathFromModulePath(norm);
+  if (base === undefined) return false;
+  // A dbt project's entry point is its descriptor, which sits INSIDE the
+  // project so that an author writes nothing outside the directory dbt itself
+  // reads.
+  if (norm.startsWith(base + DBT_MODULE_SUFFIX + "/")) {
+    return norm === dbtDescriptorPath(base);
+  }
   const suffix = MODULE_SUFFIX + "/";
-  const idx = norm.indexOf(suffix);
-  if (idx === -1) return false;
-  const rest = norm.slice(idx + suffix.length);
+  if (!norm.startsWith(base + suffix)) return false;
+  const rest = norm.slice(base.length + suffix.length);
   return rest.startsWith("script.") && !rest.includes("/");
 }
 
@@ -544,13 +851,21 @@ export function isModuleEntryPoint(p: string): boolean {
  * Extract the script base path from a module folder entry.
  * e.g., "u/admin/my_script__mod/script.ts" -> "u/admin/my_script"
  * e.g., "u/admin/my_script__mod/helper.ts" -> "u/admin/my_script"
+ * e.g., "f/x/proj__dbt/models/a.sql" -> "f/x/proj"
  */
 export function getScriptBasePathFromModulePath(p: string): string | undefined {
   const norm = normalizeSep(p);
-  const suffix = MODULE_SUFFIX + "/";
-  const idx = norm.indexOf(suffix);
-  if (idx === -1) return undefined;
-  return norm.slice(0, idx);
+  // The OUTERMOST boundary, not the first suffix that happens to match. A dbt
+  // project's directories are the author's verbatim, so `foo__dbt/models/
+  // legacy__mod/a.sql` is legal — taking `__mod` first would call
+  // `foo__dbt/models/legacy` the script and look for a descriptor that is not
+  // there, silently skipping the deploy.
+  let best: number | undefined;
+  for (const suffix of MODULE_SUFFIXES) {
+    const idx = norm.indexOf(suffix + "/");
+    if (idx !== -1 && (best === undefined || idx < best)) best = idx;
+  }
+  return best === undefined ? undefined : norm.slice(0, best);
 }
 
 /**
diff --git a/cli/src/utils/script_common.ts b/cli/src/utils/script_common.ts
index a713e41782..318f84b7c9 100644
--- a/cli/src/utils/script_common.ts
+++ b/cli/src/utils/script_common.ts
@@ -1,3 +1,4 @@
+import { isDbtDescriptorPath } from "./resource_folders.ts";
 export type ScriptLanguage =
   | "python3"
   | "deno"
@@ -21,6 +22,7 @@ export type ScriptLanguage =
   | "ansible"
   | "ruby"
   | "rlang"
+  | "dbt"
   | "java";
 // for related places search: ADD_NEW_LANG
 
@@ -106,6 +108,8 @@ export function inferContentTypeFromFilePath(
     return "java";
   } else if (contentPath.endsWith(".rb")) {
     return "ruby";
+  } else if (isDbtDescriptorPath(contentPath)) {
+    return "dbt";
   } else if (contentPath.endsWith(".r")) {
     return "rlang";
 	// for related places search: ADD_NEW_LANG
@@ -119,7 +123,7 @@ export function inferContentTypeFromFilePath(
     throw new Error(
       `Cannot infer script language from extension '${ext}' (file ${contentPath}).` +
         hint +
-        "\nSupported extensions: .ts (bun/deno), .py, .go, .sh, .ps1, .php, .rs, .cs, .nu, .java, .rb, .r, .gql, .playbook.yml, .pg.sql, .my.sql, .bq.sql, .sf.sql, .ms.sql, .odb.sql, .duckdb.sql"
+        "\nSupported extensions: .ts (bun/deno), .py, .go, .sh, .ps1, .php, .rs, .cs, .nu, .java, .rb, .r, .gql, .playbook.yml, .pg.sql, .my.sql, .bq.sql, .sf.sql, .ms.sql, .odb.sql, .duckdb.sql, and a dbt project folder `<name>__dbt/`"
     );
   }
 }
diff --git a/cli/test/dbt_module_tracker_unit.test.ts b/cli/test/dbt_module_tracker_unit.test.ts
new file mode 100644
index 0000000000..90abee18ae
--- /dev/null
+++ b/cli/test/dbt_module_tracker_unit.test.ts
@@ -0,0 +1,145 @@
+/**
+ * `buildTracker` decides whose top hash `wmill-lock.yaml` refreshes. A dbt
+ * project is mostly files that are not Windmill script extensions — the project
+ * file, `packages.yml`, schema YAML, seed CSVs — and its folder is spelled
+ * `__dbt\` on Windows, so both the extension gate and a raw-path search for
+ * `__dbt/` left the descriptor untracked and its hash stale.
+ */
+import { expect, test, describe, beforeEach, afterEach } from "bun:test";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { buildTracker, elementsToMap } from "../src/commands/sync/sync.ts";
+import { isDbtGeneratedPath } from "../src/utils/resource_folders.ts";
+import { readModulesFromDisk } from "../src/commands/script/script.ts";
+
+describe("buildTracker with a dbt project", () => {
+  let dir: string;
+  let cwd: string;
+
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), "wmill-dbt-tracker-"));
+    cwd = process.cwd();
+    process.chdir(dir);
+    fs.mkdirSync(path.join(dir, "f/analytics/analytics__dbt/models"), {
+      recursive: true,
+    });
+    fs.mkdirSync(path.join(dir, "f/analytics/analytics__dbt/seeds"), {
+      recursive: true,
+    });
+    // The descriptor sits INSIDE the project folder, and `findContentFile`
+    // resolves the metadata path to it.
+    fs.writeFileSync(path.join(dir, "f/analytics/analytics.script.yaml"), "{}");
+    fs.writeFileSync(
+      path.join(dir, "f/analytics/analytics__dbt/dbt_project.yml"),
+      "name: analytics\n",
+    );
+    fs.writeFileSync(
+      path.join(dir, "f/analytics/analytics__dbt/wm_dbt.yaml"),
+      "profile: {}\n",
+    );
+  });
+
+  afterEach(() => {
+    process.chdir(cwd);
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  const tracked = async (p: string) =>
+    (await buildTracker([{ name: "edited", path: p, before: "", after: "" }]))
+      .scripts;
+
+  test("a model edit selects the descriptor", async () => {
+    expect(
+      await tracked("f/analytics/analytics__dbt/models/stg_orders.sql"),
+    ).toEqual(["f/analytics/analytics__dbt/wm_dbt.yaml"]);
+  });
+
+  test("so do the files that are not script extensions", async () => {
+    for (const p of [
+      "f/analytics/analytics__dbt/dbt_project.yml",
+      "f/analytics/analytics__dbt/packages.yml",
+      "f/analytics/analytics__dbt/models/_models.yml",
+      "f/analytics/analytics__dbt/seeds/country_codes.csv",
+    ]) {
+      expect(await tracked(p)).toEqual(
+        ["f/analytics/analytics__dbt/wm_dbt.yaml"],
+        `${p} left the descriptor untracked`,
+      );
+    }
+  });
+
+  // Regression: hoisting the module check above the extension gate made
+  // `<base>__mod/script.yaml` — a folder-layout script's METADATA, which is an
+  // entry-point path — look like its own content file. Pushed as one, the
+  // metadata pass asks for the language of `.yaml` and aborts the command. Not a
+  // dbt shape at all; reached by editing the summary of any modular script.
+  test("a modular script's own metadata resolves to its content file", async () => {
+    fs.mkdirSync(path.join(dir, "f/helpers/util__mod"), { recursive: true });
+    fs.writeFileSync(path.join(dir, "f/helpers/util__mod/script.yaml"), "{}");
+    fs.writeFileSync(
+      path.join(dir, "f/helpers/util__mod/script.ts"),
+      "export function main() {}\n",
+    );
+    expect(await tracked("f/helpers/util__mod/script.yaml")).toEqual([
+      "f/helpers/util__mod/script.ts",
+    ]);
+  });
+
+  test("and a Windows-separated path", async () => {
+    expect(
+      await tracked("f\\analytics\\analytics__dbt\\models\\stg_orders.sql"),
+    ).toEqual(["f/analytics/analytics__dbt/wm_dbt.yaml"]);
+  });
+
+  // A dbt descriptor is the script's CONTENT and is a `.yaml` inside the
+  // project folder. `--json` drops every metadata `.yaml` as the twin it does
+  // not read — dropping this one too leaves a workspace whose dbt scripts have
+  // metadata, a lock and a project bundle, but nothing to run.
+  test("--json keeps the descriptor while dropping metadata yaml", async () => {
+    const file = (path: string) => ({
+      path,
+      isDirectory: false,
+      getChildren: async function* () {},
+      getContentText: async () => "x",
+    });
+    const root = {
+      path: "",
+      isDirectory: true,
+      getChildren: async function* () {
+        yield file("f/analytics/analytics__dbt/wm_dbt.yaml");
+        yield file("f/analytics/analytics.script.yaml");
+        yield file("f/analytics/analytics.script.json");
+      },
+      getContentText: async () => "",
+    };
+    const map = await elementsToMap(root as any, () => false, true, {});
+    expect(Object.keys(map).sort()).toEqual([
+      "f/analytics/analytics.script.json",
+      "f/analytics/analytics__dbt/wm_dbt.yaml",
+    ]);
+  });
+
+  // `cp -r my-dbt-project/.` copies whatever the checkout holds, and what a
+  // `.gitignore` was keeping out of the repo is exactly the file that must not
+  // become a script version. Both halves: bundled, it is uploaded; offered by
+  // the diff, every push asks to upload it again.
+  test("a local .env is neither bundled nor offered as a change", async () => {
+    const project = path.join(dir, "f/analytics/analytics__dbt");
+    fs.writeFileSync(path.join(project, ".env"), "DBT_PASSWORD=hunter2\n");
+    fs.writeFileSync(path.join(project, "models/stg.sql"), "select 1");
+
+    const modules = await readModulesFromDisk(project, undefined, false, true);
+    // Sorted: the bundle is a set of paths, and the walk follows `readdirSync`,
+    // whose order is the filesystem's.
+    expect(Object.keys(modules ?? {}).sort()).toEqual([
+      "dbt_project.yml",
+      "models/stg.sql",
+    ]);
+
+    // The predicate the sync's ignore filter asks, so the file is not offered
+    // as an item of its own either.
+    expect(isDbtGeneratedPath("f/analytics/analytics__dbt/.env")).toBe(true);
+    expect(isDbtGeneratedPath("f/analytics/analytics__dbt/models/stg.sql")).toBe(false);
+  });
+});
diff --git a/cli/test/dbt_optional_descriptor_unit.test.ts b/cli/test/dbt_optional_descriptor_unit.test.ts
new file mode 100644
index 0000000000..08d5561f83
--- /dev/null
+++ b/cli/test/dbt_optional_descriptor_unit.test.ts
@@ -0,0 +1,211 @@
+/**
+ * An unmodified dbt project is already a complete Windmill script: the
+ * descriptor is optional, and a project that never names one must push, diff
+ * and pull without ever growing a Windmill file inside it.
+ */
+import { expect, test, describe, beforeEach, afterEach } from "bun:test";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { FSFSElement, elementsToMap } from "../src/commands/sync/sync.ts";
+import { listWorkspacePaths } from "../src/commands/dev/dev.ts";
+import {
+  DbtPathCollisionError,
+  findContentFile,
+  handleFile,
+  hasScriptExt,
+  removeExtensionToPath,
+} from "../src/commands/script/script.ts";
+import { pushParentScriptForModule } from "../src/commands/sync/sync.ts";
+
+/** The local map's keys are the walk's own — `path.join`, so `__dbt\\` on
+ *  Windows — while a remote's are the API's. The synthesized descriptor follows
+ *  the spelling of the `dbt_project.yml` it was derived from, like every other
+ *  key in that map, so an assertion on one platform's separator tests the
+ *  platform and not the synthesis. */
+const normalized = (m: Record<string, string>) =>
+  Object.fromEntries(
+    Object.entries(m).map(([k, v]) => [k.replaceAll("\\", "/"), v]),
+  );
+
+describe("a dbt project without a descriptor", () => {
+  let dir: string;
+
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), "wmill-dbt-nodesc-"));
+    fs.mkdirSync(path.join(dir, "f/analytics/analytics__dbt/models"), {
+      recursive: true,
+    });
+    fs.writeFileSync(
+      path.join(dir, "f/analytics/analytics__dbt/dbt_project.yml"),
+      "name: analytics\n",
+    );
+    fs.writeFileSync(
+      path.join(dir, "f/analytics/analytics__dbt/models/stg_orders.sql"),
+      "select 1",
+    );
+    fs.writeFileSync(path.join(dir, "f/analytics/analytics.script.yaml"), "{}");
+  });
+
+  afterEach(() => {
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  // Without this the project has no content file, so nothing identifies it as a
+  // script and the whole project silently never deploys.
+  test("is still discovered, as an empty descriptor", async () => {
+    const root = await FSFSElement(dir, [], true);
+    const map = await elementsToMap(root, () => false, false, {});
+    expect(normalized(map)["f/analytics/analytics__dbt/wm_dbt.yaml"]).toBe("");
+  });
+
+  // The metadata has to resolve to a content path that is not on disk, or every
+  // caller that goes metadata -> content aborts the push.
+  test("resolves from its metadata to the absent descriptor", async () => {
+    const cwd = process.cwd();
+    process.chdir(dir);
+    try {
+      expect(await findContentFile("f/analytics/analytics.script.yaml")).toBe(
+        "f/analytics/analytics__dbt/wm_dbt.yaml",
+      );
+    } finally {
+      process.chdir(cwd);
+    }
+  });
+
+  // The descriptor is the one "extension" that contains a separator, so on
+  // Windows it is spelled `__dbt\wm_dbt.yaml` and a forward-slash suffix test
+  // matches nothing — every dbt project skipped, with no error.
+  test("is recognized when the path is spelled with backslashes", () => {
+    const win = "f\\analytics\\analytics__dbt\\wm_dbt.yaml";
+    expect(hasScriptExt(win)).toBe(true);
+    expect(removeExtensionToPath(win)).toBe("f\\analytics\\analytics");
+  });
+
+  // Both `<base>.py` and `<base>__dbt/` deploy to the SAME remote path, and the
+  // descriptor is optional — so the project is invisible to the candidate list
+  // while being perfectly real. Resolved to the ordinary file, a model edit
+  // deploys the Python script over the dbt one.
+  test("refuses to resolve when an ordinary script shares its path", async () => {
+    const cwd = process.cwd();
+    process.chdir(dir);
+    try {
+      fs.writeFileSync(path.join(dir, "f/analytics/analytics.py"), "def main(): ...");
+      const err = await findContentFile("f/analytics/analytics.script.yaml").then(
+        () => undefined,
+        (e) => e as Error,
+      );
+      expect(err?.message).toContain("f/analytics/analytics__dbt/dbt_project.yml");
+      expect(err?.message).toContain("f/analytics/analytics.py");
+    } finally {
+      process.chdir(cwd);
+    }
+  });
+
+  // The guard has to sit on the push paths themselves, not only on the
+  // metadata->content resolution: an ordinary file goes straight to
+  // `handleFile`, and a module edit reaches its parent through a call whose
+  // errors were swallowed — so each path could still overwrite the other's
+  // script while reporting success.
+  test("both push paths refuse the collision", async () => {
+    const cwd = process.cwd();
+    process.chdir(dir);
+    try {
+      fs.writeFileSync(path.join(dir, "f/analytics/analytics.py"), "def main(): ...");
+      const ordinary = await handleFile(
+        "f/analytics/analytics.py",
+        { workspaceId: "w", remote: "http://localhost", name: "w", token: "t" } as any,
+        [],
+        undefined,
+        undefined,
+        {},
+        [],
+      ).then(
+        () => undefined,
+        (e) => e as Error,
+      );
+      expect(ordinary).toBeInstanceOf(DbtPathCollisionError);
+      expect(ordinary?.message).toContain("f/analytics/analytics.py");
+
+      const model = await pushParentScriptForModule(
+        "f/analytics/analytics__dbt/models/stg_orders.sql",
+        { workspaceId: "w", remote: "http://localhost", name: "w", token: "t" } as any,
+        [],
+        undefined,
+        undefined,
+        {},
+        [],
+      ).then(
+        () => undefined,
+        (e) => e as Error,
+      );
+      expect(model).toBeInstanceOf(DbtPathCollisionError);
+    } finally {
+      process.chdir(cwd);
+    }
+  });
+
+  // The two sides spell "absent" differently — nothing on disk, nothing in the
+  // export — so without one normalization a descriptor-less project reads as an
+  // addition on every push and a deletion on every pull, forever.
+  test("compares equal to a remote that carries no descriptor either", async () => {
+    const remote = {
+      path: "",
+      isDirectory: true,
+      getChildren: async function* () {
+        for (const p of [
+          "f/analytics/analytics__dbt/dbt_project.yml",
+          "f/analytics/analytics__dbt/models/stg_orders.sql",
+          "f/analytics/analytics.script.yaml",
+        ]) {
+          yield {
+            path: p,
+            isDirectory: false,
+            getChildren: async function* () {},
+            getContentText: async () => "x",
+          };
+        }
+      },
+      getContentText: async () => "",
+    };
+    const local = await elementsToMap(
+      await FSFSElement(dir, [], true),
+      () => false,
+      false,
+      {},
+    );
+    const remoteMap = await elementsToMap(remote as any, () => false, false, {});
+    const key = "f/analytics/analytics__dbt/wm_dbt.yaml";
+    expect(normalized(local)[key]).toBe("");
+    expect(normalized(remoteMap)[key]).toBe("");
+  });
+});
+
+// `wmill dev` walks basenames, and a dbt script is a DIRECTORY whose descriptor
+// may not exist — so it is recognized by the project folder or not at all. The
+// walk must also stop there: the project's own `.sql` models match the script
+// extensions and would each be listed as a script of their own.
+describe("dev-mode discovery of a dbt project", () => {
+	let dir: string
+	let cwd: string
+
+	beforeEach(() => {
+		dir = fs.mkdtempSync(path.join(os.tmpdir(), 'wmill-dbt-dev-'))
+		fs.mkdirSync(path.join(dir, 'f/analytics/analytics__dbt/models'), { recursive: true })
+		fs.writeFileSync(path.join(dir, 'f/analytics/analytics__dbt/dbt_project.yml'), 'name: a\n')
+		fs.writeFileSync(path.join(dir, 'f/analytics/analytics__dbt/models/stg.sql'), 'select 1')
+		cwd = process.cwd()
+		process.chdir(dir)
+	})
+
+	afterEach(() => {
+		process.chdir(cwd)
+		fs.rmSync(dir, { recursive: true, force: true })
+	})
+
+	test('lists the project itself and nothing inside it', async () => {
+		const items = await listWorkspacePaths()
+		const paths = items.map((i) => i.path).sort()
+		expect(paths).toEqual(['f/analytics/analytics'])
+	})
+})
diff --git a/cli/test/elements_to_map_branch_specific_unit.test.ts b/cli/test/elements_to_map_branch_specific_unit.test.ts
index b9abaa8dd1..ebab7ef929 100644
--- a/cli/test/elements_to_map_branch_specific_unit.test.ts
+++ b/cli/test/elements_to_map_branch_specific_unit.test.ts
@@ -423,3 +423,45 @@ test("elementsToMap: isRemote undefined behaves like local (backward compatible)
   // Base file should be skipped (same behavior as isRemote=false)
   expect(Object.keys(result).includes("f/test.variable.yaml")).toEqual(false);
 });
+
+// =============================================================================
+// REGRESSION TEST: --skip-scripts covers a script's module files
+// A module is deployed as part of its parent script, and the module shortcut
+// runs before every skip filter — so a changed model under a dbt project's
+// `__dbt/` folder pushed the script `--skip-scripts` asked to leave alone.
+// =============================================================================
+
+test("elementsToMap: script modules are excluded when skipScripts is set", async () => {
+  const files: MockFile[] = [
+    { path: "f/analytics/analytics.dbt.yaml", content: "profile: {}\n" },
+    {
+      path: "f/analytics/analytics__dbt/models/stg_orders.sql",
+      content: "select 1",
+    },
+    { path: "f/Shared/Variable/TestVar.variable.yaml", content: "value: test" },
+  ];
+
+  const kept = await elementsToMap(
+    createMockDynFSElement(files),
+    noIgnore,
+    false,
+    defaultSkips,
+  );
+  expect(
+    Object.keys(kept).includes("f/analytics/analytics__dbt/models/stg_orders.sql"),
+  ).toEqual(true);
+
+  const skipped = await elementsToMap(
+    createMockDynFSElement(files),
+    noIgnore,
+    false,
+    { skipScripts: true },
+  );
+  expect(
+    Object.keys(skipped).includes("f/analytics/analytics__dbt/models/stg_orders.sql"),
+  ).toEqual(false);
+  // Everything else is unaffected.
+  expect(
+    Object.keys(skipped).includes("f/Shared/Variable/TestVar.variable.yaml"),
+  ).toEqual(true);
+});
diff --git a/cli/test/pipeline_local_graph_unit.test.ts b/cli/test/pipeline_local_graph_unit.test.ts
index 7b8b8b0dc5..29d016857c 100644
--- a/cli/test/pipeline_local_graph_unit.test.ts
+++ b/cli/test/pipeline_local_graph_unit.test.ts
@@ -5,6 +5,7 @@ import { join } from "node:path";
 
 import {
   buildLocalPipelineGraph,
+  hideDbtRunnables,
   parseMuteAnnotations,
 } from "../src/commands/pipeline/localGraph.ts";
 
@@ -915,3 +916,96 @@ test("pipeline docs renders a `Macro libraries` section (call + `// use`)", asyn
     },
   );
 });
+
+test("a dbt script is not a pipeline node — a dbt-only folder has no graph", async () => {
+  await withFolder(
+    {
+      "warehouse.dbt.yaml": `engine: dbt-core-1x\nprofile:\n  resource: $res:u/admin/wh\n`,
+    },
+    async (root, folder) => {
+      const { graph, scripts } = await buildLocalPipelineGraph({
+        root,
+        folder,
+        defaultTs: "bun",
+      });
+      // A dbt project is authored and run as itself, never as a pipeline member;
+      // the deploy leaves its `auto_kind` unset, so the local graph must agree.
+      expect(graph.runnables).toEqual([]);
+      expect(scripts).toEqual([]);
+    },
+  );
+});
+
+test("a folder mixing dbt and a pipeline keeps only the pipeline member", async () => {
+  await withFolder(
+    {
+      "warehouse.dbt.yaml": `engine: dbt-core-1x\nprofile:\n  resource: $res:u/admin/wh\n`,
+      "report.bun.ts": `// pipeline\nexport async function main() {}\n`,
+    },
+    async (root, folder) => {
+      const { graph } = await buildLocalPipelineGraph({
+        root,
+        folder,
+        defaultTs: "bun",
+      });
+      expect(graph.runnables.map((r) => r.path)).toEqual(["f/mypipe/report"]);
+    },
+  );
+});
+
+test("hideDbtRunnables drops the dbt node from a deployed graph, keeping its relations", () => {
+  // `/assets/graph` is asset-usage driven, so it returns the dbt script as a
+  // producer. The CLI's deployed views must not render it as a pipeline script.
+  const deployed = {
+    runnables: [
+      { path: "f/x/dbtproj", usage_kind: "script" as const, dbt: { model_count: 2 } },
+      { path: "f/x/report", usage_kind: "script" as const, in_pipeline: true },
+    ],
+    assets: [
+      { kind: "table", path: "u/a/wh/s/stg_orders" },
+      { kind: "table", path: "u/a/wh/s/fct_orders" },
+    ],
+    edges: [
+      { runnable_kind: "script", runnable_path: "f/x/dbtproj", asset_kind: "table", asset_path: "u/a/wh/s/stg_orders", access_type: "w" as const },
+      { runnable_kind: "script", runnable_path: "f/x/dbtproj", asset_kind: "table", asset_path: "u/a/wh/s/fct_orders", access_type: "w" as const },
+      { runnable_kind: "script", runnable_path: "f/x/report", asset_kind: "table", asset_path: "u/a/wh/s/fct_orders", access_type: "r" as const },
+    ],
+    triggers: [
+      { trigger_kind: "asset" as const, asset_kind: "table", asset_path: "u/a/wh/s/fct_orders", runnable_kind: "script", runnable_path: "f/x/report" },
+    ],
+  };
+  const g = hideDbtRunnables(deployed);
+  expect(g.runnables.map((r) => r.path)).toEqual(["f/x/report"]);
+  expect(g.edges.map((e) => e.runnable_path)).toEqual(["f/x/report"]);
+  // The relations stay: they are what the downstream pipeline script reads.
+  expect(g.assets).toHaveLength(2);
+  expect(g.triggers).toHaveLength(1);
+});
+
+test("hideDbtRunnables keeps a flow sharing a path with the dbt script", () => {
+  // Runnable identity in the graph is `(usage_kind, path)`; a script and a flow
+  // may share a path, so only the dbt script may be removed.
+  const g = hideDbtRunnables({
+    runnables: [
+      { path: "f/x/proj", usage_kind: "script", dbt: { model_count: 1 } },
+      { path: "f/x/proj", usage_kind: "flow" },
+    ],
+    edges: [
+      { runnable_kind: "flow", runnable_path: "f/x/proj" },
+      { runnable_kind: "script", runnable_path: "f/x/proj" },
+    ],
+    triggers: [{ runnable_kind: "flow", runnable_path: "f/x/proj" }],
+  });
+  expect(g.runnables.map((r) => r.usage_kind)).toEqual(["flow"]);
+  expect(g.edges.map((e) => e.runnable_kind)).toEqual(["flow"]);
+  expect(g.triggers).toHaveLength(1);
+});
+
+test("hideDbtRunnables is a no-op when the folder has no dbt project", () => {
+  const g = {
+    runnables: [{ path: "f/x/a", usage_kind: "script" }],
+    edges: [],
+    triggers: [],
+  };
+  expect(hideDbtRunnables(g)).toBe(g);
+});
diff --git a/cli/test/resource_folders_unit.test.ts b/cli/test/resource_folders_unit.test.ts
index 0d07812124..de3daa18cd 100644
--- a/cli/test/resource_folders_unit.test.ts
+++ b/cli/test/resource_folders_unit.test.ts
@@ -3,7 +3,7 @@
  * Tests both dotted (.flow, .app, .raw_app) and non-dotted (__flow, __app, __raw_app) modes.
  */
 
-import { expect, test, describe, beforeEach } from "bun:test";
+import { expect, test, describe, beforeEach, afterEach } from "bun:test";
 import {
   setNonDottedPaths,
   getNonDottedPaths,
@@ -37,6 +37,13 @@ import {
   transformJsonPathToDir,
   isModuleEntryPoint,
   getScriptBasePathFromModulePath,
+  isDbtGeneratedPath,
+  dbtGeneratedDirs,
+  isUnderGeneratedDir,
+  isDbtModulePath,
+  isBundledModuleFile,
+  moduleFileExclusion,
+  MAX_MODULE_BYTES,
 } from "../src/utils/resource_folders.ts";
 import { removeWorkerPrefix } from "../src/commands/worker-groups/worker-groups.ts";
 
@@ -657,3 +664,194 @@ describe("removeWorkerPrefix", () => {
     expect(removeWorkerPrefix("worker__")).toBe("");
   });
 });
+
+// A dbt project's generated directories never belong to the bundle: hashing and
+// uploading a local `target/` would make every local `dbt run` look like a
+// project change, and a stale manifest in it is what the runtime reads as the
+// graph. They are configurable, so they are read from the project.
+describe("dbtGeneratedDirs", () => {
+  const fs = require("node:fs");
+  const os = require("node:os");
+  const nodePath = require("node:path");
+  let dir: string;
+  // Every temp directory this block makes, so none outlives the run: the helper
+  // below mints one per call by design.
+  let made: string[] = [];
+
+  beforeEach(() => {
+    dir = fs.mkdtempSync(nodePath.join(os.tmpdir(), "dbtgen-"));
+    made = [dir];
+  });
+
+  afterEach(() => {
+    for (const d of made) fs.rmSync(d, { recursive: true, force: true });
+  });
+
+  // A fresh directory per call: `dbtGeneratedDirs` memoizes per project folder,
+  // since within one sync the project file does not change under it.
+  const write = (yml: string) => {
+    const d = fs.mkdtempSync(nodePath.join(os.tmpdir(), "dbtgen-"));
+    made.push(d);
+    fs.writeFileSync(nodePath.join(d, "dbt_project.yml"), yml);
+    return dbtGeneratedDirs(d);
+  };
+
+  test("defaults apply with no project file", () => {
+    const dirs = dbtGeneratedDirs(dir);
+    expect(dirs.has("target")).toBe(true);
+    expect(dirs.has("dbt_packages")).toBe(true);
+  });
+
+  test("reads nested target-path and packages-install-path", () => {
+    const dirs = write(
+      'name: p\ntarget-path: "build/target"\npackages-install-path: ./vendor/pkgs\n',
+    );
+    expect(dirs.has("build/target")).toBe(true);
+    expect(dirs.has("vendor/pkgs")).toBe(true);
+  });
+
+  test("reads clean-targets in both of dbt's spellings", () => {
+    expect(write('name: p\nclean-targets: ["a", b]\n').has("a")).toBe(true);
+    const block = write("name: p\nclean-targets:\n  - out/one\n  - two\nmodels: {}\n");
+    expect(block.has("out/one")).toBe(true);
+    expect(block.has("two")).toBe(true);
+    expect(block.has("models")).toBe(false);
+  });
+
+  test("ignores a configured path that escapes the project", () => {
+    const dirs = write('name: p\ntarget-path: "../../etc"\n');
+    expect([...dirs].some((d) => d.includes(".."))).toBe(false);
+  });
+});
+
+describe("isUnderGeneratedDir", () => {
+  const dirs = new Set(["target", "build/target"]);
+
+  test("matches the directory and everything under it", () => {
+    expect(isUnderGeneratedDir("target", dirs)).toBe(true);
+    expect(isUnderGeneratedDir("target/manifest.json", dirs)).toBe(true);
+    expect(isUnderGeneratedDir("build/target/run_results.json", dirs)).toBe(true);
+  });
+
+  test("does not match a sibling sharing the prefix", () => {
+    expect(isUnderGeneratedDir("targetx/a.sql", dirs)).toBe(false);
+    expect(isUnderGeneratedDir("models/target_helper.sql", dirs)).toBe(false);
+    expect(isUnderGeneratedDir("build/targeted/a.sql", dirs)).toBe(false);
+  });
+});
+
+// A Windows path spells the folder `__dbt\\`. A lookup that searched the raw
+// path for `__dbt/` would find nothing, so a module-only edit would return
+// without deploying its parent while the file was still recorded as synced.
+describe("dbt module paths on either separator", () => {
+  test("isDbtModulePath and getScriptBasePathFromModulePath accept backslashes", () => {
+    expect(isDbtModulePath("f\\x\\proj__dbt\\models\\a.sql")).toBe(true);
+    expect(getScriptBasePathFromModulePath("f\\x\\proj__dbt\\models\\a.sql")).toBe(
+      "f/x/proj",
+    );
+    expect(getScriptBasePathFromModulePath("f/x/proj__dbt/models/a.sql")).toBe(
+      "f/x/proj",
+    );
+  });
+
+  test("a path with no module folder has no base path", () => {
+    expect(getScriptBasePathFromModulePath("f/x/proj.dbt.yaml")).toBeUndefined();
+  });
+});
+
+// The push, the staleness hash and the sync diff all ask this question. They
+// must agree: a file one drops and another keeps is a change no push resolves.
+describe("isBundledModuleFile", () => {
+  const fs = require("node:fs");
+  const os = require("node:os");
+  const nodePath = require("node:path");
+  let dir: string;
+
+  beforeEach(() => {
+    dir = fs.mkdtempSync(nodePath.join(os.tmpdir(), "bundled-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  const write = (name: string, data: Buffer | string) => {
+    const p = nodePath.join(dir, name);
+    fs.writeFileSync(p, data);
+    return p;
+  };
+
+  test("keeps text, including empty and unicode", () => {
+    expect(isBundledModuleFile(write("a.sql", "select 1\n"))).toBe(true);
+    expect(isBundledModuleFile(write("empty.sql", ""))).toBe(true);
+    expect(isBundledModuleFile(write("u.sql", "select 'café'\n"))).toBe(true);
+  });
+
+  test("drops a binary file, which a NUL identifies", () => {
+    expect(isBundledModuleFile(write("x.png", Buffer.from([0x89, 0x50, 0x00, 0x1a])))).toBe(
+      false,
+    );
+  });
+
+  test("drops a file over the per-file limit", () => {
+    expect(isBundledModuleFile(write("huge.csv", "x".repeat(MAX_MODULE_BYTES + 1)))).toBe(
+      false,
+    );
+  });
+
+  // The two reasons a file is not carried are not interchangeable: sync hides
+  // dbt's binary leftovers, but an oversized seed the project authored has to
+  // stay in the diff, or the push that reports the size error never runs and the
+  // remote project is left incomplete without saying so.
+  test("says WHY a file is not carried", () => {
+    expect(moduleFileExclusion(write("a.sql", "select 1\n"))).toBe(undefined);
+    expect(moduleFileExclusion(write("x.png", Buffer.from([0x89, 0x50, 0x00, 0x1a])))).toBe(
+      "binary",
+    );
+    expect(moduleFileExclusion(write("seed.csv", "x".repeat(MAX_MODULE_BYTES + 1)))).toBe(
+      "oversized",
+    );
+  });
+
+  // A pull asks this about files that do not exist locally yet. Answering "not
+  // carried" there made sync ignore the whole incoming project and write
+  // nothing — the bundle silently vanished on every fresh checkout.
+  test("treats a missing file as carried, not as excluded", () => {
+    expect(isBundledModuleFile(nodePath.join(dir, "does-not-exist.sql"))).toBe(true);
+  });
+});
+
+test("a nested __mod inside a dbt project does not steal the script boundary", () => {
+  // dbt owns its directory names verbatim, so a folder ending `__mod` is legal
+  // inside a project. The script is the OUTER module boundary.
+  expect(
+    getScriptBasePathFromModulePath("f/x/proj__dbt/models/legacy__mod/a.sql"),
+  ).toBe("f/x/proj");
+  expect(getScriptBasePathFromModulePath("f/x/proj__dbt/models/a.sql")).toBe(
+    "f/x/proj",
+  );
+  expect(getScriptBasePathFromModulePath("f/x/s__mod/inner.ts")).toBe("f/x/s");
+});
+
+test("a nested __mod inside a dbt project is not a module entry point", () => {
+  expect(isModuleEntryPoint("f/x/s__mod/script.ts")).toBe(true);
+  // `legacy__mod` is a legal dbt directory; its script.ts belongs to the dbt
+  // project, not to a module folder of its own.
+  expect(isModuleEntryPoint("f/x/proj__dbt/models/legacy__mod/script.ts")).toBe(
+    false,
+  );
+  expect(isModuleEntryPoint("f/x/proj__dbt/models/a.sql")).toBe(false);
+});
+
+test("a __dbt directory nested inside an ordinary module is not a dbt project file", () => {
+  expect(isDbtModulePath("f/x/proj__dbt/models/a.sql")).toBe(true);
+  // `vendor/x__dbt/` belongs to the `foo__mod` script, not to a dbt project.
+  expect(isDbtModulePath("f/x/foo__mod/vendor/x__dbt/a.ts")).toBe(false);
+  expect(isDbtModulePath("f/x/foo__mod/helper.ts")).toBe(false);
+});
+
+test("a __dbt/target nested in an ordinary module is not generated dbt output", () => {
+  expect(isDbtGeneratedPath("f/x/proj__dbt/target/manifest.json")).toBe(true);
+  // Belongs to the `foo__mod` script; excluding it would drop a real edit.
+  expect(isDbtGeneratedPath("f/x/foo__mod/vendor/x__dbt/target/a.ts")).toBe(false);
+});
diff --git a/cli/windmill-utils-internal/src/path-utils/path-assigner.ts b/cli/windmill-utils-internal/src/path-utils/path-assigner.ts
index 94d9085b94..6aaeea4db1 100644
--- a/cli/windmill-utils-internal/src/path-utils/path-assigner.ts
+++ b/cli/windmill-utils-internal/src/path-utils/path-assigner.ts
@@ -36,6 +36,7 @@ export const LANGUAGE_EXTENSIONS: Record<SupportedLanguage, string> = {
   bunnative: "ts",
   ruby: "rb",
   rlang: "r",
+  dbt: "dbt.yaml",
   // for related places search: ADD_NEW_LANG
 };
 
@@ -84,6 +85,7 @@ export const EXTENSION_TO_LANGUAGE: Record<string, SupportedLanguage> = {
   "playbook.yml": "ansible",
   "java": "java",
   "duckdb.sql": "duckdb",
+  "dbt.yaml": "dbt",
   "rb": "ruby",
   // Plain .ts defaults to bun (will be overridden by defaultTs setting)
   "ts": "bun",
diff --git a/docker/DockerfileFull b/docker/DockerfileFull
index 6e3f218fd6..b827208c1d 100644
--- a/docker/DockerfileFull
+++ b/docker/DockerfileFull
@@ -45,6 +45,19 @@ RUN apt-get install -y ruby ruby-bundler
 RUN apt-get install -y r-base-dev \
     && Rscript -e 'install.packages("renv", lib="/usr/lib/R/library", repos="https://cloud.r-project.org")'
 
+# dbt
+# NO dbt engine is baked in. Fusion may not be: its license grants only a
+# non-transferable, non-sublicensable redistribution right. dbt-core 1.x cannot
+# be, because its adapter is a Python package chosen per project. dbt-core 2.x
+# could be — one adapter-agnostic binary — but shipping a pre-release nobody is
+# defaulted onto costs a layer in every image and a version pinned in two places
+# that nothing keeps in step. The worker fetches whichever engine a project asks
+# for on first use and caches it (docs/dbt-runtime.md, decision 1).
+#
+# An operator who wants one pre-staged — an air-gapped instance, or a fleet that
+# should not fetch per worker — populates `DBT_BUNDLED_DIR` (default
+# /usr/local/dbt) with `core2x-<version>/dbt-sa-cli` in their own image layer.
+
 # Fix UV cache permissions for non-root user support (uid 1000, etc.)
 # The uv tool install ansible command populates the UV cache with root-owned files
 RUN chmod -R a+rw /tmp/windmill/cache/uv && \
diff --git a/docker/DockerfileFullEe b/docker/DockerfileFullEe
index 14bfceca50..5b5347558a 100644
--- a/docker/DockerfileFullEe
+++ b/docker/DockerfileFullEe
@@ -78,6 +78,19 @@ RUN apt-get install -y iptables
 # Kerberos runtime
 RUN apt-get install -y libsasl2-modules-gssapi-mit krb5-user
 
+# dbt
+# NO dbt engine is baked in. Fusion may not be: its license grants only a
+# non-transferable, non-sublicensable redistribution right. dbt-core 1.x cannot
+# be, because its adapter is a Python package chosen per project. dbt-core 2.x
+# could be — one adapter-agnostic binary — but shipping a pre-release nobody is
+# defaulted onto costs a layer in every image and a version pinned in two places
+# that nothing keeps in step. The worker fetches whichever engine a project asks
+# for on first use and caches it (docs/dbt-runtime.md, decision 1).
+#
+# An operator who wants one pre-staged — an air-gapped instance, or a fleet that
+# should not fetch per worker — populates `DBT_BUNDLED_DIR` (default
+# /usr/local/dbt) with `core2x-<version>/dbt-sa-cli` in their own image layer.
+
 # Fix UV cache permissions for non-root user support (uid 1000, etc.)
 # The uv tool install ansible command populates the UV cache with root-owned files
 RUN chmod -R a+rw /tmp/windmill/cache/uv && \
diff --git a/docs/agent-worker-e2e.md b/docs/agent-worker-e2e.md
new file mode 100644
index 0000000000..e1fd122b98
--- /dev/null
+++ b/docs/agent-worker-e2e.md
@@ -0,0 +1,131 @@
+# Running an agent worker locally, for e2e
+
+An agent worker reaches the database only through the API, so whole code paths
+(`Connection::Http`) are never taken by a normal `cargo run`. Exercising them
+needs a real one. Every step below has a failure mode that looks like something
+else; they are listed with the error each produces.
+
+## 1. Build with the right features
+
+Four features, and the agent's own mode gate is the one that is easy to miss:
+
+```bash
+cd backend
+cargo build --features quickjs,private,enterprise,license,agent_worker_server
+```
+
+- `agent_worker_server` mounts `/api/agent_workers/*` on the SERVER. Without it,
+  `create_agent_token` returns **404** with an empty body.
+- `enterprise` + `license` compile the agent MODE into the binary. Without them
+  the worker exits immediately with `Agent mode is only available in the EE`,
+  even though the server side works and mints tokens happily.
+
+Verify before spending time on the handshake — the panic string must be absent:
+
+```bash
+strings target/debug/windmill | grep -c "Agent mode is only available in the EE"   # want 0
+```
+
+**Pin this feature set for the whole session.** `target/debug/windmill` is one
+path shared by every feature combination, and cargo swaps the cached artifact in
+and out as the set changes — a `cargo build --features quickjs` (or any build
+with a different set) in another pane silently replaces the binary the server and
+agent are about to run, and the swap back "completes" in under a second, so it
+does not look like a rebuild happened. The symptom is the agent 401ing again
+after it had been working, or the EE panic reappearing. Re-run the `strings`
+check above whenever anything unexpected regresses, and start the server and the
+agent from the SAME build.
+
+## 2. Run the server without a local worker
+
+`MODE=server` so nothing else drains the queue and the agent is provably the one
+that ran the job:
+
+```bash
+DATABASE_URL=<this worktree's db> PORT=8420 MODE=server ./target/debug/windmill
+```
+
+## 3. Mint a token — with an expiry, and unquoted
+
+```bash
+TOK=$(curl -s -X POST localhost:8420/api/auth/login -H 'Content-Type: application/json' \
+  -d '{"email":"admin@windmill.dev","password":"changeme"}')
+
+AT=$(curl -s -X POST localhost:8420/api/agent_workers/create_agent_token \
+  -H "Authorization: Bearer $TOK" -H 'Content-Type: application/json' \
+  -d '{"worker_group":"agentgrp","tags":["dbt"],"exp":1900000000}' | tr -d '"')
+```
+
+Two traps, both of which surface as a bare `401` on the agent and a decoded
+reason only in the SERVER log:
+
+- **`exp` must be a real timestamp.** `"exp": null` mints a token the validator
+  rejects with `Missing required claim: exp`.
+- **The response is JSON, so it arrives quoted.** Keeping the `"` gives
+  `Base64 error: Invalid byte 34, offset 0` — hence the `tr -d '"'`.
+
+Pass the token **exactly as minted**. It looks like `jwt_agent_<jwt>` and the
+client appends its own hostname-derived suffix to form `jwt_agent_<suffix>_<jwt>`,
+which is what the server splits on. Adding a suffix yourself yields
+`Base64 error: Encoded text cannot have a 6-bit remainder`.
+
+## 4. Start the agent
+
+`WORKER_TAGS` must contain the tag the JOBS carry, not a tag you invent — a job
+whose tag nothing serves sits in `v2_job_queue` forever and looks like a hang.
+dbt scripts default to the `dbt` tag.
+
+```bash
+AGENT_TOKEN="$AT" BASE_INTERNAL_URL=http://localhost:8420 MODE=agent \
+  WINDMILL_DIR=/home/$USER/wmagent \
+  WORKER_GROUP=agentgrp WORKER_TAGS=dbt PORT=8499 ./target/debug/windmill
+```
+
+`WINDMILL_DIR` off `/tmp` matters on a dev box. Jobs fail with `IoErr: Disk quota
+exceeded (os error 122)` while writing the project's files, and `df` looks
+healthy — free space and free inodes both. `/tmp` is a tmpfs and Linux supports
+per-user quotas on it, so the limit is the user's, not the filesystem's; several
+agent sessions' caches under `/tmp` are enough to reach it. Point the worker at a
+real disk instead of trying to clean up under the quota.
+
+Confirm it registered rather than trusting a quiet log:
+
+```sql
+SELECT worker FROM worker_ping
+ WHERE worker_group = 'agentgrp' AND ping_at > now() - interval '2 min';
+-- ag-agentgrp-<host>-<rand>
+```
+
+## Reading failures
+
+The agent only ever prints `Agent worker cannot connect to server. Please check
+AGENT_TOKEN and BASE_INTERNAL_URL`. The actual reason is in the server log, from
+`windmill-api-agent-workers/src/ee.rs` — grep it for `JWT_AGENT auth error`.
+
+## Confirming the agent is what ran the job
+
+`worker` on the completed job starts with `ag-`:
+
+```bash
+curl -s -H "Authorization: Bearer $TOK" \
+  "localhost:8420/api/w/<ws>/jobs_u/completed/get/<job>" | jq -r .worker
+```
+
+## What dbt does on an agent worker
+
+Runs, retries, and publishes its graph — including a per-run snapshot for a
+dynamic descriptor, which it POSTs to `/api/agent_workers/dbt_graph/{workspace}`
+rather than writing itself.
+
+What it does not get is LIVE progress: the reporter tails a JSON event log and
+needs a SQL connection, so per-model state is settled from `run_results.json`
+when the run ends. Retry state lives only in the worker-local generation, since
+there is no database row to arbitrate against — which is why `state_dir` is keyed
+by principal.
+
+Confirming a run really exercised that path:
+
+```sql
+SELECT job_id, count(*) FROM dbt_node WHERE script_path = '<path>' GROUP BY job_id;
+-- a row keyed to the JOB id (not the zero UUID) means the agent published a snapshot
+```
diff --git a/docs/dbt-runtime.md b/docs/dbt-runtime.md
new file mode 100644
index 0000000000..ed389acd71
--- /dev/null
+++ b/docs/dbt-runtime.md
@@ -0,0 +1,1083 @@
+# Windmill as a dbt runtime
+
+Implementation spec for running an existing dbt project on Windmill with no
+changes to the project itself. Companion to [`pipelines-vs-dbt.md`](./pipelines-vs-dbt.md),
+which covers the opposite direction (native pipeline features that replace dbt).
+The two are complementary: this is the adoption ramp, that is the long game.
+
+Benchmark to beat is Airflow + [astronomer-cosmos](https://astronomer.github.io/astronomer-cosmos/),
+the dominant way dbt is orchestrated today.
+
+## Scope
+
+- **In**: run an unmodified dbt project synced into Windmill, one Windmill job per
+  invocation, live per-model observability, dbt models as first-class assets in
+  the existing asset graph.
+- **Out**: one Windmill job per dbt model, `state:modified` / slim CI,
+  `dbt docs` hosting, semantic layer, dbt platform integration.
+- **CE**: the runtime, the manifest ingest, the asset graph and every piece of
+  UI ship in CE, as do all adapters except two. Only the `mssql` and `oracle`
+  adapters are EE, mirroring the native `ScriptLang` boundary (decision 21).
+
+## Decision log
+
+| # | Decision | Resolution |
+|---|---|---|
+| 1 | dbt engine | Three-way toggle (`dbt-core-1x` \| `dbt-core-2x` \| `fusion`); shipped default `dbt-core-1x`, instance-configurable. See below |
+| 2 | Artifact shape | `ScriptLang::Dbt` |
+| 3 | Graph in v0 | Yes, both runtime and graph |
+| 4 | Execution granularity | One job per invocation |
+| 5 | Project storage | The project is the script's module bundle; nothing is cloned. See "Where the dbt project lives" |
+| 6 | Multiple run configs | Per-run `select` on one script; N scripts means N projects |
+| 7 | Run-time `select` | Descriptor default plus run-arg override |
+| 8 | Credentials | Workspace warehouses, plus `profiles.yml` passthrough. A descriptor never names a resource. See below |
+| 9 | Adapter mappings | postgres, redshift, mysql, snowflake, bigquery, databricks; others via the project's own `profiles.yml` |
+| 10 | Private repo auth | Not applicable: the project is synced, not fetched |
+| 11 | Asset kind | `dbt://<warehouse>/<schema>/<name>` — keyed on the relation, not on dbt's node id. See below |
+| 12 | Graph refresh | Deploy-time, re-ingested per run only when the descriptor is dynamic. See below |
+| 13 | Manifest storage | Sidecar table for nodes/edges. Full manifest **not** stored — see below |
+| 14 | Metadata depth | Tests, strategy, tags, freshness, column descriptions. Column **lineage** is not in the manifest — see below |
+| 15 | Node rendering | Asset nodes per model plus one runnable node for the script |
+| 16 | Progress | Live, from the JSON event stream |
+| 17 | Test failures | Honor dbt's own `severity` |
+| 18 | Retry | Automatic node-level retry in-job, plus `dbt retry` as a run argument. See below |
+| 19 | Caching | Worker-local global cache, keyed by the project digest and the resolution the deploy pinned |
+| 20 | Images | Full images only |
+| 21 | Licensing | CE except the `mssql` / `oracle` adapters. See below |
+| 22 | Naming | Match Cosmos field names; importer deferred |
+| 23 | Descriptor | `wm_dbt.yaml` inside the project, OPTIONAL. See below |
+| 24 | Warehouse | Configured on the workspace by name, `main` by default. See below |
+
+## Decision 1: engine toggle, and why the shipped default is not Fusion yet
+
+`engine: dbt-core-1x | dbt-core-2x | fusion` in the descriptor. Omitted, it is
+`dbt-core-1x`, which runs today's projects untouched.
+
+No engine is baked into any image. Each is fetched or built on first use and
+cached, for a different reason in each case.
+
+| Engine | Distribution | Cold start | License |
+|---|---|---|---|
+| `dbt-core-1x` (default) | A uv venv resolved per adapter on first use, then cached. **Cannot** be baked: the adapter is a Python package chosen per project | One venv build per (core range, adapter) | Apache 2.0 |
+| `dbt-core-2x` | One adapter-agnostic Rust binary, fetched from GitHub releases on first use, cached | One download | Apache 2.0 |
+| `fusion` | **Never bundled.** Fetched from dbt Labs on first use, cached | One download (~290MB) | dbt Fusion engine license agreement |
+
+2.x is the one that *could* be baked, and deliberately is not: it is a
+pre-release (`2.0.0-alpha.5`) that nothing is defaulted onto, so baking it costs
+a layer in every image and a version pinned in two places with nothing keeping
+them in step. An operator who wants an engine pre-staged — an air-gapped
+instance, or a fleet that should not fetch per worker — populates
+`DBT_BUNDLED_DIR` (default `/usr/local/dbt`) with `core2x-<version>/dbt-sa-cli`
+in a derived image; the worker prefers it over its own cache.
+
+Two things to know before choosing 2.x: it is a pre-release, and it does not
+emit the per-node events the run page animates (see "Live per-model progress"),
+so a run on it reports its models only at the end.
+
+The 1.x venv resolves `dbt-core>=1.8,<2.0.0` *together with* the adapter rather
+than pinning a core version, because several adapters cap below the newest core
+(dbt-oracle and dbt-databricks below 1.12) and an independent pin makes those
+projects unprovisionable. The lockfile records whichever version the resolver
+actually chose. Both bounds and each engine version are env-overridable
+(`DBT_CORE_1X_FLOOR`, `DBT_CORE_1X_CEILING`, `DBT_CORE_2X_VERSION`).
+
+Fusion is the fastest option and the toggle exists so users can choose it. Two
+things block making it the *shipped* default, both verifiable rather than matters
+of taste:
+
+1. **Redistribution terms.** The Fusion license grants only a "limited,
+   non-exclusive, non-transferable, non-sublicensable" redistribution right, and
+   4.1 forbids introducing "obstacles or delays that have the effect of hampering
+   or interfering with (a) communication between Provider and End User, (b)
+   User's ability to view, access, or use the Product and/or any Account
+   Features." A sandboxed non-interactive job runner sits squarely in that
+   clause's path, and "may not share, pool, or relay its own login credentials to
+   any End User" reads directly onto putting one dbt platform token in a
+   workspace secret. That needs counsel, not an engineering judgment.
+   **Fetch-at-runtime is the mitigation**: the user's own instance pulls the
+   binary from dbt Labs directly, so Windmill never redistributes and never
+   interposes. Do not bake Fusion into any image.
+2. **Fusion is v2 semantics, and v2 drops all deprecated functionality.** Every
+   deprecation warning, including historic ones and those added in 1.10, must be
+   resolved before a project runs on it. An arbitrary existing dbt 1.x project
+   therefore may not run unchanged, which is this feature's entire premise. dbt
+   ships an autofix tool and Fusion/Core interoperate side by side, so it is a
+   migration users can do, but not one Windmill should silently require of them.
+
+Consequence: ship with `dbt-core-1x`, which runs today's projects untouched, and
+flip the instance default to `fusion` once counsel clears the runtime-fetch model
+and a real project is verified end to end on it. Both dbt-core engines are
+exercised by the e2e suite, so the flip is a config change, not a port.
+
+## Decision 21: mirror the native warehouse boundary, do not invent one
+
+Everything structural is CE: the executor, all three engines, the manifest
+ingest, the `dbt://` asset graph, live progress, the editor. The only gate is
+on two adapters, and it is not a dbt-specific policy — it is the same boundary
+the native script languages already draw. Since `bigquery` and `snowflake`
+became CE, the only warehouse `ScriptLang`s still behind a license are `mssql`
+and `oracledb`, so those two dbt adapters are EE and every other one (postgres,
+mysql, duckdb, snowflake, bigquery, databricks, redshift, clickhouse,
+salesforce) is CE. Gating any of the others would make reaching a warehouse
+through dbt stricter than reaching it natively, which is backwards.
+
+Those two are *recognized* (for the gate and for the pip package the 1.x
+engine's venv needs), not rendered from a resource: an `oracledb` resource is
+`{user, password, database}` with no host/protocol/service, and dbt-sqlserver
+needs an ODBC `driver` the images do not install. Both reach their warehouse
+through the project's own `profiles.yml`, which is also how duckdb, clickhouse
+and salesforce work.
+
+The gate almost never fires in practice: `dbt-core-2x` supports neither adapter,
+so it can only apply to `dbt-core-1x` with one of those two.
+
+**The mechanism differs from the native languages.** They gate at compile time,
+so a CE binary simply lacks the executor. That is not available here: there is
+one dbt executor and the adapter is only known once the profile resolves. So it
+is a runtime check on the resolved adapter, at both deploy and run, and it must
+say what is wrong — a silent degradation that surfaces later as a connection
+error is worse than no gate at all.
+
+One trap: `ee_oss::LICENSE_KEY_VALID` is initialized to `true` in the OSS
+variant, so reading it alone passes on a CE build. The check is
+`cfg!(feature = "enterprise") && LICENSE_KEY_VALID`, which rejects both a CE
+build and an enterprise build whose key did not verify.
+
+## Decision 11: `dbt://`, keyed on the relation and not on the dbt node
+
+`dbt://<warehouse>/<schema>/<name>`, one `AssetKind`, where `<warehouse>` is the
+workspace warehouse's NAME, so two scripts running against the same warehouse
+agree on identity.
+
+The SCHEME names the producer, because dbt is the only thing that creates one of
+these: no other language derives warehouse relations, `// materialize` takes
+DuckLake targets only, and a dbt run does not dispatch. Calling the kind
+something generic promised a parity with native Snowflake and BigQuery scripts
+that does not exist.
+
+The PATH is the physical relation, and that is the load-bearing half. dbt-core
+has no cross-project `ref()`: two projects meet when one materializes a mart and
+the next declares it a `source`. Their dbt identities differ there —
+`model.a_pkg.orders` against `source.b_pkg.analytics.orders` — while the relation
+does not, so keying on `unique_id` would make every project an island and turn
+the handoff into two unconnected nodes. `unique_id` also embeds the package name
+from `dbt_project.yml`, which two unrelated projects may both call `analytics`,
+collapsing two different tables onto one node. The relation cannot collide that
+way. It is also what a DuckDB, Python, TS or Ansible script can name in a
+`// on dbt://…` annotation to join the lineage — those four are the languages
+with a body-asset parser; the native SQL ones cannot declare assets at all.
+
+A dbt run does **not** trigger those readers. See "no cascade from dbt" below.
+
+An ephemeral model (an inlined CTE, never written), an exposure, or a source that
+is not separately modelled has no physical relation and therefore no place in
+this namespace. If those ever prove worth rendering they need a key of their own
+— `unique_id` suits them, precisely because nothing else can refer to them.
+
+Two traps, both of which quietly defeat the point if handled wrong.
+
+**Identifier canonicalization.** `manifest.json` gives `relation_name`
+pre-quoted (`"windmill"."Analytics"."Orders"`), an annotation is written by hand,
+and the warehouses disagree on case: Snowflake folds unquoted identifiers up,
+Postgres folds them down, DuckDB compares case-insensitively. Two spellings of
+one table produce two nodes, no edge, and nothing looks broken in isolation. So
+one rule is applied in exactly one place — `parse_asset_syntax`, the single
+point where an asset URI becomes a graph key: strip the quote characters
+(`"`, backtick, `[`/`]`) from the schema and name, then ASCII-lowercase them,
+matching the case-insensitive identifier comparison the DuckDB paths already
+use. The warehouse-name prefix is spelled as the workspace configures it and
+stays case-sensitive.
+
+**Warehouse identity is the workspace warehouse's name**, exactly as
+`ducklake://main.orders` keys on the workspace lake's name — never the host,
+account or database. A descriptor cannot name a resource at all (Decision 24), so
+there is exactly one spelling per warehouse and the ambiguity a per-project
+resource would create does not arise. The warehouse names the default database
+too, so it stays out of the key; a model that *overrides*
+its database (Snowflake `database`, BigQuery `project`) is genuinely elsewhere and
+qualifies its schema segment as `<database>.<schema>`, so two same-named relations
+in different databases cannot collapse onto one node. A project that brings its own
+`profiles.yml` reports its target's database from that file, read with the same
+keys the renderer writes, so it spells a relation exactly as a workspace-warehouse
+project does and the two meet on one node. Only where the target leaves its
+database implicit does every relation qualify, because assuming they share one
+database is exactly what would collapse them.
+
+Three call sites derive this key: the manifest ingest that creates the node, and
+the live-progress and end-of-run paths that record status against it. They share
+one function, because a site that derives it differently records progress against
+a path no node has — the run still succeeds and the graph simply never moves. The same
+warehouse is reachable under several hostnames, and credential material has no
+business in an asset key. Accepted limitation, worth knowing before it is
+filed as a bug: **two workspace warehouses pointing at the same physical
+warehouse do not unify**, so assets under one will not share edges with assets
+under the other. Point both projects at one warehouse to link them.
+
+## Decision 24: the warehouse is a workspace setting, named, and the only one
+
+A descriptor names a warehouse by NAME (`profile.warehouse`, `main` when it names
+none) and cannot name a resource. Admins configure the warehouses under Settings
+→ dbt, where each entry points at a resource, exactly as `large_file_storage`
+points at the object-storage resource and a DuckLake names its catalog.
+
+Three things follow, and they are the reason for the rule rather than
+consequences to work around.
+
+**A dbt project carries no connection.** The same project runs locally against a
+developer's own `~/.dbt/profiles.yml` and on Windmill against the workspace
+warehouse, with no Windmill-specific file in between and nothing to strip before
+committing it to a repository. This is what makes Decision 23 possible at all: if
+a project had to name its own resource, the descriptor could never be optional.
+
+**Asset identity has exactly one spelling.** Keying on a name is only sound
+because a name is all there is. Had both `profile.resource` and
+`profile.warehouse` existed, one physical warehouse would be reachable under two
+spellings and two projects on it would silently fail to share nodes — the exact
+failure Decision 11 exists to prevent.
+
+**dbt is unpermissioned, and the blast radius is bounded by construction
+instead.** The warehouse resource is read with NO permission check on the runner,
+exactly as `s3://` reaches the workspace bucket without the caller being granted
+the storage resource: configuring a warehouse is what makes it available, and
+anyone who may run a dbt script may build with it and read its models. What is
+reachable stays bounded because only an admin writes the setting and a descriptor
+cannot name a resource, only one of the names an admin configured.
+
+Per-relation rules were considered and rejected. `s3://` can enforce a path glob
+because Windmill mediates every object operation through its proxy; dbt has no
+such chokepoint — Windmill renders `profiles.yml` and dbt opens its own
+connection. A rule could only be a pre-run check against the manifest, and a
+`pre-hook`, a macro or `dbt run-operation` issues arbitrary SQL on the same
+connection, so it would stop the ordinary case while implying a guarantee it
+cannot keep.
+
+A project that brings its own `profiles.yml` still connects with it, and then
+names a warehouse only to say where its assets belong. The name must still match
+a configured warehouse — a typo is not identity, it strands the project's models
+on a node nothing else reaches — but it grants nothing, since nothing here is
+granted. It gets no identity by default, because defaulting to `main` would key a
+self-hosted profile's tables onto a workspace warehouse it never connected to.
+
+That label is worth having only because such a project spells its relations the
+same way: Windmill reads the target's database out of the project's own file
+(Decision 11), so a mart it builds and a workspace-warehouse project's `source`
+on the same relation land on ONE node. Without that the label would name a
+namespace and still share nothing, which is the failure it exists to prevent.
+
+An agent worker cannot read the database, so it resolves the name through a
+job-scoped API route. That route returns the resolved connection, which is why it
+requires a job token: a running job already holds those credentials in its
+rendered `profiles.yml`, and a browsable route would hand them to anyone. The
+same worker posts its per-model outcomes to a second job-scoped route, since the
+live reporter tails a log straight into the database and cannot run there. An
+agent's run page therefore fills in when the run ends rather than during it.
+Both routes are posted with the JOB's token: an agent's own credential
+authenticates only against the agent surface.
+
+## Decision 23: the descriptor is optional, and lives inside the project
+
+`<script>__dbt/wm_dbt.yaml`. An unmodified dbt project — one `cp -r` away from a
+developer's working copy, or a repository cloned as-is — is already a complete
+Windmill script: it runs the whole project against the workspace's default
+warehouse. The descriptor appears only when the project wants something
+Windmill-specific: run arguments, a named warehouse, an engine pin, a test
+policy.
+
+It lives INSIDE the project rather than beside it so that an author writes
+nothing outside the directory dbt itself reads. A dbt developer's working copy
+and a Windmill bundle are then the same directory, which is the whole bargain of
+Decision 5.
+
+Absent means an empty descriptor, never a missing script. `dbt_project.yml` is
+what identifies a project — the descriptor cannot, being optional — and three
+rules keep "absent" from reading as a change: the export omits an empty
+descriptor, the sync map gives BOTH sides the empty descriptor an absence means
+(so neither reads as an addition), and a pull deletes rather than writes one.
+Without all three a descriptor-less project either diffs forever or grows the
+very file this decision exists to avoid.
+
+## Decision 12: the graph refreshes with the deploy
+
+The project's files are the script's, so a deploy already sees exactly what will
+run: it parses the bundle and stores the graph. "Refresh" is just "redeploy". No
+manual button, no webhook, no separate mechanism.
+
+The one case that cannot be settled at deploy is a descriptor that is dynamic by
+construction: a `vars` value spelled with a `{{ placeholder }}`, or an `env`
+value spelled `$var:` (re-resolved every run). dbt vars can steer `enabled`,
+aliases, schemas, databases and materializations, so for those the deploy cannot
+know what will run and the graph is re-ingested from every run's own manifest,
+under that run's job id. A run that cannot refresh those rows fails rather than
+showing a stale graph. What the SCRIPT owns stays the deploy's — see "Which
+run's graph becomes what the script owns" for why the two cannot diverge.
+
+An agent worker reaches the database only through the API, so it POSTs the graph
+it parsed to `/api/agent_workers/dbt_graph/{workspace}` instead of writing it —
+which is why it needs no way to READ the stored relation root: it re-ingests
+every run, so its own run page shows the profile it actually used. What it
+publishes is that per-run snapshot alone — the path-keyed ownership rows are
+written by the deploy and by database-connected workers. Dynamic descriptors and
+Windmill-resolved profiles therefore both run there. What an agent does not get is LIVE progress —
+that is a per-model event stream, and a round trip per node is the wrong trade —
+so its per-model state is settled from `run_results.json` when the run ends, and
+its retry state lives only in the worker-local generation. See
+[agent-worker-e2e.md](./agent-worker-e2e.md).
+
+The refresh happens **before** the build, from a `dbt parse` with this run's own
+vars and env, so a run in flight is already showing the models it is building.
+
+A dynamic descriptor's graph is a property of the RUN, not of the deployed
+version, so it is stored per job — see "The graph belongs to a script version"
+below. Two concurrent runs of one such script therefore keep their own, and each
+run page shows the models that run built.
+
+Re-ingesting is nearly free: the run parses the project (about a second) before
+building it and ingests that manifest.
+
+The parse is what makes a newly added model appear in the same run that builds
+it, rather than one run late: the graph is written before the build, so the run
+page shows the model while it is being built.
+
+## What a share-link viewer sees
+
+A share link is not anonymous access: the token is HMAC'd with the workspace key
+and scoped to one job and its descendants. It is an extra grant for a **logged-in
+user who lacks access to that job** — which is normally why someone was sent a
+link.
+
+Both halves of a dbt run page go through one gate: `/jobs/run_progress/{id}` and
+`/jobs/dbt_graph/{id}`, each behind `require_job_read_access`, which validates
+the token. The graph then has a second, independent filter — RLS on the `script`
+row — and a viewer sent a link usually has no grant there. Deciding the graph's
+SHAPE under that filter is wrong: it would answer for the caller's access to the
+project rather than for the run they were given, and the Models panel would come
+back blank beneath working progress rows.
+
+So a pinned run resolves its version from the JOB ROW, not from `script`: the
+`live` CTE takes the path and hash the handler read after authorizing the job.
+Two things make that safe rather than a widening:
+
+- **It leaks nothing new.** `v2_job_completed.result` already carries every
+  node's `unique_id` and `relation_name`, and this viewer can read it — the
+  model set and its relations are already visible to them.
+- **`raw_code` is gated separately**, on an `EXISTS` against `script` in the
+  authed transaction. The body of a model is the project's source code and stays
+  behind access to the project, whatever the shape query resolved.
+
+The path and hash coming from the job row rather than the query also means a
+caller cannot pin one project's version while naming another's run.
+
+## What a dbt job returns, and which half of it is a contract
+
+The result is `{engine, engine_version, command, totals, nodes, invocation_args}`,
+and each node carries both `status` and `outcome`.
+
+`invocation_args` is the arguments the run used, as SUBMITTED — a `$var:` stays a
+reference, so no resolved value is published — and it is omitted when empty. It
+exists because a `dbt retry` restores the failed run's arguments inside the
+worker and never writes them back to the retry job, whose own args are just
+`{"command": {"label": "retry", "dbt_retry_job": "<id>"}}`: the row preview, which
+is a `dbt show` of the same project, has nowhere else to get them. On a retry it is therefore ANOTHER
+invocation's arguments, which is why a hidden run saves no state at all (see the
+retry section).
+
+`status` is dbt's own word, verbatim — `success`, `error`, `partial success`,
+`no-op`. It is what the log says and what dbt's docs describe, so it belongs in
+the result, but it is dbt's vocabulary and dbt may change it: 1.x and 2.x
+already differ on casing, and `no-op` arrived in a minor release.
+
+`outcome` is the same result in Windmill's terms — `passed`, `failed`, `warned`,
+`skipped`, `no_op`, `unknown` — and it is the half a downstream script should
+branch on. A dbt release that renames a status moves `status` and leaves
+`outcome` where it is. Publishing only dbt's word would have made every such
+release either a break for users or a lie in our mapping.
+
+## The graph belongs to a script version
+
+`dbt_node` / `dbt_edge` are keyed `(workspace_id, script_path, script_hash,
+job_id, unique_id)`. Each deployed version keeps its own graph, and a job records
+the version it ran (`v2_job.runnable_id`), so a run page asks for that one:
+`/assets/graph?dbt_script_hash=<hex>` renders the project as it was — its models,
+its SQL, its `ref()` lineage — instead of whatever is deployed today.
+
+`job_id` is the second half, and it exists for dynamic descriptors only. A
+`{{ }}` placeholder in `vars` can enable a different set of models per run, so
+those runs re-ingest; keyed by version alone, each re-ingest overwrote the last
+and reopening an older run showed the newer run's project, with any model only
+the older run built simply gone. A run of a dynamic descriptor therefore writes
+its own snapshot under its job id, and its page reads the graph through
+`GET /w/{w_id}/jobs/dbt_graph/{id}`, passing the version hash.
+
+A static descriptor writes nothing per run: its graph is the version's, under
+the zero-UUID `DEPLOYED_GRAPH` sentinel, and every run of it reads that. The
+sentinel is a value rather than NULL because `job_id` is in the primary key and
+Postgres does not treat two NULLs as one key, so a re-ingest would accumulate row
+sets instead of replacing one. The route falls back to it whenever the job has no
+snapshot, which is why a run page can use it unconditionally rather than having
+to know whether its descriptor was dynamic.
+
+Pinning to a run is job-scoped, so it is a job route and not a parameter on
+`/assets/graph`: it needs the whole job-read contract, which is
+`require_job_read_access`. That helper lives in `windmill-api`, which depends on
+`windmill-api-assets`, so the read moved to the check rather than the check to
+the read. The route charges `assets:read` on top of the `jobs:read` its URL
+implies, since the body it returns is asset data.
+
+A snapshot is only written when it DIFFERS from the version's graph, compared by
+a digest of the nodes, edges and relation root. Marking a descriptor dynamic is
+conservative — a `{{ }}` in `vars` says the arguments reach dbt, not that they
+change which models exist — so the usual dynamic run (a date var) resolves to
+exactly the graph the deploy stored, and storing that per run would duplicate an
+unchanging picture. Those runs write nothing and read the version's graph
+through the fallback; only a run whose model set really differs pays.
+
+### Which run's graph becomes what the script owns
+
+Re-ingesting has several causes and they do not want the same thing, so the
+reason is carried rather than a bool (`GraphRefresh`):
+
+| Cause | Graph written | Path-keyed `asset` ownership |
+|---|---|---|
+| Descriptor is dynamic (`{{ }}` in `vars`, `$var:` in `env`) | under the job id | untouched |
+| The run overrode `vars` | under the job id | untouched |
+| The run narrowed `select`/`exclude` | nothing, unless another cause already made it ingest — then under the job id | untouched |
+| The profile moved since the last publish | the **version's** graph | republished |
+
+Ownership follows the version's graph exactly, which is what the first three
+rows have in common: the workspace graph takes an asset's relations from the
+`asset` rows and its models, SQL, tests and `ref()` lineage from that version's
+`dbt_node`/`dbt_edge`, so publishing relations the version's graph does not name
+leaves those assets with no model behind them — a placeholder that moves an
+alias would empty the current graph of everything dbt contributes to it. A run
+storing a snapshot of its own therefore publishes nothing, and an override's
+schemas and aliases do not stand as the script's until the next deploy, which is
+what a snapshot is for.
+
+The consequence for a dynamic descriptor is that its ownership stays the
+deploy's, and a profile that moves under one is settled by a redeploy rather than
+by a run: every run of it already shows its own models and re-parses regardless,
+so the drift it keeps re-detecting costs it nothing it was not already paying.
+
+The last row is the one that has to publish. The drift check compares the
+resolved root against `relation_root_at_last_ingest`, so a run that saw a move and
+did not republish leaves the next run seeing the same move — forever, with the
+asset rows still naming the old schema and every run paying a `dbt parse` for a
+snapshot nobody reads. It rewrites the VERSION's graph rather than a per-run
+snapshot for the same reason: once the root is republished no later run detects
+the move, so a snapshot would leave those runs reading the pre-move rows.
+
+A snapshot wins where they meet: a drifted run that also overrode its arguments,
+or whose descriptor is dynamic, snapshots under its job id and publishes
+nothing, and the drift is settled by an ordinary run of a static descriptor or
+by a redeploy — a wasted parse per overriding run, where the alternative is one
+caller's subset standing as the script's own, or replacing the version's graph
+with a picture missing every model that run did not select.
+
+Both halves have a retention story, and they differ because their readers do. A
+run's snapshot expires on a clock — 30 days — because the run page that reads it
+is transient. A VERSION's graph cannot: its reader is every finished run of that
+version, and a run page is as old as its job. So version graphs are bounded by
+deploy COUNT instead — the newest 50 per path keep theirs — which makes growth
+`versions x models` rather than unbounded in time. Without it a CI deploying on
+every commit adds a full model set per commit and nothing ever reclaims it. The
+bound is generous on purpose: reaching it empties that version's run pages, so
+it exists to stop unbounded growth rather than to be hit in normal use.
+
+Both are pruned by every dbt run, so no background sweep has to know about the
+tables. The prune is
+deliberately not hung off the progress reporter, which exists only for engines
+that emit node events: retention that stops working because an instance chose
+Fusion is not retention. A version's own graph lives as long as the version.
+
+Per DEPLOY, not per run: ten thousand runs of one version share one graph. The
+rows carry a composite foreign key to `script (workspace_id, hash)` with
+`ON DELETE CASCADE`, so a version's graph dies with the version and nothing has
+to sweep it.
+
+Two consequences worth knowing:
+
+* **Concurrent deploys no longer race for the graph.** Two versions write
+  disjoint rows, so neither can lose. `claim_graph_publication` survives only for
+  what is still keyed by PATH — the `asset` usage rows, of which there is one set
+  per script — and an older deploy finishing late now records its own graph
+  before declining to touch those.
+* **A pinned request is scoped differently.** Unpinned, the endpoint scopes by
+  the relations in view, using `asset`. Pinned, `asset` is the wrong scope: it
+  describes the current deploy, so a model that version had and a later one
+  dropped would be filtered out of its own run's graph. The pinned version's
+  nodes are the scope instead.
+
+## No cascade from dbt, and no pipeline membership
+
+A finished dbt run does not trigger anything. Its models are recorded, drawn and
+tracked; they do not fan out.
+
+A dbt script is also not a pipeline member (`in_pipeline` is forced false for
+`ScriptLang::Dbt` at deploy). It materializes warehouse tables, so it looks like
+one, but that membership carries an editor whose premise is that you author the
+transforms in it — and a dbt project is authored in a local `dbt run` / `dbt
+test` loop, with Windmill as the runner and the viewer. Enrolling it put a dbt
+project inside the pipeline editor and blurred which of the two a folder holds.
+Its models are `dbt://` assets in the shared graph regardless: that is what
+puts a native script reading one of them on the same node, and it is independent
+of pipeline membership.
+
+dbt already orders its own DAG, so a cascade would only ever add one thing:
+waking a Windmill script that reads a mart. That edge is real but narrow, and
+only half of it exists — nothing outside dbt can declare a `dbt://` write
+(`// materialize` accepts DuckLake targets only), so the reverse direction, an
+ingestion script waking a dbt project, cannot be expressed at all.
+
+Against that, dispatching correctly from dbt is not cheap. A run's `select` can
+build any subset of the project, so the deploy-time write set is not what ran;
+using it wakes consumers of relations the run never touched, and narrowing it
+needs a per-job record of what was built, which the per-relation state table
+cannot supply (it keeps one row per relation, stamped with the last writer).
+
+So dbt materializes and reports, and `asset_dispatch` returns early for
+`ScriptLang::Dbt`. A `# on dbt://<mart>` subscription is refused outright at
+deploy rather than accepted and left dormant — an edge drawn on the canvas that
+can never fire is worse than an error saying so.
+
+A plain READ still renders the consumer beside the model, which is what makes
+the lineage one graph — but it is written in the script's own code, not in a
+comment: the body parsers resolve an asset URI from a string literal
+(`parse_asset_syntax`), so `"dbt://<resource>/<schema>/<name>"` appearing in a
+Python, TS/Bun/Deno, DuckDB or Ansible script is the read. Those four are the
+languages with a body-asset parser; the native warehouse ones (snowflake,
+bigquery, postgresql, mysql, mssql) declare no assets at all today, so a mart
+they consume joins the graph only once that inference exists. Wiring the trigger up later means deciding what a
+selective run should notify — that decision is the work, not the plumbing.
+
+## Live per-model progress, and why only dbt-core 1.x has it
+
+`DbtEngine::emits_node_events()` is true for `dbt-core-1x` alone, so only 1.x
+moves nodes on the run-page graph while it builds. The other two engines settle
+every relation at the end instead.
+
+That is a statement about **where** the engines put their events, not about
+whether they produce them. Both Rust engines emit exactly the structured node
+events the tailer parses:
+
+```
+$ dbt-sa-cli build --log-format json   # and likewise the fusion binary
+{"info":{"name":"NodeStart"},"data":{"node_info":{
+  "node_status":"started","unique_id":"model.probe.m3",
+  "node_relation":{"relation_name":"windmill_dbt_runtime.probe_sch.m3", ...}}}}
+```
+
+Measured on 2.0.0-alpha.5 and fusion 2.0.0-preview.202, a three-model project:
+15 node events each on the console, 0 in the file log. `--log-format-file json`
+is accepted by both — `json` is a listed value — and ignored: the file is text
+either way.
+
+The events are therefore only on stdout, which is the human-readable job log.
+Taking them would mean setting `--log-format json` and rendering the log
+ourselves from each event's `info.msg`, so the run's log stays readable. That
+buys live progress on two pre-release engines at the price of permanently owning
+log presentation, to work around something upstream has already declared it
+intends to support. Not worth it: when either engine honours
+`--log-format-file json`, flipping `emits_node_events()` is the whole change,
+and the existing tailer starts working untouched.
+
+A finished run is unaffected on every engine — it is coloured from the run's own
+result, not from these events (decision 11's note on `run_progress`).
+
+## Where the dbt project lives
+
+**In Windmill.** One dbt project is one Windmill script: the script's content is
+the descriptor, and the project's files ride with it as its module bundle, a
+path-keyed map the worker materialises into the job directory before invoking
+dbt. There is one way to do this. Nothing is cloned, so there is no repository
+resource, no ref, no commit and no clone cache.
+
+A team whose repository must stay canonical keeps it: git-sync points at that
+repository and pushes it into the workspace, so the repository still holds the
+truth and Windmill receives the project. A team with no repository at all pushes
+straight from a working copy.
+
+### On disk, the project is a canonical dbt project
+
+`wmill sync pull` writes the bundle verbatim, so the tree under the module folder
+is exactly what dbt expects, with the extensions dbt expects:
+
+```
+f/analytics/
+└── analytics__dbt/                 the module bundle: the project, unmodified
+    ├── wm_dbt.yaml                 the descriptor (the script's content) — OPTIONAL
+    ├── dbt_project.yml
+    ├── packages.yml
+    ├── models/staging/stg_orders.sql
+    ├── models/marts/_marts__models.yml
+    ├── macros/cents_to_dollars.sql
+    ├── seeds/country_codes.csv
+    └── snapshots/orders_snapshot.sql
+```
+
+Import is therefore a copy, never a transformation:
+
+```
+cp -r my-dbt-project/. f/analytics/analytics__dbt/
+wmill sync push
+```
+
+The descriptor is optional, and nothing above it is authored: an unmodified dbt
+project is already a complete Windmill script, running the whole project against
+the workspace's default warehouse. `wm_dbt.yaml` appears only when the project
+needs something Windmill-specific — run arguments, a named warehouse, an engine
+pin — and it lives inside the project so that a dbt developer's working copy and
+a Windmill bundle are the same directory.
+
+Locally, dbt runs against the bundle with `--project-dir analytics__dbt` (or a
+`cd`), which is what a monorepo holding several dbt projects already does, and
+what dbt Cloud exposes as its "project subdirectory" setting.
+
+**Why a module bundle rather than one script per model.** Models as scripts was
+considered and rejected on three counts. A Windmill path admits no dots, and the
+CLI rejects bare `.sql` as ambiguous (`.pg.sql`, `.duckdb.sql`, … are the
+convention), so a model could only be typed by its location inside the project,
+which breaks the rule that extension determines language. dbt resolves `ref()`
+project-wide and cannot run a model alone, so each model job would reassemble
+and reparse the whole project anyway. And `schema.yml` describes many models at
+once, so splitting models into objects while their tests and docs stay in shared
+YAML puts a model's contract in a different object. The bundle keeps the project
+whole, and per-model execution is offered as an action on the graph node
+(`--select <model>+`) rather than as a separate object.
+
+What that costs, stated plainly: a model has no permissions or version history of
+its own. The unit of both is the project.
+
+### Consequences
+
+**The version is the script version.** Deploying the script deploys the project
+atomically; rollback is redeploying a previous version. The lockfile keeps the
+resolved engine and adapter versions and the manifest digest.
+
+**Windmill holds the files, so the graph can show them.** A model's compiled SQL
+is readable from its node in the asset graph. Editing stays local: dbt
+development is a CLI-and-editor loop (`dbt run --select`, `dbt test`, a local
+warehouse), and a browser textarea over one file of a project is a worse version
+of it. Windmill is the runner and the viewer.
+
+**Two scripts against one project means two copies.** Splitting a project across
+scripts, so an upstream selection and a downstream one compose, assumed a shared
+repository. With bundles they would duplicate the project and drift. Prefer one
+script per project with per-run `select`, and treat two scripts as two projects
+(decision 6).
+
+**Seeds are the only thing that can bloat a version.** Measured on real dbt code,
+`.sql` files run about 500 bytes median and 1.9 KB at p90, so even a 5000-model
+project is a few MB before compression. A single committed CSV can exceed all of
+it, so the CLI drops any file over 5 MB from the bundle and says which, rather
+than counting models.
+
+**Only text is carried.** A dbt project's authored files are text; a binary one
+(an image under `docs/`, a stray `.DS_Store`, a parquet seed) is skipped with
+the reason. Left in, it would be read as mojibake and, if it carried a NUL,
+rejected by Postgres with an opaque `unsupported Unicode escape sequence`.
+Binary is detected the way `git` does it, by a NUL in the first 8000 bytes,
+because `docs/` and dotfiles do not follow extensions. The push, the staleness
+hash and the sync diff share one predicate: a file one drops and another keeps
+is a change no push can resolve.
+
+**Secrets are not carried.** `.env`, `.env.*` and `.envrc` are skipped with the
+reason. The import above copies whatever the checkout holds, and what a
+`.gitignore` was keeping out of the repo is exactly the file that must not
+become a script version, readable by anyone who can read the script and handed
+back on every pull. dbt does not read them either — `env_var()` takes the
+process environment, which Windmill fills from the descriptor's `env` and the
+script's environment variables.
+
+**`dbt_project.yml` is rendered before it is read.** dbt allows `env_var()` in
+that file, so a project may name its profile or its packages directory through
+one. Windmill renders those two settings against the environment the run gives
+dbt before acting on them: reading the template instead leaves a rendered
+`profiles.yml` keyed under a name dbt never looks up, and a package cache
+watching a directory `dbt deps` never fills.
+
+## The script artifact
+
+New `ScriptLang::Dbt`. Content is a YAML descriptor whose field names track dbt's
+and Cosmos's vocabulary so the mental model ports without translation:
+
+```yaml
+engine: dbt-core-1x               # or dbt-core-2x | fusion
+profile:
+  warehouse: main                 # a warehouse configured on the workspace, by
+                                  # name; omitted takes `main`
+  target: prod
+  # schema: marts                 # target schema; REQUIRED for BigQuery, whose
+                                  # resource is a service-account JSON with no
+                                  # dataset in it
+  # profiles_yml: profiles.yml    # alternative: keep your own file; it then
+                                  # names a warehouse only to say where its
+                                  # assets belong (see below)
+select: ["tag:nightly+"]
+exclude: []
+test_behavior: build              # build | after_all | none
+vars:                             # typed: numbers/bools/lists keep their type,
+  run_date: "{{ run_date }}"      # and string leaves take job arguments
+  strict: false
+threads: 8
+full_refresh: false
+env:                              # for the project's own `{{ env_var() }}`
+  DBT_PASSWORD: $var:u/rf/wh_password
+```
+
+`env` values spelled `$var:<path>` are resolved to that Windmill variable, so a
+project keeping its own `profiles.yml` never needs a credential written into the
+descriptor — which is versioned script content. Both this map and the script's
+own environment variables apply to the deploy-time parse as well as the run, so
+an `env_var()` feeding a schema, alias or `enabled` produces the same relation
+in the stored graph and in the build either way. Prefer the descriptor's `env`
+when the value belongs to the project rather than to one deployment of it: it is
+versioned with the descriptor, so a redeploy from git carries it.
+
+`select`/`exclude`/`selector` are passed **verbatim** to dbt. Do not reimplement
+the selector grammar; Cosmos's manifest path had to, and it is a recurring source
+of divergence. One thing is decided before dbt sees them: a run that spells out
+`select` or `exclude` drops the descriptor's `selector`, because dbt resolves
+`--selector` *instead of* `--select` and passing both would silently build the
+descriptor's nodes rather than the ones the run asked for. "Spells out" means
+DIFFERS from the descriptor's own value, not merely "was submitted": the
+generated run form posts a default back for every field left untouched, and a
+selector descriptor's `select` default is `[]`, so reading a submitted `[]` as
+an override dropped `--selector` from every run started from the UI, a schedule
+or a webhook and built the whole project. A run that wants the whole project
+despite the selector asks for it with a selection that differs — `["*"]`.
+`select` and `vars` are overridable per run via job args. The **graph** stays the
+deployed descriptor's: asset rows are written at deploy, like every other
+language's, so a run-arg override changes what gets built without changing what
+the graph says the script owns. Split the project into several scripts
+(decision 6) when the graph itself should differ.
+
+A `vars` override does re-ingest — vars steer `enabled`, aliases, schemas and
+materializations, so the deployed graph would name another run's relations — but
+under the job id alone, never as what the script owns: publishing an override's
+relations would leave them recorded for the next default run, which then builds
+the descriptor's while the graph shows the override's. See "Which run's graph
+becomes what the script owns" for the whole table, including the profile move
+that is the one cause a run publishes.
+
+`vars` interpolates from job args with `interpolate_template` (`common.rs`,
+shared with the Ansible executor). The syntax is `{{ arg_name }}`.
+
+`select`/`exclude` also scope **what the script owns in the graph**, resolved by
+asking dbt (`dbt ls --output json`) rather than by interpreting the selector
+string. Without that a narrowly-selected script registers as the producer of
+every model in the project, and two scripts splitting one project would each
+claim all of it. Running several scripts with different selections only composes
+because of this.
+
+## Deploy path
+
+New `ScriptLang::Dbt` arm in `worker_lockfiles.rs` (near the `ScriptLang::Ansible`
+arm at :2758), producing:
+
+```rust
+struct DbtDependencyLocks {
+    manifest_digest: String,
+    engine: String,
+    engine_version: String,
+    adapter_version: Option<String>,
+    package_lock_digest: Option<String>,
+    profile_relation_root: Option<String>,
+}
+```
+
+Steps: write the script's modules into the job directory, `dbt deps`, `dbt parse`
+for the manifest, then ingest.
+
+Ingestion writes the rows the native parser writes, via
+`replace_static_asset_usage` (`windmill-common/src/assets.rs:254`) into
+`asset (workspace_id, path, kind, usage_access_type, usage_path, usage_kind, columns)`.
+The language dispatch point is `parse_assets_for_lang`
+(`windmill-api-scripts/src/asset_inference.rs:33`).
+
+**The one architectural wrinkle.** Every other language's asset parsing there is a
+pure function of script content. dbt's needs the bundle on disk and a dbt
+invocation, so it cannot run inline: it runs as a deploy-time job, persists the manifest, and
+`parse_assets_for_lang` reads the persisted result. **Prototype this first**, it
+is the assumption most likely to reshape the phasing.
+
+### Dependencies resolve at deploy, and are pinned for every run
+
+A project declaring `packages.yml` ranges or a mutable git revision asks dbt to
+*resolve* them, and dbt re-resolves on every `dbt deps`. Windmill resolves once, at
+deploy, and pins the result — the same contract every other language's lockfile
+gets here.
+
+The deploy records the digest of the `package-lock.yml` dbt produced into
+`DbtDependencyLocks`. That digest keys the worker-local package cache and joins the
+run identity that gates `dbt retry`. A run restores the tree under that key; a worker
+that resolves anything else is refused rather than run, because accepting it would let
+one resolution's `run_results.json` decide what a retry rebuilds.
+
+Only a run has a resolution to be held to. The deploy establishes one and accepts
+whatever dbt returns — including a `package-lock.yml` dbt rewrites itself, which it
+does whenever the `sha1_hash` it stored for `packages.yml` no longer matches. Holding
+the deploy to a committed lock would refuse the first deploy after a package is added,
+with no way out, since redeploying resolves the same way again.
+
+Consequences worth knowing before choosing whether to commit a lockfile:
+
+- **To pick up a newer version of a ranged dependency, deploy a CHANGE.** Only a
+  deploy re-resolves, and an unchanged push is skipped as a no-op — the lock and the
+  schema are both derived, so they are compared as they would be stored rather than
+  as they arrive. Editing `packages.yml`, or committing the `package-lock.yml` you
+  want, is what moves a pinned resolution.
+- **A committed `package-lock.yml` lets a deploy hit the cache**, since it is the
+  digest the lookup is keyed on before `dbt deps` has run. A project without one, or
+  whose committed lock is not what dbt resolves, pays a real `dbt deps` per deploy.
+  This is dbt's own recommendation for the same reason.
+- **The refusal is per worker, not per script.** `dbt deps` writes its lock into the
+  job directory, so a project with a range and no committed lock reproduces its
+  resolution only from a cache hit. Once upstream publishes a new version, that
+  script keeps running on every worker already holding its tree and fails on the
+  first cold one — same commit, same arguments, different outcome by worker. A
+  deploy that changes something re-pins and clears it; committing the lock avoids it
+  entirely.
+
+Nothing evicts these worker-local caches — package trees, engine installs and retry
+state alike — and `cache_clear` does not reach them either: it removes
+`$WINDMILL_DIR/cache/`, while all three live under `$WINDMILL_DIR/cache_nomount/`,
+as bun's cache does. An operator reclaims them by deleting that directory. Engine
+installs dominate the space by two orders of magnitude (~270–290 MB each, bounded
+by engine version) and package trees grow one tree per edit of a project that
+declares packages. Sweeping either on an age or a size bound is follow-up work.
+
+## Run path
+
+One `dbt build` per job, the shape Cosmos arrived at with `ExecutionMode.WATCHER`
+after per-model Airflow tasks proved roughly 6x slower (about 5.5 minutes for one
+`dbt run` versus about 32 minutes for 184 per-model invocations on
+google/fhir-dbt-analytics). dbt's own threading provides parallelism; Windmill
+provides observability.
+
+### The run's arguments are one command block
+
+A run takes a single `command` argument, plus one argument per `{{ placeholder }}`
+the descriptor interpolates. `command` is a `oneOf` whose variant IS the command,
+so it carries exactly the overrides that command takes:
+
+```jsonc
+{"command": {"label": "build", "select": [], "exclude": [], "vars": {}, "full_refresh": false}}
+{"command": {"label": "retry", "dbt_retry_job": "019fb410-8ea9-…"}}
+{"command": {"label": "show",  "model": "stg_orders", "vars": {}, "limit": 100}}
+```
+
+The union is the point: `dbt_retry_job` is required where it means something and
+absent everywhere else, `show` takes the ONE model it previews rather than the
+`select`/`exclude` pair that narrows a build, `full_refresh` cannot reach a
+command that ignores it, and
+the run form renders a toggle over the variants rather than a list of fields that
+quietly do nothing. The worker spreads the block over the run's arguments to read
+them — `label` becomes `dbt_command` — which is why a `{{ placeholder }}` may not
+take one of those names (`RESERVED_ARG_NAMES`). What a run SUBMITTED keeps the
+block, since that is what `dbt_run_state` saves and `invocation_args` publishes.
+
+1. Materialise the script's modules into the job directory, restore
+   `dbt_packages/` from cache.
+2. Render `profiles.yml` from the resource, or use the project's own file with
+   Windmill secrets injected as env vars for `{{ env_var() }}`.
+3. `dbt build --log-format json` plus `select`/`exclude`/`vars`/`threads`.
+4. Stream events: each `NodeFinished` updates per-model status live and emits
+   `RecordMaterializationRequest` (`windmill-common/src/materialization.rs:53`),
+   which already carries `asset_kind`, `asset_path`, `partition`, `status`,
+   `row_count`, `job_id`, `error`, `schema`. `run_results.json` supplies all of it.
+5. Structured job result (per-model status, timing, rows, failed tests), not just
+   an exit code. Partial failure is dbt's normal case and must be legible without
+   reading logs.
+6. **Node-level retry.** `retry_failed_nodes: {attempts, delay_seconds}` in the
+   descriptor rebuilds only what a failed build left failed or skipped, in the
+   same job, before reporting failure. dbt confines a failure to its own
+   subtree, so a transient warehouse error costs those nodes rather than the
+   project. In-job is what keeps the state question out of it: the previous
+   attempt's `run_results.json` is still in the job directory, so there is
+   nothing to persist and no worker to land back on. This is the granularity
+   astronomer-cosmos gets from one Airflow task per model, without the ~6x that
+   per-model tasks measured (decision 4).
+
+   A retry's `run_results.json` names only the nodes it redid, so it overlays
+   the accumulated results rather than replacing them: the job's result must be
+   every node the job touched, or the nodes that succeeded before the retry
+   settle no materializations.
+
+7. `dbt retry` resumes from the failure point using `run_results.json`, which is
+   what makes one-job-per-invocation defensible. It is saved twice: to the
+   worker's local cache, and to `dbt_run_state` in the database, so a retry
+   works from any worker with a database connection. An agent worker reaches
+   the database only through the API, which does not expose this, so it keeps
+   only its own local copy; the automatic node retry is refused there for the
+   same reason, since its wait could not observe a cancellation. Only `run_results.json` is stored there.
+   `dbt retry` also needs `manifest.json`, roughly sixty times larger and
+   growing with the project (732 KB against 12 KB on a six-node fixture), but
+   the manifest is a pure function of the project files, vars and env — all of
+   which the stored identity already pins — so a worker restoring from the
+   database re-derives it with a `dbt parse` of about a second. It is a run
+   argument (the `retry` command variant) rather than the automatic behavior of
+   Windmill's generic retry, which has no per-language hook to change the invoked
+   command.
+   Each attempt gets a fresh job dir, so the previous run's `target/` is cached
+   per (workspace, script) on the worker and restored for a retry.
+
+   **Naming the run.** The `retry` variant requires `dbt_retry_job`, the id of
+   the run to resume, and the worker refuses one that is not the run it holds —
+   naming both ids, since "that is not the one" is otherwise indistinguishable
+   from "nothing is saved". Only the latest failure of a script is kept, so an
+   unnamed retry would mean "whatever failed last" and would quietly resume a
+   different run than the caller was looking at. The run page's `Resume this run`
+   and `Run again → dbt retry with same args` both fill it in; on the run form,
+   choosing `retry` prefills it with the run that caller's own retry would land
+   on. It is not a selector: naming a run other than the saved one is refused,
+   not resumed.
+
+   **Concurrency is the script's, not the retry's.** A retry that starts while
+   another run of the same script is in flight rebuilds nodes that run may also
+   be rebuilding — appending an incremental model twice. That is what two
+   concurrent `build`s of one project do as well: dbt takes no cross-process
+   lock, so a project that must not run twice at once sets the script's
+   concurrency limit, which covers its retries with it. A lock held across a
+   dbt execution instead would outlive worker deaths and cancellations.
+
+   **Who may resume it.** The state is keyed `(workspace, script_path,
+   permissioned_as)` — one saved run per script per identity it executes as — so
+   anyone entitled to run the script as that principal may resume its last
+   failure, which is the same capability as re-running that job: running the
+   script requires read access on it, and that access shows them the run and its
+   arguments already. Naming the run neither widens nor narrows that; the id is
+   checked against what the state holds, not against the caller.
+
+   For an `on_behalf_of` script that means every caller shares one saved run,
+   since they all execute as the owner — deliberately, since the state describes
+   the script's last run under the owner's identity rather than any one caller's.
+
+   **What a retry actually adds, and where that crosses a line.** Resuming grants
+   no capability a caller lacks: they may already run the script as that principal,
+   and a plain run builds everything the descriptor selects, of which a retry
+   rebuilds a subset. The one thing it adds is information — the result carries
+   `invocation_args`, the resumed run's arguments as SUBMITTED, because a retry
+   job's own args are just the command and the run it names, and the row preview
+   needs the real ones.
+
+   For almost every shape the caller could already read that run, so nothing
+   crosses: under `f/`, `see_folder_extra_perms_user` makes a job readable to
+   everyone with read on the folder, which is also what grants execution; an
+   ordinary script's runs are `permissioned_as` the caller, and another user's runs
+   are keyed under their own principal and unreachable. It takes all three of a
+   `u/<owner>` path, `extra_perms` sharing and `on_behalf_of` for "may run as this
+   principal" to be broader than "may read this principal's jobs" — and there a
+   grantee learns the literal argument values of another's run. References stay
+   references, so no resolved secret is among them.
+
+   That residual is accepted rather than gated. A gate needs the caller's identity,
+   and a worker has only `created_by` — `display_username()`, which a token LABEL
+   supplies. Resolving it as a username denies every labelled token (a CI token
+   becomes `label-<name>`, which is no workspace member) and still trusts a name;
+   authorizing where the caller is real means the submitting path, not the worker.
+   The exposure did not justify either.
+
+   That equivalence holds only while the run is READABLE, so the one run that
+   breaks it saves nothing: a job pushed `invisible_to_owner` is hidden from the
+   script's owners, and a retry publishes the arguments it restored, which would
+   make that retry the one way to see them. A hidden run therefore keeps no
+   retry state at all — it cannot be resumed by anyone, including whoever
+   launched it, which is the cheaper half of the trade. Keying by the initiating
+   caller would not have worked instead: `created_by` is `display_username()`,
+   which a token LABEL supplies, so two callers can share one value and one can
+   name a third person (GHSA-8x8x-88qc-qp4r, whose fix was to stop trusting that
+   name for authorization). A retry does name the run it resumes, but that name is
+   checked against the saved state rather than authorized as a job read — doing
+   the latter, which is what would let a hidden run be resumed by its own author,
+   needs the submitting path, where the caller is real.
+8. Test failures honor dbt's `severity`: `error` fails the job, `warn` surfaces
+   without failing. Overriding this would make the same project behave differently
+   on Windmill than locally, breaking the core promise.
+
+## Two decisions the implementation narrowed
+
+**Decision 13 — no S3 copy of the manifest.** The sidecar holds every field the
+graph renders; nothing reads a stored `manifest.json`, so writing one to S3
+would be an unread copy of data that is already reproducible by redeploying (or,
+for a dynamic descriptor, by the next run). Worth adding the day something needs the
+parts the sidecar drops — compiled SQL, macro definitions — and not before.
+
+**Decision 14 — column lineage is not available.** The decision assumed
+`manifest.json` carries column-to-column edges; it does not, in either core
+engine. What it does carry is declared column *descriptions*, which are
+ingested. Real column lineage would need Fusion (which does static analysis) or
+a SQL-AST pass of our own, so `columnLineageGraph.ts` is not wired up for dbt.
+
+## Concept mapping
+
+| dbt | Windmill | Mechanism |
+|---|---|---|
+| model relation | `dbt://` asset | new `AssetKind` |
+| `ref()` graph | lineage edges | `replace_static_asset_usage` |
+| `materialized: table` | `materialize_strategy: replace` | `AssetGraphRunnableNode` |
+| `materialized: incremental` | `append` or `merge` (by `unique_key`) | same |
+| `{% snapshot %}` | `scd2` | same, incl. `<dim>_current` handling |
+| `unique`/`not_null`/`accepted_values`/`relationships` | `data_tests` | exact 1:1 with the four `// data_test` kinds |
+| declared column metadata | `columns` on the asset node | descriptions only; see the note below |
+| model `tags` | node badge | `tag` |
+| source freshness | `freshness` | `last_success_at` chip |
+| `run_results.json` | materialization records | `record_materialization` |
+| `dbt_packages/` | worker-local cache | keyed by `packages.yml`, the project digest and the `package-lock.yml` the deploy resolved |
+
+## Phases
+
+**Phase 1: run it.** `ScriptLang::Dbt` across the 41 `ADD_NEW_LANG` sites (mostly
+one-liners in `EditorBar.svelte`, `scripts.ts`, `script_helpers.ts`,
+`LanguageIcon.svelte`, `script_common.ts`). Engine provisioning for all three
+options in `Dockerfile` and `docker/DockerfileFull*` (bundle 1x and 2x, fetch
+Fusion at runtime). New `backend/windmill-worker/src/dbt_executor.rs`: descriptor
+parse, bundle materialisation, `profiles.yml` render, `dbt build`, log
+passthrough, structured result, retry.
+
+**Phase 2: graph.** `DbtDependencyLocks` and the deploy arm. Migration via
+`cargo sqlx migrate add -r dbt_runtime`. New `dbt://` `AssetKind` with
+its `canonical_prefix`. Manifest ingest. Deploy-time ingest plus the per-run
+re-ingest for dynamic descriptors. Extend `AssetGraphRunnableNode`/`AssetGraphAssetNode` in
+`frontend/src/lib/components/assets/AssetGraph/types.ts` with dbt provenance and
+render through the existing `RunnableNode.svelte` / `AssetNode.svelte` /
+`DataTestNode.svelte`.
+
+**Phase 3: live progress and ergonomics.** JSON event stream to per-model status
+on the canvas mid-run. `record_materialization` per model. Profile and select
+pickers in the editor. Per-model failure triage in the run view.
+
+**Phase 4 (not in this PR).** `--defer` and `state:modified`. Partition and
+backfill integration so `BackfillRangeDialog.svelte` works on dbt models.
+`wmill dbt import <dag.py>` reading `DbtDag(...)` kwargs.
+
+## E2E test requirements
+
+Against a real dbt project (jaffle_shop shape) and the local Postgres:
+
+1. **Happy path**: deploy a dbt script, run it, assert models exist in the
+   warehouse and the job succeeds with a structured per-model result.
+2. **Engine parity**: the same project passes on `dbt-core-1x` and `dbt-core-2x`.
+   Fusion covered by a manually-run test, not CI (runtime fetch).
+3. **Test severity**: a failing `error`-severity test fails the job; a failing
+   `warn`-severity test does not.
+4. **Retry**: a run failing midway, retried, resumes via `dbt retry` and does not
+   rebuild already-successful models.
+5. **Graph ingest**: after deploy, model assets and `ref()` edges exist; a native
+   script reading one of the marts gets an edge to it.
+6. **Shared node**: a native script that READS a mart renders as a reader of the
+   same node the dbt model writes — one node, not two islands. Declared with a
+   plain read (`# dbt://<mart>`), never `# on`: a `dbt://` subscription is
+   refused at deploy, because nothing but dbt writes a warehouse relation and a
+   dbt run does not dispatch (see "no cascade from dbt").
+7. **Selection**: descriptor `select`/`exclude`, and a run-arg override, each
+   build only the expected subset.
+8. **Dynamic descriptors**: a `{{ }}` placeholder in `vars` re-ingests the graph
+   from the run's own manifest, so a model that placeholder enables appears in
+   the same run that builds it.
+9. **Both credential paths**: resource-rendered `profiles.yml`, and the project's
+   own `profiles.yml` with env-var injection.
+10. **Caching**: a second run reuses the cached `dbt_packages/` with no network
+    fetch.
+
+Keep only tests that pin behavior a future change could break. Per AGENTS.md,
+delete development scaffolding before marking the PR ready.
diff --git a/frontend/package-lock.json b/frontend/package-lock.json
index bbae4d0618..782363b851 100644
--- a/frontend/package-lock.json
+++ b/frontend/package-lock.json
@@ -94,7 +94,7 @@
 				"windmill-parser-wasm-rust": "1.647.1",
 				"windmill-parser-wasm-ts": "1.695.0",
 				"windmill-parser-wasm-wac": "1.668.6",
-				"windmill-parser-wasm-yaml": "1.593.0",
+				"windmill-parser-wasm-yaml": "1.770.0",
 				"windmill-sql-datatype-parser-wasm": "1.512.0",
 				"windmill-utils-internal": "1.8.2",
 				"xterm": "^5.3.0",
@@ -14930,9 +14930,9 @@
 			"integrity": "sha512-/ovcLWlIO+TQMrnWwcWoXquJI6hTZ+Zpo4POhV8z6e+pb4cVModGysASI9mERn2e9uj8/xSRmYqk54TLG8oUbQ=="
 		},
 		"node_modules/windmill-parser-wasm-yaml": {
-			"version": "1.593.0",
-			"resolved": "https://registry.npmjs.org/windmill-parser-wasm-yaml/-/windmill-parser-wasm-yaml-1.593.0.tgz",
-			"integrity": "sha512-Gyx4aR2jsJYuDrD3mCNTmz7LWOQQXPw5yKNCC1xRgUOPfjsD/tINAFfsBLwVOSmlQQcFZO+wHm4KtDtXOcnGVw=="
+			"version": "1.770.0",
+			"resolved": "https://registry.npmjs.org/windmill-parser-wasm-yaml/-/windmill-parser-wasm-yaml-1.770.0.tgz",
+			"integrity": "sha512-RngxbcKYYFt3MHYqdYTzbtH6EMPfqJtY4/mqRqfLUie4cE9mmOBa9X9M3VEFVo53CD1dCRa9wJKZmeJzE5We5Q=="
 		},
 		"node_modules/windmill-sql-datatype-parser-wasm": {
 			"version": "1.512.0",
diff --git a/frontend/package.json b/frontend/package.json
index a979096694..d385e14bb6 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -170,7 +170,7 @@
 		"windmill-parser-wasm-rust": "1.647.1",
 		"windmill-parser-wasm-ts": "1.695.0",
 		"windmill-parser-wasm-wac": "1.668.6",
-		"windmill-parser-wasm-yaml": "1.593.0",
+		"windmill-parser-wasm-yaml": "1.770.0",
 		"windmill-sql-datatype-parser-wasm": "1.512.0",
 		"windmill-utils-internal": "1.8.2",
 		"xterm": "^5.3.0",
diff --git a/frontend/src/lib/components/DefaultScriptsInner.svelte b/frontend/src/lib/components/DefaultScriptsInner.svelte
index 1a451d8264..e7bdc7089e 100644
--- a/frontend/src/lib/components/DefaultScriptsInner.svelte
+++ b/frontend/src/lib/components/DefaultScriptsInner.svelte
@@ -3,17 +3,20 @@
 	import { defaultScripts, workspaceStore } from '$lib/stores'
 	import { flip } from 'svelte/animate'
 	import Toggle from './Toggle.svelte'
-	import { defaultScriptLanguages } from '$lib/scripts'
+	import { dbtLanguageOffered, defaultScriptLanguages } from '$lib/scripts'
 	import Alert from './common/alert/Alert.svelte'
 
 	interface Props {
-		small?: boolean;
+		small?: boolean
 	}
 
-	let { small = false }: Props = $props();
+	let { small = false }: Props = $props()
 
 	function computeLangs(defaultScripts: WorkspaceDefaultScripts | undefined): Script['language'][] {
-		const allLangs = Object.keys(defaultScriptLanguages) as Script['language'][]
+		// Ordering a language the picker does not offer would have no effect.
+		const allLangs = (Object.keys(defaultScriptLanguages) as Script['language'][]).filter(
+			(l) => l !== 'dbt' || dbtLanguageOffered()
+		)
 		if (!defaultScripts || defaultScripts.order == undefined) return allLangs
 		return defaultScripts.order
 			?.concat(allLangs.filter((l) => !defaultScripts.order?.includes(l)))
diff --git a/frontend/src/lib/components/DisplayResult.svelte b/frontend/src/lib/components/DisplayResult.svelte
index 99b47ea86b..8208fb193e 100644
--- a/frontend/src/lib/components/DisplayResult.svelte
+++ b/frontend/src/lib/components/DisplayResult.svelte
@@ -3,6 +3,8 @@
 
 	import { Highlight } from 'svelte-highlight'
 	import { json } from 'svelte-highlight/languages'
+	import DbtRunResult from '$lib/components/dbt/DbtRunResult.svelte'
+	import { parseDbtRun } from '$lib/components/dbt/parseDbtRun'
 	import { copyToClipboard, parseS3Object, roughSizeOfObject } from '$lib/utils'
 	import ExpandableImage from '$lib/components/common/image/ExpandableImage.svelte'
 	import { base } from '$lib/base'
@@ -704,6 +706,13 @@
 		}
 		return undefined
 	})
+
+	// Per-node breakdown of a dbt invocation, rendered above the raw result. On
+	// success it IS the result; on failure the worker puts the same JSON in the
+	// error message after the exit-status line, and that is the case worth
+	// rendering — the failing node is what the user came for. Inert (undefined)
+	// for every other DisplayResult use.
+	let dbtRun = $derived(parseDbtRun(result))
 </script>
 
 <HighlightTheme />
@@ -712,6 +721,10 @@
 	<DataTestsResult tests={dataTests} />
 {/if}
 
+{#if dbtRun}
+	<DbtRunResult run={dbtRun} />
+{/if}
+
 {#if result_stream && result == undefined}
 	<div class="flex flex-col w-full gap-2">
 		<div class="flex items-center gap-2 text-secondary text-xs">
diff --git a/frontend/src/lib/components/HighlightCode.svelte b/frontend/src/lib/components/HighlightCode.svelte
index 73c9a08c4a..bb51851003 100644
--- a/frontend/src/lib/components/HighlightCode.svelte
+++ b/frontend/src/lib/components/HighlightCode.svelte
@@ -26,7 +26,10 @@
 
 	interface Props {
 		code?: string
-		language: Script['language'] | 'bunnative' | 'frontend' | 'json' | undefined
+		// `sql` is the dialect-agnostic option: a dbt model's SQL is compiled by
+		// whichever adapter the project targets, so naming one dialect would be a
+		// guess. Every dialect below highlights through the same grammar anyway.
+		language: Script['language'] | 'bunnative' | 'frontend' | 'json' | 'sql' | undefined
 		highlightLanguage?: LanguageType<string> | undefined
 		lines?: boolean
 		className?: string
@@ -56,7 +59,9 @@
 		? 'opacity-0 group-hover:opacity-100 focus-within:opacity-100 transition-opacity duration-150'
 		: ''
 
-	function getLang(lang: Script['language'] | 'bunnative' | 'frontend' | 'json' | undefined) {
+	function getLang(
+		lang: Script['language'] | 'bunnative' | 'frontend' | 'json' | 'sql' | undefined
+	) {
 		switch (lang) {
 			case 'python3':
 				return python
@@ -76,6 +81,8 @@
 				return javascript
 			case 'graphql':
 				return graphql
+			case 'sql':
+				return sql
 			case 'mysql':
 				return sql
 			case 'postgresql':
diff --git a/frontend/src/lib/components/ScriptBuilder.svelte b/frontend/src/lib/components/ScriptBuilder.svelte
index bd30cd6909..f209907537 100644
--- a/frontend/src/lib/components/ScriptBuilder.svelte
+++ b/frontend/src/lib/components/ScriptBuilder.svelte
@@ -454,6 +454,8 @@
 					language: 'bun'
 				}
 			}
+		} else if (script.language === 'dbt') {
+			seedDbtProject()
 		}
 		const restarter = scheduleRestartSync(userDraftPath, { waitForContent: true })
 		initContent(script.language, script.kind, template).finally(() => restarter.markContentReady())
@@ -971,6 +973,34 @@
 
 	function handleDeployTrigger(_trigger: Trigger) {}
 
+	// A dbt script's modules ARE its dbt project, and the runtime refuses one
+	// without a `dbt_project.yml`. Seeded from BOTH entry points — the empty-script
+	// bootstrap and the language picker — because reaching dbt by switching an
+	// existing draft otherwise produces a script that cannot deploy or run.
+	// Existing modules are left alone: switching away and back must not discard a
+	// project the user has already grown.
+	function seedDbtProject() {
+		// Keyed on the project file rather than on "has any modules at all": a
+		// draft that grew modules under another language carries none of what dbt
+		// needs, and the worker refuses a bundle with no `dbt_project.yml` — so
+		// that draft reached dbt in a state it could neither deploy nor run.
+		if (script.modules?.['dbt_project.yml']) return
+		script.modules = {
+			'dbt_project.yml': {
+				content:
+					'name: my_dbt_project\nversion: "1.0"\nprofile: my_dbt_project\nmodels:\n  my_dbt_project:\n    +materialized: view\n',
+				language: 'dbt'
+			},
+			'models/example.sql': {
+				content: 'select 1 as id\n',
+				language: 'dbt'
+			},
+			// Last, so anything already written wins: the previous language's
+			// helper files are inert to dbt and are the user's to remove.
+			...(script.modules ?? {})
+		}
+	}
+
 	function onScriptLanguageTrigger(lang: 'docker' | 'bunnative' | ScriptLang) {
 		if (lang == 'docker') {
 			template = 'docker'
@@ -983,6 +1013,9 @@
 		//
 		initContent(language, script.kind, template)
 		script.language = language
+		if (language === 'dbt') {
+			seedDbtProject()
+		}
 	}
 
 	function onSummaryChange(value: string) {
diff --git a/frontend/src/lib/components/ScriptEditor.svelte b/frontend/src/lib/components/ScriptEditor.svelte
index 9a65fc9d2b..e112f92b3b 100644
--- a/frontend/src/lib/components/ScriptEditor.svelte
+++ b/frontend/src/lib/components/ScriptEditor.svelte
@@ -19,6 +19,10 @@
 	import { isWorkflowAsCode } from '$lib/components/graph/wacToFlow'
 	import WacDiagram from '$lib/components/graph/WacDiagram.svelte'
 	import { Pane, Splitpanes } from 'svelte-splitpanes'
+	import DbtProjectPanel, {
+		dbtFileLang,
+		dbtModelSelector
+	} from '$lib/components/dbt/DbtProjectPanel.svelte'
 	import SchemaForm from './SchemaForm.svelte'
 	import PowerShellCommonParams from './PowerShellCommonParams.svelte'
 	import LogPanel from './scriptEditor/LogPanel.svelte'
@@ -354,9 +358,32 @@
 		editor?.setCode(editorCode)
 	}
 
+	// Whether the open file is tested as a runnable of its own. A `__mod` helper
+	// is; a dbt project's files are not — the run is always the project's, so the
+	// arguments shown, edited and logged must be the descriptor's, not an empty
+	// per-module set the request would ignore.
+	let onModuleArgs = $derived(activeModuleTab !== null && lang !== 'dbt')
+
+	// The selector a Test would build with, when the open file is a model. Macros,
+	// analyses and singular tests are `.sql` too and none is selectable by name,
+	// so those fall back to running the project.
+	let dbtSelected = $derived.by(() => {
+		const open = activeModuleTab
+		if (lang !== 'dbt' || !open) return undefined
+		const selector = dbtModelSelector(modules ?? {}, open)
+		// The label drops whichever extension the selector matched, so a Python
+		// model reads `Build my_model` rather than `Build my_model.py`.
+		const name = open.split('/').pop()!.replace(/\.(sql|py)$/, '')
+		return selector ? { selector, name } : undefined
+	})
+
 	let effectiveLang = $derived(
 		activeModuleTab && modules?.[activeModuleTab]
-			? (modules[activeModuleTab].language as Preview['language'])
+			? lang === 'dbt'
+				? // Every dbt module is stored as `dbt`; the extension is what says
+					// whether this file is SQL, YAML or a seed.
+					dbtFileLang(activeModuleTab)
+				: (modules[activeModuleTab].language as Preview['language'])
 			: lang
 	)
 
@@ -373,7 +400,15 @@
 		return isTsWac || isPyWac
 	})
 	let supportsModules = $derived((lang === 'bun' || lang === 'python3') && isWacV2)
-	let mainFileName = $derived('script.' + langToExt(scriptLangToEditorLang(lang)))
+	// A dbt script's content is the descriptor and its modules are the project.
+	// A tree rather than the module tab strip: a project has folders and dozens
+	// of files, which a strip cannot show.
+	let isDbt = $derived(lang === 'dbt')
+	let mainFileName = $derived(
+		isDbt
+			? 'wm_dbt.yaml'
+			: 'script.' + langToExt(scriptLangToEditorLang(lang))
+	)
 
 	let modulePathInput = $state('')
 	let showAddModulePopover = $state(false)
@@ -428,13 +463,28 @@
 		bunnative: ['.ts']
 	}
 
+	// A dbt project's files are dbt's own, not Windmill modules: models and tests
+	// are `.sql`, schemas and the project file `.yml`, seeds `.csv`, docs `.md`.
+	// `.py` because dbt Python models are first-class on Snowflake, BigQuery and
+	// Databricks, and the CLI already bundles one; refusing to CREATE one here
+	// was the only place that restriction existed.
+	const DBT_MODULE_EXTENSIONS = ['.sql', '.py', '.yml', '.yaml', '.csv', '.md']
 	let allowedModuleExtensions = $derived(
-		lang
-			? (LANG_MODULE_EXTENSIONS[lang] ?? Object.keys(ALL_MODULE_EXTENSIONS))
-			: Object.keys(ALL_MODULE_EXTENSIONS)
+		lang === 'dbt'
+			? DBT_MODULE_EXTENSIONS
+			: lang
+				? (LANG_MODULE_EXTENSIONS[lang] ?? Object.keys(ALL_MODULE_EXTENSIONS))
+				: Object.keys(ALL_MODULE_EXTENSIONS)
 	)
 
 	function inferModuleLang(filePath: string): ScriptModule['language'] | undefined {
+		// Every file of a dbt project is stored as `dbt`, whatever its extension:
+		// they are the project's, and dbt is what reads them.
+		if (lang === 'dbt') {
+			return DBT_MODULE_EXTENSIONS.some((e) => filePath.endsWith(e))
+				? ('dbt' as ScriptModule['language'])
+				: undefined
+		}
 		for (const [ext, moduleLang] of Object.entries(ALL_MODULE_EXTENSIONS)) {
 			if (filePath.endsWith(ext)) return moduleLang
 		}
@@ -442,6 +492,12 @@
 	}
 
 	function getModuleDefaultContent(filePath: string): string {
+		if (lang === 'dbt') {
+			// A model that compiles on its own, so a new file is runnable before it
+			// is edited; anything else starts empty rather than with a guess at
+			// which dbt schema it is.
+			return filePath.endsWith('.sql') ? `select 1 as id\n` : ''
+		}
 		if (filePath.endsWith('.py')) {
 			return `def hello() -> str:\n    return "world"\n`
 		} else if (filePath.endsWith('.ts')) {
@@ -474,8 +530,19 @@
 		return ''
 	}
 
+	/// The descriptor is the script's CONTENT, not a module. A module at that same
+	/// path would be a second, independent value for one file: the export writes
+	/// the content there, and the bundle would emit over it.
+	function reservedDbtPath(path: string): string | undefined {
+		return lang === 'dbt' && path.trim() === 'wm_dbt.yaml'
+			? `wm_dbt.yaml is the descriptor, edited from the tree — it cannot also be a file`
+			: undefined
+	}
+
 	function validateModulePath(path: string): string {
 		if (!path.trim()) return ''
+		const reserved = reservedDbtPath(path)
+		if (reserved) return reserved
 		const moduleLang = inferModuleLang(path)
 		if (!moduleLang) {
 			const exts = allowedModuleExtensions.join(', ')
@@ -525,6 +592,8 @@
 
 	function validateRenameModulePath(newPath: string, oldPath: string): string {
 		if (!newPath.trim()) return ''
+		const reserved = reservedDbtPath(newPath)
+		if (reserved) return reserved
 		const moduleLang = inferModuleLang(newPath)
 		if (!moduleLang) {
 			const exts = allowedModuleExtensions.join(', ')
@@ -838,16 +907,30 @@
 		// Flush module edits back to modules map before running preview
 		flushModuleContent()
 
-		const testCode = activeModuleTab !== null ? editorCode : code
-		const testLang = activeModuleTab !== null ? effectiveLang : lang
-		const rawTestArgs =
-			activeModuleTab !== null
-				? testPanelArgs
-				: selectedTab === 'preprocessor' || kind === 'preprocessor'
-					? { _ENTRYPOINT_OVERRIDE: 'preprocessor', ...(args ?? {}) }
-					: (args ?? {})
-		const testSchema = activeModuleTab !== null ? testPanelSchema : schema
+		// A dbt run is always the project's, whichever file is open: `dbt build`
+		// takes the whole bundle, and testing one model in isolation is not a
+		// thing dbt does.
+		const onModule = onModuleArgs
+		const testCode = onModule ? editorCode : code
+		const testLang = onModule ? effectiveLang : lang
+		const rawTestArgs = onModule
+			? testPanelArgs
+			: selectedTab === 'preprocessor' || kind === 'preprocessor'
+				? { _ENTRYPOINT_OVERRIDE: 'preprocessor', ...(args ?? {}) }
+				: (args ?? {})
+		const testSchema = onModule ? testPanelSchema : schema
 		const testArgs = await processSecretArgs(rawTestArgs, testSchema, opWs)
+		// Testing with a model open builds THAT model: `dbt build --select <model>`
+		// is dbt's own inner loop, and running the whole project to check one file
+		// is the thing a dbt developer never does. Its tests come along, because
+		// `build` interleaves them.
+		if (dbtSelected) {
+			testArgs.command = {
+				...((testArgs.command as object) ?? {}),
+				label: 'build',
+				select: [dbtSelected.selector]
+			}
+		}
 		if (showPsCommonParams) {
 			for (const [k, v] of Object.entries(psCommonParams)) {
 				if (v !== undefined && v !== false && v !== '') {
@@ -891,7 +974,10 @@
 				}
 			},
 			undefined,
-			activeModuleTab !== null ? undefined : modules,
+			// A `__mod` helper is tested alone, so its siblings are left out. A dbt
+			// project cannot be: the bundle IS the project, and without it the run
+			// finds no `dbt_project.yml` whichever file happens to be open.
+			onModule ? undefined : modules,
 			undefined,
 			timeout
 		)
@@ -1041,6 +1127,11 @@
 
 	async function inferModuleSchema() {
 		if (activeModuleTab === null) return
+		// A dbt project's files are not independently runnable: a model is SQL dbt
+		// compiles, not a script with arguments. Inferring some would put another
+		// language's parameters (a `.sql` model reads as Postgres) in the run form
+		// beside the descriptor's own.
+		if (lang === 'dbt') return
 		try {
 			await inferArgs(effectiveLang, editorCode, testPanelSchema)
 			injectPartitionArg(testPanelSchema, testPanelArgs, effectiveLang, editorCode)
@@ -2241,7 +2332,7 @@
 												<JsonInputs
 													on:select={(e) => {
 														if (e.detail) {
-															if (activeModuleTab !== null) {
+															if (onModuleArgs) {
 																testPanelArgs = e.detail
 															} else {
 																args = e.detail
@@ -2259,7 +2350,7 @@
 													bind:clientHeight={schemaHeight}
 												>
 													{#key argsRender}
-														{#if activeModuleTab !== null}
+														{#if onModuleArgs}
 															<SchemaForm
 																workspace={opWs}
 																helperScript={{
@@ -2339,7 +2430,9 @@
 		startIcon={{ icon: Play, classes: 'animate-none' }}
 		shortCut={{ Icon: CornerDownLeft }}
 	>
-		Test
+		<!-- Named, because a run that silently narrowed to whichever file happens to
+		     be open is the kind of surprise a warehouse bill discovers. -->
+		{dbtSelected ? `Build ${dbtSelected.name}` : 'Test'}
 	</Button>
 {/snippet}
 
@@ -2371,7 +2464,7 @@
 		previewIsLoading={debugMode ? $debugState.running && !$debugState.stopped : testIsLoading}
 		{editor}
 		{diffEditor}
-		args={activeModuleTab !== null ? testPanelArgs : args}
+		args={onModuleArgs ? testPanelArgs : args}
 		{showCaptures}
 		customUi={customUi?.previewPanel}
 		showCustomResultPanel={showDebugPanel}
@@ -2505,7 +2598,34 @@
 {/snippet}
 
 {#snippet editorContent()}
-	<div class="h-full !overflow-visible bg-surface dark:bg-surface-secondary relative flex flex-col">
+	<div
+		class="h-full !overflow-visible bg-surface dark:bg-surface-secondary relative flex {isDbt
+			? 'flex-row'
+			: 'flex-col'}"
+	>
+		{#if isDbt}
+			<DbtProjectPanel
+				modules={modules ?? {}}
+				scriptPath={path ?? ''}
+				descriptorName={mainFileName}
+				selected={activeModuleTab}
+				onSelect={(p) => (p === null ? switchToMain() : switchToModule(p))}
+				onDelete={removeModule}
+			>
+				{#snippet addFile()}
+					<Popover bind:isOpen={showAddModulePopover} placement="bottom-end" contentClasses="p-3 w-72">
+						{#snippet trigger()}
+							<div class="p-0.5 rounded hover:bg-surface-hover" title="New file">
+								<Plus size={12} />
+							</div>
+						{/snippet}
+						{#snippet content({ close })}
+							{@render addModuleForm(close)}
+						{/snippet}
+					</Popover>
+				{/snippet}
+			</DbtProjectPanel>
+		{/if}
 		{#if supportsModules}
 			<div
 				class="flex items-center border-b border-tertiary/30 bg-surface-secondary px-1 gap-0.5 text-xs overflow-x-auto shrink-0"
@@ -2595,7 +2715,7 @@
 				</Popover>
 			</div>
 		{/if}
-		<div class="relative flex-1 min-h-0 !overflow-visible">
+		<div class="relative flex-1 min-h-0 min-w-0 !overflow-visible">
 			<div class="absolute bg-surface top-2 right-4 z-10 flex flex-row gap-2">
 				{#if assets?.length}
 					<AssetsDropdownButton {assets} />
diff --git a/frontend/src/lib/components/apps/editor/inlineScriptsPanel/EmptyInlineScript.svelte b/frontend/src/lib/components/apps/editor/inlineScriptsPanel/EmptyInlineScript.svelte
index edaefe947a..214ab3e31d 100644
--- a/frontend/src/lib/components/apps/editor/inlineScriptsPanel/EmptyInlineScript.svelte
+++ b/frontend/src/lib/components/apps/editor/inlineScriptsPanel/EmptyInlineScript.svelte
@@ -7,7 +7,7 @@
 	import { inferArgs } from '$lib/infer'
 	import { initialCode } from '$lib/script_helpers'
 	import { emptySchema } from '$lib/utils'
-	import { defaultScriptLanguages, getScriptByPath, processLangs } from '$lib/scripts'
+	import { defaultScriptLanguages, getScriptByPath, processInlineLangs } from '$lib/scripts'
 
 	import { Building, GitFork, Globe2 } from 'lucide-svelte'
 	import { createEventDispatcher } from 'svelte'
@@ -88,7 +88,7 @@
 	}
 
 	let langs = $derived(
-		processLangs(undefined, $defaultScripts?.order ?? Object.keys(defaultScriptLanguages))
+		processInlineLangs(undefined, $defaultScripts?.order ?? Object.keys(defaultScriptLanguages))
 			.map((l) => [defaultScriptLanguages[l], l])
 			.filter(
 				(x) =>
diff --git a/frontend/src/lib/components/assets/AssetGraph/AssetGraphCanvas.svelte b/frontend/src/lib/components/assets/AssetGraph/AssetGraphCanvas.svelte
index 3e5e9d8cef..8a893e3e84 100644
--- a/frontend/src/lib/components/assets/AssetGraph/AssetGraphCanvas.svelte
+++ b/frontend/src/lib/components/assets/AssetGraph/AssetGraphCanvas.svelte
@@ -18,10 +18,15 @@
 	import PanToNode from './PanToNode.svelte'
 	import InitialFitView from './InitialFitView.svelte'
 	import { layoutAssetGraph } from './assetGraphLayout'
-	import { computeMutedReadKeys } from './resolveGraph'
+	import { computeMutedReadKeys, dbtAssociations } from './resolveGraph'
 	import { buildDownstreamMap } from './graphTraversal'
 	import { buildLineageDownstreamMap } from './boundedCascade'
-	import type { AssetGraphResponse, AssetGraphSelection, NativeTriggerKind } from './types'
+	import type {
+		AssetGraphResponse,
+		AssetGraphSelection,
+		AssetRunState,
+		NativeTriggerKind
+	} from './types'
 	import type { RunnableRunState } from './activeRunnables.svelte'
 	import type { AssetKind } from '$lib/gen'
 	import { NODE } from '$lib/components/graph/util'
@@ -179,6 +184,11 @@
 		 * When a node's nonce changes, it flashes a fading green background — its
 		 * producer just recomputed it. Driven by the replay player frame-by-frame. */
 		recomputedAssetIds?: ReadonlyMap<string, number>
+		/** What a run is currently doing to each relation, keyed `asset:<kind>:<path>`
+		 *  like every other per-asset map here.
+		 *  Distinct from `recomputedAssetIds`, which is a one-shot pulse: this is
+		 *  the state a node holds until the run moves it. */
+		assetRunStatus?: ReadonlyMap<string, AssetRunState>
 		/** Let the wheel zoom the canvas (and swallow the page scroll while doing
 		 * so). Default true for the full-height editor/player. Set false when the
 		 * canvas is embedded inline inside a scrollable container, so a wheel
@@ -215,6 +225,7 @@
 		viewportFitKey = '',
 		highlightActiveRun = false,
 		recomputedAssetIds,
+		assetRunStatus,
 		scrollZoom = true
 	}: Props = $props()
 
@@ -244,6 +255,7 @@
 			| 'data-test'
 			| 'macro'
 			| 'test-dependency'
+			| 'dbt-ref'
 		unsaved?: boolean
 		// Muted read edge: a ducklake/s3 input read every run whose (default)
 		// auto cascade trigger is suppressed by `// mute` / `// mute all`.
@@ -287,6 +299,26 @@
 		// by node id across producers).
 		const addedTestNodes = new Set<string>()
 
+		// A dbt script owns every relation its project materializes. Drawing that
+		// as one edge per model buries the lineage that matters — `ref()` between
+		// models, and native consumers — under a fan-out that grows with the
+		// project, so the association is carried by the model's badge and its
+		// hover/click highlight instead. Only the DRAWING is dropped: the
+		// producer rows still drive cascade dispatch and "who produced this".
+		const dbtRunnableIds = new Set(
+			g.runnables.filter((r) => r.dbt).map((r) => `${r.usage_kind}:${r.path}`)
+		)
+		// Association only — the canvas deliberately draws no edge for it.
+		const { ownerByAsset: dbtOwnerByAsset, writesByOwner: dbtWritesByOwner } = dbtAssociations(
+			g.runnables,
+			g.edges
+		)
+		// Per-relation dbt description, to tell a project's own declared source
+		// from a relation another script materializes.
+		const dbtAssetProvenance = new Map(
+			g.assets.filter((a) => a.dbt).map((a) => [`asset:${a.kind}:${a.path}`, a.dbt!])
+		)
+
 		const hasAddNode = onAddPipelineScript != null
 		if (hasAddNode) {
 			nodes.push({
@@ -395,6 +427,7 @@
 					path: a.path,
 					fork_materialization: a.fork_materialization,
 					derived_from: a.derived_from,
+					dbt: a.dbt,
 					onAddScript: onAddScriptForAsset,
 					pathPrefix,
 					defaultPathSuffix,
@@ -404,7 +437,32 @@
 					producerFailed,
 					// Bumped by the replay player when this asset's producer just
 					// recomputed it — the node flashes green and fades.
-					recomputePulse: recomputedAssetIds?.get(assetId)
+					recomputePulse: recomputedAssetIds?.get(assetId),
+					// What the run in view is doing to this relation right now.
+					runStatus: assetRunStatus?.get(assetId)?.status,
+					runRowCount: assetRunStatus?.get(assetId)?.rowCount,
+					// The dbt project that materializes this relation, related by
+					// badge rather than by an edge — so only when that node is on
+					// this graph. The run page and the pipeline page both hide it,
+					// and passing handlers anyway makes the chip advertise a click
+					// that resolves to nothing.
+					...(dbtOwnerByAsset.has(assetId)
+						? {
+								onDbtHover: (on: boolean) => (dbtHoverId = on ? assetId : undefined),
+								onDbtSelect: () => {
+									// `runnable:<kind>:<path>` — the id shape `build` uses.
+									const owner = model.dbtOwnerByAsset.get(assetId)
+									const [kind, ...rest] = owner?.split(':') ?? []
+									if (kind && rest.length) {
+										onselect?.({
+											kind: 'runnable',
+											runnable_kind: kind as 'script' | 'flow',
+											path: rest.join(':')
+										})
+									}
+								}
+							}
+						: {})
 				}
 			})
 		}
@@ -475,6 +533,8 @@
 					tag: r.tag,
 					retry: r.retry,
 					macros: r.macros,
+					dbt: r.dbt,
+					onDbtHover: (on: boolean) => (dbtHoverId = on ? rid : undefined),
 					unsaved: r.unsaved ?? false,
 					// Same dispatch the asset node uses, only routed when the
 					// runnable is a script (the page handler short-circuits
@@ -522,10 +582,28 @@
 		// (`// mute` / `// mute all` opted the default auto trigger out). Gated
 		// on pipeline scripts inside the helper (non-pipeline reads never derive).
 		const mutedReadKeys = computeMutedReadKeys(g.edges, g.triggers, g.runnables)
+		// A dbt script owns every relation of its project. Drawing that as one
+		// edge per model buries the lineage that matters (`ref()` between models,
+		// and native consumers) under a fan-out that grows with the project — so
+		// the association is carried by the node badge and its hover/click
+		// highlight instead. Only the DRAWING is dropped: the producer rows still
+		// drive cascade dispatch and "who produced this".
 		for (const e of g.edges) {
 			const runnableId = `${e.runnable_kind}:${e.runnable_path}`
 			const assetId = `asset:${e.asset_kind}:${e.asset_path}`
 			const access = e.access_type ?? 'r'
+			// A dbt project's own relations are related by badge, not by edges: its
+			// writes are the fan-out, and its declared sources already reach its
+			// models through the `ref()` edges, so both would be noise.
+			//
+			// A read of a relation ANOTHER script builds is different — that is how
+			// two selections of one project compose (decision 6), it carries the
+			// cascade, and no `ref()` edge survives the split to stand in for it.
+			// Kept, or the two halves render as disconnected islands.
+			if (dbtRunnableIds.has(runnableId)) {
+				const isOwnSource = dbtAssetProvenance.get(assetId)?.resource_type === 'source'
+				if (access === 'w' || access === 'rw' || isOwnSource) continue
+			}
 			if (access === 'w' || access === 'rw') {
 				// Data tests assert on the `// materialize` target, which is always
 				// a ducklake asset (v1 enforces this), so only the ducklake
@@ -621,6 +699,17 @@
 			})
 		}
 
+		// dbt `ref()` lineage: model → model inside one project. The dbt script
+		// writes every one of them, so without these the canvas shows a flat
+		// fan-out from the script and loses the project's actual shape.
+		const assetNodeIds = new Set(g.assets.map((a) => `asset:${a.kind}:${a.path}`))
+		for (const de of g.dbt_edges ?? []) {
+			const from = `asset:dbt:${de.from_asset_path}`
+			const to = `asset:dbt:${de.to_asset_path}`
+			if (!assetNodeIds.has(from) || !assetNodeIds.has(to)) continue
+			edges.push({ id: `dbtref:${from}->${to}`, source: from, target: to, kind: 'dbt-ref' })
+		}
+
 		// 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
@@ -787,11 +876,24 @@
 			}
 		}
 
-		return { nodes, edges }
+		return { nodes, edges, dbtOwnerByAsset, dbtWritesByOwner }
 	}
 
 	let model = $derived(build(graph))
 
+	// dbt association, surfaced by emphasis instead of edges. Hovering a model's
+	// dbt badge lights up the project node that materializes it; hovering the
+	// project node lights up every model it owns. Clicking the badge selects the
+	// project node, so the association survives the pointer leaving.
+	let dbtHoverId = $state<string | undefined>(undefined)
+	let dbtEmphasisIds = $derived.by(() => {
+		if (!dbtHoverId) return new Set<string>()
+		const owned = model.dbtWritesByOwner.get(dbtHoverId)
+		if (owned) return new Set<string>([dbtHoverId, ...owned])
+		const owner = model.dbtOwnerByAsset.get(dbtHoverId)
+		return owner ? new Set<string>([dbtHoverId, owner]) : new Set<string>()
+	})
+
 	let selectedId = $derived.by(() => {
 		if (!selection) return undefined
 		return selection.kind === 'asset'
@@ -895,12 +997,13 @@
 				else if (boundPick.bounded.has(n.id)) boundClass = 'wm-bound-in'
 				else if (!boundPick.eligible.has(n.id)) boundClass = 'wm-bound-dim'
 			}
+			const dbtClass = dbtEmphasisIds.has(n.id) ? 'wm-dbt-linked' : undefined
 			return {
 				id: n.id,
 				type: n.type,
 				position: { x: p.x + xCenter + xShift, y: p.y + 40 },
 				data: n.data,
-				class: boundClass ?? runClass ?? assetClass,
+				class: boundClass ?? dbtClass ?? runClass ?? assetClass,
 				selected: n.id === selectedId,
 				// All nodes non-draggable: the layout is sugiyama-computed,
 				// dragging would fight the reactive re-layout. Selection is
@@ -1064,6 +1167,21 @@
 						label = 'test needs'
 						labelStyle = 'fill: rgb(217 119 6); font-size: 10px; font-weight: 600;'
 						break
+					case 'dbt-ref':
+						// model → model inside one dbt project. Orange, matching the
+						// dbt badges, and dashed because the edge is dbt's own lineage
+						// rather than a Windmill read/write the cascade acts on.
+						style = 'stroke: rgb(234 88 12); stroke-width: 1.25px;'
+						strokeDasharray = '4 3'
+						markerColor = 'rgb(234 88 12)'
+						label = 'ref'
+						labelStyle = 'fill: rgb(234 88 12); font-size: 10px; font-weight: 600;'
+						// Same rule the pipeline uses for a running script: the edges
+						// touching what is happening animate. Here the unit of work is
+						// the model, so the edges feeding the one dbt is building move,
+						// and the flow reads in DAG order as it advances.
+						animated = assetRunStatus?.get(e.target)?.status === 'running'
+						break
 					default:
 						style = ''
 				}
@@ -1254,6 +1372,11 @@
 	/* Activity-panel emphasis — soft, monochromatic, less prominent than the
 	   blue details selection above. Hover is a thin neutral ring (transient);
 	   pinning an expanded run is a soft-blue ring. */
+	/* A dbt project node and the models it materializes, related by badge
+	   rather than by edges — hovering either lights up the whole set. */
+	:global(.svelte-flow__node.wm-dbt-linked .drop-shadow-sm) {
+		@apply outline outline-2 outline-orange-400/80;
+	}
 	:global(.svelte-flow__node.wm-run-hover .drop-shadow-sm) {
 		@apply outline outline-1 outline-gray-400 dark:outline-gray-500;
 	}
diff --git a/frontend/src/lib/components/assets/AssetGraph/AssetGraphDetailsPane.svelte b/frontend/src/lib/components/assets/AssetGraph/AssetGraphDetailsPane.svelte
index d48ecbe09e..2c5e5fd97e 100644
--- a/frontend/src/lib/components/assets/AssetGraph/AssetGraphDetailsPane.svelte
+++ b/frontend/src/lib/components/assets/AssetGraph/AssetGraphDetailsPane.svelte
@@ -27,7 +27,9 @@
 	import { inferArgs } from '$lib/infer'
 	import { emptySchema, sendUserToast } from '$lib/utils'
 	import type { Schema } from '$lib/common'
-	import type { AssetGraphSelection, PipelineMode } from './types'
+	import type { AssetGraphSelection, DbtAssetProvenance, PipelineMode } from './types'
+	import HighlightCode from '$lib/components/HighlightCode.svelte'
+	import DbtIcon from '$lib/components/icons/DbtIcon.svelte'
 	import PipelineScriptView from './PipelineScriptView.svelte'
 	import {
 		parsePipelineAnnotations,
@@ -154,6 +156,9 @@
 		// resolved graph). Drives the transitive column-lineage trace shown for a
 		// selected materialized asset.
 		selectionColumnGraph?: ColumnLineageGraph
+		/** dbt provenance of the selected relation, when a dbt project
+		 *  materializes it — carries the model's own SQL. */
+		selectionDbt?: DbtAssetProvenance
 		// Whether the selected ducklake asset's schema can evolve (whole-table
 		// `replace` producer). Forwarded to the Schema tab: version history when
 		// true, a single fixed-schema view when false. Defaults to true (unknown).
@@ -284,6 +289,7 @@
 		onScriptRemoved,
 		selectionProducers = [],
 		selectionColumnGraph,
+		selectionDbt,
 		schemaCanEvolve = true,
 		selectionForkMaterialization = undefined,
 		schemaContractContext = undefined,
@@ -426,6 +432,20 @@
 			)
 	)
 
+	// Where the selected model's file sits on disk: the producing script's
+	// module folder holds the dbt project verbatim, so this is the path a
+	// `wmill sync pull` writes and the one to edit.
+	let dbtBundlePath = $derived.by(() => {
+		const file = selectionDbt?.original_file_path
+		if (!file) return undefined
+		// A relation may have several script producers, and nothing here says which
+		// of them is the dbt project this model came from. Prefixing the wrong one
+		// names a `__dbt` folder that does not exist, so an ambiguous relation shows
+		// the path inside the project alone.
+		const scripts = selectionProducers.filter((p) => p.kind === 'script')
+		return scripts.length === 1 ? `${scripts[0].path}__dbt/${file}` : file
+	})
+
 	// Bound from ScriptEditor — populated by inferAssets on every code
 	// change. Forwarded to the page so the canvas can re-derive write
 	// edges as the user edits the body (e.g. renaming a CREATE TABLE
@@ -1216,6 +1236,25 @@
 										</div>
 									</div>
 								{/key}
+							{:else if selectionDbt?.raw_code}
+								<!-- The transform behind the node. Read-only on purpose: dbt
+								     development is a local loop (`dbt run --select`, `dbt test`
+								     against a dev target), and a browser textarea over one file
+								     of a project is a worse version of it. The header names the
+								     file's path in the bundle so the edit is one `cd` away. -->
+								<div class="flex flex-col h-full min-h-0">
+									<div
+										class="shrink-0 flex items-center gap-2 px-3 py-1.5 text-2xs border-b bg-surface-secondary text-secondary"
+									>
+										<DbtIcon width={11} height={11} />
+										<span class="font-mono truncate">{dbtBundlePath ?? selectionDbt.unique_id}</span
+										>
+										<span class="ml-auto shrink-0 opacity-70">read-only · edit locally</span>
+									</div>
+									<div class="flex-1 min-h-0 overflow-auto">
+										<HighlightCode language="sql" code={selectionDbt.raw_code} />
+									</div>
+								</div>
 							{:else}
 								<div class="p-3 text-xs text-secondary">
 									No inline preview yet for {selection.asset_kind}. Use the producer/consumer arrows
diff --git a/frontend/src/lib/components/assets/AssetGraph/AssetNode.svelte b/frontend/src/lib/components/assets/AssetGraph/AssetNode.svelte
index 999559a0c7..815db36b18 100644
--- a/frontend/src/lib/components/assets/AssetGraph/AssetNode.svelte
+++ b/frontend/src/lib/components/assets/AssetGraph/AssetNode.svelte
@@ -14,13 +14,17 @@
 		Loader2,
 		Plus,
 		ShieldCheck,
-		ShieldAlert
+		ShieldAlert,
+		CheckCircle2,
+		XCircle
 	} from 'lucide-svelte'
 	import type { ScriptLang } from '$lib/gen'
 	import { enterpriseLicense, workspaceStore } from '$lib/stores'
 	import { sendUserToast } from '$lib/utils'
 	import { PIPELINE_LANGUAGES } from './pipelineLanguages'
 	import type { PipelineOutputKind } from './pipelineTemplates'
+	import type { DbtAssetProvenance } from './types'
+	import DbtIcon from '$lib/components/icons/DbtIcon.svelte'
 
 	// Shape used for both the data prop and the run callback. Drafts carry
 	// `content` / `language` so the page-level run handler can dispatch to
@@ -44,6 +48,15 @@
 			// "current view of <dim>" marker so it reads as a derived node, not an
 			// unrelated table.
 			derived_from?: string
+			// dbt provenance when this warehouse table is a dbt node: which model
+			// it is, how dbt materializes it, its tags and its generic tests.
+			dbt?: DbtAssetProvenance
+			/** Hovering the dbt chip emphasizes the project node that
+			 *  materializes this model — the association the graph deliberately
+			 *  does not draw as an edge. */
+			onDbtHover?: (on: boolean) => void
+			/** Clicking it selects that project node. */
+			onDbtSelect?: () => void
 			onAddScript?: (
 				asset: { kind: AssetKind; path: string },
 				language: ScriptLang,
@@ -78,6 +91,11 @@
 			// producer just recomputed it. A change triggers a one-shot green
 			// fade so a freshly-written table stands out as the run progresses.
 			recomputePulse?: number
+			// What the run being viewed is doing to this relation. dbt records it
+			// per model as it walks the DAG, so the graph moves with the run
+			// instead of only settling once the job ends.
+			runStatus?: 'running' | 'materialized' | 'failed'
+			runRowCount?: number | null
 		}
 		// SvelteFlow injects this on the node component when the user clicks
 		// the node. Combined with our own `hovered` state to drive the
@@ -133,6 +151,40 @@
 
 	let showAdd = $derived(data.onAddScript != undefined)
 
+	// dbt badge. `materialized` is dbt's own word rather than the Windmill
+	// strategy because `view` and `ephemeral` have no strategy, and showing the
+	// dbt word keeps the node legible to someone reading their own project.
+	let dbtLabel = $derived(data.dbt?.materialized ?? data.dbt?.resource_type)
+	let dbtTitle = $derived.by(() => {
+		const d = data.dbt
+		if (!d) return ''
+		const lines = [`dbt ${d.resource_type}: ${d.unique_id}`]
+		if (d.materialized) {
+			const strategy = d.materialize_strategy ? ` -> ${d.materialize_strategy}` : ''
+			lines.push(`materialized: ${d.materialized}${strategy}`)
+		}
+		if (d.tags?.length) lines.push(`tags: ${d.tags.join(', ')}`)
+		for (const t of d.data_tests ?? []) {
+			const col = t.column ? ` on ${t.column}` : ''
+			lines.push(`test ${t.kind}${col}${t.severity ? ` [${t.severity}]` : ''}`)
+		}
+		const cols = Object.entries(d.columns ?? {})
+		if (cols.length) {
+			lines.push(
+				`columns: ${cols.map(([c, desc]) => (desc ? `${c} (${desc})` : c)).join(', ')}`
+			)
+		}
+		if (d.freshness) {
+			const f = d.freshness as Record<string, { count?: number; period?: string }>
+			const window = (k: string) =>
+				f[k]?.count != null ? `${k.replace('_after', '')} after ${f[k].count}${f[k].period?.[0] ?? ''}` : ''
+			const windows = ['warn_after', 'error_after'].map(window).filter(Boolean)
+			if (windows.length) lines.push(`freshness: ${windows.join(', ')}`)
+		}
+		if (d.description) lines.push(d.description)
+		return lines.join('\n')
+	})
+
 	// 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.
@@ -200,6 +252,39 @@
 			class={`shrink-0 ml-2 mr-2 ${selected ? 'text-accent' : 'text-blue-600 dark:text-blue-400'}`}
 			size="14px"
 		/>
+		{#if data.runStatus}
+			<!-- The run in view, per relation: a spinner while its producer is
+			     building it, then its outcome. Left of the name so the eye finds
+			     the moving nodes first on a wide graph. -->
+			<span
+				class="shrink-0 mr-1 {data.runStatus === 'failed'
+					? 'text-red-600 dark:text-red-400'
+					: data.runStatus === 'materialized'
+						? 'text-green-600 dark:text-green-400'
+						: 'text-blue-600 dark:text-blue-400'}"
+				title={data.runStatus}
+			>
+				{#if data.runStatus === 'running'}
+					<Loader2 size={11} class="animate-spin" />
+				{:else if data.runStatus === 'failed'}
+					<XCircle size={11} />
+				{:else}
+					<CheckCircle2 size={11} />
+				{/if}
+			</span>
+			<!-- Rows the run wrote. Recorded per relation already, and the cheapest
+			     answer to "did this model actually produce anything" — a model that
+			     built green but emitted 0 rows is the failure that looks like a
+			     success. Only once settled: mid-build the number is not yet real. -->
+			{#if data.runStatus === 'materialized' && data.runRowCount != undefined}
+				<span
+					class="shrink-0 mr-1 text-3xs tabular-nums text-tertiary"
+					title="{data.runRowCount} rows written by this run"
+				>
+					{Intl.NumberFormat().format(data.runRowCount)}
+				</span>
+			{/if}
+		{/if}
 		<span class="flex-1 min-w-0 pr-1 py-0.5 text-2xs font-mono text-emphasis truncate">
 			{formatShortAssetPath(asset)}
 		</span>
@@ -225,6 +310,34 @@
 				fork
 			</span>
 		{/if}
+		<!-- dbt chip: names the materialization dbt declares, plus a test count
+		     when the model carries generic tests. Orange keeps it visually
+		     separate from the fork/SCD2 chips, which describe Windmill state.
+		     Where the project node is on the graph it also stands in for the edge
+		     to it: hovering lights that node up, clicking selects it. Where it is
+		     not — the run page, and a pipeline holding a dbt project — there is
+		     nothing to point at, so the chip renders inert. -->
+		{#if data.dbt}
+			<button
+				type="button"
+				class="shrink-0 mr-1.5 flex items-center gap-0.5 rounded px-1 py-px text-3xs font-semibold tracking-wide bg-orange-100 dark:bg-orange-900/40 text-orange-700 dark:text-orange-300 border border-orange-300 dark:border-orange-700 {data.onDbtSelect
+					? 'hover:brightness-95 cursor-pointer'
+					: 'cursor-default'}"
+				title={dbtTitle}
+				onmouseenter={() => data.onDbtHover?.(true)}
+				onmouseleave={() => data.onDbtHover?.(false)}
+				onclick={(e) => {
+					e.stopPropagation()
+					data.onDbtSelect?.()
+				}}
+			>
+				<DbtIcon width={9} height={9} />
+				{dbtLabel}
+				{#if data.dbt.data_tests?.length}
+					<span class="opacity-70">&middot; {data.dbt.data_tests.length}T</span>
+				{/if}
+			</button>
+		{/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. -->
diff --git a/frontend/src/lib/components/assets/AssetGraph/PipelineGraphEditor.svelte b/frontend/src/lib/components/assets/AssetGraph/PipelineGraphEditor.svelte
index 7db35c2353..ec28b7c784 100644
--- a/frontend/src/lib/components/assets/AssetGraph/PipelineGraphEditor.svelte
+++ b/frontend/src/lib/components/assets/AssetGraph/PipelineGraphEditor.svelte
@@ -16,8 +16,7 @@
 		AssetGraphResponse,
 		AssetGraphSelection,
 		NativeTriggerKind,
-		PipelineMode
-	} from './types'
+		PipelineMode, DbtAssetProvenance } from './types'
 	import type { AssetKind, Script, ScriptLang } from '$lib/gen'
 	import type { RunnableRunState, PipelineEvent } from './activeRunnables.svelte'
 	import type { PipelineOutputKind } from './pipelineTemplates'
@@ -76,6 +75,7 @@
 		localScriptsVersion,
 		selectionProducers = [],
 		selectionColumnGraph,
+		selectionDbt,
 		schemaCanEvolve = true,
 		selectionForkMaterialization = undefined,
 		schemaContractContext = undefined,
@@ -181,6 +181,8 @@
 		selectionProducers?: Array<{ kind: 'script' | 'flow'; path: string; unsaved?: boolean }>
 		/** Transitive column-lineage trace for a selected ducklake asset (route page). */
 		selectionColumnGraph?: ColumnLineageGraph
+		/** dbt provenance of the selected relation — carries its SQL. */
+		selectionDbt?: DbtAssetProvenance
 		schemaCanEvolve?: boolean
 		/** Fork workspaces: data-environment state of the selected ducklake asset (route page). */
 		selectionForkMaterialization?: 'fork' | 'deferred'
@@ -512,6 +514,7 @@
 						selection={activeDraft ? undefined : editor.selection}
 						selectionProducers={activeDraft ? [] : selectionProducers}
 						{selectionColumnGraph}
+						{selectionDbt}
 						{schemaCanEvolve}
 						{selectionForkMaterialization}
 						{schemaContractContext}
diff --git a/frontend/src/lib/components/assets/AssetGraph/RunnableNode.svelte b/frontend/src/lib/components/assets/AssetGraph/RunnableNode.svelte
index d8a977539b..c260bc2e5b 100644
--- a/frontend/src/lib/components/assets/AssetGraph/RunnableNode.svelte
+++ b/frontend/src/lib/components/assets/AssetGraph/RunnableNode.svelte
@@ -18,6 +18,7 @@
 		XCircle,
 		Zap
 	} from 'lucide-svelte'
+	import DbtIcon from '$lib/components/icons/DbtIcon.svelte'
 	import { twMerge } from 'tailwind-merge'
 	import { preventDefault, stopPropagation } from 'svelte/legacy'
 	import type { GraphUsageKind } from './types'
@@ -45,6 +46,13 @@
 			// Macros this script provides (deployed/drafted `// macros` library).
 			// Non-empty renders the ƒ chip marking the node as a macro library.
 			macros?: { name: string; params: string; is_table: boolean }[]
+			// Set on a dbt script: the number of models the project materializes.
+			// One runnable node stands for the whole project, so the count is what
+			// tells it apart from a single-output script.
+			dbt?: { model_count: number }
+			/** Hovering the project badge emphasizes every model it
+			 *  materializes — the fan-out the graph deliberately omits. */
+			onDbtHover?: (on: boolean) => void
 			// Last-run status + run count observed this session (from the
 			// folder queue poll). Undefined until the first observed run.
 			runState?: RunnableRunState
@@ -188,7 +196,19 @@
 </script>
 
 <!-- svelte-ignore a11y_no_static_element_interactions -->
-<div class="relative" onmouseenter={() => (hover = true)} onmouseleave={() => (hover = false)}>
+<!-- Hovering anywhere on a dbt project node highlights the models it
+     materializes: the association the graph does not draw as edges. -->
+<div
+	class="relative"
+	onmouseenter={() => {
+		hover = true
+		data.onDbtHover?.(true)
+	}}
+	onmouseleave={() => {
+		hover = false
+		data.onDbtHover?.(false)
+	}}
+>
 	<!--
 		Mirrors the flow editor's step styling (getNodeColorClasses): muted
 		surface-tertiary fill with a quiet gray border, accent only for the
@@ -276,6 +296,15 @@
 				<span class="text-3xs leading-none">×{data.macros.length}</span>
 			</div>
 		{/if}
+		{#if data.dbt}
+			<div
+				class="shrink-0 flex items-center gap-0.5 px-1 py-0.5 mr-1 rounded-sm bg-orange-100 dark:bg-orange-900/40 text-orange-700 dark:text-orange-300"
+				title={`dbt project — materializes ${data.dbt.model_count} model${data.dbt.model_count === 1 ? '' : 's'}`}
+			>
+				<DbtIcon width={10} height={10} />
+				<span class="text-3xs leading-none">×{data.dbt.model_count}</span>
+			</div>
+		{/if}
 		{#if data.runState}
 			{@const rs = data.runState}
 			<div
diff --git a/frontend/src/lib/components/assets/AssetGraph/cascadeRun.ts b/frontend/src/lib/components/assets/AssetGraph/cascadeRun.ts
index 407dc886f9..e948eb2cf5 100644
--- a/frontend/src/lib/components/assets/AssetGraph/cascadeRun.ts
+++ b/frontend/src/lib/components/assets/AssetGraph/cascadeRun.ts
@@ -23,7 +23,7 @@ export const CASCADE_JOB_TIMEOUT_MS = 30 * 60 * 1000
 // Data-asset kinds a pipeline graph resolves — the `asset_kinds` filter for the
 // `/assets/graph` fetch. Shared so the pipeline editor and deploy-to-hub request
 // the same nodes/edges (and can't silently diverge when a kind is added).
-export const DATA_ASSET_KINDS = ['s3object', 'ducklake', 'datatable', 'volume']
+export const DATA_ASSET_KINDS = ['s3object', 'ducklake', 'datatable', 'volume', 'dbt']
 
 export type LocalScriptContent = {
 	content: string
diff --git a/frontend/src/lib/components/assets/AssetGraph/hideDbtRunnables.test.ts b/frontend/src/lib/components/assets/AssetGraph/hideDbtRunnables.test.ts
new file mode 100644
index 0000000000..1d4f8eb64d
--- /dev/null
+++ b/frontend/src/lib/components/assets/AssetGraph/hideDbtRunnables.test.ts
@@ -0,0 +1,99 @@
+import { describe, it, expect } from 'vitest'
+import { hideDbtRunnables } from './hideDbtRunnables'
+import type { AssetGraphResponse } from './types'
+
+// A folder holding both a dbt project (2 models, one of them a shared mart) and
+// a pipeline member that reads that mart.
+function graph(): AssetGraphResponse {
+	return {
+		assets: [
+			{ kind: 'dbt', path: 'u/a/wh/s/stg_orders', dbt: { unique_id: 'model.p.stg_orders' } },
+			{ kind: 'dbt', path: 'u/a/wh/s/fct_orders', dbt: { unique_id: 'model.p.fct_orders' } },
+			{ kind: 's3object', path: 'out.csv' }
+		] as AssetGraphResponse['assets'],
+		runnables: [
+			{ path: 'f/x/dbtproj', usage_kind: 'script', dbt: { model_count: 2 } },
+			{ path: 'f/x/report', usage_kind: 'script', in_pipeline: true }
+		],
+		edges: [
+			{
+				runnable_path: 'f/x/dbtproj',
+				runnable_kind: 'script',
+				asset_kind: 'dbt',
+				asset_path: 'u/a/wh/s/stg_orders',
+				access_type: 'w'
+			},
+			{
+				runnable_path: 'f/x/dbtproj',
+				runnable_kind: 'script',
+				asset_kind: 'dbt',
+				asset_path: 'u/a/wh/s/fct_orders',
+				access_type: 'w'
+			},
+			{
+				runnable_path: 'f/x/report',
+				runnable_kind: 'script',
+				asset_kind: 'dbt',
+				asset_path: 'u/a/wh/s/fct_orders',
+				access_type: 'r'
+			}
+		],
+		triggers: [
+			{
+				trigger_kind: 'asset',
+				asset_kind: 'dbt',
+				asset_path: 'u/a/wh/s/fct_orders',
+				runnable_kind: 'script',
+				runnable_path: 'f/x/report'
+			}
+		],
+		dbt_edges: [{ from_asset_path: 'u/a/wh/s/stg_orders', to_asset_path: 'u/a/wh/s/fct_orders' }]
+	}
+}
+
+describe('hideDbtRunnables', () => {
+	it('drops the dbt script node and its write edges', () => {
+		const g = hideDbtRunnables(graph())
+		expect(g.runnables.map((r) => r.path)).toEqual(['f/x/report'])
+		expect(g.edges.map((e) => e.runnable_path)).toEqual(['f/x/report'])
+	})
+
+	it('keeps every model and its ref() lineage — the tables are the pipeline’s business', () => {
+		const g = hideDbtRunnables(graph())
+		expect(g.assets).toHaveLength(3)
+		expect(g.dbt_edges).toHaveLength(1)
+		// The cascade edge from the mart to its consumer is what survives.
+		expect(g.triggers).toHaveLength(1)
+	})
+
+	it('keeps a flow that shares a path with the dbt script', () => {
+		// A script and a flow may share a path; the graph keys runnables by
+		// `(usage_kind, path)`, so only the dbt script may be removed.
+		const base = graph()
+		const g = hideDbtRunnables({
+			...base,
+			runnables: [...base.runnables, { path: 'f/x/dbtproj', usage_kind: 'flow', in_pipeline: true }],
+			edges: [
+				...base.edges,
+				{
+					runnable_path: 'f/x/dbtproj',
+					runnable_kind: 'flow',
+					asset_kind: 's3object',
+					asset_path: 'flow-out.csv',
+					access_type: 'w'
+				}
+			]
+		})
+		expect(g.runnables.map((r) => `${r.usage_kind}:${r.path}`).sort()).toEqual([
+			'flow:f/x/dbtproj',
+			'script:f/x/report'
+		])
+		expect(g.edges.some((e) => e.runnable_kind === 'flow')).toBe(true)
+	})
+
+	it('is a no-op on a folder with no dbt project', () => {
+		const base = graph()
+		const plain = { ...base, runnables: base.runnables.filter((r) => !r.dbt) }
+		expect(hideDbtRunnables(plain)).toBe(plain)
+	})
+})
diff --git a/frontend/src/lib/components/assets/AssetGraph/hideDbtRunnables.ts b/frontend/src/lib/components/assets/AssetGraph/hideDbtRunnables.ts
new file mode 100644
index 0000000000..7e819cedb9
--- /dev/null
+++ b/frontend/src/lib/components/assets/AssetGraph/hideDbtRunnables.ts
@@ -0,0 +1,40 @@
+import type { AssetGraphResponse } from './types'
+
+/**
+ * The pipeline's view of a folder that also holds a dbt project.
+ *
+ * The relations a dbt project materializes belong on this graph: they are what
+ * a pipeline script downstream of a mart reads, so the lineage into it is
+ * visible. The dbt *script* does not. It is not a pipeline member — it is
+ * authored in a local `dbt run` loop and has its own script and run pages — so
+ * rendering it beside the pipeline's own scripts is what blurs which of the two
+ * a folder holds.
+ *
+ * Its models stay, with their `ref()` lineage. Only the node is dropped.
+ */
+export function hideDbtRunnables(graph: AssetGraphResponse): AssetGraphResponse {
+	// Keyed by `(usage_kind, path)`, which is the graph's identity for a runnable
+	// — a script and a flow may share a path, and keying on path alone would take
+	// the flow's node, edges and triggers down with the dbt script's.
+	const key = (usage_kind: string, path: string) => `${usage_kind}:${path}`
+	const dbtRunnables = new Set(
+		graph.runnables.filter((r) => r.dbt).map((r) => key(r.usage_kind, r.path))
+	)
+	if (dbtRunnables.size === 0) return graph
+
+	const kept = (usage_kind: string, path: string) => !dbtRunnables.has(key(usage_kind, path))
+	return {
+		...graph,
+		runnables: graph.runnables.filter((r) => kept(r.usage_kind, r.path)),
+		edges: graph.edges.filter((e) => kept(e.runnable_kind, e.runnable_path)),
+		triggers: graph.triggers.filter((t) => kept(t.runnable_kind, t.runnable_path)),
+		// A macro library is a script; a dbt script defines no macros, so neither
+		// end can be a flow. Kept on the script key for symmetry with the rest.
+		macro_edges: graph.macro_edges?.filter(
+			(m) => kept('script', m.lib_path) && kept('script', m.consumer_path)
+		),
+		test_edges: graph.test_edges?.filter(
+			(t) => kept(t.producer_kind, t.producer_path) && kept(t.runnable_kind, t.runnable_path)
+		)
+	}
+}
diff --git a/frontend/src/lib/components/assets/AssetGraph/parsePipelineAnnotations.test.ts b/frontend/src/lib/components/assets/AssetGraph/parsePipelineAnnotations.test.ts
index 51aaf97f52..b608c91c76 100644
--- a/frontend/src/lib/components/assets/AssetGraph/parsePipelineAnnotations.test.ts
+++ b/frontend/src/lib/components/assets/AssetGraph/parsePipelineAnnotations.test.ts
@@ -233,3 +233,62 @@ describe('parseDurationSecs', () => {
 		expect(parseDurationSecs('999999999d')).toBeUndefined()
 	})
 })
+
+describe('dbt:// canonicalization', () => {
+	const readPath = (line: string) => parsePipelineAnnotations(line).triggerAssets?.[0]?.path
+
+	it('folds every spelling of a relation onto one key', () => {
+		const canonical = 'u/me/wh/analytics/orders'
+		expect(readPath('// on dbt://u/me/wh/Analytics/Orders')).toBe(canonical)
+		expect(readPath('// on dbt://u/me/wh/"Analytics"/"Orders"')).toBe(canonical)
+		expect(readPath('// on dbt://u/me/wh/`analytics`/`orders`')).toBe(canonical)
+		expect(readPath('// on dbt://u/me/wh/[Analytics]/[Orders]')).toBe(canonical)
+	})
+
+	it('unquotes each half of a qualified database.schema segment', () => {
+		// Only an unquoted period separates the two halves — the backend
+		// ingest keys the same relation as `archive.sales/orders`, so
+		// stripping just the outer quote pair would split the node in two.
+		expect(readPath('// on dbt://u/me/wh/"Archive"."Sales"/"Orders"')).toBe(
+			'u/me/wh/archive.sales/orders'
+		)
+	})
+
+	// Every dialect escapes its own delimiter by doubling it, and the worker and
+	// `canonicalize_table_asset_path` both decode it — a live annotation that did
+	// not would point the canvas at a different key than the deploy, which is two
+	// nodes for one table. The decoded spelling has to land there too: this
+	// function also sees names that have already been through `split_relation`.
+	it('decodes a doubled delimiter, and leaves a lone one alone', () => {
+		expect(readPath('// on dbt://u/me/wh/"sales""east"/"orders"')).toBe(
+			'u/me/wh/sales"east/orders'
+		)
+		expect(readPath('// on dbt://u/me/wh/analytics/"order""s"')).toBe(
+			'u/me/wh/analytics/order"s'
+		)
+		expect(readPath('// on dbt://u/me/wh/`da``ta`/`orders`')).toBe('u/me/wh/da`ta/orders')
+		expect(readPath('// on dbt://u/me/wh/[my]]schema]/[orders]')).toBe(
+			'u/me/wh/my]schema/orders'
+		)
+		// Already decoded: a lone delimiter is part of the name, not an opening
+		// quote, so both spellings agree.
+		expect(readPath('// on dbt://u/me/wh/sales"east/orders')).toBe(
+			readPath('// on dbt://u/me/wh/"sales""east"/"orders"')
+		)
+	})
+
+	// `canonicalize_table_asset_path` folds with `to_ascii_lowercase`, so this
+	// must too: full-Unicode folding turns `Sélection` into `sélection` here and
+	// `sÉlection` at deploy — two nodes for one table, which is the split this
+	// canonicalization exists to prevent. Every warehouse accepts such names.
+	it('folds case the way the deploy does, ASCII only', () => {
+		expect(readPath('// on dbt://u/me/wh/Sélection/Orders')).toBe('u/me/wh/sélection/orders')
+		expect(readPath('// on dbt://u/me/wh/ОТЧЁТ/Orders')).toBe('u/me/wh/ОТЧЁТ/orders')
+	})
+
+	it('leaves the resource path alone', () => {
+		expect(readPath('// on dbt://u/Me/WH/analytics/orders')).toBe(
+			'u/Me/WH/analytics/orders'
+		)
+	})
+})
diff --git a/frontend/src/lib/components/assets/AssetGraph/parsePipelineAnnotations.ts b/frontend/src/lib/components/assets/AssetGraph/parsePipelineAnnotations.ts
index 5fdbc4c748..e6384d9ddf 100644
--- a/frontend/src/lib/components/assets/AssetGraph/parsePipelineAnnotations.ts
+++ b/frontend/src/lib/components/assets/AssetGraph/parsePipelineAnnotations.ts
@@ -18,9 +18,84 @@ const ASSET_PREFIXES: Array<[string, AssetKind]> = [
 	['$res:', 'resource'],
 	['ducklake://', 'ducklake'],
 	['datatable://', 'datatable'],
-	['volume://', 'volume']
+	['volume://', 'volume'],
+	['dbt://', 'dbt']
 ]
 
+/** Canonical spelling of a `dbt://` path — mirror of
+ *  `canonicalize_table_asset_path` in the Rust parser, which is the single
+ *  place a relation becomes a graph key. The live editor must agree with it
+ *  exactly, or an annotation looks connected while typing and lands on a
+ *  different node at deploy. Strips the warehouses' quote characters from the
+ *  schema and name and folds their case; the warehouse-name prefix is spelled
+ *  as the workspace configures it and stays as written. */
+function canonicalizeTablePath(path: string): string {
+	const parts = path.split('/')
+	if (parts.length < 3) return path
+	const name = parts.pop()!
+	const schema = parts.pop()!
+	return [...parts, asciiLower(unquoteSegment(schema)), asciiLower(unquoteIdentifier(name))].join(
+		'/'
+	)
+}
+
+/** ASCII only, because `canonicalize_table_asset_path` folds with
+ *  `to_ascii_lowercase`. Full-Unicode `toLowerCase` disagrees on any accented or
+ *  Cyrillic identifier — every warehouse accepts those — and the deploy and the
+ *  live canvas would then canonicalize one table to two nodes, which is the
+ *  split this whole function exists to prevent. */
+function asciiLower(s: string): string {
+	return s.replace(/[A-Z]/g, (c) => c.toLowerCase())
+}
+
+/** Mirrors the worker's `unquote_identifier`, and must keep mirroring it: a quote
+ *  counts only when it wraps the WHOLE identifier — a lone one inside an
+ *  already-decoded name is part of the name — and a doubled delimiter inside a
+ *  quoted one is that delimiter, which is how every dialect escapes it. Disagree
+ *  with the backend here and the live canvas connects an annotation to a
+ *  different key than the deploy does, which is two nodes for one table. */
+function unquoteIdentifier(s: string): string {
+	const t = s.trim()
+	for (const [open, close] of [
+		['"', '"'],
+		['`', '`'],
+		['[', ']']
+	] as const) {
+		if (t.length >= 2 && t.startsWith(open) && t.endsWith(close)) {
+			return t.slice(1, -1).split(close + close).join(close)
+		}
+	}
+	return t
+}
+
+/** The schema segment carries a `<database>.<schema>` pair when a relation
+ *  overrode its database, and each half is separately quotable, so only an
+ *  UNQUOTED period separates them — one inside an identifier is part of the
+ *  name. Mirrors `unquote_schema_segment`. */
+function unquoteSegment(s: string): string {
+	const t = s.trim()
+	const parts: string[] = []
+	let start = 0
+	let quote: string | undefined = undefined
+	for (let i = 0; i < t.length; i++) {
+		const c = t[i]
+		if (quote !== undefined) {
+			const close = quote === '[' ? ']' : quote
+			if (c === close) {
+				if (t[i + 1] === close) i++
+				else quote = undefined
+			}
+		} else if ((c === '"' || c === '`' || c === '[') && i === start) {
+			quote = c
+		} else if (c === '.') {
+			parts.push(t.slice(start, i))
+			start = i + 1
+		}
+	}
+	parts.push(t.slice(start))
+	return parts.map(unquoteIdentifier).join('.')
+}
+
 // Native trigger keywords — `// on <kind>`. Each is marker-only: the
 // binding lives on the matching trigger row's own `script_path` field.
 // Schedule joins the family — the cron is stored on the schedule row the
@@ -277,11 +352,13 @@ function stripTrailingKvOpts(s: string): string {
 function parseAssetSyntax(s: string): PipelineTriggerAsset | undefined {
 	for (const [prefix, kind] of ASSET_PREFIXES) {
 		if (s.startsWith(prefix)) {
-			// The suffix is kept verbatim, mirroring the Rust `parse_asset_syntax`.
-			// For S3 the path encodes the storage: `s3:///key` yields `/key`
-			// (default storage, leading slash significant) while
-			// `s3://secondary/key` yields `secondary/key` — two different objects.
-			return { kind, path: s.slice(prefix.length) }
+			const suffix = s.slice(prefix.length)
+			// `dbt://` is canonicalized, every other kind's suffix is kept
+			// verbatim — mirroring the Rust `parse_asset_syntax`. For S3 the path
+			// encodes the storage: `s3:///key` yields `/key` (default storage,
+			// leading slash significant) while `s3://secondary/key` yields
+			// `secondary/key` — two different objects.
+			return { kind, path: kind === 'dbt' ? canonicalizeTablePath(suffix) : suffix }
 		}
 	}
 	return undefined
diff --git a/frontend/src/lib/components/assets/AssetGraph/pipelineTemplates.ts b/frontend/src/lib/components/assets/AssetGraph/pipelineTemplates.ts
index 1e26f2bb31..8c4fdc5d6d 100644
--- a/frontend/src/lib/components/assets/AssetGraph/pipelineTemplates.ts
+++ b/frontend/src/lib/components/assets/AssetGraph/pipelineTemplates.ts
@@ -118,7 +118,10 @@ const LANG_COMPATIBILITY: Record<ScriptLang, PipelineOutputKind[]> = {
 	bunnative: ['none'],
 	nativets: ['none'],
 	ruby: ['none'],
-	rlang: ['none']
+	rlang: ['none'],
+	// A dbt script's outputs come from its manifest, not from a Windmill
+	// template — the picker has nothing to generate for it.
+	dbt: ['none']
 }
 
 export function compatibleOutputKinds(lang: ScriptLang): PipelineOutputKind[] {
@@ -215,7 +218,8 @@ const ASSET_URI_PREFIX: Record<AssetKind, string> = {
 	resource: '$res:',
 	ducklake: 'ducklake://',
 	datatable: 'datatable://',
-	volume: 'volume://'
+	volume: 'volume://',
+	dbt: 'dbt://'
 }
 
 export function assetUri(asset: { kind: AssetKind; path: string }): string {
diff --git a/frontend/src/lib/components/assets/AssetGraph/resolveGraph.test.ts b/frontend/src/lib/components/assets/AssetGraph/resolveGraph.test.ts
index e35054beab..de00aef2be 100644
--- a/frontend/src/lib/components/assets/AssetGraph/resolveGraph.test.ts
+++ b/frontend/src/lib/components/assets/AssetGraph/resolveGraph.test.ts
@@ -1,5 +1,10 @@
 import { describe, expect, it } from 'vitest'
-import { resolveGraph, computeMutedReadKeys, type ResolveGraphInput } from './resolveGraph'
+import {
+	resolveGraph,
+	computeMutedReadKeys,
+	dbtAssociations,
+	type ResolveGraphInput
+} from './resolveGraph'
 import type { PipelineAnnotations } from './parsePipelineAnnotations'
 import type { AssetGraphResponse } from './types'
 import type { AssetWithAltAccessType } from '$lib/components/assets/lib'
@@ -1024,3 +1029,129 @@ describe('open saved script: live overlay vs inferred-lineage maps', () => {
 		).toHaveLength(1)
 	})
 })
+
+describe('dbtAssociations', () => {
+	const runnables = [
+		{ usage_kind: 'script', path: 'f/a/dbtproj', dbt: { model_count: 2 } },
+		{ usage_kind: 'script', path: 'f/a/consumer' }
+	]
+	const edges = [
+		// the project builds a model and reads a source
+		{
+			runnable_kind: 'script',
+			runnable_path: 'f/a/dbtproj',
+			asset_kind: 'dbt',
+			asset_path: 'wh/s/model_a',
+			access_type: 'w'
+		},
+		{
+			runnable_kind: 'script',
+			runnable_path: 'f/a/dbtproj',
+			asset_kind: 'dbt',
+			asset_path: 'wh/s/src_a',
+			access_type: 'r'
+		},
+		// a native consumer reads the model — its edges are none of dbt's business
+		{
+			runnable_kind: 'script',
+			runnable_path: 'f/a/consumer',
+			asset_kind: 'dbt',
+			asset_path: 'wh/s/model_a',
+			access_type: 'r'
+		}
+	]
+
+	it('points every declared relation back at its project', () => {
+		const { ownerByAsset } = dbtAssociations(runnables, edges)
+		// A source is declared by the project too, so its badge finds it.
+		expect(ownerByAsset.get('asset:dbt:wh/s/src_a')).toBe('script:f/a/dbtproj')
+		expect(ownerByAsset.get('asset:dbt:wh/s/model_a')).toBe('script:f/a/dbtproj')
+	})
+
+	it('counts only what the project materializes as its transforms', () => {
+		const { writesByOwner } = dbtAssociations(runnables, edges)
+		// Hovering the project highlights the models it builds, not its inputs.
+		expect([...(writesByOwner.get('script:f/a/dbtproj') ?? [])]).toEqual([
+			'asset:dbt:wh/s/model_a'
+		])
+	})
+
+	it('ignores runnables that are not dbt', () => {
+		const { ownerByAsset } = dbtAssociations([runnables[1]], edges)
+		expect(ownerByAsset.size).toBe(0)
+	})
+})
+
+describe('dbtAssociations with a producer and a consumer of one relation', () => {
+	const runnables = [
+		{ usage_kind: 'script', path: 'f/a/producer', dbt: { model_count: 1 } },
+		{ usage_kind: 'script', path: 'f/a/reader', dbt: { model_count: 1 } }
+	]
+	const write = {
+		runnable_kind: 'script',
+		runnable_path: 'f/a/producer',
+		asset_kind: 'dbt',
+		asset_path: 'wh/s/shared',
+		access_type: 'w'
+	}
+	const read = {
+		runnable_kind: 'script',
+		runnable_path: 'f/a/reader',
+		asset_kind: 'dbt',
+		asset_path: 'wh/s/shared',
+		access_type: 'r'
+	}
+
+	// Backend edge order is unspecified, so the badge must not depend on it.
+	it('always points at the project that builds the relation', () => {
+		for (const edges of [
+			[write, read],
+			[read, write]
+		]) {
+			const { ownerByAsset } = dbtAssociations(runnables, edges)
+			expect(ownerByAsset.get('asset:dbt:wh/s/shared')).toBe('script:f/a/producer')
+		}
+	})
+
+	it('falls back to a reader when nothing here produces the relation', () => {
+		const { ownerByAsset } = dbtAssociations(runnables, [read])
+		expect(ownerByAsset.get('asset:dbt:wh/s/shared')).toBe('script:f/a/reader')
+	})
+})
+
+// Two selections of one project materializing the same model is a shape the
+// backend permits, so the badge has to land on the same one every time — not on
+// whichever write edge the backend happened to return last.
+describe('dbtAssociations with two writers of one relation', () => {
+	const runnables = [
+		{ usage_kind: 'script', path: 'f/a/upstream', dbt: { model_count: 1 } },
+		{ usage_kind: 'script', path: 'f/a/downstream', dbt: { model_count: 1 } }
+	]
+	const writeBy = (p: string) => ({
+		runnable_kind: 'script',
+		runnable_path: p,
+		asset_kind: 'dbt',
+		asset_path: 'wh/s/shared',
+		access_type: 'w'
+	})
+
+	it('picks the same producer whatever order the edges arrive in', () => {
+		const a = writeBy('f/a/upstream')
+		const b = writeBy('f/a/downstream')
+		const first = dbtAssociations(runnables, [a, b]).ownerByAsset.get('asset:dbt:wh/s/shared')
+		const second = dbtAssociations(runnables, [b, a]).ownerByAsset.get('asset:dbt:wh/s/shared')
+		expect(first).toBe(second)
+		expect(first).toBe('script:f/a/downstream')
+	})
+
+	it('still credits both with materializing it', () => {
+		const { writesByOwner } = dbtAssociations(runnables, [
+			writeBy('f/a/upstream'),
+			writeBy('f/a/downstream')
+		])
+		expect(writesByOwner.get('script:f/a/upstream')).toEqual(new Set(['asset:dbt:wh/s/shared']))
+		expect(writesByOwner.get('script:f/a/downstream')).toEqual(
+			new Set(['asset:dbt:wh/s/shared'])
+		)
+	})
+})
diff --git a/frontend/src/lib/components/assets/AssetGraph/resolveGraph.ts b/frontend/src/lib/components/assets/AssetGraph/resolveGraph.ts
index 8ee0ca53d7..867fa6f036 100644
--- a/frontend/src/lib/components/assets/AssetGraph/resolveGraph.ts
+++ b/frontend/src/lib/components/assets/AssetGraph/resolveGraph.ts
@@ -75,9 +75,25 @@ function persistedNativeKinds(base: AssetGraphResponse, path: string): Set<strin
 
 // Read-asset kinds that auto-derive a cascade trigger edge inside a
 // `// pipeline`. Mirror of the backend `is_auto_trigger_kind`
-// (windmill-common assets.rs) — ducklake tables and s3 objects only.
+// (windmill-common assets.rs): ducklake tables and s3 objects.
+//
+// `table` is excluded there and must stay excluded here: dbt is the only
+// producer of a warehouse relation and a dbt run does not dispatch, so an edge
+// derived from one draws a cascade arrow the deploy will never fire.
 const AUTO_TRIGGER_KINDS: ReadonlySet<AssetKind> = new Set(['ducklake', 's3object'])
 
+/** Whether a subscription on this kind can ever fire once deployed.
+ *
+ * A `dbt://` one cannot: dbt is the only producer of a warehouse relation and
+ * a dbt run does not dispatch, so the deploy refuses `// on dbt://…` outright
+ * (`scripts.rs`). The editor must not draw an arrow the deploy will reject —
+ * applied to the EXPLICIT overlays; auto-derivation is already scoped by
+ * `AUTO_TRIGGER_KINDS`. Parsing is left alone so the Rust-parity test still
+ * compares like for like. */
+function canTrigger(kind: AssetKind): boolean {
+	return kind !== 'dbt'
+}
+
 /** `kind:path` refs of a script's `// materialize` write target(s) (base +
  *  the scd2 `<dim>_current` companion), which the body `SELECT` doesn't express. */
 function materializeWriteRefs(parsed: PipelineAnnotations): string[] {
@@ -365,7 +381,7 @@ function makeContext(input: ResolveGraphInput): ResolveContext {
 	const liveRefKeys = new Set<string>()
 	if (openIsSavedEdit) {
 		if (liveAnnotations.scriptPath === openPath) {
-			for (const a of liveAnnotations.annotations.triggerAssets)
+			for (const a of liveAnnotations.annotations.triggerAssets.filter((a) => canTrigger(a.kind)))
 				liveRefKeys.add(`${a.kind}:${a.path}`)
 			// The `// materialize <asset>` target is a declared *output*, but it
 			// lives in an annotation (not the SQL body), so neither triggerAssets
@@ -609,7 +625,7 @@ function seedDraftOverlays(acc: Accumulator, input: ResolveGraphInput) {
 		// stable when the user clicks off this draft. Live annotations
 		// (below) take over for the currently-open draft so keystroke
 		// edits still update in real time.
-		for (const a of parsed.triggerAssets) {
+		for (const a of parsed.triggerAssets.filter((a) => canTrigger(a.kind))) {
 			extraTriggers.push({
 				trigger_kind: 'asset',
 				asset_kind: a.kind,
@@ -688,7 +704,7 @@ function applyLiveBufferOverlay(acc: Accumulator, input: ResolveGraphInput, ctx:
 	for (let i = extraTriggers.length - 1; i >= 0; i--) {
 		if (extraTriggers[i].runnable_path === livePath) extraTriggers.splice(i, 1)
 	}
-	for (const a of liveAnnotations.annotations.triggerAssets) {
+	for (const a of liveAnnotations.annotations.triggerAssets.filter((a) => canTrigger(a.kind))) {
 		const key = `${a.kind}:${a.path}`
 		if (assetKeys.has(key)) continue
 		extraTriggers.push({
@@ -839,3 +855,60 @@ function overlayInferredLineage(acc: Accumulator, input: ResolveGraphInput) {
 	overlayLineage(inferredWritesByPath, 'w')
 	overlayLineage(inferredReadsByPath, 'r')
 }
+
+
+/** dbt project ↔ relation association, for a graph that does NOT draw it.
+ *
+ * A dbt script owns every relation of its project, so drawing one edge per
+ * model buries the lineage that matters — `ref()` between models, and native
+ * consumers — under a fan-out that grows with the project. The canvas suppresses
+ * those edges and conveys the association through the model's badge instead:
+ * `ownerByAsset` powers badge → project, `writesByOwner` powers project →
+ * the transforms it materializes (its sources are inputs, not transforms).
+ *
+ * Only the DRAWING is dropped. The producer rows these are derived from still
+ * answer "who produced this".
+ */
+export function dbtAssociations(
+	runnables: Array<{ usage_kind: string; path: string; dbt?: unknown }>,
+	edges: Array<{
+		runnable_kind: string
+		runnable_path: string
+		asset_kind: string
+		asset_path: string
+		access_type?: string | null
+	}>
+): { ownerByAsset: Map<string, string>; writesByOwner: Map<string, Set<string>> } {
+	const dbtRunnableIds = new Set(
+		runnables.filter((r) => r.dbt).map((r) => `${r.usage_kind}:${r.path}`)
+	)
+	const ownerByAsset = new Map<string, string>()
+	const writesByOwner = new Map<string, Set<string>>()
+	// Candidates per relation, kept apart so the choice does not depend on the
+	// order the edges arrive in. Two things decide it: a project that WRITES a
+	// relation outranks one that merely declares it as a SOURCE, and among
+	// several writers — which the backend permits, two selections of one project
+	// materializing the same model — the smallest id wins. Anything less makes
+	// the badge lead somewhere else between two loads of the same graph.
+	const writersByAsset = new Map<string, string[]>()
+	const readersByAsset = new Map<string, string[]>()
+	for (const e of edges) {
+		const runnableId = `${e.runnable_kind}:${e.runnable_path}`
+		if (!dbtRunnableIds.has(runnableId)) continue
+		const assetId = `asset:${e.asset_kind}:${e.asset_path}`
+		const writes = e.access_type === 'w' || e.access_type === 'rw'
+		const into = writes ? writersByAsset : readersByAsset
+		let candidates = into.get(assetId)
+		if (!candidates) into.set(assetId, (candidates = []))
+		candidates.push(runnableId)
+		if (writes) {
+			let set = writesByOwner.get(runnableId)
+			if (!set) writesByOwner.set(runnableId, (set = new Set()))
+			set.add(assetId)
+		}
+	}
+	for (const [assetId, candidates] of [...readersByAsset, ...writersByAsset]) {
+		ownerByAsset.set(assetId, [...candidates].sort()[0])
+	}
+	return { ownerByAsset, writesByOwner }
+}
diff --git a/frontend/src/lib/components/assets/AssetGraph/types.ts b/frontend/src/lib/components/assets/AssetGraph/types.ts
index d9ef2dafbf..e55340e586 100644
--- a/frontend/src/lib/components/assets/AssetGraph/types.ts
+++ b/frontend/src/lib/components/assets/AssetGraph/types.ts
@@ -16,6 +16,49 @@ export interface AssetGraphAssetNode {
 	// 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
+	// Set on a `dbt://` asset a dbt project produces (or, for a source,
+	// consumes). A dbt script is ONE runnable node with many model assets, so
+	// per-model metadata hangs off the asset, not off the script. Lockstep with
+	// Rust `GraphAssetNode.dbt`.
+	dbt?: DbtAssetProvenance
+}
+
+// Describes the RELATION, not a producer: several dbt scripts (different
+// selections of one project) can materialize the same model, and the producer
+// edges already name them.
+export interface DbtAssetProvenance {
+	unique_id: string
+	resource_type: 'model' | 'snapshot' | 'seed' | 'source' | (string & {})
+	// dbt's own word (`table`, `view`, `incremental`, `snapshot`). Kept because
+	// `view` and `ephemeral` have no Windmill write-strategy analogue.
+	materialized?: string
+	materialize_strategy?: 'replace' | 'append' | 'merge' | 'scd2'
+	tags?: string[]
+	description?: string
+	data_tests?: DbtDataTest[]
+	/** Declared column metadata (name -> description). NOT column lineage:
+	 *  `manifest.json` carries none (docs/dbt-runtime.md, decision 14). */
+	columns?: Record<string, string>
+	/** A source's declared freshness policy. */
+	freshness?: unknown
+	/** The model's SQL as written — the transform behind the node. Read-only:
+	 *  this is the copy taken at deploy, and the file itself lives in the
+	 *  producing script's `__dbt/` bundle. Absent for tests and for nodes with
+	 *  no body. */
+	raw_code?: string
+	/** Its path inside the dbt project, e.g. `models/staging/stg_orders.sql`. */
+	original_file_path?: string
+}
+
+export interface DbtDataTest {
+	// The four dbt generic tests map one-for-one onto the `// data_test` kinds;
+	// a package test keeps its namespaced name (`dbt_utils.accepted_range`).
+	kind: string
+	column?: string
+	args?: unknown
+	// Lowercased. dbt's own severity decides whether a failure fails the run,
+	// so the badge shows it rather than assuming every test is blocking.
+	severity?: string
 }
 
 export interface AssetGraphRunnableNode {
@@ -73,6 +116,10 @@ export interface AssetGraphRunnableNode {
 	// drives the "defines N macros" badge and the details-pane signature
 	// list. `params` is the verbatim parameter list.
 	macros?: { name: string; params: string; is_table: boolean }[]
+	// Set on a `ScriptLang::Dbt` script: it owns a whole dbt project, so the node
+	// says how many models it materializes rather than reading as a single-output
+	// script. Lockstep with Rust `GraphRunnableNode.dbt`.
+	dbt?: { model_count: number }
 	// Synthesized by the page from a local draft; the script doesn't exist
 	// in the DB yet. Drives a dashed/lower-opacity rendering to mirror how
 	// unsaved triggers are styled — visually distinct from persisted nodes.
@@ -176,6 +223,19 @@ export interface AssetGraphResponse {
 	triggers: AssetGraphTrigger[]
 	macro_edges?: AssetGraphMacroEdge[]
 	test_edges?: AssetGraphTestEdge[]
+	dbt_edges?: AssetGraphDbtEdge[]
+	/** The job whose snapshot the dbt half was resolved from, when one was
+	 *  asked for and found. A run page polls the graph until this is its own
+	 *  job, which is how it knows a dynamic descriptor's ingest has landed. */
+	dbt_snapshot_job?: string
+}
+
+// `ref()` lineage BETWEEN two dbt models, in the terms the canvas draws
+// (relations, not dbt node ids). Without these every model hangs off the one
+// dbt runnable, which reads as a flat fan-out rather than the project's shape.
+export interface AssetGraphDbtEdge {
+	from_asset_path: string
+	to_asset_path: string
 }
 
 export type AssetGraphNodeData =
@@ -196,3 +256,11 @@ export type AssetGraphSelection = AssetGraphNodeData
  * (default) or full editor. View can additionally overlay unsaved drafts
  * ("show drafts" chip) — a view variant, not a separate mode. */
 export type PipelineMode = 'view' | 'edit'
+
+/** What a run in view is doing to one relation, and what it produced. The row
+ *  count is the cheapest answer to "did this model actually output anything" —
+ *  the worker already records it per relation, so nothing extra is fetched. */
+export type AssetRunState = {
+	status: 'running' | 'materialized' | 'failed'
+	rowCount?: number | null
+}
diff --git a/frontend/src/lib/components/assets/lib.ts b/frontend/src/lib/components/assets/lib.ts
index 655f525c86..23531d71f2 100644
--- a/frontend/src/lib/components/assets/lib.ts
+++ b/frontend/src/lib/components/assets/lib.ts
@@ -28,6 +28,8 @@ export function formatAsset(asset: Asset): string {
 			return `datatable://${asset.path}`
 		case 'volume':
 			return `volume://${asset.path}`
+		case 'dbt':
+			return `dbt://${asset.path}`
 	}
 	return 'unknown'
 }
@@ -93,6 +95,12 @@ export function formatAssetKind(asset: {
 			return 'Data table'
 		case 'volume':
 			return 'Volume'
+		case 'dbt':
+			// The SCHEME says dbt because dbt is the only thing that creates one;
+			// the PATH stays the relation, so a mart one project builds and the
+			// `source` the next reads land on one node — their dbt `unique_id`s
+			// differ where the relation does not (docs/dbt-runtime.md, decision 11).
+			return 'dbt table'
 	}
 }
 
diff --git a/frontend/src/lib/components/common/languageIcons/LanguageIcon.svelte b/frontend/src/lib/components/common/languageIcons/LanguageIcon.svelte
index 09ff1082e6..617f5206dc 100644
--- a/frontend/src/lib/components/common/languageIcons/LanguageIcon.svelte
+++ b/frontend/src/lib/components/common/languageIcons/LanguageIcon.svelte
@@ -27,6 +27,7 @@
 	import RubyIcon from '$lib/components/icons/RubyIcon.svelte'
 	import RIcon from '$lib/components/icons/RIcon.svelte'
 	import ClaudeIcon from '$lib/components/icons/ClaudeIcon.svelte'
+	import DbtIcon from '$lib/components/icons/DbtIcon.svelte'
 
 	interface Props {
 		lang:
@@ -74,6 +75,7 @@
 		java: 'Java',
 		ruby: 'Ruby',
 		rlang: 'R',
+		dbt: 'dbt',
 		claudesandbox: 'Claude Sandbox'
 		// for related places search: ADD_NEW_LANG
 	}
@@ -111,6 +113,7 @@
 		ruby: RubyIcon,
 		rlang: RIcon,
 		duckdb: DuckDbIcon,
+		dbt: DbtIcon,
 		claudesandbox: TypeScriptIcon
 		// for related places search: ADD_NEW_LANG
 	}
diff --git a/frontend/src/lib/components/copilot/chat/flow/assetKind.test.ts b/frontend/src/lib/components/copilot/chat/flow/assetKind.test.ts
new file mode 100644
index 0000000000..7da70a2cc1
--- /dev/null
+++ b/frontend/src/lib/components/copilot/chat/flow/assetKind.test.ts
@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest'
+import { flowModulesSchema } from './openFlowZod.gen'
+
+// Guards against the generated copilot flow Zod schema (openFlowZod.gen.ts)
+// drifting from the asset `kind` enum in openflow.openapi.yaml. A missing kind
+// here rejects the whole flow module in the copilot editing path
+// (validateFlowModules -> flowModulesSchema), so an unrelated AI edit to a flow
+// containing a step that reads a warehouse table would fail.
+function rawScriptModuleWithAssetKind(kind: string) {
+	return {
+		id: 'a',
+		value: {
+			type: 'rawscript',
+			language: 'bun',
+			content: 'export async function main() {}',
+			input_transforms: {},
+			assets: [{ path: 'analytics.stg_orders', kind, access_type: 'r' }]
+		}
+	}
+}
+
+describe('copilot flow module validation - asset kind', () => {
+	it('accepts table (and the s3object baseline)', () => {
+		expect(flowModulesSchema.safeParse([rawScriptModuleWithAssetKind('s3object')]).success).toBe(
+			true
+		)
+		expect(flowModulesSchema.safeParse([rawScriptModuleWithAssetKind('dbt')]).success).toBe(true)
+	})
+
+	it('still rejects a kind the API does not define', () => {
+		expect(flowModulesSchema.safeParse([rawScriptModuleWithAssetKind('warehouse')]).success).toBe(
+			false
+		)
+	})
+})
diff --git a/frontend/src/lib/components/copilot/chat/flow/openFlowZod.gen.ts b/frontend/src/lib/components/copilot/chat/flow/openFlowZod.gen.ts
index 64cabda2bb..854b768479 100644
--- a/frontend/src/lib/components/copilot/chat/flow/openFlowZod.gen.ts
+++ b/frontend/src/lib/components/copilot/chat/flow/openFlowZod.gen.ts
@@ -1,6 +1,6 @@
 import { z } from "zod"
 
-export const flowModuleValueSchema = z.discriminatedUnion("type", [z.object({ "input_transforms": z.record(z.string(), z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs")).describe("Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments"), "content": z.string().describe("The script source code. Should export a 'main' function"), "language": z.enum(["deno","bun","bunnative","python3","go","bash","powershell","postgresql","mysql","bigquery","snowflake","mssql","oracledb","graphql","nativets","php","rust","ansible","csharp","nu","java","ruby","rlang","duckdb"]).describe("Programming language for this script"), "path": z.string().describe("Optional path for saving this script").optional(), "lock": z.string().describe("Lock file content for dependencies").optional(), "type": z.literal("rawscript"), "tag": z.string().describe("Worker group tag for execution routing").optional(), "concurrent_limit": z.number().describe("Maximum concurrent executions of this script").optional(), "concurrency_time_window_s": z.number().describe("Time window for concurrent_limit").optional(), "custom_concurrency_key": z.string().describe("Custom key for grouping concurrent executions").optional(), "is_trigger": z.boolean().describe("If true, this script is a trigger that can start the flow").optional(), "assets": z.array(z.object({ "path": z.string().describe("Path to the asset"), "kind": z.enum(["s3object","resource","ducklake","datatable","volume"]).describe("Type of asset"), "access_type": z.union([z.literal("r"), z.literal("w"), z.literal("rw"), z.literal(null)]).nullable().describe("Access level for this asset").optional(), "alt_access_type": z.union([z.literal("r"), z.literal("w"), z.literal("rw"), z.literal(null)]).nullable().describe("Alternative access level").optional() })).describe("External resources this script accesses (S3 objects, resources, etc.)").optional() }).describe("Inline script with code defined directly in the flow. Use 'bun' as default language if unspecified. The script receives arguments from input_transforms"), z.object({ "input_transforms": z.record(z.string(), z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs")).describe("Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments"), "path": z.string().describe("Path to the script in the workspace (e.g., 'f/scripts/send_email')"), "hash": z.string().describe("Optional specific version hash of the script to use").optional(), "type": z.literal("script"), "tag_override": z.string().describe("Override the script's default worker group tag").optional(), "is_trigger": z.boolean().describe("If true, this script is a trigger that can start the flow").optional() }).describe("Reference to an existing script by path. Use this when calling a previously saved script instead of writing inline code"), z.object({ "input_transforms": z.record(z.string(), z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs")).describe("Map of parameter names to their values (static or JavaScript expressions). These become the subflow's input arguments"), "path": z.string().describe("Path to the flow in the workspace (e.g., 'f/flows/process_user')"), "type": z.literal("flow") }).describe("Reference to an existing flow by path. Use this to call another flow as a subflow"), z.object({ "modules": z.array(z.object({ "id": z.string().describe("Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)"), "value": z.lazy(() => flowModuleValueSchema), "stop_after_if": z.object({ "skip_if_stopped": z.boolean().describe("If true, following steps are skipped when this condition triggers").optional(), "expr": z.string().describe("JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"), "error_message": z.string().nullable().describe("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.").optional(), "error_include_result": z.boolean().describe("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.").optional() }).describe("Early termination condition for a module").optional(), "stop_after_all_iters_if": z.object({ "skip_if_stopped": z.boolean().describe("If true, following steps are skipped when this condition triggers").optional(), "expr": z.string().describe("JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"), "error_message": z.string().nullable().describe("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.").optional(), "error_include_result": z.boolean().describe("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.").optional() }).describe("Early termination condition for a module").optional(), "skip_if": z.object({ "expr": z.string().describe("JavaScript expression that returns true to skip. Can use 'flow_input' or 'results.<step_id>'") }).describe("Conditionally skip this step based on previous results or flow inputs").optional(), "sleep": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "cache_ttl": z.number().describe("Cache duration in seconds for this step's results").optional(), "cache_ignore_s3_path": z.boolean().optional(), "timeout": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "delete_after_secs": z.number().int().describe("If set, delete the step's args, result and logs after this many seconds following job completion").optional(), "summary": z.string().describe("Short description of what this step does").optional(), "mock": z.object({ "enabled": z.boolean().describe("If true, return mock value instead of executing").optional(), "return_value": z.any().describe("Value to return when mocked").optional() }).describe("Mock configuration for testing without executing the actual step").optional(), "suspend": z.object({ "required_events": z.number().int().describe("Number of approvals required before continuing").optional(), "timeout": z.number().int().describe("Timeout in seconds before auto-continuing or canceling").optional(), "resume_form": z.object({ "schema": z.record(z.string(), z.any()).describe("JSON Schema for the resume form").optional() }).describe("Form schema for collecting input when resuming").optional(), "user_auth_required": z.boolean().describe("If true, only authenticated users can approve").optional(), "user_groups_required": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "self_approval_disabled": z.boolean().describe("If true, the user who started the flow cannot approve").optional(), "hide_cancel": z.boolean().describe("If true, hide the cancel button on the approval form").optional(), "continue_on_disapprove_timeout": z.boolean().describe("If true, continue flow on timeout instead of canceling").optional() }).describe("Configuration for approval/resume steps that wait for user input").optional(), "priority": z.number().describe("Execution priority for this step (higher numbers run first)").optional(), "continue_on_error": z.boolean().describe("If true, flow continues even if this step fails").optional(), "retry": z.object({ "constant": z.object({ "attempts": z.number().int().describe("Number of retry attempts").optional(), "seconds": z.number().int().describe("Seconds to wait between retries").optional() }).describe("Retry with constant delay between attempts").optional(), "exponential": z.object({ "attempts": z.number().int().describe("Number of retry attempts").optional(), "multiplier": z.number().int().describe("Multiplier for exponential backoff").optional(), "seconds": z.number().int().gte(1).describe("Initial delay in seconds").optional(), "random_factor": z.number().int().gte(0).lte(100).describe("Random jitter percentage (0-100) to avoid thundering herd").optional() }).describe("Retry with exponential backoff (delay doubles each time)").optional(), "retry_if": z.object({ "expr": z.string().describe("JavaScript expression that returns true to retry. Has access to 'result' and 'error' variables") }).describe("Conditional retry based on error or result").optional() }).describe("Retry configuration for failed module executions").optional(), "debouncing": z.object({ "debounce_delay_s": z.number().int().describe("Delay in seconds to debounce this step's executions across flow runs").optional(), "debounce_key": z.string().describe("Expression to group debounced executions. Supports $workspace and $args[name]. Default: $workspace/flow/<flow_path>-<step_id>").optional(), "debounce_args_to_accumulate": z.array(z.string()).describe("Array-type arguments to accumulate across debounced executions").optional(), "max_total_debouncing_time": z.number().int().describe("Maximum total time in seconds before forced execution").optional(), "max_total_debounces_amount": z.number().int().describe("Maximum number of debounces before forced execution").optional() }).describe("Debounce configuration for this step (EE only)").optional() }).describe("A single step in a flow. Can be a script, subflow, loop, or branch")).describe("Steps to execute for each iteration. These can reference the iteration value via 'flow_input.iter.value'"), "iterator": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs"), "skip_failures": z.boolean().describe("If true, iteration failures don't stop the loop. Failed iterations return null"), "type": z.literal("forloopflow"), "parallel": z.boolean().describe("If true, iterations run concurrently (faster for I/O-bound operations). Use with parallelism to control concurrency").optional(), "parallelism": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "squash": z.boolean().optional() }).describe("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"), z.object({ "modules": z.array(z.object({ "id": z.string().describe("Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)"), "value": z.lazy(() => flowModuleValueSchema), "stop_after_if": z.object({ "skip_if_stopped": z.boolean().describe("If true, following steps are skipped when this condition triggers").optional(), "expr": z.string().describe("JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"), "error_message": z.string().nullable().describe("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.").optional(), "error_include_result": z.boolean().describe("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.").optional() }).describe("Early termination condition for a module").optional(), "stop_after_all_iters_if": z.object({ "skip_if_stopped": z.boolean().describe("If true, following steps are skipped when this condition triggers").optional(), "expr": z.string().describe("JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"), "error_message": z.string().nullable().describe("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.").optional(), "error_include_result": z.boolean().describe("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.").optional() }).describe("Early termination condition for a module").optional(), "skip_if": z.object({ "expr": z.string().describe("JavaScript expression that returns true to skip. Can use 'flow_input' or 'results.<step_id>'") }).describe("Conditionally skip this step based on previous results or flow inputs").optional(), "sleep": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "cache_ttl": z.number().describe("Cache duration in seconds for this step's results").optional(), "cache_ignore_s3_path": z.boolean().optional(), "timeout": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "delete_after_secs": z.number().int().describe("If set, delete the step's args, result and logs after this many seconds following job completion").optional(), "summary": z.string().describe("Short description of what this step does").optional(), "mock": z.object({ "enabled": z.boolean().describe("If true, return mock value instead of executing").optional(), "return_value": z.any().describe("Value to return when mocked").optional() }).describe("Mock configuration for testing without executing the actual step").optional(), "suspend": z.object({ "required_events": z.number().int().describe("Number of approvals required before continuing").optional(), "timeout": z.number().int().describe("Timeout in seconds before auto-continuing or canceling").optional(), "resume_form": z.object({ "schema": z.record(z.string(), z.any()).describe("JSON Schema for the resume form").optional() }).describe("Form schema for collecting input when resuming").optional(), "user_auth_required": z.boolean().describe("If true, only authenticated users can approve").optional(), "user_groups_required": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "self_approval_disabled": z.boolean().describe("If true, the user who started the flow cannot approve").optional(), "hide_cancel": z.boolean().describe("If true, hide the cancel button on the approval form").optional(), "continue_on_disapprove_timeout": z.boolean().describe("If true, continue flow on timeout instead of canceling").optional() }).describe("Configuration for approval/resume steps that wait for user input").optional(), "priority": z.number().describe("Execution priority for this step (higher numbers run first)").optional(), "continue_on_error": z.boolean().describe("If true, flow continues even if this step fails").optional(), "retry": z.object({ "constant": z.object({ "attempts": z.number().int().describe("Number of retry attempts").optional(), "seconds": z.number().int().describe("Seconds to wait between retries").optional() }).describe("Retry with constant delay between attempts").optional(), "exponential": z.object({ "attempts": z.number().int().describe("Number of retry attempts").optional(), "multiplier": z.number().int().describe("Multiplier for exponential backoff").optional(), "seconds": z.number().int().gte(1).describe("Initial delay in seconds").optional(), "random_factor": z.number().int().gte(0).lte(100).describe("Random jitter percentage (0-100) to avoid thundering herd").optional() }).describe("Retry with exponential backoff (delay doubles each time)").optional(), "retry_if": z.object({ "expr": z.string().describe("JavaScript expression that returns true to retry. Has access to 'result' and 'error' variables") }).describe("Conditional retry based on error or result").optional() }).describe("Retry configuration for failed module executions").optional(), "debouncing": z.object({ "debounce_delay_s": z.number().int().describe("Delay in seconds to debounce this step's executions across flow runs").optional(), "debounce_key": z.string().describe("Expression to group debounced executions. Supports $workspace and $args[name]. Default: $workspace/flow/<flow_path>-<step_id>").optional(), "debounce_args_to_accumulate": z.array(z.string()).describe("Array-type arguments to accumulate across debounced executions").optional(), "max_total_debouncing_time": z.number().int().describe("Maximum total time in seconds before forced execution").optional(), "max_total_debounces_amount": z.number().int().describe("Maximum number of debounces before forced execution").optional() }).describe("Debounce configuration for this step (EE only)").optional() }).describe("A single step in a flow. Can be a script, subflow, loop, or branch")).describe("Steps to execute in each iteration"), "skip_failures": z.boolean().describe("If true, iteration failures don't stop the loop. Failed iterations return null"), "type": z.literal("whileloopflow"), "parallel": z.boolean().describe("If true, iterations run concurrently (use with caution in while loops)").optional(), "parallelism": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "squash": z.boolean().optional() }).describe("Executes nested modules repeatedly until stopped. The implicit iterator is the iteration counter, so 'flow_input.iter.value' equals 'flow_input.iter.index' (0, 1, 2, ...) and never carries state. To carry state across iterations, a step reads its own previous-iteration result via 'results.<its_own_id>' with a first-iteration fallback - the loop's stop_after_if must then be on that inner step (a plain single-step body with stop_after_if on the loop module does not resolve 'results' across iterations and never terminates); plain counters can instead be derived from 'flow_input.iter.index', which works in every configuration. stop_after_if is evaluated after each iteration - on the loop module 'result' is the last iteration's result"), z.object({ "branches": z.array(z.object({ "summary": z.string().describe("Short description of this branch condition").optional(), "expr": z.string().describe("JavaScript expression that returns boolean. Can use 'results.step_id' or 'flow_input'. First true expr wins"), "modules": z.array(z.object({ "id": z.string().describe("Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)"), "value": z.lazy(() => flowModuleValueSchema), "stop_after_if": z.object({ "skip_if_stopped": z.boolean().describe("If true, following steps are skipped when this condition triggers").optional(), "expr": z.string().describe("JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"), "error_message": z.string().nullable().describe("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.").optional(), "error_include_result": z.boolean().describe("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.").optional() }).describe("Early termination condition for a module").optional(), "stop_after_all_iters_if": z.object({ "skip_if_stopped": z.boolean().describe("If true, following steps are skipped when this condition triggers").optional(), "expr": z.string().describe("JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"), "error_message": z.string().nullable().describe("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.").optional(), "error_include_result": z.boolean().describe("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.").optional() }).describe("Early termination condition for a module").optional(), "skip_if": z.object({ "expr": z.string().describe("JavaScript expression that returns true to skip. Can use 'flow_input' or 'results.<step_id>'") }).describe("Conditionally skip this step based on previous results or flow inputs").optional(), "sleep": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "cache_ttl": z.number().describe("Cache duration in seconds for this step's results").optional(), "cache_ignore_s3_path": z.boolean().optional(), "timeout": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "delete_after_secs": z.number().int().describe("If set, delete the step's args, result and logs after this many seconds following job completion").optional(), "summary": z.string().describe("Short description of what this step does").optional(), "mock": z.object({ "enabled": z.boolean().describe("If true, return mock value instead of executing").optional(), "return_value": z.any().describe("Value to return when mocked").optional() }).describe("Mock configuration for testing without executing the actual step").optional(), "suspend": z.object({ "required_events": z.number().int().describe("Number of approvals required before continuing").optional(), "timeout": z.number().int().describe("Timeout in seconds before auto-continuing or canceling").optional(), "resume_form": z.object({ "schema": z.record(z.string(), z.any()).describe("JSON Schema for the resume form").optional() }).describe("Form schema for collecting input when resuming").optional(), "user_auth_required": z.boolean().describe("If true, only authenticated users can approve").optional(), "user_groups_required": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "self_approval_disabled": z.boolean().describe("If true, the user who started the flow cannot approve").optional(), "hide_cancel": z.boolean().describe("If true, hide the cancel button on the approval form").optional(), "continue_on_disapprove_timeout": z.boolean().describe("If true, continue flow on timeout instead of canceling").optional() }).describe("Configuration for approval/resume steps that wait for user input").optional(), "priority": z.number().describe("Execution priority for this step (higher numbers run first)").optional(), "continue_on_error": z.boolean().describe("If true, flow continues even if this step fails").optional(), "retry": z.object({ "constant": z.object({ "attempts": z.number().int().describe("Number of retry attempts").optional(), "seconds": z.number().int().describe("Seconds to wait between retries").optional() }).describe("Retry with constant delay between attempts").optional(), "exponential": z.object({ "attempts": z.number().int().describe("Number of retry attempts").optional(), "multiplier": z.number().int().describe("Multiplier for exponential backoff").optional(), "seconds": z.number().int().gte(1).describe("Initial delay in seconds").optional(), "random_factor": z.number().int().gte(0).lte(100).describe("Random jitter percentage (0-100) to avoid thundering herd").optional() }).describe("Retry with exponential backoff (delay doubles each time)").optional(), "retry_if": z.object({ "expr": z.string().describe("JavaScript expression that returns true to retry. Has access to 'result' and 'error' variables") }).describe("Conditional retry based on error or result").optional() }).describe("Retry configuration for failed module executions").optional(), "debouncing": z.object({ "debounce_delay_s": z.number().int().describe("Delay in seconds to debounce this step's executions across flow runs").optional(), "debounce_key": z.string().describe("Expression to group debounced executions. Supports $workspace and $args[name]. Default: $workspace/flow/<flow_path>-<step_id>").optional(), "debounce_args_to_accumulate": z.array(z.string()).describe("Array-type arguments to accumulate across debounced executions").optional(), "max_total_debouncing_time": z.number().int().describe("Maximum total time in seconds before forced execution").optional(), "max_total_debounces_amount": z.number().int().describe("Maximum number of debounces before forced execution").optional() }).describe("Debounce configuration for this step (EE only)").optional() }).describe("A single step in a flow. Can be a script, subflow, loop, or branch")).describe("Steps to execute if this branch's expr is true") })).describe("Array of branches to evaluate in order. The first branch with expr evaluating to true executes"), "default": z.array(z.object({ "id": z.string().describe("Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)"), "value": z.lazy(() => flowModuleValueSchema), "stop_after_if": z.object({ "skip_if_stopped": z.boolean().describe("If true, following steps are skipped when this condition triggers").optional(), "expr": z.string().describe("JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"), "error_message": z.string().nullable().describe("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.").optional(), "error_include_result": z.boolean().describe("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.").optional() }).describe("Early termination condition for a module").optional(), "stop_after_all_iters_if": z.object({ "skip_if_stopped": z.boolean().describe("If true, following steps are skipped when this condition triggers").optional(), "expr": z.string().describe("JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"), "error_message": z.string().nullable().describe("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.").optional(), "error_include_result": z.boolean().describe("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.").optional() }).describe("Early termination condition for a module").optional(), "skip_if": z.object({ "expr": z.string().describe("JavaScript expression that returns true to skip. Can use 'flow_input' or 'results.<step_id>'") }).describe("Conditionally skip this step based on previous results or flow inputs").optional(), "sleep": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "cache_ttl": z.number().describe("Cache duration in seconds for this step's results").optional(), "cache_ignore_s3_path": z.boolean().optional(), "timeout": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "delete_after_secs": z.number().int().describe("If set, delete the step's args, result and logs after this many seconds following job completion").optional(), "summary": z.string().describe("Short description of what this step does").optional(), "mock": z.object({ "enabled": z.boolean().describe("If true, return mock value instead of executing").optional(), "return_value": z.any().describe("Value to return when mocked").optional() }).describe("Mock configuration for testing without executing the actual step").optional(), "suspend": z.object({ "required_events": z.number().int().describe("Number of approvals required before continuing").optional(), "timeout": z.number().int().describe("Timeout in seconds before auto-continuing or canceling").optional(), "resume_form": z.object({ "schema": z.record(z.string(), z.any()).describe("JSON Schema for the resume form").optional() }).describe("Form schema for collecting input when resuming").optional(), "user_auth_required": z.boolean().describe("If true, only authenticated users can approve").optional(), "user_groups_required": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "self_approval_disabled": z.boolean().describe("If true, the user who started the flow cannot approve").optional(), "hide_cancel": z.boolean().describe("If true, hide the cancel button on the approval form").optional(), "continue_on_disapprove_timeout": z.boolean().describe("If true, continue flow on timeout instead of canceling").optional() }).describe("Configuration for approval/resume steps that wait for user input").optional(), "priority": z.number().describe("Execution priority for this step (higher numbers run first)").optional(), "continue_on_error": z.boolean().describe("If true, flow continues even if this step fails").optional(), "retry": z.object({ "constant": z.object({ "attempts": z.number().int().describe("Number of retry attempts").optional(), "seconds": z.number().int().describe("Seconds to wait between retries").optional() }).describe("Retry with constant delay between attempts").optional(), "exponential": z.object({ "attempts": z.number().int().describe("Number of retry attempts").optional(), "multiplier": z.number().int().describe("Multiplier for exponential backoff").optional(), "seconds": z.number().int().gte(1).describe("Initial delay in seconds").optional(), "random_factor": z.number().int().gte(0).lte(100).describe("Random jitter percentage (0-100) to avoid thundering herd").optional() }).describe("Retry with exponential backoff (delay doubles each time)").optional(), "retry_if": z.object({ "expr": z.string().describe("JavaScript expression that returns true to retry. Has access to 'result' and 'error' variables") }).describe("Conditional retry based on error or result").optional() }).describe("Retry configuration for failed module executions").optional(), "debouncing": z.object({ "debounce_delay_s": z.number().int().describe("Delay in seconds to debounce this step's executions across flow runs").optional(), "debounce_key": z.string().describe("Expression to group debounced executions. Supports $workspace and $args[name]. Default: $workspace/flow/<flow_path>-<step_id>").optional(), "debounce_args_to_accumulate": z.array(z.string()).describe("Array-type arguments to accumulate across debounced executions").optional(), "max_total_debouncing_time": z.number().int().describe("Maximum total time in seconds before forced execution").optional(), "max_total_debounces_amount": z.number().int().describe("Maximum number of debounces before forced execution").optional() }).describe("Debounce configuration for this step (EE only)").optional() }).describe("A single step in a flow. Can be a script, subflow, loop, or branch")).describe("Steps to execute if no branch expressions match"), "type": z.literal("branchone") }).describe("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"), z.object({ "branches": z.array(z.object({ "summary": z.string().describe("Short description of this branch's purpose").optional(), "skip_failure": z.boolean().describe("If true, failure in this branch doesn't fail the entire flow").optional(), "modules": z.array(z.object({ "id": z.string().describe("Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)"), "value": z.lazy(() => flowModuleValueSchema), "stop_after_if": z.object({ "skip_if_stopped": z.boolean().describe("If true, following steps are skipped when this condition triggers").optional(), "expr": z.string().describe("JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"), "error_message": z.string().nullable().describe("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.").optional(), "error_include_result": z.boolean().describe("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.").optional() }).describe("Early termination condition for a module").optional(), "stop_after_all_iters_if": z.object({ "skip_if_stopped": z.boolean().describe("If true, following steps are skipped when this condition triggers").optional(), "expr": z.string().describe("JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"), "error_message": z.string().nullable().describe("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.").optional(), "error_include_result": z.boolean().describe("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.").optional() }).describe("Early termination condition for a module").optional(), "skip_if": z.object({ "expr": z.string().describe("JavaScript expression that returns true to skip. Can use 'flow_input' or 'results.<step_id>'") }).describe("Conditionally skip this step based on previous results or flow inputs").optional(), "sleep": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "cache_ttl": z.number().describe("Cache duration in seconds for this step's results").optional(), "cache_ignore_s3_path": z.boolean().optional(), "timeout": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "delete_after_secs": z.number().int().describe("If set, delete the step's args, result and logs after this many seconds following job completion").optional(), "summary": z.string().describe("Short description of what this step does").optional(), "mock": z.object({ "enabled": z.boolean().describe("If true, return mock value instead of executing").optional(), "return_value": z.any().describe("Value to return when mocked").optional() }).describe("Mock configuration for testing without executing the actual step").optional(), "suspend": z.object({ "required_events": z.number().int().describe("Number of approvals required before continuing").optional(), "timeout": z.number().int().describe("Timeout in seconds before auto-continuing or canceling").optional(), "resume_form": z.object({ "schema": z.record(z.string(), z.any()).describe("JSON Schema for the resume form").optional() }).describe("Form schema for collecting input when resuming").optional(), "user_auth_required": z.boolean().describe("If true, only authenticated users can approve").optional(), "user_groups_required": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "self_approval_disabled": z.boolean().describe("If true, the user who started the flow cannot approve").optional(), "hide_cancel": z.boolean().describe("If true, hide the cancel button on the approval form").optional(), "continue_on_disapprove_timeout": z.boolean().describe("If true, continue flow on timeout instead of canceling").optional() }).describe("Configuration for approval/resume steps that wait for user input").optional(), "priority": z.number().describe("Execution priority for this step (higher numbers run first)").optional(), "continue_on_error": z.boolean().describe("If true, flow continues even if this step fails").optional(), "retry": z.object({ "constant": z.object({ "attempts": z.number().int().describe("Number of retry attempts").optional(), "seconds": z.number().int().describe("Seconds to wait between retries").optional() }).describe("Retry with constant delay between attempts").optional(), "exponential": z.object({ "attempts": z.number().int().describe("Number of retry attempts").optional(), "multiplier": z.number().int().describe("Multiplier for exponential backoff").optional(), "seconds": z.number().int().gte(1).describe("Initial delay in seconds").optional(), "random_factor": z.number().int().gte(0).lte(100).describe("Random jitter percentage (0-100) to avoid thundering herd").optional() }).describe("Retry with exponential backoff (delay doubles each time)").optional(), "retry_if": z.object({ "expr": z.string().describe("JavaScript expression that returns true to retry. Has access to 'result' and 'error' variables") }).describe("Conditional retry based on error or result").optional() }).describe("Retry configuration for failed module executions").optional(), "debouncing": z.object({ "debounce_delay_s": z.number().int().describe("Delay in seconds to debounce this step's executions across flow runs").optional(), "debounce_key": z.string().describe("Expression to group debounced executions. Supports $workspace and $args[name]. Default: $workspace/flow/<flow_path>-<step_id>").optional(), "debounce_args_to_accumulate": z.array(z.string()).describe("Array-type arguments to accumulate across debounced executions").optional(), "max_total_debouncing_time": z.number().int().describe("Maximum total time in seconds before forced execution").optional(), "max_total_debounces_amount": z.number().int().describe("Maximum number of debounces before forced execution").optional() }).describe("Debounce configuration for this step (EE only)").optional() }).describe("A single step in a flow. Can be a script, subflow, loop, or branch")).describe("Steps to execute in this branch") })).describe("Array of branches that all execute (either in parallel or sequentially)"), "type": z.literal("branchall"), "parallel": z.boolean().describe("If true, all branches execute concurrently. If false, they execute sequentially").optional() }).describe("Parallel branching where all branches execute simultaneously. Unlike BranchOne, all branches run regardless of conditions. Useful for executing independent tasks concurrently"), z.object({ "type": z.literal("identity"), "flow": z.boolean().describe("If true, marks this as a flow identity (special handling)").optional() }).describe("Pass-through module that returns its input unchanged. Useful for flow structure or as a placeholder"), z.object({ "input_transforms": z.object({ "provider": z.discriminatedUnion("type", [z.object({ "value": z.object({ "kind": z.enum(["openai","azure_openai","azure_foundry","anthropic","mistral","deepseek","googleai","groq","openrouter","togetherai","customai","aws_bedrock"]).describe("Supported AI provider types"), "resource": z.string().describe("Resource reference in format '$res:{resource_path}' pointing to provider credentials"), "model": z.string().describe("Model identifier (e.g., 'gpt-4', 'claude-3-opus-20240229', 'gemini-pro')"), "reasoning_effort": z.string().describe("Provider-native reasoning effort token (e.g. 'low', 'high', 'none') for models that support extended thinking. Optional; unset leaves the provider default.").optional() }).describe("Complete AI provider configuration with resource reference and model selection"), "type": z.literal("static") }).describe("Static provider configuration passed directly to the AI agent"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Provider configuration - can be static (ProviderConfig), JavaScript expression, or AI-determined").optional(), "output_type": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("Output format type.\nValid values: 'text' (default) - plain text response, 'image' - image generation\n").optional(), "user_message": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("The user's prompt/message to the AI agent. Supports variable interpolation with flow.input syntax."), "system_prompt": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("System instructions that guide the AI's behavior, persona, and response style. Optional.").optional(), "streaming": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("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").optional(), "memory": z.discriminatedUnion("type", [z.object({ "value": z.discriminatedUnion("kind", [z.object({ "kind": z.literal("off") }).describe("No conversation memory/context"), z.object({ "kind": z.literal("auto"), "context_length": z.number().int().describe("Maximum number of messages to retain in context").optional(), "memory_id": z.string().describe("Identifier for persistent memory across agent invocations").optional() }).describe("Automatic context management"), z.object({ "kind": z.literal("manual"), "messages": z.array(z.object({ "role": z.enum(["user","assistant","system"]), "content": z.string() }).describe("A single message in conversation history")) }).describe("Explicit message history")]).describe("Conversation memory configuration"), "type": z.literal("static") }).describe("Static memory configuration passed directly to the AI agent"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Memory configuration - can be static (MemoryConfig), JavaScript expression, or AI-determined").optional(), "output_schema": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("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").optional(), "user_attachments": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("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").optional(), "max_completion_tokens": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("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").optional(), "temperature": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("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").optional(), "max_iterations": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("Number. Limits how many times the agent can loop through reasoning and tool use.\nRange: 1-1000.\n").optional() }).describe("Input parameters for the AI agent mapped to their values"), "tools": z.array(z.object({ "id": z.string().describe("Unique identifier for this tool. Cannot contain spaces - use underscores instead (e.g., 'get_user_data' not 'get user data')"), "summary": z.string().describe("Short description of what this tool does (shown to the AI)").optional(), "description": z.string().describe("Free-text description of the tool given to the AI to decide when and how to call it. Overrides the description auto-derived from the underlying script.").optional(), "value": z.any().superRefine((x, ctx) => {
+export const flowModuleValueSchema = z.discriminatedUnion("type", [z.object({ "input_transforms": z.record(z.string(), z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs")).describe("Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments"), "content": z.string().describe("The script source code. Should export a 'main' function"), "language": z.enum(["deno","bun","bunnative","python3","go","bash","powershell","postgresql","mysql","bigquery","snowflake","mssql","oracledb","graphql","nativets","php","rust","ansible","csharp","nu","java","ruby","rlang","duckdb"]).describe("Programming language for this script"), "path": z.string().describe("Optional path for saving this script").optional(), "lock": z.string().describe("Lock file content for dependencies").optional(), "type": z.literal("rawscript"), "tag": z.string().describe("Worker group tag for execution routing").optional(), "concurrent_limit": z.number().describe("Maximum concurrent executions of this script").optional(), "concurrency_time_window_s": z.number().describe("Time window for concurrent_limit").optional(), "custom_concurrency_key": z.string().describe("Custom key for grouping concurrent executions").optional(), "is_trigger": z.boolean().describe("If true, this script is a trigger that can start the flow").optional(), "assets": z.array(z.object({ "path": z.string().describe("Path to the asset"), "kind": z.enum(["s3object","resource","ducklake","datatable","volume","dbt"]).describe("Type of asset"), "access_type": z.union([z.literal("r"), z.literal("w"), z.literal("rw"), z.literal(null)]).nullable().describe("Access level for this asset").optional(), "alt_access_type": z.union([z.literal("r"), z.literal("w"), z.literal("rw"), z.literal(null)]).nullable().describe("Alternative access level").optional() })).describe("External resources this script accesses (S3 objects, resources, etc.)").optional() }).describe("Inline script with code defined directly in the flow. Use 'bun' as default language if unspecified. The script receives arguments from input_transforms"), z.object({ "input_transforms": z.record(z.string(), z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs")).describe("Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments"), "path": z.string().describe("Path to the script in the workspace (e.g., 'f/scripts/send_email')"), "hash": z.string().describe("Optional specific version hash of the script to use").optional(), "type": z.literal("script"), "tag_override": z.string().describe("Override the script's default worker group tag").optional(), "is_trigger": z.boolean().describe("If true, this script is a trigger that can start the flow").optional() }).describe("Reference to an existing script by path. Use this when calling a previously saved script instead of writing inline code"), z.object({ "input_transforms": z.record(z.string(), z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs")).describe("Map of parameter names to their values (static or JavaScript expressions). These become the subflow's input arguments"), "path": z.string().describe("Path to the flow in the workspace (e.g., 'f/flows/process_user')"), "type": z.literal("flow") }).describe("Reference to an existing flow by path. Use this to call another flow as a subflow"), z.object({ "modules": z.array(z.object({ "id": z.string().describe("Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)"), "value": z.lazy(() => flowModuleValueSchema), "stop_after_if": z.object({ "skip_if_stopped": z.boolean().describe("If true, following steps are skipped when this condition triggers").optional(), "expr": z.string().describe("JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"), "error_message": z.string().nullable().describe("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.").optional(), "error_include_result": z.boolean().describe("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.").optional() }).describe("Early termination condition for a module").optional(), "stop_after_all_iters_if": z.object({ "skip_if_stopped": z.boolean().describe("If true, following steps are skipped when this condition triggers").optional(), "expr": z.string().describe("JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"), "error_message": z.string().nullable().describe("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.").optional(), "error_include_result": z.boolean().describe("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.").optional() }).describe("Early termination condition for a module").optional(), "skip_if": z.object({ "expr": z.string().describe("JavaScript expression that returns true to skip. Can use 'flow_input' or 'results.<step_id>'") }).describe("Conditionally skip this step based on previous results or flow inputs").optional(), "sleep": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "cache_ttl": z.number().describe("Cache duration in seconds for this step's results").optional(), "cache_ignore_s3_path": z.boolean().optional(), "timeout": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "delete_after_secs": z.number().int().describe("If set, delete the step's args, result and logs after this many seconds following job completion").optional(), "summary": z.string().describe("Short description of what this step does").optional(), "mock": z.object({ "enabled": z.boolean().describe("If true, return mock value instead of executing").optional(), "return_value": z.any().describe("Value to return when mocked").optional() }).describe("Mock configuration for testing without executing the actual step").optional(), "suspend": z.object({ "required_events": z.number().int().describe("Number of approvals required before continuing").optional(), "timeout": z.number().int().describe("Timeout in seconds before auto-continuing or canceling").optional(), "resume_form": z.object({ "schema": z.record(z.string(), z.any()).describe("JSON Schema for the resume form").optional() }).describe("Form schema for collecting input when resuming").optional(), "user_auth_required": z.boolean().describe("If true, only authenticated users can approve").optional(), "user_groups_required": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "self_approval_disabled": z.boolean().describe("If true, the user who started the flow cannot approve").optional(), "hide_cancel": z.boolean().describe("If true, hide the cancel button on the approval form").optional(), "continue_on_disapprove_timeout": z.boolean().describe("If true, continue flow on timeout instead of canceling").optional() }).describe("Configuration for approval/resume steps that wait for user input").optional(), "priority": z.number().describe("Execution priority for this step (higher numbers run first)").optional(), "continue_on_error": z.boolean().describe("If true, flow continues even if this step fails").optional(), "retry": z.object({ "constant": z.object({ "attempts": z.number().int().describe("Number of retry attempts").optional(), "seconds": z.number().int().describe("Seconds to wait between retries").optional() }).describe("Retry with constant delay between attempts").optional(), "exponential": z.object({ "attempts": z.number().int().describe("Number of retry attempts").optional(), "multiplier": z.number().int().describe("Multiplier for exponential backoff").optional(), "seconds": z.number().int().gte(1).describe("Initial delay in seconds").optional(), "random_factor": z.number().int().gte(0).lte(100).describe("Random jitter percentage (0-100) to avoid thundering herd").optional() }).describe("Retry with exponential backoff (delay doubles each time)").optional(), "retry_if": z.object({ "expr": z.string().describe("JavaScript expression that returns true to retry. Has access to 'result' and 'error' variables") }).describe("Conditional retry based on error or result").optional() }).describe("Retry configuration for failed module executions").optional(), "debouncing": z.object({ "debounce_delay_s": z.number().int().describe("Delay in seconds to debounce this step's executions across flow runs").optional(), "debounce_key": z.string().describe("Expression to group debounced executions. Supports $workspace and $args[name]. Default: $workspace/flow/<flow_path>-<step_id>").optional(), "debounce_args_to_accumulate": z.array(z.string()).describe("Array-type arguments to accumulate across debounced executions").optional(), "max_total_debouncing_time": z.number().int().describe("Maximum total time in seconds before forced execution").optional(), "max_total_debounces_amount": z.number().int().describe("Maximum number of debounces before forced execution").optional() }).describe("Debounce configuration for this step (EE only)").optional() }).describe("A single step in a flow. Can be a script, subflow, loop, or branch")).describe("Steps to execute for each iteration. These can reference the iteration value via 'flow_input.iter.value'"), "iterator": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs"), "skip_failures": z.boolean().describe("If true, iteration failures don't stop the loop. Failed iterations return null"), "type": z.literal("forloopflow"), "parallel": z.boolean().describe("If true, iterations run concurrently (faster for I/O-bound operations). Use with parallelism to control concurrency").optional(), "parallelism": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "squash": z.boolean().optional() }).describe("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"), z.object({ "modules": z.array(z.object({ "id": z.string().describe("Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)"), "value": z.lazy(() => flowModuleValueSchema), "stop_after_if": z.object({ "skip_if_stopped": z.boolean().describe("If true, following steps are skipped when this condition triggers").optional(), "expr": z.string().describe("JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"), "error_message": z.string().nullable().describe("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.").optional(), "error_include_result": z.boolean().describe("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.").optional() }).describe("Early termination condition for a module").optional(), "stop_after_all_iters_if": z.object({ "skip_if_stopped": z.boolean().describe("If true, following steps are skipped when this condition triggers").optional(), "expr": z.string().describe("JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"), "error_message": z.string().nullable().describe("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.").optional(), "error_include_result": z.boolean().describe("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.").optional() }).describe("Early termination condition for a module").optional(), "skip_if": z.object({ "expr": z.string().describe("JavaScript expression that returns true to skip. Can use 'flow_input' or 'results.<step_id>'") }).describe("Conditionally skip this step based on previous results or flow inputs").optional(), "sleep": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "cache_ttl": z.number().describe("Cache duration in seconds for this step's results").optional(), "cache_ignore_s3_path": z.boolean().optional(), "timeout": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "delete_after_secs": z.number().int().describe("If set, delete the step's args, result and logs after this many seconds following job completion").optional(), "summary": z.string().describe("Short description of what this step does").optional(), "mock": z.object({ "enabled": z.boolean().describe("If true, return mock value instead of executing").optional(), "return_value": z.any().describe("Value to return when mocked").optional() }).describe("Mock configuration for testing without executing the actual step").optional(), "suspend": z.object({ "required_events": z.number().int().describe("Number of approvals required before continuing").optional(), "timeout": z.number().int().describe("Timeout in seconds before auto-continuing or canceling").optional(), "resume_form": z.object({ "schema": z.record(z.string(), z.any()).describe("JSON Schema for the resume form").optional() }).describe("Form schema for collecting input when resuming").optional(), "user_auth_required": z.boolean().describe("If true, only authenticated users can approve").optional(), "user_groups_required": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "self_approval_disabled": z.boolean().describe("If true, the user who started the flow cannot approve").optional(), "hide_cancel": z.boolean().describe("If true, hide the cancel button on the approval form").optional(), "continue_on_disapprove_timeout": z.boolean().describe("If true, continue flow on timeout instead of canceling").optional() }).describe("Configuration for approval/resume steps that wait for user input").optional(), "priority": z.number().describe("Execution priority for this step (higher numbers run first)").optional(), "continue_on_error": z.boolean().describe("If true, flow continues even if this step fails").optional(), "retry": z.object({ "constant": z.object({ "attempts": z.number().int().describe("Number of retry attempts").optional(), "seconds": z.number().int().describe("Seconds to wait between retries").optional() }).describe("Retry with constant delay between attempts").optional(), "exponential": z.object({ "attempts": z.number().int().describe("Number of retry attempts").optional(), "multiplier": z.number().int().describe("Multiplier for exponential backoff").optional(), "seconds": z.number().int().gte(1).describe("Initial delay in seconds").optional(), "random_factor": z.number().int().gte(0).lte(100).describe("Random jitter percentage (0-100) to avoid thundering herd").optional() }).describe("Retry with exponential backoff (delay doubles each time)").optional(), "retry_if": z.object({ "expr": z.string().describe("JavaScript expression that returns true to retry. Has access to 'result' and 'error' variables") }).describe("Conditional retry based on error or result").optional() }).describe("Retry configuration for failed module executions").optional(), "debouncing": z.object({ "debounce_delay_s": z.number().int().describe("Delay in seconds to debounce this step's executions across flow runs").optional(), "debounce_key": z.string().describe("Expression to group debounced executions. Supports $workspace and $args[name]. Default: $workspace/flow/<flow_path>-<step_id>").optional(), "debounce_args_to_accumulate": z.array(z.string()).describe("Array-type arguments to accumulate across debounced executions").optional(), "max_total_debouncing_time": z.number().int().describe("Maximum total time in seconds before forced execution").optional(), "max_total_debounces_amount": z.number().int().describe("Maximum number of debounces before forced execution").optional() }).describe("Debounce configuration for this step (EE only)").optional() }).describe("A single step in a flow. Can be a script, subflow, loop, or branch")).describe("Steps to execute in each iteration"), "skip_failures": z.boolean().describe("If true, iteration failures don't stop the loop. Failed iterations return null"), "type": z.literal("whileloopflow"), "parallel": z.boolean().describe("If true, iterations run concurrently (use with caution in while loops)").optional(), "parallelism": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "squash": z.boolean().optional() }).describe("Executes nested modules repeatedly until stopped. The implicit iterator is the iteration counter, so 'flow_input.iter.value' equals 'flow_input.iter.index' (0, 1, 2, ...) and never carries state. To carry state across iterations, a step reads its own previous-iteration result via 'results.<its_own_id>' with a first-iteration fallback - the loop's stop_after_if must then be on that inner step (a plain single-step body with stop_after_if on the loop module does not resolve 'results' across iterations and never terminates); plain counters can instead be derived from 'flow_input.iter.index', which works in every configuration. stop_after_if is evaluated after each iteration - on the loop module 'result' is the last iteration's result"), z.object({ "branches": z.array(z.object({ "summary": z.string().describe("Short description of this branch condition").optional(), "expr": z.string().describe("JavaScript expression that returns boolean. Can use 'results.step_id' or 'flow_input'. First true expr wins"), "modules": z.array(z.object({ "id": z.string().describe("Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)"), "value": z.lazy(() => flowModuleValueSchema), "stop_after_if": z.object({ "skip_if_stopped": z.boolean().describe("If true, following steps are skipped when this condition triggers").optional(), "expr": z.string().describe("JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"), "error_message": z.string().nullable().describe("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.").optional(), "error_include_result": z.boolean().describe("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.").optional() }).describe("Early termination condition for a module").optional(), "stop_after_all_iters_if": z.object({ "skip_if_stopped": z.boolean().describe("If true, following steps are skipped when this condition triggers").optional(), "expr": z.string().describe("JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"), "error_message": z.string().nullable().describe("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.").optional(), "error_include_result": z.boolean().describe("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.").optional() }).describe("Early termination condition for a module").optional(), "skip_if": z.object({ "expr": z.string().describe("JavaScript expression that returns true to skip. Can use 'flow_input' or 'results.<step_id>'") }).describe("Conditionally skip this step based on previous results or flow inputs").optional(), "sleep": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "cache_ttl": z.number().describe("Cache duration in seconds for this step's results").optional(), "cache_ignore_s3_path": z.boolean().optional(), "timeout": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "delete_after_secs": z.number().int().describe("If set, delete the step's args, result and logs after this many seconds following job completion").optional(), "summary": z.string().describe("Short description of what this step does").optional(), "mock": z.object({ "enabled": z.boolean().describe("If true, return mock value instead of executing").optional(), "return_value": z.any().describe("Value to return when mocked").optional() }).describe("Mock configuration for testing without executing the actual step").optional(), "suspend": z.object({ "required_events": z.number().int().describe("Number of approvals required before continuing").optional(), "timeout": z.number().int().describe("Timeout in seconds before auto-continuing or canceling").optional(), "resume_form": z.object({ "schema": z.record(z.string(), z.any()).describe("JSON Schema for the resume form").optional() }).describe("Form schema for collecting input when resuming").optional(), "user_auth_required": z.boolean().describe("If true, only authenticated users can approve").optional(), "user_groups_required": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "self_approval_disabled": z.boolean().describe("If true, the user who started the flow cannot approve").optional(), "hide_cancel": z.boolean().describe("If true, hide the cancel button on the approval form").optional(), "continue_on_disapprove_timeout": z.boolean().describe("If true, continue flow on timeout instead of canceling").optional() }).describe("Configuration for approval/resume steps that wait for user input").optional(), "priority": z.number().describe("Execution priority for this step (higher numbers run first)").optional(), "continue_on_error": z.boolean().describe("If true, flow continues even if this step fails").optional(), "retry": z.object({ "constant": z.object({ "attempts": z.number().int().describe("Number of retry attempts").optional(), "seconds": z.number().int().describe("Seconds to wait between retries").optional() }).describe("Retry with constant delay between attempts").optional(), "exponential": z.object({ "attempts": z.number().int().describe("Number of retry attempts").optional(), "multiplier": z.number().int().describe("Multiplier for exponential backoff").optional(), "seconds": z.number().int().gte(1).describe("Initial delay in seconds").optional(), "random_factor": z.number().int().gte(0).lte(100).describe("Random jitter percentage (0-100) to avoid thundering herd").optional() }).describe("Retry with exponential backoff (delay doubles each time)").optional(), "retry_if": z.object({ "expr": z.string().describe("JavaScript expression that returns true to retry. Has access to 'result' and 'error' variables") }).describe("Conditional retry based on error or result").optional() }).describe("Retry configuration for failed module executions").optional(), "debouncing": z.object({ "debounce_delay_s": z.number().int().describe("Delay in seconds to debounce this step's executions across flow runs").optional(), "debounce_key": z.string().describe("Expression to group debounced executions. Supports $workspace and $args[name]. Default: $workspace/flow/<flow_path>-<step_id>").optional(), "debounce_args_to_accumulate": z.array(z.string()).describe("Array-type arguments to accumulate across debounced executions").optional(), "max_total_debouncing_time": z.number().int().describe("Maximum total time in seconds before forced execution").optional(), "max_total_debounces_amount": z.number().int().describe("Maximum number of debounces before forced execution").optional() }).describe("Debounce configuration for this step (EE only)").optional() }).describe("A single step in a flow. Can be a script, subflow, loop, or branch")).describe("Steps to execute if this branch's expr is true") })).describe("Array of branches to evaluate in order. The first branch with expr evaluating to true executes"), "default": z.array(z.object({ "id": z.string().describe("Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)"), "value": z.lazy(() => flowModuleValueSchema), "stop_after_if": z.object({ "skip_if_stopped": z.boolean().describe("If true, following steps are skipped when this condition triggers").optional(), "expr": z.string().describe("JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"), "error_message": z.string().nullable().describe("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.").optional(), "error_include_result": z.boolean().describe("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.").optional() }).describe("Early termination condition for a module").optional(), "stop_after_all_iters_if": z.object({ "skip_if_stopped": z.boolean().describe("If true, following steps are skipped when this condition triggers").optional(), "expr": z.string().describe("JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"), "error_message": z.string().nullable().describe("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.").optional(), "error_include_result": z.boolean().describe("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.").optional() }).describe("Early termination condition for a module").optional(), "skip_if": z.object({ "expr": z.string().describe("JavaScript expression that returns true to skip. Can use 'flow_input' or 'results.<step_id>'") }).describe("Conditionally skip this step based on previous results or flow inputs").optional(), "sleep": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "cache_ttl": z.number().describe("Cache duration in seconds for this step's results").optional(), "cache_ignore_s3_path": z.boolean().optional(), "timeout": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "delete_after_secs": z.number().int().describe("If set, delete the step's args, result and logs after this many seconds following job completion").optional(), "summary": z.string().describe("Short description of what this step does").optional(), "mock": z.object({ "enabled": z.boolean().describe("If true, return mock value instead of executing").optional(), "return_value": z.any().describe("Value to return when mocked").optional() }).describe("Mock configuration for testing without executing the actual step").optional(), "suspend": z.object({ "required_events": z.number().int().describe("Number of approvals required before continuing").optional(), "timeout": z.number().int().describe("Timeout in seconds before auto-continuing or canceling").optional(), "resume_form": z.object({ "schema": z.record(z.string(), z.any()).describe("JSON Schema for the resume form").optional() }).describe("Form schema for collecting input when resuming").optional(), "user_auth_required": z.boolean().describe("If true, only authenticated users can approve").optional(), "user_groups_required": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "self_approval_disabled": z.boolean().describe("If true, the user who started the flow cannot approve").optional(), "hide_cancel": z.boolean().describe("If true, hide the cancel button on the approval form").optional(), "continue_on_disapprove_timeout": z.boolean().describe("If true, continue flow on timeout instead of canceling").optional() }).describe("Configuration for approval/resume steps that wait for user input").optional(), "priority": z.number().describe("Execution priority for this step (higher numbers run first)").optional(), "continue_on_error": z.boolean().describe("If true, flow continues even if this step fails").optional(), "retry": z.object({ "constant": z.object({ "attempts": z.number().int().describe("Number of retry attempts").optional(), "seconds": z.number().int().describe("Seconds to wait between retries").optional() }).describe("Retry with constant delay between attempts").optional(), "exponential": z.object({ "attempts": z.number().int().describe("Number of retry attempts").optional(), "multiplier": z.number().int().describe("Multiplier for exponential backoff").optional(), "seconds": z.number().int().gte(1).describe("Initial delay in seconds").optional(), "random_factor": z.number().int().gte(0).lte(100).describe("Random jitter percentage (0-100) to avoid thundering herd").optional() }).describe("Retry with exponential backoff (delay doubles each time)").optional(), "retry_if": z.object({ "expr": z.string().describe("JavaScript expression that returns true to retry. Has access to 'result' and 'error' variables") }).describe("Conditional retry based on error or result").optional() }).describe("Retry configuration for failed module executions").optional(), "debouncing": z.object({ "debounce_delay_s": z.number().int().describe("Delay in seconds to debounce this step's executions across flow runs").optional(), "debounce_key": z.string().describe("Expression to group debounced executions. Supports $workspace and $args[name]. Default: $workspace/flow/<flow_path>-<step_id>").optional(), "debounce_args_to_accumulate": z.array(z.string()).describe("Array-type arguments to accumulate across debounced executions").optional(), "max_total_debouncing_time": z.number().int().describe("Maximum total time in seconds before forced execution").optional(), "max_total_debounces_amount": z.number().int().describe("Maximum number of debounces before forced execution").optional() }).describe("Debounce configuration for this step (EE only)").optional() }).describe("A single step in a flow. Can be a script, subflow, loop, or branch")).describe("Steps to execute if no branch expressions match"), "type": z.literal("branchone") }).describe("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"), z.object({ "branches": z.array(z.object({ "summary": z.string().describe("Short description of this branch's purpose").optional(), "skip_failure": z.boolean().describe("If true, failure in this branch doesn't fail the entire flow").optional(), "modules": z.array(z.object({ "id": z.string().describe("Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)"), "value": z.lazy(() => flowModuleValueSchema), "stop_after_if": z.object({ "skip_if_stopped": z.boolean().describe("If true, following steps are skipped when this condition triggers").optional(), "expr": z.string().describe("JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"), "error_message": z.string().nullable().describe("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.").optional(), "error_include_result": z.boolean().describe("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.").optional() }).describe("Early termination condition for a module").optional(), "stop_after_all_iters_if": z.object({ "skip_if_stopped": z.boolean().describe("If true, following steps are skipped when this condition triggers").optional(), "expr": z.string().describe("JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"), "error_message": z.string().nullable().describe("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.").optional(), "error_include_result": z.boolean().describe("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.").optional() }).describe("Early termination condition for a module").optional(), "skip_if": z.object({ "expr": z.string().describe("JavaScript expression that returns true to skip. Can use 'flow_input' or 'results.<step_id>'") }).describe("Conditionally skip this step based on previous results or flow inputs").optional(), "sleep": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "cache_ttl": z.number().describe("Cache duration in seconds for this step's results").optional(), "cache_ignore_s3_path": z.boolean().optional(), "timeout": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "delete_after_secs": z.number().int().describe("If set, delete the step's args, result and logs after this many seconds following job completion").optional(), "summary": z.string().describe("Short description of what this step does").optional(), "mock": z.object({ "enabled": z.boolean().describe("If true, return mock value instead of executing").optional(), "return_value": z.any().describe("Value to return when mocked").optional() }).describe("Mock configuration for testing without executing the actual step").optional(), "suspend": z.object({ "required_events": z.number().int().describe("Number of approvals required before continuing").optional(), "timeout": z.number().int().describe("Timeout in seconds before auto-continuing or canceling").optional(), "resume_form": z.object({ "schema": z.record(z.string(), z.any()).describe("JSON Schema for the resume form").optional() }).describe("Form schema for collecting input when resuming").optional(), "user_auth_required": z.boolean().describe("If true, only authenticated users can approve").optional(), "user_groups_required": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "self_approval_disabled": z.boolean().describe("If true, the user who started the flow cannot approve").optional(), "hide_cancel": z.boolean().describe("If true, hide the cancel button on the approval form").optional(), "continue_on_disapprove_timeout": z.boolean().describe("If true, continue flow on timeout instead of canceling").optional() }).describe("Configuration for approval/resume steps that wait for user input").optional(), "priority": z.number().describe("Execution priority for this step (higher numbers run first)").optional(), "continue_on_error": z.boolean().describe("If true, flow continues even if this step fails").optional(), "retry": z.object({ "constant": z.object({ "attempts": z.number().int().describe("Number of retry attempts").optional(), "seconds": z.number().int().describe("Seconds to wait between retries").optional() }).describe("Retry with constant delay between attempts").optional(), "exponential": z.object({ "attempts": z.number().int().describe("Number of retry attempts").optional(), "multiplier": z.number().int().describe("Multiplier for exponential backoff").optional(), "seconds": z.number().int().gte(1).describe("Initial delay in seconds").optional(), "random_factor": z.number().int().gte(0).lte(100).describe("Random jitter percentage (0-100) to avoid thundering herd").optional() }).describe("Retry with exponential backoff (delay doubles each time)").optional(), "retry_if": z.object({ "expr": z.string().describe("JavaScript expression that returns true to retry. Has access to 'result' and 'error' variables") }).describe("Conditional retry based on error or result").optional() }).describe("Retry configuration for failed module executions").optional(), "debouncing": z.object({ "debounce_delay_s": z.number().int().describe("Delay in seconds to debounce this step's executions across flow runs").optional(), "debounce_key": z.string().describe("Expression to group debounced executions. Supports $workspace and $args[name]. Default: $workspace/flow/<flow_path>-<step_id>").optional(), "debounce_args_to_accumulate": z.array(z.string()).describe("Array-type arguments to accumulate across debounced executions").optional(), "max_total_debouncing_time": z.number().int().describe("Maximum total time in seconds before forced execution").optional(), "max_total_debounces_amount": z.number().int().describe("Maximum number of debounces before forced execution").optional() }).describe("Debounce configuration for this step (EE only)").optional() }).describe("A single step in a flow. Can be a script, subflow, loop, or branch")).describe("Steps to execute in this branch") })).describe("Array of branches that all execute (either in parallel or sequentially)"), "type": z.literal("branchall"), "parallel": z.boolean().describe("If true, all branches execute concurrently. If false, they execute sequentially").optional() }).describe("Parallel branching where all branches execute simultaneously. Unlike BranchOne, all branches run regardless of conditions. Useful for executing independent tasks concurrently"), z.object({ "type": z.literal("identity"), "flow": z.boolean().describe("If true, marks this as a flow identity (special handling)").optional() }).describe("Pass-through module that returns its input unchanged. Useful for flow structure or as a placeholder"), z.object({ "input_transforms": z.object({ "provider": z.discriminatedUnion("type", [z.object({ "value": z.object({ "kind": z.enum(["openai","azure_openai","azure_foundry","anthropic","mistral","deepseek","googleai","groq","openrouter","togetherai","customai","aws_bedrock"]).describe("Supported AI provider types"), "resource": z.string().describe("Resource reference in format '$res:{resource_path}' pointing to provider credentials"), "model": z.string().describe("Model identifier (e.g., 'gpt-4', 'claude-3-opus-20240229', 'gemini-pro')"), "reasoning_effort": z.string().describe("Provider-native reasoning effort token (e.g. 'low', 'high', 'none') for models that support extended thinking. Optional; unset leaves the provider default.").optional() }).describe("Complete AI provider configuration with resource reference and model selection"), "type": z.literal("static") }).describe("Static provider configuration passed directly to the AI agent"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Provider configuration - can be static (ProviderConfig), JavaScript expression, or AI-determined").optional(), "output_type": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("Output format type.\nValid values: 'text' (default) - plain text response, 'image' - image generation\n").optional(), "user_message": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("The user's prompt/message to the AI agent. Supports variable interpolation with flow.input syntax."), "system_prompt": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("System instructions that guide the AI's behavior, persona, and response style. Optional.").optional(), "streaming": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("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").optional(), "memory": z.discriminatedUnion("type", [z.object({ "value": z.discriminatedUnion("kind", [z.object({ "kind": z.literal("off") }).describe("No conversation memory/context"), z.object({ "kind": z.literal("auto"), "context_length": z.number().int().describe("Maximum number of messages to retain in context").optional(), "memory_id": z.string().describe("Identifier for persistent memory across agent invocations").optional() }).describe("Automatic context management"), z.object({ "kind": z.literal("manual"), "messages": z.array(z.object({ "role": z.enum(["user","assistant","system"]), "content": z.string() }).describe("A single message in conversation history")) }).describe("Explicit message history")]).describe("Conversation memory configuration"), "type": z.literal("static") }).describe("Static memory configuration passed directly to the AI agent"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Memory configuration - can be static (MemoryConfig), JavaScript expression, or AI-determined").optional(), "output_schema": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("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").optional(), "user_attachments": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("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").optional(), "max_completion_tokens": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("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").optional(), "temperature": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("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").optional(), "max_iterations": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("Number. Limits how many times the agent can loop through reasoning and tool use.\nRange: 1-1000.\n").optional() }).describe("Input parameters for the AI agent mapped to their values"), "tools": z.array(z.object({ "id": z.string().describe("Unique identifier for this tool. Cannot contain spaces - use underscores instead (e.g., 'get_user_data' not 'get user data')"), "summary": z.string().describe("Short description of what this tool does (shown to the AI)").optional(), "description": z.string().describe("Free-text description of the tool given to the AI to decide when and how to call it. Overrides the description auto-derived from the underlying script.").optional(), "value": z.any().superRefine((x, ctx) => {
     const schemas = [z.intersection(z.object({ "tool_type": z.literal("flowmodule") }), z.lazy(() => flowModuleValueSchema)).describe("A tool implemented as a flow module (script, flow, etc.). The AI can call this like any other flow module"), z.object({ "tool_type": z.literal("mcp"), "resource_path": z.string().describe("Path to the MCP resource/server configuration"), "include_tools": z.array(z.string()).describe("Whitelist of specific tools to include from this MCP server").optional(), "exclude_tools": z.array(z.string()).describe("Blacklist of tools to exclude from this MCP server").optional() }).describe("Reference to an external MCP (Model Context Protocol) tool. The AI can call tools from MCP servers"), z.object({ "tool_type": z.literal("websearch") }).describe("A tool implemented as a websearch tool. The AI can call this like any other websearch tool")];
     const errors = schemas.reduce<z.ZodError[]>(
       (errors, schema) =>
@@ -20,7 +20,7 @@ export const flowModuleValueSchema = z.discriminatedUnion("type", [z.object({ "i
   }).describe("The implementation of a tool. Can be a flow module (script/flow) or an MCP tool reference") }).describe("A tool available to an AI agent. Can be a flow module or an external MCP (Model Context Protocol) tool")).describe("Array of tools the agent can use. The agent decides which tools to call based on the task").optional(), "type": z.literal("aiagent"), "tag": z.string().describe("Worker group tag for execution routing. If not set, the AI agent step runs on the flow's tag (default `flow`)").optional(), "omit_output_from_conversation": z.boolean().describe("If true, this AI agent step does not persist its assistant or tool messages to the flow conversation when chat mode is enabled.").default(false), "agent": z.string().describe("Path of a reusable `ai_agent` resource (hybrid linking). When set, the agent brain\nconfig (provider/model/system prompt/etc.) and tool set are resolved at runtime from\nthat resource; the module's input_transforms then only carry the flow-local inputs\n(user_message/user_attachments).\n").optional(), "tool_inputs": z.record(z.string(), z.record(z.string(), z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs"))).describe("Host-local wiring for an agent's tool inputs, keyed by tool id then input key. Binds the\nreferenced agent's tools to this flow's context (flow_input/results) without mutating the\nshared resource; overlaid onto the tools' input_transforms at runtime — including when\n`agent` is unset, since a step forked for editing keeps these overrides until it is saved\nback or unlinked.\n").optional(), "parallel": z.boolean().describe("If true, the agent can execute multiple tool calls in parallel").optional() }).describe("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")]).describe("The actual implementation of a flow step. Can be a script (inline or referenced), subflow, loop, branch, or special module type")
 
 
-export const flowModuleSchema = z.object({ "id": z.string().describe("Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)"), "value": z.discriminatedUnion("type", [z.object({ "input_transforms": z.record(z.string(), z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs")).describe("Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments"), "content": z.string().describe("The script source code. Should export a 'main' function"), "language": z.enum(["deno","bun","bunnative","python3","go","bash","powershell","postgresql","mysql","bigquery","snowflake","mssql","oracledb","graphql","nativets","php","rust","ansible","csharp","nu","java","ruby","rlang","duckdb"]).describe("Programming language for this script"), "path": z.string().describe("Optional path for saving this script").optional(), "lock": z.string().describe("Lock file content for dependencies").optional(), "type": z.literal("rawscript"), "tag": z.string().describe("Worker group tag for execution routing").optional(), "concurrent_limit": z.number().describe("Maximum concurrent executions of this script").optional(), "concurrency_time_window_s": z.number().describe("Time window for concurrent_limit").optional(), "custom_concurrency_key": z.string().describe("Custom key for grouping concurrent executions").optional(), "is_trigger": z.boolean().describe("If true, this script is a trigger that can start the flow").optional(), "assets": z.array(z.object({ "path": z.string().describe("Path to the asset"), "kind": z.enum(["s3object","resource","ducklake","datatable","volume"]).describe("Type of asset"), "access_type": z.union([z.literal("r"), z.literal("w"), z.literal("rw"), z.literal(null)]).nullable().describe("Access level for this asset").optional(), "alt_access_type": z.union([z.literal("r"), z.literal("w"), z.literal("rw"), z.literal(null)]).nullable().describe("Alternative access level").optional() })).describe("External resources this script accesses (S3 objects, resources, etc.)").optional() }).describe("Inline script with code defined directly in the flow. Use 'bun' as default language if unspecified. The script receives arguments from input_transforms"), z.object({ "input_transforms": z.record(z.string(), z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs")).describe("Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments"), "path": z.string().describe("Path to the script in the workspace (e.g., 'f/scripts/send_email')"), "hash": z.string().describe("Optional specific version hash of the script to use").optional(), "type": z.literal("script"), "tag_override": z.string().describe("Override the script's default worker group tag").optional(), "is_trigger": z.boolean().describe("If true, this script is a trigger that can start the flow").optional() }).describe("Reference to an existing script by path. Use this when calling a previously saved script instead of writing inline code"), z.object({ "input_transforms": z.record(z.string(), z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs")).describe("Map of parameter names to their values (static or JavaScript expressions). These become the subflow's input arguments"), "path": z.string().describe("Path to the flow in the workspace (e.g., 'f/flows/process_user')"), "type": z.literal("flow") }).describe("Reference to an existing flow by path. Use this to call another flow as a subflow"), z.object({ "modules": z.array(z.lazy(() => flowModuleSchema)).describe("Steps to execute for each iteration. These can reference the iteration value via 'flow_input.iter.value'"), "iterator": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs"), "skip_failures": z.boolean().describe("If true, iteration failures don't stop the loop. Failed iterations return null"), "type": z.literal("forloopflow"), "parallel": z.boolean().describe("If true, iterations run concurrently (faster for I/O-bound operations). Use with parallelism to control concurrency").optional(), "parallelism": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "squash": z.boolean().optional() }).describe("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"), z.object({ "modules": z.array(z.lazy(() => flowModuleSchema)).describe("Steps to execute in each iteration"), "skip_failures": z.boolean().describe("If true, iteration failures don't stop the loop. Failed iterations return null"), "type": z.literal("whileloopflow"), "parallel": z.boolean().describe("If true, iterations run concurrently (use with caution in while loops)").optional(), "parallelism": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "squash": z.boolean().optional() }).describe("Executes nested modules repeatedly until stopped. The implicit iterator is the iteration counter, so 'flow_input.iter.value' equals 'flow_input.iter.index' (0, 1, 2, ...) and never carries state. To carry state across iterations, a step reads its own previous-iteration result via 'results.<its_own_id>' with a first-iteration fallback - the loop's stop_after_if must then be on that inner step (a plain single-step body with stop_after_if on the loop module does not resolve 'results' across iterations and never terminates); plain counters can instead be derived from 'flow_input.iter.index', which works in every configuration. stop_after_if is evaluated after each iteration - on the loop module 'result' is the last iteration's result"), z.object({ "branches": z.array(z.object({ "summary": z.string().describe("Short description of this branch condition").optional(), "expr": z.string().describe("JavaScript expression that returns boolean. Can use 'results.step_id' or 'flow_input'. First true expr wins"), "modules": z.array(z.lazy(() => flowModuleSchema)).describe("Steps to execute if this branch's expr is true") })).describe("Array of branches to evaluate in order. The first branch with expr evaluating to true executes"), "default": z.array(z.lazy(() => flowModuleSchema)).describe("Steps to execute if no branch expressions match"), "type": z.literal("branchone") }).describe("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"), z.object({ "branches": z.array(z.object({ "summary": z.string().describe("Short description of this branch's purpose").optional(), "skip_failure": z.boolean().describe("If true, failure in this branch doesn't fail the entire flow").optional(), "modules": z.array(z.lazy(() => flowModuleSchema)).describe("Steps to execute in this branch") })).describe("Array of branches that all execute (either in parallel or sequentially)"), "type": z.literal("branchall"), "parallel": z.boolean().describe("If true, all branches execute concurrently. If false, they execute sequentially").optional() }).describe("Parallel branching where all branches execute simultaneously. Unlike BranchOne, all branches run regardless of conditions. Useful for executing independent tasks concurrently"), z.object({ "type": z.literal("identity"), "flow": z.boolean().describe("If true, marks this as a flow identity (special handling)").optional() }).describe("Pass-through module that returns its input unchanged. Useful for flow structure or as a placeholder"), z.object({ "input_transforms": z.object({ "provider": z.discriminatedUnion("type", [z.object({ "value": z.object({ "kind": z.enum(["openai","azure_openai","azure_foundry","anthropic","mistral","deepseek","googleai","groq","openrouter","togetherai","customai","aws_bedrock"]).describe("Supported AI provider types"), "resource": z.string().describe("Resource reference in format '$res:{resource_path}' pointing to provider credentials"), "model": z.string().describe("Model identifier (e.g., 'gpt-4', 'claude-3-opus-20240229', 'gemini-pro')"), "reasoning_effort": z.string().describe("Provider-native reasoning effort token (e.g. 'low', 'high', 'none') for models that support extended thinking. Optional; unset leaves the provider default.").optional() }).describe("Complete AI provider configuration with resource reference and model selection"), "type": z.literal("static") }).describe("Static provider configuration passed directly to the AI agent"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Provider configuration - can be static (ProviderConfig), JavaScript expression, or AI-determined").optional(), "output_type": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("Output format type.\nValid values: 'text' (default) - plain text response, 'image' - image generation\n").optional(), "user_message": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("The user's prompt/message to the AI agent. Supports variable interpolation with flow.input syntax."), "system_prompt": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("System instructions that guide the AI's behavior, persona, and response style. Optional.").optional(), "streaming": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("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").optional(), "memory": z.discriminatedUnion("type", [z.object({ "value": z.discriminatedUnion("kind", [z.object({ "kind": z.literal("off") }).describe("No conversation memory/context"), z.object({ "kind": z.literal("auto"), "context_length": z.number().int().describe("Maximum number of messages to retain in context").optional(), "memory_id": z.string().describe("Identifier for persistent memory across agent invocations").optional() }).describe("Automatic context management"), z.object({ "kind": z.literal("manual"), "messages": z.array(z.object({ "role": z.enum(["user","assistant","system"]), "content": z.string() }).describe("A single message in conversation history")) }).describe("Explicit message history")]).describe("Conversation memory configuration"), "type": z.literal("static") }).describe("Static memory configuration passed directly to the AI agent"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Memory configuration - can be static (MemoryConfig), JavaScript expression, or AI-determined").optional(), "output_schema": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("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").optional(), "user_attachments": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("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").optional(), "max_completion_tokens": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("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").optional(), "temperature": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("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").optional(), "max_iterations": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("Number. Limits how many times the agent can loop through reasoning and tool use.\nRange: 1-1000.\n").optional() }).describe("Input parameters for the AI agent mapped to their values"), "tools": z.array(z.object({ "id": z.string().describe("Unique identifier for this tool. Cannot contain spaces - use underscores instead (e.g., 'get_user_data' not 'get user data')"), "summary": z.string().describe("Short description of what this tool does (shown to the AI)").optional(), "description": z.string().describe("Free-text description of the tool given to the AI to decide when and how to call it. Overrides the description auto-derived from the underlying script.").optional(), "value": z.any().superRefine((x, ctx) => {
+export const flowModuleSchema = z.object({ "id": z.string().describe("Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)"), "value": z.discriminatedUnion("type", [z.object({ "input_transforms": z.record(z.string(), z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs")).describe("Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments"), "content": z.string().describe("The script source code. Should export a 'main' function"), "language": z.enum(["deno","bun","bunnative","python3","go","bash","powershell","postgresql","mysql","bigquery","snowflake","mssql","oracledb","graphql","nativets","php","rust","ansible","csharp","nu","java","ruby","rlang","duckdb"]).describe("Programming language for this script"), "path": z.string().describe("Optional path for saving this script").optional(), "lock": z.string().describe("Lock file content for dependencies").optional(), "type": z.literal("rawscript"), "tag": z.string().describe("Worker group tag for execution routing").optional(), "concurrent_limit": z.number().describe("Maximum concurrent executions of this script").optional(), "concurrency_time_window_s": z.number().describe("Time window for concurrent_limit").optional(), "custom_concurrency_key": z.string().describe("Custom key for grouping concurrent executions").optional(), "is_trigger": z.boolean().describe("If true, this script is a trigger that can start the flow").optional(), "assets": z.array(z.object({ "path": z.string().describe("Path to the asset"), "kind": z.enum(["s3object","resource","ducklake","datatable","volume","dbt"]).describe("Type of asset"), "access_type": z.union([z.literal("r"), z.literal("w"), z.literal("rw"), z.literal(null)]).nullable().describe("Access level for this asset").optional(), "alt_access_type": z.union([z.literal("r"), z.literal("w"), z.literal("rw"), z.literal(null)]).nullable().describe("Alternative access level").optional() })).describe("External resources this script accesses (S3 objects, resources, etc.)").optional() }).describe("Inline script with code defined directly in the flow. Use 'bun' as default language if unspecified. The script receives arguments from input_transforms"), z.object({ "input_transforms": z.record(z.string(), z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs")).describe("Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments"), "path": z.string().describe("Path to the script in the workspace (e.g., 'f/scripts/send_email')"), "hash": z.string().describe("Optional specific version hash of the script to use").optional(), "type": z.literal("script"), "tag_override": z.string().describe("Override the script's default worker group tag").optional(), "is_trigger": z.boolean().describe("If true, this script is a trigger that can start the flow").optional() }).describe("Reference to an existing script by path. Use this when calling a previously saved script instead of writing inline code"), z.object({ "input_transforms": z.record(z.string(), z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs")).describe("Map of parameter names to their values (static or JavaScript expressions). These become the subflow's input arguments"), "path": z.string().describe("Path to the flow in the workspace (e.g., 'f/flows/process_user')"), "type": z.literal("flow") }).describe("Reference to an existing flow by path. Use this to call another flow as a subflow"), z.object({ "modules": z.array(z.lazy(() => flowModuleSchema)).describe("Steps to execute for each iteration. These can reference the iteration value via 'flow_input.iter.value'"), "iterator": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs"), "skip_failures": z.boolean().describe("If true, iteration failures don't stop the loop. Failed iterations return null"), "type": z.literal("forloopflow"), "parallel": z.boolean().describe("If true, iterations run concurrently (faster for I/O-bound operations). Use with parallelism to control concurrency").optional(), "parallelism": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "squash": z.boolean().optional() }).describe("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"), z.object({ "modules": z.array(z.lazy(() => flowModuleSchema)).describe("Steps to execute in each iteration"), "skip_failures": z.boolean().describe("If true, iteration failures don't stop the loop. Failed iterations return null"), "type": z.literal("whileloopflow"), "parallel": z.boolean().describe("If true, iterations run concurrently (use with caution in while loops)").optional(), "parallelism": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").optional(), "squash": z.boolean().optional() }).describe("Executes nested modules repeatedly until stopped. The implicit iterator is the iteration counter, so 'flow_input.iter.value' equals 'flow_input.iter.index' (0, 1, 2, ...) and never carries state. To carry state across iterations, a step reads its own previous-iteration result via 'results.<its_own_id>' with a first-iteration fallback - the loop's stop_after_if must then be on that inner step (a plain single-step body with stop_after_if on the loop module does not resolve 'results' across iterations and never terminates); plain counters can instead be derived from 'flow_input.iter.index', which works in every configuration. stop_after_if is evaluated after each iteration - on the loop module 'result' is the last iteration's result"), z.object({ "branches": z.array(z.object({ "summary": z.string().describe("Short description of this branch condition").optional(), "expr": z.string().describe("JavaScript expression that returns boolean. Can use 'results.step_id' or 'flow_input'. First true expr wins"), "modules": z.array(z.lazy(() => flowModuleSchema)).describe("Steps to execute if this branch's expr is true") })).describe("Array of branches to evaluate in order. The first branch with expr evaluating to true executes"), "default": z.array(z.lazy(() => flowModuleSchema)).describe("Steps to execute if no branch expressions match"), "type": z.literal("branchone") }).describe("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"), z.object({ "branches": z.array(z.object({ "summary": z.string().describe("Short description of this branch's purpose").optional(), "skip_failure": z.boolean().describe("If true, failure in this branch doesn't fail the entire flow").optional(), "modules": z.array(z.lazy(() => flowModuleSchema)).describe("Steps to execute in this branch") })).describe("Array of branches that all execute (either in parallel or sequentially)"), "type": z.literal("branchall"), "parallel": z.boolean().describe("If true, all branches execute concurrently. If false, they execute sequentially").optional() }).describe("Parallel branching where all branches execute simultaneously. Unlike BranchOne, all branches run regardless of conditions. Useful for executing independent tasks concurrently"), z.object({ "type": z.literal("identity"), "flow": z.boolean().describe("If true, marks this as a flow identity (special handling)").optional() }).describe("Pass-through module that returns its input unchanged. Useful for flow structure or as a placeholder"), z.object({ "input_transforms": z.object({ "provider": z.discriminatedUnion("type", [z.object({ "value": z.object({ "kind": z.enum(["openai","azure_openai","azure_foundry","anthropic","mistral","deepseek","googleai","groq","openrouter","togetherai","customai","aws_bedrock"]).describe("Supported AI provider types"), "resource": z.string().describe("Resource reference in format '$res:{resource_path}' pointing to provider credentials"), "model": z.string().describe("Model identifier (e.g., 'gpt-4', 'claude-3-opus-20240229', 'gemini-pro')"), "reasoning_effort": z.string().describe("Provider-native reasoning effort token (e.g. 'low', 'high', 'none') for models that support extended thinking. Optional; unset leaves the provider default.").optional() }).describe("Complete AI provider configuration with resource reference and model selection"), "type": z.literal("static") }).describe("Static provider configuration passed directly to the AI agent"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Provider configuration - can be static (ProviderConfig), JavaScript expression, or AI-determined").optional(), "output_type": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("Output format type.\nValid values: 'text' (default) - plain text response, 'image' - image generation\n").optional(), "user_message": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("The user's prompt/message to the AI agent. Supports variable interpolation with flow.input syntax."), "system_prompt": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("System instructions that guide the AI's behavior, persona, and response style. Optional.").optional(), "streaming": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("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").optional(), "memory": z.discriminatedUnion("type", [z.object({ "value": z.discriminatedUnion("kind", [z.object({ "kind": z.literal("off") }).describe("No conversation memory/context"), z.object({ "kind": z.literal("auto"), "context_length": z.number().int().describe("Maximum number of messages to retain in context").optional(), "memory_id": z.string().describe("Identifier for persistent memory across agent invocations").optional() }).describe("Automatic context management"), z.object({ "kind": z.literal("manual"), "messages": z.array(z.object({ "role": z.enum(["user","assistant","system"]), "content": z.string() }).describe("A single message in conversation history")) }).describe("Explicit message history")]).describe("Conversation memory configuration"), "type": z.literal("static") }).describe("Static memory configuration passed directly to the AI agent"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Memory configuration - can be static (MemoryConfig), JavaScript expression, or AI-determined").optional(), "output_schema": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("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").optional(), "user_attachments": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("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").optional(), "max_completion_tokens": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("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").optional(), "temperature": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("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").optional(), "max_iterations": z.discriminatedUnion("type", [z.object({ "value": z.any().describe("The static value. For resources, use format '$res:path/to/resource'").optional(), "type": z.literal("static") }).describe("Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'"), z.object({ "expr": z.string().describe("JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"), "type": z.literal("javascript") }).describe("JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')"), z.object({ "type": z.literal("ai") }).describe("Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.")]).describe("Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs").describe("Number. Limits how many times the agent can loop through reasoning and tool use.\nRange: 1-1000.\n").optional() }).describe("Input parameters for the AI agent mapped to their values"), "tools": z.array(z.object({ "id": z.string().describe("Unique identifier for this tool. Cannot contain spaces - use underscores instead (e.g., 'get_user_data' not 'get user data')"), "summary": z.string().describe("Short description of what this tool does (shown to the AI)").optional(), "description": z.string().describe("Free-text description of the tool given to the AI to decide when and how to call it. Overrides the description auto-derived from the underlying script.").optional(), "value": z.any().superRefine((x, ctx) => {
     const schemas = [z.intersection(z.object({ "tool_type": z.literal("flowmodule") }), z.lazy(() => flowModuleValueSchema)).describe("A tool implemented as a flow module (script, flow, etc.). The AI can call this like any other flow module"), z.object({ "tool_type": z.literal("mcp"), "resource_path": z.string().describe("Path to the MCP resource/server configuration"), "include_tools": z.array(z.string()).describe("Whitelist of specific tools to include from this MCP server").optional(), "exclude_tools": z.array(z.string()).describe("Blacklist of tools to exclude from this MCP server").optional() }).describe("Reference to an external MCP (Model Context Protocol) tool. The AI can call tools from MCP servers"), z.object({ "tool_type": z.literal("websearch") }).describe("A tool implemented as a websearch tool. The AI can call this like any other websearch tool")];
     const errors = schemas.reduce<z.ZodError[]>(
       (errors, schema) =>
diff --git a/frontend/src/lib/components/dbt/DbtProjectPanel.svelte b/frontend/src/lib/components/dbt/DbtProjectPanel.svelte
new file mode 100644
index 0000000000..449012aadb
--- /dev/null
+++ b/frontend/src/lib/components/dbt/DbtProjectPanel.svelte
@@ -0,0 +1,214 @@
+<script module lang="ts">
+	import type { Preview } from '$lib/gen'
+
+	import YAML from 'yaml'
+
+	/** What `dbt build --select` should be given for an open file, or `undefined`
+	 *  when the file is not a model.
+	 *
+	 *  Only files under the project's `model-paths` are models; a project also
+	 *  holds macros, analyses and singular tests, all `.sql`, none of them
+	 *  selectable by name. The selector is package-qualified because a bare leaf
+	 *  name also matches a dependency package's model of the same name.
+	 */
+	export function dbtModelSelector(
+		modules: Record<string, { content?: string }>,
+		filePath: string
+	): string | undefined {
+		// `.py` as well as `.sql`: a dbt Python model is a model, and leaving it
+		// out would run the whole project to check one file — the larger
+		// warehouse bill this narrowing exists to avoid.
+		const ext = ['.sql', '.py'].find((e) => filePath.endsWith(e))
+		if (!ext) return undefined
+		let project: any
+		try {
+			project = YAML.parse(modules['dbt_project.yml']?.content ?? '')
+		} catch {
+			return undefined
+		}
+		if (!project?.name) return undefined
+		const modelPaths: string[] = Array.isArray(project['model-paths'])
+			? project['model-paths']
+			: ['models']
+		if (!modelPaths.some((d) => filePath === d || filePath.startsWith(d + '/'))) return undefined
+		const name = filePath.split('/').pop()!.slice(0, -ext.length)
+		return `${name},package:${project.name}`
+	}
+
+	/** The editor language for one project file, by extension.
+	 *
+	 *  A dbt project is heterogeneous where a `__mod` bundle is not: models are
+	 *  SQL, schemas and the project file are YAML, seeds are CSV. Every module is
+	 *  stored with `language: dbt`, so highlighting has to come from the name.
+	 *  `postgresql` and `ansible` are how Windmill spells "SQL" and "YAML" to the
+	 *  editor.
+	 */
+	export function dbtFileLang(path: string): Preview['language'] {
+		if (path.endsWith('.sql')) return 'postgresql'
+		if (path.endsWith('.yml') || path.endsWith('.yaml')) return 'ansible'
+		if (path.endsWith('.py')) return 'python3'
+		// `.md` (a doc block) and `.csv` (a seed) have no grammar of their own
+		// here; `bash` leaves prose alone, where the default would colour it as
+		// TypeScript.
+		return 'bash'
+	}
+</script>
+
+<script lang="ts">
+	// A dbt script's modules ARE its project, so they are browsed as the tree dbt
+	// expects rather than the flat tab strip helper files get. Selecting one opens
+	// it in the editor: the descriptor and the project's files are edited in the
+	// same place, because once the descriptor moved inside `__dbt/` there was no
+	// longer a boundary between them to draw.
+	import type { ScriptModule } from '$lib/gen'
+	import type { Snippet } from 'svelte'
+	import { ChevronDown, ChevronRight, FileText, Trash2 } from 'lucide-svelte'
+
+	let {
+		modules,
+		scriptPath,
+		descriptorName,
+		/** `null` is the descriptor, matching the editor's `activeModuleTab`. */
+		selected,
+		onSelect,
+		onDelete,
+		/** The add-file control. Owned by the editor, which holds the form. */
+		addFile
+	}: {
+		modules: Record<string, ScriptModule>
+		scriptPath: string
+		descriptorName: string
+		selected: string | null
+		onSelect: (path: string | null) => void
+		onDelete?: (path: string) => void
+		addFile?: Snippet
+	} = $props()
+
+	type Node = { name: string; path: string; children: Node[] }
+
+	function buildTree(paths: string[]): Node[] {
+		const root: Node = { name: '', path: '', children: [] }
+		for (const p of [...paths].sort()) {
+			let node = root
+			const parts = p.split('/')
+			parts.forEach((part, i) => {
+				const path = parts.slice(0, i + 1).join('/')
+				let next = node.children.find((c) => c.name === part)
+				if (!next) {
+					// Directories carry their full path too: it is what makes a node
+					// identity, and two of the same name at one depth under different
+					// parents — `models/staging` and `tests/staging` — would otherwise
+					// share a collapse key and fold together.
+					next = { name: part, path, children: [] }
+					node.children.push(next)
+				}
+				node = next
+			})
+		}
+		// Directories before files, each alphabetical: the same order `ls` gives,
+		// so the tree reads like the checkout on disk.
+		const sort = (n: Node) => {
+			n.children.sort((a, b) => {
+				const aDir = a.children.length > 0
+				const bDir = b.children.length > 0
+				if (aDir !== bDir) return aDir ? -1 : 1
+				return a.name.localeCompare(b.name)
+			})
+			n.children.forEach(sort)
+		}
+		sort(root)
+		return root.children
+	}
+
+	let tree = $derived(buildTree(Object.keys(modules)))
+	let fileCount = $derived(Object.keys(modules).length)
+	let collapsed = $state<Record<string, boolean>>({})
+</script>
+
+{#snippet branch(nodes: Node[], depth: number)}
+	{#each nodes as node (node.name + node.path + depth)}
+		{@const key = `${depth}:${node.name}:${node.path}`}
+		{#if node.children.length > 0}
+			<button
+				class="w-full flex items-center gap-1 px-1 py-0.5 text-2xs hover:bg-surface-hover text-secondary"
+				style="padding-left: {depth * 10 + 4}px"
+				onclick={() => (collapsed[key] = !collapsed[key])}
+			>
+				{#if collapsed[key]}
+					<ChevronRight size={11} class="shrink-0" />
+				{:else}
+					<ChevronDown size={11} class="shrink-0" />
+				{/if}
+				<span class="truncate font-mono">{node.name}</span>
+			</button>
+			{#if !collapsed[key]}
+				{@render branch(node.children, depth + 1)}
+			{/if}
+		{:else}
+			<div
+				class="group w-full flex items-center hover:bg-surface-hover {selected === node.path
+					? 'bg-surface-selected'
+					: ''}"
+			>
+				<button
+					class="flex-1 min-w-0 flex items-center gap-1 px-1 py-0.5 text-2xs {selected === node.path
+						? 'font-semibold text-primary'
+						: 'text-secondary'}"
+					style="padding-left: {depth * 10 + 15}px"
+					onclick={() => onSelect(node.path)}
+				>
+					<FileText size={11} class="shrink-0 opacity-60" />
+					<span class="truncate font-mono">{node.name}</span>
+				</button>
+				<!-- `dbt_project.yml` is what makes the bundle a project: without it the
+				     worker refuses the version outright, so one click here would deploy a
+				     script that cannot run. -->
+				{#if onDelete && node.path !== 'dbt_project.yml'}
+					<button
+						class="shrink-0 px-1 opacity-0 group-hover:opacity-100 text-secondary hover:text-red-500"
+						title="Delete {node.path}"
+						onclick={() => onDelete?.(node.path)}
+					>
+						<Trash2 size={11} />
+					</button>
+				{/if}
+			</div>
+		{/if}
+	{/each}
+{/snippet}
+
+<div class="w-56 shrink-0 border-r flex flex-col min-h-0 bg-surface">
+	<div
+		class="shrink-0 flex items-center gap-2 px-2 py-1 text-2xs border-b bg-surface-secondary text-secondary"
+	>
+		<span class="font-mono truncate">{scriptPath}__dbt/</span>
+		<div class="ml-auto shrink-0 flex items-center gap-1">
+			<span class="opacity-70">{fileCount + 1}</span>
+			{@render addFile?.()}
+		</div>
+	</div>
+	<div class="flex-1 min-h-0 overflow-auto py-1">
+		<!-- The descriptor sits at the project root, which is where it lives on disk. -->
+		<button
+			class="w-full flex items-center gap-1 px-1 py-0.5 text-2xs hover:bg-surface-hover {selected ===
+			null
+				? 'bg-surface-selected font-semibold text-primary'
+				: 'text-secondary'}"
+			style="padding-left: 15px"
+			onclick={() => onSelect(null)}
+		>
+			<FileText size={11} class="shrink-0 opacity-60" />
+			<span class="truncate font-mono">{descriptorName}</span>
+		</button>
+		{@render branch(tree, 0)}
+	</div>
+	{#if fileCount === 0}
+		<div class="shrink-0 p-2 text-2xs text-secondary border-t">
+			No project yet. Copy one in and push it:
+			<pre class="mt-1 p-1 rounded bg-surface-secondary overflow-x-auto"
+				>cp -r my-dbt-project/. {scriptPath}__dbt/
+wmill sync push</pre
+			>
+		</div>
+	{/if}
+</div>
diff --git a/frontend/src/lib/components/dbt/DbtRunGraph.svelte b/frontend/src/lib/components/dbt/DbtRunGraph.svelte
new file mode 100644
index 0000000000..7b9cbee07b
--- /dev/null
+++ b/frontend/src/lib/components/dbt/DbtRunGraph.svelte
@@ -0,0 +1,769 @@
+<script lang="ts">
+	// The models this run touches, as the graph, on the page you land on when you
+	// click a running job. The live per-model state the worker records is what
+	// makes it worth having here: nodes go amber then green as dbt walks the DAG,
+	// where the alternative is reading `N of M OK created` out of the log.
+	import { onDestroy, untrack } from 'svelte'
+	import { OpenAPI, JobService } from '$lib/gen'
+	import {
+		nodeSelector,
+		parseDbtRun,
+		relationOutcome,
+		splitRelation,
+		splitUniqueId
+	} from './parseDbtRun'
+	import { Button } from '$lib/components/common'
+	import { ClipboardCopy, Code2, RefreshCw, TableProperties } from 'lucide-svelte'
+	import { copyToClipboard } from '$lib/utils'
+	import { isWindmillTooBigObject } from '$lib/components/job_args'
+	import { previewDbtRows } from './previewRows'
+	import { workspaceStore } from '$lib/stores'
+	import { appendViewToken } from '$lib/viewToken'
+	import AssetGraphCanvas from '$lib/components/assets/AssetGraph/AssetGraphCanvas.svelte'
+	import type { AssetGraphResponse, AssetRunState } from '$lib/components/assets/AssetGraph/types'
+	import { Loader2 } from 'lucide-svelte'
+	import HighlightCode from '$lib/components/HighlightCode.svelte'
+	import type { AssetGraphNodeData } from '$lib/components/assets/AssetGraph/types'
+
+	let {
+		scriptPath,
+		jobId,
+		running = false,
+		result,
+		scriptHash,
+		runArgs,
+		canResume = false,
+		onResume
+	}: {
+		scriptPath: string
+		/** The run whose per-model progress to show. dbt records a state per
+		 *  relation as it walks the DAG; without this the graph can only show
+		 *  what a relation IS, not what this run is doing to it. */
+		jobId?: string
+		// While the job is in flight the graph is re-fetched, because the per-model
+		// materialization rows the worker writes are what move the nodes.
+		running?: boolean
+		/** The finished job's result. It carries a status per dbt node, which is
+		 *  what a completed run is coloured from — see `settled`. */
+		result?: unknown
+		/** The script version this job ran. The graph is stored per deployed
+		 *  version, so passing it renders the project as it was — the models, SQL
+		 *  and `ref()` lineage of that deploy, not of today's. */
+		scriptHash?: string | number
+		/** The arguments this run was invoked with. A preview is a `dbt show` of
+		 *  the same project, so it needs them: a descriptor with a required
+		 *  `{{ }}` var is refused without them, and an overridden one would
+		 *  otherwise query a different relation than the page is showing. */
+		runArgs?: Record<string, unknown>
+		/** Whether a `dbt retry` by this caller would resume THIS run. One failure
+		 *  is saved per script per principal, so a later run of the same script
+		 *  takes the state over and the worker refuses a resume aimed here. */
+		canResume?: boolean
+		/** Submits that retry. The caller owns it so the run's own arguments and
+		 *  resolved tag come along: worker tags, debounce and concurrency keys are
+		 *  interpolated from the submitted arguments at enqueue, long before the
+		 *  worker restores the ones being resumed. */
+		onResume?: () => Promise<unknown> | void
+	} = $props()
+
+	// The graph endpoint is folder-scoped; a script outside `f/` has no folder and
+	// falls back to the whole workspace, which the filter below narrows anyway.
+	let folder = $derived(scriptPath.startsWith('f/') ? scriptPath.split('/')[1] : undefined)
+	// Read inside `load` and listed here so a change of version refetches.
+	let graphKey = $derived(`${folder ?? ''}|${scriptHash ?? ''}|${jobId ?? ''}`)
+
+	let raw = $state<AssetGraphResponse | undefined>(undefined)
+	let loading = $state(true)
+	let failed = $state(false)
+
+	// Two loads of the SAME run overlap — the poll's parting one and the
+	// finished-run effect's — and nothing orders two requests to one endpoint. The
+	// older answers with the DEPLOYED graph, so landing second it replaces the run's
+	// own snapshot with nothing left to fetch again and correct it.
+	let graphSeq = 0
+	async function load() {
+		const ws = $workspaceStore
+		if (!ws) return
+		const gen = runGen
+		const seq = ++graphSeq
+		const current = () => gen === runGen && seq === graphSeq
+		try {
+			const params = new URLSearchParams({ asset_kinds: 'dbt' })
+			if (folder) params.set('folder', folder)
+			if (scriptHash != undefined) params.set('dbt_script_hash', String(scriptHash))
+			// Through the JOB when there is one: `/assets/graph` answers the
+			// workspace-wide question and cannot pin to a run.
+			const path = jobId != undefined ? `/w/${ws}/jobs/dbt_graph/${jobId}` : `/w/${ws}/assets/graph`
+			// `appendViewToken`, because this is a raw `fetch`: the interceptor that
+			// adds `X-View-Token` is installed on the generated client only, and a
+			// shared run page carries its access in that token.
+			const res = await fetch(appendViewToken(`${OpenAPI.BASE ?? ''}${path}?${params}`), {
+				credentials: 'include'
+			})
+			// The page may have moved to another run while this was in flight, and
+			// assigning that answer would leave the previous run's graph — or its
+			// loading state — on screen with nothing to correct it. A newer request
+			// for the SAME run supersedes this one just as completely.
+			if (!current()) return
+			if (!res.ok) {
+				failed = true
+				return
+			}
+			const body = (await res.json()) as AssetGraphResponse
+			if (!current()) return
+			raw = body
+			failed = false
+		} catch {
+			if (current()) failed = true
+		} finally {
+			if (current()) loading = false
+		}
+	}
+
+	// `asset:<kind>:<path>` -> what this run is doing to that relation: the id shape
+	// the canvas builds its nodes with, where a bare `kind:path` looks right and
+	// silently never matches. A retry rewrites the same rows, so a failed node
+	// returns to `running` and on to its new outcome by itself.
+	let polled = $state<Map<string, AssetRunState>>(new Map())
+
+	async function loadProgress() {
+		const ws = $workspaceStore
+		if (!ws || !jobId) return
+		const gen = runGen
+		try {
+			const rows = await JobService.getRunProgress({ workspace: ws, id: jobId })
+			// Same reason as `load`: these are another run's per-model statuses once
+			// the page has moved on, and they would colour this run's models.
+			if (gen !== runGen) return
+			const next = new Map<string, AssetRunState>()
+			for (const r of rows) {
+				next.set(`asset:${r.asset_kind}:${r.asset_path}`, {
+					status: r.status,
+					rowCount: r.row_count
+				})
+			}
+			polled = next
+		} catch {
+			// A progress hiccup must not blank the graph.
+		}
+	}
+
+	let timer: ReturnType<typeof setInterval> | undefined
+	// Bounded so a static descriptor, which never writes a snapshot, stops
+	// asking rather than polling for the length of the run.
+	let graphTries = 0
+	// Deliberately not `$state`: this guards an effect against its own writes, so
+	// reading it must not make the effect depend on it.
+	let finalLoadFor: string | undefined = undefined
+	// SvelteKit reuses this component across runs, so every response that outlives
+	// the navigation — graph, progress poll, preview — is checked against the
+	// generation it was requested under, or the previous run's answer stays on
+	// screen. Not `$state`: the effect below writes it and must not depend on it.
+	let runGen = 0
+	$effect(() => {
+		void scriptPath
+		void graphKey
+		// SvelteKit reuses this component when navigating between runs, and all
+		// three of these describe the PREVIOUS job: a spent retry count stops the
+		// next run's snapshot poll before it starts, and stale progress colours
+		// its models with another run's statuses.
+		graphTries = 0
+		finalLoadFor = undefined
+		polled = new Map()
+		raw = undefined
+		// Both are written by `load` alone and describe the run it answered for,
+		// so they are as run-scoped as `raw`: left behind, the gap before the new
+		// run's answer falls past `{#if loading}` to the "no models in the asset
+		// graph" notice — a claim about the descriptor, on a project that is fine.
+		loading = true
+		failed = false
+		// Previews are keyed by `unique_id` alone, which is the same string for the
+		// same model in every run — so without this the next run opens showing the
+		// previous one's rows, and `runPreview` treats them as cached and refuses
+		// to fetch. The generation drops anything already in flight.
+		runGen += 1
+		selection = undefined
+		previews = {}
+		rowsFor = undefined
+		// Only while in flight; the effect below owns a FINISHED run, since a
+		// snapshot can land after the run ends. On mount both fire in the same tick,
+		// so loading here too fetches the whole graph twice. Untracked: depending on
+		// `running` would re-run this reset the moment the run finishes.
+		if (untrack(() => running)) void load()
+		void jobId
+		void loadProgress()
+	})
+	$effect(() => {
+		clearInterval(timer)
+		// Read synchronously so navigating between two RUNNING jobs re-arms this:
+		// everything below is read inside timer callbacks, so `running` alone would
+		// leave the second run polling on the first one's cycle — already spent.
+		void graphKey
+		// Only while in flight, and no faster than dbt finishes a model: this is a
+		// poll against the same rows the pipeline page reads, not a subscription.
+		if (running) {
+			// The GRAPH is refetched only until this run's own snapshot appears: a
+			// dynamic descriptor re-ingests once before the build, after a clone and
+			// a provision, so a fixed delay either fires too early to ever show the
+			// run's models or re-sends the whole graph for the length of the run.
+			timer = setInterval(() => void loadProgress(), 2000)
+			// Backed off, because for a whole class of runs neither stop below is
+			// reached and this walks to its cap: `dbt_snapshot_job` never matches a
+			// static descriptor, and `polled` stays empty on engines emitting no node
+			// events. Each try re-sends every model's SQL.
+			let graphDelay = 3000
+			let graphTimer: ReturnType<typeof setTimeout> | undefined
+			const pollGraph = () => {
+				// Two ways to be done, and the second is the common one. The
+				// ingest happens BEFORE the build, so once any model reports
+				// progress it has already run: a snapshot that is not here by
+				// then is a snapshot this run never writes.
+				if (raw?.dbt_snapshot_job === jobId || polled.size > 0 || graphTries >= 12) {
+					// One last load on the way out. Progress proves the ingest
+					// happened; it does not prove the previous tick SAW it, and
+					// dbt's compile window is usually wider than one tick.
+					if (raw?.dbt_snapshot_job !== jobId) void load()
+					return
+				}
+				graphTries += 1
+				void load()
+				graphDelay = Math.min(graphDelay * 1.6, 30000)
+				graphTimer = setTimeout(pollGraph, graphDelay)
+			}
+			graphTimer = setTimeout(pollGraph, graphDelay)
+			return () => {
+				clearTimeout(graphTimer)
+				clearInterval(timer)
+			}
+		}
+		// One unconditional load once the run has finished: the poll above gives up
+		// after a bounded number of tries, which provisioning plus `dbt deps` can
+		// outlast on a cold worker. Without this a snapshot written late is never
+		// displayed and the page keeps the deployed fallback for good.
+		else if (finalLoadFor !== (jobId ?? '')) {
+			// Once per finished job, not per response: `load()` assigns `raw`, which
+			// recomputes `settled`, which re-enters this effect and refetches the
+			// whole graph for as long as the page is open. A plain variable, so
+			// reading it adds no dependency.
+			finalLoadFor = jobId ?? ''
+			void load()
+			// `settled` colours a finished run with no request. The poll is the
+			// fallback for one that produced no `run_results.json` at all —
+			// cancelled or killed — whose relations the worker settles in the
+			// table instead.
+			if (!untrack(() => settled)) void loadProgress()
+		}
+		return () => clearInterval(timer)
+	})
+	// Read by the preview poll, which outlives the component otherwise: its own
+	// loop is what has to stop, since there is no interval to clear.
+	let destroyed = false
+	onDestroy(() => {
+		destroyed = true
+		clearInterval(timer)
+	})
+
+	// Parsed once: five derivations below read it, and `result` is the whole
+	// `run_results.json` the job returned.
+	let run = $derived(parseDbtRun(result))
+
+	// A failed run's obvious next action is "Run again", which prefills the
+	// arguments it just ran — rebuilding the whole project. `dbt retry` redoes the
+	// failed and skipped nodes alone, and nothing on the page says so.
+	let resumable = $derived(
+		canResume && !running && ((run?.totals?.error ?? 0) > 0 || (run?.totals?.skipped ?? 0) > 0)
+	)
+	let resuming = $state(false)
+
+	async function resume() {
+		if (resuming) return
+		resuming = true
+		try {
+			await onResume?.()
+		} finally {
+			resuming = false
+		}
+	}
+
+	// A test is not a relation, so a run selecting tests alone has an empty graph
+	// and a healthy one — where the empty state otherwise blames the descriptor's
+	// warehouse identity. Both kinds: dbt spells a unit test `unit_test.<pkg>.…`.
+	let ranTestsOnly = $derived(
+		!!run?.nodes?.length &&
+			run.nodes.every((n) => ['test', 'unit_test'].includes(splitUniqueId(n.unique_id).kind))
+	)
+
+	// A run page is about one script, so the graph is the relations it reads and
+	// writes — a folder's other projects are noise here, and so is a node for the
+	// script itself: on the pipeline page that node distinguishes one project
+	// from another, but here the whole graph already IS that project.
+	let scoped = $derived.by(() => {
+		if (!raw) return undefined
+		// Asked for a specific version, the response IS that version's project.
+		// Scoping by usage edges would undo that: those rows are path-keyed and
+		// describe the current deploy, so a model this version had and a later one
+		// dropped has no edge to be found by.
+		const assetIds = scriptHash
+			? new Set(raw.assets.filter((a) => a.dbt).map((a) => `${a.kind}:${a.path}`))
+			: new Set(
+					raw.edges
+						.filter((e) => e.runnable_path === scriptPath)
+						.map((e) => `${e.asset_kind}:${e.asset_path}`)
+				)
+		if (assetIds.size === 0) return undefined
+		return {
+			...raw,
+			runnables: [],
+			assets: raw.assets.filter((a) => assetIds.has(`${a.kind}:${a.path}`)),
+			edges: [],
+			triggers: [],
+			// `ref()` lineage between two of this project's own models is the shape
+			// of the dbt DAG, so it is the one edge set worth keeping whole.
+			dbt_edges: (raw.dbt_edges ?? []).filter(
+				(e) => assetIds.has(`dbt:${e.from_asset_path}`) && assetIds.has(`dbt:${e.to_asset_path}`)
+			)
+		} as AssetGraphResponse
+	})
+
+	// A FINISHED run is narrowed to what it named: the response is the VERSION's
+	// graph, so a model this run never built would appear as though it had. Sources
+	// stay — dbt lists none in `run_results.json`, but the run read them. (No
+	// `resolveGraph`: it merges drafts and editor buffers a run page has neither of.)
+	let historical = $derived.by(() => {
+		if (running || !scoped) return undefined
+		if (!run?.nodes?.length) return undefined
+		const ran = new Set(run.nodes.map((n) => n.unique_id))
+		// dbt ids are `<resource_type>.<package>.<name>`, so the packages this run
+		// named are the projects it could speak for.
+		const pkg = (id: string) => id.split('.')[1]
+		const ranPackages = new Set(run.nodes.map((n) => pkg(n.unique_id)))
+		const keep = (a: (typeof scoped.assets)[number]) =>
+			a.dbt == undefined ||
+			a.dbt.resource_type === 'source' ||
+			ran.has(a.dbt.unique_id) ||
+			// Provenance keeps one winner per relation, so a relation two projects
+			// write may carry the OTHER project's model — and this run cannot be
+			// judged against an id that was never its own. Dropping it would make the
+			// run look like it built fewer models than it did.
+			!ranPackages.has(pkg(a.dbt.unique_id))
+		const assets = scoped.assets.filter(keep)
+		if (assets.length === scoped.assets.length) return undefined
+		const ids = new Set(assets.map((a) => `${a.kind}:${a.path}`))
+		return {
+			...scoped,
+			assets,
+			dbt_edges: (scoped.dbt_edges ?? []).filter(
+				(e) => ids.has(`dbt:${e.from_asset_path}`) && ids.has(`dbt:${e.to_asset_path}`)
+			)
+		} as AssetGraphResponse
+	})
+
+	let graph = $derived(historical ?? scoped)
+
+	// Models whose id survived but whose RELATION changed — an alias, schema or
+	// database edit. The graph on screen is the version's as it stands now, so a
+	// node can name a relation this run did not write, and saying so beats
+	// asserting the run materialized a table that did not exist then.
+	let relationDrift = $derived.by(() => {
+		if (running || !graph) return 0
+		if (!run?.nodes?.length) return 0
+		// Schema AND name: the move most likely being reported, a profile repointed
+		// at another schema, leaves every model's name where it was. An asset path is
+		// `<resource>/<schema>/<name>`, whose schema segment is `<database>.<schema>`
+		// only when the model overrode the target's database.
+		const byId = new Map(
+			graph.assets
+				.filter((a) => a.dbt?.unique_id)
+				.map((a) => [a.dbt!.unique_id, a.path.split('/').slice(-2)])
+		)
+		return run.nodes.filter((n) => {
+			if (!n.relation_name) return false
+			const now = byId.get(n.unique_id)
+			if (now == undefined || now.length < 2) return false
+			const [nowSchema, nowName] = now
+			const parts = splitRelation(n.relation_name)
+			const name = parts.at(-1) ?? ''
+			const schema = parts.at(-2) ?? ''
+			const qualified = parts.length > 2 ? `${parts.at(-3)}.${schema}` : schema
+			// Either spelling counts as unmoved: an unqualified segment names the
+			// target's own database, so demanding the qualified form reports a move on
+			// every node. Lower-cased because `relation_name` is the warehouse's own —
+			// Snowflake's is upper, and comparing raw looks like a rename.
+			const here = nowSchema.toLowerCase()
+			return (
+				nowName.toLowerCase() !== name.toLowerCase() ||
+				(here !== schema.toLowerCase() && here !== qualified.toLowerCase())
+			)
+		}).length
+	})
+
+	// Models this run built that the graph on screen no longer has under the same
+	// id — renamed or deleted since, or dropped from a version graph rewritten
+	// after this run. They cannot be drawn, so the count is stated rather than
+	// silently missing.
+	let goneSinceRun = $derived.by(() => {
+		if (running || !scoped) return 0
+		if (!run?.nodes?.length) return 0
+		const known = new Set(
+			scoped.assets.map((a) => a.dbt?.unique_id).filter((u): u is string => u != undefined)
+		)
+		// Only relations whose own project still lacks the id count as gone: an id
+		// missing because another project won the provenance is not a deletion.
+		const knownPackages = new Set(
+			[...known].map((u) => u.split('.')[1]).filter((p) => p != undefined)
+		)
+		return run.nodes.filter(
+			(n) =>
+				!known.has(n.unique_id) &&
+				knownPackages.has(n.unique_id.split('.')[1]) &&
+				/^(model|seed|snapshot)\./.test(n.unique_id)
+		).length
+	})
+
+	// A finished run's own output, joined on dbt's `unique_id` — what both sides
+	// carry, where the relation name would redo the worker's path derivation. The
+	// per-relation state table holds ONE row per relation, whichever job wrote it
+	// last, so reading THAT would show an old run a later one's models.
+	let settled = $derived.by(() => {
+		if (running) return undefined
+		if (!run?.nodes?.length || !graph) return undefined
+		const assetByNode = new Map<string, string>()
+		for (const a of graph.assets) {
+			if (a.dbt?.unique_id) assetByNode.set(a.dbt.unique_id, `asset:${a.kind}:${a.path}`)
+		}
+		const out = new Map<string, AssetRunState>()
+		for (const n of run.nodes) {
+			const id = assetByNode.get(n.unique_id)
+			const outcome = id && relationOutcome(n.status, n.outcome)
+			// A test or an analysis matches no relation, and a skipped node says
+			// nothing about one; both are left uncoloured rather than guessed at.
+			if (id && outcome) out.set(id, { status: outcome, rowCount: n.rows_affected })
+		}
+		return out.size > 0 ? out : undefined
+	})
+
+	let assetRunStatus = $derived(settled ?? polled)
+
+	// The transform behind the selected relation. dbt's own DAG node is the model
+	// — the SQL and the table it writes are one thing — so a graph of relations
+	// alone leaves out what a reader came to see.
+	let selection = $state<AssetGraphNodeData | undefined>(undefined)
+	let selectedDbt = $derived.by(() => {
+		const sel = selection
+		if (sel?.kind !== 'asset') return undefined
+		const dbt = graph?.assets.find((a) => a.kind === sel.asset_kind && a.path === sel.path)?.dbt
+		if (!dbt) return undefined
+		// Provenance keeps one winner per relation workspace-wide, so a relation two
+		// projects materialize carries one project's node, whose SQL is not this
+		// run's. Sources are exempt: a run executes none, so none appear in
+		// `run_results.json`.
+		if (
+			dbt.resource_type !== 'source' &&
+			run?.nodes?.length &&
+			!run.nodes.some((n) => n.unique_id === dbt.unique_id)
+		) {
+			return undefined
+		}
+		return dbt
+	})
+
+	// `dbt show` against the selected model, run as an ordinary job — same
+	// authorization, isolation and cancellation as any other. Explicit rather
+	// than on-select: each preview costs a worker slot and a few seconds of
+	// engine start-up, so it must be something the reader asked for.
+	type Preview =
+		| { rows: Record<string, unknown>[]; tookMs: number; node?: string }
+		| { error: string }
+		| { pending: true }
+	// Cached per model id, so flipping between two nodes does not re-run a job
+	// that costs a worker slot and an engine start-up. A preview also keeps
+	// running when the selection moves — the result lands in the cache and is
+	// there when the reader comes back.
+	let previews = $state<Record<string, Preview>>({})
+	// Read under the same key `runPreview` writes: the model AND the arguments it
+	// ran with, so an edited var shows its own rows rather than the last ones.
+	let preview = $derived(
+		selectedDbt ? previews[`${selectedDbt.unique_id}|${JSON.stringify(runArgs ?? {})}`] : undefined
+	)
+	let previewing = $derived(preview != undefined && 'pending' in preview)
+	// Which model's rows are on display. Keyed by id rather than a boolean so
+	// moving the selection goes back to SQL without anything having to reset it.
+	let rowsFor = $state<string | undefined>(undefined)
+	let showRows = $derived(
+		selectedDbt != undefined && rowsFor?.startsWith(`${selectedDbt.unique_id}|`) === true
+	)
+
+	// A column can hold an array or a JSON object, whose default stringification
+	// is `[object Object]` — which tells the reader nothing about the value.
+	function cellText(v: unknown): string {
+		if (v == undefined) return ''
+		return typeof v === 'object' ? JSON.stringify(v) : String(v)
+	}
+
+	async function runPreview() {
+		const ws = $workspaceStore
+		const dbt = selectedDbt
+		if (!ws || !dbt) return
+		// Keyed on the ARGUMENTS too, not the model alone: on the script page the
+		// form above feeds this, so a var edited between two clicks previews a
+		// different query — and a cache that ignored it would return the old rows
+		// as though nothing had changed.
+		const key = `${dbt.unique_id}|${JSON.stringify(runArgs ?? {})}`
+		// Displaying the rows and running the job are separate: coming back from
+		// the SQL to a result already in hand must not spend another worker slot.
+		rowsFor = key
+		// A cached FAILURE must not be cached: it would leave the button dead for
+		// that model until reload. Only a result or an in-flight run blocks a
+		// re-run.
+		const cached = previews[key]
+		if (cached != undefined && !('error' in cached)) return
+		const gen = runGen
+		previews = { ...previews, [key]: { pending: true } }
+		// The run's own arguments, so a required `{{ }}` var resolves and an
+		// overridden one points at the relation on screen. The result's copy wins:
+		// a `dbt retry` job's own arguments name the run it resumed, while what it
+		// ran with is the restored ones published here.
+		//
+		// Fetched when they were too big to inline: while the run is still going
+		// there is no result to fall back on, so the placeholder would submit a
+		// preview with none of the descriptor's required vars.
+		let submitted: Record<string, unknown> = runArgs ?? {}
+		if (jobId && isWindmillTooBigObject(submitted)) {
+			try {
+				submitted = ((await JobService.getJobArgs({ workspace: ws, id: jobId })) ?? {}) as Record<
+					string,
+					unknown
+				>
+			} catch {
+				// Leave the placeholder: the preview may still resolve, and its own
+				// failure says more than refusing to try.
+			}
+			if (gen !== runGen || destroyed) return
+		}
+		const ran = { ...submitted, ...(run?.invocation_args ?? {}) } as Record<string, any>
+		const { command: _cmd, ...placeholders } = ran
+		const next = await previewDbtRows({
+			workspace: ws,
+			scriptPath,
+			// By HASH whenever the graph is pinned, so the rows are that version's.
+			scriptHash,
+			// Scoped to the node's package, not the bare name: a package can ship a
+			// model whose name the project also uses. Derived from the node's id
+			// and NEVER from `key`, which carries the run arguments that make the
+			// cache entry distinct and would reach dbt as part of the selector.
+			model: nodeSelector(dbt.unique_id),
+			vars: ran.command?.vars ?? {},
+			args: placeholders,
+			stillWanted: () => gen === runGen && !destroyed
+		})
+		if (!next || gen !== runGen) return
+		previews = { ...previews, [key]: next }
+	}
+
+	// Selected a relation this run built, but its stored provenance belongs to
+	// another project that writes the same table. Saying so beats rendering
+	// nothing, which reads as a dead click.
+	let selectedIsForeign = $derived.by(() => {
+		const sel = selection
+		if (sel?.kind !== 'asset' || selectedDbt) return false
+		const dbt = graph?.assets.find((a) => a.kind === sel.asset_kind && a.path === sel.path)?.dbt
+		return dbt != undefined
+	})
+
+	// Fully qualified, as dbt reported it for THIS run, and verbatim — quoting
+	// included. There is no table browser to link to, so this is the name to paste
+	// into a SQL client, and stripping the quotes turns `"wh"."analytics.v2"."Order
+	// Items"` into four parts of a name that resolves to nothing.
+	let selectedRelation = $derived.by(() => {
+		const sel = selection
+		if (sel?.kind !== 'asset' || !selectedDbt) return undefined
+		return run?.nodes?.find((n) => n.unique_id === selectedDbt!.unique_id)?.relation_name
+	})
+</script>
+
+{#snippet sqlPane()}
+	{#if selectedIsForeign}
+		<div class="border-t px-2 py-1.5 text-2xs text-secondary">
+			Another dbt project in this workspace also materializes this relation, and the graph keeps one
+			project's model per relation — so the SQL shown here would not be this run's. Open that
+			project's own run to see it.
+		</div>
+	{:else if selectedDbt?.raw_code}
+		<div class="border-t flex flex-col min-h-0 max-h-72">
+			<div
+				class="shrink-0 flex items-center gap-2 px-2 py-1 text-2xs border-b bg-surface-secondary text-secondary"
+			>
+				<span class="font-mono truncate"
+					>{selectedDbt.original_file_path ?? selectedDbt.unique_id}</span
+				>
+				{#if selectedDbt.materialized}
+					<span class="shrink-0 opacity-70">{selectedDbt.materialized}</span>
+				{/if}
+				<!-- `dbt show` is a SELECT against the node's own relation, and the
+				     worker intersects the selector with `resource_type:model`, so
+				     offering it on a seed or a snapshot only ever produces a failed
+				     job. Their SQL still shows: a snapshot has a body worth reading. -->
+				{#if selectedDbt.resource_type === 'model'}
+					{#if showRows && preview && !('error' in preview)}
+						<Button
+							unifiedSize="2xs"
+							variant="subtle"
+							startIcon={{ icon: Code2 }}
+							on:click={() => (rowsFor = undefined)}
+							title="Show the model's SQL"
+						>
+							SQL
+						</Button>
+					{:else}
+						<Button
+							unifiedSize="2xs"
+							variant="subtle"
+							startIcon={{
+								icon: previewing ? Loader2 : TableProperties,
+								classes: previewing ? 'animate-spin' : undefined
+							}}
+							disabled={previewing}
+							on:click={runPreview}
+							title="Run `dbt show` against this model and display the rows"
+						>
+							{previewing ? 'Previewing…' : 'Preview rows'}
+						</Button>
+					{/if}
+				{/if}
+				{#if selectedRelation}
+					<Button
+						unifiedSize="2xs"
+						variant="subtle"
+						startIcon={{ icon: ClipboardCopy }}
+						on:click={() => copyToClipboard(selectedRelation)}
+						title="Copy the fully-qualified relation name"
+					>
+						<span class="font-mono truncate max-w-56">{selectedRelation}</span>
+					</Button>
+				{/if}
+				<!-- The copy taken at deploy, so editing it here would change nothing the
+				     next run reads. The file itself is a module of the script — editable
+				     in the script editor, or in the project and pushed. -->
+				<span class="ml-auto shrink-0 opacity-70" title={selectedDbt.original_file_path}>
+					read-only · edit in the script
+				</span>
+			</div>
+			<div class="flex-1 min-h-0 overflow-auto">
+				{#if showRows && preview}
+					{#if 'error' in preview}
+						<div class="p-2 text-2xs text-secondary">{preview.error}</div>
+						<HighlightCode language="sql" code={selectedDbt.raw_code} />
+					{:else if 'pending' in preview}
+						<div class="flex items-center gap-2 p-2 text-2xs text-secondary">
+							<Loader2 size={12} class="animate-spin" />
+							Running `dbt show` — this is a job, so it waits on a worker and the engine.
+						</div>
+					{:else}
+						{@const cols = Object.keys(preview.rows[0] ?? {})}
+						{#if cols.length === 0}
+							<div class="p-2 text-2xs text-secondary"> The model returned no rows. </div>
+						{:else}
+							<table class="w-full text-2xs font-mono">
+								<thead class="sticky top-0 bg-surface-secondary text-secondary">
+									<tr>
+										{#each cols as c (c)}
+											<th class="text-left font-semibold px-2 py-1 border-b">{c}</th>
+										{/each}
+									</tr>
+								</thead>
+								<tbody>
+									{#each preview.rows as row, i (i)}
+										<tr class="border-b border-surface-selected">
+											{#each cols as c (c)}
+												<td class="px-2 py-0.5 truncate max-w-56">{cellText(row[c])}</td>
+											{/each}
+										</tr>
+									{/each}
+								</tbody>
+							</table>
+							<div class="px-2 py-1 text-3xs text-tertiary">
+								{preview.rows.length} rows in {(preview.tookMs / 1000).toFixed(1)}s{preview.node
+									? ` · ${preview.node}`
+									: ''}
+							</div>
+						{/if}
+					{/if}
+				{:else}
+					<HighlightCode language="sql" code={selectedDbt.raw_code} />
+				{/if}
+			</div>
+		</div>
+	{/if}
+{/snippet}
+
+{#if resumable}
+	<div class="mb-2 px-2 py-1 text-2xs text-secondary border rounded bg-surface-secondary">
+		{(run?.totals?.error ?? 0) > 0 ? `${run?.totals?.error} failed` : ''}{(run?.totals?.error ??
+			0) > 0 && (run?.totals?.skipped ?? 0) > 0
+			? ', '
+			: ''}{(run?.totals?.skipped ?? 0) > 0 ? `${run?.totals?.skipped} skipped` : ''}. Rebuild only
+		those with <span class="font-mono">dbt retry</span>, instead of the whole project.
+		<span class="inline-block ml-1 align-middle">
+			<Button
+				unifiedSize="2xs"
+				variant="subtle"
+				disabled={resuming}
+				startIcon={{
+					icon: resuming ? Loader2 : RefreshCw,
+					classes: resuming ? 'animate-spin' : undefined
+				}}
+				on:click={resume}>{resuming ? 'Resuming' : 'Resume this run'}</Button
+			>
+		</span>
+	</div>
+{/if}
+
+{#if loading}
+	<div class="flex items-center gap-2 text-xs text-secondary p-3">
+		<Loader2 class="animate-spin" size={14} /> Loading the model graph
+	</div>
+{:else if failed}
+	<div class="text-xs text-secondary p-3">Could not load the model graph.</div>
+{:else if !graph}
+	<div class="text-xs text-secondary p-3">
+		{#if ranTestsOnly}
+			This run selected tests alone, so it built no models. A dbt test is an assertion rather than a
+			relation, so it has no node here — the models it asserts against belong to the runs that build
+			them. Its results are in the table below.
+		{:else}
+			This dbt script has no models in the asset graph. A project that brings its own
+			<span class="font-mono">profiles.yml</span> without naming a
+			<span class="font-mono">profile.warehouse</span> has no warehouse identity to key them on.
+		{/if}
+	</div>
+{:else}
+	<div class="border rounded overflow-hidden flex flex-col">
+		{#if relationDrift > 0}
+			<div class="shrink-0 px-2 py-1 text-2xs text-secondary border-b bg-surface-secondary">
+				{relationDrift}
+				{relationDrift === 1 ? 'model has' : 'models have'} been renamed or moved since this run —
+				{relationDrift === 1 ? 'its node shows' : 'their nodes show'} today's relation, not the one this
+				run wrote.
+			</div>
+		{/if}
+		{#if goneSinceRun > 0}
+			<div class="shrink-0 px-2 py-1 text-2xs text-secondary border-b bg-surface-secondary">
+				{goneSinceRun}
+				{goneSinceRun === 1 ? 'model' : 'models'} this run built {goneSinceRun === 1 ? 'is' : 'are'}
+				no longer in the project — renamed or removed since, so
+				{goneSinceRun === 1 ? 'it is' : 'they are'} not drawn.
+			</div>
+		{/if}
+		<div class="h-80">
+			<AssetGraphCanvas
+				{graph}
+				{selection}
+				{assetRunStatus}
+				onselect={(s) => (selection = s)}
+				showMinimap={false}
+				scrollZoom={false}
+			/>
+		</div>
+		{@render sqlPane()}
+	</div>
+{/if}
diff --git a/frontend/src/lib/components/dbt/DbtRunResult.svelte b/frontend/src/lib/components/dbt/DbtRunResult.svelte
new file mode 100644
index 0000000000..34d7886b30
--- /dev/null
+++ b/frontend/src/lib/components/dbt/DbtRunResult.svelte
@@ -0,0 +1,146 @@
+<script lang="ts">
+	// What a dbt invocation did, per node. The payload is already structured (the
+	// worker settles it from `run_results.json`); this renders it as the run
+	// summary a dbt user reads, instead of leaving them to scroll the JSON or
+	// count PASS/WARN lines in the log.
+	import { CheckCircle2, XCircle, AlertTriangle, MinusCircle, FlaskConical } from 'lucide-svelte'
+	import Tooltip from '$lib/components/Tooltip.svelte'
+	import {
+		splitUniqueId as split,
+		splitRelation,
+		statusRank as rank,
+		type DbtOutcome,
+		type DbtRun
+	} from '$lib/components/dbt/parseDbtRun'
+
+	let { run }: { run: DbtRun } = $props()
+
+	// Failures first, then warnings, then skips: the run's outcome is decided by
+	// a handful of nodes and a long green list buries them.
+	let nodes = $derived([...(run.nodes ?? [])].sort((a, b) => rank(a.status, a.outcome) - rank(b.status, b.outcome)))
+	let totals = $derived(run.totals ?? {})
+	let hasTests = $derived(nodes.some((n) => split(n.unique_id).kind === 'test'))
+
+	function statusClass(status: string, outcome?: DbtOutcome): string {
+		switch (rank(status, outcome)) {
+			case 0:
+				return 'text-red-600 dark:text-red-400'
+			case 1:
+				return 'text-yellow-600 dark:text-yellow-400'
+			case 2:
+				return 'text-secondary'
+			default:
+				return 'text-green-600 dark:text-green-400'
+		}
+	}
+
+	function fmtTime(s: number | undefined): string {
+		if (s === undefined) return ''
+		return s < 1 ? `${Math.round(s * 1000)}ms` : `${s.toFixed(2)}s`
+	}
+
+	// dbt qualifies every part. The database is dropped only when every row shares
+	// it, which is the common case and the noisiest to repeat — a model that
+	// overrode `database` would otherwise render identically to a same-named
+	// relation in another catalog.
+	let oneDatabase = $derived(
+		new Set(
+			nodes
+				.map((n) => n.relation_name)
+				.filter((r): r is string => !!r)
+				.map((r) => splitRelation(r).slice(0, -2).join('.'))
+		).size <= 1
+	)
+	function fmtRelation(relation: string | undefined): string | undefined {
+		if (!relation) return undefined
+		const parts = splitRelation(relation)
+		return (oneDatabase ? parts.slice(-2) : parts).join('.')
+	}
+</script>
+
+<div class="w-full flex flex-col gap-2 mb-2">
+	<div class="flex items-center flex-wrap gap-x-3 gap-y-1 text-xs">
+		{#each [{ k: 'success', label: 'passed', cls: 'text-green-600 dark:text-green-400' }, { k: 'warn', label: 'warned', cls: 'text-yellow-600 dark:text-yellow-400' }, { k: 'error', label: 'failed', cls: 'text-red-600 dark:text-red-400' }, { k: 'skipped', label: 'skipped', cls: 'text-secondary' }] as t (t.k)}
+			{@const n = (totals as Record<string, number | undefined>)[t.k] ?? 0}
+			{#if n > 0}
+				<span class={t.cls}><span class="font-semibold">{n}</span> {t.label}</span>
+			{/if}
+		{/each}
+		<span class="text-secondary">of {totals.total ?? nodes.length} nodes</span>
+		<span class="ml-auto text-secondary font-mono text-2xs">
+			{run.command ?? 'build'} · {run.engine ?? ''}
+			{run.engine_version ?? ''}
+		</span>
+	</div>
+
+	{#if nodes.length > 0}
+		<div class="border rounded overflow-hidden">
+			<table class="w-full text-xs">
+				<thead class="bg-surface-secondary text-secondary">
+					<tr>
+						<th class="text-left font-normal px-2 py-1">Node</th>
+						<th class="text-left font-normal px-2 py-1 w-24">Kind</th>
+						<th class="text-left font-normal px-2 py-1">Relation</th>
+						<th class="text-right font-normal px-2 py-1 w-20">Rows</th>
+						<th class="text-right font-normal px-2 py-1 w-20">Time</th>
+					</tr>
+				</thead>
+				<tbody>
+					{#each nodes as node (node.unique_id)}
+						{@const s = split(node.unique_id)}
+						{@const r = rank(node.status, node.outcome)}
+						<tr class="border-t {r < 2 ? 'bg-surface-secondary/40' : ''}">
+							<td class="px-2 py-1">
+								<div class="flex items-center gap-1.5 min-w-0">
+									<span class={statusClass(node.status, node.outcome)}>
+										{#if r === 0}
+											<XCircle size={13} />
+										{:else if r === 1}
+											<AlertTriangle size={13} />
+										{:else if r === 2}
+											<MinusCircle size={13} />
+										{:else}
+											<CheckCircle2 size={13} />
+										{/if}
+									</span>
+									<span class="font-mono truncate">{s.name}</span>
+									{#if node.message && r < 2}
+										<Tooltip>{node.message}</Tooltip>
+									{/if}
+								</div>
+								{#if node.message && r < 2}
+									<div class="pl-5 text-2xs {statusClass(node.status, node.outcome)} truncate">
+										{node.message}
+									</div>
+								{/if}
+							</td>
+							<td class="px-2 py-1 text-secondary">
+								<span class="inline-flex items-center gap-1">
+									{#if s.kind === 'test'}
+										<FlaskConical size={11} />
+									{/if}
+									{s.kind}
+								</span>
+							</td>
+							<td class="px-2 py-1 font-mono text-secondary truncate">
+								{fmtRelation(node.relation_name) ?? ''}
+							</td>
+							<td class="px-2 py-1 text-right tabular-nums text-secondary">
+								{node.rows_affected ?? ''}
+							</td>
+							<td class="px-2 py-1 text-right tabular-nums text-secondary">
+								{fmtTime(node.execution_time)}
+							</td>
+						</tr>
+					{/each}
+				</tbody>
+			</table>
+		</div>
+		{#if hasTests}
+			<div class="text-2xs text-secondary">
+				A test's severity decides the outcome: dbt's own <span class="font-mono">warn</span> surfaces
+				without failing the job.
+			</div>
+		{/if}
+	{/if}
+</div>
diff --git a/frontend/src/lib/components/dbt/parseDbtRun.test.ts b/frontend/src/lib/components/dbt/parseDbtRun.test.ts
new file mode 100644
index 0000000000..47d6073ef7
--- /dev/null
+++ b/frontend/src/lib/components/dbt/parseDbtRun.test.ts
@@ -0,0 +1,193 @@
+import { describe, it, expect } from 'vitest'
+import {
+	parseDbtRun,
+	relationOutcome,
+	splitRelation,
+	statusRank,
+	splitUniqueId,
+	nodeSelector
+} from './parseDbtRun'
+
+const run = {
+	engine: 'dbt-core-1x',
+	engine_version: '1.12.0',
+	command: 'build',
+	totals: { total: 1, success: 1, error: 0, warn: 0, skipped: 0 },
+	nodes: [{ unique_id: 'model.p.customers', status: 'success' }]
+}
+
+describe('parseDbtRun', () => {
+	it('takes a successful run as-is', () => {
+		expect(parseDbtRun(run)?.engine).toBe('dbt-core-1x')
+	})
+
+	// The worker puts the same JSON in the error message after the exit-status
+	// line, and this is the case worth rendering: the failing node is what the
+	// user came for.
+	it('recovers the run from a failed job’s error message', () => {
+		const failed = {
+			error: {
+				name: 'ExecutionErr',
+				message: `execution error:\nNon-zero exit status for dbt build: 1\n\n${JSON.stringify(run)}`
+			}
+		}
+		expect(parseDbtRun(failed)?.totals?.total).toBe(1)
+	})
+
+	// The failures worth reading are the ones whose message carries braces of its
+	// own — a Jinja template, the compiled SQL, an adapter's own JSON — and the
+	// payload is appended after all of it.
+	it('finds the run past braces in the error text', () => {
+		const failed = {
+			error: {
+				name: 'ExecutionErr',
+				message:
+					'execution error:\nCompilation Error in model x\n  {{ ref("missing") }} depends on {"a": 1}\n' +
+					`Non-zero exit status for dbt build: 1\n\n${JSON.stringify(run)}`
+			}
+		}
+		expect(parseDbtRun(failed)?.totals?.total).toBe(1)
+	})
+
+	// `{nodes, totals}` alone is a shape an ordinary script can return, and it
+	// would then be rendered as somebody's dbt run.
+	it('does not claim an ordinary result that happens to have nodes and totals', () => {
+		expect(parseDbtRun({ nodes: [], totals: {} })).toBeUndefined()
+		expect(parseDbtRun({ engine: 'v8', nodes: [], totals: {} })).toBeUndefined()
+	})
+
+	it('accepts every engine the worker stamps', () => {
+		for (const engine of ['dbt-core-1x', 'dbt-core-2x', 'fusion']) {
+			expect(parseDbtRun({ ...run, engine })?.engine).toBe(engine)
+		}
+	})
+
+	// The payload carries one object per node, so a scan bounded by brace COUNT
+	// gives up on an ordinary project — a few hundred nodes, tests included — and
+	// silently loses the per-model table on exactly the runs it exists for.
+	it('finds the run in a payload with hundreds of nodes', () => {
+		const big = {
+			...run,
+			totals: { total: 400, success: 399, error: 1, warn: 0, skipped: 0 },
+			nodes: Array.from({ length: 400 }, (_, i) => ({
+				unique_id: `model.p.m${i}`,
+				status: i === 0 ? 'error' : 'success'
+			}))
+		}
+		const failed = {
+			error: {
+				name: 'ExecutionErr',
+				message:
+					'execution error:\nCompilation Error {{ ref("x") }} {"a": 1}\n\n' +
+					JSON.stringify(big, null, 2)
+			}
+		}
+		expect(parseDbtRun(failed)?.nodes?.length).toBe(400)
+	})
+
+	it('is undefined for anything unparseable', () => {
+		expect(parseDbtRun(undefined)).toBeUndefined()
+		expect(parseDbtRun('a string')).toBeUndefined()
+		expect(parseDbtRun({ error: { message: 'failed with {not json' } })).toBeUndefined()
+	})
+})
+
+describe('statusRank', () => {
+	// dbt counts `partial success` in totals.error and a retry redoes it, so
+	// ranking it as a pass would contradict the job's own outcome.
+	it('ranks partial success with the failures', () => {
+		expect(statusRank('partial success')).toBe(statusRank('error'))
+		expect(statusRank('PARTIAL SUCCESS')).toBe(0)
+	})
+
+	// The worker publishes `unknown` for a status it does not recognise and counts
+	// it in `totals.error`; ranking it as a pass drew a green check on a node the
+	// same result called an error.
+	// The worker counts `no_op` in totals.skipped — dbt built nothing for that
+	// node — so a green check would claim a run that never happened.
+	it('ranks a no-op with the skips, not with the passes', () => {
+		expect(statusRank('no-op', 'no_op')).toBe(statusRank('skipped', 'skipped'))
+		expect(statusRank('success', 'no_op')).toBe(2)
+	})
+
+	it('ranks an unknown outcome with the failures, not with the passes', () => {
+		expect(statusRank('some-future-dbt-status', 'unknown')).toBe(0)
+		expect(statusRank('success', 'unknown')).toBe(0)
+	})
+
+	it('orders failed before warned before skipped before passed', () => {
+		expect(
+			['success', 'skipped', 'warn', 'error'].sort((a, b) => statusRank(a) - statusRank(b))
+		).toEqual(['error', 'warn', 'skipped', 'success'])
+	})
+})
+
+describe('splitUniqueId', () => {
+	it('splits kind from name and drops a generic test’s uniqueness hash', () => {
+		expect(splitUniqueId('model.jaffle.stg_orders')).toEqual({
+			kind: 'model',
+			name: 'stg_orders'
+		})
+		expect(splitUniqueId('test.jaffle.not_null_orders_id.4e687af8d0')).toEqual({
+			kind: 'test',
+			name: 'not_null_orders_id'
+		})
+		// A model whose name contains a dot keeps it: only tests carry the hash.
+		expect(splitUniqueId('model.jaffle.a.b').name).toBe('a.b')
+	})
+})
+
+describe('relationOutcome', () => {
+	it('agrees with the worker classifier on every status it names', () => {
+		expect(relationOutcome('started')).toBe('running')
+		for (const s of ['success', 'pass', 'PASS', ' Success ']) {
+			expect(relationOutcome(s)).toBe('materialized')
+		}
+		// `partial success` built the relation and then failed its tests; the
+		// worker records it failed, so the colour must agree.
+		for (const s of ['error', 'fail', 'runtime error', 'partial success', 'PARTIAL SUCCESS']) {
+			expect(relationOutcome(s)).toBe('failed')
+		}
+		// Nothing was built, so nothing is coloured.
+		for (const s of ['warn', 'skipped', 'no-op', 'something new']) {
+			expect(relationOutcome(s)).toBeUndefined()
+		}
+	})
+})
+
+describe('splitRelation', () => {
+	it('keeps a period that lives inside a quoted identifier', () => {
+		// The backend supports it, so rendering it as `v2.orders` names a
+		// relation that does not exist.
+		expect(splitRelation('"wh"."analytics.v2"."orders"')).toEqual(['wh', 'analytics.v2', 'orders'])
+		expect(splitRelation('"db"."schema"."name"')).toEqual(['db', 'schema', 'name'])
+		expect(splitRelation('db.schema.name')).toEqual(['db', 'schema', 'name'])
+		// BigQuery backticks and T-SQL brackets quote too.
+		expect(splitRelation('`proj`.`data.set`.`t`')).toEqual(['proj', 'data.set', 't'])
+		expect(splitRelation('[db].[my.schema].[t]')).toEqual(['db', 'my.schema', 't'])
+	})
+
+	// Every one of these dialects escapes its delimiter by doubling it. Dropping
+	// the pair renames the relation, and the manifest keeps the real spelling —
+	// so the run's status would be recorded against a key no graph node has.
+	it('keeps a delimiter the identifier escaped by doubling', () => {
+		expect(splitRelation('"wh"."schema"."a""b"')).toEqual(['wh', 'schema', 'a"b'])
+		expect(splitRelation('`proj`.`da``ta`.`t`')).toEqual(['proj', 'da`ta', 't'])
+		expect(splitRelation('[db].[my]]schema].[t]')).toEqual(['db', 'my]schema', 't'])
+	})
+})
+
+describe('nodeSelector', () => {
+	// Verified against dbt-core 1.12, dbt-core 2.0.0-alpha.5 and fusion
+	// 2.0.0-preview.202: the intersection resolves to the one node whatever the
+	// project's `model-paths` is, while a path-derived FQN resolves to nothing
+	// as soon as that root is more than one segment deep.
+	it('intersects the name with its package, wherever the model sits', () => {
+		expect(nodeSelector('model.jaffle_shop.fct_orders')).toBe('fct_orders,package:jaffle_shop')
+	})
+
+	// Ambiguous across packages, but a selector dbt resolves rather than rejects.
+	it('falls back to the bare name without a package', () => {
+		expect(nodeSelector('fct_orders')).toBe('fct_orders')
+	})
+})
diff --git a/frontend/src/lib/components/dbt/parseDbtRun.ts b/frontend/src/lib/components/dbt/parseDbtRun.ts
new file mode 100644
index 0000000000..aecd3dcf03
--- /dev/null
+++ b/frontend/src/lib/components/dbt/parseDbtRun.ts
@@ -0,0 +1,247 @@
+export type DbtNode = {
+	unique_id: string
+	status: string
+	/** Windmill's stable word for the same result, published beside dbt's own.
+	 *  Preferred wherever a decision is made: `status` is dbt's vocabulary and
+	 *  dbt may rename it. */
+	outcome?: DbtOutcome
+	execution_time?: number
+	rows_affected?: number
+	relation_name?: string
+	message?: string
+}
+
+export type DbtRun = {
+	engine?: string
+	engine_version?: string
+	command?: string
+	totals?: { total?: number; success?: number; error?: number; warn?: number; skipped?: number }
+	nodes?: DbtNode[]
+	/** The arguments the run actually used, as submitted. A `dbt retry` restores
+	 *  the failed run's arguments inside the worker, so the retry job's own args
+	 *  name only the run it resumed — this is the sole way to recover what it
+	 *  really ran with. */
+	invocation_args?: Record<string, unknown>
+}
+
+/** The engines the worker stamps on a result. This is the discriminator: a
+ *  `{nodes, totals}` shape alone is one an ordinary script can return, and it
+ *  would then be rendered as somebody's dbt run. */
+const ENGINES = ['dbt-core-1x', 'dbt-core-2x', 'fusion']
+
+function asDbtRun(v: unknown): DbtRun | undefined {
+	if (!v || typeof v !== 'object') return undefined
+	const o = v as Record<string, unknown>
+	return ENGINES.includes(o.engine as string) &&
+		Array.isArray(o.nodes) &&
+		o.totals != undefined &&
+		typeof o.totals === 'object'
+		? (o as DbtRun)
+		: undefined
+}
+
+/**
+ * The dbt invocation a job result describes, if it describes one.
+ *
+ * On success the result IS the run. On failure the worker puts the same JSON in
+ * the error message after the exit-status line, and that is the case worth
+ * rendering: the failing node is what the user came for.
+ */
+export function parseDbtRun(result: any): DbtRun | undefined {
+	const direct = asDbtRun(result)
+	if (direct) return direct
+	const msg = result?.error?.message
+	if (typeof msg !== 'string') return undefined
+	// The payload is appended pretty-printed, so its `{` is the only one at COLUMN
+	// ZERO — everything nested is indented, and dbt's own error text carries its
+	// braces mid-line. Counting braces instead needs a cap that a real project
+	// blows: forwards on an error full of them, backwards on one `{` per node.
+	for (const line of lineStarts(msg)) {
+		if (msg[line] !== '{') continue
+		try {
+			const run = asDbtRun(JSON.parse(msg.slice(line)))
+			if (run) return run
+		} catch {
+			// A `{` alone on a line inside the error text; the payload is later.
+		}
+	}
+	return undefined
+}
+
+/** Index of the first character of each line, the payload's own `{` among them. */
+function* lineStarts(s: string): Generator<number> {
+	let at = 0
+	while (at !== -1 && at < s.length) {
+		yield at
+		const next = s.indexOf('\n', at)
+		at = next === -1 ? -1 : next + 1
+	}
+}
+
+/** Ordering rank of a node's status: 0 failed, 1 warned, 2 skipped, 3 passed.
+ *
+ *  Both `unknown` and `no_op` rank where the RESULT counts them, not where the
+ *  default would put them: the worker counts `unknown` in `totals.error` and
+ *  `no_op` in `totals.skipped`, so falling through to 3 drew a green check on a
+ *  node the same result called an error, and on one it never built. */
+export function statusRank(status: string, outcome?: DbtOutcome): number {
+	switch (outcome ?? classifyStatus(status)) {
+		case 'failed':
+		case 'unknown':
+			return 0
+		case 'warned':
+			return 1
+		case 'skipped':
+		case 'no_op':
+			return 2
+		default:
+			return 3
+	}
+}
+
+/** The worker's stable vocabulary for a node result, published as `outcome`. */
+export type DbtOutcome =
+	| 'started'
+	| 'passed'
+	| 'failed'
+	| 'warned'
+	| 'skipped'
+	| 'no_op'
+	| 'unknown'
+
+/**
+ * dbt's node status, reduced to the outcomes the UI distinguishes.
+ *
+ * Only for results that predate `outcome`, or for the live event stream, which
+ * carries dbt's word alone. Anything holding a node from a job result should
+ * read `outcome` instead — that is the field the worker publishes precisely so
+ * this mapping is not the contract.
+ */
+function classifyStatus(
+	status: string
+): 'started' | 'passed' | 'failed' | 'warned' | 'skipped' | 'other' {
+	// `partial success` is dbt's word for a node that built but whose tests
+	// failed. The worker counts it in `totals.error` and a retry redoes it, so
+	// showing it green would contradict the job's own outcome.
+	switch (status.trim().toLowerCase()) {
+		case 'started':
+			return 'started'
+		case 'success':
+		case 'pass':
+			return 'passed'
+		case 'error':
+		case 'fail':
+		case 'runtime error':
+		case 'partial success':
+			return 'failed'
+		case 'warn':
+			return 'warned'
+		case 'skipped':
+			return 'skipped'
+		default:
+			return 'other'
+	}
+}
+
+/**
+ * The kind and name behind a dbt `unique_id`, which dbt builds as
+ * `<resource_type>.<package>.<name>`. A generic test's name carries a trailing
+ * hash dbt adds for uniqueness; it is noise in a run summary.
+ */
+export function splitUniqueId(uniqueId: string): { kind: string; name: string } {
+	const parts = uniqueId.split('.')
+	const kind = parts[0] ?? ''
+	let name = parts.slice(2).join('.')
+	if (kind === 'test') name = name.replace(/\.[0-9a-f]{6,}$/, '')
+	return { kind, name: name || uniqueId }
+}
+
+/**
+ * What a node's status says happened to the relation it builds, or `undefined`
+ * when it says nothing.
+ *
+ * Mirrors the worker's `classify_status`, and must keep mirroring it: the two
+ * decide the same thing about the same string, one for the record it writes and
+ * one for the colour drawn over it. `warn`, `skipped` and `no-op` leave the
+ * relation untouched, so they get no colour rather than a misleading one.
+ */
+export function relationOutcome(
+	status: string,
+	outcome?: DbtOutcome
+): 'running' | 'materialized' | 'failed' | undefined {
+	switch (outcome ?? classifyStatus(status)) {
+		case 'started':
+			return 'running'
+		case 'passed':
+			return 'materialized'
+		case 'failed':
+			return 'failed'
+		// `warn`, `skipped` and `no-op` say nothing about the relation: nothing
+		// was written, so its state is whatever the last run left.
+		default:
+			return undefined
+	}
+}
+
+/**
+ * dbt's `relation_name` split into its parts, honouring quoting.
+ *
+ * Mirrors the worker's `split_relation`: `"`, `` ` `` and `[` open a quoted
+ * identifier, and a `.` inside one is part of the name. Splitting on every `.`
+ * turns `"wh"."analytics.v2"."orders"` into a relation called `orders` in a
+ * schema called `v2` — a table that does not exist.
+ */
+export function splitRelation(relation: string): string[] {
+	const parts: string[] = []
+	let current = ''
+	let quote: string | undefined
+	for (let i = 0; i < relation.length; i++) {
+		const c = relation[i]
+		if (quote !== undefined) {
+			const close = quote === '[' ? ']' : quote
+			if (c === close) {
+				// Doubled, which is how each of these dialects escapes its own
+				// delimiter: one literal character, not the end of the identifier.
+				if (relation[i + 1] === close) {
+					current += close
+					i++
+				} else {
+					quote = undefined
+				}
+			} else current += c
+		} else if (c === '"' || c === '`' || c === '[') {
+			quote = c
+		} else if (c === '.') {
+			parts.push(current)
+			current = ''
+		} else {
+			current += c
+		}
+	}
+	parts.push(current)
+	return parts.map((p) => p.trim())
+}
+
+/**
+ * A selector naming exactly one node: `<name>,package:<package>`.
+ *
+ * The comma is dbt's intersection operator, so this reads "the node whose name
+ * is `<name>` and whose package is `<package>`" — one node, since dbt refuses
+ * two models of one name inside a package. A bare name would match the leaf of
+ * every package's FQN, and a package can ship a model whose name the project
+ * also uses.
+ *
+ * Not the FQN (`<package>.<subdirs...>.<name>`), which cannot be rebuilt from
+ * `original_file_path`: how many leading segments are the resource root is
+ * `model-paths`, and dropping exactly one turns `src/models/marts/orders.sql`
+ * into `pkg.models.marts.orders`, which dbt's matcher — equal lengths, from the
+ * front — resolves to nothing at all.
+ *
+ * Without a package, the bare name — ambiguous across packages, but a selector
+ * dbt resolves rather than one it rejects.
+ */
+export function nodeSelector(uniqueId: string): string {
+	const { name } = splitUniqueId(uniqueId)
+	const pkg = uniqueId.split('.')[1]
+	return pkg ? `${name},package:${pkg}` : name
+}
diff --git a/frontend/src/lib/components/dbt/previewRows.ts b/frontend/src/lib/components/dbt/previewRows.ts
new file mode 100644
index 0000000000..48ff56ec4c
--- /dev/null
+++ b/frontend/src/lib/components/dbt/previewRows.ts
@@ -0,0 +1,68 @@
+import { JobService } from '$lib/gen'
+
+/** A model's rows, as `dbt show` returns them. */
+export type DbtPreview =
+	| { pending: true }
+	| { rows: Record<string, unknown>[]; node?: string; tookMs: number }
+	| { error: string }
+
+/**
+ * Preview one model's rows by running its own project's `dbt show`.
+ *
+ * A job, not a query: the rows come from the warehouse through the project's
+ * profile, with its vars and its adapter, which is the only place that knows how
+ * to resolve `ref()` and where the relation actually lives. `show` is therefore
+ * not a run-form command — it is what a table's preview is made of, here and on
+ * the run page's graph.
+ *
+ * `stillWanted` is asked before each poll and before the result is used, so a
+ * preview outlives neither the page that asked for it nor a navigation.
+ */
+export async function previewDbtRows(opts: {
+	workspace: string
+	scriptPath: string
+	/** Pins the preview to a deployed version, for a graph showing that version. */
+	scriptHash?: string | number
+	/** One node: a model name, or `package.model` where two packages share one. */
+	model: string
+	/** The run's own vars, so a descriptor with a required `{{ }}` var resolves. */
+	vars?: Record<string, unknown>
+	limit?: number
+	/** Extra top-level arguments — a run's `{{ placeholder }}` values. */
+	args?: Record<string, unknown>
+	stillWanted?: () => boolean
+}): Promise<DbtPreview | undefined> {
+	const { workspace, scriptPath, scriptHash, model, vars, limit, args, stillWanted } = opts
+	const startedAt = Date.now()
+	const requestBody = {
+		...(args ?? {}),
+		command: { label: 'show', vars: vars ?? {}, model, limit: limit ?? 25 }
+	}
+	try {
+		// By HASH whenever the caller pins one: the SQL on screen is that version's,
+		// and running the deployed one would show today's rows under it — or fail
+		// outright for a model since removed.
+		const id = scriptHash
+			? await JobService.runScriptByHash({
+					workspace,
+					hash: String(scriptHash),
+					requestBody
+				})
+			: await JobService.runScriptByPath({ workspace, path: scriptPath, requestBody })
+		// Polled rather than awaited: a preview is a job, and its engine may need
+		// provisioning on a cold worker.
+		for (let i = 0; i < 90; i++) {
+			await new Promise((r) => setTimeout(r, 1000))
+			if (stillWanted && !stillWanted()) return undefined
+			const done = await JobService.getCompletedJobResultMaybe({ workspace, id })
+			if (!done.completed) continue
+			const res = done.result as { node?: string; show?: Record<string, unknown>[] } | undefined
+			return done.success && res?.show
+				? { rows: res.show, node: res.node, tookMs: Date.now() - startedAt }
+				: { error: 'The preview job failed — open it from Runs for the detail.' }
+		}
+		return { error: 'The preview is still running; open it from Runs.' }
+	} catch (e) {
+		return { error: e instanceof Error ? e.message : String(e) }
+	}
+}
diff --git a/frontend/src/lib/components/flows/content/FlowInputs.svelte b/frontend/src/lib/components/flows/content/FlowInputs.svelte
index 335a37b0c7..e275df3976 100644
--- a/frontend/src/lib/components/flows/content/FlowInputs.svelte
+++ b/frontend/src/lib/components/flows/content/FlowInputs.svelte
@@ -12,7 +12,7 @@
 	import { Check, Code, Zap } from 'lucide-svelte'
 	import SuspendDrawer from './SuspendDrawer.svelte'
 	import { defaultScripts } from '$lib/stores'
-	import { defaultScriptLanguages, processLangs } from '$lib/scripts'
+	import { defaultScriptLanguages, processInlineLangs } from '$lib/scripts'
 	import type { SupportedLanguage } from '$lib/common'
 	import DefaultScripts from '$lib/components/DefaultScripts.svelte'
 	import type { FlowBuilderWhitelabelCustomUi } from '$lib/components/custom_ui'
@@ -48,7 +48,7 @@
 	let filter = $state('')
 
 	let langs = $derived(
-		processLangs(undefined, $defaultScripts?.order ?? Object.keys(defaultScriptLanguages))
+		processInlineLangs(undefined, $defaultScripts?.order ?? Object.keys(defaultScriptLanguages))
 			.map((l) => [defaultScriptLanguages[l], l])
 			.filter(
 				(x) => $defaultScripts?.hidden == undefined || !$defaultScripts.hidden.includes(x[1])
diff --git a/frontend/src/lib/components/flows/content/FlowInputsQuick.svelte b/frontend/src/lib/components/flows/content/FlowInputsQuick.svelte
index dc2cba93d4..7a55ca92fc 100644
--- a/frontend/src/lib/components/flows/content/FlowInputsQuick.svelte
+++ b/frontend/src/lib/components/flows/content/FlowInputsQuick.svelte
@@ -6,7 +6,7 @@
 <script lang="ts">
 	import { sendUserToast } from '$lib/toast'
 	import FlowScriptPickerQuick from '../pickers/FlowScriptPickerQuick.svelte'
-	import { defaultScriptLanguages, processLangs } from '$lib/scripts'
+	import { defaultScriptLanguages, processInlineLangs } from '$lib/scripts'
 	import {
 		defaultScripts,
 		enterpriseLicense,
@@ -225,7 +225,7 @@
 		$insertButtonOpen = false
 	})
 	let langs = $derived(
-		processLangs(undefined, $defaultScripts?.order ?? Object.keys(defaultScriptLanguages))
+		processInlineLangs(undefined, $defaultScripts?.order ?? Object.keys(defaultScriptLanguages))
 			.map((l) => [defaultScriptLanguages[l], l])
 			.filter(
 				(x) => $defaultScripts?.hidden == undefined || !$defaultScripts.hidden.includes(x[1])
diff --git a/frontend/src/lib/components/icons/AssetGenericIcon.svelte b/frontend/src/lib/components/icons/AssetGenericIcon.svelte
index 1e10f38d8a..4f60b75280 100644
--- a/frontend/src/lib/components/icons/AssetGenericIcon.svelte
+++ b/frontend/src/lib/components/icons/AssetGenericIcon.svelte
@@ -1,5 +1,5 @@
 <script lang="ts">
-	import { BoxesIcon, DatabaseIcon, FileIcon, HardDriveIcon, Pyramid } from 'lucide-svelte'
+	import { BoxesIcon, DatabaseIcon, FileIcon, HardDriveIcon, Pyramid, Table2 } from 'lucide-svelte'
 	import type { AssetKind } from '../assets/lib'
 	import DucklakeIcon from './DucklakeIcon.svelte'
 
@@ -22,6 +22,8 @@
 	<BoxesIcon {size} class={className} />
 {:else if assetKind == 'volume'}
 	<HardDriveIcon {size} class={className} />
+{:else if assetKind == 'dbt'}
+	<Table2 {size} class={className} />
 {:else}
 	<Pyramid {size} class={className} />
 {/if}
diff --git a/frontend/src/lib/components/icons/DbtIcon.svelte b/frontend/src/lib/components/icons/DbtIcon.svelte
new file mode 100644
index 0000000000..b647cb215e
--- /dev/null
+++ b/frontend/src/lib/components/icons/DbtIcon.svelte
@@ -0,0 +1,27 @@
+<script lang="ts">
+	interface Props {
+		height?: number
+		width?: number
+	}
+
+	let { height = 24, width = 24 }: Props = $props()
+</script>
+
+<svg
+	xmlns="http://www.w3.org/2000/svg"
+	{width}
+	{height}
+	viewBox="0 0 256 256"
+	preserveAspectRatio="xMidYMid"
+	role="img"
+	aria-label="dbt"
+>
+	<circle cx="128" cy="128" r="120" fill="#FF694A" />
+	<!-- The three crossing bars of the dbt mark. -->
+	<g stroke="#fff" stroke-width="26" stroke-linecap="round">
+		<line x1="128" y1="52" x2="128" y2="204" />
+		<line x1="62" y1="90" x2="194" y2="166" />
+		<line x1="62" y1="166" x2="194" y2="90" />
+	</g>
+	<circle cx="128" cy="128" r="30" fill="#FF694A" />
+</svg>
diff --git a/frontend/src/lib/components/worker_group.ts b/frontend/src/lib/components/worker_group.ts
index d0391b17c2..31d0cee7db 100644
--- a/frontend/src/lib/components/worker_group.ts
+++ b/frontend/src/lib/components/worker_group.ts
@@ -59,7 +59,8 @@ export const defaultTags = [
 	'java',
 	'ruby',
 	'rlang',
-	'duckdb'
+	'duckdb',
+	'dbt'
 	// for related places search: ADD_NEW_LANG
 ]
 /** Strip cache_clear, null/undefined values, empty arrays and empty objects from a worker group config. */
diff --git a/frontend/src/lib/components/workspaceSettings/DbtSettings.svelte b/frontend/src/lib/components/workspaceSettings/DbtSettings.svelte
new file mode 100644
index 0000000000..d472ce6d08
--- /dev/null
+++ b/frontend/src/lib/components/workspaceSettings/DbtSettings.svelte
@@ -0,0 +1,173 @@
+<script module lang="ts">
+	import type { GetSettingsResponse } from '$lib/gen'
+
+	export type DbtWarehouse = { name: string; resource_path?: string; target?: string }
+	export type DbtSettingsType = { warehouses: DbtWarehouse[] }
+
+	/** The name a project reaches when its descriptor names none. */
+	export const DEFAULT_WAREHOUSE = 'main'
+
+	export function convertDbtSettingsFromBackend(
+		settings: GetSettingsResponse['dbt_warehouses']
+	): DbtSettingsType {
+		return {
+			warehouses: Object.entries(settings ?? {}).map(([name, rest]) => ({
+				name,
+				resource_path: (rest as DbtWarehouse)?.resource_path,
+				target: (rest as DbtWarehouse)?.target
+			}))
+		}
+	}
+
+	export function convertDbtSettingsToBackend(
+		settings: DbtSettingsType
+	): Record<string, { resource_path: string; target?: string }> {
+		// Null-prototype: the backend accepts any alphanumeric name, `constructor`
+		// and `toString` among them, and on a plain object those are inherited —
+		// `in` would call them duplicates, and assigning `__proto__` would set the
+		// prototype instead of a key.
+		const out: Record<string, { resource_path: string; target?: string }> = Object.create(null)
+		for (const w of settings.warehouses) {
+			const name = w.name?.trim()
+			if (!name) throw 'A warehouse needs a name'
+			if (name in out) throw 'Settings contain duplicate warehouse name: ' + name
+			if (!w.resource_path) throw 'No resource selected for ' + name
+			out[name] = { resource_path: w.resource_path, target: w.target || undefined }
+		}
+		return out
+	}
+</script>
+
+<script lang="ts">
+	import { Plus, Trash } from 'lucide-svelte'
+	import { Button } from '$lib/components/common'
+	import TextInput from '../text_input/TextInput.svelte'
+	import ResourcePicker from '../ResourcePicker.svelte'
+	import DataTable from '../table/DataTable.svelte'
+	import Head from '../table/Head.svelte'
+	import Row from '../table/Row.svelte'
+	import Cell from '../table/Cell.svelte'
+	import SettingsFooter from './SettingsFooter.svelte'
+	import Description from '$lib/components/Description.svelte'
+	import { WorkspaceService } from '$lib/gen'
+	import { workspaceStore } from '$lib/stores'
+	import { sendUserToast } from '$lib/toast'
+	import { clone } from '$lib/utils'
+
+	let {
+		dbtSettings = $bindable(),
+		dbtSavedSettings = $bindable(),
+		onSave: onSaveProp = undefined,
+		onDiscard = undefined
+	}: {
+		dbtSettings: DbtSettingsType
+		dbtSavedSettings: DbtSettingsType
+		onSave?: () => void
+		onDiscard?: () => void
+	} = $props()
+
+	let hasUnsavedChanges = $derived(
+		JSON.stringify(dbtSettings.warehouses) !== JSON.stringify(dbtSavedSettings.warehouses)
+	)
+
+	async function onSave() {
+		try {
+			const dbt_warehouses = convertDbtSettingsToBackend(dbtSettings)
+			await WorkspaceService.editDbtWarehouses({
+				workspace: $workspaceStore!,
+				requestBody: { dbt_warehouses }
+			})
+			dbtSavedSettings = clone(dbtSettings)
+			sendUserToast('dbt warehouses saved successfully')
+			onSaveProp?.()
+		} catch (e) {
+			sendUserToast(e, true)
+			throw e
+		}
+	}
+</script>
+
+<Description link="https://www.windmill.dev/docs/getting_started/scripts_quickstart/dbt">
+	Where dbt projects in this workspace run. A project names a warehouse by name in its descriptor (<span
+		class="font-mono">profile.warehouse</span
+	>) and reaches
+	<span class="font-mono">{DEFAULT_WAREHOUSE}</span> when it names none, so a project carries no
+	connection of its own. The name is also what its tables are keyed on in the asset graph (<span
+		class="font-mono">dbt://{DEFAULT_WAREHOUSE}/schema/table</span
+	>), so two projects on one warehouse share their nodes. Each entry points at a resource, and
+	configuring one here is what makes it available: anyone who may run a dbt script builds with it
+	and reads its models, without being granted the resource, the same bargain workspace object
+	storage makes.
+</Description>
+
+<DataTable>
+	<Head>
+		<tr>
+			<Cell head first>Name</Cell>
+			<Cell head>Resource</Cell>
+			<Cell head>Target</Cell>
+			<Cell head last />
+		</tr>
+	</Head>
+	<tbody class="divide-y">
+		{#each dbtSettings.warehouses as warehouse, i (i)}
+			<Row>
+				<Cell first>
+					<TextInput
+							bind:value={warehouse.name}
+							inputProps={{ placeholder: DEFAULT_WAREHOUSE }}
+							class="min-w-32"
+						/>
+				</Cell>
+				<Cell>
+					<ResourcePicker class="min-w-48" bind:value={warehouse.resource_path} />
+				</Cell>
+				<Cell>
+					<TextInput
+							bind:value={warehouse.target}
+							inputProps={{ placeholder: 'default' }}
+							class="min-w-24"
+						/>
+				</Cell>
+				<Cell last>
+					<Button
+						size="xs"
+						color="light"
+						variant="border"
+						startIcon={{ icon: Trash }}
+						iconOnly
+						on:click={() => {
+							dbtSettings.warehouses = dbtSettings.warehouses.filter((_, j) => j !== i)
+						}}
+					/>
+				</Cell>
+			</Row>
+		{/each}
+		<Row>
+			<Cell first colspan={4}>
+				<Button
+					size="sm"
+					btnClasses="max-w-fit"
+					variant="default"
+					on:click={() => {
+						dbtSettings.warehouses = [
+							...dbtSettings.warehouses,
+							{ name: dbtSettings.warehouses.length === 0 ? DEFAULT_WAREHOUSE : '' }
+						]
+					}}
+				>
+					<Plus /> New warehouse
+				</Button>
+			</Cell>
+		</Row>
+	</tbody>
+</DataTable>
+
+<SettingsFooter
+	class="mt-6 mb-16"
+	inline
+	{hasUnsavedChanges}
+	{onSave}
+	onDiscard={() => onDiscard?.()}
+	saveLabel="Save dbt warehouses"
+/>
diff --git a/frontend/src/lib/infer.ts b/frontend/src/lib/infer.ts
index 1e0a36af50..db32bf0274 100644
--- a/frontend/src/lib/infer.ts
+++ b/frontend/src/lib/infer.ts
@@ -42,7 +42,8 @@ import initRustParser, { parse_rust } from 'windmill-parser-wasm-rust'
 import initYamlParser, {
 	parse_assets_ansible,
 	parse_ansible,
-	parse_ansible_delegate
+	parse_ansible_delegate,
+	parse_dbt
 } from 'windmill-parser-wasm-yaml'
 import initCSharpParser, { parse_csharp } from 'windmill-parser-wasm-csharp'
 import initNuParser, { parse_nu } from 'windmill-parser-wasm-nu'
@@ -521,6 +522,9 @@ export async function inferArgs(
 			} catch {
 				inferedSchema = parseRSignatureFallback(code)
 			}
+		} else if (language == 'dbt') {
+			await initWasmYaml()
+			inferedSchema = JSON.parse(parse_dbt(code))
 			// for related places search: ADD_NEW_LANG
 		} else {
 			return null
diff --git a/frontend/src/lib/mcpEndpointTools.ts b/frontend/src/lib/mcpEndpointTools.ts
index 70dabb01f6..f67c0415f0 100644
--- a/frontend/src/lib/mcpEndpointTools.ts
+++ b/frontend/src/lib/mcpEndpointTools.ts
@@ -709,7 +709,7 @@ export const mcpEndpointTools: EndpointTool[] = [
                 },
                 "language": {
                         "type": "string",
-                        "description": "Possible values: python3, deno, go, bash, powershell, postgresql, mysql, bigquery, snowflake, mssql, oracledb, graphql, nativets, bun, php, rust, ansible, csharp, nu, java, ruby, rlang, duckdb, bunnative"
+                        "description": "Possible values: python3, deno, go, bash, powershell, postgresql, mysql, bigquery, snowflake, mssql, oracledb, graphql, nativets, bun, php, rust, ansible, csharp, nu, java, ruby, rlang, duckdb, bunnative, dbt"
                 },
                 "kind": {
                         "type": "string",
@@ -1218,7 +1218,7 @@ export const mcpEndpointTools: EndpointTool[] = [
                 },
                 "language": {
                         "type": "string",
-                        "description": "Possible values: python3, deno, go, bash, powershell, postgresql, mysql, bigquery, snowflake, mssql, oracledb, graphql, nativets, bun, php, rust, ansible, csharp, nu, java, ruby, rlang, duckdb, bunnative"
+                        "description": "Possible values: python3, deno, go, bash, powershell, postgresql, mysql, bigquery, snowflake, mssql, oracledb, graphql, nativets, bun, php, rust, ansible, csharp, nu, java, ruby, rlang, duckdb, bunnative, dbt"
                 },
                 "tag": {
                         "type": "string"
@@ -1250,7 +1250,7 @@ export const mcpEndpointTools: EndpointTool[] = [
                                         },
                                         "language": {
                                                 "type": "string",
-                                                "description": "Possible values: python3, deno, go, bash, powershell, postgresql, mysql, bigquery, snowflake, mssql, oracledb, graphql, nativets, bun, php, rust, ansible, csharp, nu, java, ruby, rlang, duckdb, bunnative"
+                                                "description": "Possible values: python3, deno, go, bash, powershell, postgresql, mysql, bigquery, snowflake, mssql, oracledb, graphql, nativets, bun, php, rust, ansible, csharp, nu, java, ruby, rlang, duckdb, bunnative, dbt"
                                         },
                                         "lock": {
                                                 "type": "string",
diff --git a/frontend/src/lib/script_helpers.ts b/frontend/src/lib/script_helpers.ts
index 91e310f5c9..178f4474e7 100644
--- a/frontend/src/lib/script_helpers.ts
+++ b/frontend/src/lib/script_helpers.ts
@@ -1345,6 +1345,43 @@ main <- function(
     return(toJSON(result, auto_unbox = TRUE))
 }
 `
+
+// A dbt script is a whole dbt project: the descriptor below is the script's
+// content, and the project's own files live in its module bundle (the
+// `<script>__dbt/` folder the CLI syncs). Field names track dbt's vocabulary.
+const DBT_INIT_CODE = `# dbt-core-1x (default) | dbt-core-2x | fusion
+engine: dbt-core-1x
+profile:
+  # A warehouse configured on this workspace (Settings -> dbt), by name. Omitted
+  # takes 'main'. The NAME is also the warehouse's identity in the asset graph:
+  # every model becomes dbt://<warehouse>/<schema>/<name>, which is what gives
+  # this project its lineage, and lets a native script reading one of those
+  # tables share the node. A dbt run does not trigger such a script.
+  # warehouse: main
+  # target: prod
+  # Alternatively, keep the project's own file. It runs unchanged, but names a
+  # warehouse only to say where its assets belong:
+  # profiles_yml: profiles.yml
+# Passed to dbt verbatim — this is dbt's selector grammar, not Windmill's
+select: []
+exclude: []
+# build (models and tests interleaved) | after_all | none
+test_behavior: build
+vars: {}
+threads: 4
+full_refresh: false
+# Rebuild the nodes a failed build left failed or skipped, in this same job,
+# before reporting failure. dbt confines a failure to its own subtree, so a
+# transient warehouse error costs those nodes rather than the whole project.
+# Not available on agent workers, whose wait could not observe a cancellation.
+# retry_failed_nodes:
+#   attempts: 2
+#   delay_seconds: 30
+# Extra env for the project's own {{ env_var() }} lookups. A $var: value is
+# resolved to that Windmill variable, so secrets stay out of this file.
+# env:
+#   DBT_PASSWORD: $var:u/user/my_warehouse_password
+`
 // for related places search: ADD_NEW_LANG
 export const INITIAL_CODE = {
 	bun: {
@@ -1443,6 +1480,9 @@ export const INITIAL_CODE = {
 	rlang: {
 		script: R_INIT_CODE
 	},
+	dbt: {
+		script: DBT_INIT_CODE
+	},
 	claudesandbox: {
 		script: CLAUDE_SANDBOX_INIT_CODE
 	},
@@ -1610,6 +1650,8 @@ export function initialCode(
 		return INITIAL_CODE.ruby.script
 	} else if (language == 'rlang') {
 		return INITIAL_CODE.rlang.script
+	} else if (language == 'dbt') {
+		return INITIAL_CODE.dbt.script
 		// for related places search: ADD_NEW_LANG
 	} else if (language == 'bun' || language == 'bunnative') {
 		if (subkind === 'claudesandbox') {
diff --git a/frontend/src/lib/scripts.ts b/frontend/src/lib/scripts.ts
index facb4fa3f0..2122cea62d 100644
--- a/frontend/src/lib/scripts.ts
+++ b/frontend/src/lib/scripts.ts
@@ -3,7 +3,7 @@ import { base } from '$lib/base'
 import type { Schema, SupportedLanguage } from './common'
 import { FlowService, type Script, ScriptService, ScheduleService } from './gen'
 import { hubBaseUrlStore, workspaceStore } from './stores'
-import { getHubFlowIdFromPath } from './utils'
+import { getHubFlowIdFromPath, getLocalSetting } from './utils'
 
 export function scriptLangToEditorLang(
 	lang:
@@ -63,6 +63,10 @@ export function scriptLangToEditorLang(
 		return 'java'
 	} else if (lang == 'rlang') {
 		return 'r'
+	} else if (lang == 'dbt') {
+		// the script content is the YAML descriptor; the project's own files ride
+		// with it as its module bundle
+		return 'yaml'
 		// for related places search: ADD_NEW_LANG
 	} else if (lang == undefined) {
 		return 'typescript'
@@ -170,17 +174,63 @@ const scriptLanguagesArray: [SupportedLanguage | 'docker' | 'bunnative', string]
 	['java', 'Java'],
 	['duckdb', 'DuckDB'],
 	['ruby', 'Ruby'],
-	['rlang', 'R']
+	['rlang', 'R'],
+	['dbt', 'dbt']
 	// for related places search: ADD_NEW_LANG
 ]
+/**
+ * Languages a MODULE-LESS script cannot be written in.
+ *
+ * A dbt script IS its module bundle — `dbt_project.yml` and the models — and a
+ * flow step's or an app's inline script is a raw body with nowhere to carry
+ * one, so choosing it there produces a job that fails when the worker looks for
+ * the project. A flow reaches dbt the same way it reaches any other script: by
+ * path, to a deployed one.
+ */
+const LANGS_NEEDING_MODULES = ['dbt']
+
+/** `processLangs` for a surface whose scripts have no module bundle. */
+export function processInlineLangs(selected: string | undefined, langs: string[]): string[] {
+	return processLangs(selected, langs).filter((l) => !LANGS_NEEDING_MODULES.includes(l))
+}
+
+/**
+ * dbt is not offered as a language for a NEW script: a project bundle is a poor
+ * fit for the generic script editor, and it is moving to one of its own.
+ * Existing dbt scripts still open, run and deploy — `selected` keeps the entry
+ * so one of them still shows its own language in the picker.
+ *
+ * `localStorage.setItem('dbt_language', 'true')` offers it again.
+ */
+const DBT_LANGUAGE_SETTING = 'dbt_language'
+
+export function dbtLanguageOffered(selected?: string): boolean {
+	return selected === 'dbt' || getLocalSetting(DBT_LANGUAGE_SETTING) === 'true'
+}
+
 export function processLangs(selected: string | undefined, langs: string[]): string[] {
+	return processAllLangs(selected, langs).filter((l) => l !== 'dbt' || dbtLanguageOffered(selected))
+}
+
+function processAllLangs(selected: string | undefined, langs: string[]): string[] {
 	if (selected === 'nativets') {
 		return langs
 	} else {
 		let ls = langs.filter((lang) => lang !== 'nativets')
 
 		//those languages are newer and may not be in the saved list
-		let nl = ['bunnative', 'rust', 'ansible', 'csharp', 'nu', 'java', 'duckdb', 'ruby', 'rlang']
+		let nl = [
+			'bunnative',
+			'rust',
+			'ansible',
+			'csharp',
+			'nu',
+			'java',
+			'duckdb',
+			'ruby',
+			'rlang',
+			'dbt'
+		]
 		// for related places search: ADD_NEW_LANG
 		nl.forEach((lang) => {
 			if (!ls.includes(lang)) {
diff --git a/frontend/src/routes/(root)/(logged)/assets/+page.svelte b/frontend/src/routes/(root)/(logged)/assets/+page.svelte
index 6967ff3d19..9237f32977 100644
--- a/frontend/src/routes/(root)/(logged)/assets/+page.svelte
+++ b/frontend/src/routes/(root)/(logged)/assets/+page.svelte
@@ -7,6 +7,7 @@
 	import Head from '$lib/components/table/Head.svelte'
 	import {
 		AssetService,
+		ScriptService,
 		SettingService,
 		WorkspaceService,
 		type AssetKind,
@@ -26,7 +27,11 @@
 	import AssetsUsageDrawer from '$lib/components/assets/AssetsUsageDrawer.svelte'
 	import AssetGenericIcon from '$lib/components/icons/AssetGenericIcon.svelte'
 	import { Tooltip } from '$lib/components/meltComponents'
-	import { AlertTriangle, Loader2, SettingsIcon, StarIcon } from 'lucide-svelte'
+	import { AlertTriangle, Loader2, SettingsIcon, StarIcon, TableProperties } from 'lucide-svelte'
+	import { previewDbtRows, type DbtPreview } from '$lib/components/dbt/previewRows'
+	import { nodeSelector } from '$lib/components/dbt/parseDbtRun'
+	import Drawer from '$lib/components/common/drawer/Drawer.svelte'
+	import DrawerContent from '$lib/components/common/drawer/DrawerContent.svelte'
 	import { StaleWhileLoading, useInfiniteQuery, useScrollToBottom } from '$lib/svelte5Utils.svelte'
 	import { resource, watch, type ResourceReturn } from 'runed'
 	import RefreshButton from '$lib/components/common/button/RefreshButton.svelte'
@@ -55,7 +60,8 @@
 		'variable',
 		'ducklake',
 		'datatable',
-		'volume'
+		'volume',
+		'dbt'
 	])
 
 	// FilterSearchbar setup
@@ -111,6 +117,113 @@
 	let s3FilePicker: S3FilePicker | undefined = $state()
 	let assetsUsageDropdown: AssetsUsageDrawer | undefined = $state()
 
+	// A `dbt://` asset's rows, previewed through the dbt project that writes it.
+	// The producer is the asset's own WRITE usage — a table nobody writes has no
+	// project to ask, and no `ref()` to resolve the relation with.
+	type AssetRow = { path: string; kind: string; usages: { path: string; kind: string; access_type?: string }[] }
+	function dbtProducerOf(asset: AssetRow): string | undefined {
+		if (asset.kind !== 'dbt') return undefined
+		// A DEFINITE writer. A bare `dbt://…` literal in a native script is stored
+		// with no access type at all, so treating "not read" as "writes" would pick
+		// a Python consumer — and previewing would then RUN that script and its side
+		// effects instead of `dbt show`. Its being a dbt script is checked before
+		// anything is submitted.
+		return asset.usages.find(
+			(u) => u.kind === 'script' && (u.access_type === 'w' || u.access_type === 'rw')
+		)?.path
+	}
+	let previewDrawer: Drawer | undefined = $state()
+	let previewTitle = $state('')
+	let preview = $state<DbtPreview | undefined>(undefined)
+	let previewSeq = 0
+	// A warehouse row can hold JSON, an array or a struct; `String()` renders those
+	// as `[object Object]`, which says less than nothing about the data.
+	function cell(v: unknown): string {
+		if (v == undefined) return ''
+		return typeof v === 'object' ? JSON.stringify(v) : String(v)
+	}
+	async function previewTable(asset: AssetRow) {
+		const ws = $workspaceStore
+		const script = dbtProducerOf(asset)
+		if (!ws || !script) return
+		previewTitle = asset.path.split('/').pop() ?? asset.path
+		preview = { pending: true }
+		previewDrawer?.openDrawer()
+		const seq = ++previewSeq
+		const fail = (error: string) => {
+			if (seq === previewSeq) preview = { error }
+		}
+		try {
+			// A relation outlives the script that wrote it: deleting a dbt script
+			// leaves its `usages` behind, and the raw 404 that follows says nothing
+			// about which script or why.
+			const producer = await ScriptService.getScriptByPath({
+				workspace: ws,
+				path: script
+			}).catch(() => undefined)
+			if (!producer) {
+				return fail(
+					`${script} is recorded as writing this table but no longer exists, so there is ` +
+						`nothing to preview it with.`
+				)
+			}
+			if (producer.language !== 'dbt') {
+				return fail(`${script} writes this table but is not a dbt script, so there is no model to preview.`)
+			}
+			// A project whose descriptor interpolates `{{ }}` needs those values to
+			// run at all, and this page has nowhere to ask for them. Say so instead
+			// of submitting a job that fails inside dbt.
+			const needs = (((producer.schema as any)?.required ?? []) as string[]).filter(
+				(r) => r !== 'command'
+			)
+			if (needs.length > 0) {
+				return fail(
+					`${script} takes run arguments (${needs.join(', ')}), so previewing it needs the ` +
+						`run form — open the script and run \`show\` there.`
+				)
+			}
+			// dbt selects by MODEL name; the asset path ends in the relation's name,
+			// which `alias`/`identifier` may have moved away from it. The graph
+			// carries the provenance, so ask it rather than guessing from the path.
+			//
+			// Pinned to THIS script's version, which is what makes the answer the
+			// right one: provenance keeps a single winner per relation workspace-wide,
+			// so where two projects write one table the unpinned graph may name the
+			// other project's model — and running this script with that selector
+			// previews a model it does not have.
+			const graph = await AssetService.getAssetsGraph({
+				workspace: ws,
+				assetKinds: 'dbt',
+				dbtScriptHash: String(producer.hash)
+			})
+			const uniqueId = graph.assets?.find(
+				(a: any) => a.kind === asset.kind && a.path === asset.path
+			)?.dbt?.unique_id
+			if (!uniqueId) {
+				return fail(
+					`${script} writes this table but its deployed version builds no model for it, ` +
+						`so there is nothing to preview.`
+				)
+			}
+			if (seq !== previewSeq) return
+			const res = await previewDbtRows({
+				workspace: ws,
+				scriptPath: script,
+				// The SAME version the selector came from: a deploy between the
+				// provenance lookup and this submission would otherwise run a newer
+				// project with the older one's model id, previewing a renamed
+				// relation or failing outright for one since removed.
+				scriptHash: producer.hash,
+				model: nodeSelector(uniqueId),
+				stillWanted: () => seq === previewSeq
+			})
+			if (seq === previewSeq && res) preview = res
+		} catch (e) {
+			fail(e instanceof Error ? e.message : String(e))
+		}
+	}
+
+
 	let allS3Storages = resource(
 		() => $workspaceStore,
 		() =>
@@ -386,6 +499,17 @@
 						{#if assetCanBeExplored(asset, asset.metadata) && !$userStore?.operator}
 							<ExploreAssetButton {asset} {s3FilePicker} _resourceMetadata={asset.metadata} />
 						{/if}
+						{#if dbtProducerOf(asset) && !$userStore?.operator}
+							<Button
+								size="xs2"
+								color="light"
+								variant="border"
+								startIcon={{ icon: TableProperties }}
+								on:click={() => previewTable(asset)}
+							>
+								Preview
+							</Button>
+						{/if}
 						{#if asset.kind === 'resource' && asset.metadata === undefined}
 							<Tooltip class={'w-24 flex items-center justify-center'}>
 								<AlertTriangle size={20} class="text-orange-600 dark:text-orange-500" />
@@ -410,3 +534,40 @@
 		</tbody>
 	</DataTable>
 {/snippet}
+
+<Drawer bind:this={previewDrawer} size="800px">
+	<DrawerContent title={`Rows of ${previewTitle}`} on:close={() => previewDrawer?.closeDrawer()}>
+		{#if preview && 'pending' in preview}
+			<div class="flex items-center gap-2 text-xs text-secondary">
+				<Loader2 size={14} class="animate-spin" /> Previewing the first rows…
+			</div>
+		{:else if preview && 'error' in preview}
+			<div class="text-xs text-red-600 dark:text-red-400">{preview.error}</div>
+		{:else if preview && 'rows' in preview}
+			{#if preview.rows.length === 0}
+				<div class="text-xs text-secondary">No rows.</div>
+			{:else}
+				<div class="overflow-auto">
+					<table class="text-xs w-full">
+						<thead>
+							<tr>
+								{#each Object.keys(preview.rows[0]) as col}
+									<th class="text-left px-2 py-1 font-semibold border-b">{col}</th>
+								{/each}
+							</tr>
+						</thead>
+						<tbody>
+							{#each preview.rows as row}
+								<tr>
+									{#each Object.keys(preview.rows[0]) as col}
+										<td class="px-2 py-1 border-b font-mono">{cell(row[col])}</td>
+									{/each}
+								</tr>
+							{/each}
+						</tbody>
+					</table>
+				</div>
+			{/if}
+		{/if}
+	</DrawerContent>
+</Drawer>
diff --git a/frontend/src/routes/(root)/(logged)/pipeline/[folder]/+page.svelte b/frontend/src/routes/(root)/(logged)/pipeline/[folder]/+page.svelte
index 6123c07000..13c66840ae 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 { hideDbtRunnables } from '$lib/components/assets/AssetGraph/hideDbtRunnables'
 	import { buildSchemaContractContext } from '$lib/components/assets/AssetGraph/schemaContracts'
 	import {
 		computeDownstreamClosure,
@@ -188,7 +189,8 @@
 		resource: '$res:',
 		ducklake: 'ducklake://',
 		datatable: 'datatable://',
-		volume: 'volume://'
+		volume: 'volume://',
+		dbt: 'dbt://'
 	}
 
 	// Path-input split for the insert menu: a read-only `f/<folder>/` chip
@@ -1964,6 +1966,15 @@
 	// running a draft via runScriptPreview creates a `preview`-kind job at
 	// the same path, which the panel's listing query picks up.
 	let selectionProducers = $derived(assetProducers(graphWithDraft, pe.selection))
+	// dbt provenance of the selected relation: the details pane renders the
+	// model's own SQL from it. Looked up on the asset, not the producer — a
+	// relation carries one description whichever script materializes it.
+	let selectionDbt = $derived.by(() => {
+		const sel = pe.selection
+		if (sel?.kind !== 'asset') return undefined
+		return graphWithDraft?.assets?.find((a) => a.kind === sel.asset_kind && a.path === sel.path)
+			?.dbt
+	})
 
 	// Empty graph reused when the trace isn't shown (no ducklake-asset selection,
 	// or a draft is actively edited) so the pane blanks out like the other
@@ -2221,7 +2232,7 @@
 				signal
 			})
 			if (!res.ok) throw new Error(`GET /assets/graph → ${res.status}`)
-			return (await res.json()) as AssetGraphResponse
+			return hideDbtRunnables((await res.json()) as AssetGraphResponse)
 		}
 	)
 
@@ -2585,6 +2596,7 @@
 				canRunByPath={openScriptHasDataUpload}
 				onRunByPath={runByPathLegit}
 				{selectionProducers}
+				{selectionDbt}
 				selectionColumnGraph={pe.activeDraft ? EMPTY_COLUMN_GRAPH : columnGraph}
 				{schemaCanEvolve}
 				{selectionForkMaterialization}
diff --git a/frontend/src/routes/(root)/(logged)/run/[...run]/+page.svelte b/frontend/src/routes/(root)/(logged)/run/[...run]/+page.svelte
index a77a2f13ad..397394a14e 100644
--- a/frontend/src/routes/(root)/(logged)/run/[...run]/+page.svelte
+++ b/frontend/src/routes/(root)/(logged)/run/[...run]/+page.svelte
@@ -49,6 +49,7 @@
 		rememberRerunOrigin
 	} from '$lib/components/runs/rerunResolution.svelte'
 	import DisplayResult from '$lib/components/DisplayResult.svelte'
+	import DbtRunGraph from '$lib/components/dbt/DbtRunGraph.svelte'
 	import DispatchEventsPanel from '$lib/components/runs/DispatchEventsPanel.svelte'
 	import UpstreamSnapshotsPanel from '$lib/components/runs/UpstreamSnapshotsPanel.svelte'
 	import {
@@ -429,7 +430,10 @@
 	}
 
 	let runImmediatelyLoading = $state(false)
-	async function runImmediately() {
+	// An override may be a function, because the arguments it merges into are not
+	// known until they are here: a `WINDMILL_TOO_BIG` payload is a placeholder
+	// until fetched, and merging over that one drops what the fetch was for.
+	async function runImmediately(argsOverride?: ScriptArgs | ((args: ScriptArgs) => ScriptArgs)) {
 		runImmediatelyLoading = true
 		try {
 			let args = job?.args as ScriptArgs
@@ -439,6 +443,10 @@
 					id: job?.id!
 				})) as ScriptArgs
 			}
+			args =
+				typeof argsOverride === 'function'
+					? argsOverride(args ?? {})
+					: { ...args, ...(argsOverride ?? {}) }
 
 			const commonArgs = {
 				workspace: $workspaceStore!,
@@ -478,11 +486,54 @@
 			} else {
 				sendUserToast('Cannot run this job immediately', true)
 			}
+		} catch (err) {
+			// A refusal is the interesting case here: the worker rejects a `dbt
+			// retry` whose run is no longer the saved one, and a caller who saw
+			// nothing happen would just click again.
+			sendUserToast(`Could not create job: ${err}`, true)
 		} finally {
 			runImmediatelyLoading = false
 		}
 	}
 
+	// Whether a `dbt retry` submitted from here would resume THIS run: only the
+	// latest failure of a script is kept per principal, so a later run of it — or
+	// one that failed with nothing to rebuild — leaves this page's retry refused.
+	// Both entry points to it, the dropdown item and the graph's banner, ask.
+	let dbtResumable = $state(false)
+	$effect(() => {
+		const ws = $workspaceStore
+		const id = job?.id
+		const failed = job?.language === 'dbt' && job?.type === 'CompletedJob' && !job?.success
+		dbtResumable = false
+		if (!ws || !id || !failed) return
+		JobService.getDbtResumable({ workspace: ws, id })
+			.then((held) => {
+				// The page may have moved on, or the workspace changed, in flight.
+				if (job?.id === id && $workspaceStore === ws) dbtResumable = held === id
+			})
+			.catch(() => {})
+	})
+
+	// The retry goes through `runImmediately` so it carries the run's own arguments
+	// and resolved tag: worker tags, debounce and concurrency keys interpolate from
+	// the submitted arguments at enqueue, while the ones being resumed are restored
+	// later, inside the worker.
+	async function resumeDbtRun() {
+		// Merged INTO the run's own block, not put in its place: those fields are
+		// what a `$args[command.vars.tenant]` tag or concurrency key interpolates
+		// from at enqueue. The worker ignores them for a retry — it rebuilds with
+		// the arguments the failed run had — but the queue has already read them.
+		await runImmediately((args) => ({
+			...args,
+			command: {
+				...((args?.['command'] as Record<string, any> | undefined) ?? {}),
+				label: 'retry',
+				dbt_retry_job: job?.id
+			}
+		}))
+	}
+
 	let showEditButton = $derived(!isRuleActive('DisableDirectDeployment'))
 
 	$effect(() => {
@@ -794,8 +845,14 @@
 			{#if job?.job_kind === 'script' || job?.job_kind === 'script_hub' || job?.job_kind === 'flow'}
 				<Button
 					on:click|once={async () => {
+						// The form this lands on rebuilds the whole project. When resuming
+						// THIS run is the cheaper thing to do, name it so the form can
+						// offer that in one click rather than leaving the reader to know.
+						const from = dbtResumable ? `?dbt_retry_from=${job?.id}` : ''
 						goto(
-							viewHref + `#${computeSharableHash(job?.args, await getRerunTagOverride(job?.args))}`
+							viewHref +
+								from +
+								`#${computeSharableHash(job?.args, await getRerunTagOverride(job?.args))}`
 						)
 					}}
 					unifiedSize="md"
@@ -803,6 +860,11 @@
 					startIcon={{ icon: RefreshCw }}
 					loading={runImmediatelyLoading}
 					dropdownItems={[
+						// A failed dbt run's cheap next step is resuming its failed and skipped
+						// nodes rather than rebuilding the project, and `dbt_command` is the
+						// only argument that differs. Offered first, and only while the saved
+						// failure is still this run — which is what `dbtResumable` answers.
+						...(dbtResumable ? [{ label: 'dbt retry with same args', onClick: resumeDbtRun }] : []),
 						{
 							label: 'Run immediately with same args',
 							onClick: () => runImmediately()
@@ -972,6 +1034,25 @@
 					<JobProgressBar {job} {scriptProgress} class="py-4" hideStepTitle={true} />
 				{/if}
 
+				<!-- The models a dbt run touches, above its result: the run page is
+				     where you land on a running job, and the per-node table below
+				     only exists once the job has produced one. -->
+				{#if job?.language === 'dbt' && job?.script_path}
+					<div class="mr-2 sm:mr-0 mt-12">
+						<h3 class="text-xs font-semibold text-emphasis mb-1">Models</h3>
+						<DbtRunGraph
+							scriptPath={job.script_path}
+							jobId={job.id}
+							running={job.type !== 'CompletedJob'}
+							result={job.type === 'CompletedJob' ? job.result : undefined}
+							scriptHash={job.script_hash}
+							runArgs={job.args}
+							canResume={dbtResumable}
+							onResume={resumeDbtRun}
+						/>
+					</div>
+				{/if}
+
 				<!-- Result Section (moved outside tabs) -->
 				{#if job}
 					<div class="mr-2 sm:mr-0 mt-12 mb-6">
diff --git a/frontend/src/routes/(root)/(logged)/scripts/get/[...hash]/+page.svelte b/frontend/src/routes/(root)/(logged)/scripts/get/[...hash]/+page.svelte
index ff6b41bc1f..e9f1c1e2d0 100644
--- a/frontend/src/routes/(root)/(logged)/scripts/get/[...hash]/+page.svelte
+++ b/frontend/src/routes/(root)/(logged)/scripts/get/[...hash]/+page.svelte
@@ -40,6 +40,7 @@
 	} from '$lib/components/common'
 	import Skeleton from '$lib/components/common/skeleton/Skeleton.svelte'
 	import RunForm from '$lib/components/RunForm.svelte'
+	import DbtRunGraph from '$lib/components/dbt/DbtRunGraph.svelte'
 	import { goto } from '$lib/navigation'
 	import MoveDrawer from '$lib/components/MoveDrawer.svelte'
 
@@ -359,6 +360,74 @@
 		}
 	}
 
+	// A dbt retry must name the run it resumes, and a job id is not something to
+	// type from memory: picking `retry` fills the field with the run this caller's
+	// retry would land on. Filled once per script, so clearing it stays cleared.
+	let dbtResumableAsked: string | undefined = $state(undefined)
+	$effect(() => {
+		const ws = $workspaceStore
+		const path = script?.path
+		const command = args?.['command'] as Record<string, any> | undefined
+		if (!ws || !path || script?.language !== 'dbt' || command?.label !== 'retry') return
+		if (command['dbt_retry_job'] || dbtResumableAsked === path) return
+		dbtResumableAsked = path
+		JobService.getDbtResumableForScript({ workspace: ws, path })
+			.then((held) => {
+				// The page may show another script, or another workspace, by now:
+				// filling THIS answer into that form aims its retry at a run of a
+				// script it is not, which only a reload could undo.
+				if ($workspaceStore !== ws || script?.path !== path) return
+				const current = untrack(() => args)
+				const block = current?.['command'] as Record<string, any> | undefined
+				if (!held || !current || block?.label !== 'retry' || block['dbt_retry_job']) return
+				args = { ...current, command: { ...block, dbt_retry_job: held } }
+				if (jsonView) {
+					runForm?.setCode(JSON.stringify(args, null, '\t'))
+				}
+			})
+			.catch(() => {})
+	})
+
+	// Arrived from a failed dbt run's `Run again`, which prefills the arguments it
+	// ran with — a whole-project rebuild. Resuming that run instead is usually
+	// what the reader wants and there is nothing on this form that says so, hence
+	// the offer. Confirmed against the run rather than trusted from the URL: only
+	// the latest failure of a script is resumable, and by the time the form opens
+	// another run may hold it.
+	let dbtRetryFrom: string | undefined = $state(undefined)
+	$effect(() => {
+		const ws = $workspaceStore
+		const from = page.url.searchParams.get('dbt_retry_from') ?? undefined
+		dbtRetryFrom = undefined
+		if (!ws || !from || script?.language !== 'dbt') return
+		JobService.getDbtResumable({ workspace: ws, id: from })
+			.then((held) => {
+				if ($workspaceStore === ws && held === from) dbtRetryFrom = from
+			})
+			.catch(() => {})
+	})
+
+	function useDbtRetry() {
+		const from = dbtRetryFrom
+		if (!from) return
+		// Merged, never replaced: a tag, concurrency key or debounce key may
+		// interpolate `command.vars`, and the QUEUE reads those at enqueue — long
+		// before the worker restores the failed run's own arguments. Dropping them
+		// here routes the retry by a different key than the run it resumes. Same
+		// as the run page's retry.
+		args = {
+			...(args ?? {}),
+			command: {
+				...((args?.['command'] as Record<string, any> | undefined) ?? {}),
+				label: 'retry',
+				dbt_retry_job: from
+			}
+		}
+		if (jsonView) {
+			runForm?.setCode(JSON.stringify(args, null, '\t'))
+		}
+	}
+
 	let moveDrawer: MoveDrawer | undefined = $state()
 	let deploymentDrawer: DeployWorkspaceDrawer | undefined = $state()
 	let persistentScriptDrawer: PersistentScriptDrawer | undefined = $state()
@@ -751,11 +820,20 @@
 				<NoDirectDeployAlert onUpdateCanEditStatus={(v) => (showEditButtons = v)} />
 			</div>
 			{#if script}
-				<div class={twMerge('flex flex-col', isWac ? 'h-full divide-y' : '')}>
+				{@const showsDbtGraph = script.language === 'dbt' && !!script.path}
+				<div
+					class={twMerge(
+						'flex flex-col',
+						isWac || showsDbtGraph ? 'h-full divide-y' : ''
+					)}
+				>
 					<div
 						class={twMerge(
 							'p-8 w-full max-w-3xl overflow-y-auto mx-auto flex flex-col relative',
-							isWac ? 'max-h-1/2' : ''
+							isWac ? 'max-h-1/2' : '',
+							// The graph takes the rest of the pane, as a flow's does, so the form
+							// scrolls within its half instead of pushing the models off-screen.
+							showsDbtGraph ? 'shrink-0 max-h-1/2' : ''
 						)}
 					>
 						{#if script?.path}
@@ -856,6 +934,25 @@
 								</div>
 							{/if}
 
+							<!-- Landed here from a failed dbt run's `Run again`, which prefills a
+							     whole-project rebuild. Resuming that run is one click, and the
+							     form alone never says it is possible. -->
+							{#if dbtRetryFrom && (args?.['command'] as any)?.label !== 'retry'}
+								<div class="mb-2">
+									<Alert type="info" size="xs" title="This rebuilds the whole project">
+										<div class="flex flex-row gap-2 items-center flex-wrap">
+											<span>
+												The run you came from failed part-way. <span class="font-mono">dbt retry</span>
+												rebuilds only its failed and skipped nodes, with the arguments it ran with.
+											</span>
+											<Button size="xs" variant="border" color="light" on:click={useDbtRetry}>
+												Retry that run instead
+											</Button>
+										</div>
+									</Alert>
+								</div>
+							{/if}
+
 							{#if script?.schema?.prompt_for_ai !== undefined}
 								<AIFormAssistant
 									instructions={script.schema?.prompt_for_ai as string}
@@ -911,7 +1008,19 @@
 							</div>
 						</div>
 					</div>
-					{#if isWac && script.content}
+					{#if showsDbtGraph}
+						<!-- The bottom of the pane, the way a flow's graph takes it: a dbt
+						     script's `content` is a descriptor, so what it BUILDS is the thing
+						     to look at. Pinned to the version on screen and given no job, so
+						     this is the project as THIS deploy declared it; a node opens its
+						     SQL and previews its rows with whatever the form above holds. -->
+						<div class="grow min-h-0 flex flex-col">
+							<h3 class="shrink-0 text-xs font-semibold text-emphasis px-3 pt-2">Models</h3>
+							<div class="grow min-h-0">
+								<DbtRunGraph scriptPath={script.path} scriptHash={script.hash} runArgs={args} />
+							</div>
+						</div>
+					{:else if isWac && script.content}
 						<div class="grow min-h-0" style="min-height: 400px;">
 							<WacDiagram code={script.content} language={script.language ?? ''} />
 						</div>
diff --git a/frontend/src/routes/(root)/(logged)/workspace_settings/+page.svelte b/frontend/src/routes/(root)/(logged)/workspace_settings/+page.svelte
index b93a4baf7a..9407bbcc29 100644
--- a/frontend/src/routes/(root)/(logged)/workspace_settings/+page.svelte
+++ b/frontend/src/routes/(root)/(logged)/workspace_settings/+page.svelte
@@ -65,6 +65,10 @@
 	import Trashbin from '$lib/components/settings/Trashbin.svelte'
 	import { untrack } from 'svelte'
 	import { getHandlerType } from '$lib/components/triggers/utils'
+	import DbtSettings, {
+		convertDbtSettingsFromBackend,
+		type DbtSettingsType
+	} from '$lib/components/workspaceSettings/DbtSettings.svelte'
 	import DucklakeSettings, {
 		convertDucklakeSettingsFromBackend,
 		type DucklakeSettingsType
@@ -251,6 +255,8 @@
 	let dataTableSettings: DataTableSettingsType = $state({ dataTables: [] })
 	let dataTableSettingsComponent: DataTableSettings | undefined = $state(undefined)
 
+	let dbtSettings: DbtSettingsType = $state({ warehouses: [] })
+	let dbtSavedSettings: DbtSettingsType = $state(untrack(() => dbtSettings))
 	let ducklakeSettings: DucklakeSettingsType = $state({ ducklakes: [] })
 	let ducklakeSavedSettings: DucklakeSettingsType = $state(untrack(() => ducklakeSettings))
 
@@ -379,6 +385,7 @@
 			| 'windmill_lfs'
 			| 'volume_storage'
 			| 'ducklake'
+			| 'dbt'
 			| 'git_sync'
 			| 'default_app'
 			| 'native_triggers'
@@ -641,6 +648,8 @@
 		)
 		s3ResourceSavedSettings = clone(s3ResourceSettings)
 		dataTableSettings = convertDataTableSettingsFromBackend(settings.datatable)
+		dbtSettings = convertDbtSettingsFromBackend(settings.dbt_warehouses)
+		dbtSavedSettings = clone(dbtSettings)
 		ducklakeSettings = convertDucklakeSettingsFromBackend(settings.ducklake)
 		ducklakeSavedSettings = clone(ducklakeSettings)
 
@@ -937,6 +946,13 @@
 		s3ResourceSettings.volumeStorage = s3ResourceSavedSettings.volumeStorage
 	}
 
+	function getDbtSettingsInitialAndModifiedValues() {
+		return {
+			savedValue: { dbtSettings: dbtSavedSettings },
+			modifiedValue: { dbtSettings: dbtSettings }
+		}
+	}
+
 	// Function to check if there are unsaved changes in ducklake settings
 	function getDucklakeSettingsInitialAndModifiedValues() {
 		return {
@@ -1079,6 +1095,8 @@
 				return getVolumeStorageInitialAndModifiedValues()
 			case 'ducklake':
 				return getDucklakeSettingsInitialAndModifiedValues()
+			case 'dbt':
+				return getDbtSettingsInitialAndModifiedValues()
 			case 'dev_workspace':
 				return getDeploySettingsInitialAndModifiedValues()
 			case 'webhook':
@@ -1144,6 +1162,9 @@
 			case 'windmill_data_tables':
 				dataTableSettingsComponent?.discard()
 				break
+			case 'dbt':
+				dbtSettings = clone(dbtSavedSettings)
+				break
 			case 'default_app':
 				discardDefaultAppSettingsChanges()
 				break
@@ -1277,6 +1298,12 @@
 					label: 'Ducklake',
 					aiId: 'workspace-settings-ducklake',
 					aiDescription: 'Ducklake workspace settings'
+				},
+				{
+					id: 'dbt',
+					label: 'dbt',
+					aiId: 'workspace-settings-dbt',
+					aiDescription: 'dbt warehouses workspace settings'
 				}
 			]
 		},
@@ -2035,6 +2062,14 @@ export async function main(
 									s3ResourceSettings = clone(s3ResourceSavedSettings)
 								}}
 							/>
+						{:else if tab == 'dbt'}
+							<DbtSettings
+								bind:dbtSettings
+								bind:dbtSavedSettings
+								onDiscard={() => {
+									dbtSettings = clone(dbtSavedSettings)
+								}}
+							/>
 						{:else if tab == 'ducklake'}
 							<DucklakeSettings
 								bind:ducklakeSettings
diff --git a/openflow.openapi.yaml b/openflow.openapi.yaml
index 833d43cb91..a2820a7590 100644
--- a/openflow.openapi.yaml
+++ b/openflow.openapi.yaml
@@ -677,6 +677,10 @@ components:
             - ruby
             - rlang
             - duckdb
+            # NOT dbt: a dbt script runs the project carried as its module
+            # bundle, which an inline snippet has none of, and the worker rejects
+            # inline execution — advertising it here would let such a flow
+            # validate and then always fail at runtime.
             # for related places search: ADD_NEW_LANG
         path:
           type: string
@@ -724,6 +728,7 @@ components:
                   - ducklake
                   - datatable
                   - volume
+                  - dbt
               access_type:
                 type: string
                 nullable: true
diff --git a/system_prompts/auto-generated/flow.md b/system_prompts/auto-generated/flow.md
index b63d2e8008..7fdcbaedad 100644
--- a/system_prompts/auto-generated/flow.md
+++ b/system_prompts/auto-generated/flow.md
@@ -343,4 +343,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 for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')","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","bunnative","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 until stopped. The implicit iterator is the iteration counter, so 'flow_input.iter.value' equals 'flow_input.iter.index' (0, 1, 2, ...) and never carries state. To carry state across iterations, a step reads its own previous-iteration result via 'results.<its_own_id>' with a first-iteration fallback - the loop's stop_after_if must then be on that inner step (a plain single-step body with stop_after_if on the loop module does not resolve 'results' across iterations and never terminates); plain counters can instead be derived from 'flow_input.iter.index', which works in every configuration. stop_after_if is evaluated after each iteration - on the loop module 'result' is the last iteration's result","properties":{"modules":{"type":"array","description":"Steps to execute in each iteration","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)"},"description":{"type":"string","description":"Free-text description of the tool given to the AI to decide when and how to call it. Overrides the description auto-derived from the underlying script."},"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":["user_message"]},"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."},"agent":{"type":"string","description":"Path of a reusable `ai_agent` resource (hybrid linking). When set, the agent brain\nconfig (provider/model/system prompt/etc.) and tool set are resolved at runtime from\nthat resource; the module's input_transforms then only carry the flow-local inputs\n(user_message/user_attachments).\n"},"tool_inputs":{"type":"object","description":"Host-local wiring for an agent's tool inputs, keyed by tool id then input key. Binds the\nreferenced agent's tools to this flow's context (flow_input/results) without mutating the\nshared resource; overlaid onto the tools' input_transforms at runtime \u2014 including when\n`agent` is unset, since a step forked for editing keeps these overrides until it is saved\nback or unlinked.\n","additionalProperties":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}}},"parallel":{"type":"boolean","description":"If true, the agent can execute multiple tool calls in parallel"}},"required":["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 for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')","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","bunnative","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","dbt"]},"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 until stopped. The implicit iterator is the iteration counter, so 'flow_input.iter.value' equals 'flow_input.iter.index' (0, 1, 2, ...) and never carries state. To carry state across iterations, a step reads its own previous-iteration result via 'results.<its_own_id>' with a first-iteration fallback - the loop's stop_after_if must then be on that inner step (a plain single-step body with stop_after_if on the loop module does not resolve 'results' across iterations and never terminates); plain counters can instead be derived from 'flow_input.iter.index', which works in every configuration. stop_after_if is evaluated after each iteration - on the loop module 'result' is the last iteration's result","properties":{"modules":{"type":"array","description":"Steps to execute in each iteration","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)"},"description":{"type":"string","description":"Free-text description of the tool given to the AI to decide when and how to call it. Overrides the description auto-derived from the underlying script."},"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":["user_message"]},"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."},"agent":{"type":"string","description":"Path of a reusable `ai_agent` resource (hybrid linking). When set, the agent brain\nconfig (provider/model/system prompt/etc.) and tool set are resolved at runtime from\nthat resource; the module's input_transforms then only carry the flow-local inputs\n(user_message/user_attachments).\n"},"tool_inputs":{"type":"object","description":"Host-local wiring for an agent's tool inputs, keyed by tool id then input key. Binds the\nreferenced agent's tools to this flow's context (flow_input/results) without mutating the\nshared resource; overlaid onto the tools' input_transforms at runtime \u2014 including when\n`agent` is unset, since a step forked for editing keeps these overrides until it is saved\nback or unlinked.\n","additionalProperties":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}}},"parallel":{"type":"boolean","description":"If true, the agent can execute multiple tool calls in parallel"}},"required":["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 affd2b0ce7..5a16e12719 100644
--- a/system_prompts/auto-generated/prompts.ts
+++ b/system_prompts/auto-generated/prompts.ts
@@ -2896,7 +2896,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 for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')","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","bunnative","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 until stopped. The implicit iterator is the iteration counter, so 'flow_input.iter.value' equals 'flow_input.iter.index' (0, 1, 2, ...) and never carries state. To carry state across iterations, a step reads its own previous-iteration result via 'results.<its_own_id>' with a first-iteration fallback - the loop's stop_after_if must then be on that inner step (a plain single-step body with stop_after_if on the loop module does not resolve 'results' across iterations and never terminates); plain counters can instead be derived from 'flow_input.iter.index', which works in every configuration. stop_after_if is evaluated after each iteration - on the loop module 'result' is the last iteration's result","properties":{"modules":{"type":"array","description":"Steps to execute in each iteration","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)"},"description":{"type":"string","description":"Free-text description of the tool given to the AI to decide when and how to call it. Overrides the description auto-derived from the underlying script."},"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":["user_message"]},"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."},"agent":{"type":"string","description":"Path of a reusable \`ai_agent\` resource (hybrid linking). When set, the agent brain\\nconfig (provider/model/system prompt/etc.) and tool set are resolved at runtime from\\nthat resource; the module's input_transforms then only carry the flow-local inputs\\n(user_message/user_attachments).\\n"},"tool_inputs":{"type":"object","description":"Host-local wiring for an agent's tool inputs, keyed by tool id then input key. Binds the\\nreferenced agent's tools to this flow's context (flow_input/results) without mutating the\\nshared resource; overlaid onto the tools' input_transforms at runtime \\u2014 including when\\n\`agent\` is unset, since a step forked for editing keeps these overrides until it is saved\\nback or unlinked.\\n","additionalProperties":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}}},"parallel":{"type":"boolean","description":"If true, the agent can execute multiple tool calls in parallel"}},"required":["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 for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')","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","bunnative","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","dbt"]},"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 until stopped. The implicit iterator is the iteration counter, so 'flow_input.iter.value' equals 'flow_input.iter.index' (0, 1, 2, ...) and never carries state. To carry state across iterations, a step reads its own previous-iteration result via 'results.<its_own_id>' with a first-iteration fallback - the loop's stop_after_if must then be on that inner step (a plain single-step body with stop_after_if on the loop module does not resolve 'results' across iterations and never terminates); plain counters can instead be derived from 'flow_input.iter.index', which works in every configuration. stop_after_if is evaluated after each iteration - on the loop module 'result' is the last iteration's result","properties":{"modules":{"type":"array","description":"Steps to execute in each iteration","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)"},"description":{"type":"string","description":"Free-text description of the tool given to the AI to decide when and how to call it. Overrides the description auto-derived from the underlying script."},"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":["user_message"]},"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."},"agent":{"type":"string","description":"Path of a reusable \`ai_agent\` resource (hybrid linking). When set, the agent brain\\nconfig (provider/model/system prompt/etc.) and tool set are resolved at runtime from\\nthat resource; the module's input_transforms then only carry the flow-local inputs\\n(user_message/user_attachments).\\n"},"tool_inputs":{"type":"object","description":"Host-local wiring for an agent's tool inputs, keyed by tool id then input key. Binds the\\nreferenced agent's tools to this flow's context (flow_input/results) without mutating the\\nshared resource; overlaid onto the tools' input_transforms at runtime \\u2014 including when\\n\`agent\` is unset, since a step forked for editing keeps these overrides until it is saved\\nback or unlinked.\\n","additionalProperties":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}}},"parallel":{"type":"boolean","description":"If true, the agent can execute multiple tool calls in parallel"}},"required":["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
 
diff --git a/system_prompts/auto-generated/skills/write-flow/SKILL.md b/system_prompts/auto-generated/skills/write-flow/SKILL.md
index 2935eaf2f4..41f9ac4cd0 100644
--- a/system_prompts/auto-generated/skills/write-flow/SKILL.md
+++ b/system_prompts/auto-generated/skills/write-flow/SKILL.md
@@ -429,4 +429,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 for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')","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","bunnative","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 until stopped. The implicit iterator is the iteration counter, so 'flow_input.iter.value' equals 'flow_input.iter.index' (0, 1, 2, ...) and never carries state. To carry state across iterations, a step reads its own previous-iteration result via 'results.<its_own_id>' with a first-iteration fallback - the loop's stop_after_if must then be on that inner step (a plain single-step body with stop_after_if on the loop module does not resolve 'results' across iterations and never terminates); plain counters can instead be derived from 'flow_input.iter.index', which works in every configuration. stop_after_if is evaluated after each iteration - on the loop module 'result' is the last iteration's result","properties":{"modules":{"type":"array","description":"Steps to execute in each iteration","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)"},"description":{"type":"string","description":"Free-text description of the tool given to the AI to decide when and how to call it. Overrides the description auto-derived from the underlying script."},"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":["user_message"]},"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."},"agent":{"type":"string","description":"Path of a reusable `ai_agent` resource (hybrid linking). When set, the agent brain\nconfig (provider/model/system prompt/etc.) and tool set are resolved at runtime from\nthat resource; the module's input_transforms then only carry the flow-local inputs\n(user_message/user_attachments).\n"},"tool_inputs":{"type":"object","description":"Host-local wiring for an agent's tool inputs, keyed by tool id then input key. Binds the\nreferenced agent's tools to this flow's context (flow_input/results) without mutating the\nshared resource; overlaid onto the tools' input_transforms at runtime \u2014 including when\n`agent` is unset, since a step forked for editing keeps these overrides until it is saved\nback or unlinked.\n","additionalProperties":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}}},"parallel":{"type":"boolean","description":"If true, the agent can execute multiple tool calls in parallel"}},"required":["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 for loops, use 'flow_input.iter.value' for the current iteration value (in while loops it equals 'flow_input.iter.index')","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","bunnative","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","dbt"]},"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 until stopped. The implicit iterator is the iteration counter, so 'flow_input.iter.value' equals 'flow_input.iter.index' (0, 1, 2, ...) and never carries state. To carry state across iterations, a step reads its own previous-iteration result via 'results.<its_own_id>' with a first-iteration fallback - the loop's stop_after_if must then be on that inner step (a plain single-step body with stop_after_if on the loop module does not resolve 'results' across iterations and never terminates); plain counters can instead be derived from 'flow_input.iter.index', which works in every configuration. stop_after_if is evaluated after each iteration - on the loop module 'result' is the last iteration's result","properties":{"modules":{"type":"array","description":"Steps to execute in each iteration","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)"},"description":{"type":"string","description":"Free-text description of the tool given to the AI to decide when and how to call it. Overrides the description auto-derived from the underlying script."},"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":["user_message"]},"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."},"agent":{"type":"string","description":"Path of a reusable `ai_agent` resource (hybrid linking). When set, the agent brain\nconfig (provider/model/system prompt/etc.) and tool set are resolved at runtime from\nthat resource; the module's input_transforms then only carry the flow-local inputs\n(user_message/user_attachments).\n"},"tool_inputs":{"type":"object","description":"Host-local wiring for an agent's tool inputs, keyed by tool id then input key. Binds the\nreferenced agent's tools to this flow's context (flow_input/results) without mutating the\nshared resource; overlaid onto the tools' input_transforms at runtime \u2014 including when\n`agent` is unset, since a step forked for editing keeps these overrides until it is saved\nback or unlinked.\n","additionalProperties":{"type":"object","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}}},"parallel":{"type":"boolean","description":"If true, the agent can execute multiple tool calls in parallel"}},"required":["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