@wildo-ai/saas-models 1.1.5 → 1.1.6

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

@@ -67,8 +67,6 @@ export declare const ActorSystemSchema: z.ZodObject<{
             applicationId: z.ZodOptional<z.ZodString>;
             userId: z.ZodOptional<z.ZodString>;
             roles: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<typeof import("..").CORE_APP_ROLES>, z.ZodEnum<typeof import("..").CORE_ORG_ROLES>, z.ZodString]>>>;
-            requiresApproval: z.ZodDefault<z.ZodBoolean>;
-            approverRoles: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<typeof import("..").CORE_APP_ROLES>, z.ZodEnum<typeof import("..").CORE_ORG_ROLES>, z.ZodString]>>>;
         }, z.core.$strip>>;
         riskLevel: z.ZodEnum<typeof import("..").ResourceOperationRiskLevel>;
         dataClassification: z.ZodOptional<z.ZodEnum<typeof import("..").Compliance_DataClassification>>;
@@ -78,11 +76,6 @@ export declare const ActorSystemSchema: z.ZodObject<{
             redactionType: z.ZodEnum<typeof import("..").RedactionType>;
             forRoles: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<typeof import("..").CORE_APP_ROLES>, z.ZodEnum<typeof import("..").CORE_ORG_ROLES>, z.ZodString]>>>;
         }, z.core.$strip>>>;
-        retentionPolicy: z.ZodOptional<z.ZodObject<{
-            retentionDays: z.ZodNumber;
-            autoDelete: z.ZodDefault<z.ZodBoolean>;
-            archiveAfterDays: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
     }, z.core.$strip>;
     version: z.ZodOptional<z.ZodString>;
     createdAt: z.ZodOptional<z.ZodString>;
@@ -134,8 +127,26 @@ export declare const ActorExecution_SuspensionSchema: z.ZodObject<{
         }, z.core.$strip>>;
         requestedAt: z.ZodString;
         expiresAt: z.ZodOptional<z.ZodString>;
+        review: z.ZodOptional<z.ZodObject<{
+            surface: z.ZodEnum<typeof import("./human-decision.shared.schemas").AgentWorkDecisionSurface>;
+        }, z.core.$strict>>;
     }, z.core.$strip>;
     suspendedAt: z.ZodISODateTime;
