export interface DecisionNode {
    node_kind: "decision";
    id: string;
    author?: string | null;
    author_trust?: "extracted" | "confirmed" | null;
    statement: string;
    rationale: string | null;
    rationale_trust?: "extracted" | "confirmed" | null;
    rationale_missing: boolean;
    scope: string;
    component_ref: string;
    alternatives_rejected: string[];
    status: "candidate" | "active" | "superseded" | "contested";
    contested_by?: string | null;
    contested_reason?: string | null;
    superseded_by: string | null;
    created_at: string;
    embedding?: number[] | null;
}
export interface EvidenceNode {
    node_kind: "evidence";
    id: string;
    type: "quant" | "qual" | "imported";
    source_ref: string;
    result_summary: string;
    confidence: number | "low";
    confounds: string[];
    timestamp: string;
}
export interface SourceNode {
    node_kind: "source";
    id: string;
    kind: string;
    ref: string;
    commit_hashes?: string[];
    thread_count?: number;
    created_at: string;
}
export type GraphNode = DecisionNode | EvidenceNode | SourceNode;
export type AddEvidenceResult = {
    status: "created" | "existing";
    evidence: EvidenceNode;
} | {
    status: "not_found";
} | {
    status: "not_decision";
    node_kind: GraphNode["node_kind"];
};
export interface GraphEdge {
    id: string;
    from: string;
    to: string;
    type: "supersedes" | "scoped_alongside" | "supports" | "contradicts" | "derived_from";
    created_at: string;
}
export interface Embedder {
    embed(text: string): Promise<number[] | null>;
}
export declare class NullEmbedder implements Embedder {
    embed(_text: string): Promise<number[] | null>;
}
export declare class LexicalEmbedder implements Embedder {
    private dimensions;
    constructor(dimensions?: number);
    embed(text: string): Promise<number[]>;
}
export declare function cosineSimilarity(a: number[] | null | undefined, b: number[] | null | undefined): number;
export declare function similarityThreshold(): number;
export interface DecisionGraphStore {
    addNode(node: GraphNode): Promise<GraphNode>;
    addEvidenceWithEdge(decisionId: string, evidence: EvidenceNode, edge: GraphEdge): Promise<AddEvidenceResult>;
    getNode(id: string): Promise<GraphNode | null>;
    updateNode(id: string, patch: Partial<GraphNode>): Promise<GraphNode | null>;
    addEdge(edge: GraphEdge): Promise<GraphEdge>;
    listEdges(edgeType?: GraphEdge["type"]): Promise<GraphEdge[]>;
    neighbors(nodeId: string, edgeType?: GraphEdge["type"]): Promise<GraphNode[]>;
    listActiveDecisions(): Promise<DecisionNode[]>;
    listDecisions(status: DecisionNode["status"]): Promise<DecisionNode[]>;
    findSimilarActiveDecisions(node: DecisionNode, threshold: number, excludeId?: string): Promise<Array<{
        decision: DecisionNode;
        similarity: number;
    }>>;
}
export interface GapScanConfig {
    staleAfterDays: number;
    thinRationaleMinChars: number;
    weights: {
        coverage_gap: number;
        contested_with_evidence: number;
        contested: number;
        missing_rationale: number;
        thin_rationale: number;
        stale: number;
    };
}
export interface GapFinding {
    gap_type: "coverage_gap" | "missing_rationale" | "thin_rationale" | "contested" | "contested_with_evidence" | "stale";
    what: string;
    surfaced_by: string;
    decision_id: string | null;
    suggested_action: string;
    score: number;
}
export declare function gapScanConfig(): GapScanConfig;
export declare function scanGaps(store: DecisionGraphStore, opts: {
    use_cases?: string[];
    reference_components: Array<{
        name: string;
        source: string;
        traffic?: "high" | "normal";
    }>;
    config: GapScanConfig;
}): Promise<GapFinding[]>;
export declare function buildGapDigest(findings: GapFinding[]): {
    actionable: boolean;
    summary: string;
    findings: GapFinding[];
};
export declare function buildConflictPayload(a: DecisionNode, b: DecisionNode, similarity: number, evidenceFor: (id: string) => Promise<string[]>): Promise<{
    decision_a: object;
    decision_b: object;
    similarity: number;
    resolution_note: string;
}>;
export declare function discoverRepoStore(startDir: string): string | null;
export declare function decisionsHome(): string;
export declare function flagRationaleMissing<T extends {
    rationale?: string | null;
}>(input: T): T & {
    rationale_missing: boolean;
};
export declare function persistItemsIndependently<T, R>(items: T[], persist: (item: T, index: number) => Promise<R>): Promise<{
    results: R[];
    item_errors: Array<{
        index: number;
        error: string;
    }>;
}>;
export type ExtractionItem = {
    statement: string;
    rationale: string | null;
    alternatives_rejected: string[];
    source_ref?: string | null;
    author?: string | null;
};
export type ExtractionParseResult = {
    ok: true;
    items: ExtractionItem[];
    skipped: number;
} | {
    ok: false;
    error: string;
};
export declare function parseExtractionJson(raw: string): ExtractionParseResult;
export declare function buildExtractionPrompt(transcript: string): string;
export declare function buildImportExtractionPrompt(material: string, streamKind: string): string;
export declare class FsDecisionGraphStore implements DecisionGraphStore {
    private embedder;
    private writeLock;
    constructor(embedder?: Embedder);
    addNode(node: GraphNode): Promise<GraphNode>;
    getNode(id: string): Promise<GraphNode | null>;
    addEvidenceWithEdge(decisionId: string, evidence: EvidenceNode, edge: GraphEdge): Promise<AddEvidenceResult>;
    updateNode(id: string, patch: Partial<GraphNode>): Promise<GraphNode | null>;
    addEdge(edge: GraphEdge): Promise<GraphEdge>;
    listEdges(edgeType?: GraphEdge["type"]): Promise<GraphEdge[]>;
    neighbors(nodeId: string, edgeType?: GraphEdge["type"]): Promise<GraphNode[]>;
    listActiveDecisions(): Promise<DecisionNode[]>;
    findSimilarActiveDecisions(node: DecisionNode, threshold: number, excludeId?: string): Promise<Array<{
        decision: DecisionNode;
        similarity: number;
    }>>;
    listDecisions(status: DecisionNode["status"]): Promise<DecisionNode[]>;
    private prepareDecision;
    private withWriteLock;
}
export declare function recordConsultation(readerId: string, tool: string, decisions: DecisionNode[]): void;