@cline/core 0.0.38-nightly.1778113663

package/dist/extensions/tools/presets.d.ts

@@ -0,0 +1,132 @@
+/**
+ * AgentTool Presets
+ *
+ * Pre-configured tool combinations for common use cases.
+ */
+import type { AgentMode, AgentTool, ToolPolicy } from "@cline/shared";
+import type { CreateDefaultToolsOptions, DefaultToolsConfig } from "./types";
+export interface ToolPresetConfig extends DefaultToolsConfig {
+    enableSpawnAgent?: boolean;
+    enableAgentTeams?: boolean;
+}
+/**
+ * Preset configurations for common use cases
+ */
+export declare const ToolPresets: {
+    /**
+     * Act mode (full development tools)
+     * Good for coding assistants and task automation
+     */
+    readonly act: {
+        readonly enableReadFiles: true;
+        readonly enableSearch: true;
+        readonly enableBash: true;
+        readonly enableWebFetch: true;
+        readonly enableApplyPatch: false;
+        readonly enableEditor: true;
+        readonly enableSkills: true;
+        readonly enableAskQuestion: true;
+        readonly enableSubmitAndExit: false;
+        readonly enableSpawnAgent: true;
+        readonly enableAgentTeams: true;
+    };
+    /**
+     * Plan mode (read-only, no shell access)
+     * Good for analysis and documentation agents
+     */
+    readonly plan: {
+        readonly enableReadFiles: true;
+        readonly enableSearch: true;
+        readonly enableBash: true;
+        readonly enableWebFetch: true;
+        readonly enableApplyPatch: false;
+        readonly enableEditor: false;
+        readonly enableSkills: true;
+        readonly enableAskQuestion: true;
+        readonly enableSubmitAndExit: false;
+        readonly enableSpawnAgent: true;
+        readonly enableAgentTeams: true;
+    };
+    /**
+     * Search-focused tools (read_files + search_codebase)
+     * Good for code exploration and analysis agents
+     */
+    readonly search: {
+        readonly enableReadFiles: true;
+        readonly enableSearch: true;
+        readonly enableBash: false;
+        readonly enableWebFetch: false;
+        readonly enableApplyPatch: false;
+        readonly enableEditor: false;
+        readonly enableSkills: false;
+        readonly enableAskQuestion: false;
+        readonly enableSubmitAndExit: false;
+        readonly enableSpawnAgent: true;
+        readonly enableAgentTeams: true;
+    };
+    /**
+     * Minimal tools for focused tasks
+     */
+    readonly minimal: {
+        readonly enableReadFiles: false;
+        readonly enableSearch: false;
+        readonly enableBash: true;
+        readonly enableWebFetch: false;
+        readonly enableApplyPatch: false;
+        readonly enableEditor: false;
+        readonly enableSkills: false;
+        readonly enableAskQuestion: false;
+        readonly enableSubmitAndExit: false;
+        readonly enableSpawnAgent: true;
+        readonly enableAgentTeams: false;
+    };
+    /**
+     * YOLO mode (automation-focused tools + no approval required)
+     * Good for trusted local automation workflows.
+     */
+    readonly yolo: {
+        readonly enableReadFiles: true;
+        readonly enableSearch: false;
+        readonly enableBash: true;
+        readonly enableWebFetch: false;
+        readonly enableApplyPatch: false;
+        readonly enableEditor: true;
+        readonly enableSkills: false;
+        readonly enableAskQuestion: false;
+        readonly enableSubmitAndExit: true;
+        readonly enableSpawnAgent: false;
+        readonly enableAgentTeams: false;
+    };
+};
+/**
+ * Type for preset names
+ */
+export type ToolPresetName = keyof typeof ToolPresets;
+export declare function resolveToolPresetName(options: {
+    mode?: AgentMode;
+}): ToolPresetName;
+/**
+ * AgentTool policy preset names
+ */
+export type ToolPolicyPresetName = "default" | "yolo";
+/**
+ * Build tool policies for a preset.
+ * `yolo` guarantees tool policies are enabled and auto-approved.
+ */
+export declare function createToolPoliciesWithPreset(presetName: ToolPolicyPresetName): Record<string, ToolPolicy>;
+/**
+ * Create default tools using a preset configuration
+ *
+ * @example
+ * ```typescript
+ * const tools = createDefaultToolsWithPreset("plan", {
+ *   executors: {
+ *     readFile: async ({ path }) => fs.readFile(path, "utf-8"),
+ *     search: async (query, cwd) => searchFiles(query, cwd),
+ *     webFetch: async (url, prompt) => fetchAndAnalyze(url, prompt),
+ *   },
+ *   cwd: "/path/to/project",
+ * })
+ * ```
+ */
+export declare function createDefaultToolsWithPreset(presetName: ToolPresetName, options: Omit<CreateDefaultToolsOptions, keyof DefaultToolsConfig> & Partial<DefaultToolsConfig>): AgentTool[];

