import type { CliPermissionMode } from "../config/schema.js";
import type { EpisodeSummary } from "../episodes/protocol.js";
import type { ModelSlotManager } from "../slots/slot-manager.js";
import type { SlotName } from "../slots/types.js";
import type { OrchestratorTask } from "./types.js";
import { SlotWorker } from "./worker.js";
export declare class OrchestratorKernel {
    private slots;
    private workers;
    private episodes;
    private cliPermissions?;
    constructor(slots: ModelSlotManager, cliPermissions?: Record<string, CliPermissionMode>);
    private initWorkers;
    dispatch(task: OrchestratorTask): Promise<EpisodeSummary>;
    dispatchStreaming(task: OrchestratorTask, signal?: AbortSignal): AsyncGenerator<{
        type: "text" | "thinking" | "tool_use" | "error" | "done";
        content: string;
        slot: SlotName;
        tokens?: {
            input: number;
            output: number;
        };
        toolCall?: {
            id: string;
            name: string;
            status: "start" | "end";
        };
    }>;
    orchestrate(tasks: OrchestratorTask[]): Promise<EpisodeSummary[]>;
    /**
     * Handoff: dispatch to a specific slot with prior episode(s) as context.
     * This is the thread composition primitive described in the Slate blog:
     * one thread's episode becomes another thread's input context.
     */
    handoff(fromEpisodes: EpisodeSummary | EpisodeSummary[], toSlot: SlotName, prompt: string, systemPrompt?: string): Promise<EpisodeSummary>;
    /**
     * RLM-style retrieval: find past episodes relevant to the current prompt.
     * Uses keyword overlap scoring to surface the most contextually relevant
     * episodes from session history.
     */
    retrieveRelevantEpisodes(prompt: string, maxCount?: number): EpisodeSummary[];
    integrate(episodes: EpisodeSummary[]): void;
    getEpisodes(): readonly EpisodeSummary[];
    getWorker(slot: SlotName): SlotWorker | undefined;
    refreshWorkers(): void;
    /**
     * Inject input episodes into the task prompt for thread composition.
     * When a task includes inputEpisodes, their compressed content is
     * prepended to the prompt so the receiving thread inherits the
     * conclusions and work history of prior threads.
     */
    private enrichTaskWithEpisodes;
}
//# sourceMappingURL=kernel.d.ts.map