@wildo-ai/saas-models 1.1.4 → 1.1.6

package/dist/esm/requests/websocket.shared.schemas.js

@@ -1,13 +1,16 @@
 import { z } from 'zod';
 import { DataMode } from '../resources/resources-config.shared.schemas.js';
-import { FrontendDisplayHintsSchema } from '../notifications/notifications.shared.schemas.js';
+import { WorkUnitRefSchema } from '../resources/work-unit.shared.schemas.js';
+import { FrontendDisplayHintsSchema, UserNotificationTargetSchema } from '../notifications/notifications.shared.schemas.js';
 import { ValueMomentRole, ValueMomentScope } from '../config/analytics-value-moments.shared.schemas.js';
 import { OnboardingStatus } from '../config/frontend/onboarding.shared.schemas.js';
 import { GuidanceFlowScope, GuidanceRenderMode } from '../guidance/guidance-flow.shared.schemas.js';
-import { ProgressionScope, MilestoneRewardType } from '../guidance/milestone-definition.shared.schemas.js';
+import { CelebrationDisplayMode } from '../notifications/notifications.shared.schemas.js';
+import { MilestoneCelebrationLevel, ProgressionScope, MilestoneRewardType } from '../guidance/milestone-definition.shared.schemas.js';
 import { LifecycleStage, LifecycleScope } from '../guidance/lifecycle-state.shared.schemas.js';
 import { ResourceOperationVariantType } from '../resources/resources.shared.schemas.js';
 import { ResourcePrimaryScope } from '../resources/resources.shared.schemas.js';
+import { AgentWorkReasonCodeSchema, HumanDecision_RouteKind } from '../flows-actors/human-decision.shared.schemas.js';
 // =====================================================
 // WebSocket Event Types (Core Framework Events)
 // =====================================================
@@ -39,6 +42,15 @@ export var CoreWebSocketEvent;
     CoreWebSocketEvent["RESOURCE_UNLOCKED"] = "resource:unlocked";
     CoreWebSocketEvent["RESOURCE_CUSTOM"] = "resource:custom";
     CoreWebSocketEvent["RESOURCE_CUSTOM_ERROR"] = "resource:custom:error";
+    /**
+     * How far a BACKGROUND BULK run has got, sent to the person who started it (server → client).
+     *
+     * Addressed to the USER rather than to a resource room: the run spans many rows, so no row's room
+     * is the right place, and the job's own row is an internal record most people cannot read. The
+     * rows themselves still broadcast their ordinary sync events as they change, so the listing
+     * updates itself; this event is what lets the surface say how much is left (#1461).
+     */
+    CoreWebSocketEvent["BULK_JOB_PROGRESS"] = "bulk-job:progress";
     // === FlowsActors Events (bidirectional) ===
     CoreWebSocketEvent["FLOWS_ACTORS_START"] = "flows-actors:start";
     CoreWebSocketEvent["FLOWS_ACTORS_STARTED"] = "flows-actors:started";
@@ -48,6 +60,12 @@ export var CoreWebSocketEvent;
     CoreWebSocketEvent["FLOWS_ACTORS_STATUS_UPDATE"] = "flows-actors:status-update";
     CoreWebSocketEvent["FLOWS_ACTORS_COMPLETED"] = "flows-actors:completed";
     CoreWebSocketEvent["FLOWS_ACTORS_ERROR"] = "flows-actors:error";
+    /**
+     * A pending decision was routed to this person — assigned, reassigned or escalated to them (#1594 D6).
+     * Pushed to that person's own room only: broadcasting to the organization would tell everyone in it that
+     * a decision exists. It carries the decision id and nothing else; the inbox reads the card.
+     */
+    CoreWebSocketEvent["FLOWS_ACTORS_DECISION_ROUTED"] = "flows-actors:decision-routed";
     // === Billing Events (server → client, invalidation triggers) ===
     CoreWebSocketEvent["BILLING_STATUS_CHANGED"] = "billing:status_changed";
     CoreWebSocketEvent["BILLING_SUBSCRIPTION_UPDATED"] = "billing:subscription_updated";
