@wildo-ai/saas-models 1.0.1 → 1.1.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"actions.meta-workflows.shared.schemas.js","sourceRoot":"","sources":["../../../../../src/flows-actors/meta-workflows/actions.meta-workflows.shared.schemas.ts"],"names":[],"mappings":"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","sourcesContent":["import { z } from 'zod';\n\nimport {\n  ExecutionBindingIdSchema,\n} from './continuity-identifiers.meta-workflows.shared.schemas';\nimport {\n  MetaWorkflow_ExecutionAuthorityResolutionSchema,\n  MetaWorkflow_AccumulatedCostSchema,\n  MetaWorkflow_ExecutionBindingCommonFieldsSchema,\n  MetaWorkflow_ExternalCorrelationSchema,\n} from './execution-binding-common.meta-workflows.shared.schemas';\nimport { MetaWorkflow_ExecutionBindingRole } from '../task-continuity-binding.actors.shared.schemas';\nimport {\n  MetaWorkflow_IsoDateTimeSchema,\n  MetaWorkflow_LowercaseUuidV4Schema,\n  MetaWorkflow_NamespacedRefSchema,\n  MetaWorkflow_OpaqueRefSchema,\n  MetaWorkflow_PositiveOrdinalSchema,\n  MetaWorkflow_PositiveVersionSchema,\n  metaWorkflowValuesAreLexicallySorted,\n  metaWorkflowValuesAreUnique,\n} from './portable-primitives.meta-workflows.shared.schemas';\n\n/** Semantic owner of a technical Driver Request. */\nexport enum MetaWorkflow_DriverRequestOwnerKind {\n  ACTION_BINDING = 'ACTION_BINDING',\n  EVALUATOR_BINDING = 'EVALUATOR_BINDING',\n  PROMOTION_EFFECT_BINDING = 'PROMOTION_EFFECT_BINDING',\n}\n\n/** Physical lifecycle offered by a Driver descriptor. */\nexport enum MetaWorkflow_DriverLifecycle {\n  INLINE_TERMINAL = 'INLINE_TERMINAL',\n  ASYNC_OBSERVABLE = 'ASYNC_OBSERVABLE',\n  CHECKPOINT_RESUMABLE = 'CHECKPOINT_RESUMABLE',\n}\n\n/** Optional lifecycle operations that a concrete Driver really implements. */\nexport enum MetaWorkflow_DriverLifecycleFacet {\n  CANCELLABLE = 'CANCELLABLE',\n  INPUT_RESUMABLE = 'INPUT_RESUMABLE',\n  CHECKPOINT_EMITTING = 'CHECKPOINT_EMITTING',\n  OBSERVABLE = 'OBSERVABLE',\n  STREAMING = 'STREAMING',\n}\n\n/** Declared consequence of a technical failure. */\nexport enum MetaWorkflow_FailureDisposition {\n  FAIL_BINDING = 'FAIL_BINDING',\n  RETRY_NEW_BINDING = 'RETRY_NEW_BINDING',\n  REQUEST_INPUT = 'REQUEST_INPUT',\n  RECONCILE = 'RECONCILE',\n  KEEP_AND_FLAG = 'KEEP_AND_FLAG',\n  ABORT_TREATMENT = 'ABORT_TREATMENT',\n  ESCALATE_CONFLICT = 'ESCALATE_CONFLICT',\n}\n\nconst _MetaWorkflow_UniqueNamespacedRefsSchema = z\n  .array(MetaWorkflow_NamespacedRefSchema)\n  .refine(metaWorkflowValuesAreUnique, {\n    message: 'refs must be unique',\n  });\n\nconst _MetaWorkflow_NonEmptyUniqueNamespacedRefsSchema = _MetaWorkflow_UniqueNamespacedRefsSchema.min(1);\n\n/**\n * Stable semantic work definition. It describes intent and constraints, never\n * the concrete human/agent/tool/protocol chosen to realize the work.\n */\nconst _MetaWorkflow_ActionDefinitionSchema = z.strictObject({\n  schemaVersion: z.literal(1),\n  actionRef: MetaWorkflow_NamespacedRefSchema,\n  actionVersion: MetaWorkflow_PositiveVersionSchema,\n  intentRef: MetaWorkflow_NamespacedRefSchema,\n  inputSelectorRefs: _MetaWorkflow_UniqueNamespacedRefsSchema,\n  outcomeContractRefs: _MetaWorkflow_NonEmptyUniqueNamespacedRefsSchema,\n  effectSafetyPolicyRef: MetaWorkflow_NamespacedRefSchema,\n  allowedCapabilityClassRefs:\n    _MetaWorkflow_NonEmptyUniqueNamespacedRefsSchema,\n  requiredCapabilityFacetRefs: _MetaWorkflow_UniqueNamespacedRefsSchema,\n  authorityRequirementRef: MetaWorkflow_NamespacedRefSchema.nullable(),\n  budgetPolicyRef: MetaWorkflow_NamespacedRefSchema,\n  continuationPolicyRef: MetaWorkflow_NamespacedRefSchema,\n  decisionPointDefinitionRefs: _MetaWorkflow_UniqueNamespacedRefsSchema,\n});\nexport const MetaWorkflow_ActionDefinitionSchema: typeof _MetaWorkflow_ActionDefinitionSchema =\n  _MetaWorkflow_ActionDefinitionSchema;\nexport type MetaWorkflow_ActionDefinition = z.infer<\n  typeof _MetaWorkflow_ActionDefinitionSchema\n>;\n\n/**\n * Declarative Driver capabilities. Runtime implementation provenance is\n * intentionally separate and must be proven by the backend binding registry.\n */\nconst _MetaWorkflow_DriverDescriptorSchema = z\n  .strictObject({\n    schemaVersion: z.literal(1),\n    driverRef: MetaWorkflow_NamespacedRefSchema,\n    driverVersion: MetaWorkflow_PositiveVersionSchema,\n    admittedOwnerKinds: z\n      .array(z.enum(MetaWorkflow_DriverRequestOwnerKind))\n      .min(1),\n    requestSchemaRef: MetaWorkflow_NamespacedRefSchema,\n    resultSchemaRef: MetaWorkflow_NamespacedRefSchema,\n    lifecycle: z.enum(MetaWorkflow_DriverLifecycle),\n    capabilityClassRefs: _MetaWorkflow_NonEmptyUniqueNamespacedRefsSchema,\n    capabilityFacetRefs: _MetaWorkflow_UniqueNamespacedRefsSchema,\n    supportedFailureDispositions: z\n      .array(z.enum(MetaWorkflow_FailureDisposition))\n      .min(1),\n    lifecycleFacets: z.array(z.enum(MetaWorkflow_DriverLifecycleFacet)),\n  })\n  .superRefine((descriptor, context) => {\n    const orderedEnumArrays: ReadonlyArray<{\n      path: string;\n      values: ReadonlyArray<string>;\n    }> = [\n      {\n        path: 'admittedOwnerKinds',\n        values: descriptor.admittedOwnerKinds,\n      },\n      {\n        path: 'supportedFailureDispositions',\n        values: descriptor.supportedFailureDispositions,\n      },\n      {\n        path: 'lifecycleFacets',\n        values: descriptor.lifecycleFacets,\n      },\n    ];\n\n    for (const { path, values } of orderedEnumArrays) {\n      if (!metaWorkflowValuesAreUnique(values)) {\n        context.addIssue({\n          code: 'custom',\n          message: `${path} must contain unique values`,\n          path: [path],\n        });\n      }\n      if (!metaWorkflowValuesAreLexicallySorted(values)) {\n        context.addIssue({\n          code: 'custom',\n          message: `${path} must use canonical lexical order`,\n          path: [path],\n        });\n      }\n    }\n\n    const facets = new Set(descriptor.lifecycleFacets);\n    if (\n      descriptor.lifecycle ===\n        MetaWorkflow_DriverLifecycle.INLINE_TERMINAL &&\n      (facets.has(MetaWorkflow_DriverLifecycleFacet.OBSERVABLE) ||\n        facets.has(\n          MetaWorkflow_DriverLifecycleFacet.CHECKPOINT_EMITTING,\n        ) ||\n        facets.has(MetaWorkflow_DriverLifecycleFacet.INPUT_RESUMABLE))\n    ) {\n      context.addIssue({\n        code: 'custom',\n        message:\n          'INLINE_TERMINAL cannot advertise observation, checkpoint, or input-resume facets',\n        path: ['lifecycleFacets'],\n      });\n    }\n\n    if (\n      descriptor.lifecycle ===\n        MetaWorkflow_DriverLifecycle.ASYNC_OBSERVABLE &&\n      !facets.has(MetaWorkflow_DriverLifecycleFacet.OBSERVABLE)\n    ) {\n      context.addIssue({\n        code: 'custom',\n        message: 'ASYNC_OBSERVABLE requires the OBSERVABLE facet',\n        path: ['lifecycleFacets'],\n      });\n    }\n\n    if (\n      descriptor.lifecycle ===\n        MetaWorkflow_DriverLifecycle.CHECKPOINT_RESUMABLE &&\n      (!facets.has(MetaWorkflow_DriverLifecycleFacet.OBSERVABLE) ||\n        !facets.has(\n          MetaWorkflow_DriverLifecycleFacet.CHECKPOINT_EMITTING,\n        ))\n    ) {\n      context.addIssue({\n        code: 'custom',\n        message:\n          'CHECKPOINT_RESUMABLE requires OBSERVABLE and CHECKPOINT_EMITTING facets',\n        path: ['lifecycleFacets'],\n      });\n    }\n  });\nexport const MetaWorkflow_DriverDescriptorSchema: typeof _MetaWorkflow_DriverDescriptorSchema =\n  _MetaWorkflow_DriverDescriptorSchema;\nexport type MetaWorkflow_DriverDescriptor = z.infer<\n  typeof _MetaWorkflow_DriverDescriptorSchema\n>;\n\n"]}

