/**
 * Cognition engine — 8-phase dream consolidation cycle.
 *
 * Implements the full dream cycle as pure functions: storage-agnostic,
 * provider-injected. Each phase is isolated so a single phase failure
 * does not abort the whole cycle.
 *
 * Phases:
 *   Phase A (NREM analog — compression and binding):
 *     1. Cluster   — route unprocessed observations to nearest memories
 *     2. Refine    — update memory definitions from new observations
 *     3. Create    — promote unclustered observations to new memories
 *
 *   Phase B (REM analog — cross-association and integration):
 *     4. Connect   — discover edges between recently active memories
 *     5. Score     — FSRS passive review for memories in review/learning
 *     6. Abstract  — cross-domain pattern synthesis
 *     7. Hindsight — audit entrenched memories for silent confidence hardening
 *     8. Report    — narrative summary of the full cycle
 *
 * Exported entry points:
 *   dreamPhaseA()      — run NREM phases only (cluster -> refine -> create)
 *   dreamPhaseB()      — run REM phases only  (connect -> score -> abstract -> hindsight -> report)
 *   dreamConsolidate() — run all 8 phases (backward-compatible)
 */
import type { CortexStore } from '../core/store.js';
import type { EmbedProvider } from '../core/embed.js';
import type { LLMProvider } from '../core/llm.js';
import type { Observation } from '../core/types.js';
import type { PESaturationResult } from './graph-metrics.js';
export interface DreamResult {
    phases: {
        cluster: {
            clustered: number;
            unclustered: number;
        };
        refine: {
            refined: number;
        };
        create: {
            created: number;
        };
        connect: {
            edges_discovered: number;
        };
        score: {
            scored: number;
        };
        report: {
            text: string;
        };
        abstract: {
            abstractions: number;
        };
        hindsight?: {
            reviewed: number;
            revised: number;
        };
    };
    total_processed: number;
    duration_ms: number;
    /** clustered / (clustered + unclustered) */
    integration_rate: number;
    /**
     * Algebraic connectivity of the memory graph (Fiedler value).
     * Higher = more integrated knowledge. 0 = disconnected or too few nodes.
     * Computed during dreamConsolidate() and dreamPhaseB().
     * Undefined when running dreamPhaseA() alone or when skip_fiedler is set.
     */
    fiedler_value?: number;
    /**
     * Prediction-error saturation analysis for identity observations.
     * Undefined when store does not support the required queries or skip_pe_saturation is set.
     */
    pe_saturation?: PESaturationResult;
    /** Count of catch sites that swallowed an error during this cycle. */
    failures: number;
}
export interface DreamOptions {
    /** Max observations to process in cluster phase (default: 50) */
    observation_limit?: number;
    /** Max unclustered to create as memories (default: 10) */
    create_limit?: number;
    /** Max abstraction attempts in REM phase (default: 5) */
    abstraction_attempts?: number;
    /** Similarity threshold for clustering (default: 0.70) */
    cluster_threshold?: number;
    /** Similarity threshold for detecting duplicate abstractions (default: 0.88) */
    abstraction_novelty_threshold?: number;
    /** Namespace config merge threshold */
    similarity_merge?: number;
    /** Namespace config link threshold */
    similarity_link?: number;
    /**
     * If true, skip Fiedler value computation during dreamConsolidate/dreamPhaseB.
     * Useful for large graphs where the O(n*iter) pass is too slow.
     */
    skip_fiedler?: boolean;
    /**
     * If true, skip PE saturation detection.
     */
    skip_pe_saturation?: boolean;
    /**
     * Dream strategy:
     * - 'sequential' (default): many small LLM calls, each with a local view.
     * - 'long-context': one large LLM call per phase with the full memory graph visible.
     *   Requires a model with a large context window (e.g. kimi, gemini).
     *   Produces better edge discovery and abstractions on larger memory graphs.
     */
    strategy?: 'sequential' | 'long-context';
    /**
     * Max memories to include in a single long-context pass (default: 200).
     * Reduce if hitting token limits with a smaller model.
     */
    long_context_memory_limit?: number;
    /**
     * If true, skip the hindsight review phase.
     */
    skip_hindsight?: boolean;
    /**
     * Max number of entrenched memories to audit in the hindsight phase (default: 5).
     * Each memory requires one LLM call, so keep this low for cost/latency.
     */
    hindsight_max_review?: number;
    /**
     * Minimum FSRS stability (days) for a memory to be a hindsight candidate (default: 21).
     * Memories below this threshold are not yet entrenched enough to warrant review.
     */
    hindsight_stability_threshold?: number;
    /**
     * Minimum number of FSRS reps for a hindsight candidate (default: 4).
     * Ensures the memory has been reinforced multiple times before being questioned.
     */
    hindsight_min_reps?: number;
}
export interface ClusterPhaseResult {
    clustered: number;
    unclustered: number;
    /** Observations that had no near-enough memory to cluster into. */
    unclusteredObs: Observation[];
    /** Content from clustered observations, keyed by memory ID. Used by Phase 2. */
    clusteredEvidence: Map<string, string[]>;
}
export interface RefinePhaseResult {
    refined: number;
}
export interface CreatePhaseResult {
    created: number;
}
export interface ConnectPhaseResult {
    edges_discovered: number;
}
export interface ScorePhaseResult {
    scored: number;
}
export interface AbstractPhaseResult {
    abstractions: number;
}
export interface ReportPhaseResult {
    text: string;
}
export interface HindsightPhaseResult {
    /** Number of entrenched memories audited. */
    reviewed: number;
    /** Number of memories where confidence was reduced or definition was revised. */
    revised: number;
}
/**
 * Phase A (NREM analog): compression and binding.
 *
 * Run during or right after sessions to compress raw observations into the
 * memory graph. Does not perform cross-association or scoring — those are
 * Phase B concerns.
 *
 * Phases executed: Cluster -> Refine -> Create
 */