package/dist/extensions/tools/runtime.d.ts

@@ -0,0 +1,24 @@
+import type { CoreAgentMode } from "../../types/config";
+export interface ToolCatalogEntry {
+    id: string;
+    description: string;
+    defaultEnabled: boolean;
+    headlessToolNames: string[];
+}
+export interface BuiltinToolAvailabilityContext {
+    mode?: CoreAgentMode;
+    providerId?: string;
+    modelId?: string;
+    enableSpawnAgent?: boolean;
+    enableAgentTeams?: boolean;
+    disabledToolIds?: ReadonlySet<string>;
+}
+export declare function getCoreBuiltinToolCatalog(context?: BuiltinToolAvailabilityContext): ToolCatalogEntry[];
+export declare function getCoreDefaultEnabledToolIds(context?: BuiltinToolAvailabilityContext): string[];
+export declare function resolveCoreSelectedToolIds(input: {
+    enabled: boolean;
+    allowlist?: string[];
+    availabilityContext?: BuiltinToolAvailabilityContext;
+}): Set<string>;
+export declare function getCoreHeadlessToolNames(selectedToolIds: ReadonlySet<string>, context?: BuiltinToolAvailabilityContext): string[];
+export declare function getCoreAcpToolNames(selectedToolIds: ReadonlySet<string>, context?: BuiltinToolAvailabilityContext): string[];

package/dist/extensions/tools/schemas.d.ts

@@ -0,0 +1,241 @@
+/**
+ * Zod Schemas for Default Tool Inputs
+ *
+ * These schemas define the input structure for each default tool
+ * and are used for both validation and JSON Schema generation.
+ */
+import { z } from "zod";
+export declare const INPUT_ARG_CHAR_LIMIT = 6000;
+export declare const ReadFileLineRangeSchema: z.ZodObject<{
+    start_line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    end_line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+export declare const ReadFileRequestSchema: z.ZodObject<{
+    path: z.ZodString;
+    start_line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    end_line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+/**
+ * Schema for read_files tool input
+ */
+export declare const ReadFilesInputSchema: z.ZodObject<{
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        start_line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        end_line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Union schema for read_files tool input, allowing either a single string, an array of strings, or the full object schema
+ */
+export declare const ReadFilesInputUnionSchema: z.ZodUnion<readonly [z.ZodObject<{
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        start_line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        end_line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    path: z.ZodString;
+    start_line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    end_line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>, z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    start_line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    end_line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>>, z.ZodArray<z.ZodString>, z.ZodString, z.ZodObject<{
+    files: z.ZodObject<{
+        path: z.ZodString;
+        start_line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        end_line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    file_paths: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    file_paths: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    paths: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        path: z.ZodString;
+        start_line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        end_line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>]>>;
+}, z.core.$strip>, z.ZodObject<{
+    paths: z.ZodObject<{
+        path: z.ZodString;
+        start_line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        end_line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    paths: z.ZodString;
+}, z.core.$strip>]>;
+/**
+ * Schema for search_codebase tool input
+ */
+export declare const SearchCodebaseInputSchema: z.ZodObject<{
+    queries: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Union schema for search_codebase tool input, allowing either a single string, an array of strings, or the full object schema
+ */
+export declare const SearchCodebaseUnionInputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    queries: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodArray<z.ZodString>, z.ZodString, z.ZodObject<{
+    queries: z.ZodString;
+}, z.core.$strip>]>;
+/**
+ * Schema for run_commands tool input
+ */
+export declare const RunCommandsInputSchema: z.ZodObject<{
+    commands: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Union schema for run_commands tool input. More flexible.
+ */
+export declare const RunCommandsInputUnionSchema: z.ZodUnion<readonly [z.ZodObject<{
+    commands: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    commands: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    command: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    cmd: z.ZodString;
+}, z.core.$strip>, z.ZodArray<z.ZodString>, z.ZodString]>;
+export declare const StructuredCommandInputSchema: z.ZodObject<{
+    command: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const StructuredCommandEntrySchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    command: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>]>;
+/**
+ * Schema for run_commands tool input
+ */
+export declare const StructuredCommandsInputSchema: z.ZodObject<{
+    commands: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        command: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>]>>;
+}, z.core.$strip>;
+/**
+ * Union schema for run_commands tool input. More flexible.
+ */
+export declare const StructuredCommandsInputUnionSchema: z.ZodUnion<readonly [z.ZodObject<{
+    commands: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    commands: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        command: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>]>>;
+}, z.core.$strip>, z.ZodObject<{
+    commands: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        command: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>]>;
+}, z.core.$strip>, z.ZodArray<z.ZodObject<{
+    command: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>>, z.ZodObject<{
+    command: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    command: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    cmd: z.ZodString;
+}, z.core.$strip>, z.ZodArray<z.ZodString>, z.ZodString]>;
+/**
+ * Schema for a single web fetch request
+ */
+export declare const WebFetchRequestSchema: z.ZodObject<{
+    url: z.ZodString;
+    prompt: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Schema for fetch_web_content tool input
+ */
+export declare const FetchWebContentInputSchema: z.ZodObject<{
+    requests: z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        prompt: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Schema for editor tool input
+ */
+export declare const EditFileInputSchema: z.ZodObject<{
+    path: z.ZodString;
+    old_text: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    new_text: z.ZodString;
+    insert_line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+/**
+ * Schema for apply_patch tool input
+ */
+export declare const ApplyPatchInputSchema: z.ZodObject<{
+    input: z.ZodString;
+}, z.core.$strip>;
+export declare const ApplyPatchInputUnionSchema: z.ZodUnion<readonly [z.ZodObject<{
+    input: z.ZodString;
+}, z.core.$strip>, z.ZodString]>;
+/**
+ * Schema for skills tool input
+ */
+export declare const SkillsInputSchema: z.ZodObject<{
+    skill: z.ZodString;
+    args: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Schema for ask_followup_question tool input
+ */
+export declare const AskQuestionInputSchema: z.ZodObject<{
+    question: z.ZodString;
+    options: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const SubmitInputSchema: z.ZodObject<{
+    summary: z.ZodString;
+    verified: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * Input for a single file read request
+ */
+export type ReadFileRequest = z.infer<typeof ReadFileRequestSchema>;
+/**
+ * Input for the read_files tool
+ */
+export type ReadFilesInput = z.infer<typeof ReadFilesInputSchema>;
+/**
+ * Input for the search_codebase tool
+ */
+export type SearchCodebaseInput = z.infer<typeof SearchCodebaseInputSchema>;
+/**
+ * Input for the run_commands tool
+ */
+export type RunCommandsInput = z.infer<typeof RunCommandsInputSchema>;
+export type StructuredCommandInput = z.infer<typeof StructuredCommandInputSchema>;
+/**
+ * Web fetch request parameters
+ */
+export type WebFetchRequest = z.infer<typeof WebFetchRequestSchema>;
+/**
+ * Input for the fetch_web_content tool
+ */
+export type FetchWebContentInput = z.infer<typeof FetchWebContentInputSchema>;
+/**
+ * Input for the editor tool
+ */
+export type EditFileInput = z.infer<typeof EditFileInputSchema>;
+/**
+ * Input for the apply_patch tool
+ */
+export type ApplyPatchInput = z.infer<typeof ApplyPatchInputSchema>;
+/**
+ * Input for the skills tool
+ */
+export type SkillsInput = z.infer<typeof SkillsInputSchema>;
+/**
+ * Input for the ask_followup_question tool
+ */
+export type AskQuestionInput = z.infer<typeof AskQuestionInputSchema>;
+/**
+ * Input for the submit and exit tool
+ */
+export type SubmitInput = z.infer<typeof SubmitInputSchema>;

package/dist/extensions/tools/team/delegated-agent.d.ts

@@ -0,0 +1,43 @@
+import type { AgentConfig, AgentEvent, AgentHooks, AgentTool, BasicLogger, HookErrorMode, ITelemetryService, ToolApprovalRequest, ToolApprovalResult } from "@cline/shared";
+import { SessionRuntime } from "../../../runtime/orchestration/session-runtime-orchestrator";
+type AgentExtension = NonNullable<AgentConfig["extensions"]>[number];
+export type DelegatedAgentConnectionConfig = Pick<AgentConfig, "providerId" | "modelId" | "apiKey" | "baseUrl" | "headers" | "providerConfig" | "knownModels" | "thinking">;
+export interface DelegatedAgentRuntimeConfig extends DelegatedAgentConnectionConfig {
+    cwd?: string;
+    providerId: string;
+    clinePlatform?: string;
+    clineIdeName?: string;
+    maxIterations?: number;
+    hooks?: AgentHooks;
+    extensions?: AgentExtension[];
+    logger?: BasicLogger;
+    telemetry?: ITelemetryService;
+    workspaceMetadata?: string;
+}
+export interface DelegatedAgentConfigProvider {
+    getRuntimeConfig(): DelegatedAgentRuntimeConfig;
+    getConnectionConfig(): DelegatedAgentConnectionConfig;
+    updateConnectionDefaults(overrides: Partial<DelegatedAgentConnectionConfig>): void;
+}
+export type DelegatedAgentKind = "subagent" | "teammate";
+export interface BuildDelegatedAgentConfigOptions {
+    kind: DelegatedAgentKind;
+    prompt: string;
+    tools: AgentTool[];
+    configProvider: DelegatedAgentConfigProvider;
+    parentAgentId?: string;
+    maxIterations?: number;
+    abortSignal?: AbortSignal;
+    onEvent?: (event: AgentEvent) => void;
+    hookErrorMode?: HookErrorMode;
+    toolPolicies?: AgentConfig["toolPolicies"];
+    requestToolApproval?: (request: ToolApprovalRequest) => Promise<ToolApprovalResult> | ToolApprovalResult;
+    role?: string;
+    cwd?: string;
+}
+export declare function createDelegatedAgentConfigProvider(initialConfig: DelegatedAgentRuntimeConfig): DelegatedAgentConfigProvider;
+export declare function buildDelegatedAgentConfig(options: BuildDelegatedAgentConfigOptions): AgentConfig & {
+    role?: string;
+};
+export declare function createDelegatedAgent(options: BuildDelegatedAgentConfigOptions): SessionRuntime;
+export {};

package/dist/extensions/tools/team/index.d.ts

@@ -0,0 +1,2 @@
+export { buildTeamProgressSummary, toTeamProgressLifecycleEvent, } from "./projections";
+export * from "./runtime";

package/dist/extensions/tools/team/multi-agent.d.ts

@@ -0,0 +1,230 @@
+/**
+ * Multi-Agent Coordination
+ *
+ * Utilities for orchestrating multiple agents working together.
+ */
+import { type AgentConfig, type AgentEvent, type AgentResult, type AppendMissionLogInput, type AttachTeamOutcomeFragmentInput, type CreateTeamOutcomeInput, type CreateTeamTaskInput, type MissionLogEntry, type ReviewTeamOutcomeFragmentInput, type RouteToTeammateOptions, type TeamMailboxMessage, type TeamMemberSnapshot, TeamMessageType, type TeammateLifecycleSpec, type TeamOutcome, type TeamOutcomeFragment, type TeamRunRecord, type TeamRunStatus, type TeamRuntimeSnapshot, type TeamRuntimeState, type TeamTask, type TeamTaskListItem, type TeamTaskStatus } from "@cline/shared";
+import { SessionRuntime } from "../../../runtime/orchestration/session-runtime-orchestrator";
+export { type AppendMissionLogInput, type AttachTeamOutcomeFragmentInput, type CreateTeamOutcomeInput, type CreateTeamTaskInput, type MissionLogEntry, type MissionLogKind, type ReviewTeamOutcomeFragmentInput, type RouteToTeammateOptions, type TeamMailboxMessage, type TeamMemberSnapshot, TeamMessageType, type TeammateLifecycleSpec, type TeamOutcome, type TeamOutcomeFragment, type TeamOutcomeFragmentStatus, type TeamOutcomeStatus, type TeamRunRecord, type TeamRunStatus, type TeamRuntimeSnapshot, type TeamRuntimeState, type TeamTask, type TeamTaskListItem, type TeamTaskStatus, } from "@cline/shared";
+export interface TeamMemberConfig extends AgentConfig {
+    role?: string;
+}
+export interface AgentTask {
+    agentId: string;
+    message: string;
+    metadata?: Record<string, unknown>;
+}
+export interface TaskResult {
+    agentId: string;
+    result: AgentResult;
+    error?: Error;
+    metadata?: Record<string, unknown>;
+}
+export type TeamEvent = {
+    type: TeamMessageType.TaskStart;
+    agentId: string;
+    message: string;
+} | {
+    type: TeamMessageType.TaskEnd;
+    agentId: string;
+    result?: AgentResult;
+    error?: Error;
+    messages?: AgentResult["messages"];
+} | {
+    type: TeamMessageType.AgentEvent;
+    agentId: string;
+    event: AgentEvent;
+} | {
+    type: TeamMessageType.TeammateSpawned;
+    agentId: string;
+    role?: string;
+    teammate: TeammateLifecycleSpec;
+} | {
+    type: TeamMessageType.TeammateShutdown;
+    agentId: string;
+    reason?: string;
+} | {
+    type: TeamMessageType.TeamTaskUpdated;
+    task: TeamTask;
+} | {
+    type: TeamMessageType.TeamMessage;
+    message: TeamMailboxMessage;
+} | {
+    type: TeamMessageType.TeamMissionLog;
+    entry: MissionLogEntry;
+} | {
+    type: TeamMessageType.RunQueued;
+    run: TeamRunRecord;
+} | {
+    type: TeamMessageType.RunStarted;
+    run: TeamRunRecord;
+} | {
+    type: TeamMessageType.RunProgress;
+    run: TeamRunRecord;
+    message: string;
+} | {
+    type: TeamMessageType.RunCompleted;
+    run: TeamRunRecord;
+} | {
+    type: TeamMessageType.RunFailed;
+    run: TeamRunRecord;
+} | {
+    type: TeamMessageType.RunCancelled;
+    run: TeamRunRecord;
+    reason?: string;
+} | {
+    type: TeamMessageType.RunInterrupted;
+    run: TeamRunRecord;
+    reason?: string;
+} | {
+    type: TeamMessageType.OutcomeCreated;
+    outcome: TeamOutcome;
+} | {
+    type: TeamMessageType.OutcomeFragmentAttached;
+    fragment: TeamOutcomeFragment;
+} | {
+    type: TeamMessageType.OutcomeFragmentReviewed;
+    fragment: TeamOutcomeFragment;
+} | {
+    type: TeamMessageType.OutcomeFinalized;
+    outcome: TeamOutcome;
+};
+export interface AgentTeamsRuntimeOptions {
+    teamName: string;
+    leadAgentId?: string;
+    missionLogIntervalSteps?: number;
+    missionLogIntervalMs?: number;
+    maxConcurrentRuns?: number;
+    onTeamEvent?: (event: TeamEvent) => void;
+}
+export interface SpawnTeammateOptions {
+    agentId: string;
+    config: TeamMemberConfig;
+}
+export declare class AgentTeam {
+    private agents;
+    private configs;
+    private onTeamEvent?;
+    constructor(configs?: Record<string, TeamMemberConfig>, onTeamEvent?: (event: TeamEvent) => void);
+    addAgent(id: string, config: TeamMemberConfig): void;
+    removeAgent(id: string): boolean;
+    getAgent(id: string): SessionRuntime | undefined;
+    getAgentIds(): string[];
+    get size(): number;
+    routeTo(agentId: string, message: string): Promise<AgentResult>;
+    continueTo(agentId: string, message: string): Promise<AgentResult>;
+    runParallel(tasks: AgentTask[]): Promise<TaskResult[]>;
+    runSequential(tasks: AgentTask[]): Promise<TaskResult[]>;
+    runPipeline(pipeline: string[], initialMessage: string, messageTransformer?: (prevResult: AgentResult, nextAgentId: string) => string): Promise<TaskResult[]>;
+    abortAll(): void;
+    clear(): void;
+    private emitEvent;
+}
+export declare function createAgentTeam(configs: Record<string, TeamMemberConfig>, onTeamEvent?: (event: TeamEvent) => void): AgentTeam;
+export declare function createWorkerReviewerTeam(configs: {
+    worker: TeamMemberConfig;
+    reviewer: TeamMemberConfig;
+}): AgentTeam & {
+    doAndReview: (message: string) => Promise<{
+        workerResult: AgentResult;
+        reviewResult: AgentResult;
+    }>;
+};
+export declare class AgentTeamsRuntime {
+    private readonly teamId;
+    private readonly teamName;
+    private readonly onTeamEvent?;
+    private readonly members;
+    private readonly tasks;
+    private readonly missionLog;
+    private readonly mailbox;
+    private missionStepCounter;
+    private taskCounter;
+    private messageCounter;
+    private missionCounter;
+    private runCounter;
+    private outcomeCounter;
+    private outcomeFragmentCounter;
+    private readonly runs;
+    private readonly runQueue;
+    private queuedRunDispatchTimer;
+    private readonly outcomes;
+    private readonly outcomeFragments;
+    private readonly missionLogIntervalSteps;
+    private readonly missionLogIntervalMs;
+    private readonly maxConcurrentRuns;
+    constructor(options: AgentTeamsRuntimeOptions);
+    getTeamId(): string;
+    getTeamName(): string;
+    getMemberRole(agentId: string): "lead" | "teammate" | undefined;
+    getMemberIds(): string[];
+    getTeammateIds(): string[];
+    getTask(taskId: string): TeamTask | undefined;
+    listTasks(): TeamTask[];
+    listTaskItems(options?: {
+        status?: TeamTaskStatus;
+        assignee?: string;
+    }): TeamTaskListItem[];
+    listMissionLog(limit?: number): MissionLogEntry[];
+    listMailbox(agentId: string, options?: {
+        unreadOnly?: boolean;
+        markRead?: boolean;
+        limit?: number;
+    }): TeamMailboxMessage[];
+    getSnapshot(): TeamRuntimeSnapshot;
+    exportState(): TeamRuntimeState;
+    hydrateState(state: TeamRuntimeState): void;
+    isTeammateActive(agentId: string): boolean;
+    spawnTeammate({ agentId, config }: SpawnTeammateOptions): TeamMemberSnapshot;
+    shutdownTeammate(agentId: string, reason?: string): void;
+    updateTeammateConnections(overrides: Partial<Pick<AgentConfig, "apiKey" | "baseUrl" | "headers">>): void;
+    createTask(input: CreateTeamTaskInput): TeamTask;
+    claimTask(taskId: string, agentId: string): TeamTask;
+    blockTask(taskId: string, agentId: string, reason: string): TeamTask;
+    completeTask(taskId: string, agentId: string, summary: string): TeamTask;
+    routeToTeammate(agentId: string, message: string, options?: RouteToTeammateOptions): Promise<AgentResult>;
+    startTeammateRun(agentId: string, message: string, options?: RouteToTeammateOptions & {
+        priority?: number;
+        maxRetries?: number;
+        leaseOwner?: string;
+    }): TeamRunRecord;
+    private dispatchQueuedRuns;
+    private selectNextDispatchableQueuedRun;
+    private scheduleQueuedRunDispatch;
+    private clearQueuedRunDispatchTimer;
+    private countActiveRuns;
+    private executeQueuedRun;
+    listRuns(options?: {
+        status?: TeamRunStatus | null;
+        agentId?: string | null;
+        includeCompleted?: boolean | null;
+    }): TeamRunRecord[];
+    getRun(runId: string): TeamRunRecord | undefined;
+    awaitRun(runId: string, pollIntervalMs?: number): Promise<TeamRunRecord>;
+    awaitAllRuns(pollIntervalMs?: number): Promise<TeamRunRecord[]>;
+    cancelRun(runId: string, reason?: string): TeamRunRecord;
+    recoverActiveRuns(reason?: string): TeamRunRecord[];
+    markStaleRunsInterrupted(reason?: string): TeamRunRecord[];
+    sendMessage(fromAgentId: string, toAgentId: string, subject: string, body: string, taskId?: string): TeamMailboxMessage;
+    broadcast(fromAgentId: string, subject: string, body: string, options?: {
+        taskId?: string;
+    }): TeamMailboxMessage[];
+    appendMissionLog(input: AppendMissionLogInput): MissionLogEntry;
+    createOutcome(input: CreateTeamOutcomeInput): TeamOutcome;
+    listOutcomes(): TeamOutcome[];
+    attachOutcomeFragment(input: AttachTeamOutcomeFragmentInput): TeamOutcomeFragment;
+    reviewOutcomeFragment(input: ReviewTeamOutcomeFragmentInput): TeamOutcomeFragment;
+    listOutcomeFragments(outcomeId: string): TeamOutcomeFragment[];
+    finalizeOutcome(outcomeId: string): TeamOutcome;
+    cleanup(): void;
+    private requireTask;
+    private assertDependenciesResolved;
+    private getUnresolvedDependencies;
+    private trackMeaningfulEvent;
+    private recordRunActivityFromAgentEvent;
+    private recordRunProgress;
+    private formatProgressErrorActivity;
+    private recordProgressStep;
+    private buildMailboxNotification;
+    private emitEvent;
+}

package/dist/extensions/tools/team/projections.d.ts

@@ -0,0 +1,8 @@
+import type { TeamProgressLifecycleEvent, TeamProgressSummary, TeamRuntimeState } from "@cline/shared";
+import type { TeamEvent } from "./multi-agent";
+export declare function buildTeamProgressSummary(teamName: string, state: TeamRuntimeState): TeamProgressSummary;
+export declare function toTeamProgressLifecycleEvent(input: {
+    teamName: string;
+    sessionId: string;
+    event: TeamEvent;
+}): TeamProgressLifecycleEvent;

package/dist/extensions/tools/team/runtime.d.ts

@@ -0,0 +1,4 @@
+export { buildDelegatedAgentConfig, createDelegatedAgent, createDelegatedAgentConfigProvider, type DelegatedAgentConfigProvider, type DelegatedAgentConnectionConfig, type DelegatedAgentKind, type DelegatedAgentRuntimeConfig, } from "./delegated-agent";
+export { createSpawnAgentTool, type SpawnAgentInput, type SpawnAgentOutput, type SpawnAgentToolConfig, type SubAgentEndContext, type SubAgentStartContext, } from "./spawn-agent-tool";
+export { type AgentTask, AgentTeam, AgentTeamsRuntime, type AgentTeamsRuntimeOptions, createAgentTeam, createWorkerReviewerTeam, type SpawnTeammateOptions, type TaskResult, type TeamEvent, type TeamMemberConfig, } from "./multi-agent";
+export { type BootstrapAgentTeamsOptions, type BootstrapAgentTeamsResult, bootstrapAgentTeams, type CreateAgentTeamsToolsOptions, createAgentTeamsTools, reviveTeamStateDates, sanitizeTeamName, type TeamTeammateRuntimeConfig, } from "./team-tools";