package/dist/esm/flows-actors/meta-workflows/budget-authority.meta-workflows.shared.schemas.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export declare enum MetaWorkflowStructuredGenerationPlanKind {
+    SINGLE_CALL = "SINGLE_CALL",
+    CHUNKED = "CHUNKED",
+    /** Leaf ceiling is exceeded, but the root semantics cannot be preserved across partial calls. */
+    UNCHUNKABLE_OVER_LIMIT = "UNCHUNKABLE_OVER_LIMIT"
+}
+export declare const MetaWorkflowStructuredGenerationPlanV1Schema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    providerConfigurationDigest: z.ZodString;
+    outputSchemaRef: z.ZodString;
+    outputSchemaDigest: z.ZodString;
+    leafFieldCount: z.ZodNumber;
+    maximumLeafFieldsPerCall: z.ZodNumber;
+    planKind: z.ZodEnum<typeof MetaWorkflowStructuredGenerationPlanKind>;
+    physicalCallCount: z.ZodNumber;
+    planDigest: z.ZodString;
+}, z.core.$strict>;
+export type MetaWorkflowStructuredGenerationPlanV1 = z.infer<typeof MetaWorkflowStructuredGenerationPlanV1Schema>;
+//# sourceMappingURL=budget-authority.meta-workflows.shared.schemas.d.ts.map

package/dist/esm/flows-actors/meta-workflows/budget-authority.meta-workflows.shared.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"budget-authority.meta-workflows.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../../src/flows-actors/meta-workflows/budget-authority.meta-workflows.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,oBAAY,wCAAwC;IAClD,WAAW,gBAAgB;IAC3B,OAAO,YAAY;IACnB,iGAAiG;IACjG,sBAAsB,2BAA2B;CAClD;AAED,eAAO,MAAM,4CAA4C;;;;;;;;;;kBAqBvD,CAAC;AACH,MAAM,MAAM,sCAAsC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4CAA4C,CAAC,CAAC"}

package/dist/esm/flows-actors/meta-workflows/budget-authority.meta-workflows.shared.schemas.js

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { MetaWorkflow_NamespacedRefSchema, MetaWorkflow_Sha256DigestSchema, } from './portable-primitives.meta-workflows.shared.schemas.js';
+const nonnegativeSafeIntegerSchema = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).refine((value) => !Object.is(value, -0), 'negative zero is not canonical');
+const positiveSafeIntegerSchema = nonnegativeSafeIntegerSchema.refine((value) => value > 0, 'value must be positive');
+export var MetaWorkflowStructuredGenerationPlanKind;
+(function (MetaWorkflowStructuredGenerationPlanKind) {
+    MetaWorkflowStructuredGenerationPlanKind["SINGLE_CALL"] = "SINGLE_CALL";
+    MetaWorkflowStructuredGenerationPlanKind["CHUNKED"] = "CHUNKED";
+    /** Leaf ceiling is exceeded, but the root semantics cannot be preserved across partial calls. */
+    MetaWorkflowStructuredGenerationPlanKind["UNCHUNKABLE_OVER_LIMIT"] = "UNCHUNKABLE_OVER_LIMIT";
+})(MetaWorkflowStructuredGenerationPlanKind || (MetaWorkflowStructuredGenerationPlanKind = {}));
+export const MetaWorkflowStructuredGenerationPlanV1Schema = z.strictObject({
+    schemaVersion: z.literal(1),
+    providerConfigurationDigest: MetaWorkflow_Sha256DigestSchema,
+    outputSchemaRef: MetaWorkflow_NamespacedRefSchema,
+    outputSchemaDigest: MetaWorkflow_Sha256DigestSchema,
+    leafFieldCount: positiveSafeIntegerSchema,
+    maximumLeafFieldsPerCall: positiveSafeIntegerSchema,
+    planKind: z.enum(MetaWorkflowStructuredGenerationPlanKind),
+    physicalCallCount: nonnegativeSafeIntegerSchema,
+    planDigest: MetaWorkflow_Sha256DigestSchema,
+}).superRefine((plan, context) => {
+    const exceedsLimit = plan.leafFieldCount > plan.maximumLeafFieldsPerCall;
+    if (plan.planKind === MetaWorkflowStructuredGenerationPlanKind.SINGLE_CALL && (plan.physicalCallCount !== 1 || exceedsLimit)) {
+        context.addIssue({ code: 'custom', message: 'SINGLE_CALL requires one within-limit physical call', path: ['planKind'] });
+    }
+    if (plan.planKind === MetaWorkflowStructuredGenerationPlanKind.CHUNKED && (plan.physicalCallCount <= 1 || !exceedsLimit)) {
+        context.addIssue({ code: 'custom', message: 'CHUNKED requires multiple physical calls for an over-limit schema', path: ['planKind'] });
+    }
+    if (plan.planKind === MetaWorkflowStructuredGenerationPlanKind.UNCHUNKABLE_OVER_LIMIT && (plan.physicalCallCount !== 0 || !exceedsLimit)) {
+        context.addIssue({ code: 'custom', message: 'UNCHUNKABLE_OVER_LIMIT requires zero calls for an over-limit schema', path: ['planKind'] });
+    }
+});
+//# sourceMappingURL=budget-authority.meta-workflows.shared.schemas.js.map