export declare function dreamPhaseA(store: CortexStore, embed: EmbedProvider, llm: LLMProvider, options?: DreamOptions): Promise<{
    cluster: ClusterPhaseResult;
    refine: RefinePhaseResult;
    create: CreatePhaseResult;
    failures: number;
}>;
/**
 * Phase B (REM analog): cross-association and integration.
 *
 * Run in cron sessions for deep integration: edge discovery, FSRS scoring,
 * cross-domain abstraction, hindsight review, and report generation.
 *
 * Also computes the Fiedler value (graph health) and PE saturation unless
 * suppressed via options.skip_fiedler / options.skip_pe_saturation.
 *
 * Phases executed: Connect -> Score -> Abstract -> Hindsight -> Report
 */
export declare function dreamPhaseB(store: CortexStore, embed: EmbedProvider, llm: LLMProvider, options?: DreamOptions): Promise<{
    connect: ConnectPhaseResult;
    score: ScorePhaseResult;
    abstract: AbstractPhaseResult;
    hindsight: HindsightPhaseResult;
    report: ReportPhaseResult;
    fiedler_value: number | undefined;
    pe_saturation: PESaturationResult | undefined;
    failures: number;
}>;
/**
 * Run the full 8-phase dream consolidation cycle.
 *
 * Phase ordering:
 *   1 Cluster -> 2 Refine -> 3 Create -> 4 Connect -> 5 Score -> 6 Abstract -> 7 Hindsight -> 8 Report
 *
 * Report runs last so it can include all phase stats, Fiedler value, PE, and hindsight results.
 * A phase error is caught internally — the cycle continues with degraded output.
 *
 * Backward compatible: existing callers using dreamConsolidate() are unaffected.
 */
export declare function dreamConsolidate(store: CortexStore, embed: EmbedProvider, llm: LLMProvider, options?: DreamOptions): Promise<DreamResult>;
//# sourceMappingURL=cognition.d.ts.map