qlogicagent 0.3.0 → 0.4.0

package/dist/types/orchestration/skill-consolidation.d.ts

@@ -1,123 +0,0 @@
-/**
- * Skill consolidation strategy — pure decision logic for
- * the Autonomous Curator's LLM-driven skill merging phase.
- *
- * This module:
- * 1. Detects prefix clusters among skill names.
- * 2. Builds the consolidation prompt for the LLM review agent.
- * 3. Parses structured LLM output into actionable merge/prune plans.
- * 4. Reconciles LLM intent against ground truth (existing skills).
- *
- * No I/O — the caller invokes the LLM and applies the results.
- */
-/** A skill summary fed to the LLM reviewer. */
-export interface ConsolidationSkillSummary {
-    name: string;
-    description: string;
-    /** Comma-separated tool names the skill uses. */
-    tools: string;
-    useCount: number;
-    lastActivityAt: string | null;
-    state: "active" | "stale";
-}
-/** A single consolidation action proposed by the LLM. */
-export interface ConsolidationAction {
-    /** Source skill to be absorbed. */
-    sourceSkill: string;
-    /** Target umbrella skill (existing or to-be-created). */
-    targetUmbrella: string;
-    /** Whether the target umbrella already exists. */
-    targetExists: boolean;
-    /** LLM's reason for the merge. */
-    reason: string;
-}
-/** A single pruning action proposed by the LLM. */
-export interface PruningAction {
-    /** Skill to be archived (not deleted). */
-    skillName: string;
-    /** Reason for pruning. */
-    reason: string;
-}
-/** Full consolidation plan produced by parsing LLM output. */
-export interface ConsolidationPlan {
-    consolidations: ConsolidationAction[];
-    prunings: PruningAction[];
-    /** Skills mentioned by LLM but not found in ground truth. */
-    hallucinations: string[];
-}
-/** Result of reconciling the LLM plan against ground truth. */
-export interface ReconciledConsolidationPlan {
-    /** Validated consolidation actions (targets exist or are marked for creation). */
-    validConsolidations: ConsolidationAction[];
-    /** Validated pruning actions (skills exist). */
-    validPrunings: PruningAction[];
-    /** Rejected actions due to ground-truth mismatch. */
-    rejected: Array<{
-        action: string;
-        reason: string;
-    }>;
-}
-/** A detected cluster of skills sharing a naming prefix. */
-export interface SkillPrefixCluster {
-    prefix: string;
-    skills: string[];
-}
-/**
- * Detect prefix clusters among skill names.
- *
- * A cluster is ≥2 skills sharing a common hyphenated prefix of ≥2 chars.
- * E.g. `["pr-review", "pr-merge", "pr-label"]` → cluster `"pr"`.
- */
-export declare function detectPrefixClusters(skillNames: readonly string[], minClusterSize?: number): SkillPrefixCluster[];
-/**
- * Build the consolidation review prompt for the LLM curator agent.
- *
- * The prompt instructs the model to:
- * 1. Identify prefix clusters and overlapping skills.
- * 2. Propose umbrella consolidations.
- * 3. Mark redundant/trivial skills for pruning (archive, not delete).
- * 4. Output a structured YAML block.
- */
-export declare function buildConsolidationPrompt(candidates: readonly ConsolidationSkillSummary[], existingUmbrellas: readonly string[], clusters: readonly SkillPrefixCluster[]): string;
-/**
- * Parse the LLM's structured YAML response into a ConsolidationPlan.
- *
- * Tolerant: handles minor formatting variations, ignores unknown fields.
- */
-export declare function parseConsolidationOutput(llmOutput: string, knownSkills: ReadonlySet<string>): ConsolidationPlan;
-/**
- * Reconcile the LLM's consolidation plan against ground truth.
- *
- * Validates that:
- * - Source skills exist and aren't already consolidated in this plan.
- * - Target umbrellas either exist or are new (will be created).
- * - Pruning targets aren't also being consolidated.
- */
-export declare function reconcileConsolidationPlan(plan: ConsolidationPlan, knownSkills: ReadonlySet<string>): ReconciledConsolidationPlan;
-/** Summary of a curator review run. */
-export interface CuratorRunReport {
-    /** ISO-8601 timestamp of the run. */
-    runAt: string;
-    /** Duration in seconds. */
-    durationSeconds: number;
-    /** Number of skills checked for lifecycle transitions. */
-    autoTransitionsChecked: number;
-    /** Number of skills marked stale. */
-    autoMarkedStale: number;
-    /** Number of skills archived. */
-    autoArchived: number;
-    /** Number of skills reactivated. */
-    autoReactivated: number;
-    /** Number of LLM-proposed consolidations accepted. */
-    consolidationsAccepted: number;
-    /** Number of LLM-proposed prunings accepted. */
-    pruningsAccepted: number;
-    /** Number of LLM-proposed actions rejected. */
-    actionsRejected: number;
-    /** Number of hallucinated skill names. */
-    hallucinations: number;
-}
-/**
- * Build a human-readable summary from a curator run report.
- */
-export declare function buildCuratorRunSummary(report: CuratorRunReport): string;

package/dist/types/orchestration/skill-improvement.d.ts

@@ -1,59 +0,0 @@
-/**
- * Skill self-learning: decides whether a completed turn should
- * trigger skill creation or improvement instructions.
- */
-export interface SkillTurnResult {
-    ok: boolean;
-    /** Number of tool invocations in this turn */
-    toolCallCount: number;
-    /** Number of distinct tool names used */
-    distinctToolCount: number;
-    /** Was a multi-step orchestration (≥2 rounds) used? */
-    multiStep: boolean;
-    /** Did the turn involve a sidechain? */
-    hasSidechain: boolean;
-    /** Optional user feedback signal (positive/negative/none) */
-    feedback?: "positive" | "negative" | null;
-    /** Skill name if an existing skill was used */
-    existingSkillName?: string | null;
-}
-export interface SkillCreateInstruction {
-    type: "skill.create";
-    /** Suggested skill name derived from tool usage pattern */
-    suggestedName: string;
-    /** Short description of what the skill does */
-    description: string;
-    /** Tool names involved */
-    tools: string[];
-    /** Number of orchestration steps */
-    stepCount: number;
-}
-export interface SkillImproveInstruction {
-    type: "skill.improve";
-    /** Existing skill to improve */
-    skillName: string;
-    /** Reason for improvement */
-    reason: string;
-}
-export type SkillInstruction = SkillCreateInstruction | SkillImproveInstruction;
-/**
- * Determine whether a completed turn should produce a skill instruction.
- *
- * A new skill is suggested when:
- * - The turn succeeded
- * - It involved multi-step orchestration
- * - It used ≥3 tool calls across ≥2 distinct tools
- * - No existing skill was already applied
- *
- * An improvement is suggested when:
- * - The turn used an existing skill but got negative feedback
- */
-export declare function shouldCreateSkill(result: SkillTurnResult): boolean;
-export declare function shouldImproveSkill(result: SkillTurnResult): boolean;
-/**
- * Build a skill instruction from a turn result, or null if none is warranted.
- */
-export declare function buildSkillInstruction(result: SkillTurnResult, context: {
-    tools: string[];
-    suggestedName?: string;
-}): SkillInstruction | null;

package/dist/types/orchestration/skill-similarity.d.ts

@@ -1,98 +0,0 @@
-/**
- * Skill similarity — pure strategy for detecting near-duplicate skills
- * before creation and during curator consolidation reviews.
- *
- * Computes multi-signal similarity between skills:
- * 1. Tool-set Jaccard overlap (primary signal for auto-generated skills)
- * 2. Title/description cosine bigram similarity (complementary signal)
- * 3. Step-count proximity (minor signal for workflow complexity)
- *
- * No I/O — all functions are pure.
- */
-/** Minimal skill profile for similarity comparison. */
-export interface SkillSimilarityProfile {
-    skillKey: string;
-    title: string;
-    tools: readonly string[];
-    stepCount?: number;
-}
-/** Result of a pairwise similarity comparison. */
-export interface SimilarityScore {
-    /** Overall similarity [0, 1]. */
-    overall: number;
-    /** Tool-set Jaccard index [0, 1]. */
-    toolJaccard: number;
-    /** Title bigram similarity [0, 1]. */
-    titleSimilarity: number;
-    /** Step-count proximity [0, 1]. */
-    stepProximity: number;
-}
-/** A candidate detected as similar during pre-creation check. */
-export interface SimilarSkillMatch {
-    existingSkillKey: string;
-    score: SimilarityScore;
-}
-/** Policy for similarity thresholds. */
-export interface SkillSimilarityPolicy {
-    /**
-     * Overall similarity threshold to block creation and emit "improve"
-     * instead. Default: 0.75.
-     */
-    blockCreationThreshold: number;
-    /**
-     * Overall similarity threshold to flag for curator review.
-     * Default: 0.55.
-     */
-    curatorReviewThreshold: number;
-    /** Weight of toolJaccard in overall score. Default: 0.60. */
-    toolWeight: number;
-    /** Weight of titleSimilarity in overall score. Default: 0.30. */
-    titleWeight: number;
-    /** Weight of stepProximity in overall score. Default: 0.10. */
-    stepWeight: number;
-}
-export declare const DEFAULT_SKILL_SIMILARITY_POLICY: SkillSimilarityPolicy;
-/**
- * Compute Jaccard index between two tool sets.
- * Returns 0 if both sets are empty.
- */
-export declare function toolSetJaccard(toolsA: readonly string[], toolsB: readonly string[]): number;
-/**
- * Compute character-bigram similarity between two strings.
- * Uses Dice coefficient of bigram sets.
- */
-export declare function bigramSimilarity(a: string, b: string): number;
-/**
- * Compute step-count proximity [0, 1].
- * Returns 1 when counts are identical, decreases with difference.
- */
-export declare function stepCountProximity(stepsA: number | undefined, stepsB: number | undefined): number;
-/**
- * Compute overall similarity between two skill profiles.
- */
-export declare function computeSimilarity(a: SkillSimilarityProfile, b: SkillSimilarityProfile, policy?: Partial<SkillSimilarityPolicy>): SimilarityScore;
-/**
- * Check a new skill candidate against existing skills for similarity.
- *
- * Returns all existing skills above curatorReviewThreshold, sorted
- * by descending similarity. The caller should:
- * - Block creation if any match ≥ blockCreationThreshold (emit improve instead)
- * - Tag for curator review if match ≥ curatorReviewThreshold
- */
-export declare function findSimilarSkills(newSkill: SkillSimilarityProfile, existingSkills: readonly SkillSimilarityProfile[], policy?: Partial<SkillSimilarityPolicy>): SimilarSkillMatch[];
-/**
- * Determine creation decision based on similarity matches.
- */
-export type SimilarityDecision = {
-    action: "create";
-    reason: string;
-} | {
-    action: "improve";
-    targetSkillKey: string;
-    reason: string;
-} | {
-    action: "flag-for-review";
-    targetSkillKey: string;
-    reason: string;
-};
-export declare function decideSimilarityAction(matches: readonly SimilarSkillMatch[], policy?: Partial<SkillSimilarityPolicy>): SimilarityDecision;

package/dist/types/orchestration/streaming-tool-executor.d.ts

@@ -1,73 +0,0 @@
-/**
- * StreamingToolExecutor — Executes tool calls as they arrive during LLM streaming.
- *
- * Aligned with Claude Code's StreamingToolExecutor pattern:
- * - As each complete tool_use block arrives during streaming, immediately dispatch execution
- * - Don't wait for the full LLM response to finish before starting tool execution
- * - Results queue up and can be collected at any time
- *
- * This reduces perceived latency by overlapping LLM generation time with tool execution time.
- */
-export interface StreamingToolCall {
-    id: string;
-    function: {
-        name: string;
-        arguments: string;
-    };
-}
-export interface StreamingToolResult<T = unknown> {
-    toolCallId: string;
-    toolName: string;
-    result: T;
-    ok: boolean;
-    startedAt: number;
-    completedAt: number;
-    error?: string;
-}
-export interface StreamingToolExecutorConfig {
-    /** Maximum concurrent tool executions (default: 8) */
-    maxConcurrency: number;
-    /** Abort signal for cancellation */
-    abortSignal?: AbortSignal;
-}
-export type ToolExecutorFn<T = unknown> = (toolCall: StreamingToolCall, abortSignal?: AbortSignal) => Promise<T>;
-/**
- * Streaming tool executor that dispatches tool calls immediately as they complete
- * during LLM streaming output, rather than waiting for the full response.
- *
- * Usage:
- * ```ts
- * const executor = createStreamingToolExecutor(executeFn, { maxConcurrency: 4 });
- * // During streaming, as each tool block completes:
- * executor.addTool(toolCall);
- * // Periodically collect completed results:
- * const results = executor.getCompletedResults();
- * // After streaming ends, wait for all remaining:
- * const allResults = await executor.flush();
- * ```
- */
-export interface StreamingToolExecutor<T = unknown> {
-    /** Add a tool call for immediate execution. Returns false if at capacity. */
-    addTool(toolCall: StreamingToolCall): boolean;
-    /** Get results that have completed since last call (non-blocking). */
-    getCompletedResults(): StreamingToolResult<T>[];
-    /** Wait for all pending tool calls to complete and return all results. */
-    flush(): Promise<StreamingToolResult<T>[]>;
-    /** Number of currently executing tool calls. */
-    readonly pendingCount: number;
-    /** Total number of tool calls dispatched. */
-    readonly dispatchedCount: number;
-    /** Whether the executor has been aborted. */
-    readonly aborted: boolean;
-}
-export declare function createStreamingToolExecutor<T = unknown>(executeFn: ToolExecutorFn<T>, config?: Partial<StreamingToolExecutorConfig>): StreamingToolExecutor<T>;
-/**
- * Determine if a tool call can be dispatched immediately during streaming
- * based on its manifest properties.
- */
-export declare function canDispatchDuringStreaming(toolCall: StreamingToolCall, manifest?: {
-    approvalMode?: "user-confirm" | "pre-authorized";
-    requiresApproval?: boolean;
-    serialOnly?: boolean;
-    parallelSafe?: boolean;
-}): boolean;

package/dist/types/orchestration/team-orchestration.d.ts

@@ -1,195 +0,0 @@
-/**
- * Team Orchestration Strategy — multi-agent coordination layer.
- *
- * Extends the existing sidechain foundation with team/swarm semantics:
- * - Parallel agent spawning (multiple sidechains at once)
- * - Role-based agent assignment (planner / executor / reviewer)
- * - Shared knowledge pool via merge policies
- * - Budget-aware concurrency limits
- * - Lifecycle state machine for team coordination
- *
- * Architecture:
- *   Gateway ─── Hub ─── orchestration (this module, pure strategy)
- *                │
- *   ┌───────────┼───────────┐
- *   │   TeamCoordinator     │  ← Hub runtime (multi-sidechain-coordinator.ts)
- *   │   │                   │
- *   │   ├── Agent #1 (planner)
- *   │   ├── Agent #2 (executor)
- *   │   └── Agent #3 (reviewer)
- *   └───────────────────────┘
- *
- * This module provides:
- * 1. Type definitions (TeamPlan, AgentRole, TeamLifecycle)
- * 2. Pure strategy functions (plan resolution, role assignment, budget allocation)
- * 3. Merge/aggregation policies (how agent results combine)
- *
- * Hub consumes these types and strategy functions in its coordinator runtime.
- * Gateway consumes TeamPlan to spawn/manage multiple sidechain executions.
- */
-import type { SidechainType, SidechainMergePolicy, SidechainBudgetTier, SidechainToolAccessMode } from "./index.js";
-/** Roles an agent can take within a team execution. */
-export type AgentRole = "planner" | "executor" | "reviewer" | "researcher" | "custom";
-/** Execution mode for a team. */
-export type TeamExecutionMode = "parallel" | "sequential" | "pipeline" | "adaptive";
-/** How team results are aggregated into the parent execution. */
-export type TeamAggregationPolicy = "first-success" | "majority-vote" | "merge-all" | "reviewer-gate" | "planner-sync";
-/** Current lifecycle state of a team execution. */
-export type TeamLifecycleState = "planning" | "spawning" | "executing" | "aggregating" | "reviewing" | "completed" | "failed" | "cancelled";
-/** Specification for a single agent within a team. */
-export interface TeamAgentSpec {
-    /** Unique ID within the team (e.g., "agent-1", "researcher-a"). */
-    agentId: string;
-    /** Role this agent plays. */
-    role: AgentRole;
-    /** Human-readable label for tracing. */
-    label: string;
-    /** The sidechain type this agent maps to. */
-    sidechainType: SidechainType;
-    /** Task description / system prompt override for this agent. */
-    taskDescription: string;
-    /** Tool access mode for this agent's sidechain. */
-    toolAccessMode: SidechainToolAccessMode;
-    /** Budget tier for this agent. */
-    budgetTier: SidechainBudgetTier;
-    /** Which agents this one depends on (for sequential/pipeline modes). */
-    dependsOn: string[];
-    /** Maximum tokens this agent can consume. */
-    maxTokenBudget: number;
-    /** Maximum tool calls this agent can make. */
-    maxToolCalls: number;
-    /** Timeout in milliseconds (0 = inherit from team). */
-    timeoutMs: number;
-}
-/** A complete team execution plan. */
-export interface TeamPlan {
-    /** Unique team execution ID. */
-    teamId: string;
-    /** Execution mode for this team. */
-    mode: TeamExecutionMode;
-    /** How results from all agents are aggregated. */
-    aggregationPolicy: TeamAggregationPolicy;
-    /** All agent specs in this team. */
-    agents: TeamAgentSpec[];
-    /** Maximum concurrent agent executions (0 = unlimited). */
-    maxConcurrency: number;
-    /** Team-level timeout in ms (0 = no timeout). */
-    timeoutMs: number;
-    /** Total token budget across all agents. */
-    totalTokenBudget: number;
-    /** Whether early termination is allowed when one agent fails. */
-    failFast: boolean;
-    /** Shared context provided to all agents. */
-    sharedContext: string;
-    /** Merge policy for the final team output back to parent. */
-    mergePolicy: SidechainMergePolicy;
-}
-/** Result from a single agent within a team. */
-export interface TeamAgentResult {
-    agentId: string;
-    role: AgentRole;
-    status: "completed" | "failed" | "cancelled" | "timeout";
-    output: string;
-    tokenUsage: {
-        prompt: number;
-        completion: number;
-    };
-    toolCallCount: number;
-    durationMs: number;
-    error?: string;
-}
-/** Aggregated result from team execution. */
-export interface TeamResult {
-    teamId: string;
-    state: TeamLifecycleState;
-    agentResults: TeamAgentResult[];
-    aggregatedOutput: string;
-    totalTokenUsage: {
-        prompt: number;
-        completion: number;
-    };
-    totalDurationMs: number;
-}
-/** Maximum agents allowed in a team (safety bound). */
-export declare const TEAM_MAX_AGENTS = 8;
-/** Maximum recursion depth (teams spawning teams). */
-export declare const TEAM_MAX_DEPTH = 2;
-/**
- * Resolve a team plan from a high-level task decomposition.
- *
- * This is the main entry point: given a set of subtasks and constraints,
- * produce a concrete TeamPlan that the coordinator can execute.
- */
-export declare function resolveTeamPlan(params: {
-    teamId: string;
-    subtasks: Array<{
-        id: string;
-        role: AgentRole;
-        label: string;
-        task: string;
-        dependsOn?: string[];
-    }>;
-    mode?: TeamExecutionMode;
-    aggregationPolicy?: TeamAggregationPolicy;
-    totalTokenBudget?: number;
-    timeoutMs?: number;
-    failFast?: boolean;
-    sharedContext?: string;
-    mergePolicy?: SidechainMergePolicy;
-}): TeamPlan;
-/**
- * Map agent role to sidechain type for existing Hub plumbing compatibility.
- */
-export declare function mapRoleToSidechainType(role: AgentRole): SidechainType;
-/**
- * Resolve tool access mode for a given role.
- */
-export declare function resolveAgentToolAccess(role: AgentRole): SidechainToolAccessMode;
-/**
- * Allocate token budgets proportionally by role weight.
- */
-export declare function allocateTokenBudgets(agents: TeamAgentSpec[], totalBudget: number): TeamAgentSpec[];
-/**
- * Infer execution mode from agent dependency graph.
- */
-export declare function inferExecutionMode(agents: TeamAgentSpec[]): TeamExecutionMode;
-/**
- * Infer aggregation policy from mode and agent composition.
- */
-export declare function inferAggregationPolicy(mode: TeamExecutionMode, agents: TeamAgentSpec[]): TeamAggregationPolicy;
-/**
- * Determine the execution order for agents given their dependency graph.
- * Returns groups of agent IDs that can execute concurrently.
- *
- * Example: [[planner], [executor-a, executor-b], [reviewer]]
- */
-export declare function resolveExecutionOrder(agents: TeamAgentSpec[]): string[][];
-/**
- * Aggregate team results into a single output string.
- */
-export declare function aggregateTeamResults(results: TeamAgentResult[], policy: TeamAggregationPolicy): string;
-/**
- * Validate a team plan before execution.
- * Returns a list of issues (empty = valid).
- */
-export declare function validateTeamPlan(plan: TeamPlan): string[];
-/**
- * Determine if a team execution should be cancelled early based on current state.
- */
-export declare function shouldCancelTeam(params: {
-    plan: TeamPlan;
-    results: TeamAgentResult[];
-    elapsedMs: number;
-}): {
-    cancel: boolean;
-    reason: string;
-};
-/**
- * Build the task prompt for a specific agent, incorporating shared context
- * and outputs from dependency agents.
- */
-export declare function buildAgentTaskPrompt(params: {
-    agent: TeamAgentSpec;
-    plan: TeamPlan;
-    dependencyResults: TeamAgentResult[];
-}): string;

package/dist/types/orchestration/team-tool-loop-wiring.d.ts

@@ -1,92 +0,0 @@
-/**
- * Team Tool Loop Wiring — Connects team orchestration to the tool loop.
- *
- * When the LLM invokes `team_create`, this module:
- * 1. Validates the team plan
- * 2. Maps team agents to fork contexts
- * 3. Coordinates execution according to the team execution mode
- * 4. Aggregates results according to the aggregation policy
- * 5. Returns the aggregated result as a tool_result
- *
- * This bridges the gap between the pure strategy layer (team-orchestration.ts)
- * and the Hub's tool loop.
- */
-import type { AgentRole, TeamExecutionMode, TeamAggregationPolicy, TeamLifecycleState } from "./team-orchestration.js";
-import type { AgentDefinition } from "./agent-registry.js";
-import type { ForkResult } from "./fork-subagent.js";
-export interface TeamToolRequest {
-    /** Team name for identification. */
-    name: string;
-    /** Agent specs for the team. */
-    agents: TeamAgentRequest[];
-    /** Execution mode. */
-    mode: TeamExecutionMode;
-    /** How to aggregate results. */
-    aggregation: TeamAggregationPolicy;
-}
-export interface TeamAgentRequest {
-    /** Role within the team. */
-    role: AgentRole;
-    /** Agent type from built-in registry. */
-    agentType: string;
-    /** Task prompt for this agent. */
-    prompt: string;
-    /** Max turns override. */
-    maxTurns?: number;
-    /** Dependencies (agent IDs that must complete before this one). */
-    dependsOn?: string[];
-}
-export interface TeamExecutionPlan {
-    /** Ordered batches for execution. */
-    batches: TeamExecutionBatch[];
-    /** Total estimated token budget. */
-    totalBudget: number;
-    /** Lifecycle state. */
-    state: TeamLifecycleState;
-}
-export interface TeamExecutionBatch {
-    /** Agents in this batch (run in parallel within a batch). */
-    agents: TeamAgentRequest[];
-    /** Batch mode (parallel or sequential within the batch). */
-    mode: "parallel" | "serial";
-}
-/**
- * Resolve the execution plan for a team request.
- * Validates the request, resolves dependencies into ordered batches,
- * and determines the execution topology.
- */
-export declare function resolveTeamExecutionPlan(request: TeamToolRequest): TeamExecutionPlan;
-export interface TeamAggregatedResult {
-    /** Whether the team execution succeeded overall. */
-    ok: boolean;
-    /** Aggregated output text. */
-    output: string;
-    /** Individual agent results. */
-    agentResults: Array<{
-        agentId: string;
-        role: AgentRole;
-        result: ForkResult;
-    }>;
-    /** Total tokens consumed by all agents. */
-    totalTokensUsed: number;
-    /** Lifecycle state after aggregation. */
-    finalState: TeamLifecycleState;
-}
-/**
- * Aggregate results from team agents according to the aggregation policy.
- */
-export declare function aggregateTeamToolResults(results: Array<{
-    agentId: string;
-    role: AgentRole;
-    result: ForkResult;
-}>, policy: TeamAggregationPolicy): TeamAggregatedResult;
-/**
- * Map a team tool_call into the format needed for the tool loop to dispatch.
- * Returns the list of fork configs the tool loop should execute.
- */
-export declare function mapTeamRequestToForkConfigs(request: TeamToolRequest, agentRegistry: (name: string) => AgentDefinition | undefined): Array<{
-    agentDef: AgentDefinition;
-    prompt: string;
-    maxTurns?: number;
-    role: AgentRole;
-}>;