package/dist/esm/flows-actors/meta-workflows/budget-authority.meta-workflows.shared.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"budget-authority.meta-workflows.shared.schemas.js","sourceRoot":"","sources":["../../../../../src/flows-actors/meta-workflows/budget-authority.meta-workflows.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EACL,gCAAgC,EAChC,+BAA+B,GAChC,MAAM,qDAAqD,CAAC;AAE7D,MAAM,4BAA4B,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,gCAAgC,CAAC,CAAC;AAC5K,MAAM,yBAAyB,GAAG,4BAA4B,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,GAAG,CAAC,EAAE,wBAAwB,CAAC,CAAC;AAEtH,MAAM,CAAN,IAAY,wCAKX;AALD,WAAY,wCAAwC;IAClD,uEAA2B,CAAA;IAC3B,+DAAmB,CAAA;IACnB,iGAAiG;IACjG,6FAAiD,CAAA;AACnD,CAAC,EALW,wCAAwC,KAAxC,wCAAwC,QAKnD;AAED,MAAM,CAAC,MAAM,4CAA4C,GAAG,CAAC,CAAC,YAAY,CAAC;IACzE,aAAa,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;IAC3B,2BAA2B,EAAE,+BAA+B;IAC5D,eAAe,EAAE,gCAAgC;IACjD,kBAAkB,EAAE,+BAA+B;IACnD,cAAc,EAAE,yBAAyB;IACzC,wBAAwB,EAAE,yBAAyB;IACnD,QAAQ,EAAE,CAAC,CAAC,IAAI,CAAC,wCAAwC,CAAC;IAC1D,iBAAiB,EAAE,4BAA4B;IAC/C,UAAU,EAAE,+BAA+B;CAC5C,CAAC,CAAC,WAAW,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE;IAC/B,MAAM,YAAY,GAAG,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,wBAAwB,CAAC;IACzE,IAAI,IAAI,CAAC,QAAQ,KAAK,wCAAwC,CAAC,WAAW,IAAI,CAAC,IAAI,CAAC,iBAAiB,KAAK,CAAC,IAAI,YAAY,CAAC,EAAE,CAAC;QAC7H,OAAO,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,qDAAqD,EAAE,IAAI,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;IAC3H,CAAC;IACD,IAAI,IAAI,CAAC,QAAQ,KAAK,wCAAwC,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,iBAAiB,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC;QACzH,OAAO,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,mEAAmE,EAAE,IAAI,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;IACzI,CAAC;IACD,IAAI,IAAI,CAAC,QAAQ,KAAK,wCAAwC,CAAC,sBAAsB,IAAI,CAAC,IAAI,CAAC,iBAAiB,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC;QACzI,OAAO,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,qEAAqE,EAAE,IAAI,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;IAC3I,CAAC;AACH,CAAC,CAAC,CAAC","sourcesContent":["import { z } from 'zod';\n\nimport {\n  MetaWorkflow_NamespacedRefSchema,\n  MetaWorkflow_Sha256DigestSchema,\n} from './portable-primitives.meta-workflows.shared.schemas';\n\nconst nonnegativeSafeIntegerSchema = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).refine((value) => !Object.is(value, -0), 'negative zero is not canonical');\nconst positiveSafeIntegerSchema = nonnegativeSafeIntegerSchema.refine((value) => value > 0, 'value must be positive');\n\nexport enum MetaWorkflowStructuredGenerationPlanKind {\n  SINGLE_CALL = 'SINGLE_CALL',\n  CHUNKED = 'CHUNKED',\n  /** Leaf ceiling is exceeded, but the root semantics cannot be preserved across partial calls. */\n  UNCHUNKABLE_OVER_LIMIT = 'UNCHUNKABLE_OVER_LIMIT',\n}\n\nexport const MetaWorkflowStructuredGenerationPlanV1Schema = z.strictObject({\n  schemaVersion: z.literal(1),\n  providerConfigurationDigest: MetaWorkflow_Sha256DigestSchema,\n  outputSchemaRef: MetaWorkflow_NamespacedRefSchema,\n  outputSchemaDigest: MetaWorkflow_Sha256DigestSchema,\n  leafFieldCount: positiveSafeIntegerSchema,\n  maximumLeafFieldsPerCall: positiveSafeIntegerSchema,\n  planKind: z.enum(MetaWorkflowStructuredGenerationPlanKind),\n  physicalCallCount: nonnegativeSafeIntegerSchema,\n  planDigest: MetaWorkflow_Sha256DigestSchema,\n}).superRefine((plan, context) => {\n  const exceedsLimit = plan.leafFieldCount > plan.maximumLeafFieldsPerCall;\n  if (plan.planKind === MetaWorkflowStructuredGenerationPlanKind.SINGLE_CALL && (plan.physicalCallCount !== 1 || exceedsLimit)) {\n    context.addIssue({ code: 'custom', message: 'SINGLE_CALL requires one within-limit physical call', path: ['planKind'] });\n  }\n  if (plan.planKind === MetaWorkflowStructuredGenerationPlanKind.CHUNKED && (plan.physicalCallCount <= 1 || !exceedsLimit)) {\n    context.addIssue({ code: 'custom', message: 'CHUNKED requires multiple physical calls for an over-limit schema', path: ['planKind'] });\n  }\n  if (plan.planKind === MetaWorkflowStructuredGenerationPlanKind.UNCHUNKABLE_OVER_LIMIT && (plan.physicalCallCount !== 0 || !exceedsLimit)) {\n    context.addIssue({ code: 'custom', message: 'UNCHUNKABLE_OVER_LIMIT requires zero calls for an over-limit schema', path: ['planKind'] });\n  }\n});\nexport type MetaWorkflowStructuredGenerationPlanV1 = z.infer<typeof MetaWorkflowStructuredGenerationPlanV1Schema>;\n"]}

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

