import { type PhaseHint } from '../strategyLoader';
export interface StrategyVersionFingerprint {
    strategyFile: string;
    strategyContentHash: string;
    /**
     * Hash of the targeted phase_hints entry's normalized form. Empty string
     * for fingerprints that don't pin a specific hint (e.g., scene-level
     * fingerprints used during snapshot capture).
     */
    patchFingerprint: string;
    /** Optional: id of the targeted phase_hints entry (for human auditing). */
    phaseHintId?: string;
    /** Commit on `main` where this version was last observed. */
    gitCommit?: string;
    appliedAt: number;
}
/**
 * Frozen view of a scene's strategy + phase hints, captured at analyze()
 * start and released on completion.
 */
export interface RunSnapshot {
    sessionId: string;
    sceneType: string;
    strategyContent: string | undefined;
    phaseHints: PhaseHint[];
    fingerprint: StrategyVersionFingerprint;
}
export type DriftStatus = 'none' | 'whole_file_only' | 'patch_changed' | 'patch_deleted';
/**
 * Resolve the strategy file path through the loader's registry rather than
 * naively joining `${scene}.strategy.md`. Compound scene ids use underscores
 * (`touch_tracking`) while their file basenames use hyphens
 * (`touch-tracking.strategy.md`); the naive form silently returned an empty
 * hash for those scenes. Falls back to the legacy join for unknown scenes
 * so misconfigured tests still get a deterministic-looking path.
 */
declare function strategyFilePath(scene: string): string;
/**
 * Stable sha256 of the strategy file content. Returns empty string if the
 * file is missing — callers should treat that as "no fingerprint" rather
 * than blow up the analysis path.
 */
export declare function computeStrategyContentHash(scene: string): string;
/**
 * Hash a phase_hints entry by its shared canonical form. Sorted keys +
 * lower-case strings + array sort keep the hash stable across cosmetic
 * reordering of the same content.
 *
 * Intentionally excludes `id` (it is derived from the fingerprint —
 * including it would be circular) so that a freshly-rendered auto-patch
 * by `phaseHintsRenderer` produces the *same* fingerprint that
 * `detectDrift` computes off the on-disk hint after the patch lands.
 */
export declare function computePatchFingerprint(hint: PhaseHint): string;
/**
 * Compare a stored fingerprint against the current on-disk state and report
 * which drift tier we're in. Pure function — does not mutate anything.
 */
export declare function detectDrift(input: {
    fingerprint: StrategyVersionFingerprint;
    currentHints: ReadonlyArray<PhaseHint>;
    currentContentHash: string;
}): DriftStatus;
/**
 * Per-session snapshot store. Implemented as a class so a test can spin up
 * a fresh instance instead of leaning on a module-level singleton.
 *
 * Production code should use the exported `runSnapshots` instance.
 */
export declare class RunSnapshotRegistry {
    private snapshots;
    capture(sessionId: string, sceneType: string): RunSnapshot;
    release(sessionId: string): void;
    get(sessionId: string): RunSnapshot | undefined;
    /** Number of active snapshots — surfaced for the monitoring PR. */
    size(): number;
}
/** Process-wide snapshot store. Tests should construct their own instance. */
export declare const runSnapshots: RunSnapshotRegistry;
export declare const __testing: {
    strategyFilePath: typeof strategyFilePath;
    STRATEGIES_DIR: string;
};
export {};
//# sourceMappingURL=strategyFingerprint.d.ts.map