@behavior-os/schemas 0.0.0-stage → 2.2.1

package/dist/index.d.ts

@@ -0,0 +1,1958 @@
+import { z } from 'zod';
+export declare const GovernanceActionSchema: z.ZodEnum<{
+    transform: "transform";
+    block: "block";
+    escalate: "escalate";
+    warn: "warn";
+    log: "log";
+}>;
+export declare const ConditionSchema: z.ZodObject<{
+    type: z.ZodString;
+    value: z.ZodUnknown;
+}, z.core.$strip>;
+export declare const GovernanceRuleSchema: z.ZodObject<{
+    id: z.ZodString;
+    level: z.ZodEnum<{
+        critical: "critical";
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>;
+    action: z.ZodEnum<{
+        transform: "transform";
+        block: "block";
+        escalate: "escalate";
+        warn: "warn";
+        log: "log";
+    }>;
+    conditions: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        value: z.ZodUnknown;
+    }, z.core.$strip>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const QualityGateSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        test_coverage: "test_coverage";
+        lint: "lint";
+        typecheck: "typecheck";
+        security: "security";
+        performance: "performance";
+        access_control: "access_control";
+    }>;
+    threshold: z.ZodNumber;
+    operator: z.ZodOptional<z.ZodEnum<{
+        gte: "gte";
+        lte: "lte";
+        eq: "eq";
+        neq: "neq";
+    }>>;
+}, z.core.$strip>;
+export declare const PersonaBoundarySchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        max_modules: "max_modules";
+        max_files: "max_files";
+        max_lines: "max_lines";
+        max_time: "max_time";
+        max_actions: "max_actions";
+    }>;
+    value: z.ZodNumber;
+}, z.core.$strip>;
+export declare const PersonaSchema: z.ZodObject<{
+    role: z.ZodString;
+    name: z.ZodString;
+    authority: z.ZodString;
+    boundaries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<{
+            max_modules: "max_modules";
+            max_files: "max_files";
+            max_lines: "max_lines";
+            max_time: "max_time";
+            max_actions: "max_actions";
+        }>;
+        value: z.ZodNumber;
+    }, z.core.$strip>>>;
+    skills: z.ZodArray<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const WorkflowStepSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    required: z.ZodDefault<z.ZodBoolean>;
+    approvalRequired: z.ZodDefault<z.ZodBoolean>;
+    timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const WorkflowSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    steps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        required: z.ZodDefault<z.ZodBoolean>;
+        approvalRequired: z.ZodDefault<z.ZodBoolean>;
+        timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * The type of a construction pipeline phase. These mirror the
+ * phases a human software-factory director would mandate.
+ */
+export declare const PipelinePhaseDefinitionTypeSchema: z.ZodEnum<{
+    architecture: "architecture";
+    planning: "planning";
+    dependencies: "dependencies";
+    frontend: "frontend";
+    backend: "backend";
+    integration: "integration";
+    testing: "testing";
+    deployment: "deployment";
+    documentation: "documentation";
+}>;
+/**
+ * A single gate within a construction pipeline phase.
+ * Gates are evaluated by the PipelineEngine and must pass
+ * before the phase (and subsequent phases) can proceed.
+ */
+export declare const ConstructionPipelineGateSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    phaseType: z.ZodEnum<{
+        architecture: "architecture";
+        planning: "planning";
+        dependencies: "dependencies";
+        frontend: "frontend";
+        backend: "backend";
+        integration: "integration";
+        testing: "testing";
+        deployment: "deployment";
+        documentation: "documentation";
+    }>;
+    blocking: z.ZodDefault<z.ZodBoolean>;
+    condition: z.ZodObject<{
+        type: z.ZodString;
+        value: z.ZodUnknown;
+        description: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * A phase definition within a construction pipeline. Each phase
+ * is associated with specific agent personas, skills to autoload,
+ * and gates to evaluate before proceeding.
+ */
+export declare const PipelinePhaseDefinitionSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    type: z.ZodEnum<{
+        architecture: "architecture";
+        planning: "planning";
+        dependencies: "dependencies";
+        frontend: "frontend";
+        backend: "backend";
+        integration: "integration";
+        testing: "testing";
+        deployment: "deployment";
+        documentation: "documentation";
+    }>;
+    requiredAgents: z.ZodArray<z.ZodString>;
+    requiredSkills: z.ZodArray<z.ZodString>;
+    gates: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        phaseType: z.ZodEnum<{
+            architecture: "architecture";
+            planning: "planning";
+            dependencies: "dependencies";
+            frontend: "frontend";
+            backend: "backend";
+            integration: "integration";
+            testing: "testing";
+            deployment: "deployment";
+            documentation: "documentation";
+        }>;
+        blocking: z.ZodDefault<z.ZodBoolean>;
+        condition: z.ZodObject<{
+            type: z.ZodString;
+            value: z.ZodUnknown;
+            description: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    order: z.ZodNumber;
+    blocking: z.ZodDefault<z.ZodBoolean>;
+    readinessArtifact: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * A named construction pipeline defined in a DNA pattern.
+ * The PipelinePlanner selects which pipeline to use based on
+ * the project context (web-app, API, mobile, etc.).
+ */
+export declare const ConstructionPipelineSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    phases: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        type: z.ZodEnum<{
+            architecture: "architecture";
+            planning: "planning";
+            dependencies: "dependencies";
+            frontend: "frontend";
+            backend: "backend";
+            integration: "integration";
+            testing: "testing";
+            deployment: "deployment";
+            documentation: "documentation";
+        }>;
+        requiredAgents: z.ZodArray<z.ZodString>;
+        requiredSkills: z.ZodArray<z.ZodString>;
+        gates: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            phaseType: z.ZodEnum<{
+                architecture: "architecture";
+                planning: "planning";
+                dependencies: "dependencies";
+                frontend: "frontend";
+                backend: "backend";
+                integration: "integration";
+                testing: "testing";
+                deployment: "deployment";
+                documentation: "documentation";
+            }>;
+            blocking: z.ZodDefault<z.ZodBoolean>;
+            condition: z.ZodObject<{
+                type: z.ZodString;
+                value: z.ZodUnknown;
+                description: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        order: z.ZodNumber;
+        blocking: z.ZodDefault<z.ZodBoolean>;
+        readinessArtifact: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    appliesTo: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const DNASchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodString;
+    personas: z.ZodArray<z.ZodObject<{
+        role: z.ZodString;
+        name: z.ZodString;
+        authority: z.ZodString;
+        boundaries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodEnum<{
+                max_modules: "max_modules";
+                max_files: "max_files";
+                max_lines: "max_lines";
+                max_time: "max_time";
+                max_actions: "max_actions";
+            }>;
+            value: z.ZodNumber;
+        }, z.core.$strip>>>;
+        skills: z.ZodArray<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    governance: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        level: z.ZodEnum<{
+            critical: "critical";
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>;
+        action: z.ZodEnum<{
+            transform: "transform";
+            block: "block";
+            escalate: "escalate";
+            warn: "warn";
+            log: "log";
+        }>;
+        conditions: z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            value: z.ZodUnknown;
+        }, z.core.$strip>>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    quality: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<{
+            test_coverage: "test_coverage";
+            lint: "lint";
+            typecheck: "typecheck";
+            security: "security";
+            performance: "performance";
+            access_control: "access_control";
+        }>;
+        threshold: z.ZodNumber;
+        operator: z.ZodOptional<z.ZodEnum<{
+            gte: "gte";
+            lte: "lte";
+            eq: "eq";
+            neq: "neq";
+        }>>;
+    }, z.core.$strip>>;
+    workflows: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        steps: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            required: z.ZodDefault<z.ZodBoolean>;
+            approvalRequired: z.ZodDefault<z.ZodBoolean>;
+            timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    pipelines: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        phases: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            type: z.ZodEnum<{
+                architecture: "architecture";
+                planning: "planning";
+                dependencies: "dependencies";
+                frontend: "frontend";
+                backend: "backend";
+                integration: "integration";
+                testing: "testing";
+                deployment: "deployment";
+                documentation: "documentation";
+            }>;
+            requiredAgents: z.ZodArray<z.ZodString>;
+            requiredSkills: z.ZodArray<z.ZodString>;
+            gates: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                phaseType: z.ZodEnum<{
+                    architecture: "architecture";
+                    planning: "planning";
+                    dependencies: "dependencies";
+                    frontend: "frontend";
+                    backend: "backend";
+                    integration: "integration";
+                    testing: "testing";
+                    deployment: "deployment";
+                    documentation: "documentation";
+                }>;
+                blocking: z.ZodDefault<z.ZodBoolean>;
+                condition: z.ZodObject<{
+                    type: z.ZodString;
+                    value: z.ZodUnknown;
+                    description: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+            order: z.ZodNumber;
+            blocking: z.ZodDefault<z.ZodBoolean>;
+            readinessArtifact: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        appliesTo: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const MissionTypeSchema: z.ZodEnum<{
+    audit: "audit";
+    deployment: "deployment";
+    feature: "feature";
+    bugfix: "bugfix";
+    research: "research";
+    refactor: "refactor";
+    incident: "incident";
+}>;
+export declare const MissionPrioritySchema: z.ZodEnum<{
+    critical: "critical";
+    high: "high";
+    medium: "medium";
+    low: "low";
+}>;
+export declare const MissionStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    active: "active";
+    paused: "paused";
+    completed: "completed";
+    failed: "failed";
+    cancelled: "cancelled";
+}>;
+/**
+ * Where evidence came from.
+ *
+ * - `executed` — a real command/adapter ran and produced this record.
+ * - `reported` — a caller or agent asserted the result without execution.
+ * - `simulated` — the check was simulated (never a verification).
+ */
+export declare const EvidenceProvenanceSchema: z.ZodEnum<{
+    executed: "executed";
+    reported: "reported";
+    simulated: "simulated";
+}>;
+/**
+ * Evidence attached to a mission transition. `simulated: true` marks a value
+ * produced without executing the check (for example a simulated audit); such
+ * evidence can be recorded but never authorizes completion of a required gate.
+ *
+ * `provenance` and `executionId` are what let a mission in
+ * `verificationMode: 'executed'` distinguish a real run from an assertion.
+ */
+export declare const MissionEvidenceSchema: z.ZodObject<{
+    gate: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        passed: "passed";
+        skipped: "skipped";
+    }>;
+    source: z.ZodString;
+    detail: z.ZodOptional<z.ZodString>;
+    simulated: z.ZodOptional<z.ZodBoolean>;
+    provenance: z.ZodOptional<z.ZodEnum<{
+        executed: "executed";
+        reported: "reported";
+        simulated: "simulated";
+    }>>;
+    executionId: z.ZodOptional<z.ZodString>;
+    taskId: z.ZodOptional<z.ZodString>;
+    tool: z.ZodOptional<z.ZodString>;
+    command: z.ZodOptional<z.ZodString>;
+    exitCode: z.ZodOptional<z.ZodNumber>;
+    recordedAt: z.ZodString;
+}, z.core.$strip>;
+/** One auditable entry in a mission's transition history. */
+export declare const MissionTransitionSchema: z.ZodObject<{
+    from: z.ZodEnum<{
+        pending: "pending";
+        active: "active";
+        paused: "paused";
+        completed: "completed";
+        failed: "failed";
+        cancelled: "cancelled";
+    }>;
+    to: z.ZodEnum<{
+        pending: "pending";
+        active: "active";
+        paused: "paused";
+        completed: "completed";
+        failed: "failed";
+        cancelled: "cancelled";
+    }>;
+    at: z.ZodString;
+    actor: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+    version: z.ZodNumber;
+}, z.core.$strip>;
+export declare const MissionSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    type: z.ZodEnum<{
+        audit: "audit";
+        deployment: "deployment";
+        feature: "feature";
+        bugfix: "bugfix";
+        research: "research";
+        refactor: "refactor";
+        incident: "incident";
+    }>;
+    priority: z.ZodEnum<{
+        critical: "critical";
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        active: "active";
+        paused: "paused";
+        completed: "completed";
+        failed: "failed";
+        cancelled: "cancelled";
+    }>;
+    dnaPattern: z.ZodString;
+    createdBy: z.ZodString;
+    assignedTo: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    progress: z.ZodDefault<z.ZodNumber>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    version: z.ZodOptional<z.ZodNumber>;
+    requiredChecks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    verificationMode: z.ZodOptional<z.ZodEnum<{
+        any: "any";
+        executed: "executed";
+    }>>;
+    evidence: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        gate: z.ZodString;
+        status: z.ZodEnum<{
+            failed: "failed";
+            passed: "passed";
+            skipped: "skipped";
+        }>;
+        source: z.ZodString;
+        detail: z.ZodOptional<z.ZodString>;
+        simulated: z.ZodOptional<z.ZodBoolean>;
+        provenance: z.ZodOptional<z.ZodEnum<{
+            executed: "executed";
+            reported: "reported";
+            simulated: "simulated";
+        }>>;
+        executionId: z.ZodOptional<z.ZodString>;
+        taskId: z.ZodOptional<z.ZodString>;
+        tool: z.ZodOptional<z.ZodString>;
+        command: z.ZodOptional<z.ZodString>;
+        exitCode: z.ZodOptional<z.ZodNumber>;
+        recordedAt: z.ZodString;
+    }, z.core.$strip>>>;
+    transitions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        from: z.ZodEnum<{
+            pending: "pending";
+            active: "active";
+            paused: "paused";
+            completed: "completed";
+            failed: "failed";
+            cancelled: "cancelled";
+        }>;
+        to: z.ZodEnum<{
+            pending: "pending";
+            active: "active";
+            paused: "paused";
+            completed: "completed";
+            failed: "failed";
+            cancelled: "cancelled";
+        }>;
+        at: z.ZodString;
+        actor: z.ZodString;
+        reason: z.ZodOptional<z.ZodString>;
+        version: z.ZodNumber;
+    }, z.core.$strip>>>;
+    completionBasis: z.ZodOptional<z.ZodEnum<{
+        evidence: "evidence";
+        "no-required-checks": "no-required-checks";
+    }>>;
+    lastTransitionReason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const TaskStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    completed: "completed";
+    failed: "failed";
+    cancelled: "cancelled";
+    dispatched: "dispatched";
+    running: "running";
+    blocked: "blocked";
+}>;
+export declare const TaskErrorCodeSchema: z.ZodEnum<{
+    INVALID_INPUT: "INVALID_INPUT";
+    INVALID_OUTPUT: "INVALID_OUTPUT";
+    AGENT_NOT_FOUND: "AGENT_NOT_FOUND";
+    ADAPTER_NOT_FOUND: "ADAPTER_NOT_FOUND";
+    DNA_NOT_FOUND: "DNA_NOT_FOUND";
+    GOVERNANCE_DENIED: "GOVERNANCE_DENIED";
+    APPROVAL_REQUIRED: "APPROVAL_REQUIRED";
+    TIMEOUT: "TIMEOUT";
+    CANCELLED: "CANCELLED";
+    RETRY_EXHAUSTED: "RETRY_EXHAUSTED";
+    LOOP_DETECTED: "LOOP_DETECTED";
+    CIRCUIT_OPEN: "CIRCUIT_OPEN";
+    DEPENDENCY_BLOCKED: "DEPENDENCY_BLOCKED";
+    ACCEPTANCE_FAILED: "ACCEPTANCE_FAILED";
+    EXECUTION_FAILED: "EXECUTION_FAILED";
+    PERSISTENCE_FAILED: "PERSISTENCE_FAILED";
+}>;
+/** One machine-checkable acceptance criterion for a task. */
+export declare const TaskAcceptanceSchema: z.ZodObject<{
+    gate: z.ZodString;
+    description: z.ZodString;
+    type: z.ZodEnum<{
+        "exit-code": "exit-code";
+        "stdout-contains": "stdout-contains";
+        "stdout-matches": "stdout-matches";
+        "stderr-not-contains": "stderr-not-contains";
+    }>;
+    expected: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const TaskCheckResultSchema: z.ZodObject<{
+    gate: z.ZodString;
+    type: z.ZodEnum<{
+        "exit-code": "exit-code";
+        "stdout-contains": "stdout-contains";
+        "stdout-matches": "stdout-matches";
+        "stderr-not-contains": "stderr-not-contains";
+    }>;
+    required: z.ZodBoolean;
+    passed: z.ZodBoolean;
+    detail: z.ZodString;
+}, z.core.$strip>;
+/** A dispatched, fully identified task. */
+export declare const TaskDefinitionSchema: z.ZodObject<{
+    id: z.ZodString;
+    missionId: z.ZodString;
+    parentTaskId: z.ZodOptional<z.ZodString>;
+    dependsOn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    correlationId: z.ZodString;
+    idempotencyKey: z.ZodString;
+    type: z.ZodString;
+    objective: z.ZodString;
+    input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    acceptance: z.ZodArray<z.ZodObject<{
+        gate: z.ZodString;
+        description: z.ZodString;
+        type: z.ZodEnum<{
+            "exit-code": "exit-code";
+            "stdout-contains": "stdout-contains";
+            "stdout-matches": "stdout-matches";
+            "stderr-not-contains": "stderr-not-contains";
+        }>;
+        expected: z.ZodOptional<z.ZodString>;
+        required: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    agentId: z.ZodString;
+    adapter: z.ZodString;
+    status: z.ZodEnum<{
+        pending: "pending";
+        completed: "completed";
+        failed: "failed";
+        cancelled: "cancelled";
+        dispatched: "dispatched";
+        running: "running";
+        blocked: "blocked";
+    }>;
+    attempts: z.ZodNumber;
+    maxAttempts: z.ZodNumber;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    deadline: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+/** Structured, classified task failure. */
+export declare const TaskErrorSchema: z.ZodObject<{
+    code: z.ZodEnum<{
+        INVALID_INPUT: "INVALID_INPUT";
+        INVALID_OUTPUT: "INVALID_OUTPUT";
+        AGENT_NOT_FOUND: "AGENT_NOT_FOUND";
+        ADAPTER_NOT_FOUND: "ADAPTER_NOT_FOUND";
+        DNA_NOT_FOUND: "DNA_NOT_FOUND";
+        GOVERNANCE_DENIED: "GOVERNANCE_DENIED";
+        APPROVAL_REQUIRED: "APPROVAL_REQUIRED";
+        TIMEOUT: "TIMEOUT";
+        CANCELLED: "CANCELLED";
+        RETRY_EXHAUSTED: "RETRY_EXHAUSTED";
+        LOOP_DETECTED: "LOOP_DETECTED";
+        CIRCUIT_OPEN: "CIRCUIT_OPEN";
+        DEPENDENCY_BLOCKED: "DEPENDENCY_BLOCKED";
+        ACCEPTANCE_FAILED: "ACCEPTANCE_FAILED";
+        EXECUTION_FAILED: "EXECUTION_FAILED";
+        PERSISTENCE_FAILED: "PERSISTENCE_FAILED";
+    }>;
+    message: z.ZodString;
+    retryable: z.ZodBoolean;
+    fingerprint: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * The raw result an execution adapter returns. It is **untrusted** until the
+ * orchestrator validates it with this schema.
+ */
+export declare const AdapterResultSchema: z.ZodObject<{
+    exitCode: z.ZodNullable<z.ZodNumber>;
+    stdout: z.ZodString;
+    stderr: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const TaskResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    missionId: z.ZodString;
+    status: z.ZodEnum<{
+        pending: "pending";
+        completed: "completed";
+        failed: "failed";
+        cancelled: "cancelled";
+        dispatched: "dispatched";
+        running: "running";
+        blocked: "blocked";
+    }>;
+    agentId: z.ZodString;
+    adapter: z.ZodString;
+    attempts: z.ZodNumber;
+    correlationId: z.ZodString;
+    idempotencyKey: z.ZodString;
+    startedAt: z.ZodOptional<z.ZodString>;
+    completedAt: z.ZodOptional<z.ZodString>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    exitCode: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    stdout: z.ZodOptional<z.ZodString>;
+    stderr: z.ZodOptional<z.ZodString>;
+    acceptance: z.ZodArray<z.ZodObject<{
+        gate: z.ZodString;
+        type: z.ZodEnum<{
+            "exit-code": "exit-code";
+            "stdout-contains": "stdout-contains";
+            "stdout-matches": "stdout-matches";
+            "stderr-not-contains": "stderr-not-contains";
+        }>;
+        required: z.ZodBoolean;
+        passed: z.ZodBoolean;
+        detail: z.ZodString;
+    }, z.core.$strip>>;
+    evidence: z.ZodArray<z.ZodObject<{
+        gate: z.ZodString;
+        status: z.ZodEnum<{
+            failed: "failed";
+            passed: "passed";
+            skipped: "skipped";
+        }>;
+        source: z.ZodString;
+        detail: z.ZodOptional<z.ZodString>;
+        simulated: z.ZodOptional<z.ZodBoolean>;
+        provenance: z.ZodOptional<z.ZodEnum<{
+            executed: "executed";
+            reported: "reported";
+            simulated: "simulated";
+        }>>;
+        executionId: z.ZodOptional<z.ZodString>;
+        taskId: z.ZodOptional<z.ZodString>;
+        tool: z.ZodOptional<z.ZodString>;
+        command: z.ZodOptional<z.ZodString>;
+        exitCode: z.ZodOptional<z.ZodNumber>;
+        recordedAt: z.ZodString;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodEnum<{
+            INVALID_INPUT: "INVALID_INPUT";
+            INVALID_OUTPUT: "INVALID_OUTPUT";
+            AGENT_NOT_FOUND: "AGENT_NOT_FOUND";
+            ADAPTER_NOT_FOUND: "ADAPTER_NOT_FOUND";
+            DNA_NOT_FOUND: "DNA_NOT_FOUND";
+            GOVERNANCE_DENIED: "GOVERNANCE_DENIED";
+            APPROVAL_REQUIRED: "APPROVAL_REQUIRED";
+            TIMEOUT: "TIMEOUT";
+            CANCELLED: "CANCELLED";
+            RETRY_EXHAUSTED: "RETRY_EXHAUSTED";
+            LOOP_DETECTED: "LOOP_DETECTED";
+            CIRCUIT_OPEN: "CIRCUIT_OPEN";
+            DEPENDENCY_BLOCKED: "DEPENDENCY_BLOCKED";
+            ACCEPTANCE_FAILED: "ACCEPTANCE_FAILED";
+            EXECUTION_FAILED: "EXECUTION_FAILED";
+            PERSISTENCE_FAILED: "PERSISTENCE_FAILED";
+        }>;
+        message: z.ZodString;
+        retryable: z.ZodBoolean;
+        fingerprint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const TaskEventTypeSchema: z.ZodEnum<{
+    "mission.created": "mission.created";
+    "mission.completed": "mission.completed";
+    "mission.failed": "mission.failed";
+    "mission.cancelled": "mission.cancelled";
+    "mission.blocked": "mission.blocked";
+    "task.created": "task.created";
+    "task.dispatched": "task.dispatched";
+    "task.started": "task.started";
+    "task.retried": "task.retried";
+    "task.completed": "task.completed";
+    "task.failed": "task.failed";
+    "task.cancelled": "task.cancelled";
+    "task.blocked": "task.blocked";
+}>;
+/** Correlated lifecycle event. Payloads never contain stdout/stderr or env. */
+export declare const TaskEventSchema: z.ZodObject<{
+    seq: z.ZodNumber;
+    type: z.ZodEnum<{
+        "mission.created": "mission.created";
+        "mission.completed": "mission.completed";
+        "mission.failed": "mission.failed";
+        "mission.cancelled": "mission.cancelled";
+        "mission.blocked": "mission.blocked";
+        "task.created": "task.created";
+        "task.dispatched": "task.dispatched";
+        "task.started": "task.started";
+        "task.retried": "task.retried";
+        "task.completed": "task.completed";
+        "task.failed": "task.failed";
+        "task.cancelled": "task.cancelled";
+        "task.blocked": "task.blocked";
+    }>;
+    missionId: z.ZodString;
+    taskId: z.ZodOptional<z.ZodString>;
+    correlationId: z.ZodString;
+    at: z.ZodString;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const AgentTypeSchema: z.ZodEnum<{
+    operator: "operator";
+    orchestrator: "orchestrator";
+    developer: "developer";
+    architect: "architect";
+    reviewer: "reviewer";
+    analyst: "analyst";
+}>;
+export declare const AgentStatusSchema: z.ZodEnum<{
+    error: "error";
+    idle: "idle";
+    busy: "busy";
+    offline: "offline";
+}>;
+export declare const AgentSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        operator: "operator";
+        orchestrator: "orchestrator";
+        developer: "developer";
+        architect: "architect";
+        reviewer: "reviewer";
+        analyst: "analyst";
+    }>;
+    status: z.ZodEnum<{
+        error: "error";
+        idle: "idle";
+        busy: "busy";
+        offline: "offline";
+    }>;
+    dnaPattern: z.ZodString;
+    capabilities: z.ZodArray<z.ZodString>;
+    currentMission: z.ZodNullable<z.ZodString>;
+    metrics: z.ZodObject<{
+        tasksCompleted: z.ZodNumber;
+        tasksFailed: z.ZodNumber;
+        avgResponseTime: z.ZodNumber;
+        governanceViolations: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const GovernanceVerdictSchema: z.ZodEnum<{
+    transform: "transform";
+    escalate: "escalate";
+    allow: "allow";
+    deny: "deny";
+}>;
+export declare const GovernanceDecisionSchema: z.ZodObject<{
+    id: z.ZodString;
+    action: z.ZodString;
+    verdict: z.ZodEnum<{
+        transform: "transform";
+        escalate: "escalate";
+        allow: "allow";
+        deny: "deny";
+    }>;
+    reason: z.ZodString;
+    rulesEvaluated: z.ZodArray<z.ZodString>;
+    firedRules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    timestamp: z.ZodString;
+    agentId: z.ZodString;
+    missionId: z.ZodOptional<z.ZodString>;
+    transformed: z.ZodOptional<z.ZodBoolean>;
+    warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const AuditStageSchema: z.ZodEnum<{
+    lint: "lint";
+    typecheck: "typecheck";
+    security: "security";
+    performance: "performance";
+    governance: "governance";
+    coverage: "coverage";
+}>;
+export declare const AuditResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    stage: z.ZodEnum<{
+        lint: "lint";
+        typecheck: "typecheck";
+        security: "security";
+        performance: "performance";
+        governance: "governance";
+        coverage: "coverage";
+    }>;
+    status: z.ZodEnum<{
+        failed: "failed";
+        passed: "passed";
+        skipped: "skipped";
+        warning: "warning";
+    }>;
+    details: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export declare const AuditReportSchema: z.ZodObject<{
+    id: z.ZodString;
+    missionId: z.ZodString;
+    agentId: z.ZodString;
+    dnaPattern: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    persona: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    stages: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        stage: z.ZodEnum<{
+            lint: "lint";
+            typecheck: "typecheck";
+            security: "security";
+            performance: "performance";
+            governance: "governance";
+            coverage: "coverage";
+        }>;
+        status: z.ZodEnum<{
+            failed: "failed";
+            passed: "passed";
+            skipped: "skipped";
+            warning: "warning";
+        }>;
+        details: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        timestamp: z.ZodString;
+    }, z.core.$strip>>;
+    overall: z.ZodEnum<{
+        warning: "warning";
+        pass: "pass";
+        fail: "fail";
+    }>;
+    summary: z.ZodString;
+    timestamp: z.ZodString;
+    simulated: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/** Whether a gate runs before (pre) or after (post) an action executes. */
+export declare const PipelinePhaseSchema: z.ZodEnum<{
+    pre: "pre";
+    post: "post";
+}>;
+export declare const GateStatusSchema: z.ZodEnum<{
+    failed: "failed";
+    passed: "passed";
+    skipped: "skipped";
+    warning: "warning";
+}>;
+export declare const GateResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    phase: z.ZodEnum<{
+        pre: "pre";
+        post: "post";
+    }>;
+    blocking: z.ZodBoolean;
+    status: z.ZodEnum<{
+        failed: "failed";
+        passed: "passed";
+        skipped: "skipped";
+        warning: "warning";
+    }>;
+    details: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    durationMs: z.ZodNumber;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export declare const PipelineRunSchema: z.ZodObject<{
+    id: z.ZodString;
+    overall: z.ZodEnum<{
+        warning: "warning";
+        pass: "pass";
+        fail: "fail";
+    }>;
+    blocked: z.ZodBoolean;
+    blockedBy: z.ZodOptional<z.ZodString>;
+    phases: z.ZodArray<z.ZodEnum<{
+        pre: "pre";
+        post: "post";
+    }>>;
+    gates: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        phase: z.ZodEnum<{
+            pre: "pre";
+            post: "post";
+        }>;
+        blocking: z.ZodBoolean;
+        status: z.ZodEnum<{
+            failed: "failed";
+            passed: "passed";
+            skipped: "skipped";
+            warning: "warning";
+        }>;
+        details: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        durationMs: z.ZodNumber;
+        timestamp: z.ZodString;
+    }, z.core.$strip>>;
+    durationMs: z.ZodNumber;
+    timestamp: z.ZodString;
+    missionId: z.ZodOptional<z.ZodString>;
+    agentId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const VoteChoiceSchema: z.ZodEnum<{
+    approve: "approve";
+    reject: "reject";
+    abstain: "abstain";
+}>;
+export declare const VoteSchema: z.ZodObject<{
+    voterId: z.ZodString;
+    choice: z.ZodEnum<{
+        approve: "approve";
+        reject: "reject";
+        abstain: "abstain";
+    }>;
+    weight: z.ZodOptional<z.ZodNumber>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const DecisionPolicySchema: z.ZodEnum<{
+    majority: "majority";
+    supermajority: "supermajority";
+    unanimous: "unanimous";
+}>;
+export declare const DecisionOutcomeSchema: z.ZodEnum<{
+    approved: "approved";
+    rejected: "rejected";
+    no_quorum: "no_quorum";
+}>;
+export declare const DecisionSchema: z.ZodObject<{
+    id: z.ZodString;
+    subject: z.ZodString;
+    policy: z.ZodEnum<{
+        majority: "majority";
+        supermajority: "supermajority";
+        unanimous: "unanimous";
+    }>;
+    outcome: z.ZodEnum<{
+        approved: "approved";
+        rejected: "rejected";
+        no_quorum: "no_quorum";
+    }>;
+    quorum: z.ZodNumber;
+    quorumMet: z.ZodBoolean;
+    approve: z.ZodNumber;
+    reject: z.ZodNumber;
+    abstain: z.ZodNumber;
+    participatingWeight: z.ZodNumber;
+    votes: z.ZodArray<z.ZodObject<{
+        voterId: z.ZodString;
+        choice: z.ZodEnum<{
+            approve: "approve";
+            reject: "reject";
+            abstain: "abstain";
+        }>;
+        weight: z.ZodOptional<z.ZodNumber>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    decidedBy: z.ZodArray<z.ZodString>;
+    reasons: z.ZodArray<z.ZodString>;
+    timestamp: z.ZodString;
+    missionId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ConsensusPolicySchema: z.ZodEnum<{
+    majority: "majority";
+    supermajority: "supermajority";
+    unanimous: "unanimous";
+}>;
+export declare const ConsensusVoteSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    weight: z.ZodOptional<z.ZodNumber>;
+    choice: z.ZodEnum<{
+        approve: "approve";
+        reject: "reject";
+        abstain: "abstain";
+    }>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ConsensusTallySchema: z.ZodObject<{
+    approveWeight: z.ZodNumber;
+    rejectWeight: z.ZodNumber;
+    abstainWeight: z.ZodNumber;
+    totalParticipating: z.ZodNumber;
+    approveRatio: z.ZodNumber;
+    rejectRatio: z.ZodNumber;
+}, z.core.$strip>;
+export declare const ConsensusOutcomeSchema: z.ZodEnum<{
+    approved: "approved";
+    rejected: "rejected";
+    inconclusive: "inconclusive";
+}>;
+export declare const ConsensusRoundSchema: z.ZodObject<{
+    id: z.ZodString;
+    subject: z.ZodString;
+    policy: z.ZodEnum<{
+        majority: "majority";
+        supermajority: "supermajority";
+        unanimous: "unanimous";
+    }>;
+    quorum: z.ZodNumber;
+    votes: z.ZodArray<z.ZodObject<{
+        agentId: z.ZodString;
+        weight: z.ZodOptional<z.ZodNumber>;
+        choice: z.ZodEnum<{
+            approve: "approve";
+            reject: "reject";
+            abstain: "abstain";
+        }>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    tally: z.ZodObject<{
+        approveWeight: z.ZodNumber;
+        rejectWeight: z.ZodNumber;
+        abstainWeight: z.ZodNumber;
+        totalParticipating: z.ZodNumber;
+        approveRatio: z.ZodNumber;
+        rejectRatio: z.ZodNumber;
+    }, z.core.$strip>;
+    outcome: z.ZodEnum<{
+        approved: "approved";
+        rejected: "rejected";
+        inconclusive: "inconclusive";
+    }>;
+    reason: z.ZodString;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export declare const PredictionTypeSchema: z.ZodEnum<{
+    "governance-block": "governance-block";
+    "mission-failure": "mission-failure";
+    "quality-fall": "quality-fall";
+    "drift-significant": "drift-significant";
+    "pattern-repeated": "pattern-repeated";
+}>;
+export declare const PredictionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        "governance-block": "governance-block";
+        "mission-failure": "mission-failure";
+        "quality-fall": "quality-fall";
+        "drift-significant": "drift-significant";
+        "pattern-repeated": "pattern-repeated";
+    }>;
+    subject: z.ZodString;
+    confidence: z.ZodNumber;
+    horizonHours: z.ZodNumber;
+    evidence: z.ZodArray<z.ZodString>;
+    recommendation: z.ZodString;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export declare const EvolutionProposalSchema: z.ZodObject<{
+    id: z.ZodString;
+    dnaName: z.ZodString;
+    changeType: z.ZodEnum<{
+        "add-warn": "add-warn";
+        "relax-block": "relax-block";
+        "add-block": "add-block";
+    }>;
+    kind: z.ZodEnum<{
+        "governance-warn": "governance-warn";
+    }>;
+    pattern: z.ZodString;
+    condition: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        value: z.ZodUnknown;
+    }, z.core.$strip>>;
+    ruleId: z.ZodString;
+    description: z.ZodString;
+    confidence: z.ZodNumber;
+    occurrences: z.ZodNumber;
+    evidence: z.ZodArray<z.ZodString>;
+    timestamp: z.ZodString;
+    requiresVote: z.ZodDefault<z.ZodBoolean>;
+    voteThreshold: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const CodeFixProposalSchema: z.ZodObject<{
+    id: z.ZodString;
+    pattern: z.ZodString;
+    confidence: z.ZodNumber;
+    occurrences: z.ZodNumber;
+    suggestion: z.ZodString;
+    evidence: z.ZodArray<z.ZodString>;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export declare const LearningTypeSchema: z.ZodEnum<{
+    pattern: "pattern";
+    insight: "insight";
+    fix: "fix";
+    failure: "failure";
+    optimization: "optimization";
+}>;
+export declare const LearningImpactSchema: z.ZodEnum<{
+    critical: "critical";
+    high: "high";
+    medium: "medium";
+    low: "low";
+}>;
+export declare const LearningEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        pattern: "pattern";
+        insight: "insight";
+        fix: "fix";
+        failure: "failure";
+        optimization: "optimization";
+    }>;
+    source: z.ZodString;
+    content: z.ZodString;
+    impact: z.ZodEnum<{
+        critical: "critical";
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>;
+    relatedMission: z.ZodOptional<z.ZodString>;
+    relatedPattern: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/**
+ * Lifecycle of a governed learning:
+ * `observation -> lesson -> candidate -> validated -> policy -> monitored`.
+ * Each record moves exactly one stage forward and keeps an auditable trail of
+ * transitions; `validated` (and every later stage) requires evidence.
+ */
+export declare const LearningStageSchema: z.ZodEnum<{
+    policy: "policy";
+    observation: "observation";
+    lesson: "lesson";
+    candidate: "candidate";
+    validated: "validated";
+    monitored: "monitored";
+}>;
+export declare const LearningTransitionSchema: z.ZodObject<{
+    from: z.ZodEnum<{
+        policy: "policy";
+        observation: "observation";
+        lesson: "lesson";
+        candidate: "candidate";
+        validated: "validated";
+        monitored: "monitored";
+    }>;
+    to: z.ZodEnum<{
+        policy: "policy";
+        observation: "observation";
+        lesson: "lesson";
+        candidate: "candidate";
+        validated: "validated";
+        monitored: "monitored";
+    }>;
+    at: z.ZodString;
+    actor: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const LearningRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    stage: z.ZodEnum<{
+        policy: "policy";
+        observation: "observation";
+        lesson: "lesson";
+        candidate: "candidate";
+        validated: "validated";
+        monitored: "monitored";
+    }>;
+    title: z.ZodString;
+    content: z.ZodString;
+    source: z.ZodString;
+    impact: z.ZodEnum<{
+        critical: "critical";
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>;
+    evidence: z.ZodArray<z.ZodString>;
+    transitions: z.ZodArray<z.ZodObject<{
+        from: z.ZodEnum<{
+            policy: "policy";
+            observation: "observation";
+            lesson: "lesson";
+            candidate: "candidate";
+            validated: "validated";
+            monitored: "monitored";
+        }>;
+        to: z.ZodEnum<{
+            policy: "policy";
+            observation: "observation";
+            lesson: "lesson";
+            candidate: "candidate";
+            validated: "validated";
+            monitored: "monitored";
+        }>;
+        at: z.ZodString;
+        actor: z.ZodString;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    relatedMission: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export declare const ProtocolStepSchema: z.ZodObject<{
+    number: z.ZodNumber;
+    name: z.ZodString;
+    description: z.ZodString;
+    tool: z.ZodString;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const AgentStateSchema: z.ZodObject<{
+    currentStep: z.ZodDefault<z.ZodNumber>;
+    selectedDna: z.ZodNullable<z.ZodString>;
+    agentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    persona: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    activeMission: z.ZodNullable<z.ZodString>;
+    stepHistory: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export declare const McpToolSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const McpResourceSchema: z.ZodObject<{
+    uri: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    mimeType: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type GovernanceAction = z.infer<typeof GovernanceActionSchema>;
+export type Condition = z.infer<typeof ConditionSchema>;
+export type GovernanceRule = z.infer<typeof GovernanceRuleSchema>;
+export type QualityGate = z.infer<typeof QualityGateSchema>;
+export type PersonaBoundary = z.infer<typeof PersonaBoundarySchema>;
+export type Persona = z.infer<typeof PersonaSchema>;
+export type WorkflowStep = z.infer<typeof WorkflowStepSchema>;
+export type Workflow = z.infer<typeof WorkflowSchema>;
+export type DNA = z.infer<typeof DNASchema>;
+export type MissionType = z.infer<typeof MissionTypeSchema>;
+export type MissionPriority = z.infer<typeof MissionPrioritySchema>;
+export type MissionStatus = z.infer<typeof MissionStatusSchema>;
+export type Mission = z.infer<typeof MissionSchema>;
+export type MissionEvidence = z.infer<typeof MissionEvidenceSchema>;
+export type MissionTransition = z.infer<typeof MissionTransitionSchema>;
+export type EvidenceProvenance = z.infer<typeof EvidenceProvenanceSchema>;
+export type TaskStatus = z.infer<typeof TaskStatusSchema>;
+export type TaskErrorCode = z.infer<typeof TaskErrorCodeSchema>;
+export type TaskAcceptance = z.infer<typeof TaskAcceptanceSchema>;
+export type TaskCheckResult = z.infer<typeof TaskCheckResultSchema>;
+export type TaskDefinition = z.infer<typeof TaskDefinitionSchema>;
+export type TaskError = z.infer<typeof TaskErrorSchema>;
+export type AdapterResult = z.infer<typeof AdapterResultSchema>;
+export type TaskResult = z.infer<typeof TaskResultSchema>;
+export type TaskEventType = z.infer<typeof TaskEventTypeSchema>;
+export type TaskEvent = z.infer<typeof TaskEventSchema>;
+export type AgentType = z.infer<typeof AgentTypeSchema>;
+export type AgentStatus = z.infer<typeof AgentStatusSchema>;
+export type Agent = z.infer<typeof AgentSchema>;
+export type PipelinePhaseDefinitionType = z.infer<typeof PipelinePhaseDefinitionTypeSchema>;
+export type ConstructionPipelineGate = z.infer<typeof ConstructionPipelineGateSchema>;
+export type PipelinePhaseDefinition = z.infer<typeof PipelinePhaseDefinitionSchema>;
+export type ConstructionPipeline = z.infer<typeof ConstructionPipelineSchema>;
+export type GovernanceVerdict = z.infer<typeof GovernanceVerdictSchema>;
+export type GovernanceDecision = z.infer<typeof GovernanceDecisionSchema> & {
+    warnings?: string[];
+};
+export type AuditStage = z.infer<typeof AuditStageSchema>;
+export type AuditResult = z.infer<typeof AuditResultSchema>;
+export type AuditReport = z.infer<typeof AuditReportSchema>;
+export type PipelinePhase = z.infer<typeof PipelinePhaseSchema>;
+export type GateStatus = z.infer<typeof GateStatusSchema>;
+export type GateResult = z.infer<typeof GateResultSchema>;
+export type PipelineRun = z.infer<typeof PipelineRunSchema>;
+export type VoteChoice = z.infer<typeof VoteChoiceSchema>;
+export type Vote = z.infer<typeof VoteSchema>;
+export type DecisionPolicy = z.infer<typeof DecisionPolicySchema>;
+export type DecisionOutcome = z.infer<typeof DecisionOutcomeSchema>;
+export type Decision = z.infer<typeof DecisionSchema>;
+export type EvolutionProposal = z.infer<typeof EvolutionProposalSchema>;
+export type CodeFixProposal = z.infer<typeof CodeFixProposalSchema>;
+export declare const CodeFixResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    proposalId: z.ZodString;
+    pattern: z.ZodString;
+    confidence: z.ZodNumber;
+    applied: z.ZodBoolean;
+    voteOutcome: z.ZodOptional<z.ZodEnum<{
+        approved: "approved";
+        rejected: "rejected";
+        no_quorum: "no_quorum";
+    }>>;
+    voteTally: z.ZodOptional<z.ZodObject<{
+        approve: z.ZodNumber;
+        reject: z.ZodNumber;
+        abstain: z.ZodNumber;
+    }, z.core.$strip>>;
+    timestamp: z.ZodString;
+    missionId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CodeFixResult = z.infer<typeof CodeFixResultSchema>;
+/**
+ * A governed, persisted code-edit record.
+ *
+ * Every evaluated edit is recorded — including dry-runs and refusals — so the
+ * history of rejected proposals is versioned, not just the applied ones.
+ */
+export declare const CodeEditRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    file: z.ZodString;
+    beforeHash: z.ZodString;
+    afterHash: z.ZodString;
+    bytesBefore: z.ZodNumber;
+    bytesAfter: z.ZodNumber;
+    addedLines: z.ZodNumber;
+    removedLines: z.ZodNumber;
+    occurrences: z.ZodNumber;
+    applied: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+    agentId: z.ZodString;
+    dnaPattern: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    voteOutcome: z.ZodOptional<z.ZodEnum<{
+        approved: "approved";
+        rejected: "rejected";
+        no_quorum: "no_quorum";
+    }>>;
+    voteTally: z.ZodOptional<z.ZodObject<{
+        approve: z.ZodNumber;
+        reject: z.ZodNumber;
+        abstain: z.ZodNumber;
+    }, z.core.$strip>>;
+    missionId: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export type CodeEditRecord = z.infer<typeof CodeEditRecordSchema>;
+export declare const RankedRecommendationSchema: z.ZodObject<{
+    id: z.ZodString;
+    text: z.ZodString;
+    score: z.ZodNumber;
+    evidence: z.ZodArray<z.ZodString>;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export type RankedRecommendation = z.infer<typeof RankedRecommendationSchema>;
+export declare const DriftInfoSchema: z.ZodObject<{
+    id: z.ZodString;
+    newerName: z.ZodString;
+    olderName: z.ZodString;
+    rulesAdded: z.ZodNumber;
+    rulesRemoved: z.ZodNumber;
+    rulesChanged: z.ZodArray<z.ZodString>;
+    gatesAdded: z.ZodNumber;
+    gatesRemoved: z.ZodNumber;
+    gatesChanged: z.ZodArray<z.ZodString>;
+    totalChanges: z.ZodNumber;
+    significant: z.ZodBoolean;
+    summary: z.ZodString;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export type DriftInfo = z.infer<typeof DriftInfoSchema>;
+export type ConsensusPolicy = z.infer<typeof ConsensusPolicySchema>;
+export type ConsensusVote = z.infer<typeof ConsensusVoteSchema>;
+export type ConsensusTally = z.infer<typeof ConsensusTallySchema>;
+export type ConsensusOutcome = z.infer<typeof ConsensusOutcomeSchema>;
+export type ConsensusRound = z.infer<typeof ConsensusRoundSchema>;
+export type PredictionType = z.infer<typeof PredictionTypeSchema>;
+export type Prediction = z.infer<typeof PredictionSchema>;
+export type LearningType = z.infer<typeof LearningTypeSchema>;
+export type LearningImpact = z.infer<typeof LearningImpactSchema>;
+export type LearningEvent = z.infer<typeof LearningEventSchema>;
+export type LearningStage = z.infer<typeof LearningStageSchema>;
+export type LearningTransition = z.infer<typeof LearningTransitionSchema>;
+export type LearningRecord = z.infer<typeof LearningRecordSchema>;
+export type ProtocolStep = z.infer<typeof ProtocolStepSchema>;
+export type AgentState = z.infer<typeof AgentStateSchema>;
+export type McpTool = z.infer<typeof McpToolSchema>;
+export type McpResource = z.infer<typeof McpResourceSchema>;
+export declare const AntiPatternTypeSchema: z.ZodEnum<{
+    "typescript-error": "typescript-error";
+    "lint-violation": "lint-violation";
+    "security-vulnerability": "security-vulnerability";
+    "performance-issue": "performance-issue";
+    "architecture-violation": "architecture-violation";
+    "code-smell": "code-smell";
+    "test-gap": "test-gap";
+    "documentation-gap": "documentation-gap";
+    "governance-bypass": "governance-bypass";
+    "pattern-debt": "pattern-debt";
+}>;
+export declare const SeveritySchema: z.ZodEnum<{
+    critical: "critical";
+    high: "high";
+    medium: "medium";
+    low: "low";
+    info: "info";
+}>;
+export declare const AntiPatternSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        "typescript-error": "typescript-error";
+        "lint-violation": "lint-violation";
+        "security-vulnerability": "security-vulnerability";
+        "performance-issue": "performance-issue";
+        "architecture-violation": "architecture-violation";
+        "code-smell": "code-smell";
+        "test-gap": "test-gap";
+        "documentation-gap": "documentation-gap";
+        "governance-bypass": "governance-bypass";
+        "pattern-debt": "pattern-debt";
+    }>;
+    severity: z.ZodEnum<{
+        critical: "critical";
+        high: "high";
+        medium: "medium";
+        low: "low";
+        info: "info";
+    }>;
+    pattern: z.ZodString;
+    description: z.ZodString;
+    location: z.ZodOptional<z.ZodString>;
+    file: z.ZodOptional<z.ZodString>;
+    line: z.ZodOptional<z.ZodNumber>;
+    evidence: z.ZodArray<z.ZodString>;
+    recommendation: z.ZodString;
+    detectedAt: z.ZodString;
+    resolved: z.ZodDefault<z.ZodBoolean>;
+    resolvedAt: z.ZodOptional<z.ZodString>;
+    resolvedBy: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ConversationTurnSchema: z.ZodObject<{
+    id: z.ZodString;
+    agentId: z.ZodString;
+    role: z.ZodEnum<{
+        agent: "agent";
+        system: "system";
+        user: "user";
+        expert: "expert";
+    }>;
+    content: z.ZodString;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export declare const PragmaticConversationSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    problem: z.ZodString;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        resolved: "resolved";
+        open: "open";
+        "in-progress": "in-progress";
+        closed: "closed";
+    }>;
+    participants: z.ZodArray<z.ZodString>;
+    turns: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        agentId: z.ZodString;
+        role: z.ZodEnum<{
+            agent: "agent";
+            system: "system";
+            user: "user";
+            expert: "expert";
+        }>;
+        content: z.ZodString;
+        timestamp: z.ZodString;
+    }, z.core.$strip>>;
+    antiPatterns: z.ZodArray<z.ZodString>;
+    solution: z.ZodOptional<z.ZodString>;
+    resolvedBy: z.ZodOptional<z.ZodString>;
+    lessonsLearned: z.ZodArray<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export declare const PolicyRuleSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    condition: z.ZodString;
+    action: z.ZodEnum<{
+        block: "block";
+        warn: "warn";
+        require: "require";
+        "auto-fix": "auto-fix";
+    }>;
+    severity: z.ZodEnum<{
+        critical: "critical";
+        high: "high";
+        medium: "medium";
+        low: "low";
+        info: "info";
+    }>;
+    appliesTo: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        agent: "agent";
+        role: "role";
+        persona: "persona";
+        project: "project";
+    }>>>;
+    effectiveFrom: z.ZodString;
+    effectiveUntil: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const RoleSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    displayName: z.ZodString;
+    responsibilities: z.ZodArray<z.ZodString>;
+    policies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    canAudit: z.ZodDefault<z.ZodBoolean>;
+    canEnforce: z.ZodDefault<z.ZodBoolean>;
+    canTeach: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type AntiPatternType = z.infer<typeof AntiPatternTypeSchema>;
+export type Severity = z.infer<typeof SeveritySchema>;
+export type AntiPattern = z.infer<typeof AntiPatternSchema>;
+export type ConversationTurn = z.infer<typeof ConversationTurnSchema>;
+export type PragmaticConversation = z.infer<typeof PragmaticConversationSchema>;
+export type PolicyRule = z.infer<typeof PolicyRuleSchema>;
+export type Role = z.infer<typeof RoleSchema>;
+export * from './knowledge-graph.js';
+export declare const BehaviorProfileSchema: z.ZodObject<{
+    actionRate: z.ZodNumber;
+    denialRate: z.ZodNumber;
+    escalationRate: z.ZodNumber;
+    toolDiversity: z.ZodNumber;
+    offHoursRatio: z.ZodNumber;
+}, z.core.$strip>;
+export declare const AnomalyScoreSchema: z.ZodObject<{
+    id: z.ZodString;
+    agentId: z.ZodString;
+    baseline: z.ZodObject<{
+        actionRate: z.ZodNumber;
+        denialRate: z.ZodNumber;
+        escalationRate: z.ZodNumber;
+        toolDiversity: z.ZodNumber;
+        offHoursRatio: z.ZodNumber;
+    }, z.core.$strip>;
+    current: z.ZodObject<{
+        actionRate: z.ZodNumber;
+        denialRate: z.ZodNumber;
+        escalationRate: z.ZodNumber;
+        toolDiversity: z.ZodNumber;
+        offHoursRatio: z.ZodNumber;
+    }, z.core.$strip>;
+    deviation: z.ZodNumber;
+    explanation: z.ZodString;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export declare const ExperiencePhaseSchema: z.ZodEnum<{
+    execute: "execute";
+    observe: "observe";
+    reflect: "reflect";
+    abstract: "abstract";
+    apply: "apply";
+}>;
+export declare const ExperienceRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    agentId: z.ZodString;
+    action: z.ZodString;
+    outcome: z.ZodEnum<{
+        success: "success";
+        failure: "failure";
+        partial: "partial";
+    }>;
+    observation: z.ZodString;
+    reflection: z.ZodString;
+    abstraction: z.ZodString;
+    application: z.ZodString;
+    phase: z.ZodEnum<{
+        execute: "execute";
+        observe: "observe";
+        reflect: "reflect";
+        abstract: "abstract";
+        apply: "apply";
+    }>;
+    confidence: z.ZodNumber;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export declare const ComplianceStatusSchema: z.ZodEnum<{
+    compliant: "compliant";
+    "at-risk": "at-risk";
+    violation: "violation";
+}>;
+export declare const ComplianceMapSchema: z.ZodObject<{
+    id: z.ZodString;
+    regulation: z.ZodString;
+    rules: z.ZodArray<z.ZodString>;
+    evidence: z.ZodArray<z.ZodString>;
+    lastAudit: z.ZodString;
+    status: z.ZodEnum<{
+        compliant: "compliant";
+        "at-risk": "at-risk";
+        violation: "violation";
+    }>;
+    score: z.ZodNumber;
+}, z.core.$strip>;
+export type BehaviorProfile = z.infer<typeof BehaviorProfileSchema>;
+export type AnomalyScore = z.infer<typeof AnomalyScoreSchema>;
+export type ExperiencePhase = z.infer<typeof ExperiencePhaseSchema>;
+export type ExperienceRecord = z.infer<typeof ExperienceRecordSchema>;
+export type ComplianceStatus = z.infer<typeof ComplianceStatusSchema>;
+export type ComplianceMap = z.infer<typeof ComplianceMapSchema>;
+export declare const HybridEvaluationSchema: z.ZodObject<{
+    id: z.ZodString;
+    symbolicVerdict: z.ZodEnum<{
+        escalate: "escalate";
+        warn: "warn";
+        allow: "allow";
+        deny: "deny";
+    }>;
+    neuralConfidence: z.ZodNumber;
+    hybridVerdict: z.ZodEnum<{
+        escalate: "escalate";
+        warn: "warn";
+        allow: "allow";
+        deny: "deny";
+    }>;
+    diverged: z.ZodBoolean;
+    explanation: z.ZodString;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export declare const AgentIdentitySchema: z.ZodObject<{
+    agentId: z.ZodString;
+    did: z.ZodString;
+    publicKeyHash: z.ZodString;
+    capabilities: z.ZodArray<z.ZodString>;
+    issuedAt: z.ZodString;
+    expiresAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const IdentityVerificationResultSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    did: z.ZodString;
+    valid: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+    verifiedAt: z.ZodString;
+}, z.core.$strip>;
+export declare const RiskLevelSchema: z.ZodEnum<{
+    critical: "critical";
+    high: "high";
+    medium: "medium";
+    low: "low";
+}>;
+export declare const RiskAssessmentSchema: z.ZodObject<{
+    id: z.ZodString;
+    agentId: z.ZodString;
+    level: z.ZodEnum<{
+        critical: "critical";
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>;
+    score: z.ZodNumber;
+    factors: z.ZodArray<z.ZodString>;
+    adjustedThresholds: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export declare const DynamicPolicySchema: z.ZodObject<{
+    id: z.ZodString;
+    agentId: z.ZodString;
+    baseRuleIds: z.ZodArray<z.ZodString>;
+    riskLevel: z.ZodEnum<{
+        critical: "critical";
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>;
+    enforcementMultiplier: z.ZodNumber;
+    elevatedScrutiny: z.ZodBoolean;
+    activeSince: z.ZodString;
+}, z.core.$strip>;
+export declare const CounterfactualResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    originalDecisionId: z.ZodString;
+    modification: z.ZodString;
+    hypotheticalVerdict: z.ZodEnum<{
+        transform: "transform";
+        escalate: "escalate";
+        warn: "warn";
+        allow: "allow";
+        deny: "deny";
+    }>;
+    actualVerdict: z.ZodEnum<{
+        transform: "transform";
+        escalate: "escalate";
+        warn: "warn";
+        allow: "allow";
+        deny: "deny";
+    }>;
+    diverged: z.ZodBoolean;
+    explanation: z.ZodString;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export declare const ExplainableReportSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    agentId: z.ZodString;
+    from: z.ZodString;
+    to: z.ZodString;
+    decisionsAnalyzed: z.ZodNumber;
+    summary: z.ZodString;
+    findings: z.ZodArray<z.ZodString>;
+    recommendations: z.ZodArray<z.ZodString>;
+    severity: z.ZodEnum<{
+        critical: "critical";
+        healthy: "healthy";
+        attention: "attention";
+    }>;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export declare const TemporalPatternSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    ruleId: z.ZodOptional<z.ZodString>;
+    cronSchedule: z.ZodString;
+    activeDays: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    occurrences: z.ZodNumber;
+    avgDeviation: z.ZodNumber;
+    isRisk: z.ZodBoolean;
+    detectedAt: z.ZodString;
+    lastSeen: z.ZodString;
+}, z.core.$strip>;
+export declare const TemporalPatternSuggestionSchema: z.ZodObject<{
+    patternId: z.ZodString;
+    suggestedCron: z.ZodString;
+    confidence: z.ZodNumber;
+    reason: z.ZodString;
+}, z.core.$strip>;
+export declare const CrossDomainTransferSchema: z.ZodObject<{
+    id: z.ZodString;
+    sourceDna: z.ZodString;
+    targetDna: z.ZodString;
+    ruleId: z.ZodString;
+    similarity: z.ZodNumber;
+    justification: z.ZodString;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export declare const SemanticFactSchema: z.ZodObject<{
+    id: z.ZodString;
+    fact: z.ZodString;
+    sourceEpisodes: z.ZodArray<z.ZodString>;
+    confidence: z.ZodNumber;
+    createdAt: z.ZodString;
+    lastValidated: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ConsolidatedKnowledgeSchema: z.ZodObject<{
+    semanticFacts: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        fact: z.ZodString;
+        sourceEpisodes: z.ZodArray<z.ZodString>;
+        confidence: z.ZodNumber;
+        createdAt: z.ZodString;
+        lastValidated: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    summary: z.ZodString;
+    episodesProcessed: z.ZodNumber;
+    factsPruned: z.ZodNumber;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export declare const FailurePatternSchema: z.ZodObject<{
+    id: z.ZodString;
+    operationType: z.ZodString;
+    errorPattern: z.ZodString;
+    occurrences: z.ZodNumber;
+    failureRate: z.ZodNumber;
+    recommendedThreshold: z.ZodNumber;
+}, z.core.$strip>;
+export declare const BreakerAdjustmentSchema: z.ZodObject<{
+    id: z.ZodString;
+    failurePatternId: z.ZodString;
+    breakerName: z.ZodString;
+    previousThreshold: z.ZodNumber;
+    newThreshold: z.ZodNumber;
+    reason: z.ZodString;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export declare const ValueDefinitionSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    keywords: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const AlignmentScoreSchema: z.ZodObject<{
+    id: z.ZodString;
+    agentId: z.ZodString;
+    values: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        keywords: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    scores: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    overallScore: z.ZodNumber;
+    violations: z.ZodArray<z.ZodString>;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export declare const CollectiveVoteSchema: z.ZodObject<{
+    id: z.ZodString;
+    proposal: z.ZodString;
+    votes: z.ZodArray<z.ZodObject<{
+        agentId: z.ZodString;
+        choice: z.ZodEnum<{
+            approve: "approve";
+            reject: "reject";
+            abstain: "abstain";
+        }>;
+        weight: z.ZodNumber;
+        confidence: z.ZodNumber;
+        rationale: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    result: z.ZodEnum<{
+        approved: "approved";
+        rejected: "rejected";
+        tie: "tie";
+    }>;
+    collectiveConfidence: z.ZodNumber;
+}, z.core.$strip>;
+export declare const ExternalEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    source: z.ZodString;
+    type: z.ZodString;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    receivedAt: z.ZodString;
+}, z.core.$strip>;
+export declare const ExternalPolicySchema: z.ZodObject<{
+    id: z.ZodString;
+    source: z.ZodString;
+    ruleId: z.ZodString;
+    action: z.ZodEnum<{
+        transform: "transform";
+        block: "block";
+        escalate: "escalate";
+        warn: "warn";
+        log: "log";
+    }>;
+    conditions: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        value: z.ZodUnknown;
+    }, z.core.$strip>>;
+    importedAt: z.ZodString;
+}, z.core.$strip>;
+export declare const GovernanceChangeRequestSchema: z.ZodObject<{
+    id: z.ZodString;
+    dnaName: z.ZodString;
+    ruleId: z.ZodString;
+    changeType: z.ZodEnum<{
+        add: "add";
+        modify: "modify";
+        delete: "delete";
+    }>;
+    proposedRule: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        level: z.ZodEnum<{
+            critical: "critical";
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>;
+        action: z.ZodEnum<{
+            transform: "transform";
+            block: "block";
+            escalate: "escalate";
+            warn: "warn";
+            log: "log";
+        }>;
+        conditions: z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            value: z.ZodUnknown;
+        }, z.core.$strip>>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    rationale: z.ZodString;
+    ciStatus: z.ZodEnum<{
+        pending: "pending";
+        approved: "approved";
+        passing: "passing";
+        failing: "failing";
+    }>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type TemporalPattern = z.infer<typeof TemporalPatternSchema>;
+export type TemporalPatternSuggestion = z.infer<typeof TemporalPatternSuggestionSchema>;
+export type CrossDomainTransfer = z.infer<typeof CrossDomainTransferSchema>;
+export type SemanticFact = z.infer<typeof SemanticFactSchema>;
+export type ConsolidatedKnowledge = z.infer<typeof ConsolidatedKnowledgeSchema>;
+export type FailurePattern = z.infer<typeof FailurePatternSchema>;
+export type BreakerAdjustment = z.infer<typeof BreakerAdjustmentSchema>;
+export type ValueDefinition = z.infer<typeof ValueDefinitionSchema>;
+export type AlignmentScore = z.infer<typeof AlignmentScoreSchema>;
+export type CollectiveVote = z.infer<typeof CollectiveVoteSchema>;
+export type ExternalEvent = z.infer<typeof ExternalEventSchema>;
+export type ExternalPolicy = z.infer<typeof ExternalPolicySchema>;
+export type GovernanceChangeRequest = z.infer<typeof GovernanceChangeRequestSchema>;
+//# sourceMappingURL=index.d.ts.map