export declare const ROUTING_MEMORY_SCHEMA_VERSION: 1;
export declare const ROUTING_MEMORY_STORAGE_VERSION: 1;
export declare const DEFAULT_ROUTING_MEMORY_FILE: "routing-memory.json";
export declare const DEFAULT_ROUTING_MEMORY_RETENTION = 20;
export declare const DEFAULT_MAX_LEARNED_RULES = 64;
export type RoutingLanguage = "en" | "fa" | "mixed";
export type RoutingTaskFamily = "explanation" | "question" | "action" | "debug" | "implementation" | "testing" | "verification" | "audit" | "research" | "release" | "other";
export type RoutingProjectScope = "none" | "file" | "module" | "repository" | "multiple";
export type RoutingRisk = "low" | "medium" | "high";
export type RoutingAction = "mission" | "normal";
export type RoutingRuleSource = "explicit" | "learned";
/** Prompt-derived, bounded semantic data. It deliberately has no text field. */
export interface RoutingSignature {
    readonly schemaVersion: typeof ROUTING_MEMORY_SCHEMA_VERSION;
    readonly language: RoutingLanguage;
    readonly taskFamily: RoutingTaskFamily;
    readonly explanation: boolean;
    readonly question: boolean;
    readonly action: boolean;
    readonly projectScope: RoutingProjectScope;
    readonly investigation: boolean;
    readonly mutation: boolean;
    readonly implementation: boolean;
    readonly testing: boolean;
    readonly verification: boolean;
    readonly audit: boolean;
    readonly remediation: boolean;
    readonly research: boolean;
    readonly release: boolean;
    readonly multiStep: boolean;
    readonly dependentSteps: boolean;
    readonly deliverables: number;
    readonly multiRole: boolean;
    readonly sensitive: boolean;
    readonly destructive: boolean;
    readonly risk: RoutingRisk;
}
export interface RoutingMemoryRule {
    readonly id: string;
    readonly schemaVersion: typeof ROUTING_MEMORY_SCHEMA_VERSION;
    readonly action: RoutingAction;
    readonly source: RoutingRuleSource;
    readonly signature: RoutingSignature;
    readonly confidence: number;
    readonly observations: number;
    readonly enabled: boolean;
    readonly createdAt: string;
    readonly updatedAt: string;
    readonly lastObservedAt: string;
}
export type RoutingMemoryRuleView = RoutingMemoryRule;
export type RoutingMemoryRuleWrite = RoutingMemoryRuleView & {
    readonly created: boolean;
    readonly generation: number;
};
export interface RoutingLocalSignals {
    readonly missionScore?: number;
    readonly confidence?: number;
    readonly signals?: readonly string[];
    readonly path?: "simple" | "complex" | "ambiguous" | string;
}
export interface RoutingMemoryPolicy {
    readonly enabled?: boolean;
    readonly learnFromChoices?: boolean;
    readonly existingRulesApply?: boolean;
    /** Alias accepted for callers that use the imperative wording. */
    readonly applyExistingRules?: boolean;
}
export interface RoutingMemoryStoreOptions extends RoutingMemoryPolicy {
    readonly root: string;
    readonly activeFile?: string;
    readonly retention?: number;
    readonly maxLearnedRules?: number;
    readonly now?: () => string;
    readonly id?: () => string;
}
export interface RoutingMemoryCallOptions extends RoutingMemoryPolicy {
    readonly expectedGeneration?: number;
    readonly signal?: AbortSignal;
}
export type RoutingMemoryMatchKind = "none" | "conflict" | "strong";
export type RoutingMemoryMode = "AUTO_MISSION" | "SUGGEST_MISSION" | "NORMAL";
export interface RoutingMemoryMatch {
    readonly kind: RoutingMemoryMatchKind;
    /** Equivalent spelling useful to adapters that call this a status. */
    readonly status: RoutingMemoryMatchKind;
    readonly mode?: RoutingMemoryMode;
    readonly action?: RoutingAction;
    readonly source?: RoutingRuleSource;
    readonly ruleId?: string;
    readonly confidence?: number;
    readonly similarity?: number;
    readonly reason: string;
    readonly conflict?: boolean;
}
export interface RoutingMemoryLoadResult {
    readonly status: "missing" | "valid" | "corrupt";
    readonly generation: number;
    readonly savedAt?: string;
    readonly rules: readonly RoutingMemoryRuleView[];
    readonly repairRequired: boolean;
    readonly diagnostics: readonly string[];
}
export interface RoutingMemoryMutationResult {
    readonly changed: boolean;
    readonly generation: number;
    readonly previousGeneration?: number;
    readonly historyPath?: string;
    readonly warnings?: readonly string[];
}
export interface ObserveChoiceResult extends RoutingMemoryMutationResult {
    readonly learned: boolean;
    readonly created: boolean;
    readonly ruleCreated: boolean;
    readonly rule?: RoutingMemoryRuleView;
    readonly prunedRuleId?: string;
}
interface StoredRoutingMemory {
    readonly storageVersion: typeof ROUTING_MEMORY_STORAGE_VERSION;
    readonly generation: number;
    readonly savedAt: string;
    readonly rules: readonly RoutingMemoryRule[];
}
export declare function validateRoutingSignature(value: unknown): RoutingSignature;
/**
 * Compare only bounded concepts. Language is intentionally neutral so the same
 * English and Persian intent can match; lexical overlap is never considered.
 */
