/**
 * Reasoning NLP — Types, normalizer, accumulator, and JSONL writer for reasoning/thinking frames.
 *
 * Pipeline: provider output → ReasoningAccumulator.feed() → ReasoningFrame[] → reasoning.jsonl
 *
 * Visibility modes:
 *   off     — hidden (production default)
 *   summary — summarized reasoning exposed in chat (recommended)
 *   debug   — raw provider think/trace/status in dev logs only
 */
export type ReasoningVisibility = "off" | "summary" | "debug";
export type ReasoningSummaryMode = "auto" | "concise" | "detailed";
export type ReasoningFrameKind = "thinking" | "tool-activity" | "status" | "plan" | "unknown";
export interface ReasoningFrame {
    kind: ReasoningFrameKind;
    text: string;
    timestamp: string;
    provider?: string;
    elapsedMs?: number;
    raw?: string;
}
export declare class ReasoningAccumulator {
    private readonly provider?;
    private buffer;
    private inThinkBlock;
    private lastFrameTime;
    private readonly frames;
    constructor(provider?: string | undefined);
    /**
     * Feed a streaming chunk. Returns any completed frames.
     * Handles multi-line <think>...</think> and <thinking>...</thinking> blocks.
     */
    feed(chunk: string, visibility: ReasoningVisibility): ReasoningFrame[];
    /** Flush any pending think block content (e.g. on turn:end). */
    flush(): ReasoningFrame[];
    /** Get all accumulated frames. */
    allFrames(): readonly ReasoningFrame[];
    /** Get the latest thinking summary. */
    summary(): string | undefined;
    private makeFrame;
}
export interface ReasoningNormalizeOptions {
    visibility: ReasoningVisibility;
    summaryMode: ReasoningSummaryMode;
    provider?: string;
}
/**
 * Process a chunk of provider output and extract reasoning frames.
 * For streaming use, prefer ReasoningAccumulator instead.
 */
export declare function normalizeReasoningChunk(data: string, options: ReasoningNormalizeOptions): ReasoningFrame[];
/**
 * Extract a single-line thinking summary from the most recent thinking frame.
 */
export declare function extractThinkingSummary(frames: ReasoningFrame[]): string | undefined;
export interface ReasoningJsonlWriter {
    append(frames: ReasoningFrame[]): Promise<void>;
    flush(): Promise<void>;
}
export declare function createReasoningJsonlWriter(runPath: string): ReasoningJsonlWriter;
/**
 * Append reasoning frames to `.omk/runs/<runId>/reasoning.jsonl`.
 */
export declare function appendReasoningFrames(runDir: string, frames: ReasoningFrame[]): Promise<void>;
/**
 * Format a reasoning frame for terminal display.
 */
export declare function formatReasoningFrame(frame: ReasoningFrame): string;
/**
 * Format a compact thinking summary for HUD/status display.
 */
export declare function formatThinkingStatusLine(summary: string | undefined): string | undefined;
/**
 * Read reasoning.jsonl and return parsed frames.
 */
export declare function readReasoningFrames(runDir: string): Promise<ReasoningFrame[]>;
/**
 * Resolve reasoning visibility from env/flags.
 */
export declare function resolveReasoningVisibility(flag?: string, envOverride?: string): ReasoningVisibility;
/**
 * Resolve reasoning summary mode from env/flags.
 */
export declare function resolveReasoningSummaryMode(flag?: string, envOverride?: string): ReasoningSummaryMode;