@@ -0,0 +1,125 @@
+import { z } from 'zod';
+import { MetaWorkflow_DriverLifecycleFacet, MetaWorkflow_FailureDisposition } from './actions.meta-workflows.shared.schemas';
+/** Semantic content family described by an Output Contract. */
+export declare enum MetaWorkflow_OutputContentClass {
+    STRUCTURED_RECORD = "STRUCTURED_RECORD",
+    DOCUMENT = "DOCUMENT",
+    BINARY_ASSET = "BINARY_ASSET",
+    COLLECTION = "COLLECTION"
+}
+/** Cardinality of one Output Contract. */
+export declare enum MetaWorkflow_OutputContractCardinality {
+    ONE = "ONE",
+    ZERO_OR_MORE = "ZERO_OR_MORE",
+    ONE_OR_MORE = "ONE_OR_MORE"
+}
+/** Persistence commitment for all artifacts produced by one structured Action. */
+export declare enum MetaWorkflow_StructuredArtifactOutputSetCommitment {
+    ATOMIC = "ATOMIC"
+}
+declare const _MetaWorkflow_OutputContractDescriptorSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    outputContractRef: z.ZodString;
+    outputContractVersion: z.ZodNumber;
+    outputSchemaRef: z.ZodString;
+    outputSchemaVersion: z.ZodNumber;
+    contentClass: z.ZodEnum<typeof MetaWorkflow_OutputContentClass>;
+    cardinality: z.ZodEnum<typeof MetaWorkflow_OutputContractCardinality>;
+    canonicalSerializationRef: z.ZodString;
+    canonicalSerializationVersion: z.ZodNumber;
+    validatorContractRef: z.ZodString;
+    validatorContractVersion: z.ZodNumber;
+    acceptedArtifactClassificationRefs: z.ZodArray<z.ZodString>;
+    invalidOutputDisposition: z.ZodEnum<typeof MetaWorkflow_FailureDisposition>;
+}, z.core.$strict>;
+export declare const MetaWorkflow_OutputContractDescriptorSchema: typeof _MetaWorkflow_OutputContractDescriptorSchema;
+export type MetaWorkflow_OutputContractDescriptor = z.infer<typeof _MetaWorkflow_OutputContractDescriptorSchema>;
+/**
+ * Portable executable meaning for one structured-artifact Action.
+ *
+ * The record is intentionally subject-neutral: application-family ids are
+ * carried only by the authored refs and later sealed input/output artifacts.
+ * It declares exact generation, normalization, validation and atomic-output
+ * contracts without selecting a provider, credential or application subject.
+ */
+declare const _MetaWorkflow_StructuredArtifactActionDefinitionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    definitionRef: z.ZodString;
+    definitionVersion: z.ZodNumber;
+    actionDefinition: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        actionRef: z.ZodString;
+        actionVersion: z.ZodNumber;
+        intentRef: z.ZodString;
+        inputSelectorRefs: z.ZodArray<z.ZodString>;
+        outcomeContractRefs: z.ZodArray<z.ZodString>;
+        effectSafetyPolicyRef: z.ZodString;
+        allowedCapabilityClassRefs: z.ZodArray<z.ZodString>;
+        requiredCapabilityFacetRefs: z.ZodArray<z.ZodString>;
+        authorityRequirementRef: z.ZodNullable<z.ZodString>;
+        budgetPolicyRef: z.ZodString;
+        continuationPolicyRef: z.ZodString;
+        decisionPointDefinitionRefs: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    driverDescriptor: z.ZodObject<{
+        descriptorRef: z.ZodString;
+        descriptorVersion: z.ZodNumber;
+    }, z.core.$strict>;
+    inputProjectionContract: z.ZodObject<{
+        contractRef: z.ZodString;
+        contractVersion: z.ZodNumber;
+    }, z.core.$strict>;
+    providerOutputSchema: z.ZodObject<{
+        schemaRef: z.ZodString;
+        schemaVersion: z.ZodNumber;
+    }, z.core.$strict>;
+    normalizationContract: z.ZodObject<{
+        contractRef: z.ZodString;
+        contractVersion: z.ZodNumber;
+    }, z.core.$strict>;
+    outputContract: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        outputContractRef: z.ZodString;
+        outputContractVersion: z.ZodNumber;
+        outputSchemaRef: z.ZodString;
+        outputSchemaVersion: z.ZodNumber;
+        contentClass: z.ZodEnum<typeof MetaWorkflow_OutputContentClass>;
+        cardinality: z.ZodEnum<typeof MetaWorkflow_OutputContractCardinality>;
+        canonicalSerializationRef: z.ZodString;
+        canonicalSerializationVersion: z.ZodNumber;
+        validatorContractRef: z.ZodString;
+        validatorContractVersion: z.ZodNumber;
+        acceptedArtifactClassificationRefs: z.ZodArray<z.ZodString>;
+        invalidOutputDisposition: z.ZodEnum<typeof MetaWorkflow_FailureDisposition>;
+    }, z.core.$strict>;
+    outputSetCommitment: z.ZodLiteral<MetaWorkflow_StructuredArtifactOutputSetCommitment>;
+    requiredLifecycleFacets: z.ZodArray<z.ZodEnum<typeof MetaWorkflow_DriverLifecycleFacet>>;
+    requiredFailureDispositions: z.ZodArray<z.ZodEnum<typeof MetaWorkflow_FailureDisposition>>;
+}, z.core.$strict>;
+export declare const MetaWorkflow_StructuredArtifactActionDefinitionSchema: typeof _MetaWorkflow_StructuredArtifactActionDefinitionSchema;
+export type MetaWorkflow_StructuredArtifactActionDefinition = z.infer<typeof _MetaWorkflow_StructuredArtifactActionDefinitionSchema>;
+export {};
+/**
+ * Sealed runtime invocation for the generic structured-artifact Driver.
+ *
+ * The portable compiled definition carries all contract identities. The input
+ * projection is a separate exact artifact so application knowledge and method
+ * guidance remain data, never ambient Driver state.
+ */
+/**
+ * Why a prior attempt's output was rejected, in a form the next attempt can act on.
+ *
+ * These are the RUNTIME's own findings — the deterministic output-contract validator's issues, or the
+ * schema parse errors — never model-authored prose, so nothing the model wrote is copied into a durable
+ * record or back into a later prompt.
+ *
+ * They exist because the Driver used to discard them. A rejected attempt threw the validator's `issues`
+ * away inside a bare `catch`, recorded a bare INVALID_OUTPUT, and the retry re-sent a byte-identical
+ * prompt. Measured on the live lane 2026-08-22: three attempts, three failures, and the SAME
+ * deterministic rule broken twice — because nothing ever told the model which rule it had broken. A
+ * retry that cannot see its predecessor's findings is resampling, not revising.
+ *
+ * Bounded on purpose (`MAX` below): this rides inside sealed provenance and a later prompt, so it must
+ * summarise a rejection rather than transcribe an arbitrarily large validator dump.
+ */
+//# sourceMappingURL=catalog.meta-workflows.shared.schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.meta-workflows.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../../src/flows-actors/meta-workflows/catalog.meta-workflows.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,OAAO,EAGL,iCAAiC,EACjC,+BAA+B,EAChC,MAAM,yCAAyC,CAAC;AAgBjD,+DAA+D;AAC/D,oBAAY,+BAA+B;IACzC,iBAAiB,sBAAsB;IACvC,QAAQ,aAAa;IACrB,YAAY,iBAAiB;IAC7B,UAAU,eAAe;CAC1B;AAED,0CAA0C;AAC1C,oBAAY,sCAAsC;IAChD,GAAG,QAAQ;IACX,YAAY,iBAAiB;IAC7B,WAAW,gBAAgB;CAC5B;AAED,kFAAkF;AAClF,oBAAY,kDAAkD;IAC5D,MAAM,WAAW;CAClB;AAcD,QAAA,MAAM,4CAA4C;;;;;;;;;;;;;;kBAehD,CAAC;AACH,eAAO,MAAM,2CAA2C,EAAE,OAAO,4CACnB,CAAC;AAC/C,MAAM,MAAM,qCAAqC,GAAG,CAAC,CAAC,KAAK,CACzD,OAAO,4CAA4C,CACpD,CAAC;AAYF;;;;;;;GAOG;AACH,QAAA,MAAM,sDAAsD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA0DxD,CAAC;AACL,eAAO,MAAM,qDAAqD,EAAE,OAAO,sDACnB,CAAC;AACzD,MAAM,MAAM,+CAA+C,GAAG,CAAC,CAAC,KAAK,CACnE,OAAO,sDAAsD,CAC9D,CAAC;;AAEF;;;;;;GAMG;AACH;;;;;;;;;;;;;;;GAeG"}

package/dist/esm/flows-actors/meta-workflows/catalog.meta-workflows.shared.schemas.js

