lua-cli 3.35.0 → 3.37.0

package/dist/api-exports.d.ts

@@ -130,6 +130,35 @@ declare interface AgentInvocationInput {
     /** Per-request model override ("provider/model" code). Unknown codes fall back per
      *  approved-models policy server-side. */
     model?: string;
+    /**
+     * Workflow model classes (plan 6.4 "Caller-supplied legs", C.7) — the ordered,
+     * concrete `'provider/model'` codes THIS turn may run, primary first. The worker
+     * computes them (the resolved class row plus the other eligible rows of the same
+     * class, filtered to the run's consented estimate); the chat plane uses them
+     * VERBATIM as the fallback-leg list instead of the registry chain, which is the
+     * only way a workflow step can hop a leg at all — the worker sees the terminal
+     * turn and cannot hop mid-turn because tool side effects happen inside it.
+     *
+     * A pin passes exactly one leg, which is how "never substitute a model inside a
+     * workflow" becomes true: no registry chain, no last-resort platform default.
+     *
+     * Honoured server-side ONLY on internally-authenticated turns and ONLY for
+     * `channel: 'workflow'` — same posture as `toolScope`: `buildChatRequest` drops a
+     * Bearer client's value, so no client of `/chat/generate` can steer which models
+     * its turn may run.
+     */
+    legs?: string[];
+    /**
+     * Workflow model classes (plan 6.4, the `effort` row) — the reasoning effort for
+     * THIS turn. Deliberately the narrow three-value ladder the composer writes, not
+     * the six-value `ReasoningEffort` scale: the worker can never push `off`,
+     * `minimal` or `max` through the invocation. Mapped identity-wise onto
+     * `ChatRequest.options.reasoning.effort` (low → low, medium → medium, high →
+     * high), clamped to the served row's own `efforts` ladder and translated into the
+     * provider's dialect at the model-resolution seam. Inert on toggle-only rows.
+     * The applied value comes back on `AgentInvocationMeter.effortApplied`.
+     */
+    effort?: 'low' | 'medium' | 'high';
     /**
      * LUA-655 (review M2) — a platform re-ask the customer must not pay for: the workflow executor's
      * output-repair turns. Honoured server-side ONLY on internally-authenticated turns
@@ -189,19 +218,6 @@ declare interface AgentInvocationInput {
     };
 }
 
-/**
- * LUA-724 (PR 7) — the billed turn's pricing inputs, exactly as chat's settlement event carries
- * them (`chat.service.trackLlmInferenceUsage`): the model that ACTUALLY served the turn (the
- * resolver's code, not the caller's pin), the de-paged `contextInputTokens` (largest single
- * step's prompt — never the whole-turn sum), the tool-call COUNT, and whether the turn ran on
- * the org's own key. `chargedCredits` echoes the gate's answer (true ⇒ the legacy pool deducted
- * in real time; false ⇒ seat org / free turn — settlement meters it).
- *
- * Stamped by the serving pod ONLY on internal-auth turns that carry a billing `operationId`
- * (the workflow agent-step loopback), as the enumerable `luaMeter` top-level field of the
- * generate envelope — never on a Bearer turn, so the public wire is byte-identical. The
- * workflow executor prices the step's `run.budget.spent` from it with `priceModelCall`.
- */
 declare interface AgentInvocationMeter {
     model?: string;
     contextInputTokens?: number;
@@ -215,6 +231,16 @@ declare interface AgentInvocationMeter {
     toolNames?: string[];
     byok?: boolean;
     chargedCredits?: boolean;
+    /**
+     * Workflow model classes (plan 6.4, the `effort` row; round-2 architect finding 7) — the
+     * effort that was ACTUALLY applied to the turn: the request/agent/tier merge clamped to the
+     * SERVED model's `efforts` ladder, which is not always what was asked for (a row whose ladder
+     * omits `medium` serves `low`). Server-owned and stamped beside `model` on the same
+     * `operationId`-bearing loopback turns, so the worker can record it on the step row without a
+     * seventh hop of its own. Absent when no effort was in play (no requested effort, or a model
+     * that advertises no reasoning) — a non-effort turn's meter is byte-identical to today's.
+     */
+    effortApplied?: ReasoningEffort;
 }
 
 declare interface AgentInvocationOutput {
@@ -370,6 +396,30 @@ export declare interface AgentStepOptions {
      */
     maxMessages?: number;
     maxInputTokens?: number;
+    /**
+     * What this step DOES: `classify` | `extract` | `transform` | `draft` | `research` | `reason` | `code` |
+     * `judge`. On a PUSHED definition it must come with a `model` — a static `taskClass` with none is refused
+     * `task-class-without-model`, because nothing maps a task class to a model at dispatch.
+     */
+    taskClass?: WorkflowTaskClass;
+    /**
+     * Traits the chosen model must have: `vision` | `structured` | `largeContext` | `codeExecution`. Write these
+     * rather than pinning a code that may retire. A step with an `outputSchema` needs `structured`; one reading
+     * images needs `vision`.
+     */
+    requires?: WorkflowModelTrait[];
+    /** One line on why this class or pin was chosen — at most 160 characters, plain text, never parsed. */
+    modelReason?: string;
+    /**
+     * Reasoning effort for this step: `low` for fast work and tool-heavy orchestration, `high` for `reason` and
+     * `code`, `medium` otherwise. Inert on rows whose ladder is toggle-only.
+     *
+     * COMPATIBILITY: writing it changes nothing on its own. A plain `lua push` keeps the envelope at
+     * `luaWorkflow: 1`, and the executor forwards effort only when the run's frozen snapshot says 2 — opted into
+     * by `lua push --apply-effort` or by a new compose while assignment is on (plan 6.4, "The effort marker").
+     * Until then the value is carried and estimated, never applied.
+     */
+    effort?: WorkflowAgentEffort;
 }
 
 export declare interface AgentToolScope {
@@ -1394,6 +1444,52 @@ export declare type ChatMessage = TextMessage | ImageMessage | FileMessage;
  */
 export declare type ContainerArm = StepRef | [LuaMapConfig, StepRef];
 
+/**
+ * Who is in the conversation this turn runs in.
+ */
+export declare type ConversationKind = 'direct' | 'group';
+
+export declare interface ConversationParticipant {
+    /** Lua user id. For a Teams participant this is the user Lua minted for them. */
+    userId: string;
+    /** Server-resolved display name. */
+    displayName: string;
+    /** True for the room owner (desktop rooms); absent on channel rooms, which have no human owner. */
+    isOwner?: boolean;
+    /** True for the person who sent this turn. */
+    isCurrentSpeaker?: boolean;
+    /** How this person is known on the external channel (Teams group chats). */
+    channelIdentity?: {
+        provider: 'teams' | 'slack' | 'whatsapp';
+        externalId: string;
+        email?: string;
+    };
+}
+
+/**
+ * The conversation a turn runs in. Present on group turns (a desktop room or a
+ * Teams group chat); undefined on 1:1 chats, jobs, webhooks, triggers and
+ * workflow steps.
+ */
+export declare interface ConversationRef {
+    /** The room conversation id (`room:<id>`). */
+    id: string;
+    kind: ConversationKind;
+    channel: Channel;
+    /** The provider's conversation id; pass it to `Channels.send({ to: { conversationId } })` to reply proactively. */
+    externalId?: string;
+    currentSpeakerId?: string;
+    /** Capped at 50 entries, current speaker first; see `participantCount` and `truncated`. */
+    participants: ConversationParticipant[];
+    participantCount: number;
+    truncated: boolean;
+    /** The agents seated in the conversation. */
+    agents?: Array<{
+        agentId: string;
+        name?: string;
+    }>;
+}
+
 /**
  * Options for creating a custom data entry.
  */
@@ -3056,6 +3152,13 @@ export declare const lte: (l: TypedRef<number> | number, r: TypedRef<number> | L
  * if (Lua.request.webhook) {
  *   const payload = Lua.request.webhook.payload;
  * }
+ *
+ * // In a group conversation (a desktop room or a Teams group chat), see who is in it
+ * const conversation = Lua.request.conversation;
+ * if (conversation?.kind === 'group') {
+ *   const speaker = conversation.participants.find((p) => p.isCurrentSpeaker);
+ *   const others = conversation.participants.filter((p) => !p.isCurrentSpeaker).map((p) => p.displayName);
+ * }
  * ```
  */
 export declare const Lua: LuaRuntime;
@@ -3618,6 +3721,11 @@ export declare interface LuaRequest {
     userId?: string;
     /** The id of the agent handling this turn. */
     agentId?: string;
+    /**
+     * The group conversation this turn belongs to, with its participants and the
+     * current speaker. Undefined on 1:1 turns and on non-chat executions.
+     */
+    conversation?: ConversationRef;
 }
 
 /**
@@ -4017,13 +4125,13 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         provider?: "deepgram" | "elevenlabs";
         kind?: "plugin";
-        options?: Record<string, unknown>;
         class?: "LLM" | "STT" | "STTv2" | "TTS";
+        options?: Record<string, unknown>;
     }, {
         provider?: "deepgram" | "elevenlabs";
         kind?: "plugin";
-        options?: Record<string, unknown>;
         class?: "LLM" | "STT" | "STTv2" | "TTS";
+        options?: Record<string, unknown>;
     }>, z.ZodObject<{
         kind: z.ZodLiteral<"realtime">;
         provider: z.ZodEnum<["openai", "google", "xai"]>;
@@ -4083,13 +4191,13 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         provider?: "deepgram" | "elevenlabs";
         kind?: "plugin";
-        options?: Record<string, unknown>;
         class?: "LLM" | "STT" | "STTv2" | "TTS";
+        options?: Record<string, unknown>;
     }, {
         provider?: "deepgram" | "elevenlabs";
         kind?: "plugin";
-        options?: Record<string, unknown>;
         class?: "LLM" | "STT" | "STTv2" | "TTS";
+        options?: Record<string, unknown>;
     }>, z.ZodObject<{
         kind: z.ZodLiteral<"realtime">;
         provider: z.ZodEnum<["openai", "google", "xai"]>;
@@ -4149,13 +4257,13 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         provider?: "deepgram" | "elevenlabs";
         kind?: "plugin";
-        options?: Record<string, unknown>;
         class?: "LLM" | "STT" | "STTv2" | "TTS";
+        options?: Record<string, unknown>;
     }, {
         provider?: "deepgram" | "elevenlabs";
         kind?: "plugin";
-        options?: Record<string, unknown>;
         class?: "LLM" | "STT" | "STTv2" | "TTS";
+        options?: Record<string, unknown>;
     }>, z.ZodObject<{
         kind: z.ZodLiteral<"realtime">;
         provider: z.ZodEnum<["openai", "google", "xai"]>;
@@ -4341,8 +4449,8 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     } | {
         provider?: "deepgram" | "elevenlabs";
         kind?: "plugin";
-        options?: Record<string, unknown>;
         class?: "LLM" | "STT" | "STTv2" | "TTS";
+        options?: Record<string, unknown>;
     } | {
         provider?: "google" | "xai" | "openai";
         kind?: "realtime";
@@ -4357,8 +4465,8 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     } | {
         provider?: "deepgram" | "elevenlabs";
         kind?: "plugin";
-        options?: Record<string, unknown>;
         class?: "LLM" | "STT" | "STTv2" | "TTS";
+        options?: Record<string, unknown>;
     } | {
         provider?: "google" | "xai" | "openai";
         kind?: "realtime";
@@ -4372,8 +4480,8 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     } | {
         provider?: "deepgram" | "elevenlabs";
         kind?: "plugin";
-        options?: Record<string, unknown>;
         class?: "LLM" | "STT" | "STTv2" | "TTS";
+        options?: Record<string, unknown>;
     } | {
         provider?: "google" | "xai" | "openai";
         kind?: "realtime";
@@ -4435,8 +4543,8 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     } | {
         provider?: "deepgram" | "elevenlabs";
         kind?: "plugin";
-        options?: Record<string, unknown>;
         class?: "LLM" | "STT" | "STTv2" | "TTS";
+        options?: Record<string, unknown>;
     } | {
         provider?: "google" | "xai" | "openai";
         kind?: "realtime";
@@ -4451,8 +4559,8 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     } | {
         provider?: "deepgram" | "elevenlabs";
         kind?: "plugin";
-        options?: Record<string, unknown>;
         class?: "LLM" | "STT" | "STTv2" | "TTS";
+        options?: Record<string, unknown>;
     } | {
         provider?: "google" | "xai" | "openai";
         kind?: "realtime";
@@ -4466,8 +4574,8 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     } | {
         provider?: "deepgram" | "elevenlabs";
         kind?: "plugin";
-        options?: Record<string, unknown>;
         class?: "LLM" | "STT" | "STTv2" | "TTS";
+        options?: Record<string, unknown>;
     } | {
         provider?: "google" | "xai" | "openai";
         kind?: "realtime";
@@ -4529,8 +4637,8 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     } | {
         provider?: "deepgram" | "elevenlabs";
         kind?: "plugin";
-        options?: Record<string, unknown>;
         class?: "LLM" | "STT" | "STTv2" | "TTS";
+        options?: Record<string, unknown>;
     } | {
         provider?: "google" | "xai" | "openai";
         kind?: "realtime";
@@ -4545,8 +4653,8 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     } | {
         provider?: "deepgram" | "elevenlabs";
         kind?: "plugin";
-        options?: Record<string, unknown>;
         class?: "LLM" | "STT" | "STTv2" | "TTS";
+        options?: Record<string, unknown>;
     } | {
         provider?: "google" | "xai" | "openai";
         kind?: "realtime";
@@ -4560,8 +4668,8 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     } | {
         provider?: "deepgram" | "elevenlabs";
         kind?: "plugin";
-        options?: Record<string, unknown>;
         class?: "LLM" | "STT" | "STTv2" | "TTS";
+        options?: Record<string, unknown>;
     } | {
         provider?: "google" | "xai" | "openai";
         kind?: "realtime";
@@ -4623,8 +4731,8 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     } | {
         provider?: "deepgram" | "elevenlabs";
         kind?: "plugin";
-        options?: Record<string, unknown>;
         class?: "LLM" | "STT" | "STTv2" | "TTS";
+        options?: Record<string, unknown>;
     } | {
         provider?: "google" | "xai" | "openai";
         kind?: "realtime";
@@ -4639,8 +4747,8 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     } | {
         provider?: "deepgram" | "elevenlabs";
         kind?: "plugin";
-        options?: Record<string, unknown>;
         class?: "LLM" | "STT" | "STTv2" | "TTS";
+        options?: Record<string, unknown>;
     } | {
         provider?: "google" | "xai" | "openai";
         kind?: "realtime";
@@ -4654,8 +4762,8 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     } | {
         provider?: "deepgram" | "elevenlabs";
         kind?: "plugin";
-        options?: Record<string, unknown>;
         class?: "LLM" | "STT" | "STTv2" | "TTS";
+        options?: Record<string, unknown>;
     } | {
         provider?: "google" | "xai" | "openai";
         kind?: "realtime";
@@ -6379,6 +6487,12 @@ declare interface StartWorkflowRunResult {
     /** ISO — the existing run's creation time. */
     startedAt?: string;
     output?: unknown;
+    /**
+     * [WMC-E7] §6.4 — the run's `modelConsent`, the SAME object the run detail carries, served with a `gated`
+     * start so the person deciding sees the plan and the cost line at the moment they are asked. Absent on a
+     * run that assigned no model and on every server that does not serve it.
+     */
+    modelConsent?: WorkflowModelConsentView;
 }
 
 export declare const state: <T = unknown>(path: string) => TypedRef<T>;
@@ -7230,6 +7344,9 @@ declare interface WhatsAppTemplateUrlButton {
     example?: string | string[];
 }
 
+/** `agent.effort` — the reasoning-effort hint a graph agent node may carry (lua-core's envelope member). */
+declare const WORKFLOW_AGENT_EFFORTS: readonly ["low", "medium", "high"];
+
 /** `approval.onDeny` (§6.4.11 deny-as-data): `'fail'` fails the step on a denial; default `'continue'`. */
 declare const WORKFLOW_APPROVAL_ON_DENY: readonly ["fail", "continue"];
 
@@ -7239,6 +7356,13 @@ declare const WORKFLOW_JOB_HARNESSES: readonly ["claude-code", "generic"];
 /** `jobResources` (05 §5.17): the Job-tier pod size class. Default `'small'` at spawn. */
 declare const WORKFLOW_JOB_RESOURCES: readonly ["small", "medium", "large"];
 
+/**
+ * Required traits — capabilities the chosen model MUST have (`AgentNode.requires`), so a composed step can
+ * say "needs vision" without pinning a code that may retire. Derived from the catalog row's `media`,
+ * `structuredOutput`, `contextWindow` and `tools.codeExecution` (plan 6.2).
+ */
+declare const WORKFLOW_MODEL_TRAITS: readonly ["vision", "structured", "largeContext", "codeExecution"];
+
 /** What the FINAL failure of a step does to the run: `'park'` → the §06 §6.3.5 exception gate. Default `'fail'`. */
 declare const WORKFLOW_ON_ERROR: readonly ["fail", "continue", "park"];
 
@@ -7251,9 +7375,18 @@ declare const WORKFLOW_SIDE_EFFECTS: readonly ["none", "external"];
 /** `waitForSignal.onTimeout`: default `'fail'`; `'continue'` ⇒ output `{received:false, timedOut:true}`. */
 declare const WORKFLOW_SIGNAL_ON_TIMEOUT: readonly ["fail", "continue"];
 
+/**
+ * Task class — what a step DOES, the composer's primary output for model choice (`AgentNode.taskClass`).
+ * The platform maps a task class to a model class (plan 6.3's default `classMap`; an org may override it),
+ * so a composer never has to reason about concrete models. Eight values to start.
+ */
+declare const WORKFLOW_TASK_CLASSES: readonly ["classify", "extract", "transform", "draft", "research", "reason", "code", "judge"];
+
 /** The only tier a node may DECLARE (`tier:'job'`, implied by `workspace`); the worker tier is the absence. */
 declare const WORKFLOW_TIERS: readonly ["job"];
 
+declare type WorkflowAgentEffort = (typeof WORKFLOW_AGENT_EFFORTS)[number];
+
 declare type WorkflowApprovalOnDeny = (typeof WORKFLOW_APPROVAL_ON_DENY)[number];
 
 export declare type WorkflowApproverSpec = 'creator' | 'org-admins' | {
@@ -7289,6 +7422,33 @@ export declare interface WorkflowArtefactMeta {
     };
 }
 
+/**
+ * [WMC-A6] research §H2 — the organization's `autonomy` block: the pre-consented ENVELOPE inside which a
+ * start that would have asked a person starts on its own instead (`ask → auto`).
+ *
+ * Every member is optional and absent means "the platform default applies". The CLI never fills one in and
+ * never computes one: what a run is actually admitted under is `effectiveWorkflowAutonomy(policy, agent)`'s
+ * answer, served back by `GET ?effective=true`, and the two are rendered side by side rather than merged
+ * here — a CLI that guessed at the resolution would be a second source of truth for a price nobody consents
+ * to twice.
+ *
+ * `enabled` is the one member whose absence is a VALUE rather than a platform default: absent ⇒ false. That
+ * is deliberate (research §H2 — autonomy is the file's single opt-in default), so `get` words it as such.
+ */
+declare interface WorkflowAutonomyEnvelopeDto {
+    /** Absent ⇒ FALSE. The org opt-in; `enabled: false` on the agent or the platform switch still wins above it. */
+    enabled?: boolean;
+    maxCredits?: number;
+    maxSteps?: number;
+    /** Sized against the ladder's duration BOUND, not a wall (research §H2) — which is why the default is a day. */
+    maxDurationSeconds?: number;
+    /** The model overlay's estimated actions — the fourth ladder dimension (research §B4). */
+    maxActions?: number;
+    maxRunsPerHour?: number;
+    /** The composition forms the envelope admits; `script` opts in. */
+    forms?: string[];
+}
+
 export declare interface WorkflowBusinessHours {
     tz: string;
     calendar?: 'mon-fri' | {
@@ -7376,6 +7536,43 @@ export declare interface WorkflowMergePolicy {
     onConflict: 'fail' | 'agent';
 }
 
+/**
+ * [WMC-E7] §6.4 — the consent card, as the SERVER builds it.
+ *
+ * The twin of E6's `WorkflowRunDetail.modelConsent`, narrowed to what the CLI reads. `card` is the
+ * already-rendered card and is printed verbatim; `plan` rides along for `--json` consumers and is never
+ * re-rendered here. There is deliberately no CLI-side card shape and no CLI-side renderer: the number a
+ * person consents to is worded once, by the projection, so the CLI, REST and the desktop cannot disagree.
+ *
+ * Absent on every run that assigned no model, which includes every run written before the change.
+ */
+declare interface WorkflowModelConsentView {
+    /** The structured plan behind the card. Passed through to `--json`; the CLI never renders from it. */
+    plan?: {
+        runName?: string;
+        stepCount?: number;
+        steps?: Array<{
+            index?: number;
+            stepId?: string;
+            kind?: string;
+            modelClass?: string;
+            pin?: string;
+            likelyModel?: string;
+            effort?: string;
+            reason?: string;
+        }>;
+        cost?: {
+            actionsLowerBound?: number;
+            agentModelActions?: number;
+            unit?: 'actions' | 'credits';
+        };
+    };
+    /** The rendered card, line by line. What `lua workflows start` prints, unchanged. */
+    card?: string[];
+}
+
+declare type WorkflowModelTrait = (typeof WORKFLOW_MODEL_TRAITS)[number];
+
 declare type WorkflowOnError = (typeof WORKFLOW_ON_ERROR)[number];
 
 /**
@@ -7446,6 +7643,28 @@ declare interface WorkflowRun {
      * else `none`. Absent on an older server.
      */
     nextAction?: 'cancel_again' | 'force' | 'none' | 'raise_budget' | 'top_up';
+    /**
+     * [WMC-A6] The START's consent stamp, as A5 projects it (research §H2 "the consent stamp").
+     *
+     * `via` is the discriminator and it is what the CLI renders on: `'human'` is a person who cleared the
+     * consent gate, `'autonomy'` is A3's pre-consented envelope (`approvedBy: 'system:policy'`). Absent on
+     * every run started before the stamp existed, and on every server that does not project it — which is why
+     * `via` is optional beside a `consent` that may be present with nothing else the CLI reads (D28: a run
+     * with a stamp but no `via` prints no consent line rather than guessing at one).
+     *
+     * The union is left open (`| string`) on purpose, §6.9: a NEWER server may stamp a `via` this CLI has
+     * never heard of, and an unknown member must fall through to "print nothing", never to a crash or to a
+     * line worded as if it were one of the two known ones.
+     */
+    consent?: {
+        approvedBy?: string;
+        at?: number;
+        /** The HITL approval link a human decision was recorded against. Optional since A2 — an autonomous start has none. */
+        approvalLinkId?: string;
+        via?: 'human' | 'autonomy' | string;
+        /** The resolved envelope an `autonomy` start was admitted under — the numbers the line quotes. */
+        envelope?: WorkflowAutonomyEnvelopeDto;
+    };
     /**
      * The pending / audited cancel request (`runCancelView`): who asked and when; `wall` when it was the run wall's
      * own (LUA-686); LUA-704: `forcedBy` / `forcedAt` / `forceReason` on a forced terminal (`abandoned`, or
@@ -7502,6 +7721,20 @@ declare interface WorkflowRun {
         steps?: number;
         inputTokens?: number;
         outputTokens?: number;
+        /**
+         * [WMC-E7] §6.6 — the run's spend split by the model that actually served each call, present only once
+         * the server projects it (a run that never reached an agent step, and every older server, omit it).
+         * `lua workflows status` prints the roll-up when it is there and says nothing when it is not.
+         */
+        byModel?: WorkflowRunModelUsageRow[];
+        /**
+         * [WJB-B5] (BAC-671) — the run's token components, summed by the server from the usage rows its charges
+         * were written from (per-call `workflow:job` rows on the Job tier, `llm:inference` rows off it).
+         * `inputTokens` is the UNCACHED prompt; the two cache figures are read and write. Present only once the
+         * server projects it (a metered run on a server that has this change) — the CLI prints nothing otherwise,
+         * and never adds the members together: cache reads are a SUBSET of input on OpenAI-compatible providers.
+         */
+        tokens?: WorkflowRunTokensDto;
     };
     /**
      * R4: the run's caps and settled spend. `maxCredits` and `remaining` are both absent on an uncapped run (`0` = unset);
@@ -7519,6 +7752,12 @@ declare interface WorkflowRun {
         };
         reserved?: number;
         remaining?: number;
+        /**
+         * [WJB-B5] (BAC-677): the run went PAST its cap and finished anyway — the crossing step was terminal for
+         * the run, so it completed rather than parking for a raise nobody could act on. `true` or ABSENT on the
+         * wire, never `false`; the CLI prints it and never derives it from `spent > maxCredits`.
+         */
+        exceeded?: boolean;
     };
     createdAt: string;
     startedAt?: string;
@@ -7526,9 +7765,41 @@ declare interface WorkflowRun {
     updatedAt: string;
 }
 
+/**
+ * [WMC-E7] §6.6 — one row of `usage.byModel`: what a model was actually asked to do on this run and what it
+ * cost. `model` is the SERVED code (canonicalised from the meter), which is not necessarily what the step
+ * requested — a same-class hop is recorded here under the model that answered.
+ */
+declare interface WorkflowRunModelUsageRow {
+    /** The served model code, `provider/model`. */
+    model: string;
+    /** The model class it served for, when the step asked for one. */
+    class?: string;
+    /** Model calls served by this model on this run. */
+    calls?: number;
+    /** Priced actions on a seat plan. */
+    actions?: number;
+    /** Credits on the legacy plan. */
+    credits?: number;
+    /** Steps whose request this model answered because an earlier leg failed. */
+    fallbacks?: number;
+}
+
 /** §02 §2.4 run statuses (one union across every section). */
 declare type WorkflowRunStatus = 'queued' | 'running' | 'cancellation_requested' | 'gated' | 'suspended' | 'waiting' | 'completed' | 'failed' | 'cancelled' | 'abandoned' | 'timed_out';
 
+/**
+ * [WJB-B5] (BAC-671) — the four token figures the server sums per run and per step (`WorkflowRunTokens` in
+ * `@lua/shared-types`). Every member optional: the CLI is a reader of whatever the server sends, and a figure
+ * a server does not project must print as nothing rather than as a zero the run never reported.
+ */
+declare interface WorkflowRunTokensDto {
+    inputTokens?: number;
+    cacheReadTokens?: number;
+    cacheCreationTokens?: number;
+    outputTokens?: number;
+}
+
 export declare type WorkflowRunTrigger = 'chat' | 'sdk' | 'api' | 'schedule' | 'webhook' | 'template' | 'workflow' | 'device';
 
 /**
@@ -7868,6 +8139,8 @@ export declare type WorkflowSuspendTimeoutChainMember = 'deny' | 'cancel-run' |
     timeoutHours: number;
 };
 
+declare type WorkflowTaskClass = (typeof WORKFLOW_TASK_CLASSES)[number];
+
 declare type WorkflowTier = (typeof WORKFLOW_TIERS)[number];
 
 export declare type WorkflowWorkspaceBackend = 'ebs' | 'efs' | 's3';