@ai-dev-orchestrator/schemas 0.1.1

package/dist/governance/policy-engine.d.ts

@@ -0,0 +1,634 @@
+import { z } from 'zod/v4';
+export type { EscalationTrigger, HumanApproval, PolicyTokenUsage } from './governance';
+export declare const policyLayerSchema: z.ZodEnum<{
+    role: "role";
+    builtin: "builtin";
+    organization: "organization";
+    project: "project";
+    workflow_variant: "workflow_variant";
+    stage: "stage";
+}>;
+export type PolicyLayer = z.infer<typeof policyLayerSchema>;
+export declare const policySourceSchema: z.ZodObject<{
+    layer: z.ZodEnum<{
+        role: "role";
+        builtin: "builtin";
+        organization: "organization";
+        project: "project";
+        workflow_variant: "workflow_variant";
+        stage: "stage";
+    }>;
+    filePath: z.ZodOptional<z.ZodString>;
+    fieldPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PolicySource = z.infer<typeof policySourceSchema>;
+export declare const policyTypeSchema: z.ZodEnum<{
+    custom: "custom";
+    iteration_limit: "iteration_limit";
+    quality_gate: "quality_gate";
+    specification_readiness: "specification_readiness";
+    stage_skip: "stage_skip";
+    retry_limit: "retry_limit";
+    token_budget: "token_budget";
+    model_constraint: "model_constraint";
+    ownership: "ownership";
+    confidence_gate: "confidence_gate";
+}>;
+export type PolicyType = z.infer<typeof policyTypeSchema>;
+export declare const policyCompositionSchema: z.ZodEnum<{
+    conjunctive: "conjunctive";
+    disjunctive: "disjunctive";
+}>;
+export type PolicyComposition = z.infer<typeof policyCompositionSchema>;
+export declare const policyScopeSchema: z.ZodObject<{
+    organization: z.ZodOptional<z.ZodString>;
+    project: z.ZodOptional<z.ZodString>;
+    workflowVariant: z.ZodOptional<z.ZodString>;
+    stages: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    roles: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+export type PolicyScope = z.infer<typeof policyScopeSchema>;
+export declare const policyIterationLimitConfigSchema: z.ZodObject<{
+    maxReviewIterations: z.ZodNumber;
+    maxJudgeArbitrations: z.ZodNumber;
+    maxClarificationRounds: z.ZodNumber;
+    maxAcceptanceIterations: z.ZodNumber;
+}, z.core.$strip>;
+export type PolicyIterationLimitConfig = z.infer<typeof policyIterationLimitConfigSchema>;
+export declare const policyQualityGateConfigSchema: z.ZodObject<{
+    maxHighSeverityFindings: z.ZodNumber;
+    maxMediumSeverityFindings: z.ZodNumber;
+    requireDesignReview: z.ZodOptional<z.ZodBoolean>;
+    requireAdversarialReview: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type PolicyQualityGateConfig = z.infer<typeof policyQualityGateConfigSchema>;
+export declare const policySpecReadinessConfigSchema: z.ZodObject<{
+    minCompletenessScore: z.ZodNumber;
+}, z.core.$strip>;
+export type PolicySpecReadinessConfig = z.infer<typeof policySpecReadinessConfigSchema>;
+export declare const policyStageSkipConditionSchema: z.ZodObject<{
+    field: z.ZodString;
+    key: z.ZodOptional<z.ZodString>;
+    equals: z.ZodOptional<z.ZodUnknown>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const policyStageSkipConfigSchema: z.ZodObject<{
+    skipWhen: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        key: z.ZodOptional<z.ZodString>;
+        equals: z.ZodOptional<z.ZodUnknown>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type PolicyStageSkipConfig = z.infer<typeof policyStageSkipConfigSchema>;
+export declare const policyRetryLimitConfigSchema: z.ZodObject<{
+    maxRetries: z.ZodNumber;
+}, z.core.$strip>;
+export type PolicyRetryLimitConfig = z.infer<typeof policyRetryLimitConfigSchema>;
+export declare const policyTokenBudgetConfigSchema: z.ZodObject<{
+    maxTokens: z.ZodNumber;
+}, z.core.$strip>;
+export type PolicyTokenBudgetConfig = z.infer<typeof policyTokenBudgetConfigSchema>;
+export declare const policyModelConstraintConfigSchema: z.ZodObject<{
+    allowedModels: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type PolicyModelConstraintConfig = z.infer<typeof policyModelConstraintConfigSchema>;
+export declare const policyOwnershipConfigSchema: z.ZodObject<{
+    ownershipMap: z.ZodRecord<z.ZodString, z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    strict: z.ZodBoolean;
+}, z.core.$strip>;
+export type PolicyOwnershipConfig = z.infer<typeof policyOwnershipConfigSchema>;
+export declare const policyConfidenceGateConfigSchema: z.ZodObject<{
+    modelEscalationThreshold: z.ZodNumber;
+    humanEscalationThreshold: z.ZodNumber;
+    heuristicWeight: z.ZodNumber;
+    heuristicSignals: z.ZodObject<{
+        penalizeHedgingLanguage: z.ZodBoolean;
+        penalizeHighRetryCount: z.ZodBoolean;
+        penalizeUnresolvedFindings: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type PolicyConfidenceGateConfig = z.infer<typeof policyConfidenceGateConfigSchema>;
+export declare const policyCustomConfigSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export type PolicyCustomConfig = z.infer<typeof policyCustomConfigSchema>;
+export declare const policyDefinitionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"iteration_limit">;
+    config: z.ZodObject<{
+        maxReviewIterations: z.ZodNumber;
+        maxJudgeArbitrations: z.ZodNumber;
+        maxClarificationRounds: z.ZodNumber;
+        maxAcceptanceIterations: z.ZodNumber;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    scope: z.ZodObject<{
+        organization: z.ZodOptional<z.ZodString>;
+        project: z.ZodOptional<z.ZodString>;
+        workflowVariant: z.ZodOptional<z.ZodString>;
+        stages: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        roles: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>;
+    composition: z.ZodOptional<z.ZodEnum<{
+        conjunctive: "conjunctive";
+        disjunctive: "disjunctive";
+    }>>;
+    enabled: z.ZodBoolean;
+    locked: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"quality_gate">;
+    config: z.ZodObject<{
+        maxHighSeverityFindings: z.ZodNumber;
+        maxMediumSeverityFindings: z.ZodNumber;
+        requireDesignReview: z.ZodOptional<z.ZodBoolean>;
+        requireAdversarialReview: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    scope: z.ZodObject<{
+        organization: z.ZodOptional<z.ZodString>;
+        project: z.ZodOptional<z.ZodString>;
+        workflowVariant: z.ZodOptional<z.ZodString>;
+        stages: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        roles: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>;
+    composition: z.ZodOptional<z.ZodEnum<{
+        conjunctive: "conjunctive";
+        disjunctive: "disjunctive";
+    }>>;
+    enabled: z.ZodBoolean;
+    locked: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"specification_readiness">;
+    config: z.ZodObject<{
+        minCompletenessScore: z.ZodNumber;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    scope: z.ZodObject<{
+        organization: z.ZodOptional<z.ZodString>;
+        project: z.ZodOptional<z.ZodString>;
+        workflowVariant: z.ZodOptional<z.ZodString>;
+        stages: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        roles: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>;
+    composition: z.ZodOptional<z.ZodEnum<{
+        conjunctive: "conjunctive";
+        disjunctive: "disjunctive";
+    }>>;
+    enabled: z.ZodBoolean;
+    locked: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"stage_skip">;
+    config: z.ZodObject<{
+        skipWhen: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            key: z.ZodOptional<z.ZodString>;
+            equals: z.ZodOptional<z.ZodUnknown>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    scope: z.ZodObject<{
+        organization: z.ZodOptional<z.ZodString>;
+        project: z.ZodOptional<z.ZodString>;
+        workflowVariant: z.ZodOptional<z.ZodString>;
+        stages: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        roles: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>;
+    composition: z.ZodOptional<z.ZodEnum<{
+        conjunctive: "conjunctive";
+        disjunctive: "disjunctive";
+    }>>;
+    enabled: z.ZodBoolean;
+    locked: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"retry_limit">;
+    config: z.ZodObject<{
+        maxRetries: z.ZodNumber;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    scope: z.ZodObject<{
+        organization: z.ZodOptional<z.ZodString>;
+        project: z.ZodOptional<z.ZodString>;
+        workflowVariant: z.ZodOptional<z.ZodString>;
+        stages: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        roles: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>;
+    composition: z.ZodOptional<z.ZodEnum<{
+        conjunctive: "conjunctive";
+        disjunctive: "disjunctive";
+    }>>;
+    enabled: z.ZodBoolean;
+    locked: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"token_budget">;
+    config: z.ZodObject<{
+        maxTokens: z.ZodNumber;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    scope: z.ZodObject<{
+        organization: z.ZodOptional<z.ZodString>;
+        project: z.ZodOptional<z.ZodString>;
+        workflowVariant: z.ZodOptional<z.ZodString>;
+        stages: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        roles: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>;
+    composition: z.ZodOptional<z.ZodEnum<{
+        conjunctive: "conjunctive";
+        disjunctive: "disjunctive";
+    }>>;
+    enabled: z.ZodBoolean;
+    locked: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"model_constraint">;
+    config: z.ZodObject<{
+        allowedModels: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    scope: z.ZodObject<{
+        organization: z.ZodOptional<z.ZodString>;
+        project: z.ZodOptional<z.ZodString>;
+        workflowVariant: z.ZodOptional<z.ZodString>;
+        stages: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        roles: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>;
+    composition: z.ZodOptional<z.ZodEnum<{
+        conjunctive: "conjunctive";
+        disjunctive: "disjunctive";
+    }>>;
+    enabled: z.ZodBoolean;
+    locked: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"ownership">;
+    config: z.ZodObject<{
+        ownershipMap: z.ZodRecord<z.ZodString, z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        strict: z.ZodBoolean;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    scope: z.ZodObject<{
+        organization: z.ZodOptional<z.ZodString>;
+        project: z.ZodOptional<z.ZodString>;
+        workflowVariant: z.ZodOptional<z.ZodString>;
+        stages: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        roles: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>;
+    composition: z.ZodOptional<z.ZodEnum<{
+        conjunctive: "conjunctive";
+        disjunctive: "disjunctive";
+    }>>;
+    enabled: z.ZodBoolean;
+    locked: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"confidence_gate">;
+    config: z.ZodObject<{
+        modelEscalationThreshold: z.ZodNumber;
+        humanEscalationThreshold: z.ZodNumber;
+        heuristicWeight: z.ZodNumber;
+        heuristicSignals: z.ZodObject<{
+            penalizeHedgingLanguage: z.ZodBoolean;
+            penalizeHighRetryCount: z.ZodBoolean;
+            penalizeUnresolvedFindings: z.ZodBoolean;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    scope: z.ZodObject<{
+        organization: z.ZodOptional<z.ZodString>;
+        project: z.ZodOptional<z.ZodString>;
+        workflowVariant: z.ZodOptional<z.ZodString>;
+        stages: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        roles: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>;
+    composition: z.ZodOptional<z.ZodEnum<{
+        conjunctive: "conjunctive";
+        disjunctive: "disjunctive";
+    }>>;
+    enabled: z.ZodBoolean;
+    locked: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"custom">;
+    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    id: z.ZodString;
+    scope: z.ZodObject<{
+        organization: z.ZodOptional<z.ZodString>;
+        project: z.ZodOptional<z.ZodString>;
+        workflowVariant: z.ZodOptional<z.ZodString>;
+        stages: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        roles: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>;
+    composition: z.ZodOptional<z.ZodEnum<{
+        conjunctive: "conjunctive";
+        disjunctive: "disjunctive";
+    }>>;
+    enabled: z.ZodBoolean;
+    locked: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>], "type">;
+export type PolicyDefinition = z.infer<typeof policyDefinitionSchema>;
+export declare const policyOutcomeSchema: z.ZodEnum<{
+    deny: "deny";
+    escalate: "escalate";
+    allow: "allow";
+}>;
+export type PolicyOutcome = z.infer<typeof policyOutcomeSchema>;
+export declare const policyResultOutcomeSchema: z.ZodEnum<{
+    pass: "pass";
+    fail: "fail";
+    skip: "skip";
+    warn: "warn";
+}>;
+export type PolicyResultOutcome = z.infer<typeof policyResultOutcomeSchema>;
+export declare const policyResultSchema: z.ZodObject<{
+    policyId: z.ZodString;
+    policyType: z.ZodEnum<{
+        custom: "custom";
+        iteration_limit: "iteration_limit";
+        quality_gate: "quality_gate";
+        specification_readiness: "specification_readiness";
+        stage_skip: "stage_skip";
+        retry_limit: "retry_limit";
+        token_budget: "token_budget";
+        model_constraint: "model_constraint";
+        ownership: "ownership";
+        confidence_gate: "confidence_gate";
+    }>;
+    outcome: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        skip: "skip";
+        warn: "warn";
+    }>;
+    reason: z.ZodString;
+    source: z.ZodObject<{
+        layer: z.ZodEnum<{
+            role: "role";
+            builtin: "builtin";
+            organization: "organization";
+            project: "project";
+            workflow_variant: "workflow_variant";
+            stage: "stage";
+        }>;
+        filePath: z.ZodOptional<z.ZodString>;
+        fieldPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    detail: z.ZodOptional<z.ZodString>;
+    escalationTrigger: z.ZodOptional<z.ZodEnum<{
+        iteration_limit_exceeded: "iteration_limit_exceeded";
+        quality_gate_failed: "quality_gate_failed";
+        unresolvable_conflict: "unresolvable_conflict";
+        human_requested: "human_requested";
+        token_budget_exceeded: "token_budget_exceeded";
+        retry_limit_exceeded: "retry_limit_exceeded";
+        confidence_too_low: "confidence_too_low";
+        provider_failure: "provider_failure";
+        timeout: "timeout";
+        unrecoverable_error: "unrecoverable_error";
+    }>>;
+}, z.core.$strip>;
+export type PolicyResult = z.infer<typeof policyResultSchema>;
+export declare const policyFindingRefSchema: z.ZodObject<{
+    id: z.ZodString;
+    severity: z.ZodString;
+    blocking: z.ZodString;
+    status: z.ZodString;
+}, z.core.$strip>;
+export type PolicyFindingRef = z.infer<typeof policyFindingRefSchema>;
+export declare const policyContextSchema: z.ZodObject<{
+    runId: z.ZodString;
+    currentState: z.ZodString;
+    requestedTransition: z.ZodOptional<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+    }, z.core.$strip>>;
+    artifacts: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            intake_requirements: "intake_requirements";
+            canonical_specification: "canonical_specification";
+            clarification_questions: "clarification_questions";
+            clarification_answers: "clarification_answers";
+            plan: "plan";
+            plan_review: "plan_review";
+            test_plan: "test_plan";
+            implementation: "implementation";
+            static_review: "static_review";
+            security_review: "security_review";
+            performance_review: "performance_review";
+            adversarial_review: "adversarial_review";
+            design_review: "design_review";
+            docs_review: "docs_review";
+            ux_review: "ux_review";
+            review_report: "review_report";
+            remediation_plan: "remediation_plan";
+            verification: "verification";
+            judge_decision: "judge_decision";
+            planning_agreement: "planning_agreement";
+            implementation_agreement: "implementation_agreement";
+            verification_agreement: "verification_agreement";
+            release_summary: "release_summary";
+            release_agreement: "release_agreement";
+            escalation_context: "escalation_context";
+            run_manifest: "run_manifest";
+            codebase_context: "codebase_context";
+            test_suite: "test_suite";
+            acceptance_validation: "acceptance_validation";
+            review_findings: "review_findings";
+            task_breakdown: "task_breakdown";
+            decomposition_review: "decomposition_review";
+            task_specifications: "task_specifications";
+            pr_diff_context: "pr_diff_context";
+        }>;
+        name: z.ZodString;
+        version: z.ZodNumber;
+        checksum: z.ZodString;
+    }, z.core.$strip>>>;
+    findings: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        severity: z.ZodString;
+        blocking: z.ZodString;
+        status: z.ZodString;
+    }, z.core.$strip>>>>;
+    iterationCount: z.ZodOptional<z.ZodNumber>;
+    role: z.ZodOptional<z.ZodString>;
+    workflowVariant: z.ZodOptional<z.ZodString>;
+    humanApproval: z.ZodOptional<z.ZodObject<{
+        approvedBy: z.ZodString;
+        timestamp: z.ZodString;
+        conditions: z.ZodOptional<z.ZodString>;
+        artifactRef: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<{
+                intake_requirements: "intake_requirements";
+                canonical_specification: "canonical_specification";
+                clarification_questions: "clarification_questions";
+                clarification_answers: "clarification_answers";
+                plan: "plan";
+                plan_review: "plan_review";
+                test_plan: "test_plan";
+                implementation: "implementation";
+                static_review: "static_review";
+                security_review: "security_review";
+                performance_review: "performance_review";
+                adversarial_review: "adversarial_review";
+                design_review: "design_review";
+                docs_review: "docs_review";
+                ux_review: "ux_review";
+                review_report: "review_report";
+                remediation_plan: "remediation_plan";
+                verification: "verification";
+                judge_decision: "judge_decision";
+                planning_agreement: "planning_agreement";
+                implementation_agreement: "implementation_agreement";
+                verification_agreement: "verification_agreement";
+                release_summary: "release_summary";
+                release_agreement: "release_agreement";
+                escalation_context: "escalation_context";
+                run_manifest: "run_manifest";
+                codebase_context: "codebase_context";
+                test_suite: "test_suite";
+                acceptance_validation: "acceptance_validation";
+                review_findings: "review_findings";
+                task_breakdown: "task_breakdown";
+                decomposition_review: "decomposition_review";
+                task_specifications: "task_specifications";
+                pr_diff_context: "pr_diff_context";
+            }>;
+            name: z.ZodString;
+            version: z.ZodNumber;
+            checksum: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    tokenUsage: z.ZodOptional<z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        totalTokens: z.ZodNumber;
+    }, z.core.$strip>>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        completenessScore: z.ZodOptional<z.ZodNumber>;
+        ambiguityCount: z.ZodOptional<z.ZodNumber>;
+        model: z.ZodOptional<z.ZodString>;
+        retryCount: z.ZodOptional<z.ZodNumber>;
+        skipStage: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$catchall<z.ZodUnknown>>>;
+}, z.core.$strip>;
+export type PolicyContext = z.infer<typeof policyContextSchema>;
+export declare const policyDecisionSchema: z.ZodObject<{
+    outcome: z.ZodEnum<{
+        deny: "deny";
+        escalate: "escalate";
+        allow: "allow";
+    }>;
+    results: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        policyId: z.ZodString;
+        policyType: z.ZodEnum<{
+            custom: "custom";
+            iteration_limit: "iteration_limit";
+            quality_gate: "quality_gate";
+            specification_readiness: "specification_readiness";
+            stage_skip: "stage_skip";
+            retry_limit: "retry_limit";
+            token_budget: "token_budget";
+            model_constraint: "model_constraint";
+            ownership: "ownership";
+            confidence_gate: "confidence_gate";
+        }>;
+        outcome: z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+            skip: "skip";
+            warn: "warn";
+        }>;
+        reason: z.ZodString;
+        source: z.ZodObject<{
+            layer: z.ZodEnum<{
+                role: "role";
+                builtin: "builtin";
+                organization: "organization";
+                project: "project";
+                workflow_variant: "workflow_variant";
+                stage: "stage";
+            }>;
+            filePath: z.ZodOptional<z.ZodString>;
+            fieldPath: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        detail: z.ZodOptional<z.ZodString>;
+        escalationTrigger: z.ZodOptional<z.ZodEnum<{
+            iteration_limit_exceeded: "iteration_limit_exceeded";
+            quality_gate_failed: "quality_gate_failed";
+            unresolvable_conflict: "unresolvable_conflict";
+            human_requested: "human_requested";
+            token_budget_exceeded: "token_budget_exceeded";
+            retry_limit_exceeded: "retry_limit_exceeded";
+            confidence_too_low: "confidence_too_low";
+            provider_failure: "provider_failure";
+            timeout: "timeout";
+            unrecoverable_error: "unrecoverable_error";
+        }>>;
+    }, z.core.$strip>>>;
+    reason: z.ZodString;
+    remediations: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    escalationTrigger: z.ZodOptional<z.ZodEnum<{
+        iteration_limit_exceeded: "iteration_limit_exceeded";
+        quality_gate_failed: "quality_gate_failed";
+        unresolvable_conflict: "unresolvable_conflict";
+        human_requested: "human_requested";
+        token_budget_exceeded: "token_budget_exceeded";
+        retry_limit_exceeded: "retry_limit_exceeded";
+        confidence_too_low: "confidence_too_low";
+        provider_failure: "provider_failure";
+        timeout: "timeout";
+        unrecoverable_error: "unrecoverable_error";
+    }>>;
+}, z.core.$strip>;
+export type PolicyDecision = z.infer<typeof policyDecisionSchema>;
+export declare const mergeLogEntrySchema: z.ZodObject<{
+    policyId: z.ZodString;
+    field: z.ZodString;
+    fromLayer: z.ZodEnum<{
+        role: "role";
+        builtin: "builtin";
+        organization: "organization";
+        project: "project";
+        workflow_variant: "workflow_variant";
+        stage: "stage";
+    }>;
+    toLayer: z.ZodEnum<{
+        role: "role";
+        builtin: "builtin";
+        organization: "organization";
+        project: "project";
+        workflow_variant: "workflow_variant";
+        stage: "stage";
+    }>;
+    action: z.ZodEnum<{
+        override: "override";
+        merge: "merge";
+        append: "append";
+        blocked_by_lock: "blocked_by_lock";
+    }>;
+    fromValue: z.ZodUnknown;
+    toValue: z.ZodUnknown;
+}, z.core.$strip>;
+export type MergeLogEntry = z.infer<typeof mergeLogEntrySchema>;
+export declare const policyTypeInfoSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        custom: "custom";
+        iteration_limit: "iteration_limit";
+        quality_gate: "quality_gate";
+        specification_readiness: "specification_readiness";
+        stage_skip: "stage_skip";
+        retry_limit: "retry_limit";
+        token_budget: "token_budget";
+        model_constraint: "model_constraint";
+        ownership: "ownership";
+        confidence_gate: "confidence_gate";
+    }>;
+    description: z.ZodString;
+    configSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    builtIn: z.ZodBoolean;
+}, z.core.$strip>;
+export type PolicyTypeInfo = z.infer<typeof policyTypeInfoSchema>;
+export declare const policyValidationResultSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    errors: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    warnings: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type PolicyValidationResult = z.infer<typeof policyValidationResultSchema>;
+export interface ResolvedPolicySet {
+    readonly policies: readonly PolicyDefinition[];
+    readonly sources: ReadonlyMap<string, PolicySource>;
+    readonly mergeLog: readonly MergeLogEntry[];
+}