import type { AgentMessage } from '@earendil-works/pi-agent-core';
import type { Api, Model } from '@earendil-works/pi-ai/compat';
import { IdleCompactionScheduler } from '../agent/memory/idle-compaction-scheduler.js';
import type { ResolvedCompactionPolicy } from '../agent/memory/compaction-policy.js';
import type { Config } from '../config/schema.js';
import type { SessionAgentConfig } from './config-types.js';
import { type CompactionConfig, type CompactionExecutionOptions, type CompactionResult } from '../agent/memory/compaction.js';
import { type WindowConfig } from '../agent/memory/window.js';
import { loadCompactionSourceSnapshot, type SessionMetadataSeed } from '../storage/sqlite/index.js';
import type { XopcSessionTranscriptV1 } from './transcript-format.js';
import { type TranscriptStoredRow, type XopcTranscriptContextEntry } from './session-context-for-llm.js';
import type { SessionMetadata, SessionDetail, SessionListQuery, PaginatedResult, GlobalSessionStats, ExportFormat, CompactionBoundarySummary } from './types.js';
import { SessionStatus } from './types.js';
import type { Message } from './types.js';
import type { SessionTranscriptUpdate } from './transcript-events.js';
import { type SessionFindResult } from './session-find.js';
export interface SessionStoreOptions {
    config: Config;
}
export interface SessionCompactionHooks {
    before?: (event: {
        conversationId: string;
        messageCount: number;
        tokenCount: number;
    }) => Promise<void> | void;
    after?: (event: {
        conversationId: string;
        messageCount: number;
        tokenCount: number;
        compactedCount: number;
    }) => Promise<void> | void;
}
export type ModelFallbackPreparation = 'prompt' | 'resume' | 'unsafe';
export interface ForkSessionAtTurnOptions {
    targetKey: string;
    lastTurnId: string;
    targetMetadata: SessionMetadataSeed;
}
export interface ForkSessionResult {
    conversationId: string;
    rowCount: number;
    lastTurnId?: string;
}
export interface CreateSessionFromRowsOptions {
    targetKey: string;
    cwd: string;
    metadata: SessionMetadataSeed & {
        agentId: string;
    };
    rows: TranscriptStoredRow[];
    config?: SessionAgentConfig;
}
export interface PreparedCompaction {
    conversationId: string;
    snapshot: NonNullable<ReturnType<typeof loadCompactionSourceSnapshot>>;
    result: CompactionResult;
}
export declare class SessionStore {
    private options;
    readonly idleCompaction: IdleCompactionScheduler;
    private window;
    private compactor;
    private compactionHooks;
    private readonly compactionTails;
    private compactionCheckpoint;
    private clearCompactionCheckpoint;
    constructor(options: SessionStoreOptions, windowConfig?: Partial<WindowConfig>, compactionConfig?: Partial<CompactionConfig>);
    /** Refresh policy for subsequent compactions without changing an in-flight request. */
    updateConfig(config: Config): void;
    setCompactionHooks(hooks: SessionCompactionHooks): void;
    private runCompactionHook;
    private resolveWorkspaceCwd;
    private runStoreMutation;
    private runCompactionExclusive;
    initialize(): Promise<void>;
    getSessionsRoot(): string;
    resolveTranscriptPath(conversationId: string, options?: {
        metadata?: SessionMetadataSeed;
    }): Promise<{
        transcriptId: string;
        conversationId: string;
    }>;
    appendTranscriptMessage(conversationId: string, message: AgentMessage, options?: {
        metadata?: SessionMetadataSeed;
    }): Promise<void>;
    getByAgent(agentId: string): Promise<SessionMetadata[]>;
    getByAccount(accountId: string): Promise<SessionMetadata[]>;
    getByPeer(peerKind: string, peerId: string): Promise<SessionMetadata[]>;
    getMainSession(channel: string, accountId: string): Promise<SessionMetadata | null>;
    refreshIndex(): Promise<void>;
    list(query?: SessionListQuery): Promise<PaginatedResult<SessionMetadata>>;
    get(key: string, options?: {
        includeTranscriptSummary?: boolean;
        includeTranscriptRows?: boolean;
    }): Promise<SessionDetail | null>;
    getMessagePage(key: string, options?: {
        offset?: number;
        limit?: number;
        before?: string;
        includeTranscriptSummary?: boolean;
        includeTranscriptRows?: boolean;
        includeContextRows?: boolean;
        compact?: boolean;
    }): Promise<{
        session: SessionDetail;
        pagination: {
            total: number;
            limit: number;
            offset: number;
            hasMore: boolean;
            before?: string;
            nextBeforeCursor?: string;
            revision?: number;
        };
    } | null>;
    private buildSessionDetail;
    loadTranscriptRows(key: string): Promise<TranscriptStoredRow[]>;
    loadTranscriptHistoryRows(key: string): Promise<TranscriptStoredRow[]>;
    prepareModelFallback(key: string, rowsBeforeAttempt: readonly TranscriptStoredRow[]): Promise<ModelFallbackPreparation>;
    getMetadata(key: string): Promise<SessionMetadata | null>;
    resolveKeyByTranscriptId(transcriptId: string): Promise<string | null>;
    updateMetadata(key: string, updates: Partial<SessionMetadata>): Promise<void>;
    reset(key: string): Promise<{
        transcriptId: string;
        previousTranscriptId: string;
    } | null>;
    delete(key: string): Promise<boolean>;
    deleteMany(keys: string[]): Promise<{
        success: string[];
        failed: string[];
    }>;
    setStatus(key: string, status: SessionStatus): Promise<void>;
    archive(key: string): Promise<void>;
    unarchive(key: string): Promise<void>;
    pin(key: string): Promise<void>;
    unpin(key: string): Promise<void>;
    loadMessages(_key: string, _options?: {
        fromArchive?: boolean;
    }): Promise<AgentMessage[]>;
    loadTranscriptDocument(key: string): Promise<XopcSessionTranscriptV1 | null>;
    syncEmbeddedTranscriptUpdate(update: SessionTranscriptUpdate): Promise<void>;
    appendTranscriptContextEntry(key: string, entry: Omit<XopcTranscriptContextEntry, 'kind'> & Partial<Pick<XopcTranscriptContextEntry, 'kind'>>): Promise<void>;
    appendTranscriptLabelEntry(key: string, entry: {
        targetId: string;
        label?: string;
    }): Promise<void>;
    appendTranscriptCustomEntry(key: string, entry: {
        customType: string;
        data?: unknown;
    }): Promise<void>;
    appendTranscriptCustomMessageEntry(key: string, entry: {
        expectedTranscriptId?: string;
        customType: string;
        content?: string | unknown[];
        display?: boolean;
        details?: unknown;
    }): Promise<void>;
    appendTranscriptBashExecutionEntry(key: string, entry: {
        command: string;
        output?: string;
        exitCode?: number | null;
        signal?: string | null;
        excludeFromContext?: boolean;
        truncated?: boolean;
        fullOutputPath?: string;
    }): Promise<void>;
    saveMessages(key: string, messages: AgentMessage[], options?: {
        metadata?: SessionMetadataSeed;
    }): Promise<void>;
    deleteUserRound(key: string, userRoundIndex: number): Promise<{
        deleted: number;
        removedMessages: AgentMessage[];
        remainingMessages: AgentMessage[];
    } | null>;
    getWindowStats(messages: AgentMessage[]): {
        total: number;
        system: number;
        user: number;
        assistant: number;
        tool: number;
        needsTrim: boolean;
    };
    applyCompaction(key: string, result: CompactionResult, expectedSnapshot?: import("../storage/sqlite/transcript-repository.js").CompactionSourceSnapshot): Promise<AgentMessage[]>;
    /** Generate against a fixed snapshot without holding the foreground compaction queue. */
    prepareCompaction(key: string, model: Model<Api>, policy: ResolvedCompactionPolicy, signal: AbortSignal): Promise<PreparedCompaction>;
    commitCompaction(candidate: PreparedCompaction, isCurrent: () => boolean): Promise<boolean>;
    compact(key: string, messages: AgentMessage[], model: Model<Api>, instructions?: string, force?: boolean, executionOptions?: CompactionExecutionOptions): Promise<CompactionResult>;
    getCompactionStats(key: string): Promise<{
        compactionCount: number;
        totalTokensBefore: number;
        totalTokensAfter: number;
        auditPassedCount: number;
        auditDegradedCount: number;
        auditMissingItemsFound: number;
        lastCompactionAt: string;
    }>;
    listCompactionBoundaries(key: string): Promise<CompactionBoundarySummary[]>;
    restoreBeforeCompactionBoundary(key: string, compactionId: string): Promise<void>;
    deleteSession(key: string): Promise<boolean>;
    load(key: string, options?: {
        fromArchive?: boolean;
    }): Promise<AgentMessage[]>;
    estimateTokenUsage(_key: string, messages: AgentMessage[]): Promise<number>;
    searchInSession(key: string, keyword: string): Promise<Message[]>;
    findInSession(key: string, query: string, limit?: number): Promise<SessionFindResult | null>;
    recallSession(key: string, query: string, options?: {
        limit?: number;
        beforeSeq?: number;
    }): import("../storage/sqlite/transcript-repository.js").SessionTranscriptRecallMatch[];
    exportSession(key: string, format: ExportFormat): Promise<string>;
    importSessionExport(targetKey: string, jsonContent: string): Promise<{
        conversationId: string;
        rowCount: number;
    }>;
    forkSession(sourceKey: string, targetKey: string): Promise<{
        conversationId: string;
        rowCount: number;
    }>;
    createSessionFromRows(options: CreateSessionFromRowsOptions): Promise<{
        conversationId: string;
        rowCount: number;
    }>;
    forkSessionRows(sourceKey: string, targetKey: string, options?: {
        throughRow?: number;
    }): Promise<{
        conversationId: string;
        rowCount: number;
    }>;
    /**
     * Atomically copy a completed turn prefix into a new session, including the
     * source session's per-session agent configuration.
     */
    forkSessionAtTurn(sourceKey: string, options: ForkSessionAtTurnOptions): Promise<ForkSessionResult>;
    getStats(): Promise<GlobalSessionStats>;
    archiveOld(olderThanDays: number): Promise<number>;
    estimateTokens(messages: AgentMessage[]): number;
    private loadDisplayMessages;
    private paginateDisplayMessages;
    private messageContent;
    private extractTextContent;
    private injectPostCompactionContext;
    private convertMessages;
}