+    route: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<typeof import("./human-decision.shared.schemas").HumanDecision_RouteKind>;
+        eligibleRole: z.ZodOptional<z.ZodString>;
+        organizationId: z.ZodOptional<z.ZodString>;
+        organizationUnitId: z.ZodOptional<z.ZodString>;
+        assigneeUserId: z.ZodOptional<z.ZodString>;
+        claimedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    requester: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<typeof import("./human-decision.shared.schemas").HumanDecision_RequesterKind>;
+        ref: z.ZodString;
+        clientId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    routeVersion: z.ZodOptional<z.ZodNumber>;
+    suspensionId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type ActorExecution_Suspension = z.infer<typeof ActorExecution_SuspensionSchema>;
 /**
@@ -173,8 +184,26 @@ export declare const ActorExecution_CheckpointSchema: z.ZodObject<{
             }, z.core.$strip>>;
             requestedAt: z.ZodString;
             expiresAt: z.ZodOptional<z.ZodString>;
+            review: z.ZodOptional<z.ZodObject<{
+                surface: z.ZodEnum<typeof import("./human-decision.shared.schemas").AgentWorkDecisionSurface>;
+            }, z.core.$strict>>;
         }, z.core.$strip>;
         suspendedAt: z.ZodISODateTime;
+        route: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<typeof import("./human-decision.shared.schemas").HumanDecision_RouteKind>;
+            eligibleRole: z.ZodOptional<z.ZodString>;
+            organizationId: z.ZodOptional<z.ZodString>;
+            organizationUnitId: z.ZodOptional<z.ZodString>;
+            assigneeUserId: z.ZodOptional<z.ZodString>;
+            claimedAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        requester: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<typeof import("./human-decision.shared.schemas").HumanDecision_RequesterKind>;
+            ref: z.ZodString;
+            clientId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        routeVersion: z.ZodOptional<z.ZodNumber>;
+        suspensionId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     interruptedContinuations: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
@@ -194,10 +223,13 @@ export declare const ActorSystem_ExecutionSchema: z.ZodObject<{
         consumableTokenId: z.ZodOptional<z.ZodString>;
         webhookProviderId: z.ZodOptional<z.ZodString>;
         anonymousUserId: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    statusChanges: z.ZodArray<z.ZodObject<{
-        status: z.ZodEnum<typeof FlowsActors_Status>;
-        timestamp: z.ZodString;
+        inboundDeliveryId: z.ZodOptional<z.ZodString>;
+        inboundHandlerRef: z.ZodOptional<z.ZodString>;
+        inboundScopeUserId: z.ZodOptional<z.ZodString>;
+        inboundSender: z.ZodOptional<z.ZodObject<{
+            channel: z.ZodEnum<typeof import("..").InboundChannelKind>;
+            assurance: z.ZodEnum<typeof import("..").InboundSenderAssurance>;
+        }, z.core.$strict>>;
     }, z.core.$strip>>;
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
@@ -223,8 +255,26 @@ export declare const ActorSystem_ExecutionSchema: z.ZodObject<{
             }, z.core.$strip>>;
             requestedAt: z.ZodString;
             expiresAt: z.ZodOptional<z.ZodString>;
+            review: z.ZodOptional<z.ZodObject<{
+                surface: z.ZodEnum<typeof import("./human-decision.shared.schemas").AgentWorkDecisionSurface>;
+            }, z.core.$strict>>;
         }, z.core.$strip>;
         suspendedAt: z.ZodISODateTime;
+        route: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<typeof import("./human-decision.shared.schemas").HumanDecision_RouteKind>;
+            eligibleRole: z.ZodOptional<z.ZodString>;
+            organizationId: z.ZodOptional<z.ZodString>;
+            organizationUnitId: z.ZodOptional<z.ZodString>;
+            assigneeUserId: z.ZodOptional<z.ZodString>;
+            claimedAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        requester: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<typeof import("./human-decision.shared.schemas").HumanDecision_RequesterKind>;
+            ref: z.ZodString;
+            clientId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        routeVersion: z.ZodOptional<z.ZodNumber>;
+        suspensionId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
     checkpoint: z.ZodOptional<z.ZodNullable<z.ZodObject<{
         context: z.ZodAny;
@@ -249,12 +299,40 @@ export declare const ActorSystem_ExecutionSchema: z.ZodObject<{
                 }, z.core.$strip>>;
                 requestedAt: z.ZodString;
                 expiresAt: z.ZodOptional<z.ZodString>;
+                review: z.ZodOptional<z.ZodObject<{
+                    surface: z.ZodEnum<typeof import("./human-decision.shared.schemas").AgentWorkDecisionSurface>;
+                }, z.core.$strict>>;
             }, z.core.$strip>;
             suspendedAt: z.ZodISODateTime;
+            route: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<typeof import("./human-decision.shared.schemas").HumanDecision_RouteKind>;
+                eligibleRole: z.ZodOptional<z.ZodString>;
+                organizationId: z.ZodOptional<z.ZodString>;
+                organizationUnitId: z.ZodOptional<z.ZodString>;
+                assigneeUserId: z.ZodOptional<z.ZodString>;
+                claimedAt: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            requester: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<typeof import("./human-decision.shared.schemas").HumanDecision_RequesterKind>;
+                ref: z.ZodString;
+                clientId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            routeVersion: z.ZodOptional<z.ZodNumber>;
+            suspensionId: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
         interruptedContinuations: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>>;
     exclusiveSubject: z.ZodOptional<z.ZodString>;
+    statusChanges: z.ZodArray<z.ZodObject<{
+        status: z.ZodEnum<typeof FlowsActors_Status>;
+        timestamp: z.ZodString;
+        resolution: z.ZodOptional<z.ZodObject<{
+            decisionRef: z.ZodString;
+            outcome: z.ZodEnum<typeof import("./human-decision.shared.schemas").HumanDecision_Outcome>;
+            decidedByUserId: z.ZodOptional<z.ZodString>;
+            decidedAt: z.ZodISODateTime;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     plan: z.ZodOptional<z.ZodObject<{
         _id: z.ZodString;
         goalDescription: z.ZodString;
@@ -270,6 +348,13 @@ export declare const ActorSystem_ExecutionSchema: z.ZodObject<{
             consumableTokenId: z.ZodOptional<z.ZodString>;
             webhookProviderId: z.ZodOptional<z.ZodString>;
             anonymousUserId: z.ZodOptional<z.ZodString>;
+            inboundDeliveryId: z.ZodOptional<z.ZodString>;
+            inboundHandlerRef: z.ZodOptional<z.ZodString>;
+            inboundScopeUserId: z.ZodOptional<z.ZodString>;
+            inboundSender: z.ZodOptional<z.ZodObject<{
+                channel: z.ZodEnum<typeof import("..").InboundChannelKind>;
+                assurance: z.ZodEnum<typeof import("..").InboundSenderAssurance>;
+            }, z.core.$strict>>;
         }, z.core.$strip>;
         relationships: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
             kind: z.ZodLiteral<import("./flows-actors.commons.shared.schemas").FlowsActors_ElementKind.FLOW>;
@@ -396,12 +481,20 @@ export declare const ActorSystem_ExecutionSchema: z.ZodObject<{
                     consumableTokenId: z.ZodOptional<z.ZodString>;
                     webhookProviderId: z.ZodOptional<z.ZodString>;
                     anonymousUserId: z.ZodOptional<z.ZodString>;
+                    inboundDeliveryId: z.ZodOptional<z.ZodString>;
+                    inboundHandlerRef: z.ZodOptional<z.ZodString>;
+                    inboundScopeUserId: z.ZodOptional<z.ZodString>;
+                    inboundSender: z.ZodOptional<z.ZodObject<{
+                        channel: z.ZodEnum<typeof import("..").InboundChannelKind>;
+                        assurance: z.ZodEnum<typeof import("..").InboundSenderAssurance>;
+                    }, z.core.$strict>>;
                 }, z.core.$strip>>>;
                 executionType: z.ZodOptional<z.ZodEnum<typeof import("..").ExecutionContext_ExecutionType>>;
                 userGuidance: z.ZodOptional<z.ZodObject<{
                     guidanceKey: z.ZodOptional<z.ZodString>;
                     explanation: z.ZodOptional<z.ZodString>;
                     resolution: z.ZodOptional<z.ZodString>;
+                    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
                     completedSteps: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     nextAction: z.ZodOptional<z.ZodObject<{
                         label: z.ZodString;
@@ -481,6 +574,13 @@ export declare const ActorSystem_ExecutionSchema: z.ZodObject<{
             consumableTokenId: z.ZodOptional<z.ZodString>;
             webhookProviderId: z.ZodOptional<z.ZodString>;
             anonymousUserId: z.ZodOptional<z.ZodString>;
+            inboundDeliveryId: z.ZodOptional<z.ZodString>;
+            inboundHandlerRef: z.ZodOptional<z.ZodString>;
+            inboundScopeUserId: z.ZodOptional<z.ZodString>;
+            inboundSender: z.ZodOptional<z.ZodObject<{
+                channel: z.ZodEnum<typeof import("..").InboundChannelKind>;
+                assurance: z.ZodEnum<typeof import("..").InboundSenderAssurance>;
+            }, z.core.$strict>>;
         }, z.core.$strip>;
         relationships: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
             kind: z.ZodLiteral<import("./flows-actors.commons.shared.schemas").FlowsActors_ElementKind.FLOW>;
@@ -721,12 +821,20 @@ export declare const ActorSystem_ExecutionSchema: z.ZodObject<{
                     consumableTokenId: z.ZodOptional<z.ZodString>;
                     webhookProviderId: z.ZodOptional<z.ZodString>;
                     anonymousUserId: z.ZodOptional<z.ZodString>;
+                    inboundDeliveryId: z.ZodOptional<z.ZodString>;
+                    inboundHandlerRef: z.ZodOptional<z.ZodString>;
+                    inboundScopeUserId: z.ZodOptional<z.ZodString>;
+                    inboundSender: z.ZodOptional<z.ZodObject<{
+                        channel: z.ZodEnum<typeof import("..").InboundChannelKind>;
+                        assurance: z.ZodEnum<typeof import("..").InboundSenderAssurance>;
+                    }, z.core.$strict>>;
                 }, z.core.$strip>>>;
                 executionType: z.ZodOptional<z.ZodEnum<typeof import("..").ExecutionContext_ExecutionType>>;
                 userGuidance: z.ZodOptional<z.ZodObject<{
                     guidanceKey: z.ZodOptional<z.ZodString>;
                     explanation: z.ZodOptional<z.ZodString>;
                     resolution: z.ZodOptional<z.ZodString>;
+                    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
                     completedSteps: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     nextAction: z.ZodOptional<z.ZodObject<{
                         label: z.ZodString;
@@ -858,12 +966,20 @@ export declare const ActorSystem_ExecutionSchema: z.ZodObject<{
                 consumableTokenId: z.ZodOptional<z.ZodString>;
                 webhookProviderId: z.ZodOptional<z.ZodString>;
                 anonymousUserId: z.ZodOptional<z.ZodString>;
+                inboundDeliveryId: z.ZodOptional<z.ZodString>;
+                inboundHandlerRef: z.ZodOptional<z.ZodString>;
+                inboundScopeUserId: z.ZodOptional<z.ZodString>;
+                inboundSender: z.ZodOptional<z.ZodObject<{
+                    channel: z.ZodEnum<typeof import("..").InboundChannelKind>;
+                    assurance: z.ZodEnum<typeof import("..").InboundSenderAssurance>;
+                }, z.core.$strict>>;
             }, z.core.$strip>>>;
             executionType: z.ZodOptional<z.ZodEnum<typeof import("..").ExecutionContext_ExecutionType>>;
             userGuidance: z.ZodOptional<z.ZodObject<{
                 guidanceKey: z.ZodOptional<z.ZodString>;
                 explanation: z.ZodOptional<z.ZodString>;
                 resolution: z.ZodOptional<z.ZodString>;
+                params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
                 completedSteps: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 nextAction: z.ZodOptional<z.ZodObject<{
                     label: z.ZodString;

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

@@ -1 +1 @@
-{"version":3,"file":"actors.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/flows-actors/actors.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,kBAAkB,EAA6B,MAAM,uCAAuC,CAAC;AACtG,OAAO,EAAmG,oBAAoB,EAAG,MAAM,sCAAsC,CAAC;AAgB9K,oBAAY,mBAAmB;IAC7B,WAAW,gBAAgB;IAC3B,YAAY,iBAAiB;IAC7B,QAAQ,aAAa;IACrB,QAAQ,aAAa;IACrB,QAAQ,aAAa;IACrB,iBAAiB,sBAAsB;IACvC,cAAc,mBAAmB;CAClC;AAGD;;;;;;;;;;;;;;;;GAgBG;AACH,oBAAY,mBAAmB;IAC7B,OAAO,YAAY;IACnB,cAAc,mBAAmB;IACjC,iBAAiB,sBAAsB;IACvC,YAAY,iBAAiB;CAC9B;AAED,eAAO,MAAM,WAAW;;;;;;;iBAOtB,CAAC;AACH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAMhD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAS5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAO5D;;;;;;;;;GASG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;iBAG1C,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAExF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgC1C,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAGxF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoDtC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC"}
+{"version":3,"file":"actors.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/flows-actors/actors.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,kBAAkB,EAA6B,MAAM,uCAAuC,CAAC;AACtG,OAAO,EAAmG,oBAAoB,EAAG,MAAM,sCAAsC,CAAC;AAgB9K,oBAAY,mBAAmB;IAC7B,WAAW,gBAAgB;IAC3B,YAAY,iBAAiB;IAC7B,QAAQ,aAAa;IACrB,QAAQ,aAAa;IACrB,QAAQ,aAAa;IACrB,iBAAiB,sBAAsB;IACvC,cAAc,mBAAmB;CAClC;AAGD;;;;;;;;;;;;;;;;GAgBG;AACH,oBAAY,mBAAmB;IAC7B,OAAO,YAAY;IACnB,cAAc,mBAAmB;IACjC,iBAAiB,sBAAsB;IACvC,YAAY,iBAAiB;CAC9B;AAED,eAAO,MAAM,WAAW;;;;;;;iBAOtB,CAAC;AACH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAMhD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAS5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAO5D;;;;;;;;;GASG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwB1C,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAExF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgC1C,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAGxF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+DtC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC"}

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

@@ -3,7 +3,7 @@ import { WildoError_BackendSchema } from "../errors/errors.shared.schemas.js";
 import { FlowsActors_Status, describeFlowsActorsStatus } from "./flows-actors.commons.shared.schemas.js";
 import { FlowActorSystem_BaseSchema, FlowActorSystem_ErrorStates_Schema, FlowActorSystem_ExecutionSchema, FlowActorSystem_Kind, } from "./flows-actors.system.shared.schemas.js";
 import { Actors_Task_Schema, ActorsSystem_ExecutionPlan_Schema } from "./tasks.actors.shared.schemas.js";
-import { HumanDecision_RequestSchema } from "./human-decision.shared.schemas.js";
+import { HumanDecision_RequestSchema, HumanDecision_RequesterSchema, HumanDecision_ResolutionSchema, HumanDecision_RouteSchema } from "./human-decision.shared.schemas.js";
 //===============================================================
 //  Actor
 // --------
@@ -95,6 +95,27 @@ export const ActorSystemSchema = FlowActorSystem_BaseSchema.extend({
 export const ActorExecution_SuspensionSchema = z.object({
     decision: HumanDecision_RequestSchema,
     suspendedAt: z.iso.datetime(),
+    /**
+     * WHO may settle this decision (#1594 D2) — the same shape the conversational plane stores in columns.
+     * Absent on a suspension whose host routes nothing: its own door is then the only authority over it,
+     * and the engine authorizes nothing it was not given a route for.
+     */
+    route: HumanDecision_RouteSchema.optional(),
+    /** The authority the run was raised under, and resumes under. Stamped beside `route`. */
+    requester: HumanDecision_RequesterSchema.optional(),
+    /**
+     * Bumped by every move of `route` (#1594 I5). The persistence port's compare-and-swap checks it, so an
+     * answer read under an older route loses. Written `0` with a route; absent when there is none.
+     */
+    routeVersion: z.number().int().nonnegative().optional(),
+    /**
+     * THIS suspension's identity, written once when the run suspends (#1581). A run may ask again after
+     * an answer, and its decision id names the RUN (hosts use their run or task id), so neither that nor
+     * an instant tells two questions of one run apart. An answer names the suspension it read, and a
+     * resume refuses one the run has moved past. Absent on a row written before it existed; such a
+     * suspension is named by its instant (`actorExecutionSuspensionRef` in the backend runtime).
+     */
+    suspensionId: z.string().min(1).optional(),
 });
 /**
  * What a run left behind so that whatever runs next can CONTINUE it — the host's resume inputs.
@@ -163,6 +184,16 @@ export const ActorSystem_ExecutionSchema = FlowActorSystem_ExecutionSchema.exten
      * of which a restart — or a second process — could not see.
      */
     exclusiveSubject: z.string().min(1).optional(),
+    /**
+     * The run's history, oldest first — as on every execution, plus the RESOLUTION of the decision a move
+     * ended (#1594 I4). The change that takes a run out of waiting carries how that wait ended, written in
+     * the same statement, so no second write can be lost between them. A decision that won and was then
+     * put back (the tasks could not follow) is followed by a change back to waiting: the history keeps what
+     * happened, and the latest change says where the run stands.
+     */
+    statusChanges: z.array(FlowActorSystem_ExecutionSchema.shape.statusChanges.element.extend({
+        resolution: HumanDecision_ResolutionSchema.optional(),
+    })),
     plan: ActorsSystem_ExecutionPlan_Schema.optional(),
     standaloneTasks: z.array(Actors_Task_Schema),
     standaloneTaskStates: z.object({

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

@@ -1 +1 @@
-{"version":3,"file":"actors.shared.schemas.js","sourceRoot":"","sources":["../../../../src/flows-actors/actors.shared.schemas.ts"],"names":[],"mappings":"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","sourcesContent":["import { z } from \"zod\";\n\nimport { WildoError_BackendSchema } from \"../errors/errors.shared.schemas\";\nimport { FlowsActors_Status, describeFlowsActorsStatus } from \"./flows-actors.commons.shared.schemas\";\nimport { FlowActorSystem_BaseSchema, FlowActorSystem_ErrorStates_Schema, FlowActorSystem_ExecutionSchema, FlowActorSystem_Kind, } from \"./flows-actors.system.shared.schemas\";\nimport { Actors_Task_Schema, ActorsSystem_ExecutionPlan_Schema } from \"./tasks.actors.shared.schemas\";\nimport { HumanDecision_RequestSchema } from \"./human-decision.shared.schemas\";\n\n\n//===============================================================\n//  Actor\n// --------\n// Actors are reactive components that subscribe to event topics\n// and respond with automated processing. They enable event-driven\n// architecture by processing messages asynchronously, supporting\n// batch processing, filtering, and various error handling strategies.\n// Actors can emit new events, creating event chains and workflows.\n//===============================================================\n\n\nexport enum Actor_Role_Category {\n  COORDINATOR = \"coordinator\",\n  TASK_PLANNER = \"task_planner\",\n  OPERATOR = \"operator\",\n  ANALYZER = \"analyzer\",\n  REVIEWER = \"reviewer\",\n  HUMAN_IN_THE_LOOP = \"human_in_the_loop\",\n  FLOW_EXECUTION = \"flow_execution\"\n}\n\n\n/**\n * HOW an actor does its work when the runtime drives it.\n *\n * `PROGRAMMATIC` (added 2026-09-20, #1358) is the mode of an actor whose behaviour is supplied by the\n * HOST as code rather than by an agent, a flow or a person: the execution driver opens the actor's\n * task, hands the opened identities to a host-supplied executor, and settles on its outcome. An actor\n * is not an agent — a methodology step run by the app-creation companion, or a deterministic check,\n * is an actor with no model behind it, and until this member existed such an actor had to borrow\n * `AGENTIC` without an `agentRef`, which is a lie the registry cannot see.\n *\n * `FLOW_EXECUTION` is a PLANNED member and stays (decided by Paul, 2026-09-21, #1363). The Flow\n * execution model is not implemented yet — `FlowsBackendService.executeFlow` refuses honestly — and\n * it is intended: an actor whose work is a declared flow is part of what this system is for. No\n * driver dispatches on this member today, so a reader sweep reports zero; that is the state of the\n * build, not a verdict on the member. Do not delete it, the Flow model, or `Actor_Role_Category`'s\n * matching member on that measurement.\n */\nexport enum Actor_ExecutionMode {\n  AGENTIC = \"agentic\",\n  FLOW_EXECUTION = \"flow_execution\",\n  HUMAN_INTERACTION = \"human_interaction\",\n  PROGRAMMATIC = \"programmatic\",\n}\n\nexport const ActorSchema = z.object({\n  ref: z.string().min(1),\n  displayName: z.string().min(1),\n  roleCategory: z.enum(Actor_Role_Category),\n  executionMode: z.enum(Actor_ExecutionMode),\n  agentRef: z.string().optional(),\n  flowRef: z.string().optional(),\n});\nexport type Actor = z.infer<typeof ActorSchema>;\n\n//===============================================================\n//  Actor System\n//===============================================================\n\n/**\n * The ACTOR specialization of the system base — the schema that OWNS a system's\n * actor list. `actors` is declared here and in no other system schema: the base\n * cannot declare it, because a FLOW system has no actors. (Unrelated `actors`\n * members exist on the TASK schemas; those point at one actor, they are not a\n * system's roster.)\n *\n * An actor system must therefore be parsed with this schema, or one derived\n * from it. Parsing one with `FlowActorSystem_BaseSchema` strips `actors`\n * silently — see the warning there.\n */\nexport const ActorSystemSchema = FlowActorSystem_BaseSchema.extend({\n  /**\n   * Narrows the inherited `kind` discriminant to ACTOR. The historical shape\n   * added a separate `type` field here while every consumer (backend registry,\n   * execution schemas, flows counterpart) discriminates on `kind` — fixed\n   * 2026-07-02 (meta-workflows Step 0 hygiene; no `.type` consumer existed).\n   */\n  kind: z.literal(FlowActorSystem_Kind.ACTOR),\n  actors: z.array(z.lazy(() => ActorSchema)),\n});\nexport type ActorSystem = z.infer<typeof ActorSystemSchema>;\n\n\n//===============================================================\n//  Actor System Execution\n//===============================================================\n\n/**\n * The human decision an execution is WAITING on — present exactly while its status is\n * `AWAITING_APPROVAL`, and cleared by the resume that answers it.\n *\n * Until #1360 three stores held this for three kinds of question (a checkpoint file for a mid-run\n * clarification, another for an interrupted composite, a task's `output.suspension` for a parked\n * coding question), projecting one `HumanDecision_Request` each — the payload was unified by #1269\n * and the storage was left where it was on the premise that a playbook run had no execution row.\n * #1343 removed that premise. The decision lives on the row the run already has.\n */\nexport const ActorExecution_SuspensionSchema = z.object({\n  decision: HumanDecision_RequestSchema,\n  suspendedAt: z.iso.datetime(),\n});\nexport type ActorExecution_Suspension = z.infer<typeof ActorExecution_SuspensionSchema>;\n\n/**\n * What a run left behind so that whatever runs next can CONTINUE it — the host's resume inputs.\n *\n * `context` is opaque to the engine, exactly as `FlowsActors_Checkpoint.context` is: the engine owns\n * the slot and when it is written and read; the host that executes the work owns the content and\n * validates it at its own boundary. Written while a run progresses (so a run whose process is taken\n * away can be continued) and when a run suspends (so its resume can rebuild what it was doing).\n *\n * A checkpoint outliving its run is the ordinary signal of an INTERRUPTED run: the driver settles a\n * run whose host died `ABORTED` at the next startup and leaves this in place, so \"interrupted and\n * resumable\" is `ABORTED` with a checkpoint — a fact of the row, not a fourth status (#1360).\n */\nexport const ActorExecution_CheckpointSchema = z.object({\n  context: z.any(),\n  checkpointedAt: z.iso.datetime(),\n  /**\n   * The question a RESUMED run was answering, kept until the run moves past it.\n   *\n   * A resume clears `suspension` and moves the row to `PROCESSING`. When the host asked for a failed\n   * continuation to leave the question standing (`restoreSuspensionOnFailure`), a THROWN continuation\n   * is caught and the suspension restored. A continuation whose PROCESS dies throws nothing: the\n   * startup orphan sweep used to settle it `ABORTED`, and the person's answer went with it. Measured\n   * 2026-09-24 on a real domain-plan clarification: answered, resumed, and aborted 85 s later by a\n   * companion restart, which the dev loop performs every few minutes.\n   *\n   * So the resume writes the suspension here, and the sweep puts an orphan that carries one back to\n   * `AWAITING_APPROVAL` on the same question instead of aborting it. It lives on the CHECKPOINT\n   * because it is a resume input with the same lifetime: a host checkpoint written mid-run replaces\n   * the whole checkpoint and drops it (the run has moved past the question), a new suspension\n   * replaces it, and a settle that keeps the checkpoint strips it.\n   */\n  resumedSuspension: ActorExecution_SuspensionSchema.optional(),\n  /**\n   * How many continuations of the pending question DIED WITH THEIR PROCESS before this one (#1507).\n   *\n   * The startup sweep puts such a run back to waiting (see `resumedSuspension`), and nothing else\n   * remembers that a continuation ran: whatever it did and spent went with the process. Counted here so\n   * the host can say so — a playbook run records each as an unobserved part of its spend, so its total\n   * reads as a floor rather than as complete. Cleared once a host has accounted for them in the task's\n   * own record (a restored output after a thrown continuation), and whenever the run moves past the\n   * question: a new suspension replaces the checkpoint, a consuming settle clears it, and a settle that\n   * keeps it drops this count with `resumedSuspension`.\n   */\n  interruptedContinuations: z.number().int().positive().optional(),\n});\nexport type ActorExecution_Checkpoint = z.infer<typeof ActorExecution_CheckpointSchema>;\n\n\nexport const ActorSystem_ExecutionSchema = FlowActorSystem_ExecutionSchema.extend({\n  kind: z.literal(FlowActorSystem_Kind.ACTOR),\n\n  /** See {@link ActorExecution_SuspensionSchema}. `null` once answered; absent on a run that never asked. */\n  suspension: ActorExecution_SuspensionSchema.nullable().optional(),\n  /** See {@link ActorExecution_CheckpointSchema}. `null` once consumed; absent on a run that never wrote one. */\n  checkpoint: ActorExecution_CheckpointSchema.nullable().optional(),\n\n  /**\n   * What this execution runs EXCLUSIVELY — the subject of its single-flight lease (#1361).\n   *\n   * While an execution carrying a subject is `PENDING` or `PROCESSING`, the runtime refuses to open\n   * or resume another execution of the SAME system with the same subject. The lease IS the row: no\n   * second record says \"busy\", so nothing can disagree with what is actually running. A run that is\n   * waiting on a person (`AWAITING_APPROVAL`) does not hold it — it is not running — and a host's\n   * startup orphan sweep is what releases a lease whose holder died.\n   *\n   * Absent on the ordinary run, which excludes nothing. The subject's vocabulary is the opening\n   * domain's: the runtime compares it and never reads it.\n   *\n   * Until #1361 this principle was implemented three times in one consumer as in-memory flags, each\n   * of which a restart — or a second process — could not see.\n   */\n  exclusiveSubject: z.string().min(1).optional(),\n\n  plan: ActorsSystem_ExecutionPlan_Schema.optional(),\n  standaloneTasks: z.array(Actors_Task_Schema),\n\n  standaloneTaskStates: z.object({\n    taskId: z.string(),\n    status: z.enum(FlowsActors_Status),\n    updatedAt: z.iso.datetime(),\n    statusChanges: z.array(z.object({\n      status: z.enum(FlowsActors_Status)\n        .describe(describeFlowsActorsStatus(\"The state this run moved into at `timestamp`. The list is the run's history, oldest first.\")),\n      timestamp: z.iso.datetime(),\n    })),\n  }).array(),\n\n  /**\n   * Overrides the base `errorItems` with the actor-execution-scoped variant\n   * (adds taskId/planStepId locators). Historically this extension used a\n   * divergent `errors` key coexisting with the base `errorItems` — aligned\n   * 2026-07-02 (meta-workflows Step 0 hygiene; the field had no consumers).\n   */\n  errorStates : FlowActorSystem_ErrorStates_Schema.extend({\n    errorItems: WildoError_BackendSchema.extend({\n      systemRef: z.string(),\n      taskId: z.string().optional(),\n      planStepId: z.string().optional(),\n    }).array().optional(),\n  }).optional(),\n});\nexport type ActorSystem_Execution = z.infer<typeof ActorSystem_ExecutionSchema>;\n"]}
+{"version":3,"file":"actors.shared.schemas.js","sourceRoot":"","sources":["../../../../src/flows-actors/actors.shared.schemas.ts"],"names":[],"mappings":"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","sourcesContent":["import { z } from \"zod\";\n\nimport { WildoError_BackendSchema } from \"../errors/errors.shared.schemas\";\nimport { FlowsActors_Status, describeFlowsActorsStatus } from \"./flows-actors.commons.shared.schemas\";\nimport { FlowActorSystem_BaseSchema, FlowActorSystem_ErrorStates_Schema, FlowActorSystem_ExecutionSchema, FlowActorSystem_Kind, } from \"./flows-actors.system.shared.schemas\";\nimport { Actors_Task_Schema, ActorsSystem_ExecutionPlan_Schema } from \"./tasks.actors.shared.schemas\";\nimport { HumanDecision_RequestSchema, HumanDecision_RequesterSchema, HumanDecision_ResolutionSchema, HumanDecision_RouteSchema } from \"./human-decision.shared.schemas\";\n\n\n//===============================================================\n//  Actor\n// --------\n// Actors are reactive components that subscribe to event topics\n// and respond with automated processing. They enable event-driven\n// architecture by processing messages asynchronously, supporting\n// batch processing, filtering, and various error handling strategies.\n// Actors can emit new events, creating event chains and workflows.\n//===============================================================\n\n\nexport enum Actor_Role_Category {\n  COORDINATOR = \"coordinator\",\n  TASK_PLANNER = \"task_planner\",\n  OPERATOR = \"operator\",\n  ANALYZER = \"analyzer\",\n  REVIEWER = \"reviewer\",\n  HUMAN_IN_THE_LOOP = \"human_in_the_loop\",\n  FLOW_EXECUTION = \"flow_execution\"\n}\n\n\n/**\n * HOW an actor does its work when the runtime drives it.\n *\n * `PROGRAMMATIC` (added 2026-09-20, #1358) is the mode of an actor whose behaviour is supplied by the\n * HOST as code rather than by an agent, a flow or a person: the execution driver opens the actor's\n * task, hands the opened identities to a host-supplied executor, and settles on its outcome. An actor\n * is not an agent — a methodology step run by the app-creation companion, or a deterministic check,\n * is an actor with no model behind it, and until this member existed such an actor had to borrow\n * `AGENTIC` without an `agentRef`, which is a lie the registry cannot see.\n *\n * `FLOW_EXECUTION` is a PLANNED member and stays (decided by Paul, 2026-09-21, #1363). The Flow\n * execution model is not implemented yet — `FlowsBackendService.executeFlow` refuses honestly — and\n * it is intended: an actor whose work is a declared flow is part of what this system is for. No\n * driver dispatches on this member today, so a reader sweep reports zero; that is the state of the\n * build, not a verdict on the member. Do not delete it, the Flow model, or `Actor_Role_Category`'s\n * matching member on that measurement.\n */\nexport enum Actor_ExecutionMode {\n  AGENTIC = \"agentic\",\n  FLOW_EXECUTION = \"flow_execution\",\n  HUMAN_INTERACTION = \"human_interaction\",\n  PROGRAMMATIC = \"programmatic\",\n}\n\nexport const ActorSchema = z.object({\n  ref: z.string().min(1),\n  displayName: z.string().min(1),\n  roleCategory: z.enum(Actor_Role_Category),\n  executionMode: z.enum(Actor_ExecutionMode),\n  agentRef: z.string().optional(),\n  flowRef: z.string().optional(),\n});\nexport type Actor = z.infer<typeof ActorSchema>;\n\n//===============================================================\n//  Actor System\n//===============================================================\n\n/**\n * The ACTOR specialization of the system base — the schema that OWNS a system's\n * actor list. `actors` is declared here and in no other system schema: the base\n * cannot declare it, because a FLOW system has no actors. (Unrelated `actors`\n * members exist on the TASK schemas; those point at one actor, they are not a\n * system's roster.)\n *\n * An actor system must therefore be parsed with this schema, or one derived\n * from it. Parsing one with `FlowActorSystem_BaseSchema` strips `actors`\n * silently — see the warning there.\n */\nexport const ActorSystemSchema = FlowActorSystem_BaseSchema.extend({\n  /**\n   * Narrows the inherited `kind` discriminant to ACTOR. The historical shape\n   * added a separate `type` field here while every consumer (backend registry,\n   * execution schemas, flows counterpart) discriminates on `kind` — fixed\n   * 2026-07-02 (meta-workflows Step 0 hygiene; no `.type` consumer existed).\n   */\n  kind: z.literal(FlowActorSystem_Kind.ACTOR),\n  actors: z.array(z.lazy(() => ActorSchema)),\n});\nexport type ActorSystem = z.infer<typeof ActorSystemSchema>;\n\n\n//===============================================================\n//  Actor System Execution\n//===============================================================\n\n/**\n * The human decision an execution is WAITING on — present exactly while its status is\n * `AWAITING_APPROVAL`, and cleared by the resume that answers it.\n *\n * Until #1360 three stores held this for three kinds of question (a checkpoint file for a mid-run\n * clarification, another for an interrupted composite, a task's `output.suspension` for a parked\n * coding question), projecting one `HumanDecision_Request` each — the payload was unified by #1269\n * and the storage was left where it was on the premise that a playbook run had no execution row.\n * #1343 removed that premise. The decision lives on the row the run already has.\n */\nexport const ActorExecution_SuspensionSchema = z.object({\n  decision: HumanDecision_RequestSchema,\n  suspendedAt: z.iso.datetime(),\n  /**\n   * WHO may settle this decision (#1594 D2) — the same shape the conversational plane stores in columns.\n   * Absent on a suspension whose host routes nothing: its own door is then the only authority over it,\n   * and the engine authorizes nothing it was not given a route for.\n   */\n  route: HumanDecision_RouteSchema.optional(),\n  /** The authority the run was raised under, and resumes under. Stamped beside `route`. */\n  requester: HumanDecision_RequesterSchema.optional(),\n  /**\n   * Bumped by every move of `route` (#1594 I5). The persistence port's compare-and-swap checks it, so an\n   * answer read under an older route loses. Written `0` with a route; absent when there is none.\n   */\n  routeVersion: z.number().int().nonnegative().optional(),\n  /**\n   * THIS suspension's identity, written once when the run suspends (#1581). A run may ask again after\n   * an answer, and its decision id names the RUN (hosts use their run or task id), so neither that nor\n   * an instant tells two questions of one run apart. An answer names the suspension it read, and a\n   * resume refuses one the run has moved past. Absent on a row written before it existed; such a\n   * suspension is named by its instant (`actorExecutionSuspensionRef` in the backend runtime).\n   */\n  suspensionId: z.string().min(1).optional(),\n});\nexport type ActorExecution_Suspension = z.infer<typeof ActorExecution_SuspensionSchema>;\n\n/**\n * What a run left behind so that whatever runs next can CONTINUE it — the host's resume inputs.\n *\n * `context` is opaque to the engine, exactly as `FlowsActors_Checkpoint.context` is: the engine owns\n * the slot and when it is written and read; the host that executes the work owns the content and\n * validates it at its own boundary. Written while a run progresses (so a run whose process is taken\n * away can be continued) and when a run suspends (so its resume can rebuild what it was doing).\n *\n * A checkpoint outliving its run is the ordinary signal of an INTERRUPTED run: the driver settles a\n * run whose host died `ABORTED` at the next startup and leaves this in place, so \"interrupted and\n * resumable\" is `ABORTED` with a checkpoint — a fact of the row, not a fourth status (#1360).\n */\nexport const ActorExecution_CheckpointSchema = z.object({\n  context: z.any(),\n  checkpointedAt: z.iso.datetime(),\n  /**\n   * The question a RESUMED run was answering, kept until the run moves past it.\n   *\n   * A resume clears `suspension` and moves the row to `PROCESSING`. When the host asked for a failed\n   * continuation to leave the question standing (`restoreSuspensionOnFailure`), a THROWN continuation\n   * is caught and the suspension restored. A continuation whose PROCESS dies throws nothing: the\n   * startup orphan sweep used to settle it `ABORTED`, and the person's answer went with it. Measured\n   * 2026-09-24 on a real domain-plan clarification: answered, resumed, and aborted 85 s later by a\n   * companion restart, which the dev loop performs every few minutes.\n   *\n   * So the resume writes the suspension here, and the sweep puts an orphan that carries one back to\n   * `AWAITING_APPROVAL` on the same question instead of aborting it. It lives on the CHECKPOINT\n   * because it is a resume input with the same lifetime: a host checkpoint written mid-run replaces\n   * the whole checkpoint and drops it (the run has moved past the question), a new suspension\n   * replaces it, and a settle that keeps the checkpoint strips it.\n   */\n  resumedSuspension: ActorExecution_SuspensionSchema.optional(),\n  /**\n   * How many continuations of the pending question DIED WITH THEIR PROCESS before this one (#1507).\n   *\n   * The startup sweep puts such a run back to waiting (see `resumedSuspension`), and nothing else\n   * remembers that a continuation ran: whatever it did and spent went with the process. Counted here so\n   * the host can say so — a playbook run records each as an unobserved part of its spend, so its total\n   * reads as a floor rather than as complete. Cleared once a host has accounted for them in the task's\n   * own record (a restored output after a thrown continuation), and whenever the run moves past the\n   * question: a new suspension replaces the checkpoint, a consuming settle clears it, and a settle that\n   * keeps it drops this count with `resumedSuspension`.\n   */\n  interruptedContinuations: z.number().int().positive().optional(),\n});\nexport type ActorExecution_Checkpoint = z.infer<typeof ActorExecution_CheckpointSchema>;\n\n\nexport const ActorSystem_ExecutionSchema = FlowActorSystem_ExecutionSchema.extend({\n  kind: z.literal(FlowActorSystem_Kind.ACTOR),\n\n  /** See {@link ActorExecution_SuspensionSchema}. `null` once answered; absent on a run that never asked. */\n  suspension: ActorExecution_SuspensionSchema.nullable().optional(),\n  /** See {@link ActorExecution_CheckpointSchema}. `null` once consumed; absent on a run that never wrote one. */\n  checkpoint: ActorExecution_CheckpointSchema.nullable().optional(),\n\n  /**\n   * What this execution runs EXCLUSIVELY — the subject of its single-flight lease (#1361).\n   *\n   * While an execution carrying a subject is `PENDING` or `PROCESSING`, the runtime refuses to open\n   * or resume another execution of the SAME system with the same subject. The lease IS the row: no\n   * second record says \"busy\", so nothing can disagree with what is actually running. A run that is\n   * waiting on a person (`AWAITING_APPROVAL`) does not hold it — it is not running — and a host's\n   * startup orphan sweep is what releases a lease whose holder died.\n   *\n   * Absent on the ordinary run, which excludes nothing. The subject's vocabulary is the opening\n   * domain's: the runtime compares it and never reads it.\n   *\n   * Until #1361 this principle was implemented three times in one consumer as in-memory flags, each\n   * of which a restart — or a second process — could not see.\n   */\n  exclusiveSubject: z.string().min(1).optional(),\n\n  /**\n   * The run's history, oldest first — as on every execution, plus the RESOLUTION of the decision a move\n   * ended (#1594 I4). The change that takes a run out of waiting carries how that wait ended, written in\n   * the same statement, so no second write can be lost between them. A decision that won and was then\n   * put back (the tasks could not follow) is followed by a change back to waiting: the history keeps what\n   * happened, and the latest change says where the run stands.\n   */\n  statusChanges: z.array(FlowActorSystem_ExecutionSchema.shape.statusChanges.element.extend({\n    resolution: HumanDecision_ResolutionSchema.optional(),\n  })),\n\n  plan: ActorsSystem_ExecutionPlan_Schema.optional(),\n  standaloneTasks: z.array(Actors_Task_Schema),\n\n  standaloneTaskStates: z.object({\n    taskId: z.string(),\n    status: z.enum(FlowsActors_Status),\n    updatedAt: z.iso.datetime(),\n    statusChanges: z.array(z.object({\n      status: z.enum(FlowsActors_Status)\n        .describe(describeFlowsActorsStatus(\"The state this run moved into at `timestamp`. The list is the run's history, oldest first.\")),\n      timestamp: z.iso.datetime(),\n    })),\n  }).array(),\n\n  /**\n   * Overrides the base `errorItems` with the actor-execution-scoped variant\n   * (adds taskId/planStepId locators). Historically this extension used a\n   * divergent `errors` key coexisting with the base `errorItems` — aligned\n   * 2026-07-02 (meta-workflows Step 0 hygiene; the field had no consumers).\n   */\n  errorStates : FlowActorSystem_ErrorStates_Schema.extend({\n    errorItems: WildoError_BackendSchema.extend({\n      systemRef: z.string(),\n      taskId: z.string().optional(),\n      planStepId: z.string().optional(),\n    }).array().optional(),\n  }).optional(),\n});\nexport type ActorSystem_Execution = z.infer<typeof ActorSystem_ExecutionSchema>;\n"]}

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

@@ -113,6 +113,10 @@ export declare const AgentCallTraceSchema: z.ZodObject<{
                 cacheReadTokens: z.ZodOptional<z.ZodNumber>;
                 cacheWriteTokens: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>>;
+            outputTokenDetails: z.ZodOptional<z.ZodObject<{
+                textTokens: z.ZodOptional<z.ZodNumber>;
+                reasoningTokens: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
         }, z.core.$strip>>;
         outputTracking: z.ZodOptional<z.ZodObject<{
             toolsUsed: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -203,6 +207,18 @@ export declare const AgentTraceContextSchema: z.ZodObject<{
     label: z.ZodOptional<z.ZodString>;
     attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     levelOverride: z.ZodOptional<z.ZodEnum<typeof AgentTraceabilityLevel>>;
+    attribution: z.ZodOptional<z.ZodObject<{
+        organizationId: z.ZodOptional<z.ZodString>;
+        caseRef: z.ZodOptional<z.ZodObject<{
+            resourceType: z.ZodString;
+            resourceId: z.ZodString;
+        }, z.core.$strict>>;
+        executionRef: z.ZodOptional<z.ZodObject<{
+            kind: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("./work-attribution.shared.schemas").ExecutionRefKind>>;
+            id: z.ZodString;
+        }, z.core.$strict>>;
+        taskRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
 }, z.core.$strip>;
 export type AgentTraceContext = z.infer<typeof AgentTraceContextSchema>;
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"agent-traceability.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/flows-actors/agent-traceability.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;;;;GAUG;AACH,oBAAY,sBAAsB;IAChC,IAAI,SAAS;IACb,KAAK,UAAU;IACf,aAAa,kBAAkB;CAChC;AAED,wEAAwE;AACxE,eAAO,MAAM,8BAA8B,EAAE,MAAM,CAAC,sBAAsB,EAAE,MAAM,CAIjF,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,WAAW,EAAE,sBAAsB,EACnC,YAAY,EAAE,sBAAsB,GACnC,OAAO,CAET;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACvC,CAAC,EAAE,sBAAsB,EACzB,CAAC,EAAE,sBAAsB,GACxB,sBAAsB,CAExB;AAED,4EAA4E;AAC5E,eAAO,MAAM,6BAA6B;;iBAExC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEpF,qDAAqD;AACrD,oBAAY,gBAAgB;IAC1B,OAAO,YAAY;IACnB,OAAO,YAAY;CACpB;AAED;;;;;;;;;;;;;;GAcG;AACH,oBAAY,kBAAkB;IAC5B,UAAU,eAAe;IACzB,SAAS,cAAc;CACxB;AAED;;;GAGG;AACH,eAAO,MAAM,yBAAyB;;;;iBAIpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4B/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB;;;;;;iBAWlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,cAAc,CAAC;IACtB,KAAK,EAAE,sBAAsB,CAAC;IAC9B,OAAO,CAAC,EAAE,iBAAiB,CAAC;CAC7B;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,kBAAkB;IACjC,eAAe,CAAC,QAAQ,EAAE,sBAAsB,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxE;;;;OAIG;IACH,QAAQ,CAAC,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnC"}
+{"version":3,"file":"agent-traceability.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/flows-actors/agent-traceability.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;;;;;;;GAUG;AACH,oBAAY,sBAAsB;IAChC,IAAI,SAAS;IACb,KAAK,UAAU;IACf,aAAa,kBAAkB;CAChC;AAED,wEAAwE;AACxE,eAAO,MAAM,8BAA8B,EAAE,MAAM,CAAC,sBAAsB,EAAE,MAAM,CAIjF,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,WAAW,EAAE,sBAAsB,EACnC,YAAY,EAAE,sBAAsB,GACnC,OAAO,CAET;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACvC,CAAC,EAAE,sBAAsB,EACzB,CAAC,EAAE,sBAAsB,GACxB,sBAAsB,CAExB;AAED,4EAA4E;AAC5E,eAAO,MAAM,6BAA6B;;iBAExC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEpF,qDAAqD;AACrD,oBAAY,gBAAgB;IAC1B,OAAO,YAAY;IACnB,OAAO,YAAY;CACpB;AAED;;;;;;;;;;;;;;GAcG;AACH,oBAAY,kBAAkB;IAC5B,UAAU,eAAe;IACzB,SAAS,cAAc;CACxB;AAED;;;GAGG;AACH,eAAO,MAAM,yBAAyB;;;;iBAIpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4B/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;iBAiBlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,cAAc,CAAC;IACtB,KAAK,EAAE,sBAAsB,CAAC;IAC9B,OAAO,CAAC,EAAE,iBAAiB,CAAC;CAC7B;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,kBAAkB;IACjC,eAAe,CAAC,QAAQ,EAAE,sBAAsB,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxE;;;;OAIG;IACH,QAAQ,CAAC,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnC"}

package/dist/esm/flows-actors/agent-traceability.shared.schemas.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { LLMProvider_OperationContext_BaseSchema } from '@wildo-ai/external-connectors-models';
+import { ModelCallAttributionInputSchema } from './work-attribution.shared.schemas.js';
 /**
  * Verbosity policy for engine-level agent-call traceability. Promotes the
  * companion's previously-local `WILDO_DEV_COMPANION_TRACEABILITY_LEVEL` to a
@@ -148,5 +149,11 @@ export const AgentTraceContextSchema = z.object({
     attributes: z.record(z.string(), z.unknown()).optional(),
     /** Per-call override of the engine policy level (else the engine default applies). */
     levelOverride: z.enum(AgentTraceabilityLevel).optional(),
+    /**
+     * Explicit work attribution for this call (#1598): tenant, case, execution and task. Wins over the
+     * ambient work frame. Deliberately a typed field and NOT part of `attributes`, which are free-form
+     * caller dimensions for telemetry and never reach the attribution store.
+     */
+    attribution: ModelCallAttributionInputSchema.optional(),
 });
 //# sourceMappingURL=agent-traceability.shared.schemas.js.map

package/dist/esm/flows-actors/agent-traceability.shared.schemas.js.map

@@ -1 +1 @@
-{"version":3,"file":"agent-traceability.shared.schemas.js","sourceRoot":"","sources":["../../../../src/flows-actors/agent-traceability.shared.schemas.ts"],"names":[],"mappings":"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","sourcesContent":["import { z } from 'zod';\nimport { LLMProvider_OperationContext_BaseSchema } from '@wildo-ai/external-connectors-models';\n\n/**\n * Verbosity policy for engine-level agent-call traceability. Promotes the\n * companion's previously-local `WILDO_DEV_COMPANION_TRACEABILITY_LEVEL` to a\n * shared engine contract so every agent caller (companion, backend runtime,\n * minions, workers) and every sink (filesystem, logger, OTel) speak the same\n * levels.\n *\n * - `NONE`          — tracing fully off; emitters must no-op before any I/O.\n * - `DEBUG`         — per-call metadata + token usage + latency (no payloads).\n * - `DEBUG_VERBOSE` — adds the resolved prompt input + raw output payloads.\n */\nexport enum AgentTraceabilityLevel {\n  NONE = 'NONE',\n  DEBUG = 'DEBUG',\n  DEBUG_VERBOSE = 'DEBUG_VERBOSE',\n}\n\n/** Numeric ordering for `AgentTraceabilityLevel` gating comparisons. */\nexport const AGENT_TRACEABILITY_LEVEL_ORDER: Record<AgentTraceabilityLevel, number> = {\n  [AgentTraceabilityLevel.NONE]: 0,\n  [AgentTraceabilityLevel.DEBUG]: 1,\n  [AgentTraceabilityLevel.DEBUG_VERBOSE]: 2,\n};\n\n/**\n * True when `activeLevel` is at least `minimumLevel` — the canonical gate every\n * sink/emitter uses so a record is persisted only when the active policy meets\n * the record's minimum verbosity.\n */\nexport function agentTraceabilityLevelAllows(\n  activeLevel: AgentTraceabilityLevel,\n  minimumLevel: AgentTraceabilityLevel,\n): boolean {\n  return AGENT_TRACEABILITY_LEVEL_ORDER[activeLevel] >= AGENT_TRACEABILITY_LEVEL_ORDER[minimumLevel];\n}\n\n/**\n * The more verbose of two levels — for hosts that COMPOSE traceability\n * concerns behind one policy binding. A host policy must never be LESS\n * verbose than any interested sink: a companion whose filesystem tracing is\n * off (`NONE`) but whose LLM-observability provider is active still needs\n * `DEBUG` so the emission reaches the sinks (each sink then self-gates).\n * Replacing a live policy with a static lower level silently kills every\n * downstream sink — the failure mode that motivated this helper.\n */\nexport function maxAgentTraceabilityLevel(\n  a: AgentTraceabilityLevel,\n  b: AgentTraceabilityLevel,\n): AgentTraceabilityLevel {\n  return AGENT_TRACEABILITY_LEVEL_ORDER[a] >= AGENT_TRACEABILITY_LEVEL_ORDER[b] ? a : b;\n}\n\n/** Engine-resolved traceability policy handed to `AgentsBackendService`. */\nexport const AgentTraceabilityPolicySchema = z.object({\n  level: z.enum(AgentTraceabilityLevel).default(AgentTraceabilityLevel.NONE),\n});\nexport type AgentTraceabilityPolicy = z.infer<typeof AgentTraceabilityPolicySchema>;\n\n/** Terminal outcome of a single agent invocation. */\nexport enum AgentCallOutcome {\n  SUCCESS = 'success',\n  FAILURE = 'failure',\n}\n\n/**\n * WHAT KIND of model call a trace records — the operation-aware axis observability sinks branch\n * on (RAG plan DL2/H4). The two kinds differ structurally, not cosmetically:\n *\n * - a GENERATION consumes prompt tokens and produces completion tokens; its usage is complete\n *   only when BOTH dimensions are present, and its payload (prompt/completion text) may be\n *   forwarded to analytics under an explicit content opt-in;\n * - an EMBEDDING consumes input tokens and produces VECTORS; it has no completion-token\n *   dimension (so completeness is judged on input tokens alone), and its output must NEVER\n *   reach analytics or logs at any verbosity — a vector is a lossy encoding of the source text,\n *   not telemetry. Producers put a `{ vectorCount, dims }` summary in `output`; sinks enforce\n *   the exclusion defensively on top.\n *\n * Absent means GENERATION (every pre-existing producer), so the field is additive.\n */\nexport enum AgentCallTraceKind {\n  GENERATION = 'generation',\n  EMBEDDING = 'embedding',\n}\n\n/**\n * Structured, JSON-serializable shape for a failed agent call. (Never the raw\n * `Error` object — it collapses to `{}` under `JSON.stringify`.)\n */\nexport const AgentCallTraceErrorSchema = z.object({\n  name: z.string().optional(),\n  message: z.string(),\n  code: z.string().optional(),\n});\nexport type AgentCallTraceError = z.infer<typeof AgentCallTraceErrorSchema>;\n\n/**\n * The typed per-call trace record the engine emits to the configured sink, once\n * per `invokeAgent` completion (success or failure). This is the contract that\n * replaces every caller's hand-rolled `response.executionContext as { usage?,\n * executionTime? }` cast + manual artifact write.\n *\n * - `context` reuses {@link LLMProvider_OperationContext_BaseSchema} — the exact\n *   telemetry envelope (`usage` / `executionTime` / `finishedAt` / `finishReason`\n *   / `transport` / `outputTracking`) that `invokeAgent` already assembles. No\n *   parallel shape, no drift.\n * - `input` / `output` are agent-specific and therefore opaque here; sinks\n *   persist them only at `DEBUG_VERBOSE` (payload gating is a sink concern).\n * - `attempt` lets a caller-side retry loop correlate multiple records for one\n *   logical generation: the engine traces each physical call; retry orchestration\n *   stays caller-side.\n */\nexport const AgentCallTraceSchema = z.object({\n  agentRef: z.string(),\n  /** See {@link AgentCallTraceKind}. Absent = `GENERATION` (the pre-existing producers). */\n  kind: z.enum(AgentCallTraceKind).optional(),\n  /**\n   * Resolved LLM vendor ref (e.g. `anthropic`, `openai`). Maps to analytics\n   * dimensions like PostHog `$ai_provider`. Optional — non-LLM/uncaptured calls omit it.\n   */\n  provider: z.string().optional(),\n  /**\n   * Resolved model id (e.g. `claude-opus-4-8`). Load-bearing for analytics sinks:\n   * PostHog derives `$ai_total_cost_usd` from `$ai_model` + token usage, so without\n   * it cost attribution is lost. Optional — populated for model-backed agent calls.\n   */\n  model: z.string().optional(),\n  /** ISO 8601 — when the call was initiated. */\n  callTimestamp: z.string(),\n  /** 1-based attempt index when the caller drives a retry loop. */\n  attempt: z.number().int().positive().optional(),\n  outcome: z.enum(AgentCallOutcome),\n  /** Resolved agent input (e.g. the prompt). Opaque; sink persists at DEBUG_VERBOSE. */\n  input: z.unknown().optional(),\n  /** Raw agent output. Opaque; sink persists at DEBUG_VERBOSE. */\n  output: z.unknown().optional(),\n  /** Telemetry the engine captured — token usage, latency, transport, finishReason. */\n  context: LLMProvider_OperationContext_BaseSchema.optional(),\n  /** Present on `FAILURE`. */\n  error: AgentCallTraceErrorSchema.optional(),\n});\nexport type AgentCallTrace = z.infer<typeof AgentCallTraceSchema>;\n\n/**\n * Caller-supplied correlation + enrichment, handed to `invokeAgent` so the\n * emitted {@link AgentCallTraceSchema} record can be routed and contextualized\n * by the sink.\n *\n * The engine does NOT interpret `sessionRef` / `stepRef` — they are opaque\n * handles the sink owns (e.g. the companion filesystem sink's session/step\n * directory ids). `attributes` carry caller domain context (templateRef,\n * locale, bucket, …) for filtering/grouping.\n */\nexport const AgentTraceContextSchema = z.object({\n  /** Opaque sink-owned session handle (groups many calls of one operation). */\n  sessionRef: z.string().optional(),\n  /** Opaque sink-owned step handle (one logical sub-operation within a session). */\n  stepRef: z.string().optional(),\n  /** Human-readable label (e.g. `email-template-generation:system.welcome_email`). */\n  label: z.string().optional(),\n  /** Caller domain attributes for filtering/grouping (templateRef, locale, …). */\n  attributes: z.record(z.string(), z.unknown()).optional(),\n  /** Per-call override of the engine policy level (else the engine default applies). */\n  levelOverride: z.enum(AgentTraceabilityLevel).optional(),\n});\nexport type AgentTraceContext = z.infer<typeof AgentTraceContextSchema>;\n\n/**\n * One agent-call trace emission handed to a sink: the typed per-call record, the\n * engine-resolved active level (never `NONE` — the engine skips emission at `NONE`),\n * and the caller's correlation/enrichment context. Bundled so sinks gain fields\n * without a signature change.\n */\nexport interface AgentCallTraceEmission {\n  trace: AgentCallTrace;\n  level: AgentTraceabilityLevel;\n  context?: AgentTraceContext;\n}\n\n/**\n * Pluggable destination for engine-level agent-call traces — the swappable output\n * side of `AgentsBackendService.invokeAgent` tracing (filesystem artifacts, structured\n * logs, 3rd-party LLM analytics, OTel spans, …).\n *\n * The interface lives in `saas-models` (not a backend package) so implementations can\n * live where their dependency belongs WITHOUT a dependency cycle: generic ones in\n * `saas-backend-lib` (NoOp / Logger / Composite), provider-specific ones in\n * `external-connectors-private` (e.g. the PostHog LLM-analytics sink, which owns\n * `posthog-node`), app-specific ones in the app (e.g. the companion filesystem sink).\n *\n * `recordAgentCall` MUST be best-effort: the engine wraps it so a sink failure never\n * turns a successful agent call into a failed one, and output is byte-identical when\n * traceability is off.\n */\nexport interface AgentCallTraceSink {\n  recordAgentCall(emission: AgentCallTraceEmission): void | Promise<void>;\n  /**\n   * Optional flush/cleanup, called best-effort on host shutdown. Implementations\n   * that batch + flush asynchronously (e.g. a 3rd-party analytics client) MUST drain\n   * here so short-lived processes (CLI / companion / minion) don't lose queued events.\n   */\n  shutdown?(): void | Promise<void>;\n}\n"]}
+{"version":3,"file":"agent-traceability.shared.schemas.js","sourceRoot":"","sources":["../../../../src/flows-actors/agent-traceability.shared.schemas.ts"],"names":[],"mappings":"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","sourcesContent":["import { z } from 'zod';\nimport { LLMProvider_OperationContext_BaseSchema } from '@wildo-ai/external-connectors-models';\nimport { ModelCallAttributionInputSchema } from './work-attribution.shared.schemas';\n\n/**\n * Verbosity policy for engine-level agent-call traceability. Promotes the\n * companion's previously-local `WILDO_DEV_COMPANION_TRACEABILITY_LEVEL` to a\n * shared engine contract so every agent caller (companion, backend runtime,\n * minions, workers) and every sink (filesystem, logger, OTel) speak the same\n * levels.\n *\n * - `NONE`          — tracing fully off; emitters must no-op before any I/O.\n * - `DEBUG`         — per-call metadata + token usage + latency (no payloads).\n * - `DEBUG_VERBOSE` — adds the resolved prompt input + raw output payloads.\n */\nexport enum AgentTraceabilityLevel {\n  NONE = 'NONE',\n  DEBUG = 'DEBUG',\n  DEBUG_VERBOSE = 'DEBUG_VERBOSE',\n}\n\n/** Numeric ordering for `AgentTraceabilityLevel` gating comparisons. */\nexport const AGENT_TRACEABILITY_LEVEL_ORDER: Record<AgentTraceabilityLevel, number> = {\n  [AgentTraceabilityLevel.NONE]: 0,\n  [AgentTraceabilityLevel.DEBUG]: 1,\n  [AgentTraceabilityLevel.DEBUG_VERBOSE]: 2,\n};\n\n/**\n * True when `activeLevel` is at least `minimumLevel` — the canonical gate every\n * sink/emitter uses so a record is persisted only when the active policy meets\n * the record's minimum verbosity.\n */\nexport function agentTraceabilityLevelAllows(\n  activeLevel: AgentTraceabilityLevel,\n  minimumLevel: AgentTraceabilityLevel,\n): boolean {\n  return AGENT_TRACEABILITY_LEVEL_ORDER[activeLevel] >= AGENT_TRACEABILITY_LEVEL_ORDER[minimumLevel];\n}\n\n/**\n * The more verbose of two levels — for hosts that COMPOSE traceability\n * concerns behind one policy binding. A host policy must never be LESS\n * verbose than any interested sink: a companion whose filesystem tracing is\n * off (`NONE`) but whose LLM-observability provider is active still needs\n * `DEBUG` so the emission reaches the sinks (each sink then self-gates).\n * Replacing a live policy with a static lower level silently kills every\n * downstream sink — the failure mode that motivated this helper.\n */\nexport function maxAgentTraceabilityLevel(\n  a: AgentTraceabilityLevel,\n  b: AgentTraceabilityLevel,\n): AgentTraceabilityLevel {\n  return AGENT_TRACEABILITY_LEVEL_ORDER[a] >= AGENT_TRACEABILITY_LEVEL_ORDER[b] ? a : b;\n}\n\n/** Engine-resolved traceability policy handed to `AgentsBackendService`. */\nexport const AgentTraceabilityPolicySchema = z.object({\n  level: z.enum(AgentTraceabilityLevel).default(AgentTraceabilityLevel.NONE),\n});\nexport type AgentTraceabilityPolicy = z.infer<typeof AgentTraceabilityPolicySchema>;\n\n/** Terminal outcome of a single agent invocation. */\nexport enum AgentCallOutcome {\n  SUCCESS = 'success',\n  FAILURE = 'failure',\n}\n\n/**\n * WHAT KIND of model call a trace records — the operation-aware axis observability sinks branch\n * on (RAG plan DL2/H4). The two kinds differ structurally, not cosmetically:\n *\n * - a GENERATION consumes prompt tokens and produces completion tokens; its usage is complete\n *   only when BOTH dimensions are present, and its payload (prompt/completion text) may be\n *   forwarded to analytics under an explicit content opt-in;\n * - an EMBEDDING consumes input tokens and produces VECTORS; it has no completion-token\n *   dimension (so completeness is judged on input tokens alone), and its output must NEVER\n *   reach analytics or logs at any verbosity — a vector is a lossy encoding of the source text,\n *   not telemetry. Producers put a `{ vectorCount, dims }` summary in `output`; sinks enforce\n *   the exclusion defensively on top.\n *\n * Absent means GENERATION (every pre-existing producer), so the field is additive.\n */\nexport enum AgentCallTraceKind {\n  GENERATION = 'generation',\n  EMBEDDING = 'embedding',\n}\n\n/**\n * Structured, JSON-serializable shape for a failed agent call. (Never the raw\n * `Error` object — it collapses to `{}` under `JSON.stringify`.)\n */\nexport const AgentCallTraceErrorSchema = z.object({\n  name: z.string().optional(),\n  message: z.string(),\n  code: z.string().optional(),\n});\nexport type AgentCallTraceError = z.infer<typeof AgentCallTraceErrorSchema>;\n\n/**\n * The typed per-call trace record the engine emits to the configured sink, once\n * per `invokeAgent` completion (success or failure). This is the contract that\n * replaces every caller's hand-rolled `response.executionContext as { usage?,\n * executionTime? }` cast + manual artifact write.\n *\n * - `context` reuses {@link LLMProvider_OperationContext_BaseSchema} — the exact\n *   telemetry envelope (`usage` / `executionTime` / `finishedAt` / `finishReason`\n *   / `transport` / `outputTracking`) that `invokeAgent` already assembles. No\n *   parallel shape, no drift.\n * - `input` / `output` are agent-specific and therefore opaque here; sinks\n *   persist them only at `DEBUG_VERBOSE` (payload gating is a sink concern).\n * - `attempt` lets a caller-side retry loop correlate multiple records for one\n *   logical generation: the engine traces each physical call; retry orchestration\n *   stays caller-side.\n */\nexport const AgentCallTraceSchema = z.object({\n  agentRef: z.string(),\n  /** See {@link AgentCallTraceKind}. Absent = `GENERATION` (the pre-existing producers). */\n  kind: z.enum(AgentCallTraceKind).optional(),\n  /**\n   * Resolved LLM vendor ref (e.g. `anthropic`, `openai`). Maps to analytics\n   * dimensions like PostHog `$ai_provider`. Optional — non-LLM/uncaptured calls omit it.\n   */\n  provider: z.string().optional(),\n  /**\n   * Resolved model id (e.g. `claude-opus-4-8`). Load-bearing for analytics sinks:\n   * PostHog derives `$ai_total_cost_usd` from `$ai_model` + token usage, so without\n   * it cost attribution is lost. Optional — populated for model-backed agent calls.\n   */\n  model: z.string().optional(),\n  /** ISO 8601 — when the call was initiated. */\n  callTimestamp: z.string(),\n  /** 1-based attempt index when the caller drives a retry loop. */\n  attempt: z.number().int().positive().optional(),\n  outcome: z.enum(AgentCallOutcome),\n  /** Resolved agent input (e.g. the prompt). Opaque; sink persists at DEBUG_VERBOSE. */\n  input: z.unknown().optional(),\n  /** Raw agent output. Opaque; sink persists at DEBUG_VERBOSE. */\n  output: z.unknown().optional(),\n  /** Telemetry the engine captured — token usage, latency, transport, finishReason. */\n  context: LLMProvider_OperationContext_BaseSchema.optional(),\n  /** Present on `FAILURE`. */\n  error: AgentCallTraceErrorSchema.optional(),\n});\nexport type AgentCallTrace = z.infer<typeof AgentCallTraceSchema>;\n\n/**\n * Caller-supplied correlation + enrichment, handed to `invokeAgent` so the\n * emitted {@link AgentCallTraceSchema} record can be routed and contextualized\n * by the sink.\n *\n * The engine does NOT interpret `sessionRef` / `stepRef` — they are opaque\n * handles the sink owns (e.g. the companion filesystem sink's session/step\n * directory ids). `attributes` carry caller domain context (templateRef,\n * locale, bucket, …) for filtering/grouping.\n */\nexport const AgentTraceContextSchema = z.object({\n  /** Opaque sink-owned session handle (groups many calls of one operation). */\n  sessionRef: z.string().optional(),\n  /** Opaque sink-owned step handle (one logical sub-operation within a session). */\n  stepRef: z.string().optional(),\n  /** Human-readable label (e.g. `email-template-generation:system.welcome_email`). */\n  label: z.string().optional(),\n  /** Caller domain attributes for filtering/grouping (templateRef, locale, …). */\n  attributes: z.record(z.string(), z.unknown()).optional(),\n  /** Per-call override of the engine policy level (else the engine default applies). */\n  levelOverride: z.enum(AgentTraceabilityLevel).optional(),\n  /**\n   * Explicit work attribution for this call (#1598): tenant, case, execution and task. Wins over the\n   * ambient work frame. Deliberately a typed field and NOT part of `attributes`, which are free-form\n   * caller dimensions for telemetry and never reach the attribution store.\n   */\n  attribution: ModelCallAttributionInputSchema.optional(),\n});\nexport type AgentTraceContext = z.infer<typeof AgentTraceContextSchema>;\n\n/**\n * One agent-call trace emission handed to a sink: the typed per-call record, the\n * engine-resolved active level (never `NONE` — the engine skips emission at `NONE`),\n * and the caller's correlation/enrichment context. Bundled so sinks gain fields\n * without a signature change.\n */\nexport interface AgentCallTraceEmission {\n  trace: AgentCallTrace;\n  level: AgentTraceabilityLevel;\n  context?: AgentTraceContext;\n}\n\n/**\n * Pluggable destination for engine-level agent-call traces — the swappable output\n * side of `AgentsBackendService.invokeAgent` tracing (filesystem artifacts, structured\n * logs, 3rd-party LLM analytics, OTel spans, …).\n *\n * The interface lives in `saas-models` (not a backend package) so implementations can\n * live where their dependency belongs WITHOUT a dependency cycle: generic ones in\n * `saas-backend-lib` (NoOp / Logger / Composite), provider-specific ones in\n * `external-connectors-private` (e.g. the PostHog LLM-analytics sink, which owns\n * `posthog-node`), app-specific ones in the app (e.g. the companion filesystem sink).\n *\n * `recordAgentCall` MUST be best-effort: the engine wraps it so a sink failure never\n * turns a successful agent call into a failed one, and output is byte-identical when\n * traceability is off.\n */\nexport interface AgentCallTraceSink {\n  recordAgentCall(emission: AgentCallTraceEmission): void | Promise<void>;\n  /**\n   * Optional flush/cleanup, called best-effort on host shutdown. Implementations\n   * that batch + flush asynchronously (e.g. a 3rd-party analytics client) MUST drain\n   * here so short-lived processes (CLI / companion / minion) don't lose queued events.\n   */\n  shutdown?(): void | Promise<void>;\n}\n"]}

package/dist/esm/flows-actors/agent-work-decisions.shared.resources-config.schemas.d.ts

@@ -0,0 +1,68 @@
+import { CoreResourceOperation } from '../resources/resources.shared.core.definitions';
+import { type ResourceRelationship } from '../resources/resources.shared.schemas';
+/** `userAgentWorkDecisions` / `organizationAgentWorkDecisions` / `applicationAgentWorkDecisions`. */
+export declare const agentWorkDecisionsPolymorphicFactories: Record<string, import("..").ResourceConfiguration_InitializationFactory<undefined, CoreResourceOperation.READ | CoreResourceOperation.UPDATE_MANY | CoreResourceOperation.DELETE | CoreResourceOperation.CREATE | CoreResourceOperation.LIST, any>>;
+/** `userAgentWorkDecisionContents` / `organizationAgentWorkDecisionContents` / `applicationAgentWorkDecisionContents`. */
+export declare const agentWorkDecisionContentsPolymorphicFactories: Record<string, import("..").ResourceConfiguration_InitializationFactory<undefined, CoreResourceOperation.READ | CoreResourceOperation.UPDATE_MANY | CoreResourceOperation.DELETE | CoreResourceOperation.CREATE | CoreResourceOperation.LIST, any>>;
+type OrganizationSettingCoreOperations = CoreResourceOperation.READ | CoreResourceOperation.CREATE | CoreResourceOperation.UPDATE | CoreResourceOperation.DELETE;
+/**
+ * assurance-control: WILDO.PRIVACY.DATA_MINIMIZATION — content capture is off unless the organization turns it on,
+ * with a stated purpose; every change is audited.
+ */
+export declare const agentWorkCaptureSettingsResourceConfiguration_InitializationFactory: (resourcesRelationships: ResourceRelationship[]) => import("..").ResourceConfiguration<undefined, OrganizationSettingCoreOperations, import("zod").ZodObject<{
+    _id: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodString>>;
+    organizationId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodString>>>>>;
+    contentCapture: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodDefault<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodEnum<typeof import("./agent-work-decisions.shared.schemas").CorrectionContentCapture>>>>;
+    purpose: import("zod").ZodOptional<import("zod").ZodString>;
+    contentReaderRole: import("zod").ZodOptional<import("zod").ZodString>;
+    narrowToCaseRefs: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+        resourceType: import("zod").ZodString;
+        resourceId: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>>>;
+    createdAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodDefault<import("zod").ZodDate>>>;
+    updatedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodDefault<import("zod").ZodDate>>>;
+}, import("zod/v4/core").$strip>>;
+/** assurance-control: WILDO.PRIVACY.COLLECTION_DATA_EXPORT — no export without a recorded basis; every change audited. */
+export declare const evaluationExportAuthorizationsResourceConfiguration_InitializationFactory: (resourcesRelationships: ResourceRelationship[]) => import("..").ResourceConfiguration<undefined, OrganizationSettingCoreOperations, import("zod").ZodObject<{
+    _id: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodString>>;
+    organizationId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodString>>>>>;
+    status: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodDefault<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodEnum<typeof import("./agent-work-decisions.shared.schemas").EvaluationExportAuthorizationStatus>>>>;
+    basis: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodEnum<typeof import("./agent-work-decisions.shared.schemas").EvaluationExportBasis>>>>;
+    basisReference: import("zod").ZodOptional<import("zod").ZodString>;
+    clientConsents: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+        caseRef: import("zod").ZodObject<{
+            resourceType: import("zod").ZodString;
+            resourceId: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+        consentRef: import("zod").ZodString;
+        recordedAt: import("zod").ZodISODateTime;
+    }, import("zod/v4/core").$strict>>>;
+    excludedCaseRefs: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+        resourceType: import("zod").ZodString;
+        resourceId: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>>>;
+    createdAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodDefault<import("zod").ZodDate>>>;
+    updatedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodDefault<import("zod").ZodDate>>>;
+}, import("zod/v4/core").$strip>>;
+/** The export ledger: written by the engine at each export, read by the organization administrator. */
+export declare const evaluationDatasetExportsResourceConfiguration_InitializationFactory: (resourcesRelationships: ResourceRelationship[]) => import("..").ResourceConfiguration<undefined, CoreResourceOperation.READ | CoreResourceOperation.UPDATE_MANY | CoreResourceOperation.DELETE | CoreResourceOperation.CREATE | CoreResourceOperation.LIST, import("zod").ZodObject<{
+    _id: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodString>>;
+    organizationId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodString>>>>;
+    exportedByUserId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodOptional<import("zod").ZodString>>;
+    exportedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodDate>>;
+    authorizationId: import("zod").ZodString;
+    basis: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodEnum<typeof import("./agent-work-decisions.shared.schemas").EvaluationExportBasis>>;
+    agentRef: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodString>;
+    windowFrom: import("zod").ZodDate;
+    windowTo: import("zod").ZodDate;
+    decisionRefs: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+    caseKeys: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+    recordCount: import("zod").ZodNumber;
+    pseudonymisationVersion: import("zod").ZodString;
+    destination: import("zod").ZodString;
+    invalidatedAt: import("zod").ZodOptional<import("zod").ZodDate>;
+    invalidationReason: import("zod").ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodEnum<typeof import("./agent-work-decisions.shared.schemas").EvaluationDatasetInvalidationReason>>>;
+    createdAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodDefault<import("zod").ZodDate>>>;
+}, import("zod/v4/core").$strip>>;
+export {};
+//# sourceMappingURL=agent-work-decisions.shared.resources-config.schemas.d.ts.map

package/dist/esm/flows-actors/agent-work-decisions.shared.resources-config.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-work-decisions.shared.resources-config.schemas.d.ts","sourceRoot":"","sources":["../../../../src/flows-actors/agent-work-decisions.shared.resources-config.schemas.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,qBAAqB,EAAwD,MAAM,gDAAgD,CAAC;AAC7I,OAAO,EAA4D,KAAK,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAmC5I,qGAAqG;AACrG,eAAO,MAAM,sCAAsC,qPAgDlD,CAAC;AAEF,0HAA0H;AAC1H,eAAO,MAAM,6CAA6C,qPAmDzD,CAAC;AAGF,KAAK,iCAAiC,GAAG,qBAAqB,CAAC,IAAI,GAAG,qBAAqB,CAAC,MAAM,GAAG,qBAAqB,CAAC,MAAM,GAAG,qBAAqB,CAAC,MAAM,CAAC;AAQjK;;;GAGG;AACH,eAAO,MAAM,mEAAmE,GAAI,wBAAwB,oBAAoB,EAAE;;;;;;;;;;;;iCAqC9H,CAAC;AAEL,0HAA0H;AAC1H,eAAO,MAAM,yEAAyE,GAAI,wBAAwB,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;iCAiCpI,CAAC;AAEL,uGAAuG;AACvG,eAAO,MAAM,mEAAmE,GAAI,wBAAwB,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;iCAmD9H,CAAC"}