@@ -0,0 +1,136 @@
+import { z } from 'zod';
+import { MetaWorkflow_ActionDefinitionSchema, MetaWorkflow_DriverLifecycleFacet, MetaWorkflow_FailureDisposition, } from './actions.meta-workflows.shared.schemas.js';
+import { MetaWorkflow_NamespacedRefSchema, MetaWorkflow_PositiveVersionSchema, metaWorkflowValuesAreLexicallySorted, metaWorkflowValuesAreUnique, } from './portable-primitives.meta-workflows.shared.schemas.js';
+/** Semantic content family described by an Output Contract. */
+export var MetaWorkflow_OutputContentClass;
+(function (MetaWorkflow_OutputContentClass) {
+    MetaWorkflow_OutputContentClass["STRUCTURED_RECORD"] = "STRUCTURED_RECORD";
+    MetaWorkflow_OutputContentClass["DOCUMENT"] = "DOCUMENT";
+    MetaWorkflow_OutputContentClass["BINARY_ASSET"] = "BINARY_ASSET";
+    MetaWorkflow_OutputContentClass["COLLECTION"] = "COLLECTION";
+})(MetaWorkflow_OutputContentClass || (MetaWorkflow_OutputContentClass = {}));
+/** Cardinality of one Output Contract. */
+export var MetaWorkflow_OutputContractCardinality;
+(function (MetaWorkflow_OutputContractCardinality) {
+    MetaWorkflow_OutputContractCardinality["ONE"] = "ONE";
+    MetaWorkflow_OutputContractCardinality["ZERO_OR_MORE"] = "ZERO_OR_MORE";
+    MetaWorkflow_OutputContractCardinality["ONE_OR_MORE"] = "ONE_OR_MORE";
+})(MetaWorkflow_OutputContractCardinality || (MetaWorkflow_OutputContractCardinality = {}));
+/** Persistence commitment for all artifacts produced by one structured Action. */
+export var MetaWorkflow_StructuredArtifactOutputSetCommitment;
+(function (MetaWorkflow_StructuredArtifactOutputSetCommitment) {
+    MetaWorkflow_StructuredArtifactOutputSetCommitment["ATOMIC"] = "ATOMIC";
+})(MetaWorkflow_StructuredArtifactOutputSetCommitment || (MetaWorkflow_StructuredArtifactOutputSetCommitment = {}));
+const _MetaWorkflow_DescriptorIdentitySchema = z.strictObject({
+    descriptorRef: MetaWorkflow_NamespacedRefSchema,
+    descriptorVersion: MetaWorkflow_PositiveVersionSchema,
+});
+const _MetaWorkflow_UniqueSortedNamespacedRefsSchema = z
+    .array(MetaWorkflow_NamespacedRefSchema)
+    .refine(metaWorkflowValuesAreUnique, { message: 'refs must be unique' })
+    .refine(metaWorkflowValuesAreLexicallySorted, {
+    message: 'refs must use canonical lexical order',
+});
+const _MetaWorkflow_OutputContractDescriptorSchema = z.strictObject({
+    schemaVersion: z.literal(1),
+    outputContractRef: MetaWorkflow_NamespacedRefSchema,
+    outputContractVersion: MetaWorkflow_PositiveVersionSchema,
+    outputSchemaRef: MetaWorkflow_NamespacedRefSchema,
+    outputSchemaVersion: MetaWorkflow_PositiveVersionSchema,
+    contentClass: z.enum(MetaWorkflow_OutputContentClass),
+    cardinality: z.enum(MetaWorkflow_OutputContractCardinality),
+    canonicalSerializationRef: MetaWorkflow_NamespacedRefSchema,
+    canonicalSerializationVersion: MetaWorkflow_PositiveVersionSchema,
+    validatorContractRef: MetaWorkflow_NamespacedRefSchema,
+    validatorContractVersion: MetaWorkflow_PositiveVersionSchema,
+    acceptedArtifactClassificationRefs: _MetaWorkflow_UniqueSortedNamespacedRefsSchema.min(1),
+    invalidOutputDisposition: z.enum(MetaWorkflow_FailureDisposition),
+});
+export const MetaWorkflow_OutputContractDescriptorSchema = _MetaWorkflow_OutputContractDescriptorSchema;
+const _MetaWorkflow_SchemaIdentitySchema = z.strictObject({
+    schemaRef: MetaWorkflow_NamespacedRefSchema,
+    schemaVersion: MetaWorkflow_PositiveVersionSchema,
+});
+const _MetaWorkflow_ContractIdentitySchema = z.strictObject({
+    contractRef: MetaWorkflow_NamespacedRefSchema,
+    contractVersion: MetaWorkflow_PositiveVersionSchema,
+});
+/**
+ * Portable executable meaning for one structured-artifact Action.
+ *
+ * The record is intentionally subject-neutral: application-family ids are
+ * carried only by the authored refs and later sealed input/output artifacts.
+ * It declares exact generation, normalization, validation and atomic-output
+ * contracts without selecting a provider, credential or application subject.
+ */
+const _MetaWorkflow_StructuredArtifactActionDefinitionSchema = z
+    .strictObject({
+    schemaVersion: z.literal(1),
+    definitionRef: MetaWorkflow_NamespacedRefSchema,
+    definitionVersion: MetaWorkflow_PositiveVersionSchema,
+    actionDefinition: MetaWorkflow_ActionDefinitionSchema,
+    driverDescriptor: _MetaWorkflow_DescriptorIdentitySchema,
+    inputProjectionContract: _MetaWorkflow_ContractIdentitySchema,
+    providerOutputSchema: _MetaWorkflow_SchemaIdentitySchema,
+    normalizationContract: _MetaWorkflow_ContractIdentitySchema,
+    outputContract: _MetaWorkflow_OutputContractDescriptorSchema,
+    outputSetCommitment: z.literal(MetaWorkflow_StructuredArtifactOutputSetCommitment.ATOMIC),
+    requiredLifecycleFacets: z.array(z.enum(MetaWorkflow_DriverLifecycleFacet)),
+    requiredFailureDispositions: z
+        .array(z.enum(MetaWorkflow_FailureDisposition))
+        .min(1),
+})
+    .superRefine((definition, context) => {
+    const orderedValues = [
+        {
+            path: 'requiredLifecycleFacets',
+            values: definition.requiredLifecycleFacets,
+        },
+        {
+            path: 'requiredFailureDispositions',
+            values: definition.requiredFailureDispositions,
+        },
+    ];
+    for (const entry of orderedValues) {
+        if (!metaWorkflowValuesAreUnique(entry.values)
+            || !metaWorkflowValuesAreLexicallySorted(entry.values)) {
+            context.addIssue({
+                code: 'custom',
+                message: `${entry.path} must be unique and canonically sorted`,
+                path: [entry.path],
+            });
+        }
+    }
+    if (!definition.actionDefinition.outcomeContractRefs.includes(definition.outputContract.outputContractRef)) {
+        context.addIssue({
+            code: 'custom',
+            message: 'Action Definition must name the compiled Output Contract',
+            path: ['actionDefinition', 'outcomeContractRefs'],
+        });
+    }
+});
+export const MetaWorkflow_StructuredArtifactActionDefinitionSchema = _MetaWorkflow_StructuredArtifactActionDefinitionSchema;
+/**
+ * Sealed runtime invocation for the generic structured-artifact Driver.
+ *
+ * The portable compiled definition carries all contract identities. The input
+ * projection is a separate exact artifact so application knowledge and method
+ * guidance remain data, never ambient Driver state.
+ */
+/**
+ * Why a prior attempt's output was rejected, in a form the next attempt can act on.
+ *
+ * These are the RUNTIME's own findings — the deterministic output-contract validator's issues, or the
+ * schema parse errors — never model-authored prose, so nothing the model wrote is copied into a durable
+ * record or back into a later prompt.
+ *
+ * They exist because the Driver used to discard them. A rejected attempt threw the validator's `issues`
+ * away inside a bare `catch`, recorded a bare INVALID_OUTPUT, and the retry re-sent a byte-identical
+ * prompt. Measured on the live lane 2026-08-22: three attempts, three failures, and the SAME
+ * deterministic rule broken twice — because nothing ever told the model which rule it had broken. A
+ * retry that cannot see its predecessor's findings is resampling, not revising.
+ *
+ * Bounded on purpose (`MAX` below): this rides inside sealed provenance and a later prompt, so it must
+ * summarise a rejection rather than transcribe an arbitrarily large validator dump.
+ */
+//# sourceMappingURL=catalog.meta-workflows.shared.schemas.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.meta-workflows.shared.schemas.js","sourceRoot":"","sources":["../../../../../src/flows-actors/meta-workflows/catalog.meta-workflows.shared.schemas.ts"],"names":[],"mappings":"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","sourcesContent":["import { z } from 'zod';\n\nimport {\n  AuthorityDecisionIdSchema,\n  ContinuitySubjectIdSchema,\n  ExecutionBindingIdSchema,\n} from './continuity-identifiers.meta-workflows.shared.schemas';\nimport {\n  MetaWorkflow_ActionDefinitionSchema,\n  MetaWorkflow_DriverDescriptorSchema,\n  MetaWorkflow_DriverLifecycleFacet,\n  MetaWorkflow_FailureDisposition,\n} from './actions.meta-workflows.shared.schemas';\nimport {\n  MetaWorkflow_ExecutionDefinitionSchemaRef,\n  MetaWorkflow_EvaluatorDescriptorSchema,\n} from './decisions.meta-workflows.shared.schemas';\nimport {\n  MetaWorkflow_IsoDateTimeSchema,\n  MetaWorkflow_LowercaseUuidV4Schema,\n  MetaWorkflow_NamespacedRefSchema,\n  MetaWorkflow_NonNegativeRevisionSchema,\n  MetaWorkflow_OpaqueRefSchema,\n  MetaWorkflow_PositiveVersionSchema,\n  metaWorkflowValuesAreLexicallySorted,\n  metaWorkflowValuesAreUnique,\n} from './portable-primitives.meta-workflows.shared.schemas';\n\n/** Semantic content family described by an Output Contract. */\nexport enum MetaWorkflow_OutputContentClass {\n  STRUCTURED_RECORD = 'STRUCTURED_RECORD',\n  DOCUMENT = 'DOCUMENT',\n  BINARY_ASSET = 'BINARY_ASSET',\n  COLLECTION = 'COLLECTION',\n}\n\n/** Cardinality of one Output Contract. */\nexport enum MetaWorkflow_OutputContractCardinality {\n  ONE = 'ONE',\n  ZERO_OR_MORE = 'ZERO_OR_MORE',\n  ONE_OR_MORE = 'ONE_OR_MORE',\n}\n\n/** Persistence commitment for all artifacts produced by one structured Action. */\nexport enum MetaWorkflow_StructuredArtifactOutputSetCommitment {\n  ATOMIC = 'ATOMIC',\n}\n\nconst _MetaWorkflow_DescriptorIdentitySchema = z.strictObject({\n  descriptorRef: MetaWorkflow_NamespacedRefSchema,\n  descriptorVersion: MetaWorkflow_PositiveVersionSchema,\n});\n\nconst _MetaWorkflow_UniqueSortedNamespacedRefsSchema = z\n  .array(MetaWorkflow_NamespacedRefSchema)\n  .refine(metaWorkflowValuesAreUnique, { message: 'refs must be unique' })\n  .refine(metaWorkflowValuesAreLexicallySorted, {\n    message: 'refs must use canonical lexical order',\n  });\n\nconst _MetaWorkflow_OutputContractDescriptorSchema = z.strictObject({\n  schemaVersion: z.literal(1),\n  outputContractRef: MetaWorkflow_NamespacedRefSchema,\n  outputContractVersion: MetaWorkflow_PositiveVersionSchema,\n  outputSchemaRef: MetaWorkflow_NamespacedRefSchema,\n  outputSchemaVersion: MetaWorkflow_PositiveVersionSchema,\n  contentClass: z.enum(MetaWorkflow_OutputContentClass),\n  cardinality: z.enum(MetaWorkflow_OutputContractCardinality),\n  canonicalSerializationRef: MetaWorkflow_NamespacedRefSchema,\n  canonicalSerializationVersion: MetaWorkflow_PositiveVersionSchema,\n  validatorContractRef: MetaWorkflow_NamespacedRefSchema,\n  validatorContractVersion: MetaWorkflow_PositiveVersionSchema,\n  acceptedArtifactClassificationRefs:\n    _MetaWorkflow_UniqueSortedNamespacedRefsSchema.min(1),\n  invalidOutputDisposition: z.enum(MetaWorkflow_FailureDisposition),\n});\nexport const MetaWorkflow_OutputContractDescriptorSchema: typeof _MetaWorkflow_OutputContractDescriptorSchema =\n  _MetaWorkflow_OutputContractDescriptorSchema;\nexport type MetaWorkflow_OutputContractDescriptor = z.infer<\n  typeof _MetaWorkflow_OutputContractDescriptorSchema\n>;\n\nconst _MetaWorkflow_SchemaIdentitySchema = z.strictObject({\n  schemaRef: MetaWorkflow_NamespacedRefSchema,\n  schemaVersion: MetaWorkflow_PositiveVersionSchema,\n});\n\nconst _MetaWorkflow_ContractIdentitySchema = z.strictObject({\n  contractRef: MetaWorkflow_NamespacedRefSchema,\n  contractVersion: MetaWorkflow_PositiveVersionSchema,\n});\n\n/**\n * Portable executable meaning for one structured-artifact Action.\n *\n * The record is intentionally subject-neutral: application-family ids are\n * carried only by the authored refs and later sealed input/output artifacts.\n * It declares exact generation, normalization, validation and atomic-output\n * contracts without selecting a provider, credential or application subject.\n */\nconst _MetaWorkflow_StructuredArtifactActionDefinitionSchema = z\n  .strictObject({\n    schemaVersion: z.literal(1),\n    definitionRef: MetaWorkflow_NamespacedRefSchema,\n    definitionVersion: MetaWorkflow_PositiveVersionSchema,\n    actionDefinition: MetaWorkflow_ActionDefinitionSchema,\n    driverDescriptor: _MetaWorkflow_DescriptorIdentitySchema,\n    inputProjectionContract: _MetaWorkflow_ContractIdentitySchema,\n    providerOutputSchema: _MetaWorkflow_SchemaIdentitySchema,\n    normalizationContract: _MetaWorkflow_ContractIdentitySchema,\n    outputContract: _MetaWorkflow_OutputContractDescriptorSchema,\n    outputSetCommitment: z.literal(\n      MetaWorkflow_StructuredArtifactOutputSetCommitment.ATOMIC,\n    ),\n    requiredLifecycleFacets: z.array(\n      z.enum(MetaWorkflow_DriverLifecycleFacet),\n    ),\n    requiredFailureDispositions: z\n      .array(z.enum(MetaWorkflow_FailureDisposition))\n      .min(1),\n  })\n  .superRefine((definition, context) => {\n    const orderedValues: ReadonlyArray<{\n      path: 'requiredLifecycleFacets' | 'requiredFailureDispositions';\n      values: ReadonlyArray<string>;\n    }> = [\n      {\n        path: 'requiredLifecycleFacets',\n        values: definition.requiredLifecycleFacets,\n      },\n      {\n        path: 'requiredFailureDispositions',\n        values: definition.requiredFailureDispositions,\n      },\n    ];\n    for (const entry of orderedValues) {\n      if (\n        !metaWorkflowValuesAreUnique(entry.values)\n        || !metaWorkflowValuesAreLexicallySorted(entry.values)\n      ) {\n        context.addIssue({\n          code: 'custom',\n          message: `${entry.path} must be unique and canonically sorted`,\n          path: [entry.path],\n        });\n      }\n    }\n    if (\n      !definition.actionDefinition.outcomeContractRefs.includes(\n        definition.outputContract.outputContractRef,\n      )\n    ) {\n      context.addIssue({\n        code: 'custom',\n        message: 'Action Definition must name the compiled Output Contract',\n        path: ['actionDefinition', 'outcomeContractRefs'],\n      });\n    }\n  });\nexport const MetaWorkflow_StructuredArtifactActionDefinitionSchema: typeof _MetaWorkflow_StructuredArtifactActionDefinitionSchema =\n  _MetaWorkflow_StructuredArtifactActionDefinitionSchema;\nexport type MetaWorkflow_StructuredArtifactActionDefinition = z.infer<\n  typeof _MetaWorkflow_StructuredArtifactActionDefinitionSchema\n>;\n\n/**\n * Sealed runtime invocation for the generic structured-artifact Driver.\n *\n * The portable compiled definition carries all contract identities. The input\n * projection is a separate exact artifact so application knowledge and method\n * guidance remain data, never ambient Driver state.\n */\n/**\n * Why a prior attempt's output was rejected, in a form the next attempt can act on.\n *\n * These are the RUNTIME's own findings — the deterministic output-contract validator's issues, or the\n * schema parse errors — never model-authored prose, so nothing the model wrote is copied into a durable\n * record or back into a later prompt.\n *\n * They exist because the Driver used to discard them. A rejected attempt threw the validator's `issues`\n * away inside a bare `catch`, recorded a bare INVALID_OUTPUT, and the retry re-sent a byte-identical\n * prompt. Measured on the live lane 2026-08-22: three attempts, three failures, and the SAME\n * deterministic rule broken twice — because nothing ever told the model which rule it had broken. A\n * retry that cannot see its predecessor's findings is resampling, not revising.\n *\n * Bounded on purpose (`MAX` below): this rides inside sealed provenance and a later prompt, so it must\n * summarise a rejection rather than transcribe an arbitrarily large validator dump.\n */\n"]}

