export declare const TOOL_NAMES: readonly ["codex", "claude", "copilot"];
export type ToolName = (typeof TOOL_NAMES)[number];
export declare const SPECIALIST_RESULT_FIELDS: readonly ["role", "status", "summary", "agreements", "conflicts", "validations", "risks", "touched_files", "next_steps"];
export type SpecialistResultField = (typeof SPECIALIST_RESULT_FIELDS)[number];
export declare const PROJECT_TYPES: readonly ["python", "node", "docs", "data-platform", "generic"];
export type ProjectType = (typeof PROJECT_TYPES)[number];
export declare const TASK_TYPES: readonly ["planning", "implementation", "inline", "review", "testing", "docs", "bugfix", "refactor", "migration", "release-readiness"];
export type TaskType = (typeof TASK_TYPES)[number];
export declare const EXECUTION_MODES: readonly ["assisted", "guarded", "inline"];
export type ExecutionMode = (typeof EXECUTION_MODES)[number];
export declare const CHANGE_SIZES: readonly ["small", "medium", "large"];
export type ChangeSize = (typeof CHANGE_SIZES)[number];
export declare const FILE_AREAS: readonly ["application", "config", "context", "data", "docs", "infra", "tests", "unknown"];
export type FileArea = (typeof FILE_AREAS)[number];
export type RoutingRiskLevel = "low" | "medium" | "high";
export interface GlobalConfig {
    version: number;
    name: string;
    authority: {
        canonical_dirs: string[];
        generated_outputs_are_derived: boolean;
    };
    defaults: {
        task_directory: string;
        context_directory: string;
        managed_prefix: string;
        default_profile: string;
        default_execution_mode: ExecutionMode;
        default_task_type: TaskType;
        default_change_size: ChangeSize;
        authority_files: string[];
    };
    surfaces: Record<ToolName, string>;
}
export interface RoutingSurface {
    file: string;
    template: string;
    block_name: string;
}
export interface RoutingConfig {
    version: number;
    surfaces: Record<ToolName, RoutingSurface>;
    portable_state: {
        project: string;
        checks: string;
        context: {
            architecture: string;
            commands: string;
            specialists: string;
            conventions: string;
            tool_capabilities: string;
            mcp_capabilities: string;
            runbooks: string;
        };
        memory: {
            repo_facts: string;
            architecture_decisions: string;
            domain_glossary: string;
            current_focus: string;
            open_risks: string;
            known_gotchas: string;
            last_successful_patterns: string;
        };
        roles: {
            readme: string;
            specialist_template: string;
        };
        templates: {
            role_result: string;
        };
        state: {
            current_phase: string;
            active_role_hints: string;
            checkpoint_latest_json: string;
            checkpoint_latest_markdown: string;
            handoff_readme: string;
            dispatch_readme: string;
            reconcile_readme: string;
        };
        scripts: {
            verify_contract: string;
        };
        github: {
            instructions: {
                backend: string;
                frontend: string;
                docs: string;
                data: string;
            };
            agents: {
                shrey_junior: string;
                specialist_template: string;
            };
            workflows: {
                contract: string;
            };
        };
    };
    task_packets: {
        directory: string;
        roles: string[];
    };
    defaults: {
        fallback_tool: ToolName;
        planning_tool: ToolName;
        review_tool: ToolName;
        docs_tool: ToolName;
        inline_tool: ToolName;
    };
    profiles: Record<string, RoutingProfile>;
}
export interface ModelsConfig {
    version: number;
    tool_packets: Record<ToolName, {
        default_prompt: string;
        role: string;
    }>;
    fanout_roles: Record<string, {
        prompt: string;
    }>;
    task_prompts: Record<TaskType, string>;
}
export interface GuardrailsConfig {
    version: number;
    sensitive_path_patterns: string[];
    metadata_only_patterns: string[];
    protected_global_roots: string[];
    refuse_global_writes: boolean;
    append_only_surfaces: string[];
    forbidden_scope: {
        default: string[];
        [profileName: string]: string[];
    };
    execution_modes: Record<ExecutionMode, {
        description: string;
    }>;
}
export interface McpRegistryConfig {
    version: number;
    notes: string;
    mcpServers: Record<string, {
        id?: string;
        category: string;
        purpose: string;
        portable: boolean;
        treatment: string;
        allowedProfiles: string[];
        trustLevel: "low" | "medium" | "high";
        humanNotes: string;
        toolCompatibility: ToolName[];
        referenceOnly: boolean;
        repoEligible: boolean;
        compatibleSpecialists?: string[];
        readOnly?: boolean;
        writeCapable?: boolean;
        approvalRequired?: boolean;
        usageGuidance?: string[];
        antiPatterns?: string[];
    }>;
}
export interface SpecialistDefinition {
    id: string;
    name: string;
    purpose: string;
    aliases?: string[];
    preferred_tools: ToolName[];
    allowed_profiles: string[];
    routing_bias: {
        roles: string[];
        task_types: TaskType[];
        file_areas: FileArea[];
        preferred_primary_tool?: ToolName;
        preferred_review_tool?: ToolName;
    };
    validation_expectations: string[];
    result_schema_expectations: SpecialistResultField[];
    mcp_eligibility: string[];
    risk_posture: "low" | "medium" | "high" | "conservative";
    handoff_guidance: string[];
}
export interface SpecialistsConfig {
    version: number;
    defaults: {
        specialist_by_role: Record<string, string>;
        fallback_specialist: string;
    };
    specialists: Record<string, SpecialistDefinition>;
}
export type PolicyPoint = "pre-run" | "pre-fanout" | "pre-dispatch" | "pre-sync" | "post-sync" | "pre-checkpoint" | "pre-handoff" | "pre-push-check" | "pre-release-check";
export type PolicyCheckId = "authority-conflicts" | "profile-mismatch" | "blocked-reconcile" | "missing-structured-outputs" | "specialist-mismatch" | "mcp-ineligibility" | "missing-validations" | "push-release-blockers";
export interface PolicyCheckRule {
    id: PolicyCheckId;
    severity: "warn" | "block";
}
export interface PoliciesConfig {
    version: number;
    points: Record<PolicyPoint, {
        checks: PolicyCheckRule[];
    }>;
}
export interface GlobalBootstrapDefaults {
    version?: number;
    default_profile?: string;
    project_type_profiles?: Partial<Record<ProjectType, string>>;
    project_type_specialists?: Partial<Record<ProjectType, string[]>>;
    project_type_validation_hints?: Partial<Record<ProjectType, string[]>>;
    project_type_mcp_hints?: Partial<Record<ProjectType, string[]>>;
}
export interface GlobalHomePaths {
    root: string;
    configs: string;
    prompts: string;
    specialists: string;
    policies: string;
    mcp: string;
    defaults: string;
    adapters: string;
    bin: string;
}
export interface RoutingProfile {
    description: string;
    default_execution_mode: ExecutionMode;
    review_tool: ToolName;
    sync: {
        default_backup: boolean;
    };
    packet: {
        medium_risk_required_roles: string[];
        high_risk_required_roles: string[];
    };
    routing: {
        task_types: Partial<Record<TaskType, ToolName>>;
        risk_overrides: Partial<Record<RoutingRiskLevel, {
            review_tool?: ToolName;
            required_roles?: string[];
        }>>;
        file_area_overrides: Partial<Record<FileArea, ToolName>>;
    };
}
export interface LoadedConfig {
    repoRoot: string;
    global: GlobalConfig;
    routing: RoutingConfig;
    models: ModelsConfig;
    guardrails: GuardrailsConfig;
    mcpServers: McpRegistryConfig;
    specialists: SpecialistsConfig;
    policies: PoliciesConfig;
}
export declare function loadCanonicalConfig(repoRoot: string): Promise<LoadedConfig>;
export declare function getGlobalHomeRoot(): string;
export declare function getGlobalHomePaths(root?: string): GlobalHomePaths;
export declare function loadGlobalBootstrapDefaults(root?: string): Promise<GlobalBootstrapDefaults | null>;
//# sourceMappingURL=config.d.ts.map