@wildo-ai/platform-core-shared 1.1.10 → 1.1.11

package/dist/esm/wildo-application-executions/wildo-application-executions.custom.shared.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wildo-application-executions.custom.shared.schemas.d.ts","sourceRoot":"","sources":["../../../src/wildo-application-executions/wildo-application-executions.custom.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAGL,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAK/B;;;GAGG;AACH,eAAO,MAAM,8CAA8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMzD,CAAC;AACH,MAAM,MAAM,uCAAuC,GACjD,CAAC,CAAC,KAAK,CAAC,OAAO,8CAA8C,CAAC,CAAC;AAEjE;;;GAGG;AACH,eAAO,MAAM,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMxD,CAAC;AACH,MAAM,MAAM,sCAAsC,GAChD,CAAC,CAAC,KAAK,CAAC,OAAO,6CAA6C,CAAC,CAAC"}
+{"version":3,"file":"wildo-application-executions.custom.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/wildo-application-executions/wildo-application-executions.custom.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAGL,kBAAkB,EAElB,KAAK,gBAAgB,EACtB,MAAM,uBAAuB,CAAC;AA6B/B;;;;;;GAMG;AACH,eAAO,MAAM,iCAAiC,EAAE,SAAS,gBAAgB,EAA+B,CAAC;AAgBzG;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,8CAA8C,EAAE,SAAS,gBAAgB,EAWrF,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,8CAA8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqBzD,CAAC;AACH,MAAM,MAAM,uCAAuC,GACjD,CAAC,CAAC,KAAK,CAAC,OAAO,8CAA8C,CAAC,CAAC;AAEjE;;;;GAIG;AACH,eAAO,MAAM,6CAA6C,EAAE,SAAS,gBAAgB,EAA2C,CAAC;AAEjI;;;GAGG;AACH,eAAO,MAAM,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAaxD,CAAC;AACH,MAAM,MAAM,sCAAsC,GAChD,CAAC,CAAC,KAAK,CAAC,OAAO,6CAA6C,CAAC,CAAC"}

package/dist/esm/wildo-application-executions/wildo-application-executions.custom.shared.schemas.js

@@ -1,7 +1,85 @@
 import { z } from 'zod';
-import { ActorSystem_ExecutionSchema, FlowSystem_Execution_Schema, FlowsActors_Status, } from '@wildo-ai/saas-models';
+import { ActorSystem_ExecutionSchema, FlowSystem_Execution_Schema, FlowsActors_Status, forwardedUserNameDirectory, } from '@wildo-ai/saas-models';
 import { initZodDecorators } from '@wildo-ai/zod-decorators';
 initZodDecorators(z);
+/**
+ * A persisted run's INSTANTS, as dates (#2187).
+ *
+ * The canonical execution schema (`FlowActorSystem_ExecutionSchema`) carries `createdAt` /
+ * `updatedAt` / `finishedAt` as ISO strings, which is right for the in-memory and wire form and
+ * wrong for a stored row: the PostgreSQL planner maps every string to `text`, so the platform
+ * stored these as text holding a LOCAL offset (`2026-10-01T16:26:43.497+02:00`, 381 rows measured),
+ * and every newest-first listing sorted the strings. String order is time order only while every
+ * value has the same offset — not across a daylight-saving change, nor between hosts in different
+ * zones. As dates they plan `timestamptz` and compare as instants. The engine's own persisted
+ * execution schemas declare the same fields as `z.date()` for the same reason.
+ *
+ * Only the persisted row changes. The wire (the companion's HTTP contracts, the in-memory runtime)
+ * keeps ISO strings; the companion's executions service converts at its persistence boundary.
+ *
+ * `updatedAt` is indexed: the companion's listing reads the newest rows of an application by it
+ * (#2186), and without the index PostgreSQL sorts every row of the application to return a page.
+ */
+const PersistedExecutionInstants = {
+    createdAt: z.date(),
+    updatedAt: z.date().isDBIndexed(),
+    finishedAt: z.date().optional(),
+};
+/**
+ * Where a run record's execution-context initiators name a PERSON (#2823), on every control-plane run record (an actor
+ * run, a flow run, a task): the one who started it (`initiator`), and the one whose request each error item records
+ * (`errorStates.errorItems[].initiatorIds`). In each, `userId` is the signed-in person and `inboundScopeUserId` the
+ * person an inbound delivery belongs to; both are user ids. The initiator's other ids (an organization, an application,
+ * a credential, an anonymous visitor, a delivery) are not people with a profile, and are left as recorded.
+ */
+export const RUN_RECORD_INITIATOR_PERSON_PATHS = initiatorPersonPathsAt('');
+/**
+ * The initiator person paths of a record nested at `prefix` (`''` for the record itself): a run's plan and each of its
+ * standalone tasks carry an initiator and error items of their own, of the same shape.
+ */
+function initiatorPersonPathsAt(prefix) {
+    const at = (path) => (prefix ? `${prefix}.${path}` : path);
+    return [
+        at('initiator.userId'),
+        at('initiator.inboundScopeUserId'),
+        at('errorStates.errorItems[].initiatorIds.userId'),
+        at('errorStates.errorItems[].initiatorIds.inboundScopeUserId'),
+    ];
+}
+/**
+ * Every place an actor run's schema types a PERSON by user id below its top level (#2823), named by the run's
+ * `userNames`:
+ *
+ * - who started it, and whose request each error item records ({@link RUN_RECORD_INITIATOR_PERSON_PATHS}), on the run
+ *   itself, on its plan (`plan.`) and on each standalone task it carries (`standaloneTasks[].`);
+ * - who decided each decision the run waited on (`statusChanges[].resolution.decidedByUserId`);
+ * - for the question the run is waiting on, and for the one a resume is answering (`checkpoint.resumedSuspension`): the
+ *   person it was raised for (`requester.ref`) and the person it is assigned to (`route.assigneeUserId`);
+ * - for a settled review whose agent-work record is still owed (`pendingCorrectionRecord`): who decided it
+ *   (`deciderUserId`) and the person whose work it was, when the work was a person's (`owner.userId`; the owner is an
+ *   organization or an application otherwise, which this path does not reach).
+ *
+ * `requester.ref` is a CREDENTIAL id when the requester is a machine. No profile carries a credential id, so the
+ * directory names nothing there and the id stays as recorded, which is what a machine's reference should show.
+ *
+ * Not walked, because they are not typed: the free-form `checkpoint.context`, a task's `input`, `output` and `memory`.
+ * Not people: a task's correlation refs, a plan step's relationships, an organization unit.
+ *
+ * A display that shows these ids reads this list too (`nameUserIdsAtPaths`), so a person is named where their id was
+ * by the same statement that made the backend look them up.
+ */
+export const WILDO_APPLICATION_ACTOR_EXECUTION_PERSON_PATHS = [
+    ...RUN_RECORD_INITIATOR_PERSON_PATHS,
+    'statusChanges[].resolution.decidedByUserId',
+    'suspension.requester.ref',
+    'suspension.route.assigneeUserId',
+    'checkpoint.resumedSuspension.requester.ref',
+    'checkpoint.resumedSuspension.route.assigneeUserId',
+    'pendingCorrectionRecord.deciderUserId',
+    'pendingCorrectionRecord.owner.userId',
+    ...initiatorPersonPathsAt('plan'),
+    ...initiatorPersonPathsAt('standaloneTasks[]'),
+];
 /**
  * Platform-owned actor executions are persisted in the apps-manager database but
  * stay explicitly attached to the owning Wildo application row.
@@ -12,7 +90,28 @@ export const Wildo_Application_ActorSystem_Execution_Schema = ActorSystem_Execut
     wildoApplicationId: z.string().isDBIndexed().isForeignKey().isSummaryField().excludeFromUpdate(),
     systemRef: z.string().min(1).isDBIndexed().isSummaryField(),
     status: z.enum(FlowsActors_Status).systemEnum('FlowsActors_Status').isDBIndexed().isSummaryField(),
+    ...PersistedExecutionInstants,
+    /**
+     * The people this run records, by name (#2823): user id → their profile's first and last name, for every id at
+     * {@link WILDO_APPLICATION_ACTOR_EXECUTION_PERSON_PATHS}. Virtual: resolved when the run is read, never stored, so no
+     * column and no migration; an erased person reads as their profile now does (hidden, or masked), never by the name
+     * they had. No email fallback.
+     *
+     * WHO MAY BE TOLD: whoever may READ the run, i.e. a member of the organization that owns it (`ORG_MEMBER`, see the
+     * resource configuration). The people it names acted on this application's runs in that organization: the companion's
+     * signed-in operators who started a run, were asked by it, or decided for it. Their names are what the organization's
+     * own member list already tells its members, and nothing more (no email, no role).
+     *
+     * Not a summary field: only a run's own page shows its decisions and its question, so a LIST pays no profile read.
+     */
+    userNames: forwardedUserNameDirectory({ paths: WILDO_APPLICATION_ACTOR_EXECUTION_PERSON_PATHS }),
 });
+/**
+ * Every place a flow run's schema types a PERSON by user id below its top level (#2823): its initiators only. A flow
+ * run's history carries no decision, so it has no decider, and its nodes are references to the flow's own steps (a
+ * step's `toUserId` is a value reference the step resolves, never stored on the run).
+ */
+export const WILDO_APPLICATION_FLOW_EXECUTION_PERSON_PATHS = [...RUN_RECORD_INITIATOR_PERSON_PATHS];
 /**
  * Flow executions follow the same platform ownership chain as actor executions:
  * org-scoped in the apps-manager DB and child-linked to a single Wildo app.
@@ -23,5 +122,12 @@ export const Wildo_Application_FlowSystem_Execution_Schema = FlowSystem_Executio
     wildoApplicationId: z.string().isDBIndexed().isForeignKey().isSummaryField().excludeFromUpdate(),
     systemRef: z.string().min(1).isDBIndexed().isSummaryField(),
     status: z.enum(FlowsActors_Status).systemEnum('FlowsActors_Status').isDBIndexed().isSummaryField(),
+    ...PersistedExecutionInstants,
+    /**
+     * The people this flow run records, by name (#2823), at {@link WILDO_APPLICATION_FLOW_EXECUTION_PERSON_PATHS}. The
+     * actor run's `userNames` explains the field and its disclosure; the same reader (an organization member) is told the
+     * same thing (a profile name) about the same people (the companion's operators of this application).
+     */
+    userNames: forwardedUserNameDirectory({ paths: WILDO_APPLICATION_FLOW_EXECUTION_PERSON_PATHS }),
 });
 //# sourceMappingURL=wildo-application-executions.custom.shared.schemas.js.map

package/dist/esm/wildo-application-executions/wildo-application-executions.custom.shared.schemas.js.map

@@ -1 +1 @@
-{"version":3,"file":"wildo-application-executions.custom.shared.schemas.js","sourceRoot":"","sources":["../../../../src/wildo-application-executions/wildo-application-executions.custom.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EACL,2BAA2B,EAC3B,2BAA2B,EAC3B,kBAAkB,GACnB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D,iBAAiB,CAAC,CAAC,CAAC,CAAC;AAErB;;;GAGG;AACH,MAAM,CAAC,MAAM,8CAA8C,GAAG,2BAA2B,CAAC,MAAM,CAAC;IAC/F,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY,EAAE,CAAC,cAAc,EAAE;IACtD,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,CAAC,YAAY,EAAE,CAAC,cAAc,EAAE,CAAC,iBAAiB,EAAE;IAC5F,kBAAkB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,CAAC,YAAY,EAAE,CAAC,cAAc,EAAE,CAAC,iBAAiB,EAAE;IAChG,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,cAAc,EAAE;IAC3D,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,UAAU,CAAC,oBAAoB,CAAC,CAAC,WAAW,EAAE,CAAC,cAAc,EAAE;CACnG,CAAC,CAAC;AAIH;;;GAGG;AACH,MAAM,CAAC,MAAM,6CAA6C,GAAG,2BAA2B,CAAC,MAAM,CAAC;IAC9F,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY,EAAE,CAAC,cAAc,EAAE;IACtD,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,CAAC,YAAY,EAAE,CAAC,cAAc,EAAE,CAAC,iBAAiB,EAAE;IAC5F,kBAAkB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,CAAC,YAAY,EAAE,CAAC,cAAc,EAAE,CAAC,iBAAiB,EAAE;IAChG,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,cAAc,EAAE;IAC3D,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,UAAU,CAAC,oBAAoB,CAAC,CAAC,WAAW,EAAE,CAAC,cAAc,EAAE;CACnG,CAAC,CAAC","sourcesContent":["import { z } from 'zod';\nimport {\n  ActorSystem_ExecutionSchema,\n  FlowSystem_Execution_Schema,\n  FlowsActors_Status,\n} from '@wildo-ai/saas-models';\nimport { initZodDecorators } from '@wildo-ai/zod-decorators';\n\ninitZodDecorators(z);\n\n/**\n * Platform-owned actor executions are persisted in the apps-manager database but\n * stay explicitly attached to the owning Wildo application row.\n */\nexport const Wildo_Application_ActorSystem_Execution_Schema = ActorSystem_ExecutionSchema.extend({\n  _id: z.string().min(1).isPrimaryKey().isSummaryField(),\n  organizationId: z.string().isDBIndexed().isForeignKey().isSummaryField().excludeFromUpdate(),\n  wildoApplicationId: z.string().isDBIndexed().isForeignKey().isSummaryField().excludeFromUpdate(),\n  systemRef: z.string().min(1).isDBIndexed().isSummaryField(),\n  status: z.enum(FlowsActors_Status).systemEnum('FlowsActors_Status').isDBIndexed().isSummaryField(),\n});\nexport type Wildo_Application_ActorSystem_Execution =\n  z.infer<typeof Wildo_Application_ActorSystem_Execution_Schema>;\n\n/**\n * Flow executions follow the same platform ownership chain as actor executions:\n * org-scoped in the apps-manager DB and child-linked to a single Wildo app.\n */\nexport const Wildo_Application_FlowSystem_Execution_Schema = FlowSystem_Execution_Schema.extend({\n  _id: z.string().min(1).isPrimaryKey().isSummaryField(),\n  organizationId: z.string().isDBIndexed().isForeignKey().isSummaryField().excludeFromUpdate(),\n  wildoApplicationId: z.string().isDBIndexed().isForeignKey().isSummaryField().excludeFromUpdate(),\n  systemRef: z.string().min(1).isDBIndexed().isSummaryField(),\n  status: z.enum(FlowsActors_Status).systemEnum('FlowsActors_Status').isDBIndexed().isSummaryField(),\n});\nexport type Wildo_Application_FlowSystem_Execution =\n  z.infer<typeof Wildo_Application_FlowSystem_Execution_Schema>;\n"]}
+{"version":3,"file":"wildo-application-executions.custom.shared.schemas.js","sourceRoot":"","sources":["../../../../src/wildo-application-executions/wildo-application-executions.custom.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EACL,2BAA2B,EAC3B,2BAA2B,EAC3B,kBAAkB,EAClB,0BAA0B,GAE3B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D,iBAAiB,CAAC,CAAC,CAAC,CAAC;AAErB;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,0BAA0B,GAAG;IACjC,SAAS,EAAE,CAAC,CAAC,IAAI,EAAE;IACnB,SAAS,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE;IACjC,UAAU,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE;CAChC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,iCAAiC,GAAgC,sBAAsB,CAAC,EAAE,CAAC,CAAC;AAEzG;;;GAGG;AACH,SAAS,sBAAsB,CAAC,MAAc;IAC5C,MAAM,EAAE,GAAG,CAAC,IAAY,EAAoB,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IACrF,OAAO;QACL,EAAE,CAAC,kBAAkB,CAAC;QACtB,EAAE,CAAC,8BAA8B,CAAC;QAClC,EAAE,CAAC,8CAA8C,CAAC;QAClD,EAAE,CAAC,0DAA0D,CAAC;KAC/D,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,8CAA8C,GAAgC;IACzF,GAAG,iCAAiC;IACpC,4CAA4C;IAC5C,0BAA0B;IAC1B,iCAAiC;IACjC,4CAA4C;IAC5C,mDAAmD;IACnD,uCAAuC;IACvC,sCAAsC;IACtC,GAAG,sBAAsB,CAAC,MAAM,CAAC;IACjC,GAAG,sBAAsB,CAAC,mBAAmB,CAAC;CAC/C,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,8CAA8C,GAAG,2BAA2B,CAAC,MAAM,CAAC;IAC/F,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY,EAAE,CAAC,cAAc,EAAE;IACtD,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,CAAC,YAAY,EAAE,CAAC,cAAc,EAAE,CAAC,iBAAiB,EAAE;IAC5F,kBAAkB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,CAAC,YAAY,EAAE,CAAC,cAAc,EAAE,CAAC,iBAAiB,EAAE;IAChG,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,cAAc,EAAE;IAC3D,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,UAAU,CAAC,oBAAoB,CAAC,CAAC,WAAW,EAAE,CAAC,cAAc,EAAE;IAClG,GAAG,0BAA0B;IAC7B;;;;;;;;;;;;OAYG;IACH,SAAS,EAAE,0BAA0B,CAAC,EAAE,KAAK,EAAE,8CAA8C,EAAE,CAAC;CACjG,CAAC,CAAC;AAIH;;;;GAIG;AACH,MAAM,CAAC,MAAM,6CAA6C,GAAgC,CAAC,GAAG,iCAAiC,CAAC,CAAC;AAEjI;;;GAGG;AACH,MAAM,CAAC,MAAM,6CAA6C,GAAG,2BAA2B,CAAC,MAAM,CAAC;IAC9F,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY,EAAE,CAAC,cAAc,EAAE;IACtD,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,CAAC,YAAY,EAAE,CAAC,cAAc,EAAE,CAAC,iBAAiB,EAAE;IAC5F,kBAAkB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,CAAC,YAAY,EAAE,CAAC,cAAc,EAAE,CAAC,iBAAiB,EAAE;IAChG,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,cAAc,EAAE;IAC3D,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,UAAU,CAAC,oBAAoB,CAAC,CAAC,WAAW,EAAE,CAAC,cAAc,EAAE;IAClG,GAAG,0BAA0B;IAC7B;;;;OAIG;IACH,SAAS,EAAE,0BAA0B,CAAC,EAAE,KAAK,EAAE,6CAA6C,EAAE,CAAC;CAChG,CAAC,CAAC","sourcesContent":["import { z } from 'zod';\nimport {\n  ActorSystem_ExecutionSchema,\n  FlowSystem_Execution_Schema,\n  FlowsActors_Status,\n  forwardedUserNameDirectory,\n  type NestedUserIdPath,\n} from '@wildo-ai/saas-models';\nimport { initZodDecorators } from '@wildo-ai/zod-decorators';\n\ninitZodDecorators(z);\n\n/**\n * A persisted run's INSTANTS, as dates (#2187).\n *\n * The canonical execution schema (`FlowActorSystem_ExecutionSchema`) carries `createdAt` /\n * `updatedAt` / `finishedAt` as ISO strings, which is right for the in-memory and wire form and\n * wrong for a stored row: the PostgreSQL planner maps every string to `text`, so the platform\n * stored these as text holding a LOCAL offset (`2026-10-01T16:26:43.497+02:00`, 381 rows measured),\n * and every newest-first listing sorted the strings. String order is time order only while every\n * value has the same offset — not across a daylight-saving change, nor between hosts in different\n * zones. As dates they plan `timestamptz` and compare as instants. The engine's own persisted\n * execution schemas declare the same fields as `z.date()` for the same reason.\n *\n * Only the persisted row changes. The wire (the companion's HTTP contracts, the in-memory runtime)\n * keeps ISO strings; the companion's executions service converts at its persistence boundary.\n *\n * `updatedAt` is indexed: the companion's listing reads the newest rows of an application by it\n * (#2186), and without the index PostgreSQL sorts every row of the application to return a page.\n */\nconst PersistedExecutionInstants = {\n  createdAt: z.date(),\n  updatedAt: z.date().isDBIndexed(),\n  finishedAt: z.date().optional(),\n};\n\n/**\n * Where a run record's execution-context initiators name a PERSON (#2823), on every control-plane run record (an actor\n * run, a flow run, a task): the one who started it (`initiator`), and the one whose request each error item records\n * (`errorStates.errorItems[].initiatorIds`). In each, `userId` is the signed-in person and `inboundScopeUserId` the\n * person an inbound delivery belongs to; both are user ids. The initiator's other ids (an organization, an application,\n * a credential, an anonymous visitor, a delivery) are not people with a profile, and are left as recorded.\n */\nexport const RUN_RECORD_INITIATOR_PERSON_PATHS: readonly NestedUserIdPath[] = initiatorPersonPathsAt('');\n\n/**\n * The initiator person paths of a record nested at `prefix` (`''` for the record itself): a run's plan and each of its\n * standalone tasks carry an initiator and error items of their own, of the same shape.\n */\nfunction initiatorPersonPathsAt(prefix: string): NestedUserIdPath[] {\n  const at = (path: string): NestedUserIdPath => (prefix ? `${prefix}.${path}` : path);\n  return [\n    at('initiator.userId'),\n    at('initiator.inboundScopeUserId'),\n    at('errorStates.errorItems[].initiatorIds.userId'),\n    at('errorStates.errorItems[].initiatorIds.inboundScopeUserId'),\n  ];\n}\n\n/**\n * Every place an actor run's schema types a PERSON by user id below its top level (#2823), named by the run's\n * `userNames`:\n *\n * - who started it, and whose request each error item records ({@link RUN_RECORD_INITIATOR_PERSON_PATHS}), on the run\n *   itself, on its plan (`plan.`) and on each standalone task it carries (`standaloneTasks[].`);\n * - who decided each decision the run waited on (`statusChanges[].resolution.decidedByUserId`);\n * - for the question the run is waiting on, and for the one a resume is answering (`checkpoint.resumedSuspension`): the\n *   person it was raised for (`requester.ref`) and the person it is assigned to (`route.assigneeUserId`);\n * - for a settled review whose agent-work record is still owed (`pendingCorrectionRecord`): who decided it\n *   (`deciderUserId`) and the person whose work it was, when the work was a person's (`owner.userId`; the owner is an\n *   organization or an application otherwise, which this path does not reach).\n *\n * `requester.ref` is a CREDENTIAL id when the requester is a machine. No profile carries a credential id, so the\n * directory names nothing there and the id stays as recorded, which is what a machine's reference should show.\n *\n * Not walked, because they are not typed: the free-form `checkpoint.context`, a task's `input`, `output` and `memory`.\n * Not people: a task's correlation refs, a plan step's relationships, an organization unit.\n *\n * A display that shows these ids reads this list too (`nameUserIdsAtPaths`), so a person is named where their id was\n * by the same statement that made the backend look them up.\n */\nexport const WILDO_APPLICATION_ACTOR_EXECUTION_PERSON_PATHS: readonly NestedUserIdPath[] = [\n  ...RUN_RECORD_INITIATOR_PERSON_PATHS,\n  'statusChanges[].resolution.decidedByUserId',\n  'suspension.requester.ref',\n  'suspension.route.assigneeUserId',\n  'checkpoint.resumedSuspension.requester.ref',\n  'checkpoint.resumedSuspension.route.assigneeUserId',\n  'pendingCorrectionRecord.deciderUserId',\n  'pendingCorrectionRecord.owner.userId',\n  ...initiatorPersonPathsAt('plan'),\n  ...initiatorPersonPathsAt('standaloneTasks[]'),\n];\n\n/**\n * Platform-owned actor executions are persisted in the apps-manager database but\n * stay explicitly attached to the owning Wildo application row.\n */\nexport const Wildo_Application_ActorSystem_Execution_Schema = ActorSystem_ExecutionSchema.extend({\n  _id: z.string().min(1).isPrimaryKey().isSummaryField(),\n  organizationId: z.string().isDBIndexed().isForeignKey().isSummaryField().excludeFromUpdate(),\n  wildoApplicationId: z.string().isDBIndexed().isForeignKey().isSummaryField().excludeFromUpdate(),\n  systemRef: z.string().min(1).isDBIndexed().isSummaryField(),\n  status: z.enum(FlowsActors_Status).systemEnum('FlowsActors_Status').isDBIndexed().isSummaryField(),\n  ...PersistedExecutionInstants,\n  /**\n   * The people this run records, by name (#2823): user id → their profile's first and last name, for every id at\n   * {@link WILDO_APPLICATION_ACTOR_EXECUTION_PERSON_PATHS}. Virtual: resolved when the run is read, never stored, so no\n   * column and no migration; an erased person reads as their profile now does (hidden, or masked), never by the name\n   * they had. No email fallback.\n   *\n   * WHO MAY BE TOLD: whoever may READ the run, i.e. a member of the organization that owns it (`ORG_MEMBER`, see the\n   * resource configuration). The people it names acted on this application's runs in that organization: the companion's\n   * signed-in operators who started a run, were asked by it, or decided for it. Their names are what the organization's\n   * own member list already tells its members, and nothing more (no email, no role).\n   *\n   * Not a summary field: only a run's own page shows its decisions and its question, so a LIST pays no profile read.\n   */\n  userNames: forwardedUserNameDirectory({ paths: WILDO_APPLICATION_ACTOR_EXECUTION_PERSON_PATHS }),\n});\nexport type Wildo_Application_ActorSystem_Execution =\n  z.infer<typeof Wildo_Application_ActorSystem_Execution_Schema>;\n\n/**\n * Every place a flow run's schema types a PERSON by user id below its top level (#2823): its initiators only. A flow\n * run's history carries no decision, so it has no decider, and its nodes are references to the flow's own steps (a\n * step's `toUserId` is a value reference the step resolves, never stored on the run).\n */\nexport const WILDO_APPLICATION_FLOW_EXECUTION_PERSON_PATHS: readonly NestedUserIdPath[] = [...RUN_RECORD_INITIATOR_PERSON_PATHS];\n\n/**\n * Flow executions follow the same platform ownership chain as actor executions:\n * org-scoped in the apps-manager DB and child-linked to a single Wildo app.\n */\nexport const Wildo_Application_FlowSystem_Execution_Schema = FlowSystem_Execution_Schema.extend({\n  _id: z.string().min(1).isPrimaryKey().isSummaryField(),\n  organizationId: z.string().isDBIndexed().isForeignKey().isSummaryField().excludeFromUpdate(),\n  wildoApplicationId: z.string().isDBIndexed().isForeignKey().isSummaryField().excludeFromUpdate(),\n  systemRef: z.string().min(1).isDBIndexed().isSummaryField(),\n  status: z.enum(FlowsActors_Status).systemEnum('FlowsActors_Status').isDBIndexed().isSummaryField(),\n  ...PersistedExecutionInstants,\n  /**\n   * The people this flow run records, by name (#2823), at {@link WILDO_APPLICATION_FLOW_EXECUTION_PERSON_PATHS}. The\n   * actor run's `userNames` explains the field and its disclosure; the same reader (an organization member) is told the\n   * same thing (a profile name) about the same people (the companion's operators of this application).\n   */\n  userNames: forwardedUserNameDirectory({ paths: WILDO_APPLICATION_FLOW_EXECUTION_PERSON_PATHS }),\n});\nexport type Wildo_Application_FlowSystem_Execution =\n  z.infer<typeof Wildo_Application_FlowSystem_Execution_Schema>;\n"]}

package/dist/esm/wildo-application-tasks/wildo-application-tasks.custom.shared.resources-config.schemas.d.ts

@@ -13,7 +13,7 @@ export declare const wildoApplicationActorTasks_ResourceConfiguration_Initializa
         userId: import("zod").ZodOptional<import("zod").ZodString>;
         applicationId: import("zod").ZodOptional<import("zod").ZodString>;
         machineCredential: import("zod").ZodOptional<import("zod").ZodObject<{
-            authMethod: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").MachineAuthMethod>;
+            authMethod: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").MachineAuthMethod>>;
             credentialId: import("zod").ZodString;
         }, import("zod/v4/core").$strip>>;
         consumableTokenId: import("zod").ZodOptional<import("zod").ZodString>;
@@ -22,6 +22,10 @@ export declare const wildoApplicationActorTasks_ResourceConfiguration_Initializa
         inboundDeliveryId: import("zod").ZodOptional<import("zod").ZodString>;
         inboundHandlerRef: import("zod").ZodOptional<import("zod").ZodString>;
         inboundScopeUserId: import("zod").ZodOptional<import("zod").ZodString>;
+        decisionNoticeId: import("zod").ZodOptional<import("zod").ZodString>;
+        decisionNoticeHandlerRef: import("zod").ZodOptional<import("zod").ZodString>;
+        chatConversationId: import("zod").ZodOptional<import("zod").ZodString>;
+        chatReplyHandlerRef: import("zod").ZodOptional<import("zod").ZodString>;
         inboundSender: import("zod").ZodOptional<import("zod").ZodObject<{
             channel: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").InboundChannelKind>;
             assurance: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").InboundSenderAssurance>;
@@ -29,37 +33,37 @@ export declare const wildoApplicationActorTasks_ResourceConfiguration_Initializa
     }, import("zod/v4/core").$strip>;
     relationships: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
         kind: import("zod").ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.FLOW>;
-        relation: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>;
+        relation: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>>;
         flowId: import("zod").ZodString;
     }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
         kind: import("zod").ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.ACTOR>;
-        relation: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>;
+        relation: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>>;
         actorId: import("zod").ZodString;
         actorSystemId: import("zod").ZodString;
     }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
         kind: import("zod").ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.FLOW_STEP>;
-        relation: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>;
+        relation: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>>;
         flowId: import("zod").ZodString;
         stepId: import("zod").ZodString;
     }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
         kind: import("zod").ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.TASK>;
-        relation: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>;
+        relation: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>>;
         taskId: import("zod").ZodString;
         actorSystemId: import("zod").ZodString;
     }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
         kind: import("zod").ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.PLAN>;
-        relation: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>;
+        relation: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>>;
         planId: import("zod").ZodString;
         actorSystemId: import("zod").ZodString;
     }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
         kind: import("zod").ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.PLAN_STEP>;
-        relation: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>;
+        relation: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>>;
         planId: import("zod").ZodString;
         planStepId: import("zod").ZodString;
         actorSystemId: import("zod").ZodString;
     }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
         kind: import("zod").ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.ACTOR_SYSTEM>;
-        relation: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>;
+        relation: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>>;
         actorSystemId: import("zod").ZodString;
     }, import("zod/v4/core").$strip>], "kind">>;
     actors: import("zod").ZodObject<{
@@ -260,7 +264,7 @@ export declare const wildoApplicationActorTasks_ResourceConfiguration_Initializa
                 userId: import("zod").ZodOptional<import("zod").ZodString>;
                 applicationId: import("zod").ZodOptional<import("zod").ZodString>;
                 machineCredential: import("zod").ZodOptional<import("zod").ZodObject<{
-                    authMethod: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").MachineAuthMethod>;
+                    authMethod: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").MachineAuthMethod>>;
                     credentialId: import("zod").ZodString;
                 }, import("zod/v4/core").$strip>>;
                 consumableTokenId: import("zod").ZodOptional<import("zod").ZodString>;
@@ -269,12 +273,16 @@ export declare const wildoApplicationActorTasks_ResourceConfiguration_Initializa
                 inboundDeliveryId: import("zod").ZodOptional<import("zod").ZodString>;
                 inboundHandlerRef: import("zod").ZodOptional<import("zod").ZodString>;
                 inboundScopeUserId: import("zod").ZodOptional<import("zod").ZodString>;
+                decisionNoticeId: import("zod").ZodOptional<import("zod").ZodString>;
+                decisionNoticeHandlerRef: import("zod").ZodOptional<import("zod").ZodString>;
+                chatConversationId: import("zod").ZodOptional<import("zod").ZodString>;
+                chatReplyHandlerRef: import("zod").ZodOptional<import("zod").ZodString>;
                 inboundSender: import("zod").ZodOptional<import("zod").ZodObject<{
                     channel: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").InboundChannelKind>;
                     assurance: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").InboundSenderAssurance>;
                 }, import("zod/v4/core").$strict>>;
             }, import("zod/v4/core").$strip>>>;
-            executionType: import("zod").ZodOptional<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").ExecutionContext_ExecutionType>>;
+            executionType: import("zod").ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").ExecutionContext_ExecutionType>>>;
             userGuidance: import("zod").ZodOptional<import("zod").ZodObject<{
                 guidanceKey: import("zod").ZodOptional<import("zod").ZodString>;
                 explanation: import("zod").ZodOptional<import("zod").ZodString>;
@@ -289,6 +297,7 @@ export declare const wildoApplicationActorTasks_ResourceConfiguration_Initializa
                 retryAfterSeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
                 missingConfiguration: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
             }, import("zod/v4/core").$strip>>;
+            requestOutcome: import("zod").ZodOptional<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").ErrorRequestOutcome>>;
             actorRef: import("zod").ZodString;
         }, import("zod/v4/core").$strip>>>;
         checkpointChecks: import("zod").ZodArray<import("zod").ZodObject<{
@@ -339,16 +348,17 @@ export declare const wildoApplicationActorTasks_ResourceConfiguration_Initializa
             context: import("zod").ZodOptional<import("zod").ZodAny>;
         }, import("zod/v4/core").$strip>>>;
     }, import("zod/v4/core").$strip>>;
-    createdAt: import("zod").ZodString;
-    startedAt: import("zod").ZodOptional<import("zod").ZodString>;
-    completedAt: import("zod").ZodOptional<import("zod").ZodString>;
     _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>>>>;
     wildoApplicationId: 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>>>>;
     wildoApplicationActorSystemExecutionId: import("zod").ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodString>>>;
     title: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodString>;
     status: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Status>>>>;
-    updatedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodString>;
+    createdAt: import("zod").ZodDate;
+    updatedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodDate>;
+    startedAt: import("zod").ZodOptional<import("zod").ZodDate>;
+    completedAt: import("zod").ZodOptional<import("zod").ZodDate>;
+    userNames: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>>;
 }, import("zod/v4/core").$strip>>;
 export {};
 //# sourceMappingURL=wildo-application-tasks.custom.shared.resources-config.schemas.d.ts.map

package/dist/esm/wildo-application-tasks/wildo-application-tasks.custom.shared.resources-config.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wildo-application-tasks.custom.shared.resources-config.schemas.d.ts","sourceRoot":"","sources":["../../../src/wildo-application-tasks/wildo-application-tasks.custom.shared.resources-config.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,qBAAqB,EAGrB,oBAAoB,EAErB,MAAM,uBAAuB,CAAC;AAS/B,KAAK,yCAAyC,GAC1C,qBAAqB,CAAC,MAAM,GAC5B,qBAAqB,CAAC,IAAI,GAC1B,qBAAqB,CAAC,IAAI,GAC1B,qBAAqB,CAAC,MAAM,CAAC;AA2CjC;;;;GAIG;AACH,eAAO,MAAM,sEAAsE,GAChF,wBAAwB,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAwB7C,CAAC"}
+{"version":3,"file":"wildo-application-tasks.custom.shared.resources-config.schemas.d.ts","sourceRoot":"","sources":["../../../../src/wildo-application-tasks/wildo-application-tasks.custom.shared.resources-config.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,qBAAqB,EAGrB,oBAAoB,EAErB,MAAM,uBAAuB,CAAC;AAS/B,KAAK,yCAAyC,GAC1C,qBAAqB,CAAC,MAAM,GAC5B,qBAAqB,CAAC,IAAI,GAC1B,qBAAqB,CAAC,IAAI,GAC1B,qBAAqB,CAAC,MAAM,CAAC;AA2CjC;;;;GAIG;AACH,eAAO,MAAM,sEAAsE,GAChF,wBAAwB,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAwB7C,CAAC"}

package/dist/esm/wildo-application-tasks/wildo-application-tasks.custom.shared.schemas.d.ts

@@ -1,5 +1,11 @@
 import { z } from 'zod';
-import { FlowsActors_Status } from '@wildo-ai/saas-models';
+import { FlowsActors_Status, type NestedUserIdPath } from '@wildo-ai/saas-models';
+/**
+ * Every place an actor task's schema types a PERSON by user id below its top level (#2823): its initiators (who started
+ * it, and whose request each error item records). Named by the task's `userNames`. Not walked, because they are not
+ * typed: its `input`, `output` and `memory`. Not people: its correlation refs and relationships.
+ */
+export declare const WILDO_APPLICATION_ACTOR_TASK_PERSON_PATHS: readonly NestedUserIdPath[];
 /**
  * Actor-flow tasks are persisted as first-class platform records because task
  * content evolves independently of one execution snapshot. The execution link is
@@ -14,7 +20,7 @@ export declare const Wildo_Application_Actor_Task_Schema: z.ZodObject<{
         userId: z.ZodOptional<z.ZodString>;
         applicationId: z.ZodOptional<z.ZodString>;
         machineCredential: z.ZodOptional<z.ZodObject<{
-            authMethod: z.ZodEnum<typeof import("@wildo-ai/saas-models").MachineAuthMethod>;
+            authMethod: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("@wildo-ai/saas-models").MachineAuthMethod>>;
             credentialId: z.ZodString;
         }, z.core.$strip>>;
         consumableTokenId: z.ZodOptional<z.ZodString>;
@@ -23,6 +29,10 @@ export declare const Wildo_Application_Actor_Task_Schema: z.ZodObject<{
         inboundDeliveryId: z.ZodOptional<z.ZodString>;
         inboundHandlerRef: z.ZodOptional<z.ZodString>;
         inboundScopeUserId: z.ZodOptional<z.ZodString>;
+        decisionNoticeId: z.ZodOptional<z.ZodString>;
+        decisionNoticeHandlerRef: z.ZodOptional<z.ZodString>;
+        chatConversationId: z.ZodOptional<z.ZodString>;
+        chatReplyHandlerRef: z.ZodOptional<z.ZodString>;
         inboundSender: z.ZodOptional<z.ZodObject<{
             channel: z.ZodEnum<typeof import("@wildo-ai/saas-models").InboundChannelKind>;
             assurance: z.ZodEnum<typeof import("@wildo-ai/saas-models").InboundSenderAssurance>;
@@ -30,37 +40,37 @@ export declare const Wildo_Application_Actor_Task_Schema: z.ZodObject<{
     }, z.core.$strip>;
     relationships: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.FLOW>;
-        relation: z.ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>;
+        relation: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>>;
         flowId: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.ACTOR>;
-        relation: z.ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>;
+        relation: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>>;
         actorId: z.ZodString;
         actorSystemId: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.FLOW_STEP>;
-        relation: z.ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>;
+        relation: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>>;
         flowId: z.ZodString;
         stepId: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.TASK>;
-        relation: z.ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>;
+        relation: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>>;
         taskId: z.ZodString;
         actorSystemId: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.PLAN>;
-        relation: z.ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>;
+        relation: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>>;
         planId: z.ZodString;
         actorSystemId: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.PLAN_STEP>;
-        relation: z.ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>;
+        relation: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>>;
         planId: z.ZodString;
         planStepId: z.ZodString;
         actorSystemId: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<import("@wildo-ai/saas-models").FlowsActors_ElementKind.ACTOR_SYSTEM>;
-        relation: z.ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>;
+        relation: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>>;
         actorSystemId: z.ZodString;
     }, z.core.$strip>], "kind">>;
     actors: z.ZodObject<{
@@ -261,7 +271,7 @@ export declare const Wildo_Application_Actor_Task_Schema: z.ZodObject<{
                 userId: z.ZodOptional<z.ZodString>;
                 applicationId: z.ZodOptional<z.ZodString>;
                 machineCredential: z.ZodOptional<z.ZodObject<{
-                    authMethod: z.ZodEnum<typeof import("@wildo-ai/saas-models").MachineAuthMethod>;
+                    authMethod: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("@wildo-ai/saas-models").MachineAuthMethod>>;
                     credentialId: z.ZodString;
                 }, z.core.$strip>>;
                 consumableTokenId: z.ZodOptional<z.ZodString>;
@@ -270,12 +280,16 @@ export declare const Wildo_Application_Actor_Task_Schema: z.ZodObject<{
                 inboundDeliveryId: z.ZodOptional<z.ZodString>;
                 inboundHandlerRef: z.ZodOptional<z.ZodString>;
                 inboundScopeUserId: z.ZodOptional<z.ZodString>;
+                decisionNoticeId: z.ZodOptional<z.ZodString>;
+                decisionNoticeHandlerRef: z.ZodOptional<z.ZodString>;
+                chatConversationId: z.ZodOptional<z.ZodString>;
+                chatReplyHandlerRef: z.ZodOptional<z.ZodString>;
                 inboundSender: z.ZodOptional<z.ZodObject<{
                     channel: z.ZodEnum<typeof import("@wildo-ai/saas-models").InboundChannelKind>;
                     assurance: z.ZodEnum<typeof import("@wildo-ai/saas-models").InboundSenderAssurance>;
                 }, z.core.$strict>>;
             }, z.core.$strip>>>;
-            executionType: z.ZodOptional<z.ZodEnum<typeof import("@wildo-ai/saas-models").ExecutionContext_ExecutionType>>;
+            executionType: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("@wildo-ai/saas-models").ExecutionContext_ExecutionType>>>;
             userGuidance: z.ZodOptional<z.ZodObject<{
                 guidanceKey: z.ZodOptional<z.ZodString>;
                 explanation: z.ZodOptional<z.ZodString>;
@@ -290,6 +304,7 @@ export declare const Wildo_Application_Actor_Task_Schema: z.ZodObject<{
                 retryAfterSeconds: z.ZodOptional<z.ZodNumber>;
                 missingConfiguration: z.ZodOptional<z.ZodArray<z.ZodString>>;
             }, z.core.$strip>>;
+            requestOutcome: z.ZodOptional<z.ZodEnum<typeof import("@wildo-ai/saas-models").ErrorRequestOutcome>>;
             actorRef: z.ZodString;
         }, z.core.$strip>>>;
         checkpointChecks: z.ZodArray<z.ZodObject<{
@@ -340,16 +355,17 @@ export declare const Wildo_Application_Actor_Task_Schema: z.ZodObject<{
             context: z.ZodOptional<z.ZodAny>;
         }, z.core.$strip>>>;
     }, z.core.$strip>>;
-    createdAt: z.ZodString;
-    startedAt: z.ZodOptional<z.ZodString>;
-    completedAt: z.ZodOptional<z.ZodString>;
     _id: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.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<z.ZodString>>>>;
     wildoApplicationId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>>;
     wildoApplicationActorSystemExecutionId: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
     title: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
     status: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof FlowsActors_Status>>>>;
-    updatedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
+    createdAt: z.ZodDate;
+    updatedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>;
+    startedAt: z.ZodOptional<z.ZodDate>;
+    completedAt: z.ZodOptional<z.ZodDate>;
+    userNames: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
 }, z.core.$strip>;
 export type Wildo_Application_Actor_Task = z.infer<typeof Wildo_Application_Actor_Task_Schema>;
 //# sourceMappingURL=wildo-application-tasks.custom.shared.schemas.d.ts.map

package/dist/esm/wildo-application-tasks/wildo-application-tasks.custom.shared.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wildo-application-tasks.custom.shared.schemas.d.ts","sourceRoot":"","sources":["../../../src/wildo-application-tasks/wildo-application-tasks.custom.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAEL,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAK/B;;;;;GAKG;AACH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqC9C,CAAC;AACH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAC"}
+{"version":3,"file":"wildo-application-tasks.custom.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/wildo-application-tasks/wildo-application-tasks.custom.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAEL,kBAAkB,EAElB,KAAK,gBAAgB,EACtB,MAAM,uBAAuB,CAAC;AAM/B;;;;GAIG;AACH,eAAO,MAAM,yCAAyC,EAAE,SAAS,gBAAgB,EAA2C,CAAC;AAE7H;;;;;GAKG;AACH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsD9C,CAAC;AACH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAC"}

package/dist/esm/wildo-application-tasks/wildo-application-tasks.custom.shared.schemas.js

@@ -1,7 +1,14 @@
 import { z } from 'zod';
-import { Actors_Task_Schema, FlowsActors_Status, } from '@wildo-ai/saas-models';
+import { Actors_Task_Schema, FlowsActors_Status, forwardedUserNameDirectory, } from '@wildo-ai/saas-models';
 import { initZodDecorators } from '@wildo-ai/zod-decorators';
+import { RUN_RECORD_INITIATOR_PERSON_PATHS } from '../wildo-application-executions/wildo-application-executions.custom.shared.schemas.js';
 initZodDecorators(z);
+/**
+ * Every place an actor task's schema types a PERSON by user id below its top level (#2823): its initiators (who started
+ * it, and whose request each error item records). Named by the task's `userNames`. Not walked, because they are not
+ * typed: its `input`, `output` and `memory`. Not people: its correlation refs and relationships.
+ */
+export const WILDO_APPLICATION_ACTOR_TASK_PERSON_PATHS = [...RUN_RECORD_INITIATOR_PERSON_PATHS];
 /**
  * Actor-flow tasks are persisted as first-class platform records because task
  * content evolves independently of one execution snapshot. The execution link is
@@ -44,6 +51,23 @@ export const Wildo_Application_Actor_Task_Schema = Actors_Task_Schema.extend({
      */
     title: z.string().min(1).isSummaryField(),
     status: z.enum(FlowsActors_Status).systemEnum('FlowsActors_Status').isDBIndexed().isSummaryField(),
-    updatedAt: z.string().refine((val) => !isNaN(Date.parse(val)), { error: 'Invalid datetime string' }).isDBIndexed(),
+    /*
+     * The task's instants are DATES on the persisted row (#2187), not the canonical `Actors_Task_Schema`'s
+     * ISO strings: a string plans `text`, which the platform filled with local-offset values whose order
+     * breaks across a daylight-saving change. As dates they plan `timestamptz`. The wire keeps strings;
+     * the companion converts at its persistence boundary. See the execution schemas for the measurement.
+     */
+    createdAt: z.date(),
+    updatedAt: z.date().isDBIndexed(),
+    startedAt: z.date().optional(),
+    completedAt: z.date().optional(),
+    /**
+     * The people this task records, by name (#2823), at {@link WILDO_APPLICATION_ACTOR_TASK_PERSON_PATHS}: user id →
+     * their profile's first and last name. Virtual: resolved when the task is read, never stored (no column, no
+     * migration), no email fallback; an erased person reads as their profile now does. Told to whoever may read the task
+     * (a member of the organization that owns it), about the companion's operators of this application. Not a summary
+     * field: only the task's own page shows who started it.
+     */
+    userNames: forwardedUserNameDirectory({ paths: WILDO_APPLICATION_ACTOR_TASK_PERSON_PATHS }),
 });
 //# sourceMappingURL=wildo-application-tasks.custom.shared.schemas.js.map

package/dist/esm/wildo-application-tasks/wildo-application-tasks.custom.shared.schemas.js.map

@@ -1 +1 @@
-{"version":3,"file":"wildo-application-tasks.custom.shared.schemas.js","sourceRoot":"","sources":["../../../../src/wildo-application-tasks/wildo-application-tasks.custom.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EACL,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D,iBAAiB,CAAC,CAAC,CAAC,CAAC;AAErB;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mCAAmC,GAAG,kBAAkB,CAAC,MAAM,CAAC;IAC3E,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY,EAAE,CAAC,cAAc,EAAE;IACtD,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,CAAC,YAAY,EAAE,CAAC,cAAc,EAAE,CAAC,iBAAiB,EAAE;IAC5F,kBAAkB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,CAAC,YAAY,EAAE,CAAC,cAAc,EAAE,CAAC,iBAAiB,EAAE;IAChG,sCAAsC,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,CAAC,YAAY,EAAE,CAAC,QAAQ,EAAE;IAC1F;;;;;;;;;;;OAWG;IACH;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,cAAc,EAAE;IACzC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,UAAU,CAAC,oBAAoB,CAAC,CAAC,WAAW,EAAE,CAAC,cAAc,EAAE;IAClG,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,yBAAyB,EAAE,CAAC,CAAC,WAAW,EAAE;CACnH,CAAC,CAAC","sourcesContent":["import { z } from 'zod';\nimport {\n  Actors_Task_Schema,\n  FlowsActors_Status,\n} from '@wildo-ai/saas-models';\nimport { initZodDecorators } from '@wildo-ai/zod-decorators';\n\ninitZodDecorators(z);\n\n/**\n * Actor-flow tasks are persisted as first-class platform records because task\n * content evolves independently of one execution snapshot. The execution link is\n * optional/updateable so tasks can outlive a specific run while still being\n * queryable from the current actor-system follow-up record.\n */\nexport const Wildo_Application_Actor_Task_Schema = Actors_Task_Schema.extend({\n  _id: z.string().min(1).isPrimaryKey().isSummaryField(),\n  organizationId: z.string().isDBIndexed().isForeignKey().isSummaryField().excludeFromUpdate(),\n  wildoApplicationId: z.string().isDBIndexed().isForeignKey().isSummaryField().excludeFromUpdate(),\n  wildoApplicationActorSystemExecutionId: z.string().isDBIndexed().isForeignKey().optional(),\n  /*\n   * `continuityAttemptKey` was here until 2026-09-19 (#1337), described as the \"server-managed\n   * physical-attempt identity for continuity-bound Tasks\" and carrying a sparse unique\n   * `(wildoApplicationId, continuityAttemptKey)` index as a database backstop against concurrent\n   * creation of one Execution-Binding attempt.\n   *\n   * Execution bindings were demolished on 2026-08-23, and the field was measured to have ZERO\n   * writers anywhere — so every application was materializing a unique index, on every actor-task\n   * table, for a column that is always null, and the workbench rendered an always-empty field as a\n   * machine identity. Removed with its index, its UI field, its label, its interface member and\n   * the test that pinned the index shape.\n   */\n  /*\n   * `workbenchBuildPlanTaskId` was here until 2026-09-20 (#1348) — a foreign key from the GENERIC\n   * platform actor-task row into an app-creation workbench resource, and the last app-creation\n   * field on this row.\n   *\n   * It is not folded away, it is MOVED: the association now travels in the engine's own\n   * `Actors_Task_Context.correlation` envelope as\n   * `{ domain: 'application-creation', refs: { buildPlanTaskRef } }`, which is durable on this same\n   * row and says nothing about what a build-plan task is. The traversable edge moved with it, to\n   * the plane that owns the vocabulary: `Workbench_BuildDispatch.codingTaskId` already pointed at\n   * this row and is now a DECLARED relationship.\n   *\n   * What that cost, recorded because it was the objection to folding: this row no longer renders\n   * the build-plan task as a summary field, and no longer declares the edge from its own side.\n   * Nothing queried the column — measured across the companion before removing it — so the loss is\n   * a rendered field on the generic row, which is the thing that should not have been here.\n   */\n  title: z.string().min(1).isSummaryField(),\n  status: z.enum(FlowsActors_Status).systemEnum('FlowsActors_Status').isDBIndexed().isSummaryField(),\n  updatedAt: z.string().refine((val) => !isNaN(Date.parse(val)), { error: 'Invalid datetime string' }).isDBIndexed(),\n});\nexport type Wildo_Application_Actor_Task = z.infer<typeof Wildo_Application_Actor_Task_Schema>;\n"]}
+{"version":3,"file":"wildo-application-tasks.custom.shared.schemas.js","sourceRoot":"","sources":["../../../../src/wildo-application-tasks/wildo-application-tasks.custom.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EACL,kBAAkB,EAClB,kBAAkB,EAClB,0BAA0B,GAE3B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,iCAAiC,EAAE,MAAM,oFAAoF,CAAC;AAEvI,iBAAiB,CAAC,CAAC,CAAC,CAAC;AAErB;;;;GAIG;AACH,MAAM,CAAC,MAAM,yCAAyC,GAAgC,CAAC,GAAG,iCAAiC,CAAC,CAAC;AAE7H;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mCAAmC,GAAG,kBAAkB,CAAC,MAAM,CAAC;IAC3E,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY,EAAE,CAAC,cAAc,EAAE;IACtD,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,CAAC,YAAY,EAAE,CAAC,cAAc,EAAE,CAAC,iBAAiB,EAAE;IAC5F,kBAAkB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,CAAC,YAAY,EAAE,CAAC,cAAc,EAAE,CAAC,iBAAiB,EAAE;IAChG,sCAAsC,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,CAAC,YAAY,EAAE,CAAC,QAAQ,EAAE;IAC1F;;;;;;;;;;;OAWG;IACH;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,cAAc,EAAE;IACzC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,UAAU,CAAC,oBAAoB,CAAC,CAAC,WAAW,EAAE,CAAC,cAAc,EAAE;IAClG;;;;;OAKG;IACH,SAAS,EAAE,CAAC,CAAC,IAAI,EAAE;IACnB,SAAS,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE;IACjC,SAAS,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE;IAC9B,WAAW,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE;IAChC;;;;;;OAMG;IACH,SAAS,EAAE,0BAA0B,CAAC,EAAE,KAAK,EAAE,yCAAyC,EAAE,CAAC;CAC5F,CAAC,CAAC","sourcesContent":["import { z } from 'zod';\nimport {\n  Actors_Task_Schema,\n  FlowsActors_Status,\n  forwardedUserNameDirectory,\n  type NestedUserIdPath,\n} from '@wildo-ai/saas-models';\nimport { initZodDecorators } from '@wildo-ai/zod-decorators';\nimport { RUN_RECORD_INITIATOR_PERSON_PATHS } from '../wildo-application-executions/wildo-application-executions.custom.shared.schemas';\n\ninitZodDecorators(z);\n\n/**\n * Every place an actor task's schema types a PERSON by user id below its top level (#2823): its initiators (who started\n * it, and whose request each error item records). Named by the task's `userNames`. Not walked, because they are not\n * typed: its `input`, `output` and `memory`. Not people: its correlation refs and relationships.\n */\nexport const WILDO_APPLICATION_ACTOR_TASK_PERSON_PATHS: readonly NestedUserIdPath[] = [...RUN_RECORD_INITIATOR_PERSON_PATHS];\n\n/**\n * Actor-flow tasks are persisted as first-class platform records because task\n * content evolves independently of one execution snapshot. The execution link is\n * optional/updateable so tasks can outlive a specific run while still being\n * queryable from the current actor-system follow-up record.\n */\nexport const Wildo_Application_Actor_Task_Schema = Actors_Task_Schema.extend({\n  _id: z.string().min(1).isPrimaryKey().isSummaryField(),\n  organizationId: z.string().isDBIndexed().isForeignKey().isSummaryField().excludeFromUpdate(),\n  wildoApplicationId: z.string().isDBIndexed().isForeignKey().isSummaryField().excludeFromUpdate(),\n  wildoApplicationActorSystemExecutionId: z.string().isDBIndexed().isForeignKey().optional(),\n  /*\n   * `continuityAttemptKey` was here until 2026-09-19 (#1337), described as the \"server-managed\n   * physical-attempt identity for continuity-bound Tasks\" and carrying a sparse unique\n   * `(wildoApplicationId, continuityAttemptKey)` index as a database backstop against concurrent\n   * creation of one Execution-Binding attempt.\n   *\n   * Execution bindings were demolished on 2026-08-23, and the field was measured to have ZERO\n   * writers anywhere — so every application was materializing a unique index, on every actor-task\n   * table, for a column that is always null, and the workbench rendered an always-empty field as a\n   * machine identity. Removed with its index, its UI field, its label, its interface member and\n   * the test that pinned the index shape.\n   */\n  /*\n   * `workbenchBuildPlanTaskId` was here until 2026-09-20 (#1348) — a foreign key from the GENERIC\n   * platform actor-task row into an app-creation workbench resource, and the last app-creation\n   * field on this row.\n   *\n   * It is not folded away, it is MOVED: the association now travels in the engine's own\n   * `Actors_Task_Context.correlation` envelope as\n   * `{ domain: 'application-creation', refs: { buildPlanTaskRef } }`, which is durable on this same\n   * row and says nothing about what a build-plan task is. The traversable edge moved with it, to\n   * the plane that owns the vocabulary: `Workbench_BuildDispatch.codingTaskId` already pointed at\n   * this row and is now a DECLARED relationship.\n   *\n   * What that cost, recorded because it was the objection to folding: this row no longer renders\n   * the build-plan task as a summary field, and no longer declares the edge from its own side.\n   * Nothing queried the column — measured across the companion before removing it — so the loss is\n   * a rendered field on the generic row, which is the thing that should not have been here.\n   */\n  title: z.string().min(1).isSummaryField(),\n  status: z.enum(FlowsActors_Status).systemEnum('FlowsActors_Status').isDBIndexed().isSummaryField(),\n  /*\n   * The task's instants are DATES on the persisted row (#2187), not the canonical `Actors_Task_Schema`'s\n   * ISO strings: a string plans `text`, which the platform filled with local-offset values whose order\n   * breaks across a daylight-saving change. As dates they plan `timestamptz`. The wire keeps strings;\n   * the companion converts at its persistence boundary. See the execution schemas for the measurement.\n   */\n  createdAt: z.date(),\n  updatedAt: z.date().isDBIndexed(),\n  startedAt: z.date().optional(),\n  completedAt: z.date().optional(),\n  /**\n   * The people this task records, by name (#2823), at {@link WILDO_APPLICATION_ACTOR_TASK_PERSON_PATHS}: user id →\n   * their profile's first and last name. Virtual: resolved when the task is read, never stored (no column, no\n   * migration), no email fallback; an erased person reads as their profile now does. Told to whoever may read the task\n   * (a member of the organization that owns it), about the companion's operators of this application. Not a summary\n   * field: only the task's own page shows who started it.\n   */\n  userNames: forwardedUserNameDirectory({ paths: WILDO_APPLICATION_ACTOR_TASK_PERSON_PATHS }),\n});\nexport type Wildo_Application_Actor_Task = z.infer<typeof Wildo_Application_Actor_Task_Schema>;\n"]}

package/dist/esm/wildo-applications/wildo-applications.custom.shared.resources-config.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wildo-applications.custom.shared.resources-config.schemas.d.ts","sourceRoot":"","sources":["../../../src/wildo-applications/wildo-applications.custom.shared.resources-config.schemas.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA6BH,eAAO,MAAM,6DAA6D,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAkJ9F,CAAC"}
+{"version":3,"file":"wildo-applications.custom.shared.resources-config.schemas.d.ts","sourceRoot":"","sources":["../../../../src/wildo-applications/wildo-applications.custom.shared.resources-config.schemas.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA6BH,eAAO,MAAM,6DAA6D,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAkJ9F,CAAC"}

package/dist/esm/wildo-applications/wildo-applications.custom.shared.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wildo-applications.custom.shared.schemas.d.ts","sourceRoot":"","sources":["../../../src/wildo-applications/wildo-applications.custom.shared.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB;;;;;;;;;;;;GAYG;AACH,oBAAY,sBAAsB;IAChC,yGAAyG;IACzG,MAAM,WAAW;IAEjB;;;;;;;;OAQG;IACH,YAAY,iBAAiB;CAC9B;AAED,eAAO,MAAM,wBAAwB;;;;;;;;;;;iBA0EnC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}
+{"version":3,"file":"wildo-applications.custom.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/wildo-applications/wildo-applications.custom.shared.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB;;;;;;;;;;;;GAYG;AACH,oBAAY,sBAAsB;IAChC,yGAAyG;IACzG,MAAM,WAAW;IAEjB;;;;;;;;OAQG;IACH,YAAY,iBAAiB;CAC9B;AAED,eAAO,MAAM,wBAAwB;;;;;;;;;;;iBA0EnC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/esm/wildo-applications-versions/wildo-applications-versions.custom.shared.resources-config.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wildo-applications-versions.custom.shared.resources-config.schemas.d.ts","sourceRoot":"","sources":["../../../src/wildo-applications-versions/wildo-applications-versions.custom.shared.resources-config.schemas.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAwBH,eAAO,MAAM,oEAAoE,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAwErG,CAAC"}
+{"version":3,"file":"wildo-applications-versions.custom.shared.resources-config.schemas.d.ts","sourceRoot":"","sources":["../../../../src/wildo-applications-versions/wildo-applications-versions.custom.shared.resources-config.schemas.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAwBH,eAAO,MAAM,oEAAoE,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAwErG,CAAC"}

package/dist/esm/wildo-applications-versions/wildo-applications-versions.custom.shared.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wildo-applications-versions.custom.shared.schemas.d.ts","sourceRoot":"","sources":["../../../src/wildo-applications-versions/wildo-applications-versions.custom.shared.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,gCAAgC;;;;;;;;iBAQ3C,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC"}
+{"version":3,"file":"wildo-applications-versions.custom.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/wildo-applications-versions/wildo-applications-versions.custom.shared.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,gCAAgC;;;;;;;;iBAQ3C,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC"}

package/dist/esm/workbench/workbench-aspect-resources.custom.shared.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workbench-aspect-resources.custom.shared.schemas.d.ts","sourceRoot":"","sources":["../../../src/workbench/workbench-aspect-resources.custom.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EAMrB,oBAAoB,EAKrB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,OAAO,EAEL,4BAA4B,EAC7B,MAAM,mDAAmD,CAAC;AAM3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH;;;;;;;GAOG;AACH,oBAAY,2BAA2B;IACrC,mFAAmF;IACnF,YAAY,iBAAiB;IAC7B,8DAA8D;IAC9D,SAAS,cAAc;IACvB,gGAAgG;IAChG,OAAO,YAAY;CACpB;AAED,MAAM,WAAW,6BAA6B;IAC5C,+EAA+E;IAC/E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,yDAAyD;IACzD,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,gDAAgD;IAChD,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,yBAAyB;IACxC,8EAA8E;IAC9E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,4BAA4B,CAAC;IACpD,0EAA0E;IAC1E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,2BAA2B,CAAC;IAC/C,QAAQ,CAAC,KAAK,EAAE,SAAS,6BAA6B,EAAE,CAAC;CAC1D;AAED,eAAO,MAAM,4BAA4B,EAAE,SAAS,yBAAyB,EAo2B5E,CAAC;AAMF,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,MAAM,GAAG,yBAAyB,GAAG,SAAS,CAErG;AAED;;;;;;GAMG;AACH,wBAAgB,kCAAkC,CAChD,UAAU,EAAE,yBAAyB,GACpC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,CAuC5B;AAED,KAAK,8BAA8B,GAAG,qBAAqB,CAAC,IAAI,GAAG,qBAAqB,CAAC,IAAI,CAAC;AAE9F;;;;;GAKG;AACH,wBAAgB,wCAAwC,CAAC,UAAU,EAAE,yBAAyB,IAEpF,wBAAwB,oBAAoB,EAAE;;oBA6BvD;AAED;;;;;;;;GAQG;AACH,wBAAgB,iCAAiC,IAAI,oBAAoB,EAAE,CA8D1E;AAED,mGAAmG;AACnG,eAAO,MAAM,iDAAiD,EAAE,MAAM,CACpE,MAAM,EACN,UAAU,CAAC,OAAO,wCAAwC,CAAC,CAM5D,CAAC"}
+{"version":3,"file":"workbench-aspect-resources.custom.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/workbench/workbench-aspect-resources.custom.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EAMrB,oBAAoB,EAKrB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,OAAO,EAEL,4BAA4B,EAC7B,MAAM,mDAAmD,CAAC;AAM3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH;;;;;;;GAOG;AACH,oBAAY,2BAA2B;IACrC,mFAAmF;IACnF,YAAY,iBAAiB;IAC7B,8DAA8D;IAC9D,SAAS,cAAc;IACvB,gGAAgG;IAChG,OAAO,YAAY;CACpB;AAED,MAAM,WAAW,6BAA6B;IAC5C,+EAA+E;IAC/E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,yDAAyD;IACzD,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,gDAAgD;IAChD,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,yBAAyB;IACxC,8EAA8E;IAC9E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,4BAA4B,CAAC;IACpD,0EAA0E;IAC1E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,2BAA2B,CAAC;IAC/C,QAAQ,CAAC,KAAK,EAAE,SAAS,6BAA6B,EAAE,CAAC;CAC1D;AAED,eAAO,MAAM,4BAA4B,EAAE,SAAS,yBAAyB,EAk4B5E,CAAC;AAMF,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,MAAM,GAAG,yBAAyB,GAAG,SAAS,CAErG;AAED;;;;;;GAMG;AACH,wBAAgB,kCAAkC,CAChD,UAAU,EAAE,yBAAyB,GACpC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,CAuC5B;AAED,KAAK,8BAA8B,GAAG,qBAAqB,CAAC,IAAI,GAAG,qBAAqB,CAAC,IAAI,CAAC;AAE9F;;;;;GAKG;AACH,wBAAgB,wCAAwC,CAAC,UAAU,EAAE,yBAAyB,IAEpF,wBAAwB,oBAAoB,EAAE;;oBA6BvD;AAED;;;;;;;;GAQG;AACH,wBAAgB,iCAAiC,IAAI,oBAAoB,EAAE,CA8D1E;AAED,mGAAmG;AACnG,eAAO,MAAM,iDAAiD,EAAE,MAAM,CACpE,MAAM,EACN,UAAU,CAAC,OAAO,wCAAwC,CAAC,CAM5D,CAAC"}

package/dist/esm/workbench/workbench-aspect-resources.custom.shared.schemas.js

@@ -731,6 +731,36 @@ export const WORKBENCH_ASPECT_DESCRIPTORS = [
             { field: 'servesSuccessCriterionIds', targetAspectKey: 'vision.success-criterion', many: true },
         ],
     },
+    {
+        /*
+         * One service of the firm (#2305): its case, stages, steps, decisions, deliverables, retention and pricing. Its one
+         * spine edge is to the qualifications its decisions are routed to; the domain-plan resources it names are not edges
+         * here, because the domain plan is derived from the method and does not exist when it is written.
+         */
+        aspectKey: 'service-method.service',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_SERVICE_METHOD_SERVICE,
+        rowsPath: 'serviceMethodServices',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'serviceMethodQualificationIds', targetAspectKey: 'service-method.qualification', many: true },
+        ],
+    },
+    {
+        /* Who may be trusted with a decision: a role, and a professional qualification when the person must hold one. */
+        aspectKey: 'service-method.qualification',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_SERVICE_METHOD_QUALIFICATION,
+        rowsPath: 'serviceMethodQualifications',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [],
+    },
+    {
+        /* Why an expert corrects an agent's work, recorded with each correction. */
+        aspectKey: 'service-method.correction-reason',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_SERVICE_METHOD_CORRECTION_REASON,
+        rowsPath: 'serviceMethodCorrectionReasons',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [],
+    },
     {
         /*
          * One requirement's standing (#1496), and the aspect that carries BOTH multi-edge shapes at