import type { CompiledBuildPlan } from "../core/buildPlan.js";
import { type RecoveryDirective } from "../core/recovery.js";
import { type BuildRunningAction, type BuildWorkerBudgetReservation } from "../core/buildExecution.js";
import { type GraphExecutionState } from "../core/scheduler.js";
export interface BuildWorkerRequest {
    schemaVersion: 1;
    requestRef: string;
    effectRequestRef: string;
    idempotencyKey: string;
    runId: string;
    planVersion: number;
    planHash: string;
    nodeId: string;
    visit: number;
    attempt: number;
    handler: "inspect" | "design" | "implement";
    toolPolicy: "read-only" | "declared-writes";
    activeTools: readonly string[];
    declaredWriteSet: readonly string[];
    declaredOutputContracts: readonly Readonly<{
        id: string;
        kind: "artifact" | "file-set" | "evidence";
        validation: "exists" | "sha256" | "structured" | "reviewed-command" | "human-review";
    }>[];
    workspace: {
        kind: "shared";
    } | {
        kind: "owned-worktree";
        intentId: string;
        runId: string;
        planVersion: number;
        planHash: string;
        ownerNodeId: string;
        baseSha: string;
        ownershipReceiptHash: string;
        worktreePath: string;
    };
    timeoutMs: number;
    outerBuildBudgetRef: string;
    prompt: string;
}
export interface BuildWorkerReceipt {
    schemaVersion: 1;
    requestRef: string;
    outcome: "succeeded" | "failed";
    worker: {
        provider: string;
        model: string;
        family?: string;
    };
    claimedOutputPaths: readonly string[];
    outputPayloads: readonly Readonly<{
        contractId: string;
        content: string;
    }>[];
    summary: string;
    usage: {
        inputTokens: number | "unknown";
        outputTokens: number | "unknown";
        observedUsd: number | "unknown";
    };
    completedAt: string;
}
export interface BuildWorkerAdapter {
    invoke(request: Readonly<BuildWorkerRequest>, options: Readonly<{
        signal: AbortSignal;
    }>): Promise<unknown>;
    reconcile(request: Readonly<BuildWorkerRequest>, options: Readonly<{
        signal: AbortSignal;
    }>): Promise<unknown | undefined>;
}
export declare function createBuildWorkerRequest(compiled: Readonly<CompiledBuildPlan>, state: Readonly<GraphExecutionState>, actionValue: Readonly<BuildRunningAction>, optionsValue: Readonly<{
    reservation: Readonly<BuildWorkerBudgetReservation>;
}>): BuildWorkerRequest;
/**
 * Create the narrow DEBUG → BUILD repair handoff. It preserves the approved
 * plan version and exposes only the typed directive plus its declared repair
 * scope; diagnosis prose and ambient conversation never enter the worker.
 */
export declare function createRecoveryBuildWorkerRequest(inputValue: Readonly<{
    runId: string;
    planVersion: number;
    planHash: string;
    directive: Readonly<RecoveryDirective>;
    outerEffectRequestRef: string;
    timeoutMs: number;
}>): BuildWorkerRequest;
export declare function validateBuildWorkerReceipt(value: unknown, request: Readonly<BuildWorkerRequest>): BuildWorkerReceipt;
export declare function dispatchBuildWorker(request: Readonly<BuildWorkerRequest>, intentValue: unknown, adapter: Readonly<BuildWorkerAdapter>, options?: Readonly<{
    signal?: AbortSignal;
}>): Promise<BuildWorkerReceipt>;
export declare function reconcileBuildWorker(request: Readonly<BuildWorkerRequest>, adapter: Readonly<BuildWorkerAdapter>, options?: Readonly<{
    signal?: AbortSignal;
}>): Promise<BuildWorkerReceipt | undefined>;
/** Run already-guarded worker tasks with a deterministic bounded pool and stable result ordering. */
export declare function runBoundedBuildWorkerTasks<T>(tasksValue: readonly (() => Promise<T>)[], maxConcurrency: number): Promise<readonly T[]>;