package/dist/esm/flows-actors/meta-workflows/context-selection.meta-workflows.shared.schemas.d.ts

@@ -0,0 +1,180 @@
+import { z } from 'zod';
+/** Why a source participates in a semantic assessment package. */
+export declare enum MetaWorkflow_ContextSourceRole {
+    MANDATORY = "MANDATORY",
+    CONDITIONAL = "CONDITIONAL",
+    ADVISORY = "ADVISORY"
+}
+/** Freshness is source evidence, never a model inference. */
+export declare enum MetaWorkflow_ContextSourceFreshness {
+    CURRENT = "CURRENT",
+    STALE = "STALE",
+    UNKNOWN = "UNKNOWN"
+}
+/** Disclosure safety is decided by the source adapter before prompt assembly. */
+export declare enum MetaWorkflow_ContextSourceDisclosure {
+    SAFE_FOR_MODEL = "SAFE_FOR_MODEL",
+    RESTRICTED = "RESTRICTED"
+}
+/** Who the assembled context is FOR. The consumer decides what may travel and what a mistake costs. */
+export declare enum MetaWorkflow_ContextSelectionConsumerKind {
+    ASSESSMENT_INPUT = "ASSESSMENT_INPUT",
+    /**
+     * Context assembled for a CODING AGENT that will mutate the application workspace.
+     *
+     * Deliberately not folded into `ASSESSMENT_INPUT`. The two consumers differ in what the context is FOR and
+     * in what a mistake costs: an assessment input feeds a judgement that produces a finding, while this feeds
+     * a run that writes files into a developer's source tree. They also differ in what may travel — the
+     * application coding-task contract refuses any source that is not `SAFE_FOR_MODEL`, because its content is
+     * rendered verbatim into the agent prompt.
+     */
+    CODING_AGENT = "CODING_AGENT"
+}
+/** One acquired context source offered to the selector. `content` is portable JSON data only. */
+export declare const MetaWorkflow_ContextSourceCandidateSchema: z.ZodObject<{
+    sourceRef: z.ZodString;
+    sourceVersion: z.ZodOptional<z.ZodNumber>;
+    originRef: z.ZodString;
+    role: z.ZodEnum<typeof MetaWorkflow_ContextSourceRole>;
+    relevance: z.ZodOptional<z.ZodNumber>;
+    estimatedTokens: z.ZodNumber;
+    freshness: z.ZodOptional<z.ZodEnum<typeof MetaWorkflow_ContextSourceFreshness>>;
+    disclosure: z.ZodEnum<typeof MetaWorkflow_ContextSourceDisclosure>;
+    /** Portable JSON data only. */
+    content: z.ZodJSONSchema;
+}, z.core.$strict>;
+export type MetaWorkflow_ContextSourceCandidate = z.infer<typeof MetaWorkflow_ContextSourceCandidateSchema>;
+/** Declared requirement: no planner or curator may remove this source role. */
+export declare const MetaWorkflow_ContextSourceRequirementSchema: z.ZodObject<{
+    sourceRef: z.ZodString;
+    /** Unknown freshness is never admissible for model-visible required context. */
+    minimumFreshness: z.ZodEnum<{
+        CURRENT: MetaWorkflow_ContextSourceFreshness.CURRENT;
+        STALE: MetaWorkflow_ContextSourceFreshness.STALE;
+    }>;
+    role: z.ZodEnum<typeof MetaWorkflow_ContextSourceRole>;
+}, z.core.$strict>;
+export type MetaWorkflow_ContextSourceRequirement = z.infer<typeof MetaWorkflow_ContextSourceRequirementSchema>;
+/** One deterministic omission recorded after acquisition, keyed by source and reason. */
+export declare const MetaWorkflow_ContextWarningSchema: z.ZodObject<{
+    sourceRef: z.ZodString;
+    reasonRef: z.ZodString;
+}, z.core.$strict>;
+export type MetaWorkflow_ContextWarning = z.infer<typeof MetaWorkflow_ContextWarningSchema>;
+/**
+ * Bounded, source-grounded selection instruction for one assessment iteration.
+ * It deliberately carries no filesystem, companion, Git, or application-family
+ * concepts; those belong to the host adapter which supplies candidates.
+ */
+export declare const MetaWorkflow_ContextSelectionPlanSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    planRef: z.ZodString;
+    objectiveRef: z.ZodString;
+    assessmentSubjectRef: z.ZodString;
+    scope: z.ZodRecord<z.ZodString, z.ZodString>;
+    iterationOrdinal: z.ZodNumber;
+    /**
+     * The assessment stable kernel this selection is bound to — ASSESSMENT consumers only.
+     *
+     * Optional, because it is meaningful for exactly one consumer kind. The assessment input compiler and the
+     * semantic-evaluation service compare these two against the episode's own kernel; a CODING_AGENT run has
+     * no kernel to compare against, and supplying a manufactured ref and digest so the shape would parse
+     * would be inventing a fact the run does not have.
+     *
+     * Absence stays FAIL-CLOSED where it matters: both assessment readers compare with `!==`, so an absent
+     * value cannot equal a real kernel and the assessment refuses exactly as it did before.
+     */
+    stableKernelRef: z.ZodOptional<z.ZodString>;
+    stableKernelDigest: z.ZodOptional<z.ZodString>;
+    consumerKind: z.ZodEnum<typeof MetaWorkflow_ContextSelectionConsumerKind>;
+    maximumOptionalSources: z.ZodNumber;
+    maximumTokenBudget: z.ZodNumber;
+    mandatorySources: z.ZodArray<z.ZodObject<{
+        sourceRef: z.ZodString;
+        /** Unknown freshness is never admissible for model-visible required context. */
+        minimumFreshness: z.ZodEnum<{
+            CURRENT: MetaWorkflow_ContextSourceFreshness.CURRENT;
+            STALE: MetaWorkflow_ContextSourceFreshness.STALE;
+        }>;
+        role: z.ZodEnum<typeof MetaWorkflow_ContextSourceRole>;
+    }, z.core.$strict>>;
+    optionalSourceRequirements: z.ZodArray<z.ZodObject<{
+        sourceRef: z.ZodString;
+        /** Unknown freshness is never admissible for model-visible required context. */
+        minimumFreshness: z.ZodEnum<{
+            CURRENT: MetaWorkflow_ContextSourceFreshness.CURRENT;
+            STALE: MetaWorkflow_ContextSourceFreshness.STALE;
+        }>;
+        role: z.ZodEnum<typeof MetaWorkflow_ContextSourceRole>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type MetaWorkflow_ContextSelectionPlan = z.infer<typeof MetaWorkflow_ContextSelectionPlanSchema>;
+export declare const MetaWorkflow_ContextSelectionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    planRef: z.ZodString;
+    /**
+     * Repeated from the plan so a consumer can bind a sealed selection to its
+     * exact objective and assessment scope without reopening a mutable plan.
+     */
+    objectiveRef: z.ZodString;
+    assessmentSubjectRef: z.ZodString;
+    scope: z.ZodRecord<z.ZodString, z.ZodString>;
+    iterationOrdinal: z.ZodNumber;
+    stableKernelRef: z.ZodOptional<z.ZodString>;
+    stableKernelDigest: z.ZodOptional<z.ZodString>;
+    consumerKind: z.ZodEnum<typeof MetaWorkflow_ContextSelectionConsumerKind>;
+    selectedSources: z.ZodArray<z.ZodObject<{
+        sourceRef: z.ZodString;
+        sourceVersion: z.ZodOptional<z.ZodNumber>;
+        originRef: z.ZodString;
+        role: z.ZodEnum<typeof MetaWorkflow_ContextSourceRole>;
+        relevance: z.ZodOptional<z.ZodNumber>;
+        estimatedTokens: z.ZodNumber;
+        freshness: z.ZodOptional<z.ZodEnum<typeof MetaWorkflow_ContextSourceFreshness>>;
+        disclosure: z.ZodEnum<typeof MetaWorkflow_ContextSourceDisclosure>;
+        /** Portable JSON data only. */
+        content: z.ZodJSONSchema;
+    }, z.core.$strict>>;
+    /**
+     * Deterministic omissions AFTER acquisition. A missing or unusable MANDATORY
+     * source is never one of these: the selector refuses outright, because a
+     * model input that silently lacks required evidence is exactly the fabricated
+     * completeness this contract exists to prevent.
+     */
+    warnings: z.ZodArray<z.ZodObject<{
+        sourceRef: z.ZodString;
+        reasonRef: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type MetaWorkflow_ContextSelection = z.infer<typeof MetaWorkflow_ContextSelectionSchema>;
+/**
+ * Stable assessment semantics supplied by the host alongside a selected
+ * context package. It intentionally carries only declared references and
+ * deterministic facts/guidance: the Treatment remains the owner of exact
+ * evaluator protocol, criterion wording and authority boundaries.
+ */
+/** Deterministic finding outcome carried inside the stable assessment kernel. */
+export declare enum MetaWorkflow_DeterministicFindingStatus {
+    PASSED = "PASSED",
+    FAILED = "FAILED",
+    NOT_EVALUABLE = "NOT_EVALUABLE"
+}
+export declare const MetaWorkflow_AssessmentStableKernelSchema: z.ZodObject<{
+    kernelRef: z.ZodString;
+    kernelDigest: z.ZodString;
+    declaredCriterionRefs: z.ZodArray<z.ZodString>;
+    deterministicFindings: z.ZodArray<z.ZodObject<{
+        findingRef: z.ZodString;
+        findingKindRef: z.ZodString;
+        status: z.ZodEnum<typeof MetaWorkflow_DeterministicFindingStatus>;
+        evidenceRefs: z.ZodArray<z.ZodString>;
+        rationale: z.ZodString;
+    }, z.core.$strict>>;
+    guidance: z.ZodArray<z.ZodObject<{
+        guidanceRef: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strict>>;
+    effectiveExplorationBreadth: z.ZodNumber;
+    revisionThreshold: z.ZodNumber;
+}, z.core.$strict>;
+//# sourceMappingURL=context-selection.meta-workflows.shared.schemas.d.ts.map

package/dist/esm/flows-actors/meta-workflows/context-selection.meta-workflows.shared.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-selection.meta-workflows.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../../src/flows-actors/meta-workflows/context-selection.meta-workflows.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAcxB,kEAAkE;AAClE,oBAAY,8BAA8B;IACxC,SAAS,cAAc;IACvB,WAAW,gBAAgB;IAC3B,QAAQ,aAAa;CACtB;AAED,6DAA6D;AAC7D,oBAAY,mCAAmC;IAC7C,OAAO,YAAY;IACnB,KAAK,UAAU;IACf,OAAO,YAAY;CACpB;AAED,iFAAiF;AACjF,oBAAY,oCAAoC;IAC9C,cAAc,mBAAmB;IACjC,UAAU,eAAe;CAC1B;AAED,uGAAuG;AACvG,oBAAY,yCAAyC;IACnD,gBAAgB,qBAAqB;IACrC;;;;;;;;OAQG;IACH,YAAY,iBAAiB;CAC9B;AAED,iGAAiG;AACjG,eAAO,MAAM,yCAAyC;;;;;;;;;IASpD,+BAA+B;;kBAE/B,CAAC;AACH,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yCAAyC,CAAC,CAAC;AAE5G,+EAA+E;AAC/E,eAAO,MAAM,2CAA2C;;IAEtD,gFAAgF;;;;;;kBAMhF,CAAC;AACH,MAAM,MAAM,qCAAqC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2CAA2C,CAAC,CAAC;AAEhH,yFAAyF;AACzF,eAAO,MAAM,iCAAiC;;;kBAG5C,CAAC;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAE5F;;;;GAIG;AACH,eAAO,MAAM,uCAAuC;;;;;;;IAOlD;;;;;;;;;;OAUG;;;;;;;;QAtCH,gFAAgF;;;;;;;;;QAAhF,gFAAgF;;;;;;;kBAoEhF,CAAC;AACH,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uCAAuC,CAAC,CAAC;AAExG,eAAO,MAAM,mCAAmC;;;IAG9C;;;OAGG;;;;;;;;;;;;;;;;;QArFH,+BAA+B;;;IA8F/B;;;;;OAKG;;;;;kBAcH,CAAC;AACH,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAC;AAEhG;;;;;GAKG;AACH,iFAAiF;AACjF,oBAAY,uCAAuC;IACjD,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,aAAa,kBAAkB;CAChC;AAED,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;kBAiBpD,CAAC"}