@@ -178,6 +196,11 @@ export const WS_ResourceNotificationPayloadSchema = z.object({
     variantKey: z.string().optional(),
     // Context for scoped matching
     contextResourceIdentifiers: ContextResourceIdentifiersSchema.optional(),
+    /** Server-authored delivery policy. Keep the frame for data refresh even when its message is suppressed. */
+    deliveryPolicy: z.object({
+        target: UserNotificationTargetSchema,
+        alwaysDeliver: z.boolean(),
+    }),
     // Notification data
     action: ResourceActionSchema,
     /** Explicit notification level (overrides action-based default) */
@@ -280,12 +303,25 @@ export const WS_MilestoneAchievedPayloadSchema = z.object({
         type: z.enum(MilestoneRewardType),
         featureRef: z.string().optional(),
         guidanceFlowRef: z.string().optional(),
-        celebrationLevel: z.enum(['low', 'medium', 'high']).optional(),
+        /*
+         * Typed against the named vocabulary rather than the inline union it was — the same correction
+         * the lifecycle fields below record, for the same reason: this payload is what the frontend
+         * derives a presentation from, and an untyped copy of a vocabulary drifts from it in silence.
+         */
+        celebrationLevel: z.enum(MilestoneCelebrationLevel).optional(),
+        /** An explicit presentation, overriding whatever the level would have chosen. */
+        celebrationMode: z.enum(CelebrationDisplayMode).optional(),
     }),
     /** Phase 5 integration: lifecycle transition triggered by this milestone */
+    /**
+     * Typed against the named vocabulary, like `WS_LifecycleStageChangedPayloadSchema` a few
+     * declarations below — these two were `z.string()` while their neighbour used
+     * `z.enum(LifecycleStage)` for the same fact. See `MilestoneLifecycleTransition` for what the
+     * untyped form cost.
+     */
     lifecycleTransition: z.object({
-        from: z.string(),
-        to: z.string(),
+        from: z.enum(LifecycleStage),
+        to: z.enum(LifecycleStage),
     }).optional(),
     /** Timestamp of achievement */
     achievedAt: WebSocketTimestampSchema,
@@ -465,6 +501,57 @@ export const WS_ResourceCustomEventPayloadSchema = z.object({
     // DataMode values match directly: DataMode.RAW === 'raw', etc.
     dataMode: z.enum(DataMode).optional(),
 });
+/**
+ * How far a background bulk run has got.
+ *
+ * `attemptedCount` is what the run was GIVEN, and it never changes during the run — it is the
+ * denominator a progress bar needs. `processedCount` counts rows the run has finished with, whether
+ * they succeeded or were refused, so `processed / attempted` is honest progress rather than a
+ * success rate; `failedCount` is how many of those were refusals.
+ *
+ * `finished` is explicit rather than inferred from `processedCount === attemptedCount`: a run that
+ * ends early — a worker lost, a job that failed outright — would otherwise leave a bar sitting at
+ * 94% forever with nothing to say it had stopped.
+ */
+export const WS_BulkJobProgressPayloadSchema = z.object({
+    jobId: z.string().min(1),
+    resourceType: z.string().min(1),
+    operationIdentifier: z.string().min(1),
+    attemptedCount: z.number().int().min(0),
+    processedCount: z.number().int().min(0),
+    failedCount: z.number().int().min(0),
+    finished: z.boolean(),
+    /**
+     * WHICH rows were refused, and why — sent on the FINAL event only, and capped at
+     * {@link BULK_JOB_REPORTED_FAILURE_LIMIT}.
+     *
+     * A count tells a person something went wrong; it does not tell them what to do. The refusal's
+     * REFERENCE is what does, because it is the thing a locale turns into words and a client branches
+     * on — so the reasons arrive as references and the surface says them in the reader's language.
+     *
+     * Capped because a run may be given thousands of rows and a socket message is not a report: past
+     * the cap, `failedCount` remains exact while the list is a sample. Every refusal is in the job
+     * result regardless, which is the durable record.
+     *
+     * Sent only when finished, deliberately: a list that grew with each progress event would make the
+     * surface re-render its whole failure panel on every row, and a person cannot read a list that is
+     * still moving.
+     */
+    failures: z.array(z.object({
+        resourceId: z.string().min(1),
+        customMessageReference: z.string().optional(),
+        errorType: z.string().optional(),
+    })).optional(),
+    timestamp: WebSocketOptionalTimestampSchema,
+});
+/**
+ * How many individual refusals a finished bulk run reports over the wire.
+ *
+ * 50 is what a person can actually read in a panel before it stops being a summary; the exact count
+ * is always `failedCount`, and the complete list is in the job result. A larger number would make
+ * the message bigger without making it more useful.
+ */
+export const BULK_JOB_REPORTED_FAILURE_LIMIT = 50;
 /** Error response for custom events */
 export const WS_ResourceCustomErrorPayloadSchema = z.object({
     eventName: z.string(),
@@ -498,6 +585,12 @@ export const WS_FlowsActorsStartPayloadSchema = z.object({
     executionId: z.string().optional(), // Server generates if not provided
     contextResourceIdentifiers: ContextResourceIdentifiersSchema,
     initialInput: z.record(z.string(), z.unknown()).optional(),
+    /**
+     * The CASE this conversation works on (#1598): a row of a resource declared `workUnit: true`. Admitted only if
+     * the connected user can READ it; its model calls, and its resumes', are then attributed to it. Kept for the
+     * thread's life: a later turn of the same thread keeps the case it was opened on.
+     */
+    caseRef: WorkUnitRefSchema.optional(),
 });
 /** Confirmation of FlowActorSystem start (server → client) */
 export const WS_FlowsActorsStartedPayloadSchema = z.object({
@@ -533,9 +626,9 @@ export const WS_FlowsActorsMessagePayloadSchema = z.object({
  * It is a named schema rather than a shape both ends open-code, because the `data` bag is
  * `z.record(z.string(), z.unknown())` — so nothing typed the announcement, and the browser
  * listened on `FLOWS_ACTORS_APPROVAL_REQUEST` instead, an event **nothing has ever emitted**.
- * The result: `pendingApproval` was never set, no shipped screen could observe a paused turn,
- * and `resourceServerInstanceRef` — which the server sends precisely so a decision can echo it —
- * was discarded, leaving an approval raised on a NAMED agent instance unresumable (#528).
+ * The result: `pendingApproval` was never set and no shipped screen could observe a paused turn (#528).
+ * Since #1594 the one thing a client echoes back is `decisionRef`; the agent instance, which the answer
+ * once had to carry, is read off the row.
  *
  * Producer: `persistApprovalSuspension`. Consumer: `FlowsActorsContext`.
  */
@@ -543,6 +636,17 @@ export const WS_FlowsActorsApprovalAnnouncementDataSchema = z.object({
     /** Discriminator. The `data` bag carries other kinds of payload on other messages. */
     approvalRequested: z.literal(true),
     approvalId: z.string(),
+    /**
+     * The decision's one id (#1594) — what every answer, reassignment and audit row names, and the one
+     * value a client echoes back. Absent only on a turn paused before decisions were routed.
+     */
+    decisionRef: z.string().optional(),
+    /**
+     * Who answers it (#1594). OWNER: the person whose conversation this is — the page showing it may answer.
+     * ASSIGNEE / ROLE: a reviewer answers from their inbox, and the requester may not (separation of duties),
+     * so a page showing the conversation shows the question as waiting for review, with nothing to press.
+     */
+    routeKind: z.enum(HumanDecision_RouteKind).optional(),
     /** The tool call being gated. */
     toolName: z.string(),
     /**
@@ -551,15 +655,58 @@ export const WS_FlowsActorsApprovalAnnouncementDataSchema = z.object({
      * these gets their schema from the tool declaration.
      */
     toolArgs: z.record(z.string(), z.unknown()).optional(),
+    /**
+     * The gated tool's INPUT SCHEMA, as the `SerializableZodSchema` descriptor `serializeZodSchema`
+     * (`@wildo-ai/zod-decorators`) produces from the tool's own `inputSchema` (#587).
+     *
+     * It exists so an approver who edits the call is shown the tool's fields — which arguments exist,
+     * which are required, which are enumerations — instead of a JSON blob. It is a RENDERING HINT and
+     * never the control: the server re-validates `modifiedToolArgs` against the tool's live schema and
+     * refuses a violation whatever the browser believed, and the descriptor drops refinements (min/max,
+     * patterns) by construction.
+     *
+     * Absent when the tool cannot be resolved from the paused turn. A client that finds a shape it
+     * cannot render as fields falls back to the raw editor rather than to no editor.
+     *
+     * Loose on the wire for the same reason as `toolArgs`: the shape belongs to the descriptor type,
+     * which this transport does not re-validate.
+     */
+    toolInputSchema: z.record(z.string(), z.unknown()).optional(),
     requestedAt: z.string(),
     /** When the pause lapses. Written since #465; it reaches a client only through this block. */
     expiresAt: z.string().optional(),
     /**
-     * The isolation axis the DECISION must carry back, sent unconditionally — including when it is
-     * the default sentinel — so a client echoes one field rather than branching on whether the value
-     * is meaningful.
+     * The reason codes the answer may carry (#1921) — the application's declared vocabulary
+     * (`agentWorkReview.reasonCodes`), offered by the approval card when the approver changes or rejects the call.
+     * Absent when the application declares none. A tool approval is always a review of agent work, so it always
+     * carries the vocabulary when there is one.
      */
-    resourceServerInstanceRef: z.string(),
+    reasonCodes: z.array(AgentWorkReasonCodeSchema).optional(),
+});
+/**
+ * A TOOL-STATUS announcement, carried in the `data` bag of a `FLOWS_ACTORS_MESSAGE` of type
+ * `PROGRESS` — one per tool CALL while an assistant turn is working.
+ *
+ * It carries FACTS, never words. The server used to send `content: "Looking up your todos…"`,
+ * composed from the tool name by a humanizer: English produced by code, untranslatable, and wrong
+ * for any resource whose identifier is not also its name (#1283,
+ * `.claude/rules/display-text-comes-from-i18n.md`). The person's words are now resolved in the
+ * browser from the label tree — the component's status labels, and the resource's own authored
+ * title — and `content` carries the tool name verbatim, a value rather than a sentence.
+ *
+ * Producer: `ConversationalExecutionBackendService` (`onToolEvent`). Consumer: the flows-actors
+ * view's status line. The A2A plane ignores tool-status frames (they carry no `messageId`).
+ */
+export const WS_FlowsActorsToolStatusDataSchema = z.object({
+    /** Discriminator. The `data` bag carries other kinds of payload on other messages. */
+    toolStatus: z.literal(true),
+    /** The tool being called, as the agent runtime names it. */
+    tool: z.string(),
+    /**
+     * The resource the tool READS, when it is one of the engine's resource-read tools. Lets the
+     * status name the resource through its authored title; absent for every other tool.
+     */
+    readsResourceType: z.string().optional(),
 });
 /** Human approval request (server → client) */
 export const WS_FlowsActorsApprovalRequestPayloadSchema = z.object({
@@ -576,20 +723,19 @@ export const WS_FlowsActorsApprovalResponsePayloadSchema = z.object({
     systemRef: z.string(),
     executionId: z.string(),
     approvalId: z.string(),
-    approved: z.boolean(),
-    comment: z.string().optional(),
     /**
-     * The agent instance the paused conversation belongs to — ECHOED from the approval REQUEST.
+     * The decision being answered (#1594), echoed from the announcement. When present it is the ONLY
+     * key the server addresses the decision by: everything else — who owns the conversation, its machine
+     * credential and its agent instance — is read from the row. When absent the server resolves it from
+     * `executionId` + `approvalId`.
      *
-     * A conversation is isolated by owner FK, machine credential AND agent instance, so a resume that
-     * omits this axis is filtered against the DEFAULT instance sentinel. An approval raised on a NAMED
-     * A2A agent instance therefore matched no row and the decision was dropped silently — logged as
-     * "no pending approval matches" and returned, with the turn left paused forever.
-     *
-     * Optional because the in-app conversational plane runs on the default instance and has nothing to
-     * echo; absent means default, which is the value those executions were written with.
+     * The agent instance used to be echoed here as well, because the answer filtered on it and a missing
+     * value matched the default instance and silently dropped a named-instance decision (#528). An answer
+     * now reads the instance off the row, so an echoed one could only ever disagree with it; the field is gone.
      */
-    resourceServerInstanceRef: z.string().optional(),
+    decisionRef: z.string().optional(),
+    approved: z.boolean(),
+    comment: z.string().optional(),
     /**
      * APPROVE-WITH-MODIFICATIONS (#566): the arguments the approver authored, replacing the ones the
      * model proposed. Meaningful only when `approved` is true — a denial resumes so the model can
@@ -607,6 +753,15 @@ export const WS_FlowsActorsApprovalResponsePayloadSchema = z.object({
      * server's, against that tool — the browser's is a convenience, never the control.
      */
     modifiedToolArgs: z.record(z.string(), z.unknown()).optional(),
+    /**
+     * A reason code of the application's declared vocabulary (`agentWorkReview.reasonCodes`, #1599), recorded on the
+     * agent-work decision beside the outcome. An undeclared code is refused and the decision stands.
+     */
+    reasonCode: AgentWorkReasonCodeSchema.optional(),
+});
+/** A decision was routed to the recipient (server → client). The id only; the inbox reads the card. */
+export const WS_FlowsActorsDecisionRoutedPayloadSchema = z.object({
+    decisionRef: z.string(),
 });
 /** Status update during execution (server → client) */
 export const WS_FlowsActorsStatusUpdatePayloadSchema = z.object({
@@ -626,12 +781,121 @@ export const WS_FlowsActorsCompletedPayloadSchema = z.object({
     duration: z.number().optional(), // in ms
 });
 /** Execution error (server → client) */
+/**
+ * Why a flows-actors request reported an error on `FLOWS_ACTORS_ERROR` — from the socket boundary
+ * (an unauthenticated or malformed request) or from the conversational turn itself.
+ *
+ * One named vocabulary, so a client that must BRANCH on a code — the approval surface keeps a refused
+ * modification on screen rather than dropping it (#587) — compares against a member instead of a
+ * string it copied from the producer.
+ */
+export var FlowsActors_ExecutionErrorCode;
+(function (FlowsActors_ExecutionErrorCode) {
+    /** The socket carries no authenticated user, so a conversation cannot be started. */
+    FlowsActors_ExecutionErrorCode["UNAUTHENTICATED"] = "UNAUTHENTICATED";
+    /** The inbound flows-actors payload failed validation. */
+    FlowsActors_ExecutionErrorCode["INVALID_PAYLOAD"] = "INVALID_PAYLOAD";
+    /** The conversation has no resolvable owner scope. */
+    FlowsActors_ExecutionErrorCode["NO_OWNER"] = "NO_OWNER";
+    /** The system has no agentic actor bound to an agent to converse with. */
+    FlowsActors_ExecutionErrorCode["NO_CHAT_ACTOR"] = "NO_CHAT_ACTOR";
+    /** No user message was provided to start the conversation. */
+    FlowsActors_ExecutionErrorCode["EMPTY_INPUT"] = "EMPTY_INPUT";
+    /** The execution record could not be opened. */
+    FlowsActors_ExecutionErrorCode["PERSIST_FAILED"] = "PERSIST_FAILED";
+    /** The assistant failed to produce a response. */
+    FlowsActors_ExecutionErrorCode["AGENT_FAILED"] = "AGENT_FAILED";
+    /**
+     * The approver's edited tool arguments were refused. RECOVERABLE: the approval is still pending and
+     * can be answered again, so a surface must keep it — this is the one code a client branches on.
+     */
+    FlowsActors_ExecutionErrorCode["APPROVAL_MODIFICATION_REJECTED"] = "APPROVAL_MODIFICATION_REJECTED";
+    /**
+     * The answer's reason code is not one the application declares (#1599). RECOVERABLE, like a refused edit: the
+     * approval is still pending and can be answered again, with a declared code or none.
+     */
+    FlowsActors_ExecutionErrorCode["APPROVAL_REASON_CODE_REJECTED"] = "APPROVAL_REASON_CODE_REJECTED";
+    /** The system is a FLOW system, and conversational execution of flows is not implemented. */
+    FlowsActors_ExecutionErrorCode["FLOW_CONVERSATION_NOT_IMPLEMENTED"] = "FLOW_CONVERSATION_NOT_IMPLEMENTED";
+    /** No actor system is registered under the requested ref. */
+    FlowsActors_ExecutionErrorCode["SYSTEM_NOT_FOUND"] = "SYSTEM_NOT_FOUND";
+    /**
+     * The application requires consent purposes the person has not granted
+     * (`compliance.serviceConsentRequirement.requiredPurposes`), so no turn is started. Terminal for this turn,
+     * and cured by the person recording their consent in their own preferences — the same refusal every other
+     * user-initiated surface answers (#534).
+     */
+    FlowsActors_ExecutionErrorCode["SERVICE_CONSENT_REQUIRED"] = "SERVICE_CONSENT_REQUIRED";
+    /**
+     * CLIENT-DETECTED — no server emits it. The socket that started this turn dropped before the turn
+     * ended. A turn's events are emitted to the socket that started it, so after a drop none of them can
+     * arrive, whether the server went away (a restart) or only the connection did; without this the turn
+     * stays `STARTING` / `RUNNING` forever and the composer never comes back (#1464, 2026-09-24).
+     * RECOVERABLE: when the server survived, the turn still completes and is persisted, and the thread's
+     * own history carries the reply.
+     */
+    FlowsActors_ExecutionErrorCode["CONNECTION_LOST"] = "CONNECTION_LOST";
+    /**
+     * The person cannot answer this decision (#1594): it does not exist, it was already settled, or the
+     * route does not admit them. One code for all three on purpose — telling someone that a decision
+     * EXISTS but is not theirs is itself a disclosure. The refusal is recorded on the audit trail.
+     */
+    FlowsActors_ExecutionErrorCode["DECISION_NOT_ANSWERABLE"] = "DECISION_NOT_ANSWERABLE";
+    /**
+     * The decision was answered, but the authority the work was raised under no longer holds (a revoked
+     * membership, a suspended user, a revoked delegation). The approved work did NOT run, and the turn is
+     * over; the requester must ask again (#1594).
+     */
+    FlowsActors_ExecutionErrorCode["DECISION_REQUESTER_AUTHORITY_LAPSED"] = "DECISION_REQUESTER_AUTHORITY_LAPSED";
+})(FlowsActors_ExecutionErrorCode || (FlowsActors_ExecutionErrorCode = {}));
+/**
+ * Why the server refused an approver's EDIT to a tool call's arguments (#1186).
+ *
+ * The refusal used to travel as English prose in `errorMessage`, which the approval card printed after a
+ * localized prefix — untranslatable, and the one place on the card a person read a server sentence. Each
+ * member is a different diagnosis with a different remedy, so the card renders a label per member; the
+ * prose stays in `errorMessage` for logs.
+ */
+export var FlowsActors_ApprovalModificationRefusalReason;
+(function (FlowsActors_ApprovalModificationRefusalReason) {
+    /** The agent that raised the approval is no longer registered, so nothing can check the arguments. */
+    FlowsActors_ApprovalModificationRefusalReason["AGENT_NOT_REGISTERED"] = "agent_not_registered";
+    /** The agent no longer declares the tool the approval names. */
+    FlowsActors_ApprovalModificationRefusalReason["TOOL_NOT_DECLARED"] = "tool_not_declared";
+    /** The tool no longer requires approval, so the pending decision is stale. */
+    FlowsActors_ApprovalModificationRefusalReason["TOOL_NO_LONGER_GATED"] = "tool_no_longer_gated";
+    /** The edited arguments fail the tool's own input schema; `argumentPaths` names the offending ones. */
+    FlowsActors_ApprovalModificationRefusalReason["ARGUMENTS_INVALID"] = "arguments_invalid";
+    /** The approval-signing key is not configured, so a modified call cannot be re-bound. */
+    FlowsActors_ApprovalModificationRefusalReason["SIGNING_KEY_NOT_CONFIGURED"] = "signing_key_not_configured";
+    /** The paused turn's resume payload does not contain the call the approval names. */
+    FlowsActors_ApprovalModificationRefusalReason["CALL_NOT_REWRITABLE"] = "call_not_rewritable";
+})(FlowsActors_ApprovalModificationRefusalReason || (FlowsActors_ApprovalModificationRefusalReason = {}));
+/**
+ * The structured half of an `APPROVAL_MODIFICATION_REJECTED` error: what the card needs to say, in labels.
+ * `reason` is a {@link FlowsActors_ApprovalModificationRefusalReason} member, kept a STRING on the wire for
+ * the same reason `errorCode` is — a client older than a new reason must still parse the payload.
+ */
+export const WS_FlowsActorsApprovalModificationRefusalSchema = z.object({
+    reason: z.string(),
+    /** The tool the approval names, for the reasons that mention it. */
+    toolName: z.string().optional(),
+    /** The argument paths the tool's schema refused — names only, never the values the approver typed. */
+    argumentPaths: z.array(z.string()).optional(),
+});
 export const WS_FlowsActorsErrorPayloadSchema = z.object({
     systemRef: z.string(),
     executionId: z.string(),
+    /**
+     * A {@link FlowsActors_ExecutionErrorCode} member. Kept a STRING on the wire so a client built
+     * before a code was added still parses the payload; producers emit the enum and consumers compare
+     * against it.
+     */
     errorCode: z.string(),
     errorMessage: z.string(),
     recoverable: z.boolean().default(false),
+    /** Present on `APPROVAL_MODIFICATION_REJECTED`: the refusal as labels can say it (#1186). */
+    approvalModificationRefusal: WS_FlowsActorsApprovalModificationRefusalSchema.optional(),
 });
 // =====================================================
 // System Payloads
@@ -646,6 +910,27 @@ export const WS_OrganizationSwitchPayloadSchema = z.object({
     organizationId: z.string(),
     previousOrganizationId: z.string().optional(),
 });
+/**
+ * The codes a `SYSTEM_ERROR` carries — what a client BRANCHES on, so each one names the client's remedy.
+ *
+ * `code` on the payload stays a plain string on the wire so a client decoding a newer server's code does not fail to
+ * parse the whole event; this enum is the vocabulary both sides compare against.
+ */
+export var WebSocketSystemErrorCode;
+(function (WebSocketSystemErrorCode) {
+    /** A live AUTH_REFRESH was rejected. The client renews its token and refreshes again. */
+    WebSocketSystemErrorCode["AUTH_REFRESH_FAILED"] = "AUTH_REFRESH_FAILED";
+    /**
+     * An ORGANIZATION_SWITCH was refused: the connection stays in its PREVIOUS organization — its rooms, its subscription
+     * checks. The client re-handshakes with the organization it intended (#1597), which re-derives everything server-side
+     * with the latest token. The handshake applies its own rules: a revoked session or an expired token fails it; an
+     * organization the user holds no entry in is simply not honoured (it falls back to the user's sole membership, or
+     * none), so the connection never gains that organization's rooms.
+     */
+    WebSocketSystemErrorCode["ORGANIZATION_SWITCH_FORBIDDEN"] = "ORGANIZATION_SWITCH_FORBIDDEN";
+    /** Too many real-time requests. The client slows down; nothing is retried automatically. */
+    WebSocketSystemErrorCode["RATE_LIMIT_EXCEEDED"] = "RATE_LIMIT_EXCEEDED";
+})(WebSocketSystemErrorCode || (WebSocketSystemErrorCode = {}));
 export const WS_SystemErrorPayloadSchema = z.object({
     code: z.string(),
     message: z.string(),
@@ -684,6 +969,7 @@ export const WebSocketEventSchemas = {
     [CoreWebSocketEvent.RESOURCE_LOCKED]: WS_ResourceRoomStatePayloadSchema,
     [CoreWebSocketEvent.RESOURCE_UNLOCKED]: WS_ResourceRoomStatePayloadSchema,
     [CoreWebSocketEvent.RESOURCE_CUSTOM]: WS_ResourceCustomEventPayloadSchema,
+    [CoreWebSocketEvent.BULK_JOB_PROGRESS]: WS_BulkJobProgressPayloadSchema,
     [CoreWebSocketEvent.RESOURCE_CUSTOM_ERROR]: WS_ResourceCustomErrorPayloadSchema,
     // FlowsActors
     [CoreWebSocketEvent.FLOWS_ACTORS_START]: WS_FlowsActorsStartPayloadSchema,
@@ -694,6 +980,7 @@ export const WebSocketEventSchemas = {
     [CoreWebSocketEvent.FLOWS_ACTORS_STATUS_UPDATE]: WS_FlowsActorsStatusUpdatePayloadSchema,
     [CoreWebSocketEvent.FLOWS_ACTORS_COMPLETED]: WS_FlowsActorsCompletedPayloadSchema,
     [CoreWebSocketEvent.FLOWS_ACTORS_ERROR]: WS_FlowsActorsErrorPayloadSchema,
+    [CoreWebSocketEvent.FLOWS_ACTORS_DECISION_ROUTED]: WS_FlowsActorsDecisionRoutedPayloadSchema,
     // Billing
     [CoreWebSocketEvent.BILLING_STATUS_CHANGED]: WS_BillingEventPayloadSchema,
     [CoreWebSocketEvent.BILLING_SUBSCRIPTION_UPDATED]: WS_BillingEventPayloadSchema,