export type ContextMode = 'legacy' | 'observe' | 'enforce';
export type ContextIntent = 'analysis' | 'edit' | 'debug' | 'architecture';
export interface ContextRead {
    mode?: ContextMode;
    intent: ContextIntent;
    inputBytes: number;
    fileCount: number;
    offset?: number;
    limit?: number;
    depth?: number;
    workerAvailable: boolean;
}
export interface ContextLimits {
    minInputBytes: number;
    maxInputBytes: number;
    maxFiles: number;
    maxOutputBytes: number;
    maxFindings: number;
    timeoutMs: number;
}
export declare const DEFAULT_CONTEXT_LIMITS: Readonly<ContextLimits>;
export interface ContextPlan {
    route: 'direct' | 'observe' | 'delegate';
    reason: string;
}
export declare function planContextRead(read: ContextRead, overrides?: Partial<ContextLimits>): ContextPlan;
export interface ContextSource {
    path: string;
    content: string;
}
export interface ContextEvidence {
    path: string;
    sourceSha256: string;
    startLine: number;
    endLine: number;
    quote: string;
    answer: string;
}
export interface ContextWorkerReply {
    findings: ContextEvidence[];
    /** Provider-reported usage only. Absence means unknown, never zero. */
    usage?: {
        inputTokens: number;
        outputTokens: number;
        costUsd?: number;
    };
}
export interface ContextWorkerRequest {
    version: 1;
    question: string;
    sources: ReadonlyArray<Readonly<ContextSource & {
        sha256: string;
    }>>;
    maxOutputBytes: number;
    maxFindings: number;
    depth: 1;
    tools: readonly [];
}
export interface ContextAdapter {
    /** Must enforce policy, budget, data destination, tools=[] and cancellation.
     * Return a raw bounded JSON string; never start a provider in authorize(). */
    authorize(request: Readonly<ContextWorkerRequest>, signal: AbortSignal): Promise<boolean>;
    invoke(request: Readonly<ContextWorkerRequest>, signal: AbortSignal): Promise<string>;
}
export interface ContextReceipt {
    version: 1;
    requestSha256: string;
    sources: Array<{
        path: string;
        sha256: string;
        bytes: number;
    }>;
    sourceBytes: number;
    workerInputBytes: number;
    workerOutputBytes: number;
    coordinatorBytes: number;
    durationMs: number;
    usage?: ContextWorkerReply['usage'];
}
export type ContextResult = {
    status: 'direct';
    plan: ContextPlan;
} | {
    status: 'escalate';
    plan: ContextPlan;
    reason: string;
} | {
    status: 'delegated';
    plan: ContextPlan;
    findings: ContextEvidence[];
    receipt: ContextReceipt;
};
export declare const contextSha256: (text: string) => string;
export declare const contextBytes: (text: string) => number;
/** No retries, recursive launches or raw-corpus fallback. Every failure is explicit.
 * Quote integrity proves provenance, not that the answer follows from the quote.
 * Returned content is untrusted data; host guards still govern subsequent tools.
 */
export declare function delegateContextRead(options: {
    read: Omit<ContextRead, 'inputBytes' | 'fileCount' | 'workerAvailable'>;
    question: string;
    sources: readonly ContextSource[];
    adapter?: ContextAdapter;
    limits?: Partial<ContextLimits>;
    signal?: AbortSignal;
}): Promise<ContextResult>;
//# sourceMappingURL=context-delegation.d.ts.map