agent-contracts 0.0.2 → 0.5.1

package/dist/index.d.ts

@@ -1,2 +1,726 @@
-export declare const VERSION = "0.0.2";
-//# sourceMappingURL=index.d.ts.map
+import { z } from 'zod';
+
+declare const RuleSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    severity: z.ZodEnum<{
+        mandatory: "mandatory";
+        recommended: "recommended";
+        optional: "optional";
+    }>;
+    detection_method: z.ZodOptional<z.ZodString>;
+    escalation: z.ZodOptional<z.ZodString>;
+    ref: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type Rule = z.infer<typeof RuleSchema>;
+declare const EscalationCriterionSchema: z.ZodObject<{
+    condition: z.ZodString;
+    action: z.ZodEnum<{
+        stop_and_report: "stop_and_report";
+        report_to_architect: "report_to_architect";
+        wait_for_approval: "wait_for_approval";
+    }>;
+}, z.core.$strict>;
+type EscalationCriterion = z.infer<typeof EscalationCriterionSchema>;
+declare const PrerequisiteSchema: z.ZodObject<{
+    action: z.ZodEnum<{
+        read: "read";
+        execute: "execute";
+    }>;
+    target: z.ZodString;
+    required: z.ZodBoolean;
+}, z.core.$strict>;
+type Prerequisite = z.infer<typeof PrerequisiteSchema>;
+declare const AgentSchema: z.ZodObject<{
+    role_name: z.ZodString;
+    purpose: z.ZodString;
+    can_read_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    can_write_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    can_execute_tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    can_perform_validations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    can_invoke_agents: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    can_return_handoffs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    dispatch_only: z.ZodOptional<z.ZodBoolean>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        "read-only": "read-only";
+        "read-write": "read-write";
+    }>>;
+    responsibilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+        severity: z.ZodEnum<{
+            mandatory: "mandatory";
+            recommended: "recommended";
+            optional: "optional";
+        }>;
+        detection_method: z.ZodOptional<z.ZodString>;
+        escalation: z.ZodOptional<z.ZodString>;
+        ref: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    anti_patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    escalation_criteria: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        condition: z.ZodString;
+        action: z.ZodEnum<{
+            stop_and_report: "stop_and_report";
+            report_to_architect: "report_to_architect";
+            wait_for_approval: "wait_for_approval";
+        }>;
+    }, z.core.$strict>>>;
+    prerequisites: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        action: z.ZodEnum<{
+            read: "read";
+            execute: "execute";
+        }>;
+        target: z.ZodString;
+        required: z.ZodBoolean;
+    }, z.core.$strict>>>;
+}, z.core.$loose>;
+type Agent = z.infer<typeof AgentSchema>;
+
+declare const ArtifactSchema: z.ZodObject<{
+    type: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    owner: z.ZodString;
+    producers: z.ZodArray<z.ZodString>;
+    editors: z.ZodArray<z.ZodString>;
+    consumers: z.ZodArray<z.ZodString>;
+    states: z.ZodArray<z.ZodString>;
+    required_validations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    visibility: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+type Artifact = z.infer<typeof ArtifactSchema>;
+
+declare const DslSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    extends: z.ZodOptional<z.ZodString>;
+    system: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        default_phase_order: z.ZodArray<z.ZodString>;
+    }, z.core.$loose>;
+    agents: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        role_name: z.ZodString;
+        purpose: z.ZodString;
+        can_read_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        can_write_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        can_execute_tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        can_perform_validations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        can_invoke_agents: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        can_return_handoffs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        dispatch_only: z.ZodOptional<z.ZodBoolean>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            "read-only": "read-only";
+            "read-write": "read-write";
+        }>>;
+        responsibilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+            severity: z.ZodEnum<{
+                mandatory: "mandatory";
+                recommended: "recommended";
+                optional: "optional";
+            }>;
+            detection_method: z.ZodOptional<z.ZodString>;
+            escalation: z.ZodOptional<z.ZodString>;
+            ref: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        anti_patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        escalation_criteria: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            condition: z.ZodString;
+            action: z.ZodEnum<{
+                stop_and_report: "stop_and_report";
+                report_to_architect: "report_to_architect";
+                wait_for_approval: "wait_for_approval";
+            }>;
+        }, z.core.$strict>>>;
+        prerequisites: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            action: z.ZodEnum<{
+                read: "read";
+                execute: "execute";
+            }>;
+            target: z.ZodString;
+            required: z.ZodBoolean;
+        }, z.core.$strict>>>;
+    }, z.core.$loose>>>;
+    tasks: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        description: z.ZodString;
+        target_agent: z.ZodString;
+        allowed_from_agents: z.ZodArray<z.ZodString>;
+        phase: z.ZodString;
+        input_artifacts: z.ZodArray<z.ZodString>;
+        invocation_handoff: z.ZodString;
+        result_handoff: z.ZodString;
+        default_priority: z.ZodOptional<z.ZodString>;
+        responsibilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        execution_steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            action: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+            abort_on_failure: z.ZodOptional<z.ZodBoolean>;
+            uses_tool: z.ZodOptional<z.ZodString>;
+            produces_artifact: z.ZodOptional<z.ZodString>;
+            depends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            skip_condition: z.ZodOptional<z.ZodString>;
+            wait_for_approval: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>>;
+        completion_criteria: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            description: z.ZodString;
+            severity: z.ZodEnum<{
+                mandatory: "mandatory";
+                recommended: "recommended";
+                optional: "optional";
+            }>;
+            detection_method: z.ZodOptional<z.ZodString>;
+            escalation: z.ZodOptional<z.ZodString>;
+            ref: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        anti_patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        escalation_criteria: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            condition: z.ZodString;
+            action: z.ZodEnum<{
+                stop_and_report: "stop_and_report";
+                report_to_architect: "report_to_architect";
+                wait_for_approval: "wait_for_approval";
+            }>;
+        }, z.core.$strict>>>;
+    }, z.core.$loose>>>;
+    artifacts: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        owner: z.ZodString;
+        producers: z.ZodArray<z.ZodString>;
+        editors: z.ZodArray<z.ZodString>;
+        consumers: z.ZodArray<z.ZodString>;
+        states: z.ZodArray<z.ZodString>;
+        required_validations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        visibility: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+    tools: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        kind: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        input_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        output_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        invokable_by: z.ZodArray<z.ZodString>;
+        side_effects: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$loose>>>;
+    validations: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        target_artifact: z.ZodString;
+        kind: z.ZodEnum<{
+            schema: "schema";
+            mechanical: "mechanical";
+            semantic: "semantic";
+            approval: "approval";
+        }>;
+        executor_type: z.ZodEnum<{
+            tool: "tool";
+            agent: "agent";
+        }>;
+        executor: z.ZodString;
+        blocking: z.ZodBoolean;
+        produces_evidence: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+    handoff_types: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        version: z.ZodNumber;
+        description: z.ZodOptional<z.ZodString>;
+        payload: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, z.core.$loose>>>;
+    workflow: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        entry_conditions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"handoff">;
+            handoff_kind: z.ZodString;
+            task: z.ZodOptional<z.ZodString>;
+            from_agent: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"validation">;
+            validation: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"decision">;
+            on: z.ZodString;
+            branches: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>], "type">>;
+    }, z.core.$loose>>>;
+    policies: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        when: z.ZodObject<{
+            artifact_type: z.ZodOptional<z.ZodString>;
+            phase: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>;
+        requires_validations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+type Dsl = z.infer<typeof DslSchema>;
+
+declare const HandoffTypeSchema: z.ZodObject<{
+    version: z.ZodNumber;
+    description: z.ZodOptional<z.ZodString>;
+    payload: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, z.core.$loose>;
+type HandoffType = z.infer<typeof HandoffTypeSchema>;
+
+declare const AppendOperatorSchema: z.ZodObject<{
+    $append: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, z.core.$strip>;
+type AppendOperator = z.infer<typeof AppendOperatorSchema>;
+declare const PrependOperatorSchema: z.ZodObject<{
+    $prepend: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, z.core.$strip>;
+type PrependOperator = z.infer<typeof PrependOperatorSchema>;
+declare const InsertAfterOperatorSchema: z.ZodObject<{
+    $insert_after: z.ZodObject<{
+        after: z.ZodString;
+        entries: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type InsertAfterOperator = z.infer<typeof InsertAfterOperatorSchema>;
+declare const ReplaceOperatorSchema: z.ZodObject<{
+    $replace: z.ZodAny;
+}, z.core.$strip>;
+type ReplaceOperator = z.infer<typeof ReplaceOperatorSchema>;
+declare const RemoveOperatorSchema: z.ZodObject<{
+    $remove: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type RemoveOperator = z.infer<typeof RemoveOperatorSchema>;
+type MergeableRecord<T> = Record<string, T> | {
+    $append: Record<string, unknown>;
+} | {
+    $prepend: Record<string, unknown>;
+} | {
+    $insert_after: {
+        after: string;
+        entries: Record<string, unknown>;
+    };
+} | {
+    $replace: unknown;
+} | {
+    $remove: string[];
+};
+
+declare const PolicyWhenSchema: z.ZodObject<{
+    artifact_type: z.ZodOptional<z.ZodString>;
+    phase: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+type PolicyWhen = z.infer<typeof PolicyWhenSchema>;
+declare const PolicySchema: z.ZodObject<{
+    when: z.ZodObject<{
+        artifact_type: z.ZodOptional<z.ZodString>;
+        phase: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+    requires_validations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+type Policy = z.infer<typeof PolicySchema>;
+
+declare const VersionLiteralSchema: z.ZodLiteral<1>;
+type VersionLiteral = z.infer<typeof VersionLiteralSchema>;
+declare const ExtendsSchema: z.ZodOptional<z.ZodString>;
+type Extends = z.infer<typeof ExtendsSchema>;
+declare const SystemSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    default_phase_order: z.ZodArray<z.ZodString>;
+}, z.core.$loose>;
+type System = z.infer<typeof SystemSchema>;
+
+declare const ExecutionStepSchema: z.ZodObject<{
+    id: z.ZodString;
+    action: z.ZodString;
+    required: z.ZodOptional<z.ZodBoolean>;
+    abort_on_failure: z.ZodOptional<z.ZodBoolean>;
+    uses_tool: z.ZodOptional<z.ZodString>;
+    produces_artifact: z.ZodOptional<z.ZodString>;
+    depends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    skip_condition: z.ZodOptional<z.ZodString>;
+    wait_for_approval: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+type ExecutionStep = z.infer<typeof ExecutionStepSchema>;
+declare const TaskSchema: z.ZodObject<{
+    description: z.ZodString;
+    target_agent: z.ZodString;
+    allowed_from_agents: z.ZodArray<z.ZodString>;
+    phase: z.ZodString;
+    input_artifacts: z.ZodArray<z.ZodString>;
+    invocation_handoff: z.ZodString;
+    result_handoff: z.ZodString;
+    default_priority: z.ZodOptional<z.ZodString>;
+    responsibilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    execution_steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        action: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
+        abort_on_failure: z.ZodOptional<z.ZodBoolean>;
+        uses_tool: z.ZodOptional<z.ZodString>;
+        produces_artifact: z.ZodOptional<z.ZodString>;
+        depends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        skip_condition: z.ZodOptional<z.ZodString>;
+        wait_for_approval: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>>;
+    completion_criteria: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+        severity: z.ZodEnum<{
+            mandatory: "mandatory";
+            recommended: "recommended";
+            optional: "optional";
+        }>;
+        detection_method: z.ZodOptional<z.ZodString>;
+        escalation: z.ZodOptional<z.ZodString>;
+        ref: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    anti_patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    escalation_criteria: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        condition: z.ZodString;
+        action: z.ZodEnum<{
+            stop_and_report: "stop_and_report";
+            report_to_architect: "report_to_architect";
+            wait_for_approval: "wait_for_approval";
+        }>;
+    }, z.core.$strict>>>;
+}, z.core.$loose>;
+type Task = z.infer<typeof TaskSchema>;
+
+declare const ToolSchema: z.ZodObject<{
+    kind: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    input_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    output_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    invokable_by: z.ZodArray<z.ZodString>;
+    side_effects: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+type Tool = z.infer<typeof ToolSchema>;
+
+declare const ValidationSchema: z.ZodObject<{
+    target_artifact: z.ZodString;
+    kind: z.ZodEnum<{
+        schema: "schema";
+        mechanical: "mechanical";
+        semantic: "semantic";
+        approval: "approval";
+    }>;
+    executor_type: z.ZodEnum<{
+        tool: "tool";
+        agent: "agent";
+    }>;
+    executor: z.ZodString;
+    blocking: z.ZodBoolean;
+    produces_evidence: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+type Validation = z.infer<typeof ValidationSchema>;
+
+declare const WorkflowStepSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"handoff">;
+    handoff_kind: z.ZodString;
+    task: z.ZodOptional<z.ZodString>;
+    from_agent: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"validation">;
+    validation: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"decision">;
+    on: z.ZodString;
+    branches: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+}, z.core.$strict>], "type">;
+type WorkflowStep = z.infer<typeof WorkflowStepSchema>;
+declare const WorkflowSchema: z.ZodObject<{
+    entry_conditions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"handoff">;
+        handoff_kind: z.ZodString;
+        task: z.ZodOptional<z.ZodString>;
+        from_agent: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"validation">;
+        validation: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"decision">;
+        on: z.ZodString;
+        branches: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>], "type">>;
+}, z.core.$loose>;
+type Workflow = z.infer<typeof WorkflowSchema>;
+
+interface LoadResult {
+    data: Record<string, unknown>;
+    filePath: string;
+}
+declare class DslLoadError extends Error {
+    readonly filePath?: string | undefined;
+    constructor(message: string, filePath?: string | undefined);
+}
+declare function loadDsl(entryPath: string): Promise<LoadResult>;
+
+declare class BaseResolveError extends Error {
+    constructor(message: string);
+}
+declare function resolveBase(extendsValue: string, projectDir: string): Promise<LoadResult>;
+
+declare class MergeError extends Error {
+    constructor(message: string);
+}
+type AnyRecord = Record<string, unknown>;
+declare function mergeDsl(base: AnyRecord, project: AnyRecord): AnyRecord;
+
+interface ResolveResult {
+    data: Record<string, unknown>;
+    projectPath: string;
+    basePath?: string;
+}
+declare function resolve(projectDirOrFile: string): Promise<ResolveResult>;
+
+interface DiagnosticMessage {
+    path: string;
+    message: string;
+    code: string;
+}
+interface SchemaValidationResult {
+    success: boolean;
+    data?: Dsl;
+    diagnostics: DiagnosticMessage[];
+}
+declare function validateSchema(data: Record<string, unknown>): SchemaValidationResult;
+
+interface ReferenceDiagnostic {
+    path: string;
+    message: string;
+    code: string;
+}
+declare function checkReferences(dsl: Dsl): ReferenceDiagnostic[];
+
+type Severity = "error" | "warning" | "info";
+interface LintDiagnostic {
+    ruleId: string;
+    severity: Severity;
+    path: string;
+    message: string;
+}
+interface LintRule {
+    id: string;
+    description: string;
+    run(dsl: Dsl): LintDiagnostic[];
+}
+
+declare const builtinRules: LintRule[];
+declare function lint(dsl: Dsl, rules?: LintRule[]): LintDiagnostic[];
+
+/**
+ * Run Spectral rules on a resolved DSL object.
+ * Returns diagnostics in the same format as the TypeScript linter.
+ */
+declare function spectralLint(dslObject: Record<string, unknown>): Promise<LintDiagnostic[]>;
+
+declare const CONTEXT_TYPES: readonly ["agent", "task", "artifact", "tool", "validation", "handoff_type", "workflow", "policy", "system"];
+declare const ContextTypeSchema: z.ZodEnum<{
+    tool: "tool";
+    agent: "agent";
+    task: "task";
+    validation: "validation";
+    system: "system";
+    workflow: "workflow";
+    artifact: "artifact";
+    handoff_type: "handoff_type";
+    policy: "policy";
+}>;
+type ContextType = z.infer<typeof ContextTypeSchema>;
+declare const RenderTargetSchema: z.ZodObject<{
+    template: z.ZodString;
+    context: z.ZodEnum<{
+        tool: "tool";
+        agent: "agent";
+        task: "task";
+        validation: "validation";
+        system: "system";
+        workflow: "workflow";
+        artifact: "artifact";
+        handoff_type: "handoff_type";
+        policy: "policy";
+    }>;
+    output: z.ZodString;
+    include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type RenderTarget = z.infer<typeof RenderTargetSchema>;
+declare const AgentContractsConfigSchema: z.ZodObject<{
+    dsl: z.ZodString;
+    renders: z.ZodArray<z.ZodObject<{
+        template: z.ZodString;
+        context: z.ZodEnum<{
+            tool: "tool";
+            agent: "agent";
+            task: "task";
+            validation: "validation";
+            system: "system";
+            workflow: "workflow";
+            artifact: "artifact";
+            handoff_type: "handoff_type";
+            policy: "policy";
+        }>;
+        output: z.ZodString;
+        include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type AgentContractsConfig = z.infer<typeof AgentContractsConfigSchema>;
+interface ResolvedRenderTarget {
+    template: string;
+    context: ContextType;
+    output: string;
+    include?: string[];
+    exclude?: string[];
+}
+interface ResolvedConfig {
+    dsl: string;
+    renders: ResolvedRenderTarget[];
+    configDir: string;
+}
+
+declare function renderFromConfig(dsl: Dsl, renderTargets: ResolvedRenderTarget[]): Promise<string[]>;
+declare function checkDriftFromConfig(dsl: Dsl, renderTargets: ResolvedRenderTarget[]): Promise<{
+    hasDrift: boolean;
+    diffs: string[];
+}>;
+
+interface GlobalContext {
+    system: Dsl["system"];
+    agents: Dsl["agents"];
+    tasks: Dsl["tasks"];
+    artifacts: Dsl["artifacts"];
+    tools: Dsl["tools"];
+    validations: Dsl["validations"];
+    handoff_types: Dsl["handoff_types"];
+    workflow: Dsl["workflow"];
+    policies: Dsl["policies"];
+    [key: string]: unknown;
+}
+interface SystemContext {
+    system: System;
+    dsl: Dsl;
+    [key: string]: unknown;
+}
+interface PerTaskContext {
+    task: Task & {
+        id: string;
+    };
+    targetAgent: (Agent & {
+        id: string;
+    }) | null;
+    dsl: Dsl;
+    [key: string]: unknown;
+}
+interface PerArtifactContext {
+    artifact: Artifact & {
+        id: string;
+    };
+    dsl: Dsl;
+    [key: string]: unknown;
+}
+interface PerToolContext {
+    tool: Tool & {
+        id: string;
+    };
+    dsl: Dsl;
+    [key: string]: unknown;
+}
+interface PerValidationContext {
+    validation: Validation & {
+        id: string;
+    };
+    dsl: Dsl;
+    [key: string]: unknown;
+}
+interface PerHandoffTypeContext {
+    handoff_type: HandoffType & {
+        id: string;
+    };
+    relatedTasks: Array<Task & {
+        id: string;
+    }>;
+    dsl: Dsl;
+    [key: string]: unknown;
+}
+interface PerWorkflowContext {
+    workflow: Workflow & {
+        id: string;
+    };
+    dsl: Dsl;
+    [key: string]: unknown;
+}
+interface PerPolicyContext {
+    policy: Policy & {
+        id: string;
+    };
+    dsl: Dsl;
+    [key: string]: unknown;
+}
+interface MergedBehavioralSpec {
+    responsibilities: string[];
+    constraints: string[];
+    rules: Array<Record<string, unknown>>;
+    anti_patterns: string[];
+    escalation_criteria: Array<Record<string, unknown>>;
+    execution_steps: Array<Record<string, unknown>>;
+    completion_criteria: string[];
+}
+interface DelegatableTaskView {
+    id: string;
+    description: string;
+    target_agent: string;
+    phase: string;
+    input_artifacts: string[];
+    invocation_handoff: string;
+    invocation_payload_keys: string[];
+    result_handoff: string;
+    result_payload_keys: string[];
+}
+interface PerAgentContext {
+    agent: (Agent & Record<string, unknown>) & {
+        id: string;
+    };
+    tasks: Array<(Task & Record<string, unknown>) & {
+        id: string;
+    }>;
+    receivableTasks: Array<(Task & Record<string, unknown>) & {
+        id: string;
+    }>;
+    delegatableTasks: DelegatableTaskView[];
+    relatedArtifacts: Dsl["artifacts"];
+    relatedTools: Dsl["tools"];
+    relatedHandoffTypes: Dsl["handoff_types"];
+    mergedBehavior: MergedBehavioralSpec;
+    dsl: Dsl;
+    [key: string]: unknown;
+}
+declare function buildGlobalContext(dsl: Dsl): GlobalContext;
+declare function buildSystemContext(dsl: Dsl): SystemContext;
+declare function buildTaskContext(dsl: Dsl, taskId: string): PerTaskContext;
+declare function buildArtifactContext(dsl: Dsl, artifactId: string): PerArtifactContext;
+declare function buildToolContext(dsl: Dsl, toolId: string): PerToolContext;
+declare function buildValidationContext(dsl: Dsl, validationId: string): PerValidationContext;
+declare function buildHandoffTypeContext(dsl: Dsl, handoffTypeId: string): PerHandoffTypeContext;
+declare function buildWorkflowContext(dsl: Dsl, phaseId: string): PerWorkflowContext;
+declare function buildPolicyContext(dsl: Dsl, policyId: string): PerPolicyContext;
+declare function buildPerAgentContext(dsl: Dsl, agent: Agent & {
+    id: string;
+}): PerAgentContext;
+
+declare class ConfigLoadError extends Error {
+    readonly filePath?: string | undefined;
+    constructor(message: string, filePath?: string | undefined);
+}
+declare function loadConfig(configPath?: string): Promise<ResolvedConfig | null>;
+declare function resolveDslPath(dirArg: string | undefined, dirArgDefault: string, config: ResolvedConfig | null): string;
+
+export { type Agent, type AgentContractsConfig, AgentContractsConfigSchema, AgentSchema, type AppendOperator, AppendOperatorSchema, type Artifact, ArtifactSchema, BaseResolveError, CONTEXT_TYPES, ConfigLoadError, type ContextType, ContextTypeSchema, type DelegatableTaskView, type DiagnosticMessage, type Dsl, DslLoadError, DslSchema, type EscalationCriterion, EscalationCriterionSchema, type ExecutionStep, ExecutionStepSchema, type Extends, ExtendsSchema, type GlobalContext, type HandoffType, HandoffTypeSchema, type InsertAfterOperator, InsertAfterOperatorSchema, type LintDiagnostic, type LintRule, type LoadResult, MergeError, type MergeableRecord, type MergedBehavioralSpec, type PerAgentContext, type PerArtifactContext, type PerHandoffTypeContext, type PerPolicyContext, type PerTaskContext, type PerToolContext, type PerValidationContext, type PerWorkflowContext, type Policy, PolicySchema, type PolicyWhen, PolicyWhenSchema, type PrependOperator, PrependOperatorSchema, type Prerequisite, PrerequisiteSchema, type ReferenceDiagnostic, type RemoveOperator, RemoveOperatorSchema, type RenderTarget, RenderTargetSchema, type ReplaceOperator, ReplaceOperatorSchema, type ResolveResult, type ResolvedConfig, type ResolvedRenderTarget, type Rule, RuleSchema, type SchemaValidationResult, type Severity, type System, type SystemContext, SystemSchema, type Task, TaskSchema, type Tool, ToolSchema, type Validation, ValidationSchema, type VersionLiteral, VersionLiteralSchema, type Workflow, WorkflowSchema, type WorkflowStep, WorkflowStepSchema, buildArtifactContext, buildGlobalContext, buildHandoffTypeContext, buildPerAgentContext, buildPolicyContext, buildSystemContext, buildTaskContext, buildToolContext, buildValidationContext, buildWorkflowContext, builtinRules, checkDriftFromConfig, checkReferences, lint, loadConfig, loadDsl, mergeDsl, renderFromConfig, resolve, resolveBase, resolveDslPath, spectralLint, validateSchema };