import type { AgentMessage } from "@earendil-works/pi-agent-core";
import { type ProviderHeaders } from "@earendil-works/pi-ai";
import { type ContextRemaining } from "./window-budget.ts";
import type { CompactionResult, CustomMessageEntryDraft, ExtensionAPI, ExtensionContext, ExtensionEvent, SessionBeforeCompactEvent, SessionEntry } from "@earendil-works/pi-coding-agent";
import type { ContextManagementMode } from "../adapter/activation/config.ts";
import { type CodexContextManagementMessageDetails, type ContextWindowCompactionDetails, type ContextWindowIdentity } from "./messages.ts";
export interface StartContextWindowOptions {
    signal?: AbortSignal | undefined;
    mode?: ContextManagementMode | undefined;
    trimPreviousWindow: boolean;
    sourceLeafId?: string | undefined;
}
type ThreadHintLoader = (ctx: ExtensionContext, mode: ContextManagementMode, signal?: AbortSignal) => Promise<string | undefined>;
export declare class CodexContextWindowManager {
    private identity;
    private readonly budget;
    private rolloverPending;
    private rolloverCompaction;
    private manualCheckpoint;
    private promptedManualCheckpoint;
    private trimPendingWindowId;
    private readonly loadThreadHint;
    private readonly beforeWindowStart;
    constructor(loadThreadHint?: ThreadHintLoader, beforeWindowStart?: (ctx: ExtensionContext, options: Pick<StartContextWindowOptions, "sourceLeafId" | "signal">) => Promise<void>);
    reset(): void;
    currentIdentity(): ContextWindowIdentity | undefined;
    restore(entries: readonly SessionEntry[]): void;
    ensureInitialized(pi: ExtensionAPI, ctx: ExtensionContext, active: boolean): void;
    project(messages: readonly AgentMessage[], mode: ContextManagementMode, activeEntries?: readonly SessionEntry[], allEntries?: readonly SessionEntry[]): AgentMessage[];
    scheduleRolloverCompaction(): boolean;
    cancelScheduledCompaction(): void;
    finishTurn(ctx: ExtensionContext, continueWindow: () => Promise<unknown>): boolean;
    completeRolloverCompaction(pi: ExtensionAPI, ctx: ExtensionContext, mode: ContextManagementMode): Promise<void>;
    isRolloverCompactionRunning(): boolean;
    startNewWindow(pi: ExtensionAPI, ctx: ExtensionContext, options: StartContextWindowOptions): Promise<boolean>;
    recordBudget(ctx: ExtensionContext, mode: ContextManagementMode, contextTokens?: number): CustomMessageEntryDraft | undefined;
    remaining(ctx: ExtensionContext, contextTokens?: number): ContextRemaining;
    prepareCompaction(event: SessionBeforeCompactEvent, mode: ContextManagementMode, compactOnRollover?: boolean): {
        cancel: true;
    } | {
        compaction: CompactionResult<ContextWindowCompactionDetails>;
    } | undefined;
    finishManualCheckpointRequest(pi: ExtensionAPI, ctx: Pick<ExtensionContext, "isIdle" | "ui" | "sessionManager">, event: Extract<ExtensionEvent, {
        type: "session_compact_failed";
    }>, active: boolean): boolean;
    beginPromptedManualCheckpointRun(): void;
    finishPromptedManualCheckpoint(ctx: Pick<ExtensionContext, "sessionManager">, active: boolean): "ready" | "missing" | undefined;
    recordCompaction(details: unknown): void;
    createCompaction(event: SessionBeforeCompactEvent): CompactionResult<ContextWindowCompactionDetails>;
    rewritePayload(payload: unknown, ctx: ExtensionContext): unknown;
    rewriteHeaders(headers: ProviderHeaders, ctx: ExtensionContext): void;
    private sendWindowMessage;
}
/** Apply the same explicit retirement boundary to compaction and native replay. */
export declare function projectContextWindowBranch(entries: SessionEntry[]): SessionEntry[];
export declare function findLatestWindowBoundaryEntry(entries: readonly SessionEntry[]): (Extract<SessionEntry, {
    type: "custom_message";
}> & {
    details: CodexContextManagementMessageDetails;
}) | undefined;
export {};