import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
import { type WorkflowRunStore } from "../workflows/store.js";
import type { AgentStepContract, ConversationRange } from "../workflows/types.js";
import { type MessageEndEventLike, type MessageStartEventLike, type MessageUpdateEventLike, type ToolExecutionEndEventLike, type ToolExecutionStartEventLike, type ToolExecutionUpdateEventLike, type TurnEndEventLike, type TurnStartEventLike } from "./session-events.js";
type RecordedEntry = {
    id: string;
    entry: Record<string, unknown>;
    claimed: boolean;
};
/**
 * Records both settled Pi entries and normalized temporal events into one run
 * bundle. The hot event path only stamps and queues records; filesystem work
 * runs on a separate ordered append chain.
 */
export declare class SessionRecorder {
    private readonly store;
    private readonly runDir;
    private readonly runId;
    private cursor;
    private readonly recorded;
    private readonly unclaimedEntries;
    private bound;
    private acceptingEntries;
    private acceptingEvents;
    private entryChain;
    private stopPromise;
    private nextEventSeq;
    private nextTurnId;
    private nextMessageId;
    private currentAttempt;
    private currentTurn;
    private currentMessage;
    private lastFinishedAttempt;
    private finishPromise;
    private resolveFinish;
    private finishTimer;
    private readonly messageOwners;
    private readonly stableMessageOwners;
    private readonly toolOwners;
    private readonly turnToolCallIds;
    private eventQueue;
    private readonly pendingMessageEnds;
    private outstandingRecords;
    private outstandingBytes;
    private flushTimer;
    private flushPromise;
    private captureFailure;
    constructor(store: WorkflowRunStore, runDir: string, runId: string);
    bind(ctx: ExtensionContext): Promise<void>;
    /** Fix the owner before the executor delivers an agent-step prompt. */
    beginAttempt(contract: AgentStepContract): void;
    /** Release ownership of the turn that Pi has fully settled. */
    settleAttempt(): void;
    handleTurnStart(event: TurnStartEventLike): void;
    handleTurnEnd(event: TurnEndEventLike, ctx: ExtensionContext): Promise<void>;
    handleMessageStart(event: MessageStartEventLike, ctx: ExtensionContext): Promise<void>;
    handleMessageUpdate(event: MessageUpdateEventLike): void;
    handleMessageEnd(event: MessageEndEventLike): void;
    handleToolStart(event: ToolExecutionStartEventLike): void;
    handleToolUpdate(event: ToolExecutionUpdateEventLike): void;
    handleToolEnd(event: ToolExecutionEndEventLike): void;
    /** Flush new entries on the current branch into the bundle. */
    record(ctx: ExtensionContext): Promise<RecordedEntry[]>;
    /** Record durable entries, then release deferred message-end events in order. */
    synchronize(ctx: ExtensionContext): Promise<void>;
    /**
     * Finalize immediately when no Pi turn is active. Otherwise wait for
     * `turn_end`, which is the last documented lifecycle boundary needed to
     * include the workflow tool result and any following assistant output.
     */
    finish(): Promise<void>;
    stop(): Promise<void>;
    mark(): number;
    rangeSince(mark: number): ConversationRange | undefined;
    private ownerForMessage;
    private claimEntry;
    private enqueue;
    private queuedBytes;
    private scheduleFlush;
    private startFlush;
    private flushAllEvents;
    private clearFlushTimer;
    private failCapture;
}
export {};