@wildo-ai/saas-models 1.0.1 → 1.1.0

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

@@ -0,0 +1,678 @@
+import { z } from 'zod';
+import { MetaWorkflow_DriverLifecycleFacet, } from './actions.meta-workflows.shared.schemas.js';
+import { MetaWorkflow_NamespacedRefSchema, MetaWorkflow_NonNegativeFiniteNumberSchema, MetaWorkflow_OpaqueRefSchema, MetaWorkflow_PositiveVersionSchema, metaWorkflowValuesAreLexicallySorted, metaWorkflowValuesAreUnique, } from './portable-primitives.meta-workflows.shared.schemas.js';
+/** Cardinality and decision significance of one evidence requirement. */
+export var MetaWorkflow_EvidenceRequirementKind;
+(function (MetaWorkflow_EvidenceRequirementKind) {
+    MetaWorkflow_EvidenceRequirementKind["MANDATORY"] = "MANDATORY";
+    MetaWorkflow_EvidenceRequirementKind["CONDITIONAL"] = "CONDITIONAL";
+    MetaWorkflow_EvidenceRequirementKind["ADVISORY"] = "ADVISORY";
+})(MetaWorkflow_EvidenceRequirementKind || (MetaWorkflow_EvidenceRequirementKind = {}));
+/** Semantic class of an evaluator contract, never its implementation identity. */
+export var MetaWorkflow_EvaluatorClass;
+(function (MetaWorkflow_EvaluatorClass) {
+    MetaWorkflow_EvaluatorClass["DETERMINISTIC"] = "DETERMINISTIC";
+    MetaWorkflow_EvaluatorClass["SEMANTIC_MODEL"] = "SEMANTIC_MODEL";
+    MetaWorkflow_EvaluatorClass["HUMAN_REVIEW"] = "HUMAN_REVIEW";
+    MetaWorkflow_EvaluatorClass["HYBRID"] = "HYBRID";
+})(MetaWorkflow_EvaluatorClass || (MetaWorkflow_EvaluatorClass = {}));
+/** Decision-boundary class implemented by one declarative Decision Rule. */
+export var MetaWorkflow_DecisionRuleBoundaryClass;
+(function (MetaWorkflow_DecisionRuleBoundaryClass) {
+    MetaWorkflow_DecisionRuleBoundaryClass["HARD_DETERMINISTIC"] = "HARD_DETERMINISTIC";
+    MetaWorkflow_DecisionRuleBoundaryClass["QUALITY_INTERPRETATION"] = "QUALITY_INTERPRETATION";
+    MetaWorkflow_DecisionRuleBoundaryClass["ADVISORY"] = "ADVISORY";
+})(MetaWorkflow_DecisionRuleBoundaryClass || (MetaWorkflow_DecisionRuleBoundaryClass = {}));
+/** Valid semantic conclusion emitted only after a completed evaluator execution. */
+export var MetaWorkflow_EvaluationVerdict;
+(function (MetaWorkflow_EvaluationVerdict) {
+    MetaWorkflow_EvaluationVerdict["PASS"] = "PASS";
+    MetaWorkflow_EvaluationVerdict["CONCERN"] = "CONCERN";
+    MetaWorkflow_EvaluationVerdict["GAP"] = "GAP";
+    MetaWorkflow_EvaluationVerdict["INDETERMINATE"] = "INDETERMINATE";
+})(MetaWorkflow_EvaluationVerdict || (MetaWorkflow_EvaluationVerdict = {}));
+/** One selected next step from a bounded assessment episode. */
+export var MetaWorkflow_AssessmentAction;
+(function (MetaWorkflow_AssessmentAction) {
+    MetaWorkflow_AssessmentAction["REVISE_CANDIDATE"] = "REVISE_CANDIDATE";
+    MetaWorkflow_AssessmentAction["REQUEST_EVIDENCE"] = "REQUEST_EVIDENCE";
+    MetaWorkflow_AssessmentAction["CONTINUE"] = "CONTINUE";
+    MetaWorkflow_AssessmentAction["DEFER_CONCERN"] = "DEFER_CONCERN";
+    MetaWorkflow_AssessmentAction["REQUEST_DECISION"] = "REQUEST_DECISION";
+    MetaWorkflow_AssessmentAction["STOP_GOOD_ENOUGH"] = "STOP_GOOD_ENOUGH";
+    MetaWorkflow_AssessmentAction["PROPOSE_ACCEPTANCE"] = "PROPOSE_ACCEPTANCE";
+})(MetaWorkflow_AssessmentAction || (MetaWorkflow_AssessmentAction = {}));
+/** Closed assembly contract for evaluator instructions and sealed evidence. */
+export var MetaWorkflow_EvaluationPromptAssemblyStrategy;
+(function (MetaWorkflow_EvaluationPromptAssemblyStrategy) {
+    MetaWorkflow_EvaluationPromptAssemblyStrategy["CANONICAL_PROTOCOL_EVIDENCE_V1"] = "CANONICAL_PROTOCOL_EVIDENCE_V1";
+})(MetaWorkflow_EvaluationPromptAssemblyStrategy || (MetaWorkflow_EvaluationPromptAssemblyStrategy = {}));
+/** Closed aggregation contract for criterion-level semantic verdicts. */
+export var MetaWorkflow_EvaluationAggregationStrategy;
+(function (MetaWorkflow_EvaluationAggregationStrategy) {
+    MetaWorkflow_EvaluationAggregationStrategy["WORST_VERDICT_PRECEDENCE_V1"] = "WORST_VERDICT_PRECEDENCE_V1";
+})(MetaWorkflow_EvaluationAggregationStrategy || (MetaWorkflow_EvaluationAggregationStrategy = {}));
+/** Consequence selected by a Decision Rule before continuation policy is applied. */
+export var MetaWorkflow_DecisionConsequence;
+(function (MetaWorkflow_DecisionConsequence) {
+    MetaWorkflow_DecisionConsequence["CONTINUE"] = "CONTINUE";
+    MetaWorkflow_DecisionConsequence["REVISE"] = "REVISE";
+    MetaWorkflow_DecisionConsequence["REQUEST_EVIDENCE"] = "REQUEST_EVIDENCE";
+    MetaWorkflow_DecisionConsequence["REQUEST_AUTHORITY"] = "REQUEST_AUTHORITY";
+    MetaWorkflow_DecisionConsequence["BLOCK"] = "BLOCK";
+    MetaWorkflow_DecisionConsequence["CANCEL"] = "CANCEL";
+})(MetaWorkflow_DecisionConsequence || (MetaWorkflow_DecisionConsequence = {}));
+/** Treatment-flow action produced by a Continuation Policy. */
+export var MetaWorkflow_ContinuationAction;
+(function (MetaWorkflow_ContinuationAction) {
+    MetaWorkflow_ContinuationAction["CONTINUE"] = "CONTINUE";
+    MetaWorkflow_ContinuationAction["REVISE"] = "REVISE";
+    MetaWorkflow_ContinuationAction["REQUEST_EVIDENCE"] = "REQUEST_EVIDENCE";
+    MetaWorkflow_ContinuationAction["REQUEST_AUTHORITY"] = "REQUEST_AUTHORITY";
+    MetaWorkflow_ContinuationAction["BLOCK"] = "BLOCK";
+    MetaWorkflow_ContinuationAction["CANCEL"] = "CANCEL";
+})(MetaWorkflow_ContinuationAction || (MetaWorkflow_ContinuationAction = {}));
+/** Decision mechanism that actually produced an authority response. */
+export var MetaWorkflow_AuthorityDecisionMode;
+(function (MetaWorkflow_AuthorityDecisionMode) {
+    MetaWorkflow_AuthorityDecisionMode["EXPLICIT_OPERATOR_CONFIRMATION"] = "EXPLICIT_OPERATOR_CONFIRMATION";
+    MetaWorkflow_AuthorityDecisionMode["POLICY_DECISION"] = "POLICY_DECISION";
+})(MetaWorkflow_AuthorityDecisionMode || (MetaWorkflow_AuthorityDecisionMode = {}));
+/** Assurance achieved by the selected authority channel. */
+export var MetaWorkflow_AuthorityAssuranceClass;
+(function (MetaWorkflow_AuthorityAssuranceClass) {
+    MetaWorkflow_AuthorityAssuranceClass["LOCAL_OS_SESSION"] = "LOCAL_OS_SESSION";
+    MetaWorkflow_AuthorityAssuranceClass["AUTHENTICATED_PRINCIPAL"] = "AUTHENTICATED_PRINCIPAL";
+})(MetaWorkflow_AuthorityAssuranceClass || (MetaWorkflow_AuthorityAssuranceClass = {}));
+/** Closed interaction channels understood by the generic authority membrane. */
+export var MetaWorkflow_AuthorityInteractionChannel;
+(function (MetaWorkflow_AuthorityInteractionChannel) {
+    MetaWorkflow_AuthorityInteractionChannel["INTERFACE_RELAY"] = "INTERFACE_RELAY";
+    MetaWorkflow_AuthorityInteractionChannel["LOCAL_UI"] = "LOCAL_UI";
+    MetaWorkflow_AuthorityInteractionChannel["CLI_TTY"] = "CLI_TTY";
+})(MetaWorkflow_AuthorityInteractionChannel || (MetaWorkflow_AuthorityInteractionChannel = {}));
+/** A hard floor is structurally non-waivable in every authority posture. */
+export var MetaWorkflow_HardFloorPosture;
+(function (MetaWorkflow_HardFloorPosture) {
+    MetaWorkflow_HardFloorPosture["NON_WAIVABLE"] = "NON_WAIVABLE";
+})(MetaWorkflow_HardFloorPosture || (MetaWorkflow_HardFloorPosture = {}));
+/** Portable schema identity for one executable treatment artifact. */
+export var MetaWorkflow_ExecutionDefinitionSchemaRef;
+(function (MetaWorkflow_ExecutionDefinitionSchemaRef) {
+    MetaWorkflow_ExecutionDefinitionSchemaRef["EVALUATION_TREATMENT_V1"] = "wildo:meta-workflow/evaluation-treatment-definition:v1";
+    MetaWorkflow_ExecutionDefinitionSchemaRef["STRUCTURED_ARTIFACT_ACTION_V1"] = "wildo:meta-workflow/structured-artifact-action-definition:v1";
+})(MetaWorkflow_ExecutionDefinitionSchemaRef || (MetaWorkflow_ExecutionDefinitionSchemaRef = {}));
+const _MetaWorkflow_DescriptorIdentitySchema = z.strictObject({
+    descriptorRef: MetaWorkflow_NamespacedRefSchema,
+    descriptorVersion: MetaWorkflow_PositiveVersionSchema,
+});
+const _MetaWorkflow_PolicyIdentitySchema = z.strictObject({
+    policyRef: MetaWorkflow_NamespacedRefSchema,
+    policyVersion: MetaWorkflow_PositiveVersionSchema,
+});
+const _MetaWorkflow_RequirementIdentitySchema = z.strictObject({
+    requirementRef: MetaWorkflow_NamespacedRefSchema,
+    requirementVersion: MetaWorkflow_PositiveVersionSchema,
+});
+const _MetaWorkflow_UniqueNamespacedRefsSchema = z
+    .array(MetaWorkflow_NamespacedRefSchema)
+    .refine(metaWorkflowValuesAreUnique, {
+    message: 'refs must be unique',
+});
+const _MetaWorkflow_UniqueSortedNamespacedRefsSchema = _MetaWorkflow_UniqueNamespacedRefsSchema.refine(metaWorkflowValuesAreLexicallySorted, {
+    message: 'refs must use canonical lexical order',
+});
+const _MetaWorkflow_UniqueModelOpaqueRefsSchema = z
+    .array(MetaWorkflow_OpaqueRefSchema)
+    .refine(metaWorkflowValuesAreUnique, { message: 'opaque refs must be unique' });
+const _MetaWorkflow_UniqueModelNamespacedRefsSchema = z
+    .array(MetaWorkflow_NamespacedRefSchema)
+    .refine(metaWorkflowValuesAreUnique, { message: 'refs must be unique' });
+/**
+ * One declared evidence obligation. Requirements describe what counts as
+ * evidence; they do not claim that evidence currently exists.
+ */
+const _MetaWorkflow_EvidenceRequirementSchema = z
+    .strictObject({
+    schemaVersion: z.literal(1),
+    requirementRef: MetaWorkflow_NamespacedRefSchema,
+    requirementVersion: MetaWorkflow_PositiveVersionSchema,
+    kind: z.enum(MetaWorkflow_EvidenceRequirementKind),
+    criterionRef: MetaWorkflow_NamespacedRefSchema,
+    subjectRef: MetaWorkflow_NamespacedRefSchema,
+    minCount: z.number().int().nonnegative(),
+    maxCount: z.number().int().positive().nullable(),
+    coveragePolicyRef: MetaWorkflow_NamespacedRefSchema,
+    freshnessPolicyRef: MetaWorkflow_NamespacedRefSchema,
+    conditionRef: MetaWorkflow_NamespacedRefSchema.nullable(),
+    independencePolicyRef: MetaWorkflow_NamespacedRefSchema.nullable(),
+    diversityPolicyRef: MetaWorkflow_NamespacedRefSchema.nullable(),
+    aggregationPolicyRef: MetaWorkflow_NamespacedRefSchema.nullable(),
+})
+    .superRefine((requirement, context) => {
+    if (requirement.maxCount !== null &&
+        requirement.minCount > requirement.maxCount) {
+        context.addIssue({
+            code: 'custom',
+            message: 'minCount cannot exceed maxCount',
+            path: ['maxCount'],
+        });
+    }
+    if (requirement.kind === MetaWorkflow_EvidenceRequirementKind.MANDATORY &&
+        requirement.minCount < 1) {
+        context.addIssue({
+            code: 'custom',
+            message: 'MANDATORY evidence requires minCount >= 1',
+            path: ['minCount'],
+        });
+    }
+    const needsCondition = requirement.kind === MetaWorkflow_EvidenceRequirementKind.CONDITIONAL;
+    if (needsCondition !== (requirement.conditionRef !== null)) {
+        context.addIssue({
+            code: 'custom',
+            message: 'conditionRef is required only for CONDITIONAL evidence requirements',
+            path: ['conditionRef'],
+        });
+    }
+});
+const _MetaWorkflow_EvaluationCriterionDefinitionSchema = z
+    .strictObject({
+    schemaVersion: z.literal(1),
+    criterionRef: MetaWorkflow_NamespacedRefSchema,
+    criterionVersion: MetaWorkflow_PositiveVersionSchema,
+    instruction: z.string().trim().min(1),
+    evidenceRequirements: z.array(_MetaWorkflow_RequirementIdentitySchema).min(1),
+    verdictGuidance: z.strictObject({
+        [MetaWorkflow_EvaluationVerdict.PASS]: z.string().trim().min(1),
+        [MetaWorkflow_EvaluationVerdict.CONCERN]: z.string().trim().min(1),
+        [MetaWorkflow_EvaluationVerdict.GAP]: z.string().trim().min(1),
+        [MetaWorkflow_EvaluationVerdict.INDETERMINATE]: z.string().trim().min(1),
+    }),
+})
+    .superRefine((criterion, context) => {
+    const requirementKeys = criterion.evidenceRequirements.map((requirement) => `${requirement.requirementRef}@${requirement.requirementVersion}`);
+    if (!metaWorkflowValuesAreUnique(requirementKeys) || !metaWorkflowValuesAreLexicallySorted(requirementKeys)) {
+        context.addIssue({
+            code: 'custom',
+            message: 'evidenceRequirements must be unique and canonically sorted by exact identity',
+            path: ['evidenceRequirements'],
+        });
+    }
+});
+/**
+ * Complete, portable evaluator meaning for one treatment.
+ *
+ * Criteria carry the instruction and exact evidence identities consumed by an
+ * evaluator. Prompt assembly and aggregation are deliberately closed
+ * strategies, rather than ambient implementation conventions.
+ */
+const _MetaWorkflow_EvaluationProtocolDefinitionSchema = z
+    .strictObject({
+    schemaVersion: z.literal(1),
+    protocolRef: MetaWorkflow_NamespacedRefSchema,
+    protocolVersion: MetaWorkflow_PositiveVersionSchema,
+    criteria: z.array(_MetaWorkflow_EvaluationCriterionDefinitionSchema).min(1),
+    promptAssemblyStrategy: z.literal(MetaWorkflow_EvaluationPromptAssemblyStrategy.CANONICAL_PROTOCOL_EVIDENCE_V1),
+    aggregationStrategy: z.literal(MetaWorkflow_EvaluationAggregationStrategy.WORST_VERDICT_PRECEDENCE_V1),
+    verdictPrecedence: z.tuple([
+        z.literal(MetaWorkflow_EvaluationVerdict.GAP),
+        z.literal(MetaWorkflow_EvaluationVerdict.INDETERMINATE),
+        z.literal(MetaWorkflow_EvaluationVerdict.CONCERN),
+        z.literal(MetaWorkflow_EvaluationVerdict.PASS),
+    ]),
+    aggregationPolicyRef: MetaWorkflow_NamespacedRefSchema,
+    provenance: z.strictObject({
+        sourcePlaybookRef: MetaWorkflow_NamespacedRefSchema,
+        compilerRef: MetaWorkflow_NamespacedRefSchema,
+        compilerVersion: MetaWorkflow_PositiveVersionSchema,
+    }),
+})
+    .superRefine((protocol, context) => {
+    const criterionKeys = protocol.criteria.map((criterion) => `${criterion.criterionRef}@${criterion.criterionVersion}`);
+    if (!metaWorkflowValuesAreUnique(criterionKeys) || !metaWorkflowValuesAreLexicallySorted(criterionKeys)) {
+        context.addIssue({
+            code: 'custom',
+            message: 'criteria must be unique and canonically sorted by exact identity',
+            path: ['criteria'],
+        });
+    }
+});
+/** Runtime-neutral evaluator capability declaration. */
+const _MetaWorkflow_EvaluatorDescriptorSchema = z
+    .strictObject({
+    schemaVersion: z.literal(1),
+    evaluatorRef: MetaWorkflow_NamespacedRefSchema,
+    evaluatorVersion: MetaWorkflow_PositiveVersionSchema,
+    evaluatorClass: z.enum(MetaWorkflow_EvaluatorClass),
+    acceptedEvidenceRequirementSchemaVersions: z
+        .array(MetaWorkflow_PositiveVersionSchema)
+        .min(1),
+    evaluationOutputContract: _MetaWorkflow_DescriptorIdentitySchema,
+    admissibleDriverDescriptors: z
+        .array(_MetaWorkflow_DescriptorIdentitySchema)
+        .min(1),
+    requiredCapabilityClassRefs: _MetaWorkflow_UniqueNamespacedRefsSchema.min(1),
+    requiredCapabilityFacetRefs: _MetaWorkflow_UniqueNamespacedRefsSchema,
+    requiredLifecycleFacets: z.array(z.enum(MetaWorkflow_DriverLifecycleFacet)),
+    supportedBoundaryClasses: z
+        .array(z.enum(MetaWorkflow_DecisionRuleBoundaryClass))
+        .min(1),
+    uncertaintyFacetRefs: _MetaWorkflow_UniqueNamespacedRefsSchema,
+    criterionResultFacetRefs: _MetaWorkflow_UniqueNamespacedRefsSchema,
+})
+    .superRefine((descriptor, context) => {
+    const scalarSets = [
+        {
+            path: 'acceptedEvidenceRequirementSchemaVersions',
+            values: descriptor.acceptedEvidenceRequirementSchemaVersions,
+        },
+        {
+            path: 'requiredLifecycleFacets',
+            values: descriptor.requiredLifecycleFacets,
+        },
+        {
+            path: 'supportedBoundaryClasses',
+            values: descriptor.supportedBoundaryClasses,
+        },
+    ];
+    for (const entry of scalarSets) {
+        if (!metaWorkflowValuesAreUnique(entry.values)) {
+            context.addIssue({
+                code: 'custom',
+                message: `${entry.path} must contain unique values`,
+                path: [entry.path],
+            });
+        }
+        if (!metaWorkflowValuesAreLexicallySorted(entry.values)) {
+            context.addIssue({
+                code: 'custom',
+                message: `${entry.path} must use canonical lexical order`,
+                path: [entry.path],
+            });
+        }
+    }
+    const driverKeys = descriptor.admissibleDriverDescriptors.map((identity) => `${identity.descriptorRef}@${identity.descriptorVersion}`);
+    if (!metaWorkflowValuesAreUnique(driverKeys)) {
+        context.addIssue({
+            code: 'custom',
+            message: 'admissible Driver descriptor identities must be unique',
+            path: ['admissibleDriverDescriptors'],
+        });
+    }
+});
+export const MetaWorkflow_EvaluatorDescriptorSchema = _MetaWorkflow_EvaluatorDescriptorSchema;
+/** Decision-owned policy for selecting one exact evaluator descriptor. */
+const _MetaWorkflow_EvaluatorBindingPolicySchema = z
+    .strictObject({
+    schemaVersion: z.literal(1),
+    policyRef: MetaWorkflow_NamespacedRefSchema,
+    policyVersion: MetaWorkflow_PositiveVersionSchema,
+    admissibleEvaluatorDescriptors: z
+        .array(_MetaWorkflow_DescriptorIdentitySchema)
+        .min(1),
+    defaultEvaluatorDescriptor: _MetaWorkflow_DescriptorIdentitySchema,
+    fallbackPolicyRef: MetaWorkflow_NamespacedRefSchema,
+    escalationPolicyRef: MetaWorkflow_NamespacedRefSchema,
+    maximumAttempts: z.number().int().positive(),
+    timeoutPolicyRef: MetaWorkflow_NamespacedRefSchema,
+    budgetPolicyRef: MetaWorkflow_NamespacedRefSchema,
+    outputSchemaRef: MetaWorkflow_NamespacedRefSchema,
+    selectionPolicyRef: MetaWorkflow_NamespacedRefSchema,
+})
+    .superRefine((policy, context) => {
+    const keys = policy.admissibleEvaluatorDescriptors.map((identity) => `${identity.descriptorRef}@${identity.descriptorVersion}`);
+    if (!metaWorkflowValuesAreUnique(keys)) {
+        context.addIssue({
+            code: 'custom',
+            message: 'admissible evaluator descriptor identities must be unique',
+            path: ['admissibleEvaluatorDescriptors'],
+        });
+    }
+    const defaultKey = `${policy.defaultEvaluatorDescriptor.descriptorRef}`
+        + `@${policy.defaultEvaluatorDescriptor.descriptorVersion}`
+        + ``;
+    if (!keys.includes(defaultKey)) {
+        context.addIssue({
+            code: 'custom',
+            message: 'defaultEvaluatorDescriptor must appear in admissibleEvaluatorDescriptors',
+            path: ['defaultEvaluatorDescriptor'],
+        });
+    }
+});
+/** Model citations name sealed evidence only. */
+const _MetaWorkflow_CriterionResultModelSchema = z.strictObject({
+    criterionRef: MetaWorkflow_NamespacedRefSchema,
+    verdict: z.enum(MetaWorkflow_EvaluationVerdict),
+    score: z.number().finite().min(0).max(1).nullable(),
+    evidenceRefs: _MetaWorkflow_UniqueModelOpaqueRefsSchema.min(1),
+    rationale: z.string().trim().min(1),
+});
+/**
+ * A model-local key lets proposals cite a discovery before the runtime derives
+ * its durable candidate-scoped ref.
+ *
+ * The model deliberately does not echo the assessment subject or scope. Both
+ * are sealed host inputs and the runtime attaches them to every admitted
+ * finding. Besides avoiding a meaningless trust-in-the-echo check, this keeps
+ * the provider-facing JSON Schema free of open-key records, which strict
+ * structured-output providers cannot represent portably.
+ */
+const _MetaWorkflow_DiscoveredFindingModelSchema = z.strictObject({
+    // A key is a local cross-reference, not a content address. The bound keeps
+    // strict generators from expanding hashes/evidence into the identifier and
+    // exhausting the whole output allowance before completing valid JSON.
+    findingKey: MetaWorkflow_OpaqueRefSchema.max(160),
+    materiality: MetaWorkflow_NonNegativeFiniteNumberSchema.max(1),
+    uncertainty: MetaWorkflow_NonNegativeFiniteNumberSchema.max(1),
+    evidenceRefs: _MetaWorkflow_UniqueModelOpaqueRefsSchema.min(1),
+    rationale: z.string().trim().min(1),
+});
+const _MetaWorkflow_ModelActionProposalCommonShape = {
+    criterionRefs: _MetaWorkflow_UniqueModelNamespacedRefsSchema,
+    // `findingKeys` are model-local cross-references, so their order carries no
+    // meaning at all; the runtime resolves them to derived refs and canonicalizes
+    // those. Ordering them was the one constraint the model could not even
+    // reason about, since it names keys it invented in the same response.
+    findingKeys: _MetaWorkflow_UniqueModelOpaqueRefsSchema,
+    rationale: z.string().trim().min(1),
+};
+/**
+ * Bounded suggestions only. The discriminated payload makes a proposal useful
+ * to a composition policy while deliberately excluding authority, effect,
+ * accepted-state and hard-floor-override claims from model output.
+ */
+const _MetaWorkflow_ModelActionProposalSchema = z.strictObject({
+    ..._MetaWorkflow_ModelActionProposalCommonShape,
+    action: z.enum(MetaWorkflow_AssessmentAction),
+    /**
+     * Provider-portable proposal payload. The runtime maps these two fields into
+     * the action-specific durable payload and rejects an invalid combination.
+     * Keeping the model boundary flat avoids `oneOf`, which is not accepted by
+     * every strict structured-output provider.
+     */
+    payloadRefs: _MetaWorkflow_UniqueModelOpaqueRefsSchema,
+    payloadText: z.string().trim().min(1).nullable(),
+});
+/**
+ * Model-owned semantic claims only. Runtime-owned identity, aggregation and
+ * provenance are intentionally absent so an LLM cannot counterfeit them.
+ */
+const _MetaWorkflow_StructuredSemanticModelOutputV1Schema = z.strictObject({
+    outputVersion: z.literal(1),
+    criterionResults: z.array(_MetaWorkflow_CriterionResultModelSchema).min(1),
+    discoveredFindings: z.array(_MetaWorkflow_DiscoveredFindingModelSchema),
+    actionProposals: z.array(_MetaWorkflow_ModelActionProposalSchema),
+    missingEvidenceRequirementRefs: _MetaWorkflow_UniqueModelNamespacedRefsSchema,
+    conflictingEvidenceRefs: _MetaWorkflow_UniqueModelOpaqueRefsSchema,
+    uncertainty: MetaWorkflow_NonNegativeFiniteNumberSchema.max(1),
+    /**
+     * Bounded semantic advice for application composition. These are not
+     * authority claims: deterministic hard floors, declared playbook bounds,
+     * and resource ceilings still decide whether the suggested posture is
+     * admissible. Explicit `null` is the settled-evaluation posture; dynamic
+     * working episodes refuse it before composition. Requiring the property on
+     * the provider boundary keeps the schema compatible with strict structured
+     * output without treating missing data as implicit policy.
+     *
+     * Full hierarchical/scoped posture is intentionally a later extension. The
+     * v0 boolean concerns only this sealed assessment scope; it is not a global
+     * application-wide deferral permission.
+     */
+    assessmentAdvice: z.strictObject({
+        maturity: MetaWorkflow_NonNegativeFiniteNumberSchema.max(1),
+        likelyImprovement: MetaWorkflow_NonNegativeFiniteNumberSchema.max(1),
+        scopedConcernCanDefer: z.boolean(),
+        materialOperatorDecisionRequired: z.boolean(),
+    }).nullable(),
+    limitations: z.array(z.string().trim().min(1)),
+});
+export const MetaWorkflow_StructuredSemanticModelOutputV1Schema = _MetaWorkflow_StructuredSemanticModelOutputV1Schema;
+const _MetaWorkflow_DecisionRuleMappingSchema = z.strictObject({
+    verdict: z.enum(MetaWorkflow_EvaluationVerdict),
+    consequence: z.enum(MetaWorkflow_DecisionConsequence),
+});
+const _MetaWorkflow_HardFloorBindingSchema = z.strictObject({
+    hardFloorRef: MetaWorkflow_NamespacedRefSchema,
+    evidenceRequirementRefs: _MetaWorkflow_UniqueSortedNamespacedRefsSchema.min(1),
+});
+/** Closed result mapping, not a general expression or fuzzy-rule DSL. */
+const _MetaWorkflow_DecisionRuleSchema = z
+    .strictObject({
+    schemaVersion: z.literal(1),
+    ruleRef: MetaWorkflow_NamespacedRefSchema,
+    ruleVersion: MetaWorkflow_PositiveVersionSchema,
+    boundaryClass: z.enum(MetaWorkflow_DecisionRuleBoundaryClass),
+    evidenceAggregationRef: MetaWorkflow_NamespacedRefSchema,
+    resultMappings: z.array(_MetaWorkflow_DecisionRuleMappingSchema).min(1),
+    hardFloorBindings: z.array(_MetaWorkflow_HardFloorBindingSchema),
+    hardFloorFailureConsequence: z.literal(MetaWorkflow_DecisionConsequence.BLOCK),
+    hardFloorShortcutAllowed: z.literal(false),
+    unresolvedConsequence: z.enum(MetaWorkflow_DecisionConsequence),
+    evaluatorFailureConsequence: z.enum(MetaWorkflow_DecisionConsequence),
+})
+    .superRefine((rule, context) => {
+    const verdicts = rule.resultMappings.map((mapping) => mapping.verdict);
+    if (!metaWorkflowValuesAreUnique(verdicts)) {
+        context.addIssue({
+            code: 'custom',
+            message: 'resultMappings may map each verdict only once',
+            path: ['resultMappings'],
+        });
+    }
+    const hardFloorRefs = rule.hardFloorBindings.map((binding) => binding.hardFloorRef);
+    if (!metaWorkflowValuesAreUnique(hardFloorRefs) || !metaWorkflowValuesAreLexicallySorted(hardFloorRefs)) {
+        context.addIssue({
+            code: 'custom',
+            message: 'hardFloorBindings must contain unique bindings sorted by hardFloorRef',
+            path: ['hardFloorBindings'],
+        });
+    }
+});
+/** Declared human/operator authority membrane. */
+const _MetaWorkflow_AuthorityRequirementSchema = z.strictObject({
+    schemaVersion: z.literal(1),
+    requirementRef: MetaWorkflow_NamespacedRefSchema,
+    requirementVersion: MetaWorkflow_PositiveVersionSchema,
+    consequenceClassRef: MetaWorkflow_NamespacedRefSchema,
+    riskClassRef: MetaWorkflow_NamespacedRefSchema,
+    decisionModePolicyRef: MetaWorkflow_NamespacedRefSchema,
+    assurancePolicyRef: MetaWorkflow_NamespacedRefSchema,
+    channelPolicyRef: MetaWorkflow_NamespacedRefSchema,
+    principalPolicyRef: MetaWorkflow_NamespacedRefSchema.nullable(),
+    requiredDecisionMode: z.enum(MetaWorkflow_AuthorityDecisionMode),
+    minimumAssurance: z.enum(MetaWorkflow_AuthorityAssuranceClass),
+    admittedChannels: z.array(z.enum(MetaWorkflow_AuthorityInteractionChannel)).min(1),
+    requiredEvidenceRequirementRefs: _MetaWorkflow_UniqueNamespacedRefsSchema.min(1),
+    expiryPolicyRef: MetaWorkflow_NamespacedRefSchema,
+    noncePolicyRef: MetaWorkflow_NamespacedRefSchema,
+    hardFloorPosture: z.literal(MetaWorkflow_HardFloorPosture.NON_WAIVABLE),
+    hardFloorOverrideAllowed: z.literal(false),
+}).superRefine((requirement, context) => {
+    if (!metaWorkflowValuesAreUnique(requirement.admittedChannels) || !metaWorkflowValuesAreLexicallySorted(requirement.admittedChannels)) {
+        context.addIssue({ code: 'custom', message: 'admittedChannels must be unique and lexically sorted', path: ['admittedChannels'] });
+    }
+    if (requirement.minimumAssurance === MetaWorkflow_AuthorityAssuranceClass.AUTHENTICATED_PRINCIPAL
+        && requirement.principalPolicyRef === null) {
+        context.addIssue({ code: 'custom', message: 'authenticated-principal assurance requires an explicit principal policy', path: ['principalPolicyRef'] });
+    }
+});
+/** Stable semantic Decision Point declaration. */
+const _MetaWorkflow_DecisionPointDefinitionSchema = z.strictObject({
+    schemaVersion: z.literal(1),
+    decisionPointRef: MetaWorkflow_NamespacedRefSchema,
+    decisionPointVersion: MetaWorkflow_PositiveVersionSchema,
+    triggerRefs: _MetaWorkflow_UniqueNamespacedRefsSchema,
+    evidenceRequirements: z.array(_MetaWorkflow_RequirementIdentitySchema).min(1),
+    evaluatorBindingPolicy: _MetaWorkflow_PolicyIdentitySchema,
+    decisionRule: z.strictObject({
+        ruleRef: MetaWorkflow_NamespacedRefSchema,
+        ruleVersion: MetaWorkflow_PositiveVersionSchema,
+    }),
+    authorityRequirement: _MetaWorkflow_RequirementIdentitySchema.nullable(),
+    continuationPolicy: _MetaWorkflow_PolicyIdentitySchema,
+    hardFloorRefs: _MetaWorkflow_UniqueNamespacedRefsSchema,
+    riskPolicyRef: MetaWorkflow_NamespacedRefSchema,
+    significancePolicyRef: MetaWorkflow_NamespacedRefSchema,
+});
+const _MetaWorkflow_ContinuationMappingSchema = z.strictObject({
+    decisionConsequence: z.enum(MetaWorkflow_DecisionConsequence),
+    action: z.enum(MetaWorkflow_ContinuationAction),
+});
+/** Treatment-flow policy; it has no application-truth mutation operation. */
+const _MetaWorkflow_ContinuationPolicySchema = z
+    .strictObject({
+    schemaVersion: z.literal(1),
+    policyRef: MetaWorkflow_NamespacedRefSchema,
+    policyVersion: MetaWorkflow_PositiveVersionSchema,
+    mappings: z.array(_MetaWorkflow_ContinuationMappingSchema).min(1),
+    maximumRevisionAttempts: z.number().int().nonnegative(),
+    maximumEvidenceRequests: z.number().int().nonnegative(),
+    maximumAuthorityReviews: z.number().int().nonnegative(),
+    fallbackAction: z.enum([
+        MetaWorkflow_ContinuationAction.BLOCK,
+        MetaWorkflow_ContinuationAction.CANCEL,
+    ]),
+})
+    .superRefine((policy, context) => {
+    const consequences = policy.mappings.map((mapping) => mapping.decisionConsequence);
+    if (!metaWorkflowValuesAreUnique(consequences)) {
+        context.addIssue({
+            code: 'custom',
+            message: 'mappings may contain each decision consequence only once',
+            path: ['mappings'],
+        });
+    }
+});
+/**
+ * One self-contained executable decision treatment.
+ *
+ * Every member is carried in full so a catalog artifact has no ambient
+ * semantic dependency. The backend integrity validator recomputes each nested
+ * identity and checks that the Decision Point identities refer to these exact
+ * members.
+ */
+const _MetaWorkflow_EvaluationTreatmentDefinitionSchema = z
+    .strictObject({
+    schemaVersion: z.literal(1),
+    definitionRef: MetaWorkflow_NamespacedRefSchema,
+    definitionVersion: MetaWorkflow_PositiveVersionSchema,
+    evaluationProtocol: _MetaWorkflow_EvaluationProtocolDefinitionSchema,
+    evidenceRequirements: z.array(_MetaWorkflow_EvidenceRequirementSchema).min(1),
+    evaluatorBindingPolicy: _MetaWorkflow_EvaluatorBindingPolicySchema,
+    decisionPointDefinition: _MetaWorkflow_DecisionPointDefinitionSchema,
+    decisionRule: _MetaWorkflow_DecisionRuleSchema,
+    authorityRequirement: _MetaWorkflow_AuthorityRequirementSchema.nullable(),
+    continuationPolicy: _MetaWorkflow_ContinuationPolicySchema,
+})
+    .superRefine((treatment, context) => {
+    const carriedRequirementsByKey = new Map(treatment.evidenceRequirements.map((requirement) => [
+        `${requirement.requirementRef}@${requirement.requirementVersion}`,
+        requirement,
+    ]));
+    const protocolRequirementKeys = [];
+    for (const [criterionIndex, criterion] of treatment.evaluationProtocol.criteria.entries()) {
+        for (const [requirementIndex, requirement] of criterion.evidenceRequirements.entries()) {
+            const key = `${requirement.requirementRef}@${requirement.requirementVersion}`;
+            protocolRequirementKeys.push(key);
+            const carriedRequirement = carriedRequirementsByKey.get(key);
+            if (carriedRequirement === undefined || carriedRequirement.criterionRef !== criterion.criterionRef) {
+                context.addIssue({
+                    code: 'custom',
+                    message: 'criterion evidence identity and criterionRef must match one carried Evidence Requirement',
+                    path: ['evaluationProtocol', 'criteria', criterionIndex, 'evidenceRequirements', requirementIndex],
+                });
+            }
+        }
+    }
+    const requirementKeys = treatment.evidenceRequirements.map((requirement) => `${requirement.requirementRef}@${requirement.requirementVersion}`);
+    if (!metaWorkflowValuesAreUnique(requirementKeys) || !metaWorkflowValuesAreLexicallySorted(requirementKeys)) {
+        context.addIssue({
+            code: 'custom',
+            message: 'evidenceRequirements must be unique and canonically sorted by exact identity',
+            path: ['evidenceRequirements'],
+        });
+    }
+    if (!metaWorkflowValuesAreUnique(protocolRequirementKeys)
+        || [...protocolRequirementKeys].sort().join('\0') !== [...requirementKeys].sort().join('\0')) {
+        context.addIssue({
+            code: 'custom',
+            message: 'Evaluation Protocol criteria must account exactly once for every carried Evidence Requirement',
+            path: ['evaluationProtocol', 'criteria'],
+        });
+    }
+    if (treatment.evaluationProtocol.aggregationPolicyRef !== treatment.decisionRule.evidenceAggregationRef) {
+        context.addIssue({
+            code: 'custom',
+            message: 'Evaluation Protocol aggregation policy must match the carried Decision Rule',
+            path: ['evaluationProtocol', 'aggregationPolicyRef'],
+        });
+    }
+    const declaredRequirementRefs = new Set(treatment.evidenceRequirements.map((requirement) => requirement.requirementRef));
+    const boundHardFloorRefs = treatment.decisionRule.hardFloorBindings.map((binding) => binding.hardFloorRef);
+    if (boundHardFloorRefs.join('\0') !== treatment.decisionPointDefinition.hardFloorRefs.join('\0')) {
+        context.addIssue({
+            code: 'custom',
+            message: 'Decision Rule hard-floor bindings must exactly match the Decision Point hard floors',
+            path: ['decisionRule', 'hardFloorBindings'],
+        });
+    }
+    for (const [bindingIndex, binding] of treatment.decisionRule.hardFloorBindings.entries()) {
+        if (binding.evidenceRequirementRefs.some((requirementRef) => !declaredRequirementRefs.has(requirementRef))) {
+            context.addIssue({
+                code: 'custom',
+                message: 'Every hard-floor binding must refer only to carried Evidence Requirements',
+                path: ['decisionRule', 'hardFloorBindings', bindingIndex, 'evidenceRequirementRefs'],
+            });
+        }
+    }
+    const declaredRequirementKeys = treatment.decisionPointDefinition.evidenceRequirements.map((requirement) => `${requirement.requirementRef}@${requirement.requirementVersion}`);
+    if (requirementKeys.join('\0') !== declaredRequirementKeys.join('\0')) {
+        context.addIssue({
+            code: 'custom',
+            message: 'Decision Point evidence requirements must exactly match the carried definitions',
+            path: ['decisionPointDefinition', 'evidenceRequirements'],
+        });
+    }
+    const policy = treatment.decisionPointDefinition.evaluatorBindingPolicy;
+    if (policy.policyRef !== treatment.evaluatorBindingPolicy.policyRef
+        || policy.policyVersion !== treatment.evaluatorBindingPolicy.policyVersion) {
+        context.addIssue({
+            code: 'custom',
+            message: 'Decision Point evaluator policy identity must match the carried policy',
+            path: ['decisionPointDefinition', 'evaluatorBindingPolicy'],
+        });
+    }
+    const rule = treatment.decisionPointDefinition.decisionRule;
+    if (rule.ruleRef !== treatment.decisionRule.ruleRef
+        || rule.ruleVersion !== treatment.decisionRule.ruleVersion) {
+        context.addIssue({
+            code: 'custom',
+            message: 'Decision Point rule identity must match the carried rule',
+            path: ['decisionPointDefinition', 'decisionRule'],
+        });
+    }
+    const authority = treatment.decisionPointDefinition.authorityRequirement;
+    const carriedAuthority = treatment.authorityRequirement;
+    if ((authority === null) !== (carriedAuthority === null)
+        || (authority !== null
+            && carriedAuthority !== null
+            && (authority.requirementRef !== carriedAuthority.requirementRef
+                || authority.requirementVersion !== carriedAuthority.requirementVersion))) {
+        context.addIssue({
+            code: 'custom',
+            message: 'Decision Point authority requirement identity must match the carried requirement',
+            path: ['decisionPointDefinition', 'authorityRequirement'],
+        });
+    }
+    const continuation = treatment.decisionPointDefinition.continuationPolicy;
+    if (continuation.policyRef !== treatment.continuationPolicy.policyRef
+        || continuation.policyVersion !== treatment.continuationPolicy.policyVersion) {
+        context.addIssue({
+            code: 'custom',
+            message: 'Decision Point continuation policy identity must match the carried policy',
+            path: ['decisionPointDefinition', 'continuationPolicy'],
+        });
+    }
+});
+export const MetaWorkflow_EvaluationTreatmentDefinitionSchema = _MetaWorkflow_EvaluationTreatmentDefinitionSchema;
+//# sourceMappingURL=decisions.meta-workflows.shared.schemas.js.map