@wildo-ai/saas-models 1.1.5 → 1.1.7

package/dist/esm/flows-actors/flows-actors-execution.shared.schemas.d.ts

@@ -31,7 +31,9 @@
  *   log mirrors (`WS_FlowsActorsMessagePayloadSchema`)
  */
 import { z } from 'zod';
-import { FlowsActors_Status } from './flows-actors.commons.shared.schemas';
+import { FlowsActors_InitiationKind, FlowsActors_Status } from './flows-actors.commons.shared.schemas';
+import { HumanDecision_Outcome, HumanDecision_RequesterKind, HumanDecision_RouteKind, ReviewClockBasis } from './human-decision.shared.schemas';
+import { AutonomousPrincipalSource, AutonomousTurnTrigger } from './autonomous-agents.shared.schemas';
 import { FlowActorSystem_Kind } from './flows-actors.system.shared.schemas';
 import { type PolymorphicVariantDefinition } from '../resources/utils/resource-polymorphism.schemas';
 /**
@@ -93,9 +95,10 @@ export type FlowActorExecution_PausedApproval = z.infer<typeof FlowActorExecutio
  * against a conversation, a world and an intent that have all moved on, and "do you approve this?"
  * with no memory of the question is a prompt people click through.
  *
- * A framework default rather than an operator knob, for now. If an application ever needs its own,
- * the knob goes beside the consent lifetime in the auth config — but nobody has asked, and a
- * timeout that every application authors identically is a default wearing a config field.
+ * The DEFAULT, not a fixed rule: since #1628 a gate may declare its own lapse
+ * (`humanApproval.deadlines.lapseAfter`, always elapsed time), and this is what a gate declaring none
+ * gets. The gate is the right owner — how long "do you approve deleting this customer?" stays
+ * meaningful depends on the action, not on the application.
  */
 export declare const FLOW_ACTOR_APPROVAL_DEFAULT_TIMEOUT_MS: number;
 /** Serialize paused-approval state for the scalar `pausedApproval` string column. */
@@ -158,6 +161,52 @@ export declare const FlowActorExecutionBaseSchema: z.ZodObject<{
         createdAt: z.ZodDefault<z.ZodDate>;
     }, z.core.$strip>>>>>;
     pausedApproval: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodOptional<z.ZodNullable<z.ZodString>>>>;
+    initiationKind: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof FlowsActors_InitiationKind>>>>>;
+    autonomousAgentRef: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    autonomousTrigger: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof AutonomousTurnTrigger>>>>;
+    autonomousPrincipalSource: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof AutonomousPrincipalSource>>>>;
+    caseRef: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodObject<{
+        resourceType: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strict>>>;
+    autonomousActiveSlotKey: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    pendingDecisionRef: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
+    pendingDecisionRouteKind: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof HumanDecision_RouteKind>>>>>>;
+    pendingDecisionEligibleRole: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
+    pendingDecisionOrganizationId: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
+    pendingDecisionOrganizationUnitId: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    pendingDecisionAssigneeUserId: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
+    pendingDecisionClaimedAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionRequesterKind: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof HumanDecision_RequesterKind>>>>>;
+    pendingDecisionRequesterRef: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    pendingDecisionRequesterClientId: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    pendingDecisionRequestedAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionExpiresAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>>;
+    pendingDecisionRouteVersion: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNumber>>>;
+    pendingDecisionClaimDeadlineAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionClaimWarningAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionClaimClockBasis: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof ReviewClockBasis>>>>>;
+    pendingDecisionDecisionDeadlineAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionDecisionWarningAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionDecisionClockBasis: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof ReviewClockBasis>>>>>;
+    pendingDecisionNextDueAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>>;
+    pendingDecisionClockPausedAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionClockPauseStateRef: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    pendingDecisionClockPausedMs: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNumber>>>;
+    pendingDecisionClaimWarningFiredAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionClaimMissedFiredAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionDecisionWarningFiredAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionDecisionMissedFiredAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    lastResolvedDecisionRef: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
+    decidedByUserId: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    decidedAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    decisionOutcome: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof HumanDecision_Outcome>>>>>;
+    decisionToolName: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    decisionModifiedArgumentNames: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodString>>>>;
+    pendingCorrectionRecordRef: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
+    pendingCorrectionPresentedAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingCorrectionOrganizationId: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    pendingCorrectionAdmittedByRole: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
     createdAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodDate>>>;
     updatedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodDate>>>>;
     finishedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodOptional<z.ZodDate>>>;
@@ -201,6 +250,52 @@ export declare const flowActorExecutionsPolymorphicDeclaration: import("..").Pol
         createdAt: z.ZodDefault<z.ZodDate>;
     }, z.core.$strip>>>>>;
     pausedApproval: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodOptional<z.ZodNullable<z.ZodString>>>>;
