@voltro/plugin-ai-flows 0.10.0 → 0.11.1

package/CHANGELOG.md

@@ -39,6 +39,140 @@ _Changes staged for the next release accumulate here (rolled up from
 
 ---
 
+## [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.
+- **@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
+
+- **@voltro/client, @voltro/web** — **@voltro/client** — `useSequence` steps gain **`covers`** and **`when`**, and the undo contract that was implicit is now written down.
+
+  **`covers` — overlapping undos.** Every succeeded step's undo runs, and the runner has no idea whether two of them reverse the same thing. Reported from a Jira rollback: `deleteJiraDraftTicket` deletes the issue *and* discards the draft, so the earlier `discardDraft` undo ran on something already gone. It worked only because discarding is idempotent — and **nothing said that was load-bearing**. For a refund or a cancellation email the double-run is a defect, not a nuisance.
+
+  ```tsx
+  .step('draft', createDraft, { undo: discardDraft })
+  .step('jira',  createTicket, { undo: deleteJiraDraftTicket, covers: ['draft'] })
+  ```
+
+  `covers` is static rather than a runtime signal on purpose: "this reverse also reverses that one" is a property of the operation, legible where it is defined and checkable against the step names in scope.
+
+  **When the covering undo FAILS**, the covered steps are neither run nor claimed. Whether the cascade got that far is genuinely unknown — running the covered undo risks the double reverse, skipping it risks an orphan — so both guesses are refused and the steps come back in `compensationUncertain` with the step that was supposed to cover them. Same principle as never compensating the step that failed: surface the ambiguity, don't resolve it by assumption.
+
+  **`when` — one optional step.** 13 multi-await blocks in one app; only 5 could migrate. Several of the rest were linear *except* for one conditional step ("schedule the summary only if the set changed", `if (assigneeKey) assign else unassign`) and fell back to `try/catch` entirely, though 80% of the flow was a clean pipeline. An optional step is a different shape from a loop, and the scoping was treating them the same.
+
+  ```tsx
+  .step('summary', (c) => scheduleSummary.run({ id: c.save.id }), { when: (c) => c.save.changed })
+  ```
+
+  A skipped step contributes `undefined` to the context — the overload says so, so a later step has to acknowledge it — and gets no undo, since it had no effect to reverse. Loops and real branches still keep their `try/catch`; this deliberately does not widen to them.
+
+  **The break:** `StepOptions` gained a type parameter — `StepOptions<Result>` became `StepOptions<Ctx, Result>`, because `covers` and `when` both need to see the accumulated context (`covers` is checked against the step names in scope; `when` receives it). Call sites that pass an object literal to `.step()` are unaffected — the type is inferred — but anyone who *named* the type explicitly gets a compile error. Filed BREAKING rather than Added for the same reason a widened union is: the test is "can this turn code that compiled into code that does not", and it can. `@voltro/web` is listed because it re-exports the client surface — the third time in this round that coupling has decided where a change lands.
+
+### Added
+
+- **@voltro/cli** — **Repo gate** — a new `Claimed-wiring check` (`scripts/check-claimed-wirings.mjs`, wired into CI and therefore into `pnpm gate`): a doc comment that says something wires a symbol up must be telling the truth.
+
+  `setSystemStoreHandle`'s comment read *"Process-wide handle, registered by the runtime boot (dev.ts / start.ts)"*. Nothing registered it, in either path, through an entire release — so `runAsSystem` threw for every consumer, and the comment was the only evidence anyone had that it should work. The shape is not rare: a comment gets written when the wiring is planned, the wiring gets deferred, and the comment never finds out. It then reads as documentation of behaviour rather than of intention, and the more confidently it is phrased the less likely anyone is to check it.
+
+  Two things it does that the obvious version does not, both learned by watching it report the bug as clean:
+
+  - **it counts real call expressions, not text.** The first version matched regexes and found `setSystemStoreHandle({ … })` inside `runAsSystem`'s own error-message string — a text match cannot tell a call from a sentence about a call. (Precisely the defect fixed in the hand-roll detector one commit earlier, repeated one file later.) - **it checks the NAMED caller, not any caller.** The second version asked "does anything call this"; `@voltro/testing` calls it from a test harness, so the bug read clean again. A claim that the runtime boot registers something is not satisfied by a test helper registering it.
+
+  Verified the only way this kind of check can be: by removing the wiring and confirming it fails, with the diagnosis that would have saved the original investigation — `called by: packages/testing/src/testContext.ts ← none of these is the boot`.
+
+### Fixed
+
+- **@voltro/database, @voltro/runtime, @voltro/sql-postgres, @voltro/sql-mysql, @voltro/sql-sqlite, @voltro/sql-mssql** — **@voltro/database + every store** — a row inserted into a table that declares an `id()` scheme now gets one **at the store**, not only when the caller happened to go through `wrapStoreWithMixinBehaviour`.
+
+  Id generation was sitting one layer too high. It is the single stamped field that needs no subject — the scheme is a property of the declared table — yet it lived in the subject-aware wrapper. So every insert through an unwrapped store reached the database with `id: null`:
+
+  ```
+  null value in column "id" of relation "_voltro_seeds" violates not-null constraint
+  ```
+
+  That was a real shipped bug in the seed ledger (the runner holds the raw store), and a survey found the same shape waiting elsewhere: `plugin-rbac/userRoleStore.ts`, `plugin-governance/consent.ts`, and `plugin-sso-saml/saml-cache.ts` all insert without an id into tables that declare one. Whether any of them broke came down to how their caller happened to obtain its store — and *"depends on how the caller obtained its store"* is not a contract, it is a coin flip with a NOT NULL constraint on the other side.
+
+  `stampGeneratedId` now runs in every store's insert path (all four dialects plus the in-memory store, at the private `executeInsert` / `executeInsertMany` / `executeInsertIgnore` choke points that every public and namespace-view path funnels through). It preserves the semantics the wrapper had: an explicit id is never overwritten, a `numeric` scheme deletes the key so the dialect's SERIAL fires, and an unregistered table is passed through untouched rather than guessed at.
+
+  The wrapper still stamps — it holds the schema registry and does the subject-derived fields in the same pass — and now finds the id already set. That is a floor, not a second implementation of a rule: the invariant is "a row that reaches the database has an id when its table declares a generating scheme", and only the store can promise that for *every* caller, including a `DataStore` someone implemented themselves.
+- **@voltro/cli** — **Repo tests** — the liveness backstop for real-listener / real-child-process suites goes from 60s to 120s, in `vitest.config.ts` and the CI flag that overrides it.
+
+  Worth stating plainly what this number is, because raising a timeout is the classic way to bury a problem: it asserts nothing about performance. A real `serveApi` boot is ~0.2s in isolation. The value is pure headroom against residual starvation that the four existing mitigations — the unit/integration project split, group ordering, `fileParallelism: false`, per-package mssql databases — cannot reach, because the remaining contention is turbo running two *packages* concurrently alongside the docker stack.
+
+  60s tripped twice in one session, on two different files (`connectionServe.test.ts`, then `serveApi.test.ts`), each passing in ~2s alone. Different file each time, always in the same family, never reproducible in isolation: that is the signature of starvation rather than of a slow test, and it cost two full gate runs.
+
+  What would not be honest is treating a green run afterwards as evidence the contention is gone. It is not. If a third file trips this, the answer is to stop running two heavy packages concurrently — not to raise it again.
+- **@voltro/cli, @voltro/database** — **@voltro/cli, @voltro/database** — two fixes to the 0.10.0 seed ledger, both reported from its first real use, both mine.
+
+  **The ledger never wrote.** `store.insert('_voltro_seeds', …)` ran against the RAW store, and auto-id lives in `wrapStoreWithMixinBehaviour` — so the row reached postgres with `id: null` and died on the NOT NULL constraint. Every boot reported `ran=1 skipped=0` regardless of fingerprint: the feature shipped doing nothing. The ledger now stamps its own id, derived from `_voltroSeedsTable`'s declared scheme rather than a hardcoded prefix, so it no longer depends on how a caller happens to have wrapped its store.
+
+  **Worse than the bug was the logging.** I put the failure on `debug` and swallowed it, reasoning that "it degrades to re-running, which is only a performance regression". That reasoning is exactly what made it undiagnosable: a silently unwritten ledger looks identical to a working one whose seeds all changed — no symptom, nothing to grep, and the reporter had to read the error out of a debug stream to find it. Both the write and the read path now warn, naming the table and the consequence.
+
+  **And the reason it shipped:** the test fake *invented an id* when the row lacked one, making it more permissive than any database. A fake that supplies what the subject under test forgot is not a test — it is the subject testing itself. It now rejects an id-less insert with the real constraint's message; reintroducing the bug fails five cases.
+
+  **A seed step could not reach a usable store.** `SeedStore` exposed only `query`/`insert`/`update`/`delete`, and `query` took just `{ table, predicate }`. A restore of 1361 rows across 167 tables, multi-pass for FK order, needs an idempotent insert and a read it can page — and `upsertByUnique` is neither: a read per row, and it overwrites what it finds, which is wrong whenever the live row is newer than the snapshot. `SeedStore` now carries **`insertIgnore`** (one statement per row, native on every dialect) and a full descriptor read (`order` / `take` / `skip` / `projection`).
+
+  Seed reads are unscoped and include soft-deleted rows *by construction* — a seed runs at boot with no request and therefore no subject, so nothing applies a tenant filter or the `deletedAt IS NULL` predicate. That is now documented on the type rather than left to be discovered, since the absence of `.unscoped()` / `.withDeleted()` reads as a missing feature until you know why they cannot exist here.
+
+  *(`apiSurface: compatible`: the golden churn in `@voltro/database` is two `(undocumented)` markers disappearing because `SeedStore` and its new member gained TSDoc — a comment cannot break a caller. The added `insertIgnore` member is additive for consumers, which is everyone: a `SeedStore` is what `ctx.store` IS, handed to you by the runner. Nobody constructs one, so nobody can be missing a member.)*
+- **@voltro/cli** — **@voltro/cli** — `runAsSystem` now works. The process-wide system store is registered at boot by **both** `voltro dev` and `voltro serve`; until now neither did, so every call threw `no data store available — register one at boot via setSystemStoreHandle`.
+
+  `setSystemStoreHandle`'s own doc comment reads "registered by the runtime boot (dev.ts / start.ts)". It describes wiring that was never written: the only callers in the repo were its unit test and a note in `@voltro/testing`. So the failure was not a lifecycle-ordering subtlety — the handle was never set at any point, in any command, and `runAsSystem` was unusable for every consumer.
+
+  Surfaced by someone reporting it as "not registered *yet* at seed time", which implied it worked later. Checking that framing rather than the symptom is what turned a scheduling question into a missing-wiring one. It is registered before the seed runner in dev, since seeds are the earliest thing that can plausibly want it.
+
+  Same class as the seed lifecycle table and the `@voltro/web` re-export: a documented behaviour with nothing behind it, where the doc is the only evidence anyone has.
+
+---
+
 ## [0.10.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.10.0",
+  "version": "0.11.1",
   "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.10.0",
-    "@voltro/database": "0.10.0",
-    "@voltro/env": "0.10.0",
-    "@voltro/plugin-audit": "0.10.0",
-    "@voltro/plugin-multitenancy": "0.10.0",
-    "@voltro/plugin-soft-delete": "0.10.0",
-    "@voltro/protocol": "0.10.0",
-    "@voltro/runtime": "0.10.0",
-    "@voltro/workflow": "0.10.0"
+    "@voltro/ai": "0.11.1",
+    "@voltro/database": "0.11.1",
+    "@voltro/env": "0.11.1",
+    "@voltro/plugin-audit": "0.11.1",
+    "@voltro/plugin-multitenancy": "0.11.1",
+    "@voltro/plugin-soft-delete": "0.11.1",
+    "@voltro/protocol": "0.11.1",
+    "@voltro/runtime": "0.11.1",
+    "@voltro/workflow": "0.11.1"
   },
   "peerDependencies": {
     "effect": "^3.21.4"