export type ResolvedRunnerConfig = import("../../shared/types.ts").AgentRunnerConfig;
export interface RunnerSubagentStep {
    /** Session id of the direct parent session for permission-system ask forwarding. */
    parentSessionId?: string;
    /** Resolved opt-in rules for native Pi child tool calls. */
    permissionRules?: import("./permissions.ts").PermissionRules;
    agent: string;
    task: string;
    runner?: ResolvedRunnerConfig;
    /** Resolved launch context for this child. */
    context?: "fresh" | "fork";
    importAsyncRoot?: {
        runId: string;
        asyncDir: string;
        resultPath: string;
        index: number;
    };
    phase?: string;
    label?: string;
    outputName?: string;
    structured?: boolean;
    cwd?: string;
    model?: string;
    thinking?: string;
    modelCandidates?: string[];
    tools?: string[];
    extensions?: string[];
    subagentOnlyExtensions?: string[];
    mcpDirectTools?: string[];
    completionGuard?: boolean;
    systemPrompt?: string | null;
    systemPromptMode?: "append" | "replace";
    inheritProjectContext: boolean;
    inheritSkills: boolean;
    skills?: string[];
    outputPath?: string;
    /** Defer the authoritative output instruction until a dynamic fanout item is materialized. */
    namespaceOutputPath?: boolean;
    outputMode?: "inline" | "file-only";
    sessionFile?: string;
    maxSubagentDepth?: number;
    waitToolEnabled?: boolean;
    structuredOutput?: {
        schema: import("../../shared/types.ts").JsonSchemaObject;
        schemaPath: string;
        outputPath: string;
    };
    structuredOutputSchema?: import("../../shared/types.ts").JsonSchemaObject;
    agentContract?: import("../../shared/types.ts").AgentContract;
    definitionDigest?: string;
    launchBindingTask?: string;
    launchContractDigest?: string;
    launchResolvedExtensions?: import("../../shared/types.ts").LaunchResolvedChildExtensionsV1;
    runtimeAcknowledgedExtensions?: import("../../shared/types.ts").RuntimeAcknowledgedChildExtensionsV1;
    effectiveAcceptance?: import("../../shared/types.ts").ResolvedAcceptanceConfig;
    acceptanceInput?: import("../../shared/types.ts").AcceptanceInput;
    acceptanceRole?: import("../../shared/types.ts").AcceptanceRole;
    gateOn?: import("../../shared/types.ts").ChainGateLayer;
    toolBudget?: import("../../shared/types.ts").ResolvedToolBudget;
    capabilityCeiling?: import("./capability-ceiling.ts").ResolvedSubagentCapabilityCeiling;
    capabilityAudit?: import("./capability-ceiling.ts").SubagentCapabilityAudit;
}
export interface RunnerCheckpointStep {
    checkpoint: string;
    message?: string;
    phase?: string;
    label?: string;
}
export interface ParallelStepGroup {
    parallel: RunnerSubagentStep[];
    concurrency?: number;
    failFast?: boolean;
    worktree?: boolean;
}
export interface DynamicRunnerGroup {
    expand: import("../../shared/settings.ts").DynamicExpandSpec;
    parallel: RunnerSubagentStep;
    collect: import("../../shared/settings.ts").DynamicCollectSpec;
    concurrency?: number;
    failFast?: boolean;
    phase?: string;
    label?: string;
    sessionFiles?: (string | undefined)[];
    thinkingOverrides?: (string | undefined)[];
    effectiveAcceptance?: import("../../shared/types.ts").ResolvedAcceptanceConfig;
    acceptanceInput?: import("../../shared/types.ts").AcceptanceInput;
    acceptanceRole?: import("../../shared/types.ts").AcceptanceRole;
    agentContract?: import("../../shared/types.ts").AgentContract;
    gateOn?: import("../../shared/types.ts").ChainGateLayer;
    capabilityCeiling?: import("./capability-ceiling.ts").ResolvedSubagentCapabilityCeiling;
    capabilityAudit?: import("./capability-ceiling.ts").SubagentCapabilityAudit;
}
export type RunnerStep = RunnerSubagentStep | ParallelStepGroup | DynamicRunnerGroup | RunnerCheckpointStep;
export declare function isCheckpointRunnerStep(step: RunnerStep): step is RunnerCheckpointStep;
export declare function isParallelGroup(step: RunnerStep): step is ParallelStepGroup;
export declare function isDynamicRunnerGroup(step: RunnerStep): step is DynamicRunnerGroup;
export declare function flattenSteps(steps: RunnerStep[]): RunnerSubagentStep[];
export declare const DEFAULT_GLOBAL_CONCURRENCY_LIMIT = 20;
/**
 * A promise-based semaphore for limiting concurrent access across multiple
 * mapConcurrent calls within a single run. Enforces a global cap on the total
 * number of subagent tasks executing simultaneously, regardless of each step's
 * per-step concurrency limit.
 */
export declare class Semaphore {
    private available;
    private readonly queue;
    constructor(limit: number);
    acquire(): Promise<void>;
    release(): void;
}
export declare function mapConcurrent<T, R>(items: T[], limit: number, fn: (item: T, i: number) => Promise<R>, globalSemaphore?: Semaphore, 
/** Invoked after every worker has stopped, including workers outliving an early rejection. */
onSchedulingSettled?: () => void): Promise<R[]>;
export interface ParallelTaskResult {
    agent: string;
    taskIndex?: number;
    output: string;
    exitCode: number | null;
    error?: string;
    timedOut?: boolean;
    model?: string;
    attemptedModels?: string[];
    outputTargetPath?: string;
    outputTargetExists?: boolean;
}
export declare function aggregateParallelOutputs(results: ParallelTaskResult[], headerFormat?: (index: number, agent: string) => string): string;
export declare const MAX_PARALLEL_CONCURRENCY = 4;
//# sourceMappingURL=parallel-utils.d.ts.map