+    initiationKind: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof FlowsActors_InitiationKind>>>>>;
+    autonomousAgentRef: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    autonomousTrigger: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof AutonomousTurnTrigger>>>>;
+    autonomousPrincipalSource: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof AutonomousPrincipalSource>>>>;
+    caseRef: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodObject<{
+        resourceType: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strict>>>;
+    autonomousActiveSlotKey: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    pendingDecisionRef: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
+    pendingDecisionRouteKind: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof HumanDecision_RouteKind>>>>>>;
+    pendingDecisionEligibleRole: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
+    pendingDecisionOrganizationId: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
+    pendingDecisionOrganizationUnitId: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    pendingDecisionAssigneeUserId: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
+    pendingDecisionClaimedAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionRequesterKind: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof HumanDecision_RequesterKind>>>>>;
+    pendingDecisionRequesterRef: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    pendingDecisionRequesterClientId: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    pendingDecisionRequestedAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionExpiresAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>>;
+    pendingDecisionRouteVersion: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNumber>>>;
+    pendingDecisionClaimDeadlineAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionClaimWarningAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionClaimClockBasis: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof ReviewClockBasis>>>>>;
+    pendingDecisionDecisionDeadlineAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionDecisionWarningAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionDecisionClockBasis: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof ReviewClockBasis>>>>>;
+    pendingDecisionNextDueAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>>;
+    pendingDecisionClockPausedAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionClockPauseStateRef: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    pendingDecisionClockPausedMs: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNumber>>>;
+    pendingDecisionClaimWarningFiredAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionClaimMissedFiredAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionDecisionWarningFiredAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionDecisionMissedFiredAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    lastResolvedDecisionRef: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
+    decidedByUserId: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    decidedAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    decisionOutcome: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof HumanDecision_Outcome>>>>>;
+    decisionToolName: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    decisionModifiedArgumentNames: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodString>>>>;
+    pendingCorrectionRecordRef: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
+    pendingCorrectionPresentedAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingCorrectionOrganizationId: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    pendingCorrectionAdmittedByRole: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
     createdAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodDate>>>;
     updatedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodDate>>>>;
     finishedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodOptional<z.ZodDate>>>;
@@ -212,20 +307,59 @@ export declare const flowActorExecutionsPolymorphicDeclaration: import("..").Pol
  */
 export declare const FlowActorExecutionUpdateInternalSchema: z.ZodObject<{
     status: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof FlowsActors_Status>>>>;
-    statusChanges: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodObject<{
+    statusChanges: z.ZodOptional<z.ZodArray<z.ZodObject<{
         status: z.ZodEnum<typeof FlowsActors_Status>;
         timestamp: z.ZodDate;
-    }, z.core.$strip>>>>;
-    messages: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodArray<z.ZodObject<{
+    }, z.core.$strip>>>;
+    messages: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodUUID;
         role: z.ZodEnum<typeof FlowsActors_ConversationRole>;
         contentType: z.ZodDefault<z.ZodEnum<typeof FlowsActors_MessageContentType>>;
         content: z.ZodString;
         data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         createdAt: z.ZodDefault<z.ZodDate>;
-    }, z.core.$strip>>>>>>;
+    }, z.core.$strip>>>;
     finishedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodOptional<z.ZodDate>>>;
     pausedApproval: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodOptional<z.ZodNullable<z.ZodString>>>>>>;
+    initiationKind: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof FlowsActors_InitiationKind>>>>>;
+    autonomousActiveSlotKey: z.ZodNullable<z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
+    pendingDecisionRef: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
+    pendingDecisionRouteKind: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof HumanDecision_RouteKind>>>>>>;
+    pendingDecisionEligibleRole: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
+    pendingDecisionOrganizationId: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
+    pendingDecisionOrganizationUnitId: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    pendingDecisionAssigneeUserId: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
+    pendingDecisionClaimedAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionRequesterKind: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof HumanDecision_RequesterKind>>>>>;
+    pendingDecisionRequesterRef: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    pendingDecisionRequesterClientId: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    pendingDecisionRequestedAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionExpiresAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>>;
+    pendingDecisionRouteVersion: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNumber>>>;
+    pendingDecisionClaimDeadlineAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionClaimWarningAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionClaimClockBasis: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof ReviewClockBasis>>>>>;
+    pendingDecisionDecisionDeadlineAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionDecisionWarningAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionDecisionClockBasis: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof ReviewClockBasis>>>>>;
+    pendingDecisionNextDueAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>>;
+    pendingDecisionClockPausedAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionClockPauseStateRef: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    pendingDecisionClockPausedMs: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNumber>>>;
+    pendingDecisionClaimWarningFiredAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionClaimMissedFiredAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionDecisionWarningFiredAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingDecisionDecisionMissedFiredAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    lastResolvedDecisionRef: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
+    decidedByUserId: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    decidedAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    decisionOutcome: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof HumanDecision_Outcome>>>>>;
+    decisionToolName: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    decisionModifiedArgumentNames: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodString>>>>;
+    pendingCorrectionRecordRef: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
+    pendingCorrectionPresentedAt: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>>;
+    pendingCorrectionOrganizationId: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
+    pendingCorrectionAdmittedByRole: z.ZodOptional<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
 }, z.core.$strip>;
 /**
  * Runtime shape of a persisted execution (the base envelope). The owner FK is

package/dist/esm/flows-actors/flows-actors-execution.shared.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flows-actors-execution.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/flows-actors/flows-actors-execution.shared.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAA2E,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAGpJ,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAM5E,OAAO,EAGL,KAAK,4BAA4B,EAClC,MAAM,kDAAkD,CAAC;AAQ1D;;;;;GAKG;AACH,oBAAY,4BAA4B;IACtC,IAAI,SAAS;IACb,SAAS,cAAc;IACvB,MAAM,WAAW;IACjB,IAAI,SAAS;CACd;AAED;;;;;GAKG;AACH,oBAAY,8BAA8B;IACxC,IAAI,SAAS;IACb,QAAQ,aAAa;IACrB,QAAQ,aAAa;IACrB,IAAI,SAAS;CACd;AAED,eAAO,MAAM,gCAAgC;;;;;;;iBAwB3C,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAE1F;;;;;;;GAOG;AACH,eAAO,MAAM,uCAAuC;;;;;;;iBAgDlD,CAAC;AACH,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uCAAuC,CAAC,CAAC;AAExG;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,sCAAsC,QAAsB,CAAC;AAE1E,qFAAqF;AACrF,wBAAgB,gCAAgC,CAAC,KAAK,EAAE,iCAAiC,GAAG,MAAM,CAEjG;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,MAAM,GAAG,iCAAiC,CAE3F;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,IAAI,CAAC,iCAAiC,EAAE,WAAW,CAAC,EAAE,GAAG,EAAE,IAAI,GAAG,OAAO,CAIhI;AAuBD;;;;;;;;;GASG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;iBAkJvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAMlF;;;;;;;;GAQG;AACH,eAAO,MAAM,mCAAmC,EAAE,4BAA4B,EAIvC,CAAC;AAExC;;;;;GAKG;AACH,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;kBAMpD,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;iBAqBjD,CAAC;AAMH;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAE9E;;;;;;;GAOG;AACH,wBAAgB,iCAAiC,CAAC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,GAAG,MAAM,CAMnH"}
+{"version":3,"file":"flows-actors-execution.shared.schemas.d.ts","sourceRoot":"","sources":["../../../src/flows-actors/flows-actors-execution.shared.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAA2E,0BAA0B,EAAE,kBAAkB,EAA6B,MAAM,uCAAuC,CAAC;AAC3M,OAAO,EAAE,qBAAqB,EAAE,2BAA2B,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAChJ,OAAO,EAAE,yBAAyB,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAItG,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAM5E,OAAO,EAGL,KAAK,4BAA4B,EAClC,MAAM,kDAAkD,CAAC;AAQ1D;;;;;GAKG;AACH,oBAAY,4BAA4B;IACtC,IAAI,SAAS;IACb,SAAS,cAAc;IACvB,MAAM,WAAW;IACjB,IAAI,SAAS;CACd;AAED;;;;;GAKG;AACH,oBAAY,8BAA8B;IACxC,IAAI,SAAS;IACb,QAAQ,aAAa;IACrB,QAAQ,aAAa;IACrB,IAAI,SAAS;CACd;AAED,eAAO,MAAM,gCAAgC;;;;;;;iBAwB3C,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAE1F;;;;;;;GAOG;AACH,eAAO,MAAM,uCAAuC;;;;;;;iBAgDlD,CAAC;AACH,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uCAAuC,CAAC,CAAC;AAExG;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,sCAAsC,QAAsB,CAAC;AAE1E,qFAAqF;AACrF,wBAAgB,gCAAgC,CAAC,KAAK,EAAE,iCAAiC,GAAG,MAAM,CAEjG;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,MAAM,GAAG,iCAAiC,CAE3F;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,IAAI,CAAC,iCAAiC,EAAE,WAAW,CAAC,EAAE,GAAG,EAAE,IAAI,GAAG,OAAO,CAIhI;AAuBD;;;;;;;;;GASG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAySvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAMlF;;;;;;;;GAQG;AACH,eAAO,MAAM,mCAAmC,EAAE,4BAA4B,EAIvC,CAAC;AAExC;;;;;GAKG;AACH,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAMpD,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0EjD,CAAC;AAMH;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAE9E;;;;;;;GAOG;AACH,wBAAgB,iCAAiC,CAAC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,GAAG,MAAM,CAMnH"}

package/dist/esm/flows-actors/flows-actors-execution.shared.schemas.js

@@ -32,7 +32,10 @@
  */
 import { z } from 'zod';
 import { initZodDecorators, addImpersonalizeWith } from '@wildo-ai/zod-decorators';
-import { FlowsActors_Status } from './flows-actors.commons.shared.schemas.js';
+import { FlowsActors_InitiationKind, FlowsActors_Status, describeFlowsActorsStatus } from './flows-actors.commons.shared.schemas.js';
+import { HumanDecision_Outcome, HumanDecision_RequesterKind, HumanDecision_RouteKind, ReviewClockBasis } from './human-decision.shared.schemas.js';
+import { AutonomousPrincipalSource, AutonomousTurnTrigger } from './autonomous-agents.shared.schemas.js';
+import { WorkUnitRefSchema } from '../resources/work-unit.shared.schemas.js';
 import { DataPortabilityProvenance } from '../compliance/privacy/subject-export.shared.schemas.js';
 import { PersonalDataCategory } from '../compliance/privacy/personal-data-category.shared.schemas.js';
 import { FlowActorSystem_Kind } from './flows-actors.system.shared.schemas.js';
@@ -71,7 +74,7 @@ export var FlowsActors_MessageContentType;
 })(FlowsActors_MessageContentType || (FlowsActors_MessageContentType = {}));
 export const FlowActorExecution_MessageSchema = z.object({
     /** Stable per-message id (client-correlatable across stream deltas). */
-    id: z.uuid(),
+    id: z.uuid().describe("The message's id (a UUID). For an agent reply it is the same `messageId` the live stream used, so a streamed reply can be matched to the stored one."),
     role: z.enum(FlowsActors_ConversationRole)
         .describe('Who produced this message.\n\nValues:\n'
         + '- `user`: the person, or the client acting for them.\n'
@@ -85,7 +88,7 @@ export const FlowActorExecution_MessageSchema = z.object({
         + '- `progress`: an interim note about work in flight; `data` carries the detail.\n'
         + '- `data`: a structured payload rather than prose; read `data`, not `content`.'),
     /** Rendered text content (may be assembled from streamed deltas). */
-    content: z.string(),
+    content: z.string().describe('The text of the message, rendered as `contentType` says. An agent reply is the full text assembled from what was streamed.'),
     /** Structured payload for `DATA`/`PROGRESS` messages (tool results, progress). */
     data: z.record(z.string(), z.unknown()).optional(),
     createdAt: z.date().default(() => new Date()),
@@ -137,7 +140,7 @@ export const FlowActorExecution_PausedApprovalSchema = z.object({
      * The terminal state on expiry is `FlowsActors_Status.FAILED`, which the status vocabulary already
      * names for it. Nothing new was invented. Two producers write it and both read "lapsed" from
      * {@link isFlowActorPausedApprovalLapsed}: the refusal of a decision that arrives too late, and the
-     * hourly sweep that fails a pause nobody answered (#484).
+     * scheduled sweep that fails a pause nobody answered (#484), every minute since gates declare their own lapse (#1628).
      *
      * (That vocabulary's doc used to say a DENIAL was terminal too. It is not — a denial resumes the
      * turn so the model can answer the refusal — and the doc was corrected in the same change.)
@@ -156,9 +159,10 @@ export const FlowActorExecution_PausedApprovalSchema = z.object({
  * against a conversation, a world and an intent that have all moved on, and "do you approve this?"
  * with no memory of the question is a prompt people click through.
  *
- * A framework default rather than an operator knob, for now. If an application ever needs its own,
- * the knob goes beside the consent lifetime in the auth config — but nobody has asked, and a
- * timeout that every application authors identically is a default wearing a config field.
+ * The DEFAULT, not a fixed rule: since #1628 a gate may declare its own lapse
+ * (`humanApproval.deadlines.lapseAfter`, always elapsed time), and this is what a gate declaring none
+ * gets. The gate is the right owner — how long "do you approve deleting this customer?" stays
+ * meaningful depends on the action, not on the application.
  */
 export const FLOW_ACTOR_APPROVAL_DEFAULT_TIMEOUT_MS = 24 * 60 * 60 * 1000;
 /** Serialize paused-approval state for the scalar `pausedApproval` string column. */
@@ -283,8 +287,9 @@ export const FlowActorExecutionBaseSchema = z.object({
     contextRef: z.string().isDBIndexed().excludeFromUpdate().default(''),
     status: z.enum(FlowsActors_Status).isDBIndexed().isSummaryField(),
     statusChanges: z.array(z.object({
-        status: z.enum(FlowsActors_Status),
-        timestamp: z.date(),
+        status: z.enum(FlowsActors_Status)
+            .describe(describeFlowsActorsStatus("The state this run moved into at `timestamp`. The list is the run's history, oldest first.")),
+        timestamp: z.date().describe('When the run moved into `status`.'),
     })).default([]),
     // === Conversational log (chat history) ===
     /**
@@ -354,6 +359,146 @@ export const FlowActorExecutionBaseSchema = z.object({
     // runtime continuation state, not conversation content: generic client reads,
     // summaries and generated API schemas must never disclose it.
     pausedApproval: z.string().nullish().excludeFromCreate().isBackendOnly(),
+    /** Which door opened the turn (#1594). Set on create by the backend; absent on rows older than the column. */
+    initiationKind: z.enum(FlowsActors_InitiationKind).systemEnum('FlowsActors_InitiationKind').isBackendOnly().nullish(),
+    // === Autonomous turn (#1611) ===
+    //
+    // Written on CREATE by the autonomous entry point (`startAutonomousAgentTurn`) and by nothing else,
+    // and never updated: a turn keeps the agent, trigger and principal source it was opened with for its
+    // whole life, including after a reviewer's decision resumes it.
+    /**
+     * The declared autonomous agent this turn runs as. The resume re-resolves the machine principal from
+     * it (with the row's organization), so a binding removed while a decision waits stops the work.
+     */
+    autonomousAgentRef: z.string().min(1).isDBIndexed().excludeFromUpdate().optional(),
+    /** What started the turn. An INBOUND_DELIVERY turn is offered only read or reviewer-gated tools, for its whole life. */
+    autonomousTrigger: z.enum(AutonomousTurnTrigger).systemEnum('AutonomousTurnTrigger').excludeFromUpdate().optional(),
+    /** Where the machine principal came from when the turn started: the tenant's own client, or a firm's admitted one. */
+    autonomousPrincipalSource: z.enum(AutonomousPrincipalSource).systemEnum('AutonomousPrincipalSource').excludeFromUpdate().optional(),
+    /**
+     * The case the turn works on (#1598 attributes its model calls to it). Accepted at start only when the
+     * turn's own principal can READ that row.
+     */
+    caseRef: WorkUnitRefSchema.excludeFromUpdate().optional(),
+    /**
+     * The concurrency slot of a `SKIP_IF_ACTIVE` agent: `<agentRef>|<organizationId>` while the turn is
+     * active, absent otherwise. The unique index is what makes a second active turn's CREATE fail, which the
+     * entry point turns into a skip — the check is the store's, so two occurrences arriving at once cannot
+     * both see "none active".
+     *
+     * Released by the entry point, not by every terminal write: a terminal row still holding its key is
+     * reclaimed with a compare-and-swap (on the key AND a terminal status) the next time the slot is
+     * wanted. So a turn ended by a sweep, a lapse or an escalation lane needs no knowledge of the slot, and
+     * a live turn's key can never be taken. `.optional()` (not nullish) so a clear REMOVES the field: a
+     * stored null would be indexed by MongoDB's sparse index and collide with the next clear.
+     */
+    autonomousActiveSlotKey: z.string().min(1).isUnique({ scope: 'global', sparse: true }).isBackendOnly().optional(),
+    // === Pending human decision (#1594) ===
+    //
+    // Real COLUMNS, on the row that holds the resume compare-and-swap, never in a second store: #1360
+    // measured what a store beside the row costs (a second handle, drift, and a two-row write with no
+    // transaction, which lets a reassignment and an answer both win). Present only while `status` is
+    // AWAITING_APPROVAL; cleared by the CAS that releases the pause. All backend-only: the route says who
+    // may answer, and listing it to a generic reader would reveal that a decision exists.
+    //
+    // DEVIATION from the issue's column list, deliberately: it named a `pendingDecisionRole` beside
+    // `pendingDecisionEligibleRole`. For a ROLE route the route's role IS the eligible role, and a claimed
+    // decision recovers its role from `pendingDecisionClaimedAt` plus the unchanged eligible role — so a
+    // second column could only ever hold a copy that drifts.
+    /** The one decision id, shared by both planes and every audit row (`HumanDecision_Request.decisionId`). Minted by the engine at pause. */
+    pendingDecisionRef: z.string().min(1).isUnique({ scope: 'global', sparse: true }).isBackendOnly().nullish(),
+    pendingDecisionRouteKind: z.enum(HumanDecision_RouteKind).systemEnum('HumanDecision_RouteKind').isDBIndexed().isBackendOnly().nullish(),
+    /** The role every holder must meet (ROLE and ASSIGNEE). The listing's role filter. */
+    pendingDecisionEligibleRole: z.string().min(1).isDBIndexed().isBackendOnly().nullish(),
+    /** The organization the role is matched in. The listing's organization filter. */
+    pendingDecisionOrganizationId: z.string().min(1).isDBIndexed().isBackendOnly().nullish(),
+    /** Stamped from the requester's unit scope, so a unit-scoped holder can be matched (#1597). */
+    pendingDecisionOrganizationUnitId: z.string().min(1).isBackendOnly().nullish(),
+    /** ASSIGNEE only. The listing's "assigned to me" filter. */
+    pendingDecisionAssigneeUserId: z.string().min(1).isDBIndexed().isBackendOnly().nullish(),
+    /** Set when an ASSIGNEE route came from claiming a ROLE route; UNCLAIM restores ROLE. */
+    pendingDecisionClaimedAt: z.date().isBackendOnly().nullish(),
+    pendingDecisionRequesterKind: z.enum(HumanDecision_RequesterKind).systemEnum('HumanDecision_RequesterKind').isBackendOnly().nullish(),
+    /** The user id for USER and DELEGATED_CLIENT; the credential id for MACHINE. What the resume rebuilds authority from. */
+    pendingDecisionRequesterRef: z.string().min(1).isBackendOnly().nullish(),
+    /** DELEGATED_CLIENT only: the client the person delegated to, re-checked at resume. */
+    pendingDecisionRequesterClientId: z.string().min(1).isBackendOnly().nullish(),
+    pendingDecisionRequestedAt: z.date().isBackendOnly().nullish(),
+    /** When answering is refused. The expiry sweep selects on this column instead of parsing every blob. */
+    pendingDecisionExpiresAt: z.date().isDBIndexed().isBackendOnly().nullish(),
+    /** Incremented by every reassign, claim, unclaim and escalate; the answer's release CAS includes it, so an answer read under an older route loses. */
+    pendingDecisionRouteVersion: z.number().int().nonnegative().isBackendOnly().nullish(),
+    // === Pending decision deadlines (#1628) ===
+    //
+    // The two SERVICE-TARGET clocks (CLAIM, DECISION) beside the lapse above, armed at pause from the gate's
+    // `humanApproval.deadlines`. Each stage's due instant is stored, so the sweep never depends on the gate
+    // still resolving and a deployment never reshapes a running clock. Cleared with the rest of the pending
+    // decision. Backend-only, like the route.
+    //
+    // DEVIATION from #1628's column list, deliberately: it named the two deadlines and the next-due instant.
+    // The two WARNING instants and the two clock bases are stored too — a warning is `warnBefore` earlier on
+    // its own basis, and a resume must count the paused time on that basis; recomputing either would read the
+    // gate again, which is exactly the dependency storing the deadlines avoids.
+    pendingDecisionClaimDeadlineAt: z.date().isBackendOnly().nullish(),
+    /** Armed only when the gate's `claim.warnBefore` is declared. */
+    pendingDecisionClaimWarningAt: z.date().isBackendOnly().nullish(),
+    pendingDecisionClaimClockBasis: z.enum(ReviewClockBasis).systemEnum('ReviewClockBasis').isBackendOnly().nullish(),
+    pendingDecisionDecisionDeadlineAt: z.date().isBackendOnly().nullish(),
+    /** Armed only when the gate's `decision.warnBefore` is declared. */
+    pendingDecisionDecisionWarningAt: z.date().isBackendOnly().nullish(),
+    pendingDecisionDecisionClockBasis: z.enum(ReviewClockBasis).systemEnum('ReviewClockBasis').isBackendOnly().nullish(),
+    /**
+     * The earliest instant a stage may still fire at; `null` while the clocks are paused and once nothing is
+     * left to fire. The deadline sweep selects on this indexed column. Every write that fires a stage, pauses,
+     * resumes, claims or unclaims recomputes it in the same statement.
+     */
+    pendingDecisionNextDueAt: z.date().isDBIndexed().isBackendOnly().nullish(),
+    /** Set while the CLAIM and DECISION clocks are paused. Never stops the lapse. */
+    pendingDecisionClockPausedAt: z.date().isBackendOnly().nullish(),
+    /** The gate-declared pause state the clocks are paused in. */
+    pendingDecisionClockPauseStateRef: z.string().min(1).isBackendOnly().nullish(),
+    /** Paused time accumulated over every completed pause, in milliseconds of wall time. */
+    pendingDecisionClockPausedMs: z.number().int().nonnegative().isBackendOnly().nullish(),
+    /*
+     * One fired marker per stage. Each is written by a compare-and-swap on `(pendingDecisionRef, <marker> IS
+     * NULL)`, so a stage fires once however many hosts run the sweep, and only the writer that won runs the
+     * stage's actions. Four nullable timestamps rather than one "fired stages" array: an add-if-absent array
+     * swap is expressed differently on MongoDB and PostgreSQL, a null check is the same predicate on both.
+     */
+    pendingDecisionClaimWarningFiredAt: z.date().isBackendOnly().nullish(),
+    pendingDecisionClaimMissedFiredAt: z.date().isBackendOnly().nullish(),
+    pendingDecisionDecisionWarningFiredAt: z.date().isBackendOnly().nullish(),
+    pendingDecisionDecisionMissedFiredAt: z.date().isBackendOnly().nullish(),
+    // === Last resolved decision (#1594) ===
+    //
+    // Written INSIDE the CAS that releases the pause, so a crash after it still leaves a complete record
+    // of who decided what — the record #1599's corrections repair from.
+    /** The decision these fields describe. Also what a failed release write is re-read against (D10). */
+    lastResolvedDecisionRef: z.string().min(1).isDBIndexed().isBackendOnly().nullish(),
+    /** Absent for a lapse and for a withdrawal nobody answered. */
+    decidedByUserId: z.string().min(1).isBackendOnly().nullish(),
+    decidedAt: z.date().isBackendOnly().nullish(),
+    decisionOutcome: z.enum(HumanDecision_Outcome).systemEnum('HumanDecision_Outcome').isBackendOnly().nullish(),
+    decisionToolName: z.string().min(1).isBackendOnly().nullish(),
+    /** The argument NAMES a decider changed. Never their values. */
+    decisionModifiedArgumentNames: z.array(z.string()).isBackendOnly().nullish(),
+    // === Agent-work review record (#1599): the crash-repair marker ===
+    /**
+     * The decision whose agent-work record is still OWED. Set by the very write that settles a decision on an agent's
+     * proposal (the release, a lapse, a withdrawal) — so a process that dies before the record is written leaves the
+     * debt on the row — and cleared by a compare-and-swap once the record exists. The repair sweep selects on it.
+     */
+    pendingCorrectionRecordRef: z.string().min(1).isDBIndexed().isBackendOnly().nullish(),
+    /** When the settled proposal was PUT BEFORE the decider (#1594's claim instant, else its request instant). */
+    pendingCorrectionPresentedAt: z.date().isBackendOnly().nullish(),
+    /**
+     * The organization the owed decision was ROUTED in. The settling write clears the route columns
+     * (`pendingDecisionOrganizationId`), so without this a repaired record of a user thread with no case would name no
+     * tenant and fall out of that organization's override rate and export.
+     */
+    pendingCorrectionOrganizationId: z.string().min(1).isBackendOnly().nullish(),
+    /** The route role that admitted the decider of the owed decision, cleared by the settle for the same reason. */
+    pendingCorrectionAdmittedByRole: z.string().min(1).isBackendOnly().nullish(),
     // === Timing (system-managed; defaults are load-bearing — the create pipeline
     //     strips these then date-coerces, so a missing default → Invalid Date) ===
     createdAt: z.date().default(() => new Date()).excludeFromCreate().excludeFromUpdate(),
@@ -398,8 +543,17 @@ export const flowActorExecutionsPolymorphicDeclaration = declarePolymorphicSchem
  */
 export const FlowActorExecutionUpdateInternalSchema = z.object({
     status: FlowActorExecutionBaseSchema.shape.status.optional(),
-    statusChanges: FlowActorExecutionBaseSchema.shape.statusChanges.optional(),
-    messages: FlowActorExecutionBaseSchema.shape.messages.optional(),
+    /*
+     * `.unwrap()` takes each field's `.default([])` off, and it must stay off. Zod 4 applies an inner
+     * default under `.optional()`, so `{ status: FAILED }` parsed to `{ status, statusChanges: [],
+     * messages: [] }`, and every partial update of a row reset its transcript and status history.
+     * Measured 2026-09-25 on Wonder Todos: a turn cut off by a companion restart was settled FAILED and
+     * lost the creator's message, and the page read "Nothing has been said yet". The same held for the
+     * resume claim, the pause and the lapsed-approval fail. A default belongs to CREATE; an absent
+     * field on an update means "unchanged".
+     */
+    statusChanges: FlowActorExecutionBaseSchema.shape.statusChanges.unwrap().optional(),
+    messages: FlowActorExecutionBaseSchema.shape.messages.unwrap().optional(),
     finishedAt: FlowActorExecutionBaseSchema.shape.finishedAt,
     /**
      * The suspended-turn state, written when a turn pauses for a human decision and cleared when one
@@ -417,6 +571,50 @@ export const FlowActorExecutionUpdateInternalSchema = z.object({
      * would leave a resumed turn still advertising a decision nobody can answer.
      */
     pausedApproval: FlowActorExecutionBaseSchema.shape.pausedApproval.nullish(),
+    // #1594 — the pending decision and the last resolution. Allow-listed here for the reason above: a field
+    // missing from this contract is a write that succeeds and persists nothing.
+    initiationKind: FlowActorExecutionBaseSchema.shape.initiationKind,
+    // #1611 — the slot is released by the autonomous entry point; `null` removes it (see the field).
+    autonomousActiveSlotKey: FlowActorExecutionBaseSchema.shape.autonomousActiveSlotKey.nullable(),
+    pendingDecisionRef: FlowActorExecutionBaseSchema.shape.pendingDecisionRef,
+    pendingDecisionRouteKind: FlowActorExecutionBaseSchema.shape.pendingDecisionRouteKind,
+    pendingDecisionEligibleRole: FlowActorExecutionBaseSchema.shape.pendingDecisionEligibleRole,
+    pendingDecisionOrganizationId: FlowActorExecutionBaseSchema.shape.pendingDecisionOrganizationId,
+    pendingDecisionOrganizationUnitId: FlowActorExecutionBaseSchema.shape.pendingDecisionOrganizationUnitId,
+    pendingDecisionAssigneeUserId: FlowActorExecutionBaseSchema.shape.pendingDecisionAssigneeUserId,
+    pendingDecisionClaimedAt: FlowActorExecutionBaseSchema.shape.pendingDecisionClaimedAt,
+    pendingDecisionRequesterKind: FlowActorExecutionBaseSchema.shape.pendingDecisionRequesterKind,
+    pendingDecisionRequesterRef: FlowActorExecutionBaseSchema.shape.pendingDecisionRequesterRef,
+    pendingDecisionRequesterClientId: FlowActorExecutionBaseSchema.shape.pendingDecisionRequesterClientId,
+    pendingDecisionRequestedAt: FlowActorExecutionBaseSchema.shape.pendingDecisionRequestedAt,
+    pendingDecisionExpiresAt: FlowActorExecutionBaseSchema.shape.pendingDecisionExpiresAt,
+    pendingDecisionRouteVersion: FlowActorExecutionBaseSchema.shape.pendingDecisionRouteVersion,
+    // #1628 — the deadline clocks, allow-listed for the same reason.
+    pendingDecisionClaimDeadlineAt: FlowActorExecutionBaseSchema.shape.pendingDecisionClaimDeadlineAt,
+    pendingDecisionClaimWarningAt: FlowActorExecutionBaseSchema.shape.pendingDecisionClaimWarningAt,
+    pendingDecisionClaimClockBasis: FlowActorExecutionBaseSchema.shape.pendingDecisionClaimClockBasis,
+    pendingDecisionDecisionDeadlineAt: FlowActorExecutionBaseSchema.shape.pendingDecisionDecisionDeadlineAt,
+    pendingDecisionDecisionWarningAt: FlowActorExecutionBaseSchema.shape.pendingDecisionDecisionWarningAt,
+    pendingDecisionDecisionClockBasis: FlowActorExecutionBaseSchema.shape.pendingDecisionDecisionClockBasis,
+    pendingDecisionNextDueAt: FlowActorExecutionBaseSchema.shape.pendingDecisionNextDueAt,
+    pendingDecisionClockPausedAt: FlowActorExecutionBaseSchema.shape.pendingDecisionClockPausedAt,
+    pendingDecisionClockPauseStateRef: FlowActorExecutionBaseSchema.shape.pendingDecisionClockPauseStateRef,
+    pendingDecisionClockPausedMs: FlowActorExecutionBaseSchema.shape.pendingDecisionClockPausedMs,
+    pendingDecisionClaimWarningFiredAt: FlowActorExecutionBaseSchema.shape.pendingDecisionClaimWarningFiredAt,
+    pendingDecisionClaimMissedFiredAt: FlowActorExecutionBaseSchema.shape.pendingDecisionClaimMissedFiredAt,
+    pendingDecisionDecisionWarningFiredAt: FlowActorExecutionBaseSchema.shape.pendingDecisionDecisionWarningFiredAt,
+    pendingDecisionDecisionMissedFiredAt: FlowActorExecutionBaseSchema.shape.pendingDecisionDecisionMissedFiredAt,
+    lastResolvedDecisionRef: FlowActorExecutionBaseSchema.shape.lastResolvedDecisionRef,
+    decidedByUserId: FlowActorExecutionBaseSchema.shape.decidedByUserId,
+    decidedAt: FlowActorExecutionBaseSchema.shape.decidedAt,
+    decisionOutcome: FlowActorExecutionBaseSchema.shape.decisionOutcome,
+    decisionToolName: FlowActorExecutionBaseSchema.shape.decisionToolName,
+    decisionModifiedArgumentNames: FlowActorExecutionBaseSchema.shape.decisionModifiedArgumentNames,
+    // #1599 — the agent-work record the settlement owes; allow-listed for the reason above.
+    pendingCorrectionRecordRef: FlowActorExecutionBaseSchema.shape.pendingCorrectionRecordRef,
+    pendingCorrectionPresentedAt: FlowActorExecutionBaseSchema.shape.pendingCorrectionPresentedAt,
+    pendingCorrectionOrganizationId: FlowActorExecutionBaseSchema.shape.pendingCorrectionOrganizationId,
+    pendingCorrectionAdmittedByRole: FlowActorExecutionBaseSchema.shape.pendingCorrectionAdmittedByRole,
 });
 /**
  * One string for a set of context resource identifiers — `key=value` pairs sorted by key, joined