@ai-dev-orchestrator/schemas 0.1.1

package/dist/artifacts/artifact-system.js

@@ -0,0 +1,124 @@
+import { z } from 'zod/v4';
+export const ARTIFACT_TYPES = [
+    'intake_requirements',
+    'canonical_specification',
+    'clarification_questions',
+    'clarification_answers',
+    'plan',
+    'plan_review',
+    'test_plan',
+    'implementation',
+    'static_review',
+    'security_review',
+    'performance_review',
+    'adversarial_review',
+    'design_review',
+    'docs_review',
+    'ux_review',
+    'review_report',
+    'remediation_plan',
+    'verification',
+    'judge_decision',
+    'planning_agreement',
+    'implementation_agreement',
+    'verification_agreement',
+    'release_summary',
+    'release_agreement',
+    'escalation_context',
+    'run_manifest',
+    'codebase_context',
+    'test_suite',
+    'acceptance_validation',
+    'review_findings',
+    'task_breakdown',
+    'decomposition_review',
+    'task_specifications',
+    'pr_diff_context',
+];
+export const artifactTypeSchema = z.enum(ARTIFACT_TYPES);
+export const artifactRefSchema = z.object({
+    type: artifactTypeSchema,
+    name: z.string(),
+    version: z.number(),
+    checksum: z.string(),
+});
+export const artifactInputSchema = z.object({
+    type: artifactTypeSchema,
+    name: z.string(),
+    runId: z.string().optional(),
+    content: z.string(),
+    producedBy: z.string(),
+    predecessorRef: artifactRefSchema.optional(),
+    metadata: z
+        .object({
+        validationFailed: z.boolean().optional(),
+    })
+        .catchall(z.unknown())
+        .optional(),
+    preValidated: z.boolean().optional(),
+});
+export const artifactSchema = z.object({
+    ref: artifactRefSchema,
+    type: artifactTypeSchema,
+    name: z.string(),
+    version: z.number(),
+    content: z.string(),
+    checksum: z.string(),
+    producedBy: z.string(),
+    predecessorRef: artifactRefSchema.optional(),
+    createdAt: z.string(),
+    sizeBytes: z.number(),
+    metadata: z
+        .object({
+        validationFailed: z.boolean().optional(),
+    })
+        .catchall(z.unknown())
+        .optional(),
+});
+export const artifactQuerySchema = z.object({
+    type: artifactTypeSchema.optional(),
+    name: z.string().optional(),
+    producedBy: z.string().optional(),
+    minVersion: z.number().optional(),
+    maxVersion: z.number().optional(),
+    createdAfter: z.string().optional(),
+    createdBefore: z.string().optional(),
+});
+export const artifactSummarySchema = z.object({
+    ref: artifactRefSchema,
+    type: artifactTypeSchema,
+    name: z.string(),
+    version: z.number(),
+    producedBy: z.string(),
+    createdAt: z.string(),
+    sizeBytes: z.number(),
+});
+export const artifactInventorySchema = z.object({
+    runId: z.string(),
+    artifacts: z.array(artifactSummarySchema).readonly(),
+    totalCount: z.number(),
+    totalSizeBytes: z.number(),
+});
+export const integrityResultSchema = z.object({
+    valid: z.boolean(),
+    expectedChecksum: z.string(),
+    actualChecksum: z.string(),
+    ref: artifactRefSchema,
+});
+export const artifactMetadataSchema = z.object({
+    type: artifactTypeSchema,
+    name: z.string(),
+    runId: z.string().optional(),
+    version: z.number(),
+    checksum: z.string(),
+    producedBy: z.string(),
+    predecessorRef: artifactRefSchema.nullable(),
+    createdAt: z.string(),
+    sizeBytes: z.number(),
+    metadata: z
+        .object({
+        validationFailed: z.boolean().optional(),
+    })
+        .catchall(z.unknown())
+        .optional(),
+});

package/dist/artifacts/index.d.ts

@@ -0,0 +1,3 @@
+export * from './artifact-system';
+export * from './agreement-artifacts';
+export * from './artifact-dependency-graph';

package/dist/artifacts/index.js

@@ -0,0 +1,3 @@
+export * from './artifact-system';
+export * from './agreement-artifacts';
+export * from './artifact-dependency-graph';

package/dist/config/configuration.d.ts

@@ -0,0 +1,324 @@
+import { z } from 'zod/v4';
+export declare const logLevelSchema: z.ZodEnum<{
+    error: "error";
+    warn: "warn";
+    debug: "debug";
+    info: "info";
+}>;
+export type LogLevel = z.infer<typeof logLevelSchema>;
+export declare const runtimeConfigSchema: z.ZodObject<{
+    logLevel: z.ZodEnum<{
+        error: "error";
+        warn: "warn";
+        debug: "debug";
+        info: "info";
+    }>;
+    reportOutputPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type RuntimeConfig = z.infer<typeof runtimeConfigSchema>;
+export declare const specificationReadinessGateSchema: z.ZodObject<{
+    minCompletenessScore: z.ZodNumber;
+}, z.core.$strip>;
+export type SpecificationReadinessGate = z.infer<typeof specificationReadinessGateSchema>;
+export declare const implementationReviewGateSchema: z.ZodObject<{
+    maxHighSeverityFindings: z.ZodNumber;
+    maxMediumSeverityFindings: z.ZodNumber;
+}, z.core.$strip>;
+export type ImplementationReviewGate = z.infer<typeof implementationReviewGateSchema>;
+export declare const qualityGateConfigSchema: z.ZodObject<{
+    specificationReadiness: z.ZodObject<{
+        minCompletenessScore: z.ZodNumber;
+    }, z.core.$strip>;
+    implementationReview: z.ZodObject<{
+        maxHighSeverityFindings: z.ZodNumber;
+        maxMediumSeverityFindings: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type QualityGateConfig = z.infer<typeof qualityGateConfigSchema>;
+export declare const iterationLimitDefaultsSchema: z.ZodObject<{
+    maxReviewIterations: z.ZodNumber;
+    maxJudgeArbitrations: z.ZodNumber;
+    maxClarificationRounds: z.ZodNumber;
+    maxAcceptanceIterations: z.ZodNumber;
+}, z.core.$strip>;
+export type IterationLimitDefaults = z.infer<typeof iterationLimitDefaultsSchema>;
+export declare const iterationLimitConfigSchema: z.ZodObject<{
+    defaults: z.ZodObject<{
+        maxReviewIterations: z.ZodNumber;
+        maxJudgeArbitrations: z.ZodNumber;
+        maxClarificationRounds: z.ZodNumber;
+        maxAcceptanceIterations: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type IterationLimitConfig = z.infer<typeof iterationLimitConfigSchema>;
+export declare const budgetConfigSchema: z.ZodObject<{
+    maxTokensPerRun: z.ZodOptional<z.ZodNumber>;
+    alertThresholds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodNumber>>>;
+}, z.core.$strip>;
+export type BudgetConfig = z.infer<typeof budgetConfigSchema>;
+export declare const confidenceGateConfigSchema: 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 ConfidenceGateConfig = z.infer<typeof confidenceGateConfigSchema>;
+export declare const governanceConfigSchema: z.ZodObject<{
+    iterationLimits: z.ZodObject<{
+        defaults: z.ZodObject<{
+            maxReviewIterations: z.ZodNumber;
+            maxJudgeArbitrations: z.ZodNumber;
+            maxClarificationRounds: z.ZodNumber;
+            maxAcceptanceIterations: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    qualityGates: z.ZodObject<{
+        specificationReadiness: z.ZodObject<{
+            minCompletenessScore: z.ZodNumber;
+        }, z.core.$strip>;
+        implementationReview: z.ZodObject<{
+            maxHighSeverityFindings: z.ZodNumber;
+            maxMediumSeverityFindings: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    budget: z.ZodOptional<z.ZodObject<{
+        maxTokensPerRun: z.ZodOptional<z.ZodNumber>;
+        alertThresholds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodNumber>>>;
+    }, z.core.$strip>>;
+    confidenceGate: z.ZodOptional<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>>;
+}, z.core.$strip>;
+export type GovernanceConfig = z.infer<typeof governanceConfigSchema>;
+export declare const roleAssignmentSchema: z.ZodObject<{
+    model: z.ZodString;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    dispatchType: z.ZodOptional<z.ZodEnum<{
+        agent: "agent";
+    }>>;
+    runner: z.ZodOptional<z.ZodString>;
+    agentConfig: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        instructions: z.ZodOptional<z.ZodString>;
+        command: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        handshakeTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        liveRequestTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        endpoint: z.ZodOptional<z.ZodString>;
+        authHeader: z.ZodOptional<z.ZodString>;
+        pollIntervalMs: z.ZodOptional<z.ZodNumber>;
+        maxTurns: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RoleAssignment = z.infer<typeof roleAssignmentSchema>;
+export declare const customRoleDefinitionSchema: z.ZodObject<{
+    description: z.ZodString;
+    ownedArtifacts: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    readableArtifacts: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    forbiddenArtifacts: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    requiredCapabilities: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    reviewedBy: z.ZodOptional<z.ZodString>;
+    reviews: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CustomRoleDefinition = z.infer<typeof customRoleDefinitionSchema>;
+export declare const permissionRuleSchema: z.ZodObject<{
+    action: z.ZodString;
+    decision: z.ZodEnum<{
+        grant: "grant";
+        deny: "deny";
+    }>;
+    scope: z.ZodOptional<z.ZodString>;
+    pattern: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PermissionRule = z.infer<typeof permissionRuleSchema>;
+export declare const permissionPolicySchema: z.ZodObject<{
+    defaultAction: z.ZodOptional<z.ZodEnum<{
+        grant: "grant";
+        deny: "deny";
+        ask_human: "ask_human";
+    }>>;
+    rules: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        action: z.ZodString;
+        decision: z.ZodEnum<{
+            grant: "grant";
+            deny: "deny";
+        }>;
+        scope: z.ZodOptional<z.ZodString>;
+        pattern: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>>;
+    roleTrust: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    safeCommands: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+export type PermissionPolicy = z.infer<typeof permissionPolicySchema>;
+export declare const rolesConfigSchema: z.ZodObject<{
+    assignments: z.ZodRecord<z.ZodString, z.ZodObject<{
+        model: z.ZodString;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+        overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        dispatchType: z.ZodOptional<z.ZodEnum<{
+            agent: "agent";
+        }>>;
+        runner: z.ZodOptional<z.ZodString>;
+        agentConfig: z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            timeoutMs: z.ZodOptional<z.ZodNumber>;
+            instructions: z.ZodOptional<z.ZodString>;
+            command: z.ZodOptional<z.ZodString>;
+            args: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            handshakeTimeoutMs: z.ZodOptional<z.ZodNumber>;
+            liveRequestTimeoutMs: z.ZodOptional<z.ZodNumber>;
+            endpoint: z.ZodOptional<z.ZodString>;
+            authHeader: z.ZodOptional<z.ZodString>;
+            pollIntervalMs: z.ZodOptional<z.ZodNumber>;
+            maxTurns: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    customRoles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        description: z.ZodString;
+        ownedArtifacts: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        readableArtifacts: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        forbiddenArtifacts: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        requiredCapabilities: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        reviewedBy: z.ZodOptional<z.ZodString>;
+        reviews: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    permissionPolicy: z.ZodOptional<z.ZodObject<{
+        defaultAction: z.ZodOptional<z.ZodEnum<{
+            grant: "grant";
+            deny: "deny";
+            ask_human: "ask_human";
+        }>>;
+        rules: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            action: z.ZodString;
+            decision: z.ZodEnum<{
+                grant: "grant";
+                deny: "deny";
+            }>;
+            scope: z.ZodOptional<z.ZodString>;
+            pattern: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>>;
+        roleTrust: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        safeCommands: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RolesConfig = z.infer<typeof rolesConfigSchema>;
+export declare const workflowConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    globalTransitionLimit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type WorkflowConfig = z.infer<typeof workflowConfigSchema>;
+export declare const mergedConfigurationSchema: z.ZodObject<{
+    workflow: z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+        globalTransitionLimit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    roles: z.ZodObject<{
+        assignments: z.ZodRecord<z.ZodString, z.ZodObject<{
+            model: z.ZodString;
+            maxTokens: z.ZodOptional<z.ZodNumber>;
+            overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            dispatchType: z.ZodOptional<z.ZodEnum<{
+                agent: "agent";
+            }>>;
+            runner: z.ZodOptional<z.ZodString>;
+            agentConfig: z.ZodOptional<z.ZodObject<{
+                model: z.ZodOptional<z.ZodString>;
+                timeoutMs: z.ZodOptional<z.ZodNumber>;
+                instructions: z.ZodOptional<z.ZodString>;
+                command: z.ZodOptional<z.ZodString>;
+                args: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+                handshakeTimeoutMs: z.ZodOptional<z.ZodNumber>;
+                liveRequestTimeoutMs: z.ZodOptional<z.ZodNumber>;
+                endpoint: z.ZodOptional<z.ZodString>;
+                authHeader: z.ZodOptional<z.ZodString>;
+                pollIntervalMs: z.ZodOptional<z.ZodNumber>;
+                maxTurns: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        customRoles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            description: z.ZodString;
+            ownedArtifacts: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            readableArtifacts: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            forbiddenArtifacts: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            requiredCapabilities: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            reviewedBy: z.ZodOptional<z.ZodString>;
+            reviews: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        permissionPolicy: z.ZodOptional<z.ZodObject<{
+            defaultAction: z.ZodOptional<z.ZodEnum<{
+                grant: "grant";
+                deny: "deny";
+                ask_human: "ask_human";
+            }>>;
+            rules: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                action: z.ZodString;
+                decision: z.ZodEnum<{
+                    grant: "grant";
+                    deny: "deny";
+                }>;
+                scope: z.ZodOptional<z.ZodString>;
+                pattern: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>>;
+            roleTrust: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            safeCommands: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    governance: z.ZodObject<{
+        iterationLimits: z.ZodObject<{
+            defaults: z.ZodObject<{
+                maxReviewIterations: z.ZodNumber;
+                maxJudgeArbitrations: z.ZodNumber;
+                maxClarificationRounds: z.ZodNumber;
+                maxAcceptanceIterations: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        qualityGates: z.ZodObject<{
+            specificationReadiness: z.ZodObject<{
+                minCompletenessScore: z.ZodNumber;
+            }, z.core.$strip>;
+            implementationReview: z.ZodObject<{
+                maxHighSeverityFindings: z.ZodNumber;
+                maxMediumSeverityFindings: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        budget: z.ZodOptional<z.ZodObject<{
+            maxTokensPerRun: z.ZodOptional<z.ZodNumber>;
+            alertThresholds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodNumber>>>;
+        }, z.core.$strip>>;
+        confidenceGate: z.ZodOptional<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>>;
+    }, z.core.$strip>;
+    runtime: z.ZodObject<{
+        logLevel: z.ZodEnum<{
+            error: "error";
+            warn: "warn";
+            debug: "debug";
+            info: "info";
+        }>;
+        reportOutputPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type MergedConfiguration = z.infer<typeof mergedConfigurationSchema>;

package/dist/config/configuration.js

@@ -0,0 +1,93 @@
+import { z } from 'zod/v4';
+import { agentConfigSchema, dispatchTypeSchema } from '../runner/role-system';
+import { permissionDecisionActionSchema } from '../shared/string-enums';
+export const logLevelSchema = z.enum(['debug', 'info', 'warn', 'error']);
+export const runtimeConfigSchema = z.object({
+    logLevel: logLevelSchema,
+    reportOutputPath: z.string().optional(),
+});
+export const specificationReadinessGateSchema = z.object({
+    minCompletenessScore: z.number(),
+});
+export const implementationReviewGateSchema = z.object({
+    maxHighSeverityFindings: z.number(),
+    maxMediumSeverityFindings: z.number(),
+});
+export const qualityGateConfigSchema = z.object({
+    specificationReadiness: specificationReadinessGateSchema,
+    implementationReview: implementationReviewGateSchema,
+});
+export const iterationLimitDefaultsSchema = z.object({
+    maxReviewIterations: z.number(),
+    maxJudgeArbitrations: z.number(),
+    maxClarificationRounds: z.number(),
+    maxAcceptanceIterations: z.number(),
+});
+export const iterationLimitConfigSchema = z.object({
+    defaults: iterationLimitDefaultsSchema,
+});
+export const budgetConfigSchema = z.object({
+    maxTokensPerRun: z.number().optional(),
+    alertThresholds: z.array(z.number()).readonly().optional(),
+});
+export const confidenceGateConfigSchema = z.object({
+    modelEscalationThreshold: z.number().min(0).max(1),
+    humanEscalationThreshold: z.number().min(0).max(1),
+    heuristicWeight: z.number().min(0).max(1),
+    heuristicSignals: z.object({
+        penalizeHedgingLanguage: z.boolean(),
+        penalizeHighRetryCount: z.boolean(),
+        penalizeUnresolvedFindings: z.boolean(),
+    }),
+});
+export const governanceConfigSchema = z.object({
+    iterationLimits: iterationLimitConfigSchema,
+    qualityGates: qualityGateConfigSchema,
+    budget: budgetConfigSchema.optional(),
+    confidenceGate: confidenceGateConfigSchema.optional(),
+});
+export const roleAssignmentSchema = z.object({
+    model: z.string().min(1),
+    maxTokens: z.number().optional(),
+    overrides: z.record(z.string(), z.unknown()).optional(),
+    dispatchType: dispatchTypeSchema.optional(),
+    runner: z.string().min(1).optional(),
+    agentConfig: agentConfigSchema.optional(),
+});
+export const customRoleDefinitionSchema = z.object({
+    description: z.string(),
+    ownedArtifacts: z.array(z.string()).readonly(),
+    readableArtifacts: z.array(z.string()).readonly(),
+    forbiddenArtifacts: z.array(z.string()).readonly(),
+    requiredCapabilities: z.array(z.string()).readonly(),
+    reviewedBy: z.string().optional(),
+    reviews: z.string().optional(),
+});
+export const permissionRuleSchema = z.object({
+    action: z.string(),
+    decision: z.enum(['grant', 'deny']),
+    scope: z.string().optional(),
+    pattern: z.string().optional(),
+});
+export const permissionPolicySchema = z.object({
+    defaultAction: permissionDecisionActionSchema.optional(),
+    rules: z.array(permissionRuleSchema).readonly().optional(),
+    roleTrust: z.record(z.string(), z.string()).optional(),
+    safeCommands: z.array(z.string()).readonly().optional(),
+});
+export const rolesConfigSchema = z.object({
+    assignments: z.record(z.string(), roleAssignmentSchema),
+    customRoles: z.record(z.string(), customRoleDefinitionSchema).optional(),
+    permissionPolicy: permissionPolicySchema.optional(),
+});
+export const workflowConfigSchema = z.object({
+    name: z.string().min(1),
+    version: z.string().min(1),
+    globalTransitionLimit: z.number().min(1).optional(),
+});
+export const mergedConfigurationSchema = z.object({
+    workflow: workflowConfigSchema,
+    roles: rolesConfigSchema,
+    governance: governanceConfigSchema,
+    runtime: runtimeConfigSchema,
+});