/**
 * deep-research-codebase / claude
 *
 * A deterministically-orchestrated, distributed codebase researcher built on
 * the Claude Agent SDK with **batched** Task-tool fan-out. Specialist
 * sub-agents (codebase-locator / codebase-pattern-finder / codebase-analyzer
 * / codebase-online-researcher) run inside batch sessions: each batch is a
 * single `ctx.stage()` whose orchestrator turn dispatches up to
 * MAX_TASKS_PER_BATCH (≈10) specialists in parallel via the Task tool.
 * Research-history specialists (codebase-research-locator /
 * codebase-research-analyzer) remain as their own small pipeline since they
 * have a strict sequential dependency and run only twice per workflow.
 *
 * Why batched Task-tool dispatch instead of one ctx.stage per specialist:
 *
 *   • SDK-level fan-out scales by codebase size — at 5K LOC per partition
 *     and 4 specialists per partition, a 750K-LOC codebase would otherwise
 *     spawn 600 `claude` subprocesses. Batches of 10 cap that at ~60 SDK
 *     sessions, with each session internally fanning out via Task tool.
 *
 *   • ~10 parallel Task tool sub-agents per single message is the practical
 *     ceiling before rate limits, context contention, and degraded
 *     coordination kick in (no documented hard cap; tunable in
 *     helpers/batching.ts).
 *
 *   • Sub-agents still run in ISOLATED contexts — Task tool gives every
 *     sub-agent its own conversation window, so the locator's file index
 *     doesn't pollute the analyzer the way it would inside a shared
 *     conversation. (multi-agent-patterns swarm isolation.)
 *
 *   • The orchestrator's turn does NOT grow linearly with sub-agent count:
 *     each Task sub-agent writes its verbatim findings to a per-task scratch
 *     file and returns just "DONE", so the orchestrator collects N short
 *     confirmations rather than N transcripts (filesystem-context skill).
 *
 *   • Failure isolation is preserved at two levels: (1) Promise.allSettled
 *     around the batches means one failed batch doesn't abort siblings;
 *     (2) inside a batch, the orchestrator is instructed not to retry
 *     failed Task sub-agents — the synthesis step tolerates missing files.
 *
 *   • Synthesis remains plain TypeScript (`renderExplorerMarkdown` in
 *     helpers/scratch.ts) — no extra LLM call just to concatenate sections.
 *
 * Topology:
 *
 *           ┌─→ codebase-scout (visible)
 *   parent ─┤
 *           └─→ history-locator → history-analyzer (headless)
 *                                       │
 *                                       ▼
 *   ┌──────────────────────────────────────────────────────────────────────┐
 *   │  Wave 1 (locator + pattern-finder, no inter-deps):                    │
 *   │     wave1-batch-1  ∥  wave1-batch-2  ∥  ...  (Promise.allSettled)     │
 *   │       └── each batch session: orchestrator dispatches ≤10 Task        │
 *   │           sub-agents in one assistant message; each writes to disk    │
 *   │                                       │                                │
 *   │                                       ▼                                │
 *   │  TS reads locator-i.md files from disk for Layer 2 prompts            │
 *   │                                       │                                │
 *   │                                       ▼                                │
 *   │  Wave 2 (analyzer + online-researcher, embed locator output):         │
 *   │     wave2-batch-1  ∥  wave2-batch-2  ∥  ...  (Promise.allSettled)     │
 *   │                                       │                                │
 *   │                                       ▼                                │
 *   │  Per partition i: TS reads 4 specialist files + writes explorer-i.md  │
 *   └──────────────────────────────────────────────────────────────────────┘
 *                                       │
 *                                       ▼
 *                                  aggregator (visible)
 *
 * Batch sessions are headless (transparent to the workflow graph). Visible
 * nodes: 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