/**
 * Task decomposition engine for parallel multi-agent execution.
 *
 * Breaks complex tasks into parallel sub-agent calls, routes them through
 * the adapter registry, caches results on the blackboard, and synthesizes
 * outputs using configurable strategies (merge, vote, chain, first-success).
 *
 * @module TaskDecomposer
 */
import { AdapterRegistry } from '../adapters/adapter-registry';
import { SharedBlackboard } from './shared-blackboard';
import { AuthGuardian } from './auth-guardian';
import type { SkillContext, ParallelTask, ParallelExecutionResult, SynthesisStrategy } from './orchestrator-types';
export declare class TaskDecomposer {
    private blackboard;
    private authGuardian;
    private adapterRegistry;
    /** Maximum number of tasks to run concurrently (0 = unlimited). */
    private maxConcurrency;
    constructor(blackboard: SharedBlackboard, authGuardian: AuthGuardian, adapterRegistry: AdapterRegistry, options?: {
        maxConcurrency?: number;
    });
    /**
     * Decomposes a complex task into parallel sub-agent calls
     * This is the "Wall Breaker" - transforms impossible monolithic tasks
     * into manageable parallel executions
     */
    executeParallel(tasks: ParallelTask[], synthesisStrategy: SynthesisStrategy | undefined, context: SkillContext): Promise<ParallelExecutionResult>;
    private executeSingleTask;
    private synthesize;
    private generateMergeSummary;
    private hashPayload;
    /**
     * Execute async functions with a bounded concurrency pool.
     * @param items Items to process
     * @param fn Async function to apply to each item
     * @param limit Max concurrent executions (0 = unlimited)
     */
    private runWithConcurrencyLimit;
}
//# sourceMappingURL=task-decomposer.d.ts.map