/**
 * Domain Boundary Resolution (ADR-PIPELINE-082)
 *
 * Disambiguation rules for overlapping capability keywords and tie-break rules
 * for domain ownership. Used to resolve which domain should handle a query
 * when multiple domains could legitimately claim the same tag.
 *
 * Two rule types:
 *   1. DISAMBIGUATION_RULES — modifier-based routing (ADR-082 §3).
 *      "regression" alone → test_bench; "regression test" → quality_engineering.
 *   2. TIE_BREAK_RULES — priority resolution (ADR-082 §4).
 *      "security" always goes to safety (shield), never quality_engineering.
 *
 * This module is declarative; callers (capability classifier, agentics ask)
 * consult it to refine routing decisions. It performs no I/O and is safe to
 * import anywhere.
 */
/**
 * A disambiguation rule for a keyword that could route to multiple domains
 * depending on nearby modifiers in the prompt.
 */
export interface DisambiguationRule {
    /** Trigger keyword that activates this rule (lowercase). */
    readonly trigger: string;
    /** Ordered modifier patterns. First match wins. */
    readonly modifiers: readonly {
        pattern: RegExp;
        domain: string;
    }[];
    /** Domain used when no modifier matches. */
    readonly defaultDomain: string;
    /** Human-readable rationale tied to ADR-082. */
    readonly note: string;
}
/**
 * A tie-break rule declaring that one domain always wins a keyword over
 * another. Used to enforce the capability ownership boundary from ADR-082 §1.
 */
export interface TieBreakRule {
    /** Keyword that triggers this rule (lowercase). */
    readonly keyword: string;
    /** The domain that wins — its capabilities stay. */
    readonly winner: string;
    /**
     * Domains whose capabilities are suppressed when this keyword is present
     * AND they would otherwise match. Empty means "both stay" (complementary).
     */
    readonly suppress: readonly string[];
    /** Human-readable rationale. */
    readonly note: string;
}
/** Result of resolving a prompt against the boundary rules. */
export interface BoundaryResolution {
    /** Disambiguation resolutions: keyword → winning domain. */
    readonly disambiguations: ReadonlyMap<string, string>;
    /** Suppressed domains — their capabilities should be filtered from routing. */
    readonly suppressedDomains: ReadonlySet<string>;
    /** Applied rules for explain/debug. */
    readonly appliedRules: readonly string[];
}
/**
 * Modifier-based disambiguation rules. Order within modifiers[] matters:
 * the first matching modifier wins, so more specific patterns come first.
 */
export declare const DISAMBIGUATION_RULES: readonly DisambiguationRule[];
/**
 * Priority resolution: certain keywords always belong to one domain regardless
 * of what other domains might tag. Enforces the capability ownership boundary
 * declared in ADR-082 §1 (Shield owns security, Latency-Lens owns perf, etc.).
 *
 * Note on domain names: ecosystem.graph.json uses underscores
 * ("quality_engineering"), the CLI runner uses hyphens ("quality-engineering").
 * These rules use the graph names (underscored) to match what the classifier
 * emits.
 */
export declare const TIE_BREAK_RULES: readonly TieBreakRule[];
/**
 * Apply ADR-082 boundary rules to a user prompt.
 * Returns disambiguation decisions and suppressed domains.
 */
export declare function resolveDomainBoundary(prompt: string): BoundaryResolution;
/**
 * Check whether a domain should be filtered from routing given the prompt.
 * Convenience wrapper over resolveDomainBoundary.
 */
export declare function isDomainSuppressed(domain: string, prompt: string): boolean;
/**
 * Resolve a single keyword to its routing domain, applying both disambiguation
 * and tie-break rules. Returns null if the keyword is not governed by any rule.
 */
export declare function routeKeyword(keyword: string, prompt: string): string | null;
//# sourceMappingURL=domain-boundary.d.ts.map