export declare function routingSignatureSimilarity(left: RoutingSignature, right: RoutingSignature): number;
export declare function validateRoutingMemoryRule(value: unknown): RoutingMemoryRule;
export declare function validateStoredRoutingMemory(value: unknown): StoredRoutingMemory;
export declare function buildRoutingSignature(prompt: string, localSignals?: RoutingLocalSignals): RoutingSignature;
export declare class RoutingMemoryStore {
    private readonly root;
    private readonly activeFile;
    private readonly historyDir;
    private readonly retention;
    private readonly maxLearnedRules;
    private readonly now;
    private readonly nextId;
    private policy;
    private queue;
    private loaded;
    private generation;
    private savedAt;
    private rules;
    constructor(options: RoutingMemoryStoreOptions);
    load(): Promise<RoutingMemoryLoadResult>;
    /** Set application gating without deleting retained rules. */
    setEnabled(enabled: boolean): void;
    /** Enable or disable one stored rule. */
    setEnabled(ruleId: string, enabled: boolean, options?: RoutingMemoryCallOptions): Promise<RoutingMemoryMutationResult>;
    match(input: string | RoutingSignature, options?: RoutingMemoryCallOptions): Promise<RoutingMemoryMatch>;
    addExplicitMissionRule(input: string | RoutingSignature, options?: RoutingMemoryCallOptions & {
        readonly id?: string;
    }): Promise<RoutingMemoryRuleWrite>;
    addExplicitRule(input: string | RoutingSignature, action: RoutingAction, options?: RoutingMemoryCallOptions & {
        readonly id?: string;
    }): Promise<RoutingMemoryRuleWrite>;
    setRuleEnabled(ruleId: string, enabled: boolean, options?: RoutingMemoryCallOptions): Promise<RoutingMemoryMutationResult>;
    observeChoice(input: string | RoutingSignature, action: RoutingAction, options?: RoutingMemoryCallOptions): Promise<ObserveChoiceResult>;
    deleteRule(ruleId: string, options?: RoutingMemoryCallOptions): Promise<RoutingMemoryMutationResult>;
    forgetLearned(options?: RoutingMemoryCallOptions): Promise<RoutingMemoryMutationResult>;
    reset(options?: RoutingMemoryCallOptions): Promise<RoutingMemoryMutationResult>;
    listViews(): Promise<readonly RoutingMemoryRuleView[]>;
    backup(destination?: string): Promise<string>;
    restore(sourceOrGeneration: string | number, options?: RoutingMemoryCallOptions): Promise<RoutingMemoryMutationResult>;
    restoreBackup(source: string, options?: RoutingMemoryCallOptions): Promise<RoutingMemoryMutationResult>;
    private inputSignature;
    private resolvePolicy;
    private none;
    private compareCandidates;
    private noopObserve;
    private mutate;
    private enqueue;
    private loadUnlocked;
    private readActive;
    private readCurrentForMutation;
    private commit;
    private readHistory;
    private pruneHistory;
    private repairActive;
    private clearHistory;
    private apply;
    private timestamp;
}
export {};