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

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,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"}
+{"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.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,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"]}
+{"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":"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","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

@@ -7,15 +7,16 @@ type WildoApplicationActorTasks_CoreOperations = CoreResourceOperation.CREATE |
  */
 export declare const wildoApplicationActorTasks_ResourceConfiguration_InitializationFactory: (resourcesRelationships: ResourceRelationship[]) => import("@wildo-ai/saas-models").ResourceConfiguration<any, WildoApplicationActorTasks_CoreOperations, import("zod").ZodObject<{
     description: import("zod").ZodString;
-    topic: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").Actor_Task_Topics>>;
+    topic: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").Actor_Task_Topics>;
     initiator: import("zod").ZodObject<{
         organizationId: import("zod").ZodOptional<import("zod").ZodString>;
         userId: import("zod").ZodOptional<import("zod").ZodString>;
         applicationId: import("zod").ZodOptional<import("zod").ZodString>;
         machineCredential: import("zod").ZodOptional<import("zod").ZodObject<{
-            authMethod: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").MachineAuthMethod>>;
+            authMethod: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").MachineAuthMethod>;
             credentialId: import("zod").ZodString;
         }, import("zod/v4/core").$strip>>;
+        autonomousAgentRef: import("zod").ZodOptional<import("zod").ZodString>;
         consumableTokenId: import("zod").ZodOptional<import("zod").ZodString>;
         webhookProviderId: import("zod").ZodOptional<import("zod").ZodString>;
         anonymousUserId: import("zod").ZodOptional<import("zod").ZodString>;
@@ -33,37 +34,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("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>>;
+        relation: 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("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>>;
+        relation: 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("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>>;
+        relation: 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("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>>;
+        relation: 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("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>>;
+        relation: 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("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>>;
+        relation: 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("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>>;
+        relation: 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<{
@@ -76,11 +77,7 @@ export declare const wildoApplicationActorTasks_ResourceConfiguration_Initializa
             entries: import("zod").ZodArray<import("zod").ZodObject<{
                 key: import("zod").ZodString;
                 value: import("zod").ZodAny;
-                type: import("zod").ZodEnum<{
-                    json: "json";
-                    text: "text";
-                    binary: "binary";
-                }>;
+                type: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").Actors_Memory_EntryType>;
                 timestamp: import("zod").ZodString;
                 expiresAt: import("zod").ZodOptional<import("zod").ZodString>;
                 metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
@@ -92,11 +89,7 @@ export declare const wildoApplicationActorTasks_ResourceConfiguration_Initializa
             entries: import("zod").ZodArray<import("zod").ZodObject<{
                 key: import("zod").ZodString;
                 value: import("zod").ZodAny;
-                type: import("zod").ZodEnum<{
-                    json: "json";
-                    text: "text";
-                    binary: "binary";
-                }>;
+                type: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").Actors_Memory_EntryType>;
                 timestamp: import("zod").ZodString;
                 expiresAt: import("zod").ZodOptional<import("zod").ZodString>;
                 metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
@@ -108,11 +101,7 @@ export declare const wildoApplicationActorTasks_ResourceConfiguration_Initializa
             entries: import("zod").ZodArray<import("zod").ZodObject<{
                 key: import("zod").ZodString;
                 value: import("zod").ZodAny;
-                type: import("zod").ZodEnum<{
-                    json: "json";
-                    text: "text";
-                    binary: "binary";
-                }>;
+                type: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").Actors_Memory_EntryType>;
                 timestamp: import("zod").ZodString;
                 expiresAt: import("zod").ZodOptional<import("zod").ZodString>;
                 metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
@@ -264,9 +253,10 @@ 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("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").MachineAuthMethod>>;
+                    authMethod: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").MachineAuthMethod>;
                     credentialId: import("zod").ZodString;
                 }, import("zod/v4/core").$strip>>;
+                autonomousAgentRef: import("zod").ZodOptional<import("zod").ZodString>;
                 consumableTokenId: import("zod").ZodOptional<import("zod").ZodString>;
                 webhookProviderId: import("zod").ZodOptional<import("zod").ZodString>;
                 anonymousUserId: import("zod").ZodOptional<import("zod").ZodString>;
@@ -282,7 +272,7 @@ export declare const wildoApplicationActorTasks_ResourceConfiguration_Initializa
                     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("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").ExecutionContext_ExecutionType>>>;
+            executionType: import("zod").ZodOptional<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>;
@@ -348,17 +338,17 @@ export declare const wildoApplicationActorTasks_ResourceConfiguration_Initializa
             context: import("zod").ZodOptional<import("zod").ZodAny>;
         }, import("zod/v4/core").$strip>>>;
     }, import("zod/v4/core").$strip>>;
-    _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>>>>;
+    _id: import("zod").ZodString;
+    organizationId: import("zod").ZodString;
+    wildoApplicationId: import("zod").ZodString;
+    wildoApplicationActorSystemExecutionId: import("zod").ZodOptional<import("zod").ZodString>;
+    title: import("zod").ZodString;
+    status: import("zod").ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Status>;
     createdAt: import("zod").ZodDate;
-    updatedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("zod").ZodDate>;
+    updatedAt: 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>>>;
+    userNames: 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;AA4CjC;;;;GAIG;AACH,eAAO,MAAM,sEAAsE,GAChF,wBAAwB,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAwB7C,CAAC"}

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

@@ -15,7 +15,7 @@ function createRepositoryOnlyDefaultVariant() {
  *
  * The original decision ("no public resource-controller surface") was made when the ONLY consumer
  * was the companion's own repository-direct persistence. The application-creation workbench now
- * consumes these rows AS RESOURCES (plan `workbench-creation-board-resources.md`, Phase 1): the
+ * consumes these rows AS RESOURCES: the
  * creation board renders them through the engine's embedded resource surfaces instead of bespoke
  * companion routes. That requires exactly the read half of an API surface, so exactly the read half
  * is opened:
@@ -30,8 +30,9 @@ function createRepositoryOnlyDefaultVariant() {
  * - CREATE/UPDATE: unchanged `REPOSITORY_ONLY`. The companion remains the only writer, and the
  *   generated write API the original decision refused stays refused.
  *
- * This config is shared with the platform tier (apps-manager registers the same map), so the read
- * routes appear there too, behind the same ORG_MEMBER gate — a deliberate consequence, not a leak.
+ * This config is shared with the platform tier (apps-manager registers the same map), but apps-manager mounts no
+ * resource controller (its `controllerWhiteList` is empty), so the read routes exist only on the development companion
+ * (#3319).
  */
 function createOrgMemberReadApiVariant() {
     return {

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

@@ -1 +1 @@
-{"version":3,"file":"wildo-application-tasks.custom.shared.resources-config.schemas.js","sourceRoot":"","sources":["../../../../src/wildo-application-tasks/wildo-application-tasks.custom.shared.resources-config.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,cAAc,EACd,qBAAqB,EACrB,0BAA0B,EAC1B,4BAA4B,EAE5B,0CAA0C,GAC3C,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,oCAAoC,EACpC,yBAAyB,GAC1B,MAAM,yDAAyD,CAAC;AACjE,OAAO,EAAE,mCAAmC,EAAE,MAAM,iDAAiD,CAAC;AAEtG,MAAM,qCAAqC,GAAG,SAAS,CAAC;AAQxD,SAAS,kCAAkC;IACzC,OAAO;QACL,WAAW,EAAE,4BAA4B,CAAC,eAAwB;QAClE,SAAS,EAAE,IAAa;QACxB,KAAK,EAAE,CAAC,cAAc,CAAC,qBAAqB,CAAC;QAC7C,SAAS,EAAE,0BAA0B,CAAC,GAAY;KACnD,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,SAAS,6BAA6B;IACpC,OAAO;QACL,WAAW,EAAE,4BAA4B,CAAC,QAAiB;QAC3D,SAAS,EAAE,IAAa;QACxB,KAAK,EAAE,CAAC,cAAc,CAAC,UAAU,CAAC;QAClC,SAAS,EAAE,0BAA0B,CAAC,GAAY;KACnD,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,sEAAsE,GACjF,CAAC,sBAA8C,EAAE,EAAE,CAAC,0CAA0C,CAI5F;IACA,UAAU,EAAE,mCAAmC;IAC/C,kBAAkB,EAAE,yBAAyB,CAAC,6BAA6B;IAC3E,uBAAuB,EACrB,oCAAoC,CAAC,yBAAyB,CAAC,6BAA6B,CAAC;IAC/F,qBAAqB,EAAE,sBAAsB;IAC7C,gBAAgB,EAAE,KAAK;IACvB,cAAc,EAAE;QACd,qBAAqB,CAAC,MAAM;QAC5B,qBAAqB,CAAC,IAAI;QAC1B,qBAAqB,CAAC,IAAI;QAC1B,qBAAqB,CAAC,MAAM;KAC7B;IACD,eAAe,EAAE,qCAAqC;IACtD,uBAAuB,EAAE;QACvB,CAAC,qBAAqB,CAAC,MAAM,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,kCAAkC,EAAE,CAAC,EAAE;QACpF,CAAC,qBAAqB,CAAC,IAAI,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,6BAA6B,EAAE,CAAC,EAAE;QAC7E,CAAC,qBAAqB,CAAC,IAAI,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,6BAA6B,EAAE,CAAC,EAAE;QAC7E,CAAC,qBAAqB,CAAC,MAAM,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,kCAAkC,EAAE,CAAC,EAAE;KACrF;CACF,CAAC,CAAC","sourcesContent":["import {\n  CORE_APP_ROLES,\n  CORE_ORG_ROLES,\n  CoreResourceOperation,\n  ResourceOperationRiskLevel,\n  ResourceOperationVariantType,\n  ResourceRelationship,\n  createResourceConfiguration_Initialization,\n} from '@wildo-ai/saas-models';\nimport {\n  CustomShared_ResourceFieldIdentifier,\n  CustomShared_ResourceType,\n} from '../core/resources/resources-types.custom.shared.schemas';\nimport { Wildo_Application_Actor_Task_Schema } from './wildo-application-tasks.custom.shared.schemas';\n\nconst WildoApplicationActorTasks_Operations = undefined;\n\ntype WildoApplicationActorTasks_CoreOperations =\n  | CoreResourceOperation.CREATE\n  | CoreResourceOperation.READ\n  | CoreResourceOperation.LIST\n  | CoreResourceOperation.UPDATE;\n\nfunction createRepositoryOnlyDefaultVariant() {\n  return {\n    variantType: ResourceOperationVariantType.REPOSITORY_ONLY as const,\n    isDefault: true as const,\n    roles: [CORE_APP_ROLES.APP_ADMIN_SUPER_ADMIN],\n    riskLevel: ResourceOperationRiskLevel.LOW as const,\n  };\n}\n\n/**\n * READ/LIST are API-callable since 2026-09-01; CREATE/UPDATE stay repository-only.\n *\n * The original decision (\"no public resource-controller surface\") was made when the ONLY consumer\n * was the companion's own repository-direct persistence. The application-creation workbench now\n * consumes these rows AS RESOURCES (plan `workbench-creation-board-resources.md`, Phase 1): the\n * creation board renders them through the engine's embedded resource surfaces instead of bespoke\n * companion routes. That requires exactly the read half of an API surface, so exactly the read half\n * is opened:\n *\n * - READ/LIST: `API_CALL`, gated `ORG_MEMBER` — the SAME read-posture as the parent\n *   `wildoApplications` rows one resource over, resolved through organization membership. The first\n *   draft reused the repository-only variants' `APP_ADMIN_SUPER_ADMIN`, and the measurement retired\n *   it: a companion operator's app-tier roles are plain `APP_USER` (the seeded developer holds\n *   `ORG_ADMIN` via MEMBERSHIP, not app-tier super-admin), so the admin gate 403'd the exact\n *   operator this surface serves. Consistent with the audit-retention decision (2026-07-29): rows\n *   kept as the organization's own audit material are rows its members may read.\n * - CREATE/UPDATE: unchanged `REPOSITORY_ONLY`. The companion remains the only writer, and the\n *   generated write API the original decision refused stays refused.\n *\n * This config is shared with the platform tier (apps-manager registers the same map), so the read\n * routes appear there too, behind the same ORG_MEMBER gate — a deliberate consequence, not a leak.\n */\nfunction createOrgMemberReadApiVariant() {\n  return {\n    variantType: ResourceOperationVariantType.API_CALL as const,\n    isDefault: true as const,\n    roles: [CORE_ORG_ROLES.ORG_MEMBER],\n    riskLevel: ResourceOperationRiskLevel.LOW as const,\n  };\n}\n\n/**\n * Actor tasks are mutable control-plane records written ONLY by the local companion. Writes stay\n * repository-only, keeping the persistence contract truthful; the READ HALF is an ORG_MEMBER-gated API\n * surface since 2026-09-01 — see `createOrgMemberReadApiVariant` above for the decision.\n */\nexport const wildoApplicationActorTasks_ResourceConfiguration_InitializationFactory =\n  (resourcesRelationships: ResourceRelationship[]) => createResourceConfiguration_Initialization<\n    typeof WildoApplicationActorTasks_Operations,\n    WildoApplicationActorTasks_CoreOperations,\n    typeof Wildo_Application_Actor_Task_Schema\n  >({\n    mainSchema: Wildo_Application_Actor_Task_Schema,\n    resourceIdentifier: CustomShared_ResourceType.WILDO_APPLICATION_ACTOR_TASKS,\n    resourceFieldIdentifier:\n      CustomShared_ResourceFieldIdentifier[CustomShared_ResourceType.WILDO_APPLICATION_ACTOR_TASKS],\n    resourceRelationships: resourcesRelationships,\n    isSystemResource: false,\n    coreOperations: [\n      CoreResourceOperation.CREATE,\n      CoreResourceOperation.READ,\n      CoreResourceOperation.LIST,\n      CoreResourceOperation.UPDATE,\n    ],\n    customOperation: WildoApplicationActorTasks_Operations,\n    operationsConfiguration: {\n      [CoreResourceOperation.CREATE]: { variants: [createRepositoryOnlyDefaultVariant()] },\n      [CoreResourceOperation.READ]: { variants: [createOrgMemberReadApiVariant()] },\n      [CoreResourceOperation.LIST]: { variants: [createOrgMemberReadApiVariant()] },\n      [CoreResourceOperation.UPDATE]: { variants: [createRepositoryOnlyDefaultVariant()] },\n    },\n  });\n"]}
+{"version":3,"file":"wildo-application-tasks.custom.shared.resources-config.schemas.js","sourceRoot":"","sources":["../../../src/wildo-application-tasks/wildo-application-tasks.custom.shared.resources-config.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,cAAc,EACd,qBAAqB,EACrB,0BAA0B,EAC1B,4BAA4B,EAE5B,0CAA0C,GAC3C,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,oCAAoC,EACpC,yBAAyB,GAC1B,MAAM,yDAAyD,CAAC;AACjE,OAAO,EAAE,mCAAmC,EAAE,MAAM,iDAAiD,CAAC;AAEtG,MAAM,qCAAqC,GAAG,SAAS,CAAC;AAQxD,SAAS,kCAAkC;IACzC,OAAO;QACL,WAAW,EAAE,4BAA4B,CAAC,eAAwB;QAClE,SAAS,EAAE,IAAa;QACxB,KAAK,EAAE,CAAC,cAAc,CAAC,qBAAqB,CAAC;QAC7C,SAAS,EAAE,0BAA0B,CAAC,GAAY;KACnD,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,SAAS,6BAA6B;IACpC,OAAO;QACL,WAAW,EAAE,4BAA4B,CAAC,QAAiB;QAC3D,SAAS,EAAE,IAAa;QACxB,KAAK,EAAE,CAAC,cAAc,CAAC,UAAU,CAAC;QAClC,SAAS,EAAE,0BAA0B,CAAC,GAAY;KACnD,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,sEAAsE,GACjF,CAAC,sBAA8C,EAAE,EAAE,CAAC,0CAA0C,CAI5F;IACA,UAAU,EAAE,mCAAmC;IAC/C,kBAAkB,EAAE,yBAAyB,CAAC,6BAA6B;IAC3E,uBAAuB,EACrB,oCAAoC,CAAC,yBAAyB,CAAC,6BAA6B,CAAC;IAC/F,qBAAqB,EAAE,sBAAsB;IAC7C,gBAAgB,EAAE,KAAK;IACvB,cAAc,EAAE;QACd,qBAAqB,CAAC,MAAM;QAC5B,qBAAqB,CAAC,IAAI;QAC1B,qBAAqB,CAAC,IAAI;QAC1B,qBAAqB,CAAC,MAAM;KAC7B;IACD,eAAe,EAAE,qCAAqC;IACtD,uBAAuB,EAAE;QACvB,CAAC,qBAAqB,CAAC,MAAM,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,kCAAkC,EAAE,CAAC,EAAE;QACpF,CAAC,qBAAqB,CAAC,IAAI,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,6BAA6B,EAAE,CAAC,EAAE;QAC7E,CAAC,qBAAqB,CAAC,IAAI,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,6BAA6B,EAAE,CAAC,EAAE;QAC7E,CAAC,qBAAqB,CAAC,MAAM,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,kCAAkC,EAAE,CAAC,EAAE;KACrF;CACF,CAAC,CAAC","sourcesContent":["import {\n  CORE_APP_ROLES,\n  CORE_ORG_ROLES,\n  CoreResourceOperation,\n  ResourceOperationRiskLevel,\n  ResourceOperationVariantType,\n  ResourceRelationship,\n  createResourceConfiguration_Initialization,\n} from '@wildo-ai/saas-models';\nimport {\n  CustomShared_ResourceFieldIdentifier,\n  CustomShared_ResourceType,\n} from '../core/resources/resources-types.custom.shared.schemas';\nimport { Wildo_Application_Actor_Task_Schema } from './wildo-application-tasks.custom.shared.schemas';\n\nconst WildoApplicationActorTasks_Operations = undefined;\n\ntype WildoApplicationActorTasks_CoreOperations =\n  | CoreResourceOperation.CREATE\n  | CoreResourceOperation.READ\n  | CoreResourceOperation.LIST\n  | CoreResourceOperation.UPDATE;\n\nfunction createRepositoryOnlyDefaultVariant() {\n  return {\n    variantType: ResourceOperationVariantType.REPOSITORY_ONLY as const,\n    isDefault: true as const,\n    roles: [CORE_APP_ROLES.APP_ADMIN_SUPER_ADMIN],\n    riskLevel: ResourceOperationRiskLevel.LOW as const,\n  };\n}\n\n/**\n * READ/LIST are API-callable since 2026-09-01; CREATE/UPDATE stay repository-only.\n *\n * The original decision (\"no public resource-controller surface\") was made when the ONLY consumer\n * was the companion's own repository-direct persistence. The application-creation workbench now\n * consumes these rows AS RESOURCES: the\n * creation board renders them through the engine's embedded resource surfaces instead of bespoke\n * companion routes. That requires exactly the read half of an API surface, so exactly the read half\n * is opened:\n *\n * - READ/LIST: `API_CALL`, gated `ORG_MEMBER` — the SAME read-posture as the parent\n *   `wildoApplications` rows one resource over, resolved through organization membership. The first\n *   draft reused the repository-only variants' `APP_ADMIN_SUPER_ADMIN`, and the measurement retired\n *   it: a companion operator's app-tier roles are plain `APP_USER` (the seeded developer holds\n *   `ORG_ADMIN` via MEMBERSHIP, not app-tier super-admin), so the admin gate 403'd the exact\n *   operator this surface serves. Consistent with the audit-retention decision (2026-07-29): rows\n *   kept as the organization's own audit material are rows its members may read.\n * - CREATE/UPDATE: unchanged `REPOSITORY_ONLY`. The companion remains the only writer, and the\n *   generated write API the original decision refused stays refused.\n *\n * This config is shared with the platform tier (apps-manager registers the same map), but apps-manager mounts no\n * resource controller (its `controllerWhiteList` is empty), so the read routes exist only on the development companion\n * (#3319).\n */\nfunction createOrgMemberReadApiVariant() {\n  return {\n    variantType: ResourceOperationVariantType.API_CALL as const,\n    isDefault: true as const,\n    roles: [CORE_ORG_ROLES.ORG_MEMBER],\n    riskLevel: ResourceOperationRiskLevel.LOW as const,\n  };\n}\n\n/**\n * Actor tasks are mutable control-plane records written ONLY by the local companion. Writes stay\n * repository-only, keeping the persistence contract truthful; the READ HALF is an ORG_MEMBER-gated API\n * surface since 2026-09-01 — see `createOrgMemberReadApiVariant` above for the decision.\n */\nexport const wildoApplicationActorTasks_ResourceConfiguration_InitializationFactory =\n  (resourcesRelationships: ResourceRelationship[]) => createResourceConfiguration_Initialization<\n    typeof WildoApplicationActorTasks_Operations,\n    WildoApplicationActorTasks_CoreOperations,\n    typeof Wildo_Application_Actor_Task_Schema\n  >({\n    mainSchema: Wildo_Application_Actor_Task_Schema,\n    resourceIdentifier: CustomShared_ResourceType.WILDO_APPLICATION_ACTOR_TASKS,\n    resourceFieldIdentifier:\n      CustomShared_ResourceFieldIdentifier[CustomShared_ResourceType.WILDO_APPLICATION_ACTOR_TASKS],\n    resourceRelationships: resourcesRelationships,\n    isSystemResource: false,\n    coreOperations: [\n      CoreResourceOperation.CREATE,\n      CoreResourceOperation.READ,\n      CoreResourceOperation.LIST,\n      CoreResourceOperation.UPDATE,\n    ],\n    customOperation: WildoApplicationActorTasks_Operations,\n    operationsConfiguration: {\n      [CoreResourceOperation.CREATE]: { variants: [createRepositoryOnlyDefaultVariant()] },\n      [CoreResourceOperation.READ]: { variants: [createOrgMemberReadApiVariant()] },\n      [CoreResourceOperation.LIST]: { variants: [createOrgMemberReadApiVariant()] },\n      [CoreResourceOperation.UPDATE]: { variants: [createRepositoryOnlyDefaultVariant()] },\n    },\n  });\n"]}

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

@@ -14,15 +14,16 @@ export declare const WILDO_APPLICATION_ACTOR_TASK_PERSON_PATHS: readonly NestedU
  */
 export declare const Wildo_Application_Actor_Task_Schema: z.ZodObject<{
     description: z.ZodString;
-    topic: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("@wildo-ai/saas-models").Actor_Task_Topics>>;
+    topic: z.ZodEnum<typeof import("@wildo-ai/saas-models").Actor_Task_Topics>;
     initiator: z.ZodObject<{
         organizationId: z.ZodOptional<z.ZodString>;
         userId: z.ZodOptional<z.ZodString>;
         applicationId: z.ZodOptional<z.ZodString>;
         machineCredential: z.ZodOptional<z.ZodObject<{
-            authMethod: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("@wildo-ai/saas-models").MachineAuthMethod>>;
+            authMethod: z.ZodEnum<typeof import("@wildo-ai/saas-models").MachineAuthMethod>;
             credentialId: z.ZodString;
         }, z.core.$strip>>;
+        autonomousAgentRef: z.ZodOptional<z.ZodString>;
         consumableTokenId: z.ZodOptional<z.ZodString>;
         webhookProviderId: z.ZodOptional<z.ZodString>;
         anonymousUserId: z.ZodOptional<z.ZodString>;
@@ -40,37 +41,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: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>>;
+        relation: 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: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>>;
+        relation: 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: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>>;
+        relation: 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: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>>;
+        relation: 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: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>>;
+        relation: 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: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>>;
+        relation: 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: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>>;
+        relation: z.ZodEnum<typeof import("@wildo-ai/saas-models").FlowsActors_Relation>;
         actorSystemId: z.ZodString;
     }, z.core.$strip>], "kind">>;
     actors: z.ZodObject<{
@@ -83,11 +84,7 @@ export declare const Wildo_Application_Actor_Task_Schema: z.ZodObject<{
             entries: z.ZodArray<z.ZodObject<{
                 key: z.ZodString;
                 value: z.ZodAny;
-                type: z.ZodEnum<{
-                    json: "json";
-                    text: "text";
-                    binary: "binary";
-                }>;
+                type: z.ZodEnum<typeof import("@wildo-ai/saas-models").Actors_Memory_EntryType>;
                 timestamp: z.ZodString;
                 expiresAt: z.ZodOptional<z.ZodString>;
                 metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -99,11 +96,7 @@ export declare const Wildo_Application_Actor_Task_Schema: z.ZodObject<{
             entries: z.ZodArray<z.ZodObject<{
                 key: z.ZodString;
                 value: z.ZodAny;
-                type: z.ZodEnum<{
-                    json: "json";
-                    text: "text";
-                    binary: "binary";
-                }>;
+                type: z.ZodEnum<typeof import("@wildo-ai/saas-models").Actors_Memory_EntryType>;
                 timestamp: z.ZodString;
                 expiresAt: z.ZodOptional<z.ZodString>;
                 metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -115,11 +108,7 @@ export declare const Wildo_Application_Actor_Task_Schema: z.ZodObject<{
             entries: z.ZodArray<z.ZodObject<{
                 key: z.ZodString;
                 value: z.ZodAny;
-                type: z.ZodEnum<{
-                    json: "json";
-                    text: "text";
-                    binary: "binary";
-                }>;
+                type: z.ZodEnum<typeof import("@wildo-ai/saas-models").Actors_Memory_EntryType>;
                 timestamp: z.ZodString;
                 expiresAt: z.ZodOptional<z.ZodString>;
                 metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -271,9 +260,10 @@ 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: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("@wildo-ai/saas-models").MachineAuthMethod>>;
+                    authMethod: z.ZodEnum<typeof import("@wildo-ai/saas-models").MachineAuthMethod>;
                     credentialId: z.ZodString;
                 }, z.core.$strip>>;
+                autonomousAgentRef: z.ZodOptional<z.ZodString>;
                 consumableTokenId: z.ZodOptional<z.ZodString>;
                 webhookProviderId: z.ZodOptional<z.ZodString>;
                 anonymousUserId: z.ZodOptional<z.ZodString>;
@@ -289,7 +279,7 @@ export declare const Wildo_Application_Actor_Task_Schema: z.ZodObject<{
                     assurance: z.ZodEnum<typeof import("@wildo-ai/saas-models").InboundSenderAssurance>;
                 }, z.core.$strict>>;
             }, z.core.$strip>>>;
-            executionType: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof import("@wildo-ai/saas-models").ExecutionContext_ExecutionType>>>;
+            executionType: z.ZodOptional<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>;
@@ -355,17 +345,17 @@ export declare const Wildo_Application_Actor_Task_Schema: z.ZodObject<{
             context: z.ZodOptional<z.ZodAny>;
         }, z.core.$strip>>>;
     }, z.core.$strip>>;
-    _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>>>>;
+    _id: z.ZodString;
+    organizationId: z.ZodString;
+    wildoApplicationId: z.ZodString;
+    wildoApplicationActorSystemExecutionId: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    status: z.ZodEnum<typeof FlowsActors_Status>;
     createdAt: z.ZodDate;
-    updatedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>;
+    updatedAt: 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>>>;
+    userNames: 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,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"}
+{"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.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,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"]}
+{"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

@@ -1,8 +1,8 @@
 /**
- * Billable Items Shared Resource Configuration
+ * Wildo applications: the platform's record of each managed application (slug, organization, status, topology).
  *
- * Resource configuration for managing invoice line items and billable entries.
- * Handles creation, updates, and management of billable items across invoices.
+ * Read over HTTP (by the development companion's workbench, behind organization membership); written only by the
+ * platform through the repository.
  */
 export declare const wildoApplications_ResourceConfiguration_InitializationFactory: (...args: any[]) => any;
 //# sourceMappingURL=wildo-applications.custom.shared.resources-config.schemas.d.ts.map

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;AAqDH,eAAO,MAAM,6DAA6D,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GA+G9F,CAAC"}

package/dist/esm/wildo-applications/wildo-applications.custom.shared.resources-config.schemas.js

@@ -1,18 +1,41 @@
 /**
- * Billable Items Shared Resource Configuration
+ * Wildo applications: the platform's record of each managed application (slug, organization, status, topology).
  *
- * Resource configuration for managing invoice line items and billable entries.
- * Handles creation, updates, and management of billable items across invoices.
+ * Read over HTTP (by the development companion's workbench, behind organization membership); written only by the
+ * platform through the repository.
  */
 import { z } from 'zod';
 import { CoreResourceOperation, CORE_APP_ROLES, ResourceSystemAccessMode } from '@wildo-ai/saas-models';
 import { ResourceOperationVariantType, ResourceOperationRiskLevel } from '@wildo-ai/saas-models';
-import { CoreUserNotificationTarget, CoreUserNotificationChannel } from '@wildo-ai/saas-models';
 import { createResourceConfiguration_Initialization } from '@wildo-ai/saas-models';
 import { CORE_ORG_ROLES } from '@wildo-ai/saas-models';
 import { CustomShared_ResourceType, CustomShared_ResourceFieldIdentifier } from '../core/resources/resources-types.custom.shared.schemas.js';
 import { Wildo_Application_Schema } from './wildo-applications.custom.shared.schemas.js';
 const WildoApplications_Operations = undefined;
+/**
+ * The write doors of the platform's record of an application: REPOSITORY_ONLY, so no HTTP route exists for them (#3319).
+ *
+ * Every writer this row has today is the platform itself, through the repository: apps-manager's
+ * `WildoApplicationsLifecycleService`, reached from registration, the bootstrap seed and administrator init. A search
+ * of the repository on 2026-11-05 found no service-tier or HTTP caller of a CREATE, UPDATE or DELETE; apps-manager
+ * mounts no controller for this resource. The only process that mounts one is the development companion, for the
+ * workbench, which LISTs the row to learn its own id and reads it to label rows. These were `API_CALL` variants
+ * (CREATE `APP_ADMIN_SUPER_ADMIN`, UPDATE `ORG_MANAGER`, DELETE `ORG_MEMBER`), so the companion routed them: measured
+ * 2026-11-05 on the running companion, an organization OWNER's PUT and DELETE on a made-up id passed authorization and
+ * reached the not-found answer, so a member holding either role could have rewritten or deleted the row apps-manager
+ * resolves the application by. Kept as default variants because the repository refuses a verb with no default
+ * variant; where apps-manager names the UPDATE path (deregistration and restore) it resolves it through
+ * `getInternalRepositoryOperationPathDefault`. The same shape as the control-plane rows' writes
+ * (`createRepositoryOnlyDefaultVariant` in `wildo-application-tasks`).
+ */
+function createRepositoryOnlyWriteVariant(riskLevel) {
+    return {
+        variantType: ResourceOperationVariantType.REPOSITORY_ONLY,
+        isDefault: true,
+        roles: [CORE_APP_ROLES.APP_ADMIN_SUPER_ADMIN],
+        riskLevel,
+    };
+}
 export const wildoApplications_ResourceConfiguration_InitializationFactory = (resourcesRelationships) => createResourceConfiguration_Initialization({
     mainSchema: Wildo_Application_Schema,
     resourceIdentifier: CustomShared_ResourceType.WILDO_APPLICATION,
@@ -69,23 +92,7 @@ export const wildoApplications_ResourceConfiguration_InitializationFactory = (re
     ],
     customOperation: WildoApplications_Operations,
     operationsConfiguration: {
-        [CoreResourceOperation.CREATE]: {
-            variants: [
-                {
-                    variantType: ResourceOperationVariantType.API_CALL,
-                    isDefault: true,
-                    roles: [CORE_APP_ROLES.APP_ADMIN_SUPER_ADMIN],
-                    riskLevel: ResourceOperationRiskLevel.HIGH,
-                    // requestDto auto-derived from decorators
-                }
-            ],
-            userNotifications: [
-                {
-                    target: CoreUserNotificationTarget.USER_SELF,
-                    channel: CoreUserNotificationChannel.FRONT_END_SUCCESS,
-                }
-            ]
-        },
+        [CoreResourceOperation.CREATE]: { variants: [createRepositoryOnlyWriteVariant(ResourceOperationRiskLevel.HIGH)] },
         [CoreResourceOperation.READ]: {
             variants: [
                 {
@@ -124,27 +131,8 @@ export const wildoApplications_ResourceConfiguration_InitializationFactory = (re
                 }
             ],
         },
-        [CoreResourceOperation.UPDATE]: {
-            variants: [
-                {
-                    variantType: ResourceOperationVariantType.API_CALL,
-                    isDefault: true,
-                    roles: [CORE_ORG_ROLES.ORG_MANAGER],
-                    riskLevel: ResourceOperationRiskLevel.LOW,
-                    // requestDto auto-derived from decorators
-                }
-            ]
-        },
-        [CoreResourceOperation.DELETE]: {
-            variants: [
-                {
-                    variantType: ResourceOperationVariantType.API_CALL,
-                    isDefault: true,
-                    roles: [CORE_ORG_ROLES.ORG_MEMBER],
-                    riskLevel: ResourceOperationRiskLevel.LOW,
-                }
-            ]
-        },
+        [CoreResourceOperation.UPDATE]: { variants: [createRepositoryOnlyWriteVariant(ResourceOperationRiskLevel.HIGH)] },
+        [CoreResourceOperation.DELETE]: { variants: [createRepositoryOnlyWriteVariant(ResourceOperationRiskLevel.HIGH)] },
     },
     // responseSummaryDto auto-derived from isSummaryField decorators
 });