@voltro/plugin-ai-flows 0.11.0 → 0.11.2

package/CHANGELOG.md

@@ -39,6 +39,96 @@ _Changes staged for the next release accumulate here (rolled up from
 
 ---
 
+## [0.11.2] — 2026-07-24
+
+### Added
+
+- **@voltro/i18n** — Two escapes for adopting typed messages (`createTypedMessages`, #16) app-wide (#19):
+
+  - **`t.dynamic(runtimeKey, values?)`** — a first-class escape for a genuinely runtime-computed key, on both `useT` and the `useTFn()` result. It takes a plain string with NO forced ICU args, so it doesn't fight the strict literal-key surface. Until now the natural escape — casting a computed key to the catalog key union — made things WORSE: that union spans placeholder-bearing keys, so the call then demanded a spurious 2nd ICU arg. `t.dynamic` is the documented, discoverable alternative. - **`LooseTFunction`** — the widened `(id: string, values?) => string` signature to type a `t` pass-through across a package boundary that can't import the app catalog, instead of falling back to `(...args: any[]) => string`. A strict `TypedTFunction` is deliberately NOT assignable to it (a narrowed key param can't satisfy a wider one — that would erase the checking); pass `t.dynamic` at the boundary, which IS a `LooseTFunction`.
+
+  Additive: `TypedTFunction<C>` gains a `.dynamic` member (the callable surface is unchanged, so `Parameters<TypedTFunction<C>>[0]` and existing typed call sites still resolve). `createTypedMessages` attaches `.dynamic` in place on the two translate functions — no new per-render closure, so a captured `t`'s identity stays stable.
+- **@voltro/testing, @voltro/database** — `fixtureRow(table, overrides)` (`@voltro/testing`) completes a partial test row so it satisfies the 0.11.1 required-column insert validation — WITHOUT disabling the check. It fills every NOT-NULL, no-default, non-auto-stamped column the payload omits with a schema-typed placeholder (a `oneOf` column takes its first allowed value; a `unique` column gets a distinct value per call so two fixtures don't collide; `timestamp`/`date` get a fixed epoch), then merges your overrides on top (an explicit value always wins). It leaves out exactly what a caller may omit — nullable, defaulted, and framework auto-stamped columns (id / tenant / audit) — and refuses to guess a structured type (`json` / `bytes` / `vector` / `array` / `interval` / `raw`), throwing a message that names the column and says to pass it explicitly.
+
+  The motivating case: 0.11.1 made the in-memory/test store reject the same partial inserts real Postgres always would (correct — it surfaced a latent prod bug), which turned lean fixtures (`insert(users, { id })`, an omitted required FK) into `TableValidationFailed`. The wrong fix is a `validateInserts: false` knob — it re-hides that bug class, and a test store laxer than production is a fake testing itself. `fixtureRow` is the right one: it makes the fixture COMPLETE.
+
+  ```ts
+  await ctx.store.insert('journal_entries', fixtureRow(journalEntries, {
+    tenantId, amount: '100.00',   // the columns THIS test cares about
+  }))                             // entryNumber, postedAt, … auto-filled + unique
+  ```
+
+  It is a runtime filler for the loose `store.insert(name, row)` path (what fixtures use). For COMPILE-time payload typing, use `insertRow` / `upsertRow` from `@voltro/database`. The auto-stamped column set it skips is now exported as `AUTO_FILLED_COLUMNS` from `@voltro/database` — the same list `InferInsertRow` derives its optional columns from, single-sourced so the two can't drift.
+
+### Changed
+
+- **@voltro/cli** — `voltro build` now emits **directly-executable** boot bundles for BOTH app kinds: the web start bundle (`.framework/dist-web/startBundle/startEntry.js`) and the api serve bundle (`.framework/dist-api/serveBundle/serveEntry.js`) each carry a main-guard that boots the app when run as `node <entry>.js`, and stays inert when imported (the `voltro start` / `voltro serve` dev fast paths are unchanged). Production containers can now use `CMD ["node", "…/startEntry.js"]` (or `serveEntry.js`) instead of `pnpm voltro start` / `pnpm voltro serve` — no pnpm process, no `@voltro/cli` bin at runtime — which is what makes `voltro prune-runtime` safe to enable on both: with the self-contained bundle as the real entrypoint, the @vercel/nft trace roots there and legitimately drops `@voltro/cli` and the whole inlined framework tree (a static site's `node_modules` collapses to ~0; a memory api's 146 MB → 11 MB). `prune-runtime` now also roots the trace at the serve bundle. The serve entry chdir's to the app root BEFORE its app-module registry keys are computed from cwd, preserving relocation-safety. Existing `pnpm voltro start` / `pnpm voltro serve` entrypoints keep working. The standalone Dockerfiles gain a build-time boot smoke that fails the build unless the pruned tree reaches ready.
+
+### Fixed
+
+- **@voltro/i18n** — `createTypedMessages` (#16) no longer extracts phantom required vars from a nested plural/select message (#19). For `'{count, plural, one {# day} other {# days total duration}}'`, the type-level `ICUVars` parse was reading a branch's TEXT (`"# days total duration"`) as a bogus required arg name, so `useT('key', { count })` failed to typecheck even though it renders perfectly — and a real var nested inside a branch was dropped. `ICUArgName` now resolves to `never` for any candidate that isn't a valid ICU identifier (`^[A-Za-z0-9_]+$`), so branch text — which contains spaces / `#` / `—` — is never mistaken for a var. Only the top-level arg (`count`) is required, matching what the message actually needs.
+
+  Scope note: a REAL var nested inside a plural branch (`other {# — {discipline}}`) is still not collected, so it reads as not-required rather than wrongly-required — the safe direction. Apps that pluralise in JS over simple `{count}` messages (the Voltro idiom) were already fully typed and are unaffected.
+- **@voltro/database, @voltro/runtime** — `InferInsertRow` (and thus `insertRow` / `upsertRow`, #15) no longer requires a non-nullable DB-generated (`generatedAs`) column (#20). A stored/virtual generated column declared without `.nullable()` and without a default was typed **required**, but MariaDB/Postgres REJECT an explicit value for a generated column — so the type forced the caller to pass a value the database refuses at runtime. `.generatedAs()` now marks the column optional-for-insert exactly like a `.default()` column (the DB supplies it), so it may be omitted; the whole payload guard on every real column stays intact.
+
+  Two runtime halves complete it, so the loose `store.insert(name, row)` path agrees: the required-column validation (`missingRequiredColumns`) skips generated columns — omitting one is correct, never a missing-column error — and the store write path now STRIPS any value a caller supplied for a generated column before the INSERT reaches the dialect (tracked on the schema registry as `generatedColumns`), so a value from an untyped insert can't blow up on MariaDB. A generated column is never caller-supplied; the framework and the DB own it end to end.
+
+  The `.generatedAs()` return type narrows from `this` to `ColumnBuilder<…, true>` (the HasDefault flag) — a purely more-permissive refinement: it only makes the column omittable, so no existing code stops compiling.
+
+---
+
+## [0.11.1] — 2026-07-23
+
+### Added
+
+- **@voltro/runtime** — `defineExecutor(descriptor, fn)` type-checks a query/mutation/action handler's return against the descriptor's `output` schema Type — so returning a `number` where `output` is `timestampMs` (Type = `Date`) is a COMPILE error at the handler, not a runtime encode failure that Dies the subscription. The gap it closes: the executor is a separate default export whose return was never tied to `output`, so a handler that builds a plain object with a leftover `.getTime()` compiled green and only threw `Expected DateFromSelf, actual 1784…` at encode time — invisible while a nullable date was null, exploding the instant it became non-null.
+
+  Opt-in and zero-cost: it's a runtime identity (returns `fn` unchanged, so the codegen wires it exactly as the bare default export), and the compile check is the whole value. Wrap the handler and import the descriptor into its `*.server.ts`:
+
+  ```ts
+  export default defineExecutor(getRoadmapsByYear, (input, ctx) => …)
+  ```
+
+  The Effect error and requirement channels stay inferred from the handler; only the success value is constrained. A reactive query that returns a `{ descriptor }` builder is allowed through unchecked — the store produces its rows, so a value-level return type can't express that row-vs-output check.
+- **@voltro/database, @voltro/runtime** — An `.encrypted()` column that can't be decrypted with the active key now fails as a typed, readable `FieldDecryptionError` naming the `table.column`, instead of a raw `Error: field cipher: malformed ciphertext` with no context. It carries a `_tag` (the same tagged shape `storeErrors` uses, so `Effect.catchTag` matches), and never includes the ciphertext. The common trigger is restoring a prod/staging snapshot into a dev DB whose `VOLTRO_FIELD_ENCRYPTION_KEY` differs.
+
+  New dev/migration escape hatch: `VOLTRO_FIELD_DECRYPT_ON_ERROR=null` degrades an undecryptable column to `null` (with one deduped warning per `table.column`, scope `store.fieldEncryption`) instead of letting one bad row nuke the whole read — its readable siblings still decrypt. Default stays `'throw'`; never set `null` in production, where a key mismatch must fail loud. `decryptFieldsOnRead` gains an optional `{ onError, warn }` argument (additive); the raw throw is replaced by the typed one, which existing `catch (e: Error)` handlers still catch.
+- **@voltro/i18n** — `assertCatalogParity({ en, de })` checks every locale uses the SAME ICU `{var}` set per key. `defineLocale` enforces KEY parity but not PLACEHOLDER parity — a translation that drops or renames a `{var}` (`'Published on {date}'` → `'Veröffentlicht'`) compiles and boots, then throws `The intl string context variable "date" was not provided` only in that locale, only when the message renders. Call it in a test or at boot; it throws listing every drift (or warns with `onMismatch: 'warn'`). Plural argument names are extracted; a plural's inner `{# item}` branches are not mistaken for placeholders.
+- **@voltro/i18n** — `createTypedMessages<typeof en>()` binds a catalog's LITERAL message types to `useT` / `useTFn` / `<T>`, so a missing ICU placeholder is a COMPILE error instead of a runtime throw at format time. Until now `defineCatalog` / `defineLocale` enforced key PARITY across locales, but the call site `t('key', values)` was untyped — a message like `'Published on {date}'` called as `t('roadmap.publishedAt')` (or via the `t('key').replace('{{date}}', …)` idiom from other i18n systems) threw `The intl string context variable "date" was not provided` only when it rendered. Now `useT('roadmap.publishedAt')` demands `{ date }` at compile time, and a wrong/missing key is caught too.
+
+  Opt-in and purely additive: call `createTypedMessages` once with your base catalog (`as const`) and re-export the returned `useT`/`useTFn`/`T`; the bare hooks keep their existing loose signatures. Scope: simple `{name}` and single-argument `{count, number}` forms are extracted; messages with nested inline ICU (`{n, plural, one {…} other {…}}` / `select`) accept a loose values bag rather than a wrong strict one — apps that pluralise in JS over simple `{count}` messages stay fully typed. `<T>` gets a typed key with loose values, because its rich-text `<tag>` renderers can't be modelled by `{var}` extraction.
+- **@voltro/plugin-ai-flows** — An AI-flow `MediaGenerator` (and the `makeMediaGenerator` persistence seam) now receives the run it executes within — `run: { runId, tenantId }` — resolved from the durable run row rather than the caller subject. This is what a resume needs: a BOOTSTRAP/crash resume runs under a tenant-less `SYSTEM_SUBJECT`, so a host that persists artifacts per tenant could not read the tenant from `ctx.request.subject` (it isn't there) and would either fail closed or, under an old anonymous fallback, write into the wrong tenant. The engine already loads the run row (for `ownerId`); it now reads `tenantId` from the same row and hands it down to both the deterministic and agentic media steps, and `MediaPersist.put` / `ingestUrl` forward it to `storage.put` / `ingestUrl` so persistence continues in the run's own tenant on replay.
+
+  Additive: `run` is appended to the generator/persist arguments, so a host that ignores it keeps compiling; the tenant is simply available when it doesn't. No `@voltro/web` change — the engine is server-only and not re-exported to the browser surface.
+- **@voltro/client, @voltro/web** — A sequence step's `undo` now receives the accumulated context as a second argument — `undo: (result, ctx) => …` — alongside the step's own result. An inverse usually needs an id from an EARLIER step as well as this one's (`deleteJiraDraftTicket({ jiraKey: created.key, draftId: ctx.draft.id })`), and until now the only way to reach it was to re-return that id from the step purely so the undo could read it back. `ctx` is typed as of the step's definition — the steps before it, the same context `covers` and `when` already see — so a later step's result is deliberately not visible (it is rolled back before this one).
+
+  Additive, not breaking: `StepUndo<Result>` became `StepUndo<Result, Ctx = Record<string, unknown>>` with the context parameter defaulted and appended, so a named `StepUndo<T>` still resolves and an existing single-argument `undo: (r) => …` stays assignable. `@voltro/web` re-exports the client surface, which is why it moves too.
+- **@voltro/cli** — SSR `ctx.query` now has a first-class, server-only api origin for split web/api deployments (#18). Previously, a `renderMode:'ssr'` page reloaded in a split deployment 500'd: the web pod's `POST <origin>/rpc` fell back to the DEV proxy target (`http://localhost:4000`), which nothing serves in production → `ECONNREFUSED` buried in a render error. Browser-reachability and SSR-reachability were conflated into the one `url` field.
+
+  New `apis.<name>.serverUrl` (and env overrides `VOLTRO_API_ORIGIN_<NAME>` / `VOLTRO_API_ORIGIN`) set the origin the WEB POD uses for SSR — the api's internal cluster DNS (`http://api.<ns>.svc.cluster.local`) — distinct from the browser's relative wsPath, and NEVER emitted into the browser bundle. Resolution: env > `serverUrl` > (dev only) the vite proxy target > an external api's absolute url. Under `voltro start` a package api with none resolves to `undefined` and the loader query FAILS LOUD naming the api and the config to set — it never dials the dev localhost port. A transport failure is wrapped naming the api and the origin attempted, instead of a bare `fetch failed`.
+- **@voltro/database, @voltro/runtime** — `store.insert` / `upsert` / `insertIgnore` now raise a clear, typed `TableValidationFailed` naming the column when the payload omits one that is NOT NULL, has no default, and isn't auto-stamped — instead of a raw dialect `SqlError: Failed to execute statement` (`Field '…' doesn't have a default value`) surfaced only on the INSERT path (so it lay dormant until the first row with no existing cache entry). An upsert / insertIgnore whose payload is missing one of its own `conflictColumns` is likewise named at the call (an absent conflict key can't match its target). The check runs AFTER stamping, so auto-id / tenant / audit columns never trip it, and skips nullable, defaulted, and id (`idScheme`) columns — exactly the ones a caller may legitimately omit.
+
+  Two pure helpers back it — `missingRequiredColumns(table, row)` and `missingConflictColumns(conflictColumns, row)` (exported from `@voltro/database`). This is the runtime half of the "handler data silently disagrees with the schema" class; a compile-time payload type needs the column DSL to track `hasDefault` at the type level, which is a separate change.
+
+  **Migration impact — behaviour-breaking for lenient test fixtures.** The in-memory/test store now rejects the same partial inserts a real Postgres always would, so it stops being laxer than production — which is the point (it surfaced at least one latent prod bug where a NOT-NULL `text().unique()` column was written without a value). But a fixture that inserted a partial row (`{ id }` parents, an omitted required FK) and passed against the old lenient memory store now throws `TableValidationFailed`. There is no code-level codemod — the fix is fixture DATA: fill the required columns. Use the new `fixtureRow(table, overrides)` helper in `@voltro/testing`, which fills every NOT-NULL-no-default column with a schema-typed placeholder and merges your overrides on top, so a fixture complies without disabling the check. There is deliberately no opt-out to turn the validation off: a test store that accepts rows production rejects is a fake testing itself.
+- **@voltro/database, @voltro/plugin-ai-flows, @voltro/plugin-audit, @voltro/plugin-deactivation, @voltro/plugin-soft-delete** — Compile-time payload typing for writes (#15) — the type-level half that the runtime `TableValidationFailed` guard flagged as a separate change. `insertRow` / `upsertRow` take the TABLE OBJECT (not a string name), so the payload is checked against `InferInsertRow<T>`: every column is required EXCEPT nullable ones, columns with a default, and the framework-filled id/tenant/audit columns. A missing NOT-NULL-no-default column — the exact `lastRefreshedAt` / `teamId` omission from the report — is now a COMPILE error at the call, not a runtime SqlError only on the INSERT path; `upsertRow`'s `conflictColumns` are constrained to the table's own columns too.
+
+  import { insertRow } from '@voltro/database' await insertRow(ctx.store, roadmapEpicStats, { teamId, lastRefreshedAt: new Date() })
+
+  Enabled by a type-level default flag: `ColumnDefinition` / `ColumnBuilder` gained a third `HasDefault` parameter that `.default()` narrows to `true`. It defaults to `boolean`, so every existing `ColumnDefinition<unknown>` (mixins, query builder, migrate, plugins) is unaffected — the only golden churn is the additive third parameter rendering (e.g. an audit mixin's defaulted `createdAt` now shows `ColumnDefinition<Date, "timestamp", true>`). The string-keyed `store.insert` / `upsert` are unchanged; the typed seam is opt-in.
+- **@voltro/runtime, @voltro/cli** — `voltro dev` now warns, once per tenant-scoped table, when a request reads it with the empty-string tenant sentinel — an authenticated subject that has no resolved org (`tenantId === ''`). The auto-merged tenant filter becomes `eq('tenantId', '')`, which matches no real row, so every such read returns empty WITH NO ERROR — indistinguishable, from the response alone, between "no such row", "filtered by an empty tenant", and "auth half-resolved". The warning names the cause and the fix. `voltro serve` deliberately stays silent (a prod diagnostic on every scoped read is noise). The decision is a pure predicate, `isEmptyTenantScopedRead`, exported from `@voltro/runtime` so it is unit-tested apart from the 6k-line dev boot; `applyTenantScope` itself stays pure.
+- **@voltro/runtime, @voltro/cli** — `voltro dev` now warns once, the first time an authenticated subject resolves with NO active org (a `user` carrying the empty-string tenant sentinel) — "authenticated, but no active org → all tenant-scoped reads will be empty". Broader and earlier than the per-table empty-tenant read warning: it catches the whole class at the door instead of on a specific read. Backed by the pure `isOrglessUserSubject` predicate in `@voltro/runtime`; dev owns the one-time log.
+- **@voltro/cli** — `voltro start` (web) now reports boot timing, matching `voltro serve`. It always logs a structured `start: ready in <n>ms` line (with `bootMs`), counted from PROCESS start so the module-graph load — the phase that dominates a scale-to-zero cold start — is included instead of being missed by a mid-boot baseline; the banner's `bootMs` uses the same total. Under `VOLTRO_BOOT_TIMING=1` the line also carries a per-phase `phases` breakdown (`modules`, `config`, `scan`, `provider`, `routes`, `cdc`, `ready`). Because the total is a structured log record, it is retrievable from the container's `/_voltro/inspect/logs` endpoint, not only from stdout.
+- **@voltro/cli** — Production web images are now self-contained and dramatically smaller. `voltro build` makes every runtime artefact framework-inlined + tree-shaken — the SSR bundle (vite `noExternal: true`), the start bundle, and the precompiled `appConfig` — so a booted `voltro start` needs from `node_modules` only the runtime-external NATIVE leaves it actually reaches (a SQL driver an ISR/config path touches). A new hidden `voltro prune-runtime <deploy-dir>` command (`@vercel/nft`, a new build-time optionalDependency) traces the real reachable set from those bundles + the app's installed native leaves and drops the rest — the whole `@voltro`/effect/react tree that's now dead weight. The standalone web Dockerfiles run it after `pnpm --prod deploy`; for a static/SSR site with no native runtime dep, `node_modules` collapses to nothing. Measured on a real marketing app: the app tree drops from ~210 MB to ~65 MB (node_modules ~145 MB → 0) and still boots + renders. Fully automatic — a used native driver is traced + kept, an unused one dropped, no per-app allow-list — and non-fatal: any trace failure keeps the fuller tree (a bigger image, never a broken one). The appConfig `@voltro/*` imports are now inlined (were external); this is safe because `runEnvGate` consumes the env schema structurally (`isEnvContract` duck-types `{ vars }`, no `instanceof`/Symbol), so a schema built by the config's inlined `@voltro/env` still validates.
+- **@voltro/cli** — `voltro build` now precompiles the web START runtime into a single bundle (`.framework/dist-web/startBundle/startEntry.js`, framework inlined) — the web counterpart to the api serve bundle. `bin/voltro.mjs`'s `voltro start` fast path prefers it, so a cold scale-from-zero web boot loads ONE artefact instead of resolving the whole `@voltro`/effect module graph. Measured on the web-spa-shell fixture: the `modules` boot phase collapses from ~1130 ms to ~67 ms (~17×), directly cutting the phase measured to dominate a scale-to-zero web cold start. Non-fatal — if the bundle build or its import fails, `voltro start` falls back to the per-module CLI entry (correct, just slower). No app or Dockerfile change is needed; the bundle rides in `.framework`, which `pnpm deploy` already copies.
+
+### Fixed
+
+- **@voltro/runtime** — An undeclared infra error no longer reaches the browser as an `ExitEncoded` schema-tree dump (a wall of text that leaks internals and no client can pattern-match). `FieldDecryptionError` — a `.encrypted()` column that can't be decrypted with the active key — now collapses to a generic `InternalError` on both the unary and the subscription paths (it was previously only `SqlError` / `ResultLengthMismatch`, and only on the unary path). Its message names an internal `table.column`, so this also stops that leak; the real cause is logged server-side with the traceId. `TableValidationFailed` is deliberately left through — its summary/issues are meant to be shown to a user. Typed app errors are untouched.
+- **@voltro/cli** — Security: the `/_voltro/inspect/logs` endpoint no longer bypasses the inspect gate. It dumps the process LogBuffer (request URLs + error payloads), but it returned early — above the `isInspectDisabled` / `VOLTRO_INSPECT_TOKEN` checks — so `VOLTRO_INSPECT=off` closed the manifest and metrics (503) while leaving the log buffer publicly readable, and a configured `VOLTRO_INSPECT_TOKEN` was ignored for it. The gate now lives inside `handleLogsRequest`, single-sourced across the three call sites (`voltro start` / `voltro dev` / the web-dev server) that each drifted (start ungated, dev gated nothing, web-dev gated disabled-but-not-token): disabled → 503, missing/bad bearer → 401.
+
+---
+
 ## [0.11.0] — 2026-07-22
 
 ### ⚠ BREAKING

package/dist/index.d.ts

@@ -20,23 +20,23 @@ export declare interface AgentResolution {
 /** `ai_flow_runs` — one execution. `.reactive()`: the engine patches this row
  *  as it progresses and the client's subscription streams the live timeline. */
 export declare const aiFlowRunsTable: Table<"ai_flow_runs", FieldDefinitions<{
-    readonly id: ColumnBuilder<string, "id">;
+    readonly id: ColumnBuilder<string, "id", boolean>;
     /** Name (code flow) or id (data flow). Not an FK — no single target. */
-    readonly flowRef: ColumnBuilder<string, "text">;
+    readonly flowRef: ColumnBuilder<string, "text", boolean>;
     /** Denormalized flow name — survives a definition delete. */
-    readonly flowName: ColumnBuilder<string | null, "text">;
+    readonly flowName: ColumnBuilder<string | null, "text", boolean>;
     /** Snapshot of the mode this run executes in. */
-    readonly mode: ColumnBuilder<string, "text">;
+    readonly mode: ColumnBuilder<string, "text", true>;
     /** pending | running | waiting | succeeded | failed | cancelled. */
-    readonly status: ColumnBuilder<string, "text">;
+    readonly status: ColumnBuilder<string, "text", true>;
     /** manual | cron. */
-    readonly source: ColumnBuilder<string | null, "text">;
+    readonly source: ColumnBuilder<string | null, "text", boolean>;
     /** Correlation + idempotency key (→ the workflow's idempotencyKey). */
-    readonly requestId: ColumnBuilder<string, "text">;
+    readonly requestId: ColumnBuilder<string, "text", boolean>;
     /** Brief values, keyed by `BriefField.key`. */
-    readonly input: ColumnBuilder<Record<string, unknown> | null, "json">;
+    readonly input: ColumnBuilder<Record<string, unknown> | null, "json", boolean>;
     /** The result bundle: `outputKey → value` (what the UI's result dialog reads). */
-    readonly output: ColumnBuilder<Record<string, unknown> | null, "json">;
+    readonly output: ColumnBuilder<Record<string, unknown> | null, "json", boolean>;
     /** Live per-step timeline (`RunStep[]`); the engine writes it on every step. */
     readonly steps: ColumnBuilder<readonly {
         readonly id: number;
@@ -61,16 +61,16 @@ export declare const aiFlowRunsTable: Table<"ai_flow_runs", FieldDefinitions<{
             }[] | undefined;
             readonly mode: "text" | "approve" | "choice";
         } | undefined;
-    }[] | null, "json">;
-    readonly currentStep: ColumnBuilder<number, "integer">;
-    readonly totalSteps: ColumnBuilder<number, "integer">;
+    }[] | null, "json", boolean>;
+    readonly currentStep: ColumnBuilder<number, "integer", true>;
+    readonly totalSteps: ColumnBuilder<number, "integer", true>;
     /** The HITL answer, written by `respond`. */
     readonly humanResponse: ColumnBuilder<{
         readonly value?: string | undefined;
         readonly text?: string | undefined;
         readonly decision?: "approve" | "reject" | undefined;
         readonly respondedAt?: string | undefined;
-    } | null, "json">;
+    } | null, "json", boolean>;
     /** Staged follow-up when the chain requires confirmation. */
     readonly chainPending: ColumnBuilder<{
         readonly input: {
@@ -78,28 +78,28 @@ export declare const aiFlowRunsTable: Table<"ai_flow_runs", FieldDefinitions<{
         };
         readonly status: "pending" | "confirmed" | "dismissed";
         readonly flowRef: string;
-    } | null, "json">;
+    } | null, "json", boolean>;
     /** Accumulated cost in micro-USD (app view projects to €/cents). */
-    readonly costMicroUsd: ColumnBuilder<number, "integer">;
-    readonly durationMs: ColumnBuilder<number | null, "integer">;
-    readonly error: ColumnBuilder<string | null, "text">;
-    readonly errorMessage: ColumnBuilder<string | null, "text">;
-    readonly startedAt: ColumnBuilder<Date | null, "timestamp">;
-    readonly completedAt: ColumnBuilder<Date | null, "timestamp">;
-    readonly cancelledAt: ColumnBuilder<Date | null, "timestamp">;
+    readonly costMicroUsd: ColumnBuilder<number, "integer", true>;
+    readonly durationMs: ColumnBuilder<number | null, "integer", boolean>;
+    readonly error: ColumnBuilder<string | null, "text", boolean>;
+    readonly errorMessage: ColumnBuilder<string | null, "text", boolean>;
+    readonly startedAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+    readonly completedAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+    readonly cancelledAt: ColumnBuilder<Date | null, "timestamp", boolean>;
     /** Studio session grouping (app concept; soft ref). */
-    readonly sessionId: ColumnBuilder<string | null, "text">;
-    readonly sessionName: ColumnBuilder<string | null, "text">;
+    readonly sessionId: ColumnBuilder<string | null, "text", boolean>;
+    readonly sessionName: ColumnBuilder<string | null, "text", boolean>;
     /** App subject the run is for/by. */
-    readonly ownerId: ColumnBuilder<string | null, "text">;
-    readonly metadata: ColumnBuilder<Record<string, unknown> | null, "json">;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly metadata: ColumnBuilder<Record<string, unknown> | null, "json", boolean>;
 }> & {
     tenantId: ColumnDefinition<string>;
 } & {
-    readonly createdAt: ColumnDefinition<Date, "timestamp">;
-    readonly updatedAt: ColumnDefinition<Date, "timestamp">;
-    readonly createdBy: ColumnDefinition<string | null, "reference">;
-    readonly updatedBy: ColumnDefinition<string | null, "reference">;
+    readonly createdAt: ColumnDefinition<Date, "timestamp", true>;
+    readonly updatedAt: ColumnDefinition<Date, "timestamp", true>;
+    readonly createdBy: ColumnDefinition<string | null, "reference", boolean>;
+    readonly updatedBy: ColumnDefinition<string | null, "reference", boolean>;
 }, true, never>;
 
 /**
@@ -122,19 +122,19 @@ export declare interface AiFlowsPluginOptions {
 /** `ai_flows` — a reusable flow DEFINITION (the data front door persists these;
  *  code-first `defineFlow` flows are NOT rows — they register in-process). */
 export declare const aiFlowsTable: Table<"ai_flows", FieldDefinitions<{
-    readonly id: ColumnBuilder<string, "id">;
-    readonly name: ColumnBuilder<string, "text">;
-    readonly description: ColumnBuilder<string | null, "text">;
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly name: ColumnBuilder<string, "text", boolean>;
+    readonly description: ColumnBuilder<string | null, "text", boolean>;
     /** 'deterministic' | 'agentic' — the execution mode (replaces allowDeviation). */
-    readonly mode: ColumnBuilder<string, "text">;
+    readonly mode: ColumnBuilder<string, "text", true>;
     /** 'draft' | 'active' | 'archived'. */
-    readonly status: ColumnBuilder<string, "text">;
+    readonly status: ColumnBuilder<string, "text", true>;
     /** 'private' | 'organization' | 'shared'. */
-    readonly visibility: ColumnBuilder<string, "text">;
-    readonly orchestratorModel: ColumnBuilder<string | null, "text">;
-    readonly orchestratorInstructions: ColumnBuilder<string | null, "text">;
+    readonly visibility: ColumnBuilder<string, "text", true>;
+    readonly orchestratorModel: ColumnBuilder<string | null, "text", boolean>;
+    readonly orchestratorInstructions: ColumnBuilder<string | null, "text", boolean>;
     /** Agentic loop bound; clamped [1,100] at run (default 30). */
-    readonly maxSteps: ColumnBuilder<number, "integer">;
+    readonly maxSteps: ColumnBuilder<number, "integer", true>;
     /** The ordered plan (`FlowStep[]`); null ≡ empty. */
     readonly steps: ColumnBuilder<readonly {
         readonly id: string;
@@ -166,7 +166,7 @@ export declare const aiFlowsTable: Table<"ai_flows", FieldDefinitions<{
             readonly value: string;
             readonly label: string;
         }[] | undefined;
-    }[] | null, "json">;
+    }[] | null, "json", boolean>;
     /** The launch-form brief (`BriefField[]`). */
     readonly inputSchema: ColumnBuilder<readonly {
         readonly key: string;
@@ -174,7 +174,7 @@ export declare const aiFlowsTable: Table<"ai_flows", FieldDefinitions<{
         readonly required?: boolean | undefined;
         readonly label: string;
         readonly placeholder?: string | undefined;
-    }[] | null, "json">;
+    }[] | null, "json", boolean>;
     readonly chainTo: ColumnBuilder<{
         readonly flowRef: string;
         readonly mappings: readonly {
@@ -182,7 +182,7 @@ export declare const aiFlowsTable: Table<"ai_flows", FieldDefinitions<{
             readonly targetKey: string;
         }[];
         readonly requireConfirmation?: boolean | undefined;
-    } | null, "json">;
+    } | null, "json", boolean>;
     readonly cadence: ColumnBuilder<{
         readonly frequency?: "weekly" | "monthly" | undefined;
         readonly repeats: readonly number[];
@@ -194,28 +194,28 @@ export declare const aiFlowsTable: Table<"ai_flows", FieldDefinitions<{
         readonly defaultInput?: {
             readonly [x: string]: unknown;
         } | undefined;
-    } | null, "json">;
+    } | null, "json", boolean>;
     /** Master on/off — gates scheduling. */
-    readonly isEnabled: ColumnBuilder<boolean, "boolean">;
-    readonly metadata: ColumnBuilder<Record<string, unknown> | null, "json">;
-    readonly icon: ColumnBuilder<string | null, "text">;
-    readonly color: ColumnBuilder<string | null, "text">;
+    readonly isEnabled: ColumnBuilder<boolean, "boolean", true>;
+    readonly metadata: ColumnBuilder<Record<string, unknown> | null, "json", boolean>;
+    readonly icon: ColumnBuilder<string | null, "text", boolean>;
+    readonly color: ColumnBuilder<string | null, "text", boolean>;
     /** Flow avatar as a plain URL (avoids a hard storage-plugin schema dep). */
-    readonly avatarUrl: ColumnBuilder<string | null, "text">;
+    readonly avatarUrl: ColumnBuilder<string | null, "text", boolean>;
     /** Run counter (incremented on launch). */
-    readonly usageCount: ColumnBuilder<number, "integer">;
+    readonly usageCount: ColumnBuilder<number, "integer", true>;
     /** App subject the flow belongs to (distinct from audit `createdBy` → actors). */
-    readonly ownerId: ColumnBuilder<string | null, "text">;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
 }> & {
     tenantId: ColumnDefinition<string>;
 } & {
-    readonly createdAt: ColumnDefinition<Date, "timestamp">;
-    readonly updatedAt: ColumnDefinition<Date, "timestamp">;
-    readonly createdBy: ColumnDefinition<string | null, "reference">;
-    readonly updatedBy: ColumnDefinition<string | null, "reference">;
+    readonly createdAt: ColumnDefinition<Date, "timestamp", true>;
+    readonly updatedAt: ColumnDefinition<Date, "timestamp", true>;
+    readonly createdBy: ColumnDefinition<string | null, "reference", boolean>;
+    readonly updatedBy: ColumnDefinition<string | null, "reference", boolean>;
 } & {
-    readonly deletedAt: ColumnDefinition<Date | null, "timestamp">;
-    readonly deletedBy: ColumnDefinition<string | null, "reference">;
+    readonly deletedAt: ColumnDefinition<Date | null, "timestamp", boolean>;
+    readonly deletedBy: ColumnDefinition<string | null, "reference", boolean>;
 }, true, never>;
 
 /** Every table this plugin contributes (fed to `extendSchema`). */
@@ -669,6 +669,9 @@ export declare type MediaGenerator = (args: {
     readonly prompt: string;
     readonly params?: Record<string, unknown>;
     readonly inputs?: Record<string, unknown>;
+    /** The run this artifact belongs to — pin persistence to `run.tenantId` rather
+     *  than the current subject, so a system/bootstrap resume stores it correctly. */
+    readonly run: MediaRunContext;
 }) => Effect.Effect<MediaResult, FlowCapabilityMissing>;
 
 export declare const MediaInputs: Schema.Record$<typeof Schema.String, Schema.Union<[Schema.Struct<{
@@ -694,16 +697,22 @@ export declare const MediaInputSlot: Schema.Union<[Schema.Struct<{
 
 export declare type MediaInputSlot = typeof MediaInputSlot.Type;
 
-/** Host-supplied persistence (from @voltro/plugin-storage's StorageService). */
+/** Host-supplied persistence (from @voltro/plugin-storage's StorageService).
+ *
+ *  Both hooks receive the `run` — its `tenantId` is the durable, resume-safe
+ *  tenant (see `MediaRunContext`). Pass it to `storage.put`/`ingestUrl` as the
+ *  scope so a BOOTSTRAP resume, whose subject has no tenant, still writes into
+ *  the run's own tenant instead of failing or defaulting. */
 export declare interface MediaPersist {
     /** Store raw bytes / base64 → a hosted URL (StorageService.put). */
     readonly put: (args: {
         data: Uint8Array | string;
         mediaType: string;
+        run: MediaRunContext;
     }) => Promise<StoredMedia>;
     /** Re-host a provider URL (StorageService.ingestUrl). If absent, a provider
      *  video URL is used as-is (no re-hosting). */
-    readonly ingestUrl?: (url: string) => Promise<StoredMedia>;
+    readonly ingestUrl?: (url: string, run: MediaRunContext) => Promise<StoredMedia>;
 }
 
 /** Media generation result (the host generator persists the artifact + returns
@@ -714,6 +723,21 @@ export declare interface MediaResult {
     readonly requestId?: string;
 }
 
+/** The run a media step executes within, resolved from the durable RUN ROW —
+ *  not the caller subject. This is the difference between a normal call and a
+ *  resume: a BOOTSTRAP/crash resume runs under a tenant-less `SYSTEM_SUBJECT`,
+ *  so a host that persists artifacts per tenant cannot read the tenant from
+ *  `ctx.request.subject` (it isn't there) and would either fail closed or, worse
+ *  under the old fallback, write into the wrong tenant. The engine reads the run
+ *  row it already loads and hands the original tenant down here, so persistence
+ *  continues in the right place on replay. */
+declare interface MediaRunContext {
+    readonly runId: string;
+    /** The run's tenant as stamped when it was created, or `null` for a
+     *  single-tenant app. Authoritative on resume, where the subject has none. */
+    readonly tenantId: string | null;
+}
+
 export declare const Modality: Schema.Literal<["text", "image", "video", "audio"]>;
 
 export declare type Modality = typeof Modality.Type;

package/dist/index.js

@@ -1,4 +1,4 @@
-import { BriefField as e, ChainPending as t, FlowCadence as n, FlowChain as r, FlowMode as i, FlowStatus as a, FlowStep as o, HumanResponse as s, Json as c, MAX_STEPS_DEFAULT as l, MAX_STEPS_MAX as u, MAX_STEPS_MIN as d, MediaInputSlot as f, MediaInputs as p, Modality as m, ReviewMode as h, ReviewOption as ee, RunReview as te, RunSource as ne, RunStatus as re, RunStep as ie, RunStepStatus as ae, StepType as oe, Visibility as se, clampMaxSteps as ce, normalizeFlow as g, sanitizeOutputKey as le } from "./ir.js";
+import { BriefField as e, ChainPending as t, FlowCadence as n, FlowChain as r, FlowMode as i, FlowStatus as a, FlowStep as o, HumanResponse as s, Json as c, MAX_STEPS_DEFAULT as l, MAX_STEPS_MAX as u, MAX_STEPS_MIN as d, MediaInputSlot as f, MediaInputs as p, Modality as ee, ReviewMode as m, ReviewOption as h, RunReview as te, RunSource as ne, RunStatus as re, RunStep as ie, RunStepStatus as ae, StepType as oe, Visibility as se, clampMaxSteps as ce, normalizeFlow as g, sanitizeOutputKey as le } from "./ir.js";
 import { FLOW_RUN_WORKFLOW as _, HUMAN_RESPONSE_SIGNAL as v } from "./workflow.js";
 import { FlowBriefIncomplete as ue, FlowCapabilityMissing as y, FlowDependencyError as de, FlowNotAwaitingResponse as fe, FlowNotFound as pe, FlowRunNotFound as b, FlowValidationError as me } from "./errors.js";
 import { n as he, t as ge } from "./cadence-Bt6dPelT.js";
@@ -99,12 +99,12 @@ var R = D("ai_flows", {
 		flowRef: t,
 		message: `no flow registered or stored for "${t}"`
 	}));
-}), Fe = (e, t, n, r) => x.gen(function* () {
-	let e = H(n.prompt ?? "", r), i = De(n.prompt ?? "", r);
-	if (i.length > 0) return { error: new de({
+}), Fe = (e, t, n, r, i) => x.gen(function* () {
+	let e = H(n.prompt ?? "", r), a = De(n.prompt ?? "", r);
+	if (a.length > 0) return { error: new de({
 		stepId: n.id,
-		unresolvedRef: i[0],
-		message: `step "${n.id}" references unresolved {{${i[0]}}}`
+		unresolvedRef: a[0],
+		message: `step "${n.id}" references unresolved {{${a[0]}}}`
 	}).message };
 	switch (n.type) {
 		case "note": return {
@@ -187,11 +187,12 @@ var R = D("ai_flows", {
 				capability: `media:${r}`,
 				message: `no media generator configured for ${r}`
 			}).message };
-			let i = n.model ?? t.defaultModels?.[r], a = yield* t.generateMedia({
+			let a = n.model ?? t.defaultModels?.[r], o = yield* t.generateMedia({
 				modality: r,
-				...i ? { model: i } : {},
+				...a ? { model: a } : {},
 				prompt: e,
-				...n.params ? { params: n.params } : {}
+				...n.params ? { params: n.params } : {},
+				run: i
 			}).pipe(x.map((e) => ({
 				ok: !0,
 				m: e
@@ -199,12 +200,12 @@ var R = D("ai_flows", {
 				ok: !1,
 				e
 			})));
-			return a.ok ? {
-				value: a.m.url,
-				url: a.m.url,
-				...a.m.requestId ? { requestId: a.m.requestId } : {},
-				costMicroUsd: a.m.costMicroUsd ?? 0
-			} : { error: a.e.message };
+			return o.ok ? {
+				value: o.m.url,
+				url: o.m.url,
+				...o.m.requestId ? { requestId: o.m.requestId } : {},
+				costMicroUsd: o.m.costMicroUsd ?? 0
+			} : { error: o.e.message };
 		}
 		case "human": return { error: new y({
 			capability: "human",
@@ -318,7 +319,10 @@ var R = D("ai_flows", {
 			name: `flow-${i}-${u.id}`,
 			input: { index: i },
 			success: Me,
-			execute: Fe(e, t, u, o)
+			execute: Fe(e, t, u, o, {
+				runId: n,
+				tenantId: a.tenantId
+			})
 		});
 		if (d.error) return c[i] = {
 			...c[i],
@@ -416,36 +420,36 @@ var R = D("ai_flows", {
 	toolCostMicroUsd: S.Number,
 	steps: S.Array(ie),
 	error: S.optional(S.String)
-}), He = (e, t, n, r, i, a) => x.gen(function* () {
+}), He = (e, t, n, r, i, a, o) => x.gen(function* () {
 	yield* q(e, n, {
 		status: "running",
 		startedAt: W(),
 		totalSteps: r.steps.length
 	});
-	let o = yield* M({
+	let s = yield* M({
 		name: "flow-agentic",
 		input: { flowRef: r.name },
 		success: Ve,
 		execute: x.gen(function* () {
-			let o = [], s = 0, c = (e) => {
-				let t = o.length;
-				return o.push({
+			let s = [], c = 0, l = (e) => {
+				let t = s.length;
+				return s.push({
 					id: t,
 					status: "running",
 					startedAt: W(),
 					...e
 				}), t;
-			}, l = (e, t) => {
-				o[e] = {
-					...o[e],
+			}, u = (e, t) => {
+				s[e] = {
+					...s[e],
 					completedAt: W(),
 					...t
 				};
-			}, u = () => q(e, n, {
-				steps: o,
-				currentStep: o.length,
-				costMicroUsd: s
-			}), d = N({
+			}, d = () => q(e, n, {
+				steps: s,
+				currentStep: s.length,
+				costMicroUsd: c
+			}), f = N({
 				name: "run_agent",
 				description: "Delegate a text task to an allowed sub-agent. Returns the agent's text.",
 				input: S.Struct({
@@ -453,14 +457,14 @@ var R = D("ai_flows", {
 					prompt: S.String
 				}),
 				execute: ({ agentRef: e, prompt: n }) => x.gen(function* () {
-					let r = c({
+					let r = l({
 						title: `agent:${e}`,
 						type: "agent"
 					});
-					if (yield* u(), !t.resolveAgent) return l(r, {
+					if (yield* d(), !t.resolveAgent) return u(r, {
 						status: "failed",
 						errorMessage: "no agent resolver configured"
-					}), yield* u(), "ERROR: no agent resolver configured";
+					}), yield* d(), "ERROR: no agent resolver configured";
 					let i = yield* t.resolveAgent(e).pipe(x.map((e) => ({
 						ok: !0,
 						a: e
@@ -468,10 +472,10 @@ var R = D("ai_flows", {
 						ok: !1,
 						e
 					})));
-					if (!i.ok) return l(r, {
+					if (!i.ok) return u(r, {
 						status: "failed",
 						errorMessage: i.e.message
-					}), yield* u(), `ERROR: ${i.e.message}`;
+					}), yield* d(), `ERROR: ${i.e.message}`;
 					let a = yield* L({
 						system: i.a.system,
 						prompt: n,
@@ -485,19 +489,19 @@ var R = D("ai_flows", {
 					})));
 					if (!a.ok) {
 						let e = String(a.e.message ?? a.e);
-						return l(r, {
+						return u(r, {
 							status: "failed",
 							errorMessage: e
-						}), yield* u(), `ERROR: ${e}`;
+						}), yield* d(), `ERROR: ${e}`;
 					}
 					let o = K(a.r.usage, a.r.providerMetadata, i.a.model);
-					return s += o, l(r, {
+					return c += o, u(r, {
 						status: "succeeded",
 						output: { text: a.r.text },
 						costMicroUsd: o
-					}), yield* u(), a.r.text;
+					}), yield* d(), a.r.text;
 				})
-			}), f = N({
+			}), p = N({
 				name: "generate_media",
 				description: "Generate an image, video, or audio artifact. Returns the hosted URL.",
 				input: S.Struct({
@@ -505,19 +509,23 @@ var R = D("ai_flows", {
 					prompt: S.String,
 					model: S.optional(S.String)
 				}),
-				execute: ({ modality: e, prompt: n, model: r }) => x.gen(function* () {
-					let i = c({
+				execute: ({ modality: e, prompt: r, model: i }) => x.gen(function* () {
+					let a = l({
 						title: `media:${e}`,
 						type: "generate"
 					});
-					if (yield* u(), !t.generateMedia) return l(i, {
+					if (yield* d(), !t.generateMedia) return u(a, {
 						status: "failed",
 						errorMessage: `no media generator for ${e}`
-					}), yield* u(), `ERROR: no media generator configured for ${e}`;
-					let a = yield* t.generateMedia({
+					}), yield* d(), `ERROR: no media generator configured for ${e}`;
+					let s = yield* t.generateMedia({
 						modality: e,
-						prompt: n,
-						...r ? { model: r } : {}
+						prompt: r,
+						...i ? { model: i } : {},
+						run: {
+							runId: n,
+							tenantId: o
+						}
 					}).pipe(x.map((e) => ({
 						ok: !0,
 						r: e
@@ -525,17 +533,17 @@ var R = D("ai_flows", {
 						ok: !1,
 						e
 					})));
-					return a.ok ? (s += a.r.costMicroUsd ?? 0, l(i, {
+					return s.ok ? (c += s.r.costMicroUsd ?? 0, u(a, {
 						status: "succeeded",
-						url: a.r.url,
-						...a.r.requestId ? { requestId: a.r.requestId } : {},
-						costMicroUsd: a.r.costMicroUsd ?? 0
-					}), yield* u(), a.r.url) : (l(i, {
+						url: s.r.url,
+						...s.r.requestId ? { requestId: s.r.requestId } : {},
+						costMicroUsd: s.r.costMicroUsd ?? 0
+					}), yield* d(), s.r.url) : (u(a, {
 						status: "failed",
-						errorMessage: a.e.message
-					}), yield* u(), `ERROR: ${a.e.message}`);
+						errorMessage: s.e.message
+					}), yield* d(), `ERROR: ${s.e.message}`);
 				})
-			}), p = N({
+			}), ee = N({
 				name: "pick_structured",
 				description: "Produce a JSON object for a task. Returns the object.",
 				input: S.Struct({
@@ -543,11 +551,11 @@ var R = D("ai_flows", {
 					model: S.optional(S.String)
 				}),
 				execute: ({ prompt: e, model: n }) => x.gen(function* () {
-					let r = c({
+					let r = l({
 						title: "structured",
 						type: "structured"
 					});
-					yield* u();
+					yield* d();
 					let i = yield* I({
 						prompt: e,
 						schema: S.Record({
@@ -564,17 +572,17 @@ var R = D("ai_flows", {
 					})));
 					if (!i.ok) {
 						let e = String(i.e.message ?? i.e);
-						return l(r, {
+						return u(r, {
 							status: "failed",
 							errorMessage: e
-						}), yield* u(), { error: e };
+						}), yield* d(), { error: e };
 					}
 					let a = K(i.r.usage, i.r.providerMetadata, n);
-					return s += a, l(r, {
+					return c += a, u(r, {
 						status: "succeeded",
 						output: { text: JSON.stringify(i.r.object) },
 						costMicroUsd: a
-					}), yield* u(), i.r.object;
+					}), yield* d(), i.r.object;
 				})
 			}), m = t.memoryPrefix ? yield* t.memoryPrefix(a).pipe(x.catchAll(() => x.succeed(""))) : "", h = yield* Ce({
 				system: m ? `${m}\n\n${Be(r)}` : Be(r),
@@ -584,9 +592,9 @@ var R = D("ai_flows", {
 					value: S.Unknown
 				}),
 				tools: {
-					run_agent: d,
-					generate_media: f,
-					pick_structured: p
+					run_agent: f,
+					generate_media: p,
+					pick_structured: ee
 				},
 				maxSteps: r.maxSteps,
 				...r.orchestrator?.model ? { provider: G(t, r.orchestrator.model) } : {}
@@ -600,36 +608,36 @@ var R = D("ai_flows", {
 			return h.ok ? {
 				object: h.r.object,
 				planCostMicroUsd: K(h.r.usage, h.r.providerMetadata, r.orchestrator?.model),
-				toolCostMicroUsd: s,
-				steps: o
+				toolCostMicroUsd: c,
+				steps: s
 			} : {
 				object: {},
 				planCostMicroUsd: 0,
-				toolCostMicroUsd: s,
-				steps: o,
+				toolCostMicroUsd: c,
+				steps: s,
 				error: String(h.e.message ?? h.e)
 			};
 		})
-	}), s = o.planCostMicroUsd + o.toolCostMicroUsd;
-	return o.error ? (yield* q(e, n, {
+	}), c = s.planCostMicroUsd + s.toolCostMicroUsd;
+	return s.error ? (yield* q(e, n, {
 		status: "failed",
-		steps: o.steps,
-		errorMessage: o.error,
+		steps: s.steps,
+		errorMessage: s.error,
 		completedAt: W(),
-		costMicroUsd: s
+		costMicroUsd: c
 	}), {
 		runId: n,
 		status: "failed"
 	}) : (yield* q(e, n, {
 		status: "succeeded",
-		steps: o.steps,
-		output: o.object,
+		steps: s.steps,
+		output: s.object,
 		completedAt: W(),
-		costMicroUsd: s
+		costMicroUsd: c
 	}), {
 		runId: n,
 		status: "succeeded",
-		output: o.object
+		output: s.object
 	});
 }), Ue = (e, t = {}) => (n, r) => x.gen(function* () {
 	let { runId: r, flowRef: i, input: a } = n, o = yield* M({
@@ -652,17 +660,18 @@ var R = D("ai_flows", {
 		runId: r,
 		status: "failed"
 	};
-	let s = o.ir, c = (yield* x.promise(() => e.store.query(E(z).where(C("id", r)).descriptor)).pipe(x.catchAllCause(() => x.succeed([]))))[0]?.ownerId ?? null, l = s.mode === "agentic" ? yield* He(e, t, r, s, a, c) : yield* Ie(e, t, r, s, a, {
-		ownerId: c,
+	let s = o.ir, c = (yield* x.promise(() => e.store.query(E(z).where(C("id", r)).descriptor)).pipe(x.catchAllCause(() => x.succeed([]))))[0], l = c?.ownerId ?? null, u = c?.tenantId ?? null, d = s.mode === "agentic" ? yield* He(e, t, r, s, a, l, u) : yield* Ie(e, t, r, s, a, {
+		ownerId: l,
+		tenantId: u,
 		source: n.source
 	});
-	return l.status === "succeeded" && s.chain && (yield* Le(e, r, s, a, l.output ?? {}, n)), t.onEvent && (l.status === "succeeded" || l.status === "failed") && (yield* t.onEvent({
-		kind: l.status,
+	return d.status === "succeeded" && s.chain && (yield* Le(e, r, s, a, d.output ?? {}, n)), t.onEvent && (d.status === "succeeded" || d.status === "failed") && (yield* t.onEvent({
+		kind: d.status,
 		runId: r,
 		flowName: s.name,
-		ownerId: c,
+		ownerId: l,
 		source: n.source
-	}).pipe(x.catchAllCause(() => x.void))), l;
+	}).pipe(x.catchAllCause(() => x.void))), d;
 }), We = {
 	text: (e) => ({
 		type: "generate",
@@ -781,7 +790,8 @@ var R = D("ai_flows", {
 			}));
 			let o = yield* x.promise(() => e.put({
 				data: a.data,
-				mediaType: a.mediaType
+				mediaType: a.mediaType,
+				run: n.run
 			}));
 			return {
 				url: o.url,
@@ -795,7 +805,8 @@ var R = D("ai_flows", {
 				...r ? { provider: i(r) } : {}
 			}), a = yield* x.promise(() => e.put({
 				data: t.audio.data,
-				mediaType: t.audio.mediaType
+				mediaType: t.audio.mediaType,
+				run: n.run
 			}));
 			return {
 				url: a.url,
@@ -808,10 +819,11 @@ var R = D("ai_flows", {
 			...r ? { provider: i(r) } : {},
 			...n.params ? { params: n.params } : {}
 		}), a;
-		if (t.video.url) a = e.ingestUrl ? yield* x.promise(() => e.ingestUrl(t.video.url)) : { url: t.video.url };
+		if (t.video.url) a = e.ingestUrl ? yield* x.promise(() => e.ingestUrl(t.video.url, n.run)) : { url: t.video.url };
 		else if (t.video.data) a = yield* x.promise(() => e.put({
 			data: t.video.data,
-			mediaType: t.video.mediaType
+			mediaType: t.video.mediaType,
+			run: n.run
 		}));
 		else return yield* x.fail(new y({
 			capability: "media:video",
@@ -962,4 +974,4 @@ var R = D("ai_flows", {
 	});
 };
 //#endregion
-export { e as BriefField, t as ChainPending, _ as FLOW_RUN_WORKFLOW, n as FlowCadence, r as FlowChain, i as FlowMode, a as FlowStatus, o as FlowStep, v as HUMAN_RESPONSE_SIGNAL, s as HumanResponse, c as Json, l as MAX_STEPS_DEFAULT, u as MAX_STEPS_MAX, d as MAX_STEPS_MIN, f as MediaInputSlot, p as MediaInputs, m as Modality, h as ReviewMode, ee as ReviewOption, te as RunReview, ne as RunSource, re as RunStatus, ie as RunStep, ae as RunStepStatus, oe as StepType, se as Visibility, z as aiFlowRunsTable, lt as aiFlowsPlugin, R as aiFlowsTable, B as aiFlowsTables, Ue as buildFlowRunExecute, ge as cadenceMatches, nt as cancelFlow, ce as clampMaxSteps, je as clearRegistry, V as collectRefs, ot as createFlow, X as cronRequestId, qe as defineFlow, ct as deleteFlow, We as flowStep, it as getFlow, ke as getRegisteredFlow, H as interpolate, et as launchFlow, at as listFlows, Ae as listRegisteredFlows, Qe as makeMediaGenerator, he as nextRuns, g as normalizeFlow, Oe as registerFlow, J as resolveIr, rt as respondToFlow, tt as retryFlow, Ye as runCadenceTick, le as sanitizeOutputKey, De as unresolvedRefs, st as updateFlow, Ke as validateFlow };
+export { e as BriefField, t as ChainPending, _ as FLOW_RUN_WORKFLOW, n as FlowCadence, r as FlowChain, i as FlowMode, a as FlowStatus, o as FlowStep, v as HUMAN_RESPONSE_SIGNAL, s as HumanResponse, c as Json, l as MAX_STEPS_DEFAULT, u as MAX_STEPS_MAX, d as MAX_STEPS_MIN, f as MediaInputSlot, p as MediaInputs, ee as Modality, m as ReviewMode, h as ReviewOption, te as RunReview, ne as RunSource, re as RunStatus, ie as RunStep, ae as RunStepStatus, oe as StepType, se as Visibility, z as aiFlowRunsTable, lt as aiFlowsPlugin, R as aiFlowsTable, B as aiFlowsTables, Ue as buildFlowRunExecute, ge as cadenceMatches, nt as cancelFlow, ce as clampMaxSteps, je as clearRegistry, V as collectRefs, ot as createFlow, X as cronRequestId, qe as defineFlow, ct as deleteFlow, We as flowStep, it as getFlow, ke as getRegisteredFlow, H as interpolate, et as launchFlow, at as listFlows, Ae as listRegisteredFlows, Qe as makeMediaGenerator, he as nextRuns, g as normalizeFlow, Oe as registerFlow, J as resolveIr, rt as respondToFlow, tt as retryFlow, Ye as runCadenceTick, le as sanitizeOutputKey, De as unresolvedRefs, st as updateFlow, Ke as validateFlow };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/plugin-ai-flows",
-  "version": "0.11.0",
+  "version": "0.11.2",
   "description": "AI Flows — durable multi-step AI pipelines (deterministic + agentic) with human-in-the-loop, chaining, and cadence. Author flows in code (defineFlow) or as data (visual editor rows); one engine runs both on @voltro/workflow durability, @voltro/ai generation, storage artifacts, and notifications.",
   "keywords": [
     "voltro",
@@ -57,15 +57,15 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@voltro/ai": "0.11.0",
-    "@voltro/database": "0.11.0",
-    "@voltro/env": "0.11.0",
-    "@voltro/plugin-audit": "0.11.0",
-    "@voltro/plugin-multitenancy": "0.11.0",
-    "@voltro/plugin-soft-delete": "0.11.0",
-    "@voltro/protocol": "0.11.0",
-    "@voltro/runtime": "0.11.0",
-    "@voltro/workflow": "0.11.0"
+    "@voltro/ai": "0.11.2",
+    "@voltro/database": "0.11.2",
+    "@voltro/env": "0.11.2",
+    "@voltro/plugin-audit": "0.11.2",
+    "@voltro/plugin-multitenancy": "0.11.2",
+    "@voltro/plugin-soft-delete": "0.11.2",
+    "@voltro/protocol": "0.11.2",
+    "@voltro/runtime": "0.11.2",
+    "@voltro/workflow": "0.11.2"
   },
   "peerDependencies": {
     "effect": "^3.21.4"