/**
 * Pre-flight context injection (Sprint 6, ADR-9):
 * PreflightContextInjector.inject() is called inside each agent's
 * runner before runAgenticLoop:
 *  - src/orchestrator/research-agent.ts (researcher-phase2)
 *  - src/orchestrator/architect-agent.ts
 *  - src/orchestrator/curator-agent.ts (writes to .bober/briefings/<contractId>-briefing.md)
 *  - src/orchestrator/generator-agent.ts
 *  - src/orchestrator/evaluator-agent.ts
 * Failure isolation: 5s timeout via Promise.race; preflight-failure
 * incident logged; original firstMessage returned on error.
 */
import type { BoberConfig } from "../config/schema.js";
import type { PlanSpec } from "../contracts/spec.js";
import type { SprintContract } from "../contracts/sprint-contract.js";
import type { EvaluationRunResult } from "../evaluators/registry.js";
import type { ContextHandoff, ProjectContext } from "./context-handoff.js";
import type { GeneratorResult } from "./generator-agent.js";
export interface PipelineResult {
    success: boolean;
    spec: PlanSpec;
    completedSprints: SprintContract[];
    failedSprints: SprintContract[];
    totalCost?: number;
    duration: number;
    /**
     * When the planner refuses to fully decompose the request (ambiguityScore
     * over threshold or open clarification questions), the pipeline stops
     * before sprint execution and sets this flag. Callers should surface
     * `spec.clarificationQuestions` to the user in this case.
     */
    needsClarification?: boolean;
}
export interface SprintCycleResult {
    contract: SprintContract;
    evaluation?: EvaluationRunResult;
    generatorResult?: GeneratorResult;
}
/**
 * Pure helper: inject queued guidance texts into a ContextHandoff by
 * appending them to `issues`. When guidanceTexts is empty, returns the
 * SAME handoff reference unchanged (deep-equal no-op for sc-4-7).
 * Exported for direct unit testing (sc-4-6/sc-4-7).
 */
export declare function injectGuidanceIntoHandoff(handoff: ContextHandoff, guidanceTexts: string[]): ContextHandoff;
export interface RunSprintCycleParams {
    contract: SprintContract;
    spec: PlanSpec;
    completedContracts: SprintContract[];
    projectRoot: string;
    config: BoberConfig;
    projectContext: ProjectContext;
    pipelineRunId?: string;
}
export declare function runSprintCycle(params: RunSprintCycleParams): Promise<SprintCycleResult>;
/**
 * Run the complete orchestration pipeline:
 *
 * 1. **Plan** — Call the planner agent to produce a PlanSpec
 * 2. **Sprint loop** — For each feature, create sprint contracts and
 *    run the generate-evaluate-iterate cycle
 * 3. **Result** — Return aggregated results
 *
 * Each agent invocation is a FRESH call (new message thread). Context
 * is carried via the ContextHandoff document.
 */
/**
 * Internal implementation: the original TypeScript pipeline body.
 * Extracted so TsPipelineEngine can wrap it without an import cycle.
 * Do NOT change the algorithm, phase order, or .bober/ write behaviour here.
 */
export declare function runTsPipeline(userPrompt: string, projectRoot: string, config: BoberConfig, opts?: {
    runId?: string;
}): Promise<PipelineResult>;
/**
 * Public entry point. Resolves the configured pipeline engine and delegates.
 * Signature is frozen — callers must not be updated when the engine changes.
 *
 * opts.teamId selects the active team (Phase 4). With no teamId, resolves to
 * 'programming', whose pipelineShape === resolveEngineName(config) — identical
 * to today's selectPipelineEngine(config) behaviour.
 */
export declare function runPipeline(userPrompt: string, projectRoot: string, config: BoberConfig, opts?: {
    runId?: string;
    teamId?: string;
}): Promise<PipelineResult>;
//# sourceMappingURL=pipeline.d.ts.map