@wildo-ai/saas-models 1.0.1 → 1.1.0

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

@@ -0,0 +1,317 @@
+/**
+ * Flows-actors TASK — the persisted, protocol-facing work record.
+ *
+ * ## Why this exists as its own family (and is NOT the conversation row)
+ *
+ * The engine keeps two DELIBERATELY SEPARATE physical planes:
+ *
+ * - `*FlowActorExecutions` owns **conversational** session history (the WS/A2A
+ *   message log, its status, its owner). Every turn has one.
+ * - **This family** owns **work lifecycle** — an addressable, pollable,
+ *   cancelable handle with its own status, artifacts and terminal outcome.
+ *
+ * `.claude/context/flows-actors.md` states the rule the hard way: an A2A-backed
+ * treatment "links the continuum to both concrete records; it does not copy the
+ * conversation into the task or recast the conversation row as a playbook run."
+ * Merging them — e.g. treating `executionId` as the A2A task id — collapses two
+ * planes the architecture keeps apart on purpose.
+ *
+ * ## Why it derives from `Actors_Task_Schema`
+ *
+ * `Actors_Task_Schema` is the CANONICAL task contract (status, artifacts,
+ * relationships, memory, per-actor states, error states, journey/playbook
+ * correlation). The platform already persists it the same way —
+ * `Wildo_Application_Actor_Task_Schema = Actors_Task_Schema.extend({...})` with
+ * scope FKs plus an OPTIONAL execution FK. This family mirrors that proven
+ * pattern at engine level rather than inventing a third task model.
+ *
+ * ⚠️ NOTE on a constraint that DOES apply here — this paragraph previously claimed the
+ * opposite and was wrong. The `FlowActorExecutionBaseSchema` warning about heavy nested
+ * sub-structures not round-tripping Zod→Mongoose is NOT limited to embedding a task
+ * inside an execution: Mongoose instantiates an empty subdocument for an optional nested
+ * object and then fails its REQUIRED inner paths, whatever the nesting depth. A real-Mongo
+ * service-tier test proved it — every create died on
+ * `errorStates → customMessageReference is required`. That is why the heavy nested
+ * orchestration state is OMITTED below rather than made optional.
+ *
+ * ## Ownership
+ *
+ * Polymorphic over the same three scopes as executions, so a user-delegated A2A
+ * turn and an org/app MACHINE turn each own their tasks under the principal that
+ * actually made the call. The owner FK is injected per variant by
+ * `declarePolymorphicSchemas()`; do NOT add an `initiator` snapshot here (a
+ * nested `initiator.organizationId` collides with the contextual scope filter —
+ * see the same warning on the execution base schema).
+ */
+import { z } from 'zod';
+import { initZodDecorators } from '@wildo-ai/zod-decorators';
+import { FlowsActors_Status } from './flows-actors.commons.shared.schemas.js';
+import { DataPortabilityProvenance } from '../compliance/privacy/subject-export.shared.schemas.js';
+import { PersonalDataCategory } from '../compliance/privacy/personal-data-category.shared.schemas.js';
+import { Actors_Task_Schema } from './tasks.actors.shared.schemas.js';
+import { CoreResourceType, coreResourceShared_FieldIdentifier, } from '../resources/resources.shared.core.definitions.js';
+import { declarePolymorphicSchemas, optOutPolymorphicAutoBusinessKey, } from '../resources/utils/resource-polymorphism.schemas.js';
+initZodDecorators(z);
+//===============================================================
+//  Base task record — NO owner scope FK (injected per variant)
+//===============================================================
+/**
+ * The work record shared by every scope variant.
+ *
+ * Derived from the canonical `Actors_Task_Schema` and narrowed with persistence
+ * concerns: a primary key, indexes on the fields the A2A surface queries, and the
+ * OPTIONAL link back to the conversational execution that produced it.
+ */
+export const FlowActorTaskBaseSchema = Actors_Task_Schema.omit({
+    // === HEAVY NESTED ORCHESTRATION STATE — OMITTED, NOT MADE OPTIONAL ===
+    //
+    // ⚠️ CORRECTION to an earlier claim in this file's history. The warning on
+    // `FlowActorExecutionBaseSchema` — that heavy nested sub-structures do NOT round-trip
+    // through the Zod→Mongoose embedded-subdocument conversion as optional slots — was
+    // dismissed here on the grounds that it applied only to EMBEDDING a task inside an
+    // execution, not to persisting tasks as their own collection. **That was wrong**, and a
+    // service-tier test against real MongoDB proved it: Mongoose instantiates an empty
+    // subdocument for an optional nested object and then fails its REQUIRED inner paths, so
+    // every create died on `errorStates → customMessageReference is required`. The trap is
+    // about optional nested objects with required inner paths — nesting DEPTH is irrelevant.
+    //
+    // Making them `.optional()` does not help (that was the first attempted fix and it
+    // failed identically). They are therefore OMITTED: an A2A-materialised task genuinely
+    // has no actor decomposition, no per-actor state, no memory and no error graph. When an
+    // orchestration runtime actually produces that state, add it back WITH the
+    // embedded-subdocument treatment the execution schema prescribes — not by relaxing a
+    // required path.
+    errorStates: true,
+    memory: true,
+    actorStates: true,
+    relationships: true,
+    actors: true,
+    initiator: true,
+    context: true,
+    // G2-6: `startedAt` / `completedAt` are ISO `z.string()` on the canonical schema and would
+    // sit beside this family's `z.date()` timestamps — the exact mixed-representation trap this
+    // file warns about below. Nothing reads or writes them here (`finishedAt` carries the
+    // terminal moment), so they are omitted rather than left as an unread inconsistency.
+    startedAt: true,
+    completedAt: true,
+}).extend({
+    // Scalar orchestration fields — safe to keep, merely absent on an A2A task.
+    // ── Provenance, per field, because the resource default cannot be right for all of them ──
+    //
+    // The config's `defaultProvenance: OBSERVED` fits the LIFECYCLE fields (status, timestamps, ids —
+    // things the platform recorded about the work). It is wrong in BOTH directions for the content:
+    //
+    //   • `title` / `input` / `description` / `topic` are SUBJECT_PROVIDED — they carry what the
+    //     requester actually said. ⚠️ This is a PRECISION change, not a behaviour change: an earlier
+    //     revision claimed OBSERVED "under-scopes an Art. 20 bundle", which is false against this
+    //     framework — `resolvePortabilityFieldScope` maps OBSERVED *and* SUBJECT_PROVIDED to
+    //     INCLUDED, and the enum's own documentation says OBSERVED is "in scope for Art. 20, which is
+    //     the whole reason this member exists". The reclassification is still right (these fields
+    //     genuinely came from the subject), but only the DERIVED half below changes what a bundle
+    //     contains.
+    //   • `output` / `artifacts` are DERIVED — model output about the subject rather than from them.
+    //     Classifying THOSE as observed over-delivers generated content into a portability bundle,
+    //     which the enum's own documentation excludes.
+    //
+    // All five also declare `USER_CONTENT` as their data CATEGORY — a separate axis, and the reason
+    // both are needed here: provenance decides Art. 20 SCOPE (is it in the portability bundle),
+    // category decides what a privacy notice ENUMERATES. `output` is excluded from a bundle and is
+    // still content held about a person, so a notice must name it. Declared rather than left blank
+    // because a field carrying a provenance and no category is reported as an OUTSTANDING gap, by
+    // name, in every generated application's notice — the engine owes its own inventory.
+    description: Actors_Task_Schema.shape.description.optional()
+        .portabilityProvenance(DataPortabilityProvenance.SUBJECT_PROVIDED)
+        .dataCategories(PersonalDataCategory.USER_CONTENT),
+    topic: Actors_Task_Schema.shape.topic.optional()
+        .portabilityProvenance(DataPortabilityProvenance.SUBJECT_PROVIDED)
+        .dataCategories(PersonalDataCategory.USER_CONTENT),
+    input: Actors_Task_Schema.shape.input.optional()
+        .portabilityProvenance(DataPortabilityProvenance.SUBJECT_PROVIDED)
+        .dataCategories(PersonalDataCategory.USER_CONTENT),
+    // ⚠️ RE-WRAP with `.optional()` FIRST — decorating these leaves in place mutates the CANONICAL
+    // schema (finding G7-3). Wrapper decorators mirror onto the inner type copy-on-write, but only
+    // ONE level: the three fields above are safe because `.optional()` mints a fresh wrapper before
+    // the decorator runs, whereas `output`/`artifacts` are ALREADY optional wrappers on the base
+    // schema, so nothing fresh was minted and the decoration landed on `Actors_Task_Schema` itself.
+    //
+    // Runtime-proven, and the FIRST fix was wrong: `.clone()` is a shallow copy that still shares the
+    // inner type, so it isolated nothing — measured `CANON leaked: derived`. `.optional()` (or
+    // `.nullish()`) mints the fresh wrapper the copy-on-write needs; measured `CANON leaked:
+    // undefined` with the decoration intact on the family. Double-optional is harmless — the outer
+    // wrapper exists to carry the decoration.
+    //
+    // Why it matters: `undefined` means "nobody decided", a DESIGNED refusal that
+    // `resolvePortabilityFieldScope` surfaces as UNDECLARED. `DERIVED` means "decided to EXCLUDE". In
+    // place, the leak silently converted an open question into an answer for every consumer of the
+    // canonical schema — `standaloneTasks` and the platform's application-task resource — and did it
+    // import-order-dependently.
+    output: Actors_Task_Schema.shape.output.optional()
+        .portabilityProvenance(DataPortabilityProvenance.DERIVED)
+        .dataCategories(PersonalDataCategory.USER_CONTENT),
+    artifacts: Actors_Task_Schema.shape.artifacts.optional()
+        .portabilityProvenance(DataPortabilityProvenance.DERIVED)
+        .dataCategories(PersonalDataCategory.USER_CONTENT),
+    /** MongoDB document id — auto-generated / auto-managed (excluded from create). */
+    _id: z.string().min(1).isPrimaryKey().isSummaryField(),
+    /**
+     * Stable business id, and the identity the A2A protocol addresses: this is the
+     * value returned as `Task.id` and accepted by `tasks/get` / `tasks/cancel`.
+     *
+     * ⚠️ `scope: 'global'` is enforced PER VARIANT, not across the family: the three
+     * variants are three separate stores, so the index cannot span them. Nothing depends on
+     * family-wide uniqueness — `readTask` resolves the variant from the authenticated
+     * owner BEFORE matching the id, so two identical ids in different scopes would never be
+     * confused (and a v4 uuid collision is not a real risk anyway). Recorded because the
+     * decorator name reads stronger than what it can deliver here.
+     */
+    taskId: z.uuid().isUnique({ scope: 'global', sparse: false }).excludeFromUpdate().isSummaryField(),
+    /**
+     * OPTIONAL link to the conversational execution this task was materialised from.
+     *
+     * A SOFT link, deliberately: it stores the execution's globally-unique
+     * `executionId` business id and is NOT declared as a resource foreign key. Two
+     * reasons, both load-bearing:
+     *
+     * 1. **Executions are polymorphic.** Their per-variant field identifiers are
+     *    `userFlowActorExecutionId` / `organizationFlowActorExecutionId` /
+     *    `applicationFlowActorExecutionId`, so one `flowActorExecutionId` FK matches
+     *    no variant. A real FK would mean declaring 3×3 (or 3 matched-pair)
+     *    relationships to express "some execution".
+     * 2. **We do not want the graph semantics.** A declared relationship implies
+     *    population and a cascade path; a task must be able to OUTLIVE the execution
+     *    that produced it (that is the entire point of keeping the two planes
+     *    separate), so deleting a conversation must not delete its work records.
+     *
+     * Ownership and cascade already flow from the injected scope FK, which is the
+     * only authority that should govern a task's lifetime. Indexed so "the tasks of
+     * this conversation" stays a single-field query.
+     */
+    flowActorExecutionId: z.string().isDBIndexed().optional(),
+    /**
+     * WHICH A2A agent (resource-server instance) this task was created through.
+     *
+     * Part of the read/cancel filter, not merely descriptive metadata. A2A agents are declared as
+     * SEPARATE resource servers — tokens are audience-bound per instance, and an agent must have
+     * "no side-door into another agent's actor system". Without this field the task plane had no
+     * per-agent dimension at all, so a token bound to agent B could read and cancel a task created
+     * through agent A whenever both resolved to the same owner scope. Since `title` carries the
+     * first 120 characters of the originating prompt, that also disclosed prompt text across the
+     * boundary the audience binding exists to enforce.
+     *
+     * Always populated: the DEFAULT (unnamed) agent is a real identity too and is stored under a
+     * sentinel that cannot collide with a declared ref (instance refs are constrained to
+     * `^[a-z0-9][a-z0-9-]*$`). Storing a normalised value rather than leaving the default agent's
+     * tasks null keeps the filter a plain equality on both persistence adapters, instead of
+     * depending on how each one matches an absent field.
+     */
+    resourceServerInstanceRef: z.string().min(1).isDBIndexed(),
+    /**
+     * WHICH machine credential opened this record — part of the read filter, not metadata.
+     *
+     * The injected scope FK does not identify the principal on the machine variants:
+     * `applicationId` is a deployment singleton and `organizationId` is shared by every machine
+     * client of one tenant, so without this axis a separately-credentialed client could read and
+     * cancel another's work — and `title` carries the opening characters of the originating prompt.
+     *
+     * User-delegated turns store {@link FLOWS_ACTORS_NO_MACHINE_CREDENTIAL}: there the human is the
+     * principal and the `userId` owner FK already discriminates.
+     */
+    machineCredentialId: z.string().min(1).isDBIndexed(),
+    /** Indexed: `tasks/get` and the abandoned-task sweep both filter on status. */
+    status: z.enum(FlowsActors_Status).isDBIndexed().isSummaryField(),
+    /**
+     * Short human-readable name for the work.
+     *
+     * ⚠️ CONTENT-BEARING, and `.isSummaryField()` puts it on the `/summary` projection: the A2A
+     * transport fills it with the opening 120 characters of the ORIGINATING PROMPT. Treat it as
+     * subject-provided content, not a label — it is why the read filter carries the agent-instance
+     * and machine-credential axes, and why the portability policy classifies it separately from the
+     * observed lifecycle fields.
+     */
+    title: z.string().min(1).isSummaryField()
+        .portabilityProvenance(DataPortabilityProvenance.SUBJECT_PROVIDED)
+        // The opening 120 characters of the originating PROMPT, per the note above — content, not a label.
+        .dataCategories(PersonalDataCategory.USER_CONTENT),
+    /**
+     * A2A `contextId` — threads related turns. Indexed so a client can enumerate
+     * the tasks of one conversation without walking executions.
+     */
+    contextId: z.string().isDBIndexed().optional(),
+    // === Timestamps are `z.date()` with defaults, NOT the canonical schema's ISO
+    //     strings: the persistence layer date-coerces, and a missing default
+    //     yields `Invalid Date` on create (same rationale as the execution base). ===
+    createdAt: z.date().default(() => new Date()).excludeFromCreate().excludeFromUpdate(),
+    /**
+     * Indexed because the abandoned-task SWEEP filters on it (`updatedAt < cutoff` AND a status set),
+     * once per variant per run. Without an index that query is a sequential scan over a collection
+     * that only ever grows — terminal tasks are never deleted — so the sweep gets slower forever
+     * while doing the same work. The sibling `status` index was declared for this query from the
+     * start; this axis was left off, which made the pair half-served (review finding L-1).
+     */
+    updatedAt: z.date().default(() => new Date()).excludeFromCreate().excludeFromUpdate().isDBIndexed(),
+    /** Set when the task reaches a terminal state; never on create. */
+    finishedAt: z.date().optional().excludeFromCreate(),
+    /**
+     * The task's A2A push-notification configurations, SERIALIZED as a JSON string.
+     *
+     * A scalar string for the same reason `pausedApproval` is one: heavy nested sub-structures do not
+     * round-trip through the Zod→Mongoose embedded-subdocument conversion, and this is a LIST of
+     * objects that themselves nest (`authentication.schemes[]`). Parse and serialize ONLY through the
+     * helpers below, at the persistence boundary.
+     *
+     * ⚠️ The stored blob contains CREDENTIALS the client gave us to present to its own webhook
+     * (`token`, `authentication.credentials`). It is therefore backend-only by intent: nothing
+     * projects this field to a client, and the read path redacts before answering. See
+     * `redactPushNotificationSecrets`.
+     */
+    pushNotificationConfigs: z.string().nullish().excludeFromCreate().isBackendOnly(),
+});
+//===============================================================
+//  Polymorphic declaration — one owner-scope variant per scope
+//===============================================================
+/**
+ * The three owner-scope variants a task is stamped out for — the SAME set as
+ * executions, so ownership of a task always matches the principal that drove the
+ * turn. Each opts OUT of the singleton auto-business-key: tasks are MULTI-ROW per
+ * scope, so the injected owner FK must NOT be marked `.isUnique()` (the second
+ * task per scope would otherwise fail with a duplicate-key error).
+ */
+export const FLOW_ACTOR_TASK_SCOPE_VARIANTS = [
+    { parentResourceType: CoreResourceType.USERS, parentFieldIdentifier: coreResourceShared_FieldIdentifier[CoreResourceType.USERS], isPrimaryScope: true },
+    { parentResourceType: CoreResourceType.ORGANIZATIONS, parentFieldIdentifier: coreResourceShared_FieldIdentifier[CoreResourceType.ORGANIZATIONS], isPrimaryScope: true },
+    { parentResourceType: CoreResourceType.APPLICATION, parentFieldIdentifier: coreResourceShared_FieldIdentifier[CoreResourceType.APPLICATION], isPrimaryScope: true },
+].map(optOutPolymorphicAutoBusinessKey);
+/**
+ * Polymorphic declaration for flows-actors tasks. Produces 3 variants:
+ *   - users         → `userFlowActorTasks`         (`userId` injected)
+ *   - organizations → `organizationFlowActorTasks` (`organizationId` injected)
+ *   - applications  → `applicationFlowActorTasks`  (`applicationId` injected)
+ */
+export const flowActorTasksPolymorphicDeclaration = declarePolymorphicSchemas({
+    baseResourceType: 'flowActorTasks',
+    baseFieldIdentifier: 'flowActorTaskId',
+    baseEnumKey: 'FLOW_ACTOR_TASKS',
+    baseSchema: FlowActorTaskBaseSchema,
+    variants: FLOW_ACTOR_TASK_SCOPE_VARIANTS,
+});
+/**
+ * Owner-agnostic UPDATE DTO — the mutations the task lifecycle actually performs.
+ * Shared across variants because it references NO owner FK (owner is immutable).
+ */
+export const FlowActorTaskUpdateInternalSchema = z.object({
+    status: FlowActorTaskBaseSchema.shape.status.optional(),
+    output: FlowActorTaskBaseSchema.shape.output,
+    artifacts: FlowActorTaskBaseSchema.shape.artifacts,
+    // `actorStates` / `errorStates` are deliberately ABSENT — they are omitted from the
+    // persisted family (see the omit block above), so an update DTO referencing them would
+    // be a contract for a column that does not exist.
+    finishedAt: FlowActorTaskBaseSchema.shape.finishedAt,
+    /**
+     * ⚠️ THIS SCHEMA IS AN ALLOW-LIST. A field absent here does not fail on write — the write
+     * SUCCEEDS and persists nothing, which is how `pausedApproval` shipped unwritable and left every
+     * paused turn unresumable. `.nullish()` because clearing a task's configurations is a real
+     * transition (`pushNotificationConfig/delete` removing the last one).
+     */
+    pushNotificationConfigs: FlowActorTaskBaseSchema.shape.pushNotificationConfigs,
+});
+//# sourceMappingURL=flows-actors-task.shared.schemas.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flows-actors-task.shared.schemas.js","sourceRoot":"","sources":["../../../../src/flows-actors/flows-actors-task.shared.schemas.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Flows-actors TASK — the persisted, protocol-facing work record.\n *\n * ## Why this exists as its own family (and is NOT the conversation row)\n *\n * The engine keeps two DELIBERATELY SEPARATE physical planes:\n *\n * - `*FlowActorExecutions` owns **conversational** session history (the WS/A2A\n *   message log, its status, its owner). Every turn has one.\n * - **This family** owns **work lifecycle** — an addressable, pollable,\n *   cancelable handle with its own status, artifacts and terminal outcome.\n *\n * `.claude/context/flows-actors.md` states the rule the hard way: an A2A-backed\n * treatment \"links the continuum to both concrete records; it does not copy the\n * conversation into the task or recast the conversation row as a playbook run.\"\n * Merging them — e.g. treating `executionId` as the A2A task id — collapses two\n * planes the architecture keeps apart on purpose.\n *\n * ## Why it derives from `Actors_Task_Schema`\n *\n * `Actors_Task_Schema` is the CANONICAL task contract (status, artifacts,\n * relationships, memory, per-actor states, error states, journey/playbook\n * correlation). The platform already persists it the same way —\n * `Wildo_Application_Actor_Task_Schema = Actors_Task_Schema.extend({...})` with\n * scope FKs plus an OPTIONAL execution FK. This family mirrors that proven\n * pattern at engine level rather than inventing a third task model.\n *\n * ⚠️ NOTE on a constraint that DOES apply here — this paragraph previously claimed the\n * opposite and was wrong. The `FlowActorExecutionBaseSchema` warning about heavy nested\n * sub-structures not round-tripping Zod→Mongoose is NOT limited to embedding a task\n * inside an execution: Mongoose instantiates an empty subdocument for an optional nested\n * object and then fails its REQUIRED inner paths, whatever the nesting depth. A real-Mongo\n * service-tier test proved it — every create died on\n * `errorStates → customMessageReference is required`. That is why the heavy nested\n * orchestration state is OMITTED below rather than made optional.\n *\n * ## Ownership\n *\n * Polymorphic over the same three scopes as executions, so a user-delegated A2A\n * turn and an org/app MACHINE turn each own their tasks under the principal that\n * actually made the call. The owner FK is injected per variant by\n * `declarePolymorphicSchemas()`; do NOT add an `initiator` snapshot here (a\n * nested `initiator.organizationId` collides with the contextual scope filter —\n * see the same warning on the execution base schema).\n */\n\nimport { z } from 'zod';\nimport { initZodDecorators } from '@wildo-ai/zod-decorators';\n\nimport { FLOWS_ACTORS_NO_MACHINE_CREDENTIAL, FlowsActors_Status } from './flows-actors.commons.shared.schemas';\nimport { DataPortabilityProvenance } from '../compliance/privacy/subject-export.shared.schemas';\nimport { PersonalDataCategory } from '../compliance/privacy/personal-data-category.shared.schemas';\nimport { Actors_Task_Schema } from './tasks.actors.shared.schemas';\nimport {\n  CoreResourceType,\n  coreResourceShared_FieldIdentifier,\n} from '../resources/resources.shared.core.definitions';\nimport {\n  declarePolymorphicSchemas,\n  optOutPolymorphicAutoBusinessKey,\n  type PolymorphicVariantDefinition,\n} from '../resources/utils/resource-polymorphism.schemas';\n\ninitZodDecorators(z);\n\n//===============================================================\n//  Base task record — NO owner scope FK (injected per variant)\n//===============================================================\n\n/**\n * The work record shared by every scope variant.\n *\n * Derived from the canonical `Actors_Task_Schema` and narrowed with persistence\n * concerns: a primary key, indexes on the fields the A2A surface queries, and the\n * OPTIONAL link back to the conversational execution that produced it.\n */\nexport const FlowActorTaskBaseSchema = Actors_Task_Schema.omit({\n  // === HEAVY NESTED ORCHESTRATION STATE — OMITTED, NOT MADE OPTIONAL ===\n  //\n  // ⚠️ CORRECTION to an earlier claim in this file's history. The warning on\n  // `FlowActorExecutionBaseSchema` — that heavy nested sub-structures do NOT round-trip\n  // through the Zod→Mongoose embedded-subdocument conversion as optional slots — was\n  // dismissed here on the grounds that it applied only to EMBEDDING a task inside an\n  // execution, not to persisting tasks as their own collection. **That was wrong**, and a\n  // service-tier test against real MongoDB proved it: Mongoose instantiates an empty\n  // subdocument for an optional nested object and then fails its REQUIRED inner paths, so\n  // every create died on `errorStates → customMessageReference is required`. The trap is\n  // about optional nested objects with required inner paths — nesting DEPTH is irrelevant.\n  //\n  // Making them `.optional()` does not help (that was the first attempted fix and it\n  // failed identically). They are therefore OMITTED: an A2A-materialised task genuinely\n  // has no actor decomposition, no per-actor state, no memory and no error graph. When an\n  // orchestration runtime actually produces that state, add it back WITH the\n  // embedded-subdocument treatment the execution schema prescribes — not by relaxing a\n  // required path.\n  errorStates: true,\n  memory: true,\n  actorStates: true,\n  relationships: true,\n  actors: true,\n  initiator: true,\n  context: true,\n  // G2-6: `startedAt` / `completedAt` are ISO `z.string()` on the canonical schema and would\n  // sit beside this family's `z.date()` timestamps — the exact mixed-representation trap this\n  // file warns about below. Nothing reads or writes them here (`finishedAt` carries the\n  // terminal moment), so they are omitted rather than left as an unread inconsistency.\n  startedAt: true,\n  completedAt: true,\n}).extend({\n  // Scalar orchestration fields — safe to keep, merely absent on an A2A task.\n  // ── Provenance, per field, because the resource default cannot be right for all of them ──\n  //\n  // The config's `defaultProvenance: OBSERVED` fits the LIFECYCLE fields (status, timestamps, ids —\n  // things the platform recorded about the work). It is wrong in BOTH directions for the content:\n  //\n  //   • `title` / `input` / `description` / `topic` are SUBJECT_PROVIDED — they carry what the\n  //     requester actually said. ⚠️ This is a PRECISION change, not a behaviour change: an earlier\n  //     revision claimed OBSERVED \"under-scopes an Art. 20 bundle\", which is false against this\n  //     framework — `resolvePortabilityFieldScope` maps OBSERVED *and* SUBJECT_PROVIDED to\n  //     INCLUDED, and the enum's own documentation says OBSERVED is \"in scope for Art. 20, which is\n  //     the whole reason this member exists\". The reclassification is still right (these fields\n  //     genuinely came from the subject), but only the DERIVED half below changes what a bundle\n  //     contains.\n  //   • `output` / `artifacts` are DERIVED — model output about the subject rather than from them.\n  //     Classifying THOSE as observed over-delivers generated content into a portability bundle,\n  //     which the enum's own documentation excludes.\n  //\n  // All five also declare `USER_CONTENT` as their data CATEGORY — a separate axis, and the reason\n  // both are needed here: provenance decides Art. 20 SCOPE (is it in the portability bundle),\n  // category decides what a privacy notice ENUMERATES. `output` is excluded from a bundle and is\n  // still content held about a person, so a notice must name it. Declared rather than left blank\n  // because a field carrying a provenance and no category is reported as an OUTSTANDING gap, by\n  // name, in every generated application's notice — the engine owes its own inventory.\n  description: Actors_Task_Schema.shape.description.optional()\n    .portabilityProvenance(DataPortabilityProvenance.SUBJECT_PROVIDED)\n    .dataCategories(PersonalDataCategory.USER_CONTENT),\n  topic: Actors_Task_Schema.shape.topic.optional()\n    .portabilityProvenance(DataPortabilityProvenance.SUBJECT_PROVIDED)\n    .dataCategories(PersonalDataCategory.USER_CONTENT),\n  input: Actors_Task_Schema.shape.input.optional()\n    .portabilityProvenance(DataPortabilityProvenance.SUBJECT_PROVIDED)\n    .dataCategories(PersonalDataCategory.USER_CONTENT),\n  // ⚠️ RE-WRAP with `.optional()` FIRST — decorating these leaves in place mutates the CANONICAL\n  // schema (finding G7-3). Wrapper decorators mirror onto the inner type copy-on-write, but only\n  // ONE level: the three fields above are safe because `.optional()` mints a fresh wrapper before\n  // the decorator runs, whereas `output`/`artifacts` are ALREADY optional wrappers on the base\n  // schema, so nothing fresh was minted and the decoration landed on `Actors_Task_Schema` itself.\n  //\n  // Runtime-proven, and the FIRST fix was wrong: `.clone()` is a shallow copy that still shares the\n  // inner type, so it isolated nothing — measured `CANON leaked: derived`. `.optional()` (or\n  // `.nullish()`) mints the fresh wrapper the copy-on-write needs; measured `CANON leaked:\n  // undefined` with the decoration intact on the family. Double-optional is harmless — the outer\n  // wrapper exists to carry the decoration.\n  //\n  // Why it matters: `undefined` means \"nobody decided\", a DESIGNED refusal that\n  // `resolvePortabilityFieldScope` surfaces as UNDECLARED. `DERIVED` means \"decided to EXCLUDE\". In\n  // place, the leak silently converted an open question into an answer for every consumer of the\n  // canonical schema — `standaloneTasks` and the platform's application-task resource — and did it\n  // import-order-dependently.\n  output: Actors_Task_Schema.shape.output.optional()\n    .portabilityProvenance(DataPortabilityProvenance.DERIVED)\n    .dataCategories(PersonalDataCategory.USER_CONTENT),\n  artifacts: Actors_Task_Schema.shape.artifacts.optional()\n    .portabilityProvenance(DataPortabilityProvenance.DERIVED)\n    .dataCategories(PersonalDataCategory.USER_CONTENT),\n\n  /** MongoDB document id — auto-generated / auto-managed (excluded from create). */\n  _id: z.string().min(1).isPrimaryKey().isSummaryField(),\n\n  /**\n   * Stable business id, and the identity the A2A protocol addresses: this is the\n   * value returned as `Task.id` and accepted by `tasks/get` / `tasks/cancel`.\n   *\n   * ⚠️ `scope: 'global'` is enforced PER VARIANT, not across the family: the three\n   * variants are three separate stores, so the index cannot span them. Nothing depends on\n   * family-wide uniqueness — `readTask` resolves the variant from the authenticated\n   * owner BEFORE matching the id, so two identical ids in different scopes would never be\n   * confused (and a v4 uuid collision is not a real risk anyway). Recorded because the\n   * decorator name reads stronger than what it can deliver here.\n   */\n  taskId: z.uuid().isUnique({ scope: 'global', sparse: false }).excludeFromUpdate().isSummaryField(),\n\n  /**\n   * OPTIONAL link to the conversational execution this task was materialised from.\n   *\n   * A SOFT link, deliberately: it stores the execution's globally-unique\n   * `executionId` business id and is NOT declared as a resource foreign key. Two\n   * reasons, both load-bearing:\n   *\n   * 1. **Executions are polymorphic.** Their per-variant field identifiers are\n   *    `userFlowActorExecutionId` / `organizationFlowActorExecutionId` /\n   *    `applicationFlowActorExecutionId`, so one `flowActorExecutionId` FK matches\n   *    no variant. A real FK would mean declaring 3×3 (or 3 matched-pair)\n   *    relationships to express \"some execution\".\n   * 2. **We do not want the graph semantics.** A declared relationship implies\n   *    population and a cascade path; a task must be able to OUTLIVE the execution\n   *    that produced it (that is the entire point of keeping the two planes\n   *    separate), so deleting a conversation must not delete its work records.\n   *\n   * Ownership and cascade already flow from the injected scope FK, which is the\n   * only authority that should govern a task's lifetime. Indexed so \"the tasks of\n   * this conversation\" stays a single-field query.\n   */\n  flowActorExecutionId: z.string().isDBIndexed().optional(),\n\n  /**\n   * WHICH A2A agent (resource-server instance) this task was created through.\n   *\n   * Part of the read/cancel filter, not merely descriptive metadata. A2A agents are declared as\n   * SEPARATE resource servers — tokens are audience-bound per instance, and an agent must have\n   * \"no side-door into another agent's actor system\". Without this field the task plane had no\n   * per-agent dimension at all, so a token bound to agent B could read and cancel a task created\n   * through agent A whenever both resolved to the same owner scope. Since `title` carries the\n   * first 120 characters of the originating prompt, that also disclosed prompt text across the\n   * boundary the audience binding exists to enforce.\n   *\n   * Always populated: the DEFAULT (unnamed) agent is a real identity too and is stored under a\n   * sentinel that cannot collide with a declared ref (instance refs are constrained to\n   * `^[a-z0-9][a-z0-9-]*$`). Storing a normalised value rather than leaving the default agent's\n   * tasks null keeps the filter a plain equality on both persistence adapters, instead of\n   * depending on how each one matches an absent field.\n   */\n  resourceServerInstanceRef: z.string().min(1).isDBIndexed(),\n\n  /**\n   * WHICH machine credential opened this record — part of the read filter, not metadata.\n   *\n   * The injected scope FK does not identify the principal on the machine variants:\n   * `applicationId` is a deployment singleton and `organizationId` is shared by every machine\n   * client of one tenant, so without this axis a separately-credentialed client could read and\n   * cancel another's work — and `title` carries the opening characters of the originating prompt.\n   *\n   * User-delegated turns store {@link FLOWS_ACTORS_NO_MACHINE_CREDENTIAL}: there the human is the\n   * principal and the `userId` owner FK already discriminates.\n   */\n  machineCredentialId: z.string().min(1).isDBIndexed(),\n\n  /** Indexed: `tasks/get` and the abandoned-task sweep both filter on status. */\n  status: z.enum(FlowsActors_Status).isDBIndexed().isSummaryField(),\n\n  /**\n   * Short human-readable name for the work.\n   *\n   * ⚠️ CONTENT-BEARING, and `.isSummaryField()` puts it on the `/summary` projection: the A2A\n   * transport fills it with the opening 120 characters of the ORIGINATING PROMPT. Treat it as\n   * subject-provided content, not a label — it is why the read filter carries the agent-instance\n   * and machine-credential axes, and why the portability policy classifies it separately from the\n   * observed lifecycle fields.\n   */\n  title: z.string().min(1).isSummaryField()\n    .portabilityProvenance(DataPortabilityProvenance.SUBJECT_PROVIDED)\n    // The opening 120 characters of the originating PROMPT, per the note above — content, not a label.\n    .dataCategories(PersonalDataCategory.USER_CONTENT),\n\n  /**\n   * A2A `contextId` — threads related turns. Indexed so a client can enumerate\n   * the tasks of one conversation without walking executions.\n   */\n  contextId: z.string().isDBIndexed().optional(),\n\n  // === Timestamps are `z.date()` with defaults, NOT the canonical schema's ISO\n  //     strings: the persistence layer date-coerces, and a missing default\n  //     yields `Invalid Date` on create (same rationale as the execution base). ===\n  createdAt: z.date().default(() => new Date()).excludeFromCreate().excludeFromUpdate(),\n  /**\n   * Indexed because the abandoned-task SWEEP filters on it (`updatedAt < cutoff` AND a status set),\n   * once per variant per run. Without an index that query is a sequential scan over a collection\n   * that only ever grows — terminal tasks are never deleted — so the sweep gets slower forever\n   * while doing the same work. The sibling `status` index was declared for this query from the\n   * start; this axis was left off, which made the pair half-served (review finding L-1).\n   */\n  updatedAt: z.date().default(() => new Date()).excludeFromCreate().excludeFromUpdate().isDBIndexed(),\n  /** Set when the task reaches a terminal state; never on create. */\n  finishedAt: z.date().optional().excludeFromCreate(),\n  /**\n   * The task's A2A push-notification configurations, SERIALIZED as a JSON string.\n   *\n   * A scalar string for the same reason `pausedApproval` is one: heavy nested sub-structures do not\n   * round-trip through the Zod→Mongoose embedded-subdocument conversion, and this is a LIST of\n   * objects that themselves nest (`authentication.schemes[]`). Parse and serialize ONLY through the\n   * helpers below, at the persistence boundary.\n   *\n   * ⚠️ The stored blob contains CREDENTIALS the client gave us to present to its own webhook\n   * (`token`, `authentication.credentials`). It is therefore backend-only by intent: nothing\n   * projects this field to a client, and the read path redacts before answering. See\n   * `redactPushNotificationSecrets`.\n   */\n  pushNotificationConfigs: z.string().nullish().excludeFromCreate().isBackendOnly(),\n});\nexport type FlowActorTaskBase = z.infer<typeof FlowActorTaskBaseSchema>;\n\n//===============================================================\n//  Polymorphic declaration — one owner-scope variant per scope\n//===============================================================\n\n/**\n * The three owner-scope variants a task is stamped out for — the SAME set as\n * executions, so ownership of a task always matches the principal that drove the\n * turn. Each opts OUT of the singleton auto-business-key: tasks are MULTI-ROW per\n * scope, so the injected owner FK must NOT be marked `.isUnique()` (the second\n * task per scope would otherwise fail with a duplicate-key error).\n */\nexport const FLOW_ACTOR_TASK_SCOPE_VARIANTS: PolymorphicVariantDefinition[] = [\n  { parentResourceType: CoreResourceType.USERS,         parentFieldIdentifier: coreResourceShared_FieldIdentifier[CoreResourceType.USERS],         isPrimaryScope: true },\n  { parentResourceType: CoreResourceType.ORGANIZATIONS, parentFieldIdentifier: coreResourceShared_FieldIdentifier[CoreResourceType.ORGANIZATIONS], isPrimaryScope: true },\n  { parentResourceType: CoreResourceType.APPLICATION,   parentFieldIdentifier: coreResourceShared_FieldIdentifier[CoreResourceType.APPLICATION],   isPrimaryScope: true },\n].map(optOutPolymorphicAutoBusinessKey);\n\n/**\n * Polymorphic declaration for flows-actors tasks. Produces 3 variants:\n *   - users         → `userFlowActorTasks`         (`userId` injected)\n *   - organizations → `organizationFlowActorTasks` (`organizationId` injected)\n *   - applications  → `applicationFlowActorTasks`  (`applicationId` injected)\n */\nexport const flowActorTasksPolymorphicDeclaration = declarePolymorphicSchemas({\n  baseResourceType: 'flowActorTasks',\n  baseFieldIdentifier: 'flowActorTaskId',\n  baseEnumKey: 'FLOW_ACTOR_TASKS',\n  baseSchema: FlowActorTaskBaseSchema,\n  variants: FLOW_ACTOR_TASK_SCOPE_VARIANTS,\n});\n\n/**\n * Owner-agnostic UPDATE DTO — the mutations the task lifecycle actually performs.\n * Shared across variants because it references NO owner FK (owner is immutable).\n */\nexport const FlowActorTaskUpdateInternalSchema = z.object({\n  status: FlowActorTaskBaseSchema.shape.status.optional(),\n  output: FlowActorTaskBaseSchema.shape.output,\n  artifacts: FlowActorTaskBaseSchema.shape.artifacts,\n  // `actorStates` / `errorStates` are deliberately ABSENT — they are omitted from the\n  // persisted family (see the omit block above), so an update DTO referencing them would\n  // be a contract for a column that does not exist.\n  finishedAt: FlowActorTaskBaseSchema.shape.finishedAt,\n  /**\n   * ⚠️ THIS SCHEMA IS AN ALLOW-LIST. A field absent here does not fail on write — the write\n   * SUCCEEDS and persists nothing, which is how `pausedApproval` shipped unwritable and left every\n   * paused turn unresumable. `.nullish()` because clearing a task's configurations is a real\n   * transition (`pushNotificationConfig/delete` removing the last one).\n   */\n  pushNotificationConfigs: FlowActorTaskBaseSchema.shape.pushNotificationConfigs,\n});\n\n/**\n * Runtime shape of a persisted task (the base record). The owner FK is\n * variant-specific (`userId` | `organizationId` | `applicationId`) and read from\n * the concrete variant; the runtime supplies it explicitly on create.\n */\nexport type FlowActorTask = z.infer<typeof FlowActorTaskBaseSchema>;\n"]}