/**
 * deep-research-codebase / claude
 *
 * A deterministically-orchestrated, distributed codebase researcher built on
 * the Claude Agent SDK's native sub-agent dispatch. Specialist sub-agents
 * (codebase-locator / codebase-pattern-finder / codebase-analyzer /
 * codebase-online-researcher / codebase-research-locator /
 * codebase-research-analyzer) are spawned as separate headless `ctx.stage()`
 * calls — each binds the SDK's `agent` option to the desired specialist
 * instead of relying on a coordinator agent that dispatches them via the
 * `@"name (agent)"` prompt syntax.
 *
 * Why SDK primitives instead of in-prompt orchestration:
 *
 *   • Each specialist runs in an ISOLATED conversation. The locator's giant
 *     file index doesn't pollute the analyzer's context window, and the
 *     online-researcher doesn't see the analyzer's reasoning at all. This is
 *     `multi-agent-patterns` swarm-style isolation, not orchestrator-style.
 *
 *   • There is no orchestrator turn whose context grows linearly with the
 *     number of specialists. Token cost per partition is bounded by the four
 *     specialists' independent prompts — adding more partitions scales
 *     cleanly because every fan-out is a fresh session.
 *
 *   • Failure of one specialist does not abort the partition mid-thought —
 *     the runtime fails the stage, but its siblings' outputs are still on
 *     disk and the aggregator can continue with whatever completed.
 *
 *   • The synthesis step that combines specialist outputs is plain TypeScript
 *     (`renderExplorerMarkdown` in helpers/scratch.ts) — no extra LLM call
 *     just to concatenate four markdown sections.
 *
 * Topology:
 *
 *           ┌─→ codebase-scout (visible)
 *   parent ─┤
 *           └─→ history-locator → history-analyzer (headless)
 *                                       │
 *                                       ▼
 *   ┌──────────────────────────────────────────────────────────────────────┐
 *   │  Per-partition (Promise.all over partitions, all stages headless):    │
 *   │                                                                       │
 *   │     locator-i      ∥   pattern-finder-i        (Layer 1, parallel)    │
 *   │            │                                                          │
 *   │            ▼                                                          │
 *   │     analyzer-i     ∥   online-researcher-i     (Layer 2, parallel)    │
 *   │            │                                                          │
 *   │            ▼                                                          │
 *   │     deterministic write to scratch file (TS helper, no LLM)           │
 *   └──────────────────────────────────────────────────────────────────────┘
 *                                       │
 *                                       ▼
 *                                  aggregator (visible)
 *
 * Specialist stages run headless (in-process via the Agent SDK's `query()`),
 * so they are transparent to the workflow graph. The visible nodes are just:
 *   parent → [codebase-scout] → aggregator
 */
declare const _default: import("../../../index.ts").WorkflowDefinition<"claude", readonly [{
    readonly name: "prompt";
    readonly type: "text";
    readonly required: true;
    readonly description: "research question";
}]>;
export default _default;
//# sourceMappingURL=index.d.ts.map