@voltro/plugin-ai-flows 0.83.1 → 0.85.0

package/dist/index.d.ts

@@ -10,9 +10,10 @@ import { Schema } from 'effect';
 import { Table } from '@voltro/database';
 import { TableLike } from '@voltro/database';
 import { VoltroPlugin } from '@voltro/protocol';
-import { WorkflowEngine } from '@effect/workflow/WorkflowEngine';
-import { WorkflowInstance } from '@effect/workflow/WorkflowEngine';
+import { WorkflowEngine } from 'effect/workflow/WorkflowEngine';
+import { WorkflowInstance } from 'effect/workflow/WorkflowEngine';
 import { WorkflowRunHandle } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
 
 /** The handle a flow row records for an ADMITTED start: the execution the
  *  engine owns. `id` is that execution too — the stable handle callers pass on. */
@@ -54,8 +55,8 @@ export declare const aiFlowRunsTable: Table<"_voltro_ai_flow_runs", FieldDefinit
         readonly workflowName: string;
         readonly deferral?: {
             readonly mode: string;
-            readonly retryAfterMs: number | null;
             readonly dueAt: number | null;
+            readonly retryAfterMs: number | null;
             readonly intentId: string | null;
         } | undefined;
     } | null, "json", boolean>;
@@ -248,11 +249,11 @@ export declare const aiFlowsTables: ReadonlyArray<TableLike>;
 
 /** A launch-form field. The run `input` is keyed by these `key`s. */
 export declare const BriefField: Schema.Struct<{
-    key: typeof Schema.String;
-    label: typeof Schema.String;
-    type: Schema.Literal<["text", "textarea", "number", "boolean"]>;
-    required: Schema.optional<typeof Schema.Boolean>;
-    placeholder: Schema.optional<typeof Schema.String>;
+    readonly key: Schema.String;
+    readonly label: Schema.String;
+    readonly type: Schema.Literals<readonly ["text", "textarea", "number", "boolean"]>;
+    readonly required: Schema.optional<Schema.Boolean>;
+    readonly placeholder: Schema.optional<Schema.String>;
 }>;
 
 /** An INTERFACE for the same reason as {@link FlowStep} — it is reached from an
@@ -312,32 +313,32 @@ export declare const cadenceMatches: (cadence: FlowCadence, now: Date) => boolea
 export declare const cancelFlow: (ctx: AppContext, args: {
     runId: string;
 }) => Effect.Effect<{
-    readonly status: "failed" | "pending" | "cancelled" | "running" | "succeeded" | "waiting" | "cancelling";
     readonly runId: string;
+    readonly status: "failed" | "pending" | "cancelled" | "running" | "succeeded" | "waiting" | "cancelling";
+    readonly engine: "unknown" | "unreachable" | "cancelled" | "accepted" | "already-terminal" | "not-requested";
     readonly control: {
+        readonly operation: "resume" | "cancel";
         readonly kind: "unknown" | "accepted" | "confirmed" | "already-terminal";
+        readonly requestId: string | null;
         readonly snapshot: {
             readonly status: "unknown" | "failed" | "cancelled" | "running" | "succeeded" | "suspended";
             readonly id: string;
+            readonly executionId: string;
+            readonly workflowName: string;
             readonly error?: {
-                readonly message: string;
                 readonly tag: string | null;
+                readonly message: string;
             } | undefined;
             readonly output?: unknown;
-            readonly executionId: string;
-            readonly workflowName: string;
         };
-        readonly operation: "resume" | "cancel";
-        readonly requestId: string | null;
     } | null;
-    readonly engine: "unknown" | "unreachable" | "cancelled" | "accepted" | "already-terminal" | "not-requested";
 }, FlowRunNotFound, never>;
 
 /** Staged follow-up when `chainTo.requireConfirmation` is set. */
 export declare const ChainPending: Schema.Struct<{
-    flowRef: typeof Schema.String;
-    input: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
-    status: Schema.Literal<["pending", "confirmed", "dismissed"]>;
+    readonly flowRef: Schema.String;
+    readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly status: Schema.Literals<readonly ["pending", "confirmed", "dismissed"]>;
 }>;
 
 /** An INTERFACE — reached from `aiFlowRuns.chainPending`; see {@link BriefField}. */
@@ -356,17 +357,17 @@ export declare const clearRegistry: () => void;
 export declare const collectRefs: (text: string) => ReadonlyArray<string>;
 
 /** The comparison a `when:` performs. */
-export declare const ConditionOp: Schema.Literal<["truthy", "falsy", "eq", "neq", "contains"]>;
+export declare const ConditionOp: Schema.Literals<readonly ["truthy", "falsy", "eq", "neq", "contains"]>;
 
 export declare type ConditionOp = typeof ConditionOp.Type;
 
 /** A run's cost verdict over its steps: every step gateway-priced → `actual`; none unpriced → `estimated`; any unpriced → `incomplete`; no priced step → `unknown`. */
-export declare const CostCompleteness: Schema.Literal<["actual", "estimated", "incomplete", "unknown"]>;
+export declare const CostCompleteness: Schema.Literals<readonly ["actual", "estimated", "incomplete", "unknown"]>;
 
 export declare type CostCompleteness = typeof CostCompleteness.Type;
 
 /** Where a cost figure came from. `unpriced` means the number beside it is a placeholder, not a price. */
-export declare const CostSource: Schema.Literal<["gateway", "estimated", "unpriced"]>;
+export declare const CostSource: Schema.Literals<readonly ["gateway", "estimated", "unpriced"]>;
 
 export declare type CostSource = typeof CostSource.Type;
 
@@ -438,7 +439,8 @@ export declare interface EngineDeps {
      *  `resolveAgent` admits. With it, `run_agent` accepts exactly these refs and
      *  the planner reads their descriptions; without it, the agent refs the plan's
      *  own agent steps name. A planner given no list guesses, and a guess is a
-     *  failed step. A failure here falls back to the plan's refs. */
+     *  failed step. An explicit empty list removes `run_agent`; a listing failure
+     *  refuses planning instead of broadening delegation. */
     readonly listAgents?: (run: FlowRunContext) => Effect.Effect<ReadonlyArray<PlannerAgent>, FlowCapabilityMissing, unknown>;
     /** Media generator for image/video/audio steps (`makeMediaGenerator` in
      *  `mediaAdapter.ts` is the @voltro/ai-backed implementation). */
@@ -503,42 +505,38 @@ export declare const FLOW_RUNS_TTL_HOURS_DEFAULT: number;
 declare class FlowAgentUnavailable extends FlowAgentUnavailable_base {
 }
 
-declare const FlowAgentUnavailable_base: Schema.TaggedErrorClass<FlowAgentUnavailable, "FlowAgentUnavailable", {
-    readonly _tag: Schema.tag<"FlowAgentUnavailable">;
-} & {
-    agentRef: typeof Schema.String;
-    reason: Schema.Literal<["not-found", "access-revoked", "model-unusable"]>;
-    message: typeof Schema.String;
-    publicMessage: Schema.optional<typeof Schema.String>;
-}>;
+declare const FlowAgentUnavailable_base: Schema.Class<FlowAgentUnavailable, Schema.TaggedStruct<"FlowAgentUnavailable", {
+    readonly agentRef: Schema.String;
+    readonly reason: Schema.Literals<readonly ["not-found", "access-revoked", "model-unusable"]>;
+    readonly message: Schema.String;
+    readonly publicMessage: Schema.optional<Schema.String>;
+}>, YieldableError>;
 
 /** A required brief field was blank at launch. */
 declare class FlowBriefIncomplete extends FlowBriefIncomplete_base {
 }
 
-declare const FlowBriefIncomplete_base: Schema.TaggedErrorClass<FlowBriefIncomplete, "FlowBriefIncomplete", {
-    readonly _tag: Schema.tag<"FlowBriefIncomplete">;
-} & {
-    missing: Schema.Array$<typeof Schema.String>;
-    message: typeof Schema.String;
-}>;
+declare const FlowBriefIncomplete_base: Schema.Class<FlowBriefIncomplete, Schema.TaggedStruct<"FlowBriefIncomplete", {
+    readonly missing: Schema.$Array<Schema.String>;
+    readonly message: Schema.String;
+}>, YieldableError>;
 
 /** Schedule spec — richer than a single cron expr (weekly interval + anchor,
  *  monthly weekOfMonth), evaluated by the shared `cadenceMatches` predicate. */
 export declare const FlowCadence: Schema.Struct<{
-    frequency: Schema.optional<Schema.Literal<["weekly", "monthly"]>>;
+    readonly frequency: Schema.optional<Schema.Literals<readonly ["weekly", "monthly"]>>;
     /** Weekdays, 0=Monday … 6=Sunday. */
-    repeats: Schema.Array$<typeof Schema.Number>;
+    readonly repeats: Schema.$Array<Schema.Number>;
     /** Weekly cycle length: 1 | 2 | 4 (anchored by anchorDate). */
-    intervalWeeks: Schema.optional<typeof Schema.Number>;
+    readonly intervalWeeks: Schema.optional<Schema.Number>;
     /** ISO YYYY-MM-DD, cycle-0 week (interval > 1). */
-    anchorDate: Schema.optional<typeof Schema.String>;
-    weekOfMonth: Schema.optional<Schema.Union<[Schema.Literal<[1, 2, 3, 4]>, Schema.Literal<["last"]>]>>;
+    readonly anchorDate: Schema.optional<Schema.String>;
+    readonly weekOfMonth: Schema.optional<Schema.Union<readonly [Schema.Literals<readonly [1, 2, 3, 4]>, Schema.Literal<"last">]>>;
     /** 0-23, default 9. */
-    hour: Schema.optional<typeof Schema.Number>;
-    minute: Schema.optional<Schema.Literal<[0, 15, 30, 45]>>;
+    readonly hour: Schema.optional<Schema.Number>;
+    readonly minute: Schema.optional<Schema.Literals<readonly [0, 15, 30, 45]>>;
     /** Brief for unattended cron runs. */
-    defaultInput: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    readonly defaultInput: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
 }>;
 
 /**
@@ -566,27 +564,27 @@ export declare interface FlowCadence {
  * The row never claims `cancelled` on its own: a confirmed engine cancellation
  * is the only receipt that reports a `cancelled` row, every other request
  * outcome leaves the row `cancelling` (or a completion that won a race). */
-export declare const FlowCancelReceipt: Schema.filter<Schema.Struct<{
-    runId: typeof Schema.NonEmptyString;
-    status: Schema.Literal<["pending", "running", "waiting", "cancelling", "succeeded", "failed", "cancelled"]>;
-    engine: Schema.Literal<["cancelled", "accepted", "unknown", "already-terminal", "unreachable", "not-requested"]>;
-    control: Schema.NullOr<Schema.filter<Schema.Struct<{
-        operation: Schema.Literal<["cancel", "resume"]>;
-        kind: Schema.Literal<["accepted", "confirmed", "unknown", "already-terminal"]>;
-        requestId: Schema.NullOr<typeof Schema.NonEmptyString>;
-        snapshot: Schema.Struct<{
-            id: typeof Schema.String;
-            workflowName: typeof Schema.String;
-            executionId: typeof Schema.String;
-            status: Schema.Union<[Schema.Literal<["running", "succeeded", "failed", "cancelled", "suspended"]>, Schema.Literal<["unknown"]>]>;
-            output: Schema.optional<typeof Schema.Unknown>;
-            error: Schema.optional<Schema.Struct<{
-                tag: Schema.NullOr<typeof Schema.String>;
-                message: typeof Schema.String;
+export declare const FlowCancelReceipt: Schema.Struct<{
+    readonly runId: Schema.NonEmptyString;
+    readonly status: Schema.Literals<readonly ["pending", "running", "waiting", "cancelling", "succeeded", "failed", "cancelled"]>;
+    readonly engine: Schema.Literals<readonly ["cancelled", "accepted", "unknown", "already-terminal", "unreachable", "not-requested"]>;
+    readonly control: Schema.NullOr<Schema.Struct<{
+        readonly operation: Schema.Literals<readonly ["cancel", "resume"]>;
+        readonly kind: Schema.Literals<readonly ["accepted", "confirmed", "unknown", "already-terminal"]>;
+        readonly requestId: Schema.NullOr<Schema.NonEmptyString>;
+        readonly snapshot: Schema.Struct<{
+            readonly id: Schema.String;
+            readonly workflowName: Schema.String;
+            readonly executionId: Schema.String;
+            readonly status: Schema.Union<readonly [Schema.Literals<readonly ["running", "succeeded", "failed", "cancelled", "suspended"]>, Schema.Literal<"unknown">]>;
+            readonly output: Schema.optional<Schema.Unknown>;
+            readonly error: Schema.optional<Schema.Struct<{
+                readonly tag: Schema.NullOr<Schema.String>;
+                readonly message: Schema.String;
             }>>;
         }>;
-    }>>>;
-}>>;
+    }>>;
+}>;
 
 export declare type FlowCancelReceipt = typeof FlowCancelReceipt.Type;
 
@@ -595,37 +593,35 @@ export declare type FlowCancelReceipt = typeof FlowCancelReceipt.Type;
 declare class FlowCapabilityMissing extends FlowCapabilityMissing_base {
 }
 
-declare const FlowCapabilityMissing_base: Schema.TaggedErrorClass<FlowCapabilityMissing, "FlowCapabilityMissing", {
-    readonly _tag: Schema.tag<"FlowCapabilityMissing">;
-} & {
-    capability: typeof Schema.String;
-    message: typeof Schema.String;
+declare const FlowCapabilityMissing_base: Schema.Class<FlowCapabilityMissing, Schema.TaggedStruct<"FlowCapabilityMissing", {
+    readonly capability: Schema.String;
+    readonly message: Schema.String;
     /** A charge that happened before the failure — the generation succeeded and
      *  was billed, then storing its artifact did not. The engine records it on
      *  the failed step, so the run's cost is not reported as unknown when it is
      *  merely incomplete. */
-    receipt: Schema.optional<Schema.Struct<{
-        costMicroUsd: Schema.optional<Schema.filter<typeof Schema.Finite>>;
-        costSource: Schema.optional<Schema.Literal<["gateway", "estimated", "unpriced"]>>;
-        requestId: Schema.optional<typeof Schema.NonEmptyString>;
-        usage: Schema.optional<Schema.Struct<{
-            status: Schema.Literal<["reported", "unreported"]>;
-            unit: Schema.optional<Schema.Literal<["tokens", "characters", "seconds"]>>;
-            input: Schema.optional<Schema.filter<typeof Schema.Finite>>;
-            output: Schema.optional<Schema.filter<typeof Schema.Finite>>;
+    readonly receipt: Schema.optional<Schema.Struct<{
+        readonly costMicroUsd: Schema.optional<Schema.Finite>;
+        readonly costSource: Schema.optional<Schema.Literals<readonly ["gateway", "estimated", "unpriced"]>>;
+        readonly requestId: Schema.optional<Schema.NonEmptyString>;
+        readonly usage: Schema.optional<Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["reported", "unreported"]>;
+            readonly unit: Schema.optional<Schema.Literals<readonly ["tokens", "characters", "seconds"]>>;
+            readonly input: Schema.optional<Schema.Finite>;
+            readonly output: Schema.optional<Schema.Finite>;
         }>>;
     }>>;
-}>;
+}>, YieldableError>;
 
 /** Follow-up flow spec. On success, map source → the child's brief. */
 export declare const FlowChain: Schema.Struct<{
     /** Child flow id (data) or name (code). */
-    flowRef: typeof Schema.String;
-    mappings: Schema.Array$<Schema.Struct<{
-        targetKey: typeof Schema.String;
-        sourceKey: typeof Schema.String;
+    readonly flowRef: Schema.String;
+    readonly mappings: Schema.$Array<Schema.Struct<{
+        readonly targetKey: Schema.String;
+        readonly sourceKey: Schema.String;
     }>>;
-    requireConfirmation: Schema.optional<typeof Schema.Boolean>;
+    readonly requireConfirmation: Schema.optional<Schema.Boolean>;
 }>;
 
 /** An INTERFACE — reached from `aiFlows.chainTo`; see {@link BriefField}. */
@@ -684,7 +680,7 @@ export declare interface FlowLifecycleEvent {
 /** Execution mode. Replaces the legacy `allowDeviation` boolean — a mode is not
  *  a boolean. `deterministic` runs the plan verbatim (resumable per step);
  *  `agentic` lets an orchestrator LLM adapt the plan via the four tools. */
-export declare const FlowMode: Schema.Literal<["deterministic", "agentic"]>;
+export declare const FlowMode: Schema.Literals<readonly ["deterministic", "agentic"]>;
 
 export declare type FlowMode = typeof FlowMode.Type;
 
@@ -693,46 +689,40 @@ export declare type FlowMode = typeof FlowMode.Type;
 declare class FlowNotAwaitingResponse extends FlowNotAwaitingResponse_base {
 }
 
-declare const FlowNotAwaitingResponse_base: Schema.TaggedErrorClass<FlowNotAwaitingResponse, "FlowNotAwaitingResponse", {
-    readonly _tag: Schema.tag<"FlowNotAwaitingResponse">;
-} & {
-    runId: typeof Schema.String;
-    status: typeof Schema.String;
-    message: typeof Schema.String;
-}>;
+declare const FlowNotAwaitingResponse_base: Schema.Class<FlowNotAwaitingResponse, Schema.TaggedStruct<"FlowNotAwaitingResponse", {
+    readonly runId: Schema.String;
+    readonly status: Schema.String;
+    readonly message: Schema.String;
+}>, YieldableError>;
 
 /** A flow (definition) could not be resolved by ref (code name or row id). */
 declare class FlowNotFound extends FlowNotFound_base {
 }
 
-declare const FlowNotFound_base: Schema.TaggedErrorClass<FlowNotFound, "FlowNotFound", {
-    readonly _tag: Schema.tag<"FlowNotFound">;
-} & {
-    flowRef: typeof Schema.String;
-    message: typeof Schema.String;
-}>;
+declare const FlowNotFound_base: Schema.Class<FlowNotFound, Schema.TaggedStruct<"FlowNotFound", {
+    readonly flowRef: Schema.String;
+    readonly message: Schema.String;
+}>, YieldableError>;
 
 /** No review-delivery confirmation. Unknown delivery may already have been consumed. */
 declare class FlowReviewDeliveryError extends FlowReviewDeliveryError_base {
 }
 
-declare const FlowReviewDeliveryError_base: Schema.TaggedErrorClass<FlowReviewDeliveryError, "FlowReviewDeliveryError", {
-    readonly _tag: Schema.tag<"FlowReviewDeliveryError">;
-} & {
-    runId: typeof Schema.String;
-    reason: Schema.Literal<["runtime-unavailable", "invalid-run", "invalid-response", "delivery-unknown"]>;
-    message: typeof Schema.String;
-}>;
+declare const FlowReviewDeliveryError_base: Schema.Class<FlowReviewDeliveryError, Schema.TaggedStruct<"FlowReviewDeliveryError", {
+    readonly runId: Schema.String;
+    readonly reason: Schema.Literals<readonly ["runtime-unavailable", "invalid-run", "invalid-response", "delivery-unknown"]>;
+    readonly message: Schema.String;
+}>, YieldableError>;
 
 /** Bind the answer to the review actually displayed, not the latest waiting step. */
 export declare const FlowReviewInput: Schema.Struct<{
-    runId: typeof Schema.NonEmptyString;
-    stepIndex: Schema.filter<typeof Schema.Int>;
-    response: Schema.Struct<{
-        decision: Schema.optional<Schema.Literal<["approve", "reject"]>>;
-        value: Schema.optional<typeof Schema.String>;
-        text: Schema.optional<typeof Schema.String>;
-        respondedAt: Schema.optional<typeof Schema.String>;
+    readonly runId: Schema.NonEmptyString;
+    readonly stepIndex: Schema.Int;
+    readonly response: Schema.Struct<{
+        readonly decision: Schema.optional<Schema.Literals<readonly ["approve", "reject"]>>;
+        readonly value: Schema.optional<Schema.String>;
+        readonly text: Schema.optional<Schema.String>;
+        readonly respondedAt: Schema.optional<Schema.String>;
     }>;
 }>;
 
@@ -740,11 +730,11 @@ export declare type FlowReviewInput = typeof FlowReviewInput.Type;
 
 /** Delivery accepted; consumption and the run's eventual outcome remain reactive state. */
 export declare const FlowReviewReceipt: Schema.Struct<{
-    runId: typeof Schema.NonEmptyString;
-    stepIndex: Schema.filter<typeof Schema.Int>;
-    executionId: typeof Schema.NonEmptyString;
-    eventId: typeof Schema.NonEmptyString;
-    status: Schema.Literal<["accepted"]>;
+    readonly runId: Schema.NonEmptyString;
+    readonly stepIndex: Schema.Int;
+    readonly executionId: Schema.NonEmptyString;
+    readonly eventId: Schema.NonEmptyString;
+    readonly status: Schema.Literal<"accepted">;
 }>;
 
 export declare type FlowReviewReceipt = typeof FlowReviewReceipt.Type;
@@ -771,12 +761,10 @@ export declare interface FlowRunContext {
 declare class FlowRunNotFound extends FlowRunNotFound_base {
 }
 
-declare const FlowRunNotFound_base: Schema.TaggedErrorClass<FlowRunNotFound, "FlowRunNotFound", {
-    readonly _tag: Schema.tag<"FlowRunNotFound">;
-} & {
-    runId: typeof Schema.String;
-    message: typeof Schema.String;
-}>;
+declare const FlowRunNotFound_base: Schema.Class<FlowRunNotFound, Schema.TaggedStruct<"FlowRunNotFound", {
+    readonly runId: Schema.String;
+    readonly message: Schema.String;
+}>, YieldableError>;
 
 /** The workflow payload shape (server executor input). */
 export declare interface FlowRunPayload {
@@ -815,18 +803,18 @@ export declare const flowSegments: (steps: ReadonlyArray<FlowStep>) => ReadonlyA
 
 /** Submission evidence, separate from the flow run's execution status. */
 export declare const FlowStartReceipt: Schema.Struct<{
-    runId: typeof Schema.NonEmptyString;
-    requestId: typeof Schema.NonEmptyString;
-    admission: Schema.Struct<{
-        id: typeof Schema.String;
-        workflowName: typeof Schema.String;
-        executionId: Schema.NullOr<typeof Schema.String>;
-        status: Schema.Literal<["running", "succeeded", "queued", "dropped", "skipped", "replayed"]>;
-        deferral: Schema.optional<Schema.Struct<{
-            mode: typeof Schema.String;
-            dueAt: Schema.NullOr<typeof Schema.Number>;
-            retryAfterMs: Schema.NullOr<typeof Schema.Number>;
-            intentId: Schema.NullOr<typeof Schema.String>;
+    readonly runId: Schema.NonEmptyString;
+    readonly requestId: Schema.NonEmptyString;
+    readonly admission: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly workflowName: Schema.String;
+        readonly executionId: Schema.NullOr<Schema.String>;
+        readonly status: Schema.Literals<readonly ["running", "succeeded", "queued", "dropped", "skipped", "replayed"]>;
+        readonly deferral: Schema.optional<Schema.Struct<{
+            readonly mode: Schema.String;
+            readonly dueAt: Schema.NullOr<Schema.Number>;
+            readonly retryAfterMs: Schema.NullOr<Schema.Number>;
+            readonly intentId: Schema.NullOr<Schema.String>;
         }>>;
     }>;
 }>;
@@ -850,7 +838,7 @@ export declare interface FlowStartReconciliation {
 }
 
 /** Flow-definition lifecycle. */
-export declare const FlowStatus: Schema.Literal<["draft", "active", "archived"]>;
+export declare const FlowStatus: Schema.Literals<readonly ["draft", "active", "archived"]>;
 
 export declare type FlowStatus = typeof FlowStatus.Type;
 
@@ -861,43 +849,43 @@ export declare type FlowStatus = typeof FlowStatus.Type;
  * `{{outputKey}}` in `prompt` / media refs.
  */
 export declare const FlowStep: Schema.Struct<{
-    id: typeof Schema.String;
-    title: Schema.optional<typeof Schema.String>;
+    readonly id: Schema.String;
+    readonly title: Schema.optional<Schema.String>;
     /** Informational; shown under the step in the run timeline. */
-    description: Schema.optional<typeof Schema.String>;
-    type: Schema.Literal<["agent", "generate", "structured", "note", "human"]>;
+    readonly description: Schema.optional<Schema.String>;
+    readonly type: Schema.Literals<readonly ["agent", "generate", "structured", "note", "human"]>;
     /** Sanitized [\w.-]; the result-bundle key + the `{{ref}}` name. */
-    outputKey: Schema.optional<typeof Schema.String>;
+    readonly outputKey: Schema.optional<Schema.String>;
     /** Template with `{{key}}` placeholders (brief inputs + prior outputKeys). */
-    prompt: Schema.optional<typeof Schema.String>;
-    modality: Schema.optional<Schema.Literal<["text", "image", "video", "audio"]>>;
-    model: Schema.optional<typeof Schema.String>;
-    params: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
-    mediaInputs: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Union<[Schema.Struct<{
-        from: Schema.Literal<["upload"]>;
-        url: typeof Schema.String;
-        mediaType: Schema.optional<typeof Schema.NonEmptyString>;
+    readonly prompt: Schema.optional<Schema.String>;
+    readonly modality: Schema.optional<Schema.Literals<readonly ["text", "image", "video", "audio"]>>;
+    readonly model: Schema.optional<Schema.String>;
+    readonly params: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly mediaInputs: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+        readonly from: Schema.Literal<"upload">;
+        readonly url: Schema.String;
+        readonly mediaType: Schema.optional<Schema.NonEmptyString>;
     }>, Schema.Struct<{
-        from: Schema.Literal<["step"]>;
-        ref: typeof Schema.String;
-        artifact: Schema.optional<Schema.filter<typeof Schema.Int>>;
+        readonly from: Schema.Literal<"step">;
+        readonly ref: Schema.String;
+        readonly artifact: Schema.optional<Schema.Int>;
     }>]>>>;
     /** Allowed sub-agent id/name, resolved and authorized by the host. */
-    agentRef: Schema.optional<typeof Schema.String>;
+    readonly agentRef: Schema.optional<Schema.String>;
     /** JSON Schema of the desired object, preserved and validated at run. */
-    schema: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
-    reviewMode: Schema.optional<Schema.Literal<["approve", "choice", "text"]>>;
-    options: Schema.optional<Schema.Array$<Schema.Struct<{
-        value: typeof Schema.String;
-        label: typeof Schema.String;
+    readonly schema: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly reviewMode: Schema.optional<Schema.Literals<readonly ["approve", "choice", "text"]>>;
+    readonly options: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly value: Schema.String;
+        readonly label: Schema.String;
     }>>>;
     /** Gate this step on a prior value. Absent → the step always runs. A step
      *  whose condition is false is SKIPPED, not failed: it produces no output, so
      *  anything referencing its `outputKey` sees an absent value. */
-    when: Schema.optional<Schema.Struct<{
-        ref: typeof Schema.String;
-        op: Schema.Literal<["truthy", "falsy", "eq", "neq", "contains"]>;
-        value: Schema.optional<typeof Schema.Unknown>;
+    readonly when: Schema.optional<Schema.Struct<{
+        readonly ref: Schema.String;
+        readonly op: Schema.Literals<readonly ["truthy", "falsy", "eq", "neq", "contains"]>;
+        readonly value: Schema.optional<Schema.Unknown>;
     }>>;
     /**
      * Fan-out group. CONSECUTIVE steps sharing a group name run CONCURRENTLY,
@@ -908,12 +896,12 @@ export declare const FlowStep: Schema.Struct<{
      * step may not join a group either: it suspends the whole workflow, which is
      * not a thing one branch of a fan-out can do.
      */
-    group: Schema.optional<typeof Schema.String>;
+    readonly group: Schema.optional<Schema.String>;
     /** `human` step only — how long the run parks awaiting this review before it
      *  fails, in milliseconds. Omitted → the flow's `humanTimeoutMs`, then the
      *  engine/plugin default (see `resolveHumanReviewTimeoutMs`). `0` means WAIT
      *  FOREVER (the park is slot-free, so an unbounded wait costs no worker). */
-    timeoutMs: Schema.optional<typeof Schema.Number>;
+    readonly timeoutMs: Schema.optional<Schema.Number>;
 }>;
 
 /**
@@ -1052,10 +1040,10 @@ export declare const HUMAN_REVIEW_TIMEOUT_HOURS_DEFAULT: number;
 
 /** The HITL answer; the engine projects it after consuming the durable signal. */
 export declare const HumanResponse: Schema.Struct<{
-    decision: Schema.optional<Schema.Literal<["approve", "reject"]>>;
-    value: Schema.optional<typeof Schema.String>;
-    text: Schema.optional<typeof Schema.String>;
-    respondedAt: Schema.optional<typeof Schema.String>;
+    readonly decision: Schema.optional<Schema.Literals<readonly ["approve", "reject"]>>;
+    readonly value: Schema.optional<Schema.String>;
+    readonly text: Schema.optional<Schema.String>;
+    readonly respondedAt: Schema.optional<Schema.String>;
 }>;
 
 /** An INTERFACE — reached from `aiFlowRuns.humanResponse`; see {@link BriefField}. */
@@ -1110,7 +1098,7 @@ export declare const interpolate: (text: string, context: Record<string, unknown
 export declare const isTruthy: (v: unknown) => boolean;
 
 /** A JSON value (for `params` / `input` / a `structured` step's JSON Schema). */
-export declare const Json: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+export declare const Json: Schema.$Record<Schema.String, Schema.Unknown>;
 
 export declare type Json = typeof Json.Type;
 
@@ -1130,8 +1118,8 @@ export declare const launchFlow: (ctx: AppContext, args: {
         readonly workflowName: string;
         readonly deferral?: {
             readonly mode: string;
-            readonly retryAfterMs: number | null;
             readonly dueAt: number | null;
+            readonly retryAfterMs: number | null;
             readonly intentId: string | null;
         } | undefined;
     };
@@ -1178,22 +1166,22 @@ export declare const MAX_STEPS_MIN = 1;
 /** One persisted media artifact. Storage identity is not a provider request ID.
  *  Exactly one artifact per result has role `primary`; other roles are host-defined. */
 export declare const MediaArtifact: Schema.Struct<{
-    url: typeof Schema.NonEmptyString;
-    mediaType: typeof Schema.NonEmptyString;
-    role: typeof Schema.NonEmptyString;
-    storageRefId: Schema.optional<typeof Schema.NonEmptyString>;
-    providerMetadata: Schema.optional<typeof Schema.Unknown>;
+    readonly url: Schema.NonEmptyString;
+    readonly mediaType: Schema.NonEmptyString;
+    readonly role: Schema.NonEmptyString;
+    readonly storageRefId: Schema.optional<Schema.NonEmptyString>;
+    readonly providerMetadata: Schema.optional<Schema.Unknown>;
 }>;
 
 export declare type MediaArtifact = typeof MediaArtifact.Type;
 
-export declare const MediaArtifacts: Schema.filter<Schema.Array$<Schema.Struct<{
-    url: typeof Schema.NonEmptyString;
-    mediaType: typeof Schema.NonEmptyString;
-    role: typeof Schema.NonEmptyString;
-    storageRefId: Schema.optional<typeof Schema.NonEmptyString>;
-    providerMetadata: Schema.optional<typeof Schema.Unknown>;
-}>>>;
+export declare const MediaArtifacts: Schema.$Array<Schema.Struct<{
+    readonly url: Schema.NonEmptyString;
+    readonly mediaType: Schema.NonEmptyString;
+    readonly role: Schema.NonEmptyString;
+    readonly storageRefId: Schema.optional<Schema.NonEmptyString>;
+    readonly providerMetadata: Schema.optional<Schema.Unknown>;
+}>>;
 
 /** Host-supplied media generator for image/video/audio steps — `@voltro/ai`'s
  *  `generateImage` / `generateVideo` / `generateSpeech` plug in here via the
@@ -1215,14 +1203,14 @@ export declare type MediaGenerator = (args: {
     readonly run: FlowRunContext;
 }) => Effect.Effect<MediaResult, FlowCapabilityMissing, unknown>;
 
-export declare const MediaInputs: Schema.Record$<typeof Schema.String, Schema.Union<[Schema.Struct<{
-    from: Schema.Literal<["upload"]>;
-    url: typeof Schema.String;
-    mediaType: Schema.optional<typeof Schema.NonEmptyString>;
+export declare const MediaInputs: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+    readonly from: Schema.Literal<"upload">;
+    readonly url: Schema.String;
+    readonly mediaType: Schema.optional<Schema.NonEmptyString>;
 }>, Schema.Struct<{
-    from: Schema.Literal<["step"]>;
-    ref: typeof Schema.String;
-    artifact: Schema.optional<Schema.filter<typeof Schema.Int>>;
+    readonly from: Schema.Literal<"step">;
+    readonly ref: Schema.String;
+    readonly artifact: Schema.optional<Schema.Int>;
 }>]>>;
 
 export declare type MediaInputs = typeof MediaInputs.Type;
@@ -1230,14 +1218,14 @@ export declare type MediaInputs = typeof MediaInputs.Type;
 /** A media-input slot — an absolute HTTP(S) uploaded URL or a reference to a
  *  brief field/prior step's URL output. Keyed by capability slot name
  *  (`referenceImageUrl`, `lastFrameImageUrl`, `referenceVideoUrl`, …). */
-export declare const MediaInputSlot: Schema.Union<[Schema.Struct<{
-    from: Schema.Literal<["upload"]>;
-    url: typeof Schema.String;
-    mediaType: Schema.optional<typeof Schema.NonEmptyString>;
+export declare const MediaInputSlot: Schema.Union<readonly [Schema.Struct<{
+    readonly from: Schema.Literal<"upload">;
+    readonly url: Schema.String;
+    readonly mediaType: Schema.optional<Schema.NonEmptyString>;
 }>, Schema.Struct<{
-    from: Schema.Literal<["step"]>;
-    ref: typeof Schema.String;
-    artifact: Schema.optional<Schema.filter<typeof Schema.Int>>;
+    readonly from: Schema.Literal<"step">;
+    readonly ref: Schema.String;
+    readonly artifact: Schema.optional<Schema.Int>;
 }>]>;
 
 export declare type MediaInputSlot = typeof MediaInputSlot.Type;
@@ -1267,43 +1255,43 @@ export declare interface MediaPersist {
  * succeeded one; the run's `costCompleteness` counts it.
  */
 export declare const MediaReceipt: Schema.Struct<{
-    costMicroUsd: Schema.optional<Schema.filter<typeof Schema.Finite>>;
-    costSource: Schema.optional<Schema.Literal<["gateway", "estimated", "unpriced"]>>;
-    requestId: Schema.optional<typeof Schema.NonEmptyString>;
-    usage: Schema.optional<Schema.Struct<{
-        status: Schema.Literal<["reported", "unreported"]>;
-        unit: Schema.optional<Schema.Literal<["tokens", "characters", "seconds"]>>;
-        input: Schema.optional<Schema.filter<typeof Schema.Finite>>;
-        output: Schema.optional<Schema.filter<typeof Schema.Finite>>;
+    readonly costMicroUsd: Schema.optional<Schema.Finite>;
+    readonly costSource: Schema.optional<Schema.Literals<readonly ["gateway", "estimated", "unpriced"]>>;
+    readonly requestId: Schema.optional<Schema.NonEmptyString>;
+    readonly usage: Schema.optional<Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["reported", "unreported"]>;
+        readonly unit: Schema.optional<Schema.Literals<readonly ["tokens", "characters", "seconds"]>>;
+        readonly input: Schema.optional<Schema.Finite>;
+        readonly output: Schema.optional<Schema.Finite>;
     }>>;
 }>;
 
 export declare type MediaReceipt = typeof MediaReceipt.Type;
 
 export declare const MediaResult: Schema.Struct<{
-    artifacts: Schema.filter<Schema.Array$<Schema.Struct<{
-        url: typeof Schema.NonEmptyString;
-        mediaType: typeof Schema.NonEmptyString;
-        role: typeof Schema.NonEmptyString;
-        storageRefId: Schema.optional<typeof Schema.NonEmptyString>;
-        providerMetadata: Schema.optional<typeof Schema.Unknown>;
-    }>>>;
-    costMicroUsd: Schema.optional<Schema.filter<typeof Schema.Finite>>;
-    costSource: Schema.optional<Schema.Literal<["gateway", "estimated", "unpriced"]>>;
+    readonly artifacts: Schema.$Array<Schema.Struct<{
+        readonly url: Schema.NonEmptyString;
+        readonly mediaType: Schema.NonEmptyString;
+        readonly role: Schema.NonEmptyString;
+        readonly storageRefId: Schema.optional<Schema.NonEmptyString>;
+        readonly providerMetadata: Schema.optional<Schema.Unknown>;
+    }>>;
+    readonly costMicroUsd: Schema.optional<Schema.Finite>;
+    readonly costSource: Schema.optional<Schema.Literals<readonly ["gateway", "estimated", "unpriced"]>>;
     /** A provider/usage correlation only, never a storage reference. */
-    requestId: Schema.optional<typeof Schema.NonEmptyString>;
+    readonly requestId: Schema.optional<Schema.NonEmptyString>;
     /** What the generation consumed — the quantity behind `costMicroUsd`. */
-    usage: Schema.optional<Schema.Struct<{
-        status: Schema.Literal<["reported", "unreported"]>;
-        unit: Schema.optional<Schema.Literal<["tokens", "characters", "seconds"]>>;
-        input: Schema.optional<Schema.filter<typeof Schema.Finite>>;
-        output: Schema.optional<Schema.filter<typeof Schema.Finite>>;
+    readonly usage: Schema.optional<Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["reported", "unreported"]>;
+        readonly unit: Schema.optional<Schema.Literals<readonly ["tokens", "characters", "seconds"]>>;
+        readonly input: Schema.optional<Schema.Finite>;
+        readonly output: Schema.optional<Schema.Finite>;
     }>>;
 }>;
 
 export declare type MediaResult = typeof MediaResult.Type;
 
-export declare const Modality: Schema.Literal<["text", "image", "video", "audio"]>;
+export declare const Modality: Schema.Literals<readonly ["text", "image", "video", "audio"]>;
 
 export declare type Modality = typeof Modality.Type;
 
@@ -1347,14 +1335,14 @@ export declare const registerFlow: (ir: FlowIR) => void;
 /** Test seam — forget the recorded tunables. */
 export declare const resetAiFlowsDefaults: () => void;
 
-declare const ResolvedMediaInputRefs: Schema.Record$<typeof Schema.String, Schema.Struct<{
-    url: Schema.filter<typeof Schema.String>;
-    mediaType: typeof Schema.NonEmptyString;
+declare const ResolvedMediaInputRefs: Schema.$Record<Schema.String, Schema.Struct<{
+    readonly url: Schema.String;
+    readonly mediaType: Schema.NonEmptyString;
 }>>;
 
 declare type ResolvedMediaInputRefs = typeof ResolvedMediaInputRefs.Type;
 
-declare const ResolvedMediaInputs: Schema.Record$<typeof Schema.String, Schema.filter<typeof Schema.String>>;
+declare const ResolvedMediaInputs: Schema.$Record<Schema.String, Schema.String>;
 
 declare type ResolvedMediaInputs = typeof ResolvedMediaInputs.Type;
 
@@ -1396,11 +1384,11 @@ export declare const resolveMaxChainDepth: (deps?: {
  *  this sender, projects the consumed answer into humanResponse. A lost delivery
  *  acknowledgement is unknown, never a fabricated successful response. */
 export declare const respondToFlow: (ctx: AppContext, args: FlowReviewInput) => Effect.Effect<{
-    readonly status: "accepted";
     readonly runId: string;
+    readonly stepIndex: number;
     readonly executionId: string;
     readonly eventId: string;
-    readonly stepIndex: number;
+    readonly status: "accepted";
 }, FlowRunNotFound | FlowNotAwaitingResponse | FlowReviewDeliveryError, never>;
 
 /** Resubmit the persisted input under the same requestId. The returned admission
@@ -1418,20 +1406,20 @@ export declare const retryFlow: (ctx: AppContext, args: {
         readonly workflowName: string;
         readonly deferral?: {
             readonly mode: string;
-            readonly retryAfterMs: number | null;
             readonly dueAt: number | null;
+            readonly retryAfterMs: number | null;
             readonly intentId: string | null;
         } | undefined;
     };
 }, FlowRunNotFound, never>;
 
-export declare const ReviewMode: Schema.Literal<["approve", "choice", "text"]>;
+export declare const ReviewMode: Schema.Literals<readonly ["approve", "choice", "text"]>;
 
 export declare type ReviewMode = typeof ReviewMode.Type;
 
 export declare const ReviewOption: Schema.Struct<{
-    value: typeof Schema.String;
-    label: typeof Schema.String;
+    readonly value: Schema.String;
+    readonly label: Schema.String;
 }>;
 
 export declare type ReviewOption = typeof ReviewOption.Type;
@@ -1451,18 +1439,18 @@ export declare const runCadenceTick: (ctx: AppContext, now?: Date) => Promise<{
 
 /** Human-review config projected onto a `waiting` run step. */
 export declare const RunReview: Schema.Struct<{
-    mode: Schema.Literal<["approve", "choice", "text"]>;
-    options: Schema.optional<Schema.Array$<Schema.Struct<{
-        value: typeof Schema.String;
-        label: typeof Schema.String;
+    readonly mode: Schema.Literals<readonly ["approve", "choice", "text"]>;
+    readonly options: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly value: Schema.String;
+        readonly label: Schema.String;
     }>>>;
-    prompt: typeof Schema.String;
+    readonly prompt: Schema.String;
 }>;
 
 export declare type RunReview = typeof RunReview.Type;
 
 /** What triggered a run. */
-export declare const RunSource: Schema.Literal<["manual", "cron"]>;
+export declare const RunSource: Schema.Literals<readonly ["manual", "cron"]>;
 
 export declare type RunSource = typeof RunSource.Type;
 
@@ -1473,62 +1461,62 @@ export declare type RunSource = typeof RunSource.Type;
  *  confirmed: the row carries that uncertainty until the engine stops the run
  *  (cooperatively, by interruption, or through a later confirmed request).
  *  Only `succeeded`, `failed` and `cancelled` are terminal. */
-export declare const RunStatus: Schema.Literal<["pending", "running", "waiting", "cancelling", "succeeded", "failed", "cancelled"]>;
+export declare const RunStatus: Schema.Literals<readonly ["pending", "running", "waiting", "cancelling", "succeeded", "failed", "cancelled"]>;
 
 export declare type RunStatus = typeof RunStatus.Type;
 
 export declare const RunStep: Schema.Struct<{
-    id: typeof Schema.Number;
-    title: typeof Schema.String;
-    description: Schema.optional<typeof Schema.String>;
-    type: Schema.Literal<["agent", "generate", "structured", "note", "human"]>;
-    status: Schema.Literal<["pending", "running", "waiting", "succeeded", "failed", "skipped"]>;
+    readonly id: Schema.Number;
+    readonly title: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+    readonly type: Schema.Literals<readonly ["agent", "generate", "structured", "note", "human"]>;
+    readonly status: Schema.Literals<readonly ["pending", "running", "waiting", "succeeded", "failed", "skipped"]>;
     /** The agent an `agent` step delegated to — a field, so a run view never
      *  parses it out of `title`. */
-    agentRef: Schema.optional<typeof Schema.String>;
+    readonly agentRef: Schema.optional<Schema.String>;
     /** What a `generate` step produced. */
-    modality: Schema.optional<Schema.Literal<["text", "image", "video", "audio"]>>;
-    startedAt: Schema.optional<typeof Schema.String>;
-    completedAt: Schema.optional<typeof Schema.String>;
+    readonly modality: Schema.optional<Schema.Literals<readonly ["text", "image", "video", "audio"]>>;
+    readonly startedAt: Schema.optional<Schema.String>;
+    readonly completedAt: Schema.optional<Schema.String>;
     /** Per-step cost in micro-USD (the app view projects to €/cents). */
-    costMicroUsd: Schema.optional<typeof Schema.Number>;
+    readonly costMicroUsd: Schema.optional<Schema.Number>;
     /** Where that number came from — the gateway's actual charge, a price-table
      *  estimate, or nothing (`unpriced`: the 0 above is not a price). */
-    costSource: Schema.optional<Schema.Literal<["gateway", "estimated", "unpriced"]>>;
+    readonly costSource: Schema.optional<Schema.Literals<readonly ["gateway", "estimated", "unpriced"]>>;
     /** Links a media step to its generation/usage record. */
-    requestId: Schema.optional<typeof Schema.String>;
+    readonly requestId: Schema.optional<Schema.String>;
     /** What the step consumed — also on a FAILED step that was charged. */
-    usage: Schema.optional<Schema.Struct<{
-        status: Schema.Literal<["reported", "unreported"]>;
-        unit: Schema.optional<Schema.Literal<["tokens", "characters", "seconds"]>>;
-        input: Schema.optional<Schema.filter<typeof Schema.Finite>>;
-        output: Schema.optional<Schema.filter<typeof Schema.Finite>>;
+    readonly usage: Schema.optional<Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["reported", "unreported"]>;
+        readonly unit: Schema.optional<Schema.Literals<readonly ["tokens", "characters", "seconds"]>>;
+        readonly input: Schema.optional<Schema.Finite>;
+        readonly output: Schema.optional<Schema.Finite>;
     }>>;
     /** Hosted media artifact URL (image/video/audio), via storage. */
-    url: Schema.optional<typeof Schema.String>;
+    readonly url: Schema.optional<Schema.String>;
     /** All media variants, including roles and storage references; url projects the primary artifact. */
-    artifacts: Schema.optional<Schema.filter<Schema.Array$<Schema.Struct<{
-        url: typeof Schema.NonEmptyString;
-        mediaType: typeof Schema.NonEmptyString;
-        role: typeof Schema.NonEmptyString;
-        storageRefId: Schema.optional<typeof Schema.NonEmptyString>;
-        providerMetadata: Schema.optional<typeof Schema.Unknown>;
-    }>>>>;
+    readonly artifacts: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly url: Schema.NonEmptyString;
+        readonly mediaType: Schema.NonEmptyString;
+        readonly role: Schema.NonEmptyString;
+        readonly storageRefId: Schema.optional<Schema.NonEmptyString>;
+        readonly providerMetadata: Schema.optional<Schema.Unknown>;
+    }>>>;
     /** Inline text output (rendered as markdown). */
-    output: Schema.optional<Schema.Struct<{
-        text: typeof Schema.String;
+    readonly output: Schema.optional<Schema.Struct<{
+        readonly text: Schema.String;
     }>>;
-    errorMessage: Schema.optional<typeof Schema.String>;
+    readonly errorMessage: Schema.optional<Schema.String>;
     /** Why a `skipped` step was skipped — the rendered condition, so the timeline
      *  says "{{approved}} is not set" instead of leaving a silent gap. */
-    skipReason: Schema.optional<typeof Schema.String>;
-    review: Schema.optional<Schema.Struct<{
-        mode: Schema.Literal<["approve", "choice", "text"]>;
-        options: Schema.optional<Schema.Array$<Schema.Struct<{
-            value: typeof Schema.String;
-            label: typeof Schema.String;
+    readonly skipReason: Schema.optional<Schema.String>;
+    readonly review: Schema.optional<Schema.Struct<{
+        readonly mode: Schema.Literals<readonly ["approve", "choice", "text"]>;
+        readonly options: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly value: Schema.String;
+            readonly label: Schema.String;
         }>>>;
-        prompt: typeof Schema.String;
+        readonly prompt: Schema.String;
     }>>;
 }>;
 
@@ -1560,7 +1548,7 @@ export declare interface RunStep {
     readonly review?: RunReview | undefined;
 }
 
-export declare const RunStepStatus: Schema.Literal<["pending", "running", "waiting", "succeeded", "failed", "skipped"]>;
+export declare const RunStepStatus: Schema.Literals<readonly ["pending", "running", "waiting", "succeeded", "failed", "skipped"]>;
 
 export declare type RunStepStatus = typeof RunStepStatus.Type;
 
@@ -1572,10 +1560,10 @@ export declare const setAiFlowsDefaults: (defaults: AiFlowsDefaults) => void;
 
 declare const StepCondition: Schema.Struct<{
     /** A brief-field key or an EARLIER step's `outputKey`. */
-    ref: typeof Schema.String;
-    op: Schema.Literal<["truthy", "falsy", "eq", "neq", "contains"]>;
+    readonly ref: Schema.String;
+    readonly op: Schema.Literals<readonly ["truthy", "falsy", "eq", "neq", "contains"]>;
     /** The right-hand side for `eq` / `neq` / `contains`. Ignored by the unary ops. */
-    value: Schema.optional<typeof Schema.Unknown>;
+    readonly value: Schema.optional<Schema.Unknown>;
 }>;
 
 /** An INTERFACE, for the same api-report reason as `FlowStep` — it is reached
@@ -1599,7 +1587,7 @@ declare interface StepControls {
 }
 
 /** The five step types. `generate` fans out to four modalities. */
-export declare const StepType: Schema.Literal<["agent", "generate", "structured", "note", "human"]>;
+export declare const StepType: Schema.Literals<readonly ["agent", "generate", "structured", "note", "human"]>;
 
 export declare type StepType = typeof StepType.Type;
 
@@ -1614,10 +1602,10 @@ export declare type StepType = typeof StepType.Type;
  * later, or reconciled against an invoice.
  */
 export declare const StepUsage: Schema.Struct<{
-    status: Schema.Literal<["reported", "unreported"]>;
-    unit: Schema.optional<Schema.Literal<["tokens", "characters", "seconds"]>>;
-    input: Schema.optional<Schema.filter<typeof Schema.Finite>>;
-    output: Schema.optional<Schema.filter<typeof Schema.Finite>>;
+    readonly status: Schema.Literals<readonly ["reported", "unreported"]>;
+    readonly unit: Schema.optional<Schema.Literals<readonly ["tokens", "characters", "seconds"]>>;
+    readonly input: Schema.optional<Schema.Finite>;
+    readonly output: Schema.optional<Schema.Finite>;
 }>;
 
 export declare type StepUsage = typeof StepUsage.Type;
@@ -1647,7 +1635,7 @@ export declare const updateFlow: (ctx: AppContext, args: {
 export declare const validateFlow: (ir: FlowIR) => void;
 
 /** Gallery scope. `shared` → per-subject share list; `organization` → tenant. */
-export declare const Visibility: Schema.Literal<["private", "organization", "shared"]>;
+export declare const Visibility: Schema.Literals<readonly ["private", "organization", "shared"]>;
 
 export declare type Visibility = typeof Visibility.Type;