@wildo-ai/saas-models 1.0.1 → 1.1.0

package/dist/esm/files/files.shared.utils.js

@@ -14,10 +14,14 @@ export class FileScopeUtils {
     /**
      * Validates that scope identifiers are consistent with primaryScope.
      *
+     * applicationId is always required for all scope types — it is the tenant isolation field
+     * set from the execution context at file creation time, regardless of primaryScope.
+     *
      * Rules:
-     * - APPLICATION: requires applicationId
-     * - ORGANIZATIONS: requires organizationId
-     * - USER_SELF: requires organizationId + userId
+     * - APPLICATION: requires applicationId only (no organizationId, no userId)
+     * - ORGANIZATIONS: requires applicationId + organizationId (no userId)
+     * - USER_SELF: requires applicationId + userId, and NO organizationId (USER_SELF and
+     *   ORGANIZATIONS are independent primary-scope axes — a self-owned file is never org-scoped)
      *
      * ANONYMOUS is intentionally not supported for files yet. The file layer
      * fails closed until anonymous file semantics are defined end to end.
@@ -34,7 +38,7 @@ export class FileScopeUtils {
      *
      * @param scope - The scope identifiers
      * @param fileId - The file identifier
-     * @returns Path suffix like "org/{orgId}/{fileId}" or "user/{orgId}/{userId}/{fileId}"
+     * @returns Path suffix like "org/{orgId}/{fileId}" or "user/{userId}/{fileId}"
      * @throws Error if primaryScope is unsupported or unknown
      */
     static buildStoragePath(scope, fileId) {
@@ -47,7 +51,7 @@ export class FileScopeUtils {
             case ResourcePrimaryScope.ORGANIZATIONS:
                 return `org/${scope.organizationId}/${fileId}`;
             case ResourcePrimaryScope.USER_SELF:
-                return `user/${scope.organizationId}/${scope.userId}/${fileId}`;
+                return `user/${scope.userId}/${fileId}`;
             default:
                 throw new Error(`Unknown primaryScope: ${scope.primaryScope}`);
         }
@@ -71,4 +75,4 @@ export class FileScopeUtils {
         return this.validate(scope) ? scope : null;
     }
 }
-//# sourceMappingURL=files.shared.utils.js.map
+//# sourceMappingURL=files.shared.utils.js.map

package/dist/esm/files/files.shared.utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"files.shared.utils.js","sourceRoot":"","sources":["../../../src/files/files.shared.utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAC7E,OAAO,EACL,4BAA4B,GAG7B,MAAM,wBAAwB,CAAC;AAEhC;;;GAGG;AACH,MAAM,OAAO,cAAc;IACzB;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,QAAQ,CAAC,KAA2B;QACzC,OAAO,4BAA4B,CAAC,KAAK,CAAC,CAAC;IAC7C,CAAC;IAED;;;;;;;;OAQG;IACH,MAAM,CAAC,gBAAgB,CAAC,KAA2B,EAAE,MAAc;QACjE,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,+CAA+C,KAAK,CAAC,YAAY,EAAE,CAAC,CAAC;QACvF,CAAC;QAED,QAAQ,KAAK,CAAC,YAAY,EAAE,CAAC;YAC3B,KAAK,oBAAoB,CAAC,WAAW;gBACnC,OAAO,OAAO,KAAK,CAAC,aAAa,IAAI,MAAM,EAAE,CAAC;YAChD,KAAK,oBAAoB,CAAC,aAAa;gBACrC,OAAO,OAAO,KAAK,CAAC,cAAc,IAAI,MAAM,EAAE,CAAC;YACjD,KAAK,oBAAoB,CAAC,SAAS;gBACjC,OAAO,QAAQ,KAAK,CAAC,cAAc,IAAI,KAAK,CAAC,MAAM,IAAI,MAAM,EAAE,CAAC;YAClE;gBACE,MAAM,IAAI,KAAK,CAAC,yBAAyB,KAAK,CAAC,YAAY,EAAE,CAAC,CAAC;QACnE,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,eAAe,CAAC,IAAU;QAC/B,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;YACvB,OAAO,IAAI,CAAC;QACd,CAAC;QACD,MAAM,KAAK,GAAG;YACZ,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,MAAM,EAAE,IAAI,CAAC,MAAM;SACpB,CAAC;QAEF,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;IAC7C,CAAC;CACF"}
+{"version":3,"file":"files.shared.utils.js","sourceRoot":"","sources":["../../../../src/files/files.shared.utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAC7E,OAAO,EACL,4BAA4B,GAG7B,MAAM,wBAAwB,CAAC;AAEhC;;;GAGG;AACH,MAAM,OAAO,cAAc;IACzB;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CAAC,QAAQ,CAAC,KAA2B;QACzC,OAAO,4BAA4B,CAAC,KAAK,CAAC,CAAC;IAC7C,CAAC;IAED;;;;;;;;OAQG;IACH,MAAM,CAAC,gBAAgB,CAAC,KAA2B,EAAE,MAAc;QACjE,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,+CAA+C,KAAK,CAAC,YAAY,EAAE,CAAC,CAAC;QACvF,CAAC;QAED,QAAQ,KAAK,CAAC,YAAY,EAAE,CAAC;YAC3B,KAAK,oBAAoB,CAAC,WAAW;gBACnC,OAAO,OAAO,KAAK,CAAC,aAAa,IAAI,MAAM,EAAE,CAAC;YAChD,KAAK,oBAAoB,CAAC,aAAa;gBACrC,OAAO,OAAO,KAAK,CAAC,cAAc,IAAI,MAAM,EAAE,CAAC;YACjD,KAAK,oBAAoB,CAAC,SAAS;gBACjC,OAAO,QAAQ,KAAK,CAAC,MAAM,IAAI,MAAM,EAAE,CAAC;YAC1C;gBACE,MAAM,IAAI,KAAK,CAAC,yBAAyB,KAAK,CAAC,YAAY,EAAE,CAAC,CAAC;QACnE,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,eAAe,CAAC,IAAU;QAC/B,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;YACvB,OAAO,IAAI,CAAC;QACd,CAAC;QACD,MAAM,KAAK,GAAG;YACZ,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,MAAM,EAAE,IAAI,CAAC,MAAM;SACpB,CAAC;QAEF,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;IAC7C,CAAC;CACF","sourcesContent":["/**\n * File Scope Utilities\n * \n * Utility class for file scope operations including validation, \n * storage path construction, and scope extraction.\n */\n\nimport { ResourcePrimaryScope } from '../resources/resources.shared.schemas';\nimport {\n  validateFileScopeIdentifiers,\n  type File,\n  type FileScopeIdentifiers,\n} from './files.shared.schemas';\n\n/**\n * Utility class for file scope operations.\n * All methods are static and can be called without instantiation.\n */\nexport class FileScopeUtils {\n  /**\n   * Validates that scope identifiers are consistent with primaryScope.\n   *\n   * applicationId is always required for all scope types — it is the tenant isolation field\n   * set from the execution context at file creation time, regardless of primaryScope.\n   *\n   * Rules:\n   * - APPLICATION: requires applicationId only (no organizationId, no userId)\n   * - ORGANIZATIONS: requires applicationId + organizationId (no userId)\n   * - USER_SELF: requires applicationId + userId, and NO organizationId (USER_SELF and\n   *   ORGANIZATIONS are independent primary-scope axes — a self-owned file is never org-scoped)\n   *\n   * ANONYMOUS is intentionally not supported for files yet. The file layer\n   * fails closed until anonymous file semantics are defined end to end.\n   *\n   * @param scope - The scope identifiers to validate\n   * @returns true if valid, false otherwise\n   */\n  static validate(scope: FileScopeIdentifiers): boolean {\n    return validateFileScopeIdentifiers(scope);\n  }\n\n  /**\n   * Builds storage path suffix based on scope identifiers.\n   * Full path is constructed by gateway as: applications/{appId}/environments/{appEnv}/files/{scopePath}\n   * \n   * @param scope - The scope identifiers\n   * @param fileId - The file identifier\n   * @returns Path suffix like \"org/{orgId}/{fileId}\" or \"user/{userId}/{fileId}\"\n   * @throws Error if primaryScope is unsupported or unknown\n   */\n  static buildStoragePath(scope: FileScopeIdentifiers, fileId: string): string {\n    if (!this.validate(scope)) {\n      throw new Error(`Invalid scope identifiers for primaryScope: ${scope.primaryScope}`);\n    }\n\n    switch (scope.primaryScope) {\n      case ResourcePrimaryScope.APPLICATION:\n        return `app/${scope.applicationId}/${fileId}`;\n      case ResourcePrimaryScope.ORGANIZATIONS:\n        return `org/${scope.organizationId}/${fileId}`;\n      case ResourcePrimaryScope.USER_SELF:\n        return `user/${scope.userId}/${fileId}`;\n      default:\n        throw new Error(`Unknown primaryScope: ${scope.primaryScope}`);\n    }\n  }\n\n  /**\n   * Extracts scope identifiers from a File record.\n   * \n   * @param file - The file record to extract scope from\n   * @returns FileScopeIdentifiers if primaryScope is set, null otherwise\n   */\n  static extractFromFile(file: File): FileScopeIdentifiers | null {\n    if (!file.primaryScope) {\n      return null;\n    }\n    const scope = {\n      primaryScope: file.primaryScope,\n      applicationId: file.applicationId,\n      organizationId: file.organizationId,\n      userId: file.userId,\n    };\n\n    return this.validate(scope) ? scope : null;\n  }\n}\n"]}

package/dist/esm/flows-actors/a2a-push-delivery-log.shared.resources-config.schemas.d.ts

@@ -0,0 +1,40 @@
+/**
+ * A2A Push Delivery Log Resource Configuration — polymorphic across the three A2A owner scopes.
+ *
+ * Produces 3 factory functions (USER + ORG + APP). Spread into the registry factory map:
+ *   ...a2aPushDeliveryLogPolymorphicFactories
+ *
+ * Operation set, and why each one is shaped the way it is:
+ *   - READ / LIST / SEARCH (API)             : an owner inspects what was delivered on its behalf
+ *   - CREATE               (INTERNAL_CALL)   : dispatcher-only — a delivery row is EVIDENCE, and a
+ *                                              client that could author one could fabricate proof
+ *                                              that a notification was sent
+ *   - UPDATE               (INTERNAL_CALL)   : the worker's lifecycle transitions
+ *                                              (PENDING → IN_FLIGHT → DELIVERED/FAILED)
+ *   - DELETE / DELETE_MANY (REPOSITORY_ONLY) : reserved for retention purging. Deliberately NO
+ *                                              external single-row delete — a trail an owner can
+ *                                              selectively erase is not a trail
+ *
+ * **Route-lessness and TIER are two different questions, and conflating them broke this resource.**
+ * `INTERNAL_CALL` and `REPOSITORY_ONLY` are both route-less — neither exposes an HTTP surface, so the
+ * "never a public mutation" property above holds identically under either. What they differ on is which
+ * tier can REACH them. CREATE and UPDATE are written by `A2APushDeliveryLogRepository` through
+ * `*AsSystem` (the service tier), which resolves via `getServiceOperationPathDefault` and matches only
+ * `INTERNAL_CALL` / `API_CALL`; they were authored `REPOSITORY_ONLY` and therefore threw on every write
+ * until 2026-08-11. DELETE / DELETE_MANY correctly STAY `REPOSITORY_ONLY`: nothing calls them through
+ * `*AsSystem` — retention purging and the owner-scope composition cascade both run at the repository
+ * tier, which is exactly the tier `REPOSITORY_ONLY` serves. Enumerated deliberately rather than swept:
+ * changing a variant nothing calls would have been churn, and leaving one a caller DOES reach was the bug.
+ *
+ * Deliberately NO `RETRY` custom operation, unlike the M2M delivery log. Retry there is an admin
+ * repairing a tenant's own integration; here the caller is an external agent client, and letting it
+ * re-fire deliveries on demand would hand it an amplifier pointed at a URL it also chose. Retries
+ * are the worker's, on its own backoff schedule. If an operator-driven retry is ever wanted it
+ * belongs on an admin surface, not on this resource.
+ *
+ * @see notifications/m2m/m2m-webhook-delivery-log.shared.resources-config.schemas.ts — the pattern
+ * @see a2a-token-budget-state.shared.resources-config.schemas.ts — the 3-scope role precedent
+ */
+import { CoreResourceOperation } from '../resources/resources.shared.core.definitions';
+export declare const a2aPushDeliveryLogPolymorphicFactories: Record<string, import("..").ResourceConfiguration_InitializationFactory<undefined, CoreResourceOperation.READ | CoreResourceOperation.UPDATE | CoreResourceOperation.DELETE | CoreResourceOperation.DELETE_MANY | CoreResourceOperation.CREATE | CoreResourceOperation.LIST | CoreResourceOperation.SEARCH, any>>;
+//# sourceMappingURL=a2a-push-delivery-log.shared.resources-config.schemas.d.ts.map

package/dist/esm/flows-actors/a2a-push-delivery-log.shared.resources-config.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"a2a-push-delivery-log.shared.resources-config.schemas.d.ts","sourceRoot":"","sources":["../../../../src/flows-actors/a2a-push-delivery-log.shared.resources-config.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAGH,OAAO,EACL,qBAAqB,EAEtB,MAAM,gDAAgD,CAAC;AAsCxD,eAAO,MAAM,sCAAsC,mTA4IlD,CAAC"}

package/dist/esm/flows-actors/a2a-push-delivery-log.shared.resources-config.schemas.js

@@ -0,0 +1,204 @@
+/**
+ * A2A Push Delivery Log Resource Configuration — polymorphic across the three A2A owner scopes.
+ *
+ * Produces 3 factory functions (USER + ORG + APP). Spread into the registry factory map:
+ *   ...a2aPushDeliveryLogPolymorphicFactories
+ *
+ * Operation set, and why each one is shaped the way it is:
+ *   - READ / LIST / SEARCH (API)             : an owner inspects what was delivered on its behalf
+ *   - CREATE               (INTERNAL_CALL)   : dispatcher-only — a delivery row is EVIDENCE, and a
+ *                                              client that could author one could fabricate proof
+ *                                              that a notification was sent
+ *   - UPDATE               (INTERNAL_CALL)   : the worker's lifecycle transitions
+ *                                              (PENDING → IN_FLIGHT → DELIVERED/FAILED)
+ *   - DELETE / DELETE_MANY (REPOSITORY_ONLY) : reserved for retention purging. Deliberately NO
+ *                                              external single-row delete — a trail an owner can
+ *                                              selectively erase is not a trail
+ *
+ * **Route-lessness and TIER are two different questions, and conflating them broke this resource.**
+ * `INTERNAL_CALL` and `REPOSITORY_ONLY` are both route-less — neither exposes an HTTP surface, so the
+ * "never a public mutation" property above holds identically under either. What they differ on is which
+ * tier can REACH them. CREATE and UPDATE are written by `A2APushDeliveryLogRepository` through
+ * `*AsSystem` (the service tier), which resolves via `getServiceOperationPathDefault` and matches only
+ * `INTERNAL_CALL` / `API_CALL`; they were authored `REPOSITORY_ONLY` and therefore threw on every write
+ * until 2026-08-11. DELETE / DELETE_MANY correctly STAY `REPOSITORY_ONLY`: nothing calls them through
+ * `*AsSystem` — retention purging and the owner-scope composition cascade both run at the repository
+ * tier, which is exactly the tier `REPOSITORY_ONLY` serves. Enumerated deliberately rather than swept:
+ * changing a variant nothing calls would have been churn, and leaving one a caller DOES reach was the bug.
+ *
+ * Deliberately NO `RETRY` custom operation, unlike the M2M delivery log. Retry there is an admin
+ * repairing a tenant's own integration; here the caller is an external agent client, and letting it
+ * re-fire deliveries on demand would hand it an amplifier pointed at a URL it also chose. Retries
+ * are the worker's, on its own backoff schedule. If an operator-driven retry is ever wanted it
+ * belongs on an admin surface, not on this resource.
+ *
+ * @see notifications/m2m/m2m-webhook-delivery-log.shared.resources-config.schemas.ts — the pattern
+ * @see a2a-token-budget-state.shared.resources-config.schemas.ts — the 3-scope role precedent
+ */
+import { z } from 'zod';
+import { CoreResourceOperation, CoreResourceType, } from '../resources/resources.shared.core.definitions.js';
+import { ResourceOperationRiskLevel, ResourceOperationVariantType, } from '../resources/resources.shared.schemas.js';
+import { ResourceSystemAccessMode } from '../resources/resources-config.shared.schemas.js';
+import { DataPortabilityProvenance } from '../compliance/privacy/subject-export.shared.schemas.js';
+import { createPolymorphicResourceConfigurations } from '../resources/utils/resource-polymorphism.factory.js';
+import { CORE_ORG_ROLES, CORE_APP_ROLES } from '../security/authorizations/roles.shared.schemas.js';
+import { a2aPushDeliveryLogPolymorphicDeclaration, A2APushDeliveryStatus, } from './a2a-push-delivery-log.shared.schemas.js';
+/**
+ * Who may read a delivery row.
+ *
+ * A row names a webhook URL the owner itself registered and the outcome of contacting it. It
+ * carries no message content by construction (the payload is a `statusUpdate`, never a `Task` — see
+ * `a2a-push-notification-delivery.backend.utils.ts`), so owner-level read is the right bar rather
+ * than an admin one: the party that configured the delivery is the party that needs to see whether
+ * it worked, and forcing them to an admin to diagnose their own webhook helps nobody.
+ *
+ * Follows the token-budget precedent for the same three scopes.
+ */
+const OWNER_READ_ROLES = {
+    [CoreResourceType.USERS]: [CORE_APP_ROLES.APP_USER],
+    [CoreResourceType.ORGANIZATIONS]: [CORE_ORG_ROLES.ORG_MEMBER],
+    [CoreResourceType.APPLICATION]: [CORE_APP_ROLES.APP_USER],
+};
+/** Writes are the dispatcher's and the worker's; the role here gates nothing reachable over HTTP. */
+const SYSTEM_WRITE_ROLES = {
+    [CoreResourceType.USERS]: [CORE_APP_ROLES.APP_ADMIN_SUPER_ADMIN],
+    [CoreResourceType.ORGANIZATIONS]: [CORE_ORG_ROLES.ORG_ADMIN],
+    [CoreResourceType.APPLICATION]: [CORE_APP_ROLES.APP_ADMIN_SUPER_ADMIN],
+};
+export const a2aPushDeliveryLogPolymorphicFactories = createPolymorphicResourceConfigurations(a2aPushDeliveryLogPolymorphicDeclaration, {
+    isSystemResource: true,
+    /**
+     * Opt the runtime into scoped writes on the owner's behalf. Absent this, every `*AsSystem` verb
+     * fails closed.
+     *
+     * This resource follows the TASK service's pattern rather than the M2M delivery log's, and the
+     * difference is not stylistic: the M2M dispatcher runs inside the resource operation that
+     * triggered the webhook and therefore holds that operation's `ExecutionContext`, whereas a push
+     * notification is triggered by `advanceTask` — a system-owned transition with no caller context
+     * to borrow. Synthesising one at the call site would fabricate an authority nobody granted;
+     * `*AsSystem` is the door built for exactly this.
+     *
+     * No `delete` mode: nothing system-deletes a delivery row. Removal is retention purging or the
+     * owner-scope cascade, both of which run through their own paths.
+     */
+    systemAccessPolicy: {
+        // The subject's own delivery evidence — including the webhook URLs they registered. Granted
+        // because the owner can already READ/LIST/SEARCH these rows over the API, so withholding them
+        // from a subject export would make the export narrower than the product surface.
+        exportSubject: ResourceSystemAccessMode.ALLOWED,
+        create: ResourceSystemAccessMode.ALLOWED,
+        read: ResourceSystemAccessMode.ALLOWED,
+        update: ResourceSystemAccessMode.ALLOWED,
+    },
+    // Art. 20 portability provenance for the field sweep this user-DEPENDENT resource enters.
+    // Every field on a delivery row is delivery mechanics the SYSTEM observed while attempting the
+    // webhook (attempt counts, timestamps, response status, the destination recorded at send time)
+    // — none of it is content the subject provided on THIS row, so the blanket default is OBSERVED,
+    // matching the A2A siblings (task, execution, token-budget state). Without this declaration the
+    // fail-closed subject-export authority refuses the whole runtime graph at companion bootstrap
+    // ("no effective portability provenance … (undeclared)" for every field).
+    portabilityPolicy: { defaultProvenance: DataPortabilityProvenance.OBSERVED },
+    coreOperations: [
+        CoreResourceOperation.READ,
+        CoreResourceOperation.LIST,
+        CoreResourceOperation.SEARCH,
+        CoreResourceOperation.CREATE,
+        CoreResourceOperation.UPDATE,
+        CoreResourceOperation.DELETE,
+        CoreResourceOperation.DELETE_MANY,
+    ],
+    operationsConfiguration: {
+        [CoreResourceOperation.READ]: {
+            variants: [{
+                    variantType: ResourceOperationVariantType.API_CALL,
+                    isDefault: true,
+                    polymorphicRole: OWNER_READ_ROLES,
+                    riskLevel: ResourceOperationRiskLevel.LOW,
+                }],
+        },
+        [CoreResourceOperation.LIST]: {
+            variants: [{
+                    variantType: ResourceOperationVariantType.API_CALL,
+                    isDefault: true,
+                    polymorphicRole: OWNER_READ_ROLES,
+                    riskLevel: ResourceOperationRiskLevel.LOW,
+                }],
+        },
+        [CoreResourceOperation.SEARCH]: {
+            variants: [{
+                    variantType: ResourceOperationVariantType.API_CALL,
+                    isDefault: true,
+                    polymorphicRole: OWNER_READ_ROLES,
+                    riskLevel: ResourceOperationRiskLevel.LOW,
+                    isSearchable: true,
+                    // `failureReason` is searchable because "why did my webhook stop working" is the question
+                    // this resource exists to answer. `httpUrl` is NOT: it would let a caller enumerate rows
+                    // by destination, and the owner already knows its own URLs from the configuration plane.
+                    searchableFields: ['taskId', 'pushNotificationConfigId', 'failureReason'],
+                    filterFields: {
+                        status: z.enum(A2APushDeliveryStatus),
+                        taskId: z.string(),
+                        resourceServerInstanceRef: z.string(),
+                        createdAt: z.date(),
+                    },
+                    sortFields: ['createdAt', 'status', 'attemptCount'],
+                }],
+        },
+        // A delivery row is EVIDENCE that a notification was attempted. Authoring one from outside
+        // would let a caller fabricate that evidence — so CREATE carries NO HTTP surface.
+        //
+        // ⚠️ `INTERNAL_CALL`, not `REPOSITORY_ONLY`, and the distinction is load-bearing rather than
+        // stylistic. Both are route-less, so both withhold the surface equally; what differs is which
+        // TIER can reach them. `A2APushDeliveryLogRepository` writes through `*AsSystem`, which
+        // dispatches via the service tier and resolves through `getServiceOperationPathDefault` —
+        // matching only `INTERNAL_CALL` / `API_CALL`. This op was authored `REPOSITORY_ONLY`, so every
+        // `open()` threw `resources_registry_operation_path_not_found`, the dispatcher's no-throw
+        // contract swallowed it at WARN, and the whole push-delivery feature was inert for eleven days
+        // while the agent card advertised it (measured 2026-08-11 by the live lane; the config was green
+        // at boot throughout, because a variant satisfies every "the op exists" check and fails only when
+        // a service-tier caller invokes it).
+        //
+        // The sibling `flows-actors-task` config states the same rule for the same reason and is the
+        // pattern this follows: "INTERNAL_CALL (not REPOSITORY_ONLY) is mandatory". Keep the two in step —
+        // both are written by the A2A runtime through `*AsSystem`, governed by `systemAccessPolicy` above
+        // rather than by the op RBAC (`SYSTEM_WRITE_ROLES` gates nothing reachable here).
+        [CoreResourceOperation.CREATE]: {
+            variants: [{
+                    variantType: ResourceOperationVariantType.INTERNAL_CALL,
+                    isDefault: true,
+                    polymorphicRole: SYSTEM_WRITE_ROLES,
+                    riskLevel: ResourceOperationRiskLevel.LOW,
+                }],
+        },
+        // The worker's lifecycle transitions, reached through `updateAsSystem` — so `INTERNAL_CALL` for
+        // exactly the reason CREATE is, and broken the same way while it was not. Still no HTTP surface:
+        // exposing UPDATE would let a caller mark its own undelivered notifications DELIVERED.
+        [CoreResourceOperation.UPDATE]: {
+            variants: [{
+                    variantType: ResourceOperationVariantType.INTERNAL_CALL,
+                    isDefault: true,
+                    polymorphicRole: SYSTEM_WRITE_ROLES,
+                    riskLevel: ResourceOperationRiskLevel.LOW,
+                }],
+        },
+        [CoreResourceOperation.DELETE]: {
+            variants: [{
+                    variantType: ResourceOperationVariantType.REPOSITORY_ONLY,
+                    isDefault: true,
+                    polymorphicRole: SYSTEM_WRITE_ROLES,
+                    riskLevel: ResourceOperationRiskLevel.HIGH,
+                }],
+        },
+        // Retention purging. Bulk twin of DELETE, and REPOSITORY_ONLY for the same reason: a trail an
+        // owner can selectively erase is not a trail.
+        [CoreResourceOperation.DELETE_MANY]: {
+            variants: [{
+                    variantType: ResourceOperationVariantType.REPOSITORY_ONLY,
+                    isDefault: true,
+                    polymorphicRole: SYSTEM_WRITE_ROLES,
+                    riskLevel: ResourceOperationRiskLevel.HIGH,
+                }],
+        },
+    },
+});
+//# sourceMappingURL=a2a-push-delivery-log.shared.resources-config.schemas.js.map

package/dist/esm/flows-actors/a2a-push-delivery-log.shared.resources-config.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"a2a-push-delivery-log.shared.resources-config.schemas.js","sourceRoot":"","sources":["../../../../src/flows-actors/a2a-push-delivery-log.shared.resources-config.schemas.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * A2A Push Delivery Log Resource Configuration — polymorphic across the three A2A owner scopes.\n *\n * Produces 3 factory functions (USER + ORG + APP). Spread into the registry factory map:\n *   ...a2aPushDeliveryLogPolymorphicFactories\n *\n * Operation set, and why each one is shaped the way it is:\n *   - READ / LIST / SEARCH (API)             : an owner inspects what was delivered on its behalf\n *   - CREATE               (INTERNAL_CALL)   : dispatcher-only — a delivery row is EVIDENCE, and a\n *                                              client that could author one could fabricate proof\n *                                              that a notification was sent\n *   - UPDATE               (INTERNAL_CALL)   : the worker's lifecycle transitions\n *                                              (PENDING → IN_FLIGHT → DELIVERED/FAILED)\n *   - DELETE / DELETE_MANY (REPOSITORY_ONLY) : reserved for retention purging. Deliberately NO\n *                                              external single-row delete — a trail an owner can\n *                                              selectively erase is not a trail\n *\n * **Route-lessness and TIER are two different questions, and conflating them broke this resource.**\n * `INTERNAL_CALL` and `REPOSITORY_ONLY` are both route-less — neither exposes an HTTP surface, so the\n * \"never a public mutation\" property above holds identically under either. What they differ on is which\n * tier can REACH them. CREATE and UPDATE are written by `A2APushDeliveryLogRepository` through\n * `*AsSystem` (the service tier), which resolves via `getServiceOperationPathDefault` and matches only\n * `INTERNAL_CALL` / `API_CALL`; they were authored `REPOSITORY_ONLY` and therefore threw on every write\n * until 2026-08-11. DELETE / DELETE_MANY correctly STAY `REPOSITORY_ONLY`: nothing calls them through\n * `*AsSystem` — retention purging and the owner-scope composition cascade both run at the repository\n * tier, which is exactly the tier `REPOSITORY_ONLY` serves. Enumerated deliberately rather than swept:\n * changing a variant nothing calls would have been churn, and leaving one a caller DOES reach was the bug.\n *\n * Deliberately NO `RETRY` custom operation, unlike the M2M delivery log. Retry there is an admin\n * repairing a tenant's own integration; here the caller is an external agent client, and letting it\n * re-fire deliveries on demand would hand it an amplifier pointed at a URL it also chose. Retries\n * are the worker's, on its own backoff schedule. If an operator-driven retry is ever wanted it\n * belongs on an admin surface, not on this resource.\n *\n * @see notifications/m2m/m2m-webhook-delivery-log.shared.resources-config.schemas.ts — the pattern\n * @see a2a-token-budget-state.shared.resources-config.schemas.ts — the 3-scope role precedent\n */\n\nimport { z } from 'zod';\nimport {\n  CoreResourceOperation,\n  CoreResourceType,\n} from '../resources/resources.shared.core.definitions';\nimport {\n  ResourceOperationRiskLevel,\n  ResourceOperationVariantType,\n} from '../resources/resources.shared.schemas';\nimport { ResourceSystemAccessMode } from '../resources/resources-config.shared.schemas';\nimport { DataPortabilityProvenance } from '../compliance/privacy/subject-export.shared.schemas';\nimport { createPolymorphicResourceConfigurations } from '../resources/utils/resource-polymorphism.factory';\nimport { CORE_ORG_ROLES, CORE_APP_ROLES } from '../security/authorizations/roles.shared.schemas';\nimport {\n  a2aPushDeliveryLogPolymorphicDeclaration,\n  A2APushDeliveryStatus,\n} from './a2a-push-delivery-log.shared.schemas';\n\n/**\n * Who may read a delivery row.\n *\n * A row names a webhook URL the owner itself registered and the outcome of contacting it. It\n * carries no message content by construction (the payload is a `statusUpdate`, never a `Task` — see\n * `a2a-push-notification-delivery.backend.utils.ts`), so owner-level read is the right bar rather\n * than an admin one: the party that configured the delivery is the party that needs to see whether\n * it worked, and forcing them to an admin to diagnose their own webhook helps nobody.\n *\n * Follows the token-budget precedent for the same three scopes.\n */\nconst OWNER_READ_ROLES = {\n  [CoreResourceType.USERS]: [CORE_APP_ROLES.APP_USER],\n  [CoreResourceType.ORGANIZATIONS]: [CORE_ORG_ROLES.ORG_MEMBER],\n  [CoreResourceType.APPLICATION]: [CORE_APP_ROLES.APP_USER],\n};\n\n/** Writes are the dispatcher's and the worker's; the role here gates nothing reachable over HTTP. */\nconst SYSTEM_WRITE_ROLES = {\n  [CoreResourceType.USERS]: [CORE_APP_ROLES.APP_ADMIN_SUPER_ADMIN],\n  [CoreResourceType.ORGANIZATIONS]: [CORE_ORG_ROLES.ORG_ADMIN],\n  [CoreResourceType.APPLICATION]: [CORE_APP_ROLES.APP_ADMIN_SUPER_ADMIN],\n};\n\nexport const a2aPushDeliveryLogPolymorphicFactories = createPolymorphicResourceConfigurations(\n  a2aPushDeliveryLogPolymorphicDeclaration,\n  {\n    isSystemResource: true,\n\n    /**\n     * Opt the runtime into scoped writes on the owner's behalf. Absent this, every `*AsSystem` verb\n     * fails closed.\n     *\n     * This resource follows the TASK service's pattern rather than the M2M delivery log's, and the\n     * difference is not stylistic: the M2M dispatcher runs inside the resource operation that\n     * triggered the webhook and therefore holds that operation's `ExecutionContext`, whereas a push\n     * notification is triggered by `advanceTask` — a system-owned transition with no caller context\n     * to borrow. Synthesising one at the call site would fabricate an authority nobody granted;\n     * `*AsSystem` is the door built for exactly this.\n     *\n     * No `delete` mode: nothing system-deletes a delivery row. Removal is retention purging or the\n     * owner-scope cascade, both of which run through their own paths.\n     */\n    systemAccessPolicy: {\n      // The subject's own delivery evidence — including the webhook URLs they registered. Granted\n      // because the owner can already READ/LIST/SEARCH these rows over the API, so withholding them\n      // from a subject export would make the export narrower than the product surface.\n      exportSubject: ResourceSystemAccessMode.ALLOWED,\n      create: ResourceSystemAccessMode.ALLOWED,\n      read: ResourceSystemAccessMode.ALLOWED,\n      update: ResourceSystemAccessMode.ALLOWED,\n    },\n    // Art. 20 portability provenance for the field sweep this user-DEPENDENT resource enters.\n    // Every field on a delivery row is delivery mechanics the SYSTEM observed while attempting the\n    // webhook (attempt counts, timestamps, response status, the destination recorded at send time)\n    // — none of it is content the subject provided on THIS row, so the blanket default is OBSERVED,\n    // matching the A2A siblings (task, execution, token-budget state). Without this declaration the\n    // fail-closed subject-export authority refuses the whole runtime graph at companion bootstrap\n    // (\"no effective portability provenance … (undeclared)\" for every field).\n    portabilityPolicy: { defaultProvenance: DataPortabilityProvenance.OBSERVED },\n\n    coreOperations: [\n      CoreResourceOperation.READ,\n      CoreResourceOperation.LIST,\n      CoreResourceOperation.SEARCH,\n      CoreResourceOperation.CREATE,\n      CoreResourceOperation.UPDATE,\n      CoreResourceOperation.DELETE,\n      CoreResourceOperation.DELETE_MANY,\n    ],\n    operationsConfiguration: {\n      [CoreResourceOperation.READ]: {\n        variants: [{\n          variantType: ResourceOperationVariantType.API_CALL,\n          isDefault: true,\n          polymorphicRole: OWNER_READ_ROLES,\n          riskLevel: ResourceOperationRiskLevel.LOW,\n        }],\n      },\n      [CoreResourceOperation.LIST]: {\n        variants: [{\n          variantType: ResourceOperationVariantType.API_CALL,\n          isDefault: true,\n          polymorphicRole: OWNER_READ_ROLES,\n          riskLevel: ResourceOperationRiskLevel.LOW,\n        }],\n      },\n      [CoreResourceOperation.SEARCH]: {\n        variants: [{\n          variantType: ResourceOperationVariantType.API_CALL,\n          isDefault: true,\n          polymorphicRole: OWNER_READ_ROLES,\n          riskLevel: ResourceOperationRiskLevel.LOW,\n          isSearchable: true,\n          // `failureReason` is searchable because \"why did my webhook stop working\" is the question\n          // this resource exists to answer. `httpUrl` is NOT: it would let a caller enumerate rows\n          // by destination, and the owner already knows its own URLs from the configuration plane.\n          searchableFields: ['taskId', 'pushNotificationConfigId', 'failureReason'],\n          filterFields: {\n            status: z.enum(A2APushDeliveryStatus),\n            taskId: z.string(),\n            resourceServerInstanceRef: z.string(),\n            createdAt: z.date(),\n          },\n          sortFields: ['createdAt', 'status', 'attemptCount'] as const,\n        }],\n      },\n      // A delivery row is EVIDENCE that a notification was attempted. Authoring one from outside\n      // would let a caller fabricate that evidence — so CREATE carries NO HTTP surface.\n      //\n      // ⚠️ `INTERNAL_CALL`, not `REPOSITORY_ONLY`, and the distinction is load-bearing rather than\n      // stylistic. Both are route-less, so both withhold the surface equally; what differs is which\n      // TIER can reach them. `A2APushDeliveryLogRepository` writes through `*AsSystem`, which\n      // dispatches via the service tier and resolves through `getServiceOperationPathDefault` —\n      // matching only `INTERNAL_CALL` / `API_CALL`. This op was authored `REPOSITORY_ONLY`, so every\n      // `open()` threw `resources_registry_operation_path_not_found`, the dispatcher's no-throw\n      // contract swallowed it at WARN, and the whole push-delivery feature was inert for eleven days\n      // while the agent card advertised it (measured 2026-08-11 by the live lane; the config was green\n      // at boot throughout, because a variant satisfies every \"the op exists\" check and fails only when\n      // a service-tier caller invokes it).\n      //\n      // The sibling `flows-actors-task` config states the same rule for the same reason and is the\n      // pattern this follows: \"INTERNAL_CALL (not REPOSITORY_ONLY) is mandatory\". Keep the two in step —\n      // both are written by the A2A runtime through `*AsSystem`, governed by `systemAccessPolicy` above\n      // rather than by the op RBAC (`SYSTEM_WRITE_ROLES` gates nothing reachable here).\n      [CoreResourceOperation.CREATE]: {\n        variants: [{\n          variantType: ResourceOperationVariantType.INTERNAL_CALL,\n          isDefault: true,\n          polymorphicRole: SYSTEM_WRITE_ROLES,\n          riskLevel: ResourceOperationRiskLevel.LOW,\n        }],\n      },\n      // The worker's lifecycle transitions, reached through `updateAsSystem` — so `INTERNAL_CALL` for\n      // exactly the reason CREATE is, and broken the same way while it was not. Still no HTTP surface:\n      // exposing UPDATE would let a caller mark its own undelivered notifications DELIVERED.\n      [CoreResourceOperation.UPDATE]: {\n        variants: [{\n          variantType: ResourceOperationVariantType.INTERNAL_CALL,\n          isDefault: true,\n          polymorphicRole: SYSTEM_WRITE_ROLES,\n          riskLevel: ResourceOperationRiskLevel.LOW,\n        }],\n      },\n      [CoreResourceOperation.DELETE]: {\n        variants: [{\n          variantType: ResourceOperationVariantType.REPOSITORY_ONLY,\n          isDefault: true,\n          polymorphicRole: SYSTEM_WRITE_ROLES,\n          riskLevel: ResourceOperationRiskLevel.HIGH,\n        }],\n      },\n      // Retention purging. Bulk twin of DELETE, and REPOSITORY_ONLY for the same reason: a trail an\n      // owner can selectively erase is not a trail.\n      [CoreResourceOperation.DELETE_MANY]: {\n        variants: [{\n          variantType: ResourceOperationVariantType.REPOSITORY_ONLY,\n          isDefault: true,\n          polymorphicRole: SYSTEM_WRITE_ROLES,\n          riskLevel: ResourceOperationRiskLevel.HIGH,\n        }],\n      },\n    },\n  },\n);\n"]}

package/dist/esm/flows-actors/a2a-push-delivery-log.shared.schemas.d.ts

@@ -0,0 +1,113 @@
+/**
+ * A2A push-notification delivery log — one row per (task state change × registered webhook).
+ *
+ * ## Why this is a SIBLING of the M2M webhook delivery log rather than a variant of it
+ *
+ * The two share a delivery PATTERN — write the row before enqueueing, one queue job per row, the
+ * worker classifies the response and either retries or terminates — and that pattern is reused
+ * deliberately, down to the transport primitive. What they do not share is a SCOPE SET:
+ * `M2MWebhookDeliveryLog` is stamped out for `ORGANIZATIONS` and `APPLICATION`, while an A2A task
+ * can be owned by a **USER** as well. A delegated-user A2A caller is the ordinary case, not an edge
+ * one, so extending the M2M resource would have meant adding a user-scoped variant — a whole
+ * user-facing resource surface — to a shipped feature on behalf of a different subsystem.
+ *
+ * Keeping them separate also keeps the two producers separable in every query: a resource-operation
+ * notification and a task-lifecycle notification are different facts about different things, and an
+ * operator filtering one should never have to exclude the other by hand.
+ *
+ * ## Why the row is written BEFORE the delivery is attempted
+ *
+ * Copied from the M2M dispatcher's reasoning, because it is the property that makes this table
+ * worth having: if the worker created the row on its first attempt, an unreachable queue would
+ * leave no trace at all. Writing it up front means an operator always sees an entry per
+ * (task transition × webhook), including the deliveries that never got as far as being tried.
+ *
+ * spec-cite: A2A 1.0 §4.3.3 — *"Agents MUST attempt delivery at least once for each configured
+ * webhook"* — and §13.2, which asks for retry with exponential backoff and permits giving up after
+ * a configured number of consecutive failures. This row is where all three become observable.
+ *
+ * @see notifications/m2m/m2m-webhook-delivery-log.shared.schemas.ts — the pattern this mirrors
+ * @see a2a-token-budget-state.shared.schemas.ts — the 3-scope A2A polymorphic precedent
+ */
+import { z } from 'zod';
+import { type PolymorphicVariantDefinition } from '../resources/utils/resource-polymorphism.schemas';
+/**
+ * The delivery lifecycle:
+ *   PENDING → IN_FLIGHT → DELIVERED   (acknowledged with 2xx)
+ *   PENDING → IN_FLIGHT → PENDING     (transient failure — retry scheduled with backoff)
+ *   PENDING → IN_FLIGHT → FAILED      (terminal — non-retryable status, or attempts exhausted)
+ *
+ * Deliberately its OWN enum rather than a reuse of `M2MWebhookDeliveryLogStatus`, even though the
+ * members coincide. That enum is named for, and owned by, the M2M notifications feature; importing
+ * it here would couple flows-actors to that subsystem's release cycle for no gain, and would make
+ * either feature's future state change a cross-feature edit. If a third outbound-delivery consumer
+ * ever appears, the answer is to extract ONE shared vocabulary — not to have the second consumer
+ * borrow the first one's.
+ */
+export declare enum A2APushDeliveryStatus {
+    PENDING = "pending",
+    IN_FLIGHT = "in_flight",
+    DELIVERED = "delivered",
+    FAILED = "failed"
+}
+export declare const A2APushDeliveryLogSchema: z.ZodObject<{
+    _id: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    deliveryId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    taskId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    pushNotificationConfigId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
+    resourceServerInstanceRef: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    machineCredentialId: z.ZodOptional<z.ZodString>;
+    httpUrl: z.ZodURL;
+    payloadHash: z.ZodString;
+    payload: z.ZodUnknown;
+    status: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodEnum<typeof A2APushDeliveryStatus>>>>;
+    attemptCount: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodNumber>>;
+    lastAttemptAt: z.ZodOptional<z.ZodDate>;
+    nextAttemptAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodOptional<z.ZodDate>>;
+    responseStatus: z.ZodOptional<z.ZodNumber>;
+    responseBodyTruncated: z.ZodOptional<z.ZodString>;
+    failureReason: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodOptional<z.ZodString>>;
+    deliveredAt: z.ZodOptional<z.ZodDate>;
+    failedAt: z.ZodOptional<z.ZodDate>;
+    createdAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodDate>>>;
+}, z.core.$strip>;
+export type A2APushDeliveryLogBase = z.infer<typeof A2APushDeliveryLogSchema>;
+/**
+ * The three owner scopes an A2A task — and therefore its deliveries — can belong to.
+ *
+ * Mirrors `flowActorTasksPolymorphicDeclaration`'s scope set exactly, and must keep mirroring it: a
+ * task owner with no delivery-log variant is a task whose notifications cannot be recorded, which
+ * is the audit hole this table exists to close.
+ */
+export declare const A2A_PUSH_DELIVERY_SCOPE_VARIANTS: PolymorphicVariantDefinition[];
+/**
+ * Produces 3 variants:
+ *   - users         → `userA2aPushDeliveryLog`        (`userId` injected)
+ *   - organizations → `organizationA2aPushDeliveryLog` (`organizationId` injected)
+ *   - applications  → `applicationA2aPushDeliveryLog`  (`applicationId` injected)
+ *
+ * Multi-row, so it opts OUT of the singleton auto-business-key: unlike the token-budget
+ * accumulator, there are many delivery rows per owner and the owner FK is not their identity.
+ */
+export declare const a2aPushDeliveryLogPolymorphicDeclaration: import("..").PolymorphicSchemaDeclaration<z.ZodObject<{
+    _id: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    deliveryId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    taskId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    pushNotificationConfigId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
+    resourceServerInstanceRef: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    machineCredentialId: z.ZodOptional<z.ZodString>;
+    httpUrl: z.ZodURL;
+    payloadHash: z.ZodString;
+    payload: z.ZodUnknown;
+    status: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodEnum<typeof A2APushDeliveryStatus>>>>;
+    attemptCount: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodNumber>>;
+    lastAttemptAt: z.ZodOptional<z.ZodDate>;
+    nextAttemptAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodOptional<z.ZodDate>>;
+    responseStatus: z.ZodOptional<z.ZodNumber>;
+    responseBodyTruncated: z.ZodOptional<z.ZodString>;
+    failureReason: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodOptional<z.ZodString>>;
+    deliveredAt: z.ZodOptional<z.ZodDate>;
+    failedAt: z.ZodOptional<z.ZodDate>;
+    createdAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDefault<z.ZodDate>>>;
+}, z.core.$strip>>;
+//# sourceMappingURL=a2a-push-delivery-log.shared.schemas.d.ts.map

package/dist/esm/flows-actors/a2a-push-delivery-log.shared.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"a2a-push-delivery-log.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/flows-actors/a2a-push-delivery-log.shared.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,OAAO,EAGL,KAAK,4BAA4B,EAClC,MAAM,kDAAkD,CAAC;AAI1D;;;;;;;;;;;;GAYG;AACH,oBAAY,qBAAqB;IAC/B,OAAO,YAAY;IACnB,SAAS,cAAc;IACvB,SAAS,cAAc;IACvB,MAAM,WAAW;CAClB;AAED,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;iBA+EnC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE9E;;;;;;GAMG;AACH,eAAO,MAAM,gCAAgC,EAAE,4BAA4B,EAI1E,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;kBAMnD,CAAC"}

package/dist/esm/flows-actors/a2a-push-delivery-log.shared.schemas.js

@@ -0,0 +1,153 @@
+/**
+ * A2A push-notification delivery log — one row per (task state change × registered webhook).
+ *
+ * ## Why this is a SIBLING of the M2M webhook delivery log rather than a variant of it
+ *
+ * The two share a delivery PATTERN — write the row before enqueueing, one queue job per row, the
+ * worker classifies the response and either retries or terminates — and that pattern is reused
+ * deliberately, down to the transport primitive. What they do not share is a SCOPE SET:
+ * `M2MWebhookDeliveryLog` is stamped out for `ORGANIZATIONS` and `APPLICATION`, while an A2A task
+ * can be owned by a **USER** as well. A delegated-user A2A caller is the ordinary case, not an edge
+ * one, so extending the M2M resource would have meant adding a user-scoped variant — a whole
+ * user-facing resource surface — to a shipped feature on behalf of a different subsystem.
+ *
+ * Keeping them separate also keeps the two producers separable in every query: a resource-operation
+ * notification and a task-lifecycle notification are different facts about different things, and an
+ * operator filtering one should never have to exclude the other by hand.
+ *
+ * ## Why the row is written BEFORE the delivery is attempted
+ *
+ * Copied from the M2M dispatcher's reasoning, because it is the property that makes this table
+ * worth having: if the worker created the row on its first attempt, an unreachable queue would
+ * leave no trace at all. Writing it up front means an operator always sees an entry per
+ * (task transition × webhook), including the deliveries that never got as far as being tried.
+ *
+ * spec-cite: A2A 1.0 §4.3.3 — *"Agents MUST attempt delivery at least once for each configured
+ * webhook"* — and §13.2, which asks for retry with exponential backoff and permits giving up after
+ * a configured number of consecutive failures. This row is where all three become observable.
+ *
+ * @see notifications/m2m/m2m-webhook-delivery-log.shared.schemas.ts — the pattern this mirrors
+ * @see a2a-token-budget-state.shared.schemas.ts — the 3-scope A2A polymorphic precedent
+ */
+import { z } from 'zod';
+import { PersonalDataCategory } from '../compliance/privacy/personal-data-category.shared.schemas.js';
+import { addDataCategories, initZodDecorators } from '@wildo-ai/zod-decorators';
+import { CoreResourceType, coreResourceShared_FieldIdentifier, } from '../resources/resources.shared.core.definitions.js';
+import { declarePolymorphicSchemas, optOutPolymorphicAutoBusinessKey, } from '../resources/utils/resource-polymorphism.schemas.js';
+initZodDecorators(z);
+/**
+ * The delivery lifecycle:
+ *   PENDING → IN_FLIGHT → DELIVERED   (acknowledged with 2xx)
+ *   PENDING → IN_FLIGHT → PENDING     (transient failure — retry scheduled with backoff)
+ *   PENDING → IN_FLIGHT → FAILED      (terminal — non-retryable status, or attempts exhausted)
+ *
+ * Deliberately its OWN enum rather than a reuse of `M2MWebhookDeliveryLogStatus`, even though the
+ * members coincide. That enum is named for, and owned by, the M2M notifications feature; importing
+ * it here would couple flows-actors to that subsystem's release cycle for no gain, and would make
+ * either feature's future state change a cross-feature edit. If a third outbound-delivery consumer
+ * ever appears, the answer is to extract ONE shared vocabulary — not to have the second consumer
+ * borrow the first one's.
+ */
+export var A2APushDeliveryStatus;
+(function (A2APushDeliveryStatus) {
+    A2APushDeliveryStatus["PENDING"] = "pending";
+    A2APushDeliveryStatus["IN_FLIGHT"] = "in_flight";
+    A2APushDeliveryStatus["DELIVERED"] = "delivered";
+    A2APushDeliveryStatus["FAILED"] = "failed";
+})(A2APushDeliveryStatus || (A2APushDeliveryStatus = {}));
+export const A2APushDeliveryLogSchema = z.object({
+    /** Document id — auto-generated / auto-managed (excluded from create). */
+    _id: z.string().min(1).isPrimaryKey().isSummaryField(),
+    /**
+     * The stable identity of this delivery, generated once when the row is written and sent with
+     * every attempt so a receiver can deduplicate.
+     *
+     * spec-cite: A2A 1.0 §4.3.3 — *"Clients SHOULD process notifications idempotently, as duplicate
+     * deliveries may occur"*. A client can only honour that if duplicates are RECOGNISABLE, which
+     * means the id must be stable across retries — hence generated at row creation, never per attempt.
+     */
+    deliveryId: z.string().min(1).isDBIndexed().isSummaryField(),
+    /** The task whose transition triggered this notification. */
+    taskId: z.string().min(1).isDBIndexed().isSummaryField(),
+    /** Which registered configuration this row delivers to — a task may have several. */
+    pushNotificationConfigId: z.string().min(1).isSummaryField(),
+    /**
+     * The agent instance the task belongs to. Carried so an operator can attribute deliveries per
+     * agent, and so a per-instance purge never reaches another agent's rows — the same isolation
+     * axis the task read enforces.
+     */
+    resourceServerInstanceRef: z.string().min(1).isDBIndexed().isSummaryField(),
+    /**
+     * The machine credential that owns the task, when one does.
+     *
+     * Carried because the worker must RE-READ the live configuration to obtain the client's
+     * credential (see the worker for why the secret is not copied onto this row), and that read
+     * enforces all four isolation axes. Without this field the read falls back to the "no credential"
+     * sentinel and matches nothing for any task a machine client created — which is most A2A tasks,
+     * since client-credentials auth is the ordinary way an agent connects.
+     *
+     * Optional rather than sentinel-defaulted: a delegated-user task genuinely has no machine
+     * credential, and storing a sentinel here would make "absent" and "explicitly none" the same
+     * value on a row whose whole job is to be evidence.
+     */
+    machineCredentialId: z.string().min(1).optional(),
+    /** The destination, captured as it was AT DISPATCH — a later config edit must not rewrite history. */
+    httpUrl: z.url(),
+    payloadHash: z.string().min(1),
+    // USER_CONTENT — the delivered payload carries the task's own content, which originated with the
+    // person. The declaration says what the field is FOR; a payload can hold anything a task held.
+    //
+    // `addDataCategories` rather than the fluent form: `z.unknown()` is one of the types that carry NO
+    // prototype-installed decorators at all (a decorator-WIDE gap, not specific to this one), so
+    // `.dataCategories(...)` does not type-check on it. The helper is the documented escape hatch.
+    payload: addDataCategories(z.unknown(), PersonalDataCategory.USER_CONTENT),
+    status: z
+        .enum(A2APushDeliveryStatus)
+        .default(A2APushDeliveryStatus.PENDING)
+        .isDBIndexed()
+        .isSummaryField(),
+    attemptCount: z.number().int().nonnegative().default(0).isSummaryField(),
+    lastAttemptAt: z.date().optional(),
+    /** When the next retry becomes eligible. Indexed — this is the worker's drain query. */
+    nextAttemptAt: z.date().optional().isDBIndexed(),
+    responseStatus: z.number().int().optional(),
+    /** Truncated by the worker before persistence: a webhook may answer with an unbounded body. */
+    responseBodyTruncated: z.string().optional(),
+    failureReason: z.string().optional().isSummaryField(),
+    deliveredAt: z.date().optional(),
+    failedAt: z.date().optional(),
+    createdAt: z
+        .date()
+        .default(() => new Date())
+        .isDBIndexed()
+        .isSummaryField(),
+});
+/**
+ * The three owner scopes an A2A task — and therefore its deliveries — can belong to.
+ *
+ * Mirrors `flowActorTasksPolymorphicDeclaration`'s scope set exactly, and must keep mirroring it: a
+ * task owner with no delivery-log variant is a task whose notifications cannot be recorded, which
+ * is the audit hole this table exists to close.
+ */
+export const A2A_PUSH_DELIVERY_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 },
+];
+/**
+ * Produces 3 variants:
+ *   - users         → `userA2aPushDeliveryLog`        (`userId` injected)
+ *   - organizations → `organizationA2aPushDeliveryLog` (`organizationId` injected)
+ *   - applications  → `applicationA2aPushDeliveryLog`  (`applicationId` injected)
+ *
+ * Multi-row, so it opts OUT of the singleton auto-business-key: unlike the token-budget
+ * accumulator, there are many delivery rows per owner and the owner FK is not their identity.
+ */
+export const a2aPushDeliveryLogPolymorphicDeclaration = declarePolymorphicSchemas({
+    baseResourceType: 'a2aPushDeliveryLog',
+    baseFieldIdentifier: 'a2aPushDeliveryLogId',
+    baseEnumKey: 'A2A_PUSH_DELIVERY_LOG',
+    baseSchema: A2APushDeliveryLogSchema,
+    variants: A2A_PUSH_DELIVERY_SCOPE_VARIANTS.map(optOutPolymorphicAutoBusinessKey),
+});
+//# sourceMappingURL=a2a-push-delivery-log.shared.schemas.js.map