@evalops/maestro 0.10.17 → 0.10.20

package/dist/agent/swarm/executor.js

@@ -10,13 +10,48 @@ import { randomUUID } from "node:crypto";
 import { unlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { formatDelegation } from "@evalops/contracts";
+import { codexSubagentTypeA2ASkillID } from "../../codex/subagent-dispatch-table.js";
 import { buildEvalOpsDelegationEnvironment, issueEvalOpsDelegationToken, } from "../../oauth/index.js";
+import { rankA2ACapabilityPeers } from "../../platform/a2a-capability-market.js";
+import { buildA2AUserMessage, cancelA2ATask, getA2ATask, normalizeA2ABaseUrl, sendA2AMessage, } from "../../platform/a2a-client.js";
+import { resolveA2APeer, } from "../../platform/a2a-peer-registry.js";
+import { extractA2ATaskText, isTerminalA2AState, recordA2ATaskStart, updateA2ATaskInLedger, } from "../../platform/a2a-task-ledger.js";
+import { PlatformAgentStatusValue, listA2APeerCandidatesWithPlatform, resolveAgentRegistryServiceConfig, } from "../../platform/agent-registry-client.js";
+import { getEnvValue, trimString } from "../../platform/client.js";
+import { recordSubagentDispatch } from "../../telemetry.js";
 import { createLogger } from "../../utils/logger.js";
+import { parseMode, resolveSubagentDispatch, } from "../modes.js";
+import { publishSwarmRuntimeEvent } from "./runtime-events.js";
 const logger = createLogger("agent:swarm:executor");
 /** Default timeout per task (5 minutes) */
 const DEFAULT_TASK_TIMEOUT_MS = 5 * 60 * 1000;
 /** Maximum concurrent teammates */
 const MAX_TEAMMATES = 10;
+const DEFAULT_A2A_POLL_INTERVAL_MS = 2_000;
+const A2A_SKILL_PRIMARY_TASK_CLASSES = new Map([
+    ["maestro.subagent.code-writer", "code.implementation"],
+    ["maestro.subagent.code-review", "code.review"],
+    ["maestro.subagent.test-runner", "test.execution"],
+    ["maestro.subagent.repo-explorer", "repo.inspect"],
+    ["maestro.subagent.release-shepherd", "release.follow-through"],
+]);
+const SWARM_SUBAGENT_TASK_CLASSES = new Map([
+    ["coder", "code.implementation"],
+    ["worker", "code.implementation"],
+    ["review", "code.review"],
+    ["reviewer", "code.review"],
+    ["explore", "repo.inspect"],
+    ["explorer", "repo.inspect"],
+    ["research", "repo.inspect"],
+    ["researcher", "repo.inspect"],
+    ["test", "test.execution"],
+    ["ci", "test.execution"],
+    ["ci-monitor", "test.execution"],
+    ["planner", "agent.delegation"],
+    ["minimal", "agent.delegation"],
+    ["custom", "agent.delegation"],
+]);
 /** Teammate name prefixes for friendly identification */
 const TEAMMATE_NAMES = [
     "Alpha",
@@ -30,6 +65,12 @@ const TEAMMATE_NAMES = [
     "Iota",
     "Kappa",
 ];
+const MODEL_PROVIDERS = [
+    "anthropic",
+    "openai",
+    "openai-codex",
+    "google",
+];
 function toSafeTaskTempBasename(taskId) {
     const safeId = taskId
         .replace(/[^A-Za-z0-9_-]+/g, "_")
@@ -50,11 +91,18 @@ function cloneTeammate(teammate) {
             ? cloneTask(teammate.currentTask)
             : undefined,
         completedTasks: [...teammate.completedTasks],
+        a2a: teammate.a2a ? { ...teammate.a2a } : undefined,
     };
 }
 function cloneConfig(config) {
     return {
         ...config,
+        a2a: config.a2a
+            ? {
+                ...config.a2a,
+                peers: config.a2a.peers ? [...config.a2a.peers] : undefined,
+            }
+            : undefined,
         tasks: config.tasks.map(cloneTask),
     };
 }
@@ -69,12 +117,81 @@ function cloneState(state) {
         failedTasks: new Set(state.failedTasks),
     };
 }
+function parseModelProvider(value) {
+    const provider = value?.trim();
+    if (!provider) {
+        return undefined;
+    }
+    return MODEL_PROVIDERS.includes(provider)
+        ? provider
+        : undefined;
+}
+function parseAgentMode(value) {
+    const mode = value?.trim();
+    if (!mode) {
+        return undefined;
+    }
+    return parseMode(mode) ?? undefined;
+}
+function providerFromPrefixedModel(model) {
+    const slashIndex = model?.indexOf("/") ?? -1;
+    if (!model || slashIndex <= 0) {
+        return undefined;
+    }
+    return parseModelProvider(model.slice(0, slashIndex));
+}
+function parseBooleanEnv(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (!normalized) {
+        return undefined;
+    }
+    if (["1", "true", "yes", "on"].includes(normalized)) {
+        return true;
+    }
+    if (["0", "false", "no", "off"].includes(normalized)) {
+        return false;
+    }
+    return undefined;
+}
+function parsePositiveIntEnv(value) {
+    const parsed = Number.parseInt(value ?? "", 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+function parseCSVEnv(value) {
+    const parsed = value
+        ?.split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+    return parsed && parsed.length > 0 ? parsed : undefined;
+}
+function a2aStateCompleted(state) {
+    return /COMPLETED/u.test((state ?? "").toUpperCase().replace(/[\s-]+/gu, "_"));
+}
+function buildDispatchEnv(dispatch, reasoningEffortOverride, runtimeSelection) {
+    if (!dispatch) {
+        return {};
+    }
+    const env = {
+        MAESTRO_SWARM_MODE_NAME: dispatch.mode,
+        MAESTRO_SWARM_SUBAGENT_TYPE: dispatch.type,
+        MAESTRO_SWARM_MODEL: runtimeSelection?.model ?? dispatch.model,
+        MAESTRO_SWARM_REASONING_EFFORT: reasoningEffortOverride ?? dispatch.reasoningEffort,
+        MAESTRO_SWARM_DISPATCH_SOURCE: runtimeSelection?.source ?? dispatch.source,
+    };
+    const provider = runtimeSelection?.provider ?? dispatch.provider;
+    if (provider) {
+        env.MAESTRO_SWARM_MODEL_PROVIDER = provider;
+    }
+    return env;
+}
 /**
  * SwarmExecutor manages a swarm of parallel agent instances.
  */
 export class SwarmExecutor {
     constructor(config) {
         this.processes = new Map();
+        this.remoteA2ATasks = new Map();
+        this.a2aRouteCursor = 0;
         this.eventHandlers = new Set();
         // Validate config
         if (config.teammateCount < 1 || config.teammateCount > MAX_TEAMMATES) {
@@ -119,6 +236,12 @@ export class SwarmExecutor {
      * Emit an event to all handlers.
      */
     emit(event) {
+        publishSwarmRuntimeEvent({
+            event,
+            parentSessionId: this.state.config.parentSessionId,
+            cwd: this.state.config.cwd,
+            planFile: this.state.config.planFile,
+        });
         for (const handler of this.eventHandlers) {
             try {
                 handler(event);
@@ -138,6 +261,10 @@ export class SwarmExecutor {
      * Cancel the swarm execution.
      */
     cancel() {
+        const remoteTasks = [...this.remoteA2ATasks.entries()];
+        for (const [teammateId, remoteTask] of remoteTasks) {
+            void this.cancelRemoteA2ATask(teammateId, remoteTask);
+        }
         this.abortController.abort();
         this.state.status = "cancelled";
         // Kill all running processes
@@ -165,6 +292,24 @@ export class SwarmExecutor {
         this.processes.clear();
         logger.info("Swarm cancelled", { swarmId: this.state.id });
     }
+    async cancelRemoteA2ATask(teammateId, remoteTask) {
+        try {
+            const cancelledTask = await cancelA2ATask(remoteTask.route.config, remoteTask.taskId);
+            await this.updateA2ASwarmTaskLedger(remoteTask.route, cancelledTask);
+        }
+        catch (error) {
+            logger.warn("Failed to cancel remote A2A swarm task", {
+                error: error instanceof Error ? error.message : String(error),
+                swarmId: this.state.id,
+                teammateId,
+                remoteTaskId: remoteTask.taskId,
+                peer: remoteTask.route.name,
+            });
+        }
+        finally {
+            this.remoteA2ATasks.delete(teammateId);
+        }
+    }
     /**
      * Execute the swarm - runs all tasks with available teammates.
      */
@@ -181,6 +326,7 @@ export class SwarmExecutor {
             // Main execution loop
             while (this.state.status === "running" &&
                 (this.state.pendingTasks.length > 0 || this.state.activeTasks.size > 0)) {
+                this.skipTasksBlockedByFailedDependencies();
                 // Assign tasks to idle teammates
                 await this.assignTasks();
                 // Wait for any task to complete
@@ -265,8 +411,7 @@ export class SwarmExecutor {
         for (const task of this.state.pendingTasks) {
             // Check dependencies
             if (task.dependsOn && task.dependsOn.length > 0) {
-                const allDepsCompleted = task.dependsOn.every((depId) => this.state.completedTasks.has(depId) ||
-                    this.state.failedTasks.has(depId));
+                const allDepsCompleted = task.dependsOn.every((depId) => this.state.completedTasks.has(depId));
                 if (!allDepsCompleted)
                     continue;
             }
@@ -274,15 +419,38 @@ export class SwarmExecutor {
         }
         return null;
     }
+    skipTasksBlockedByFailedDependencies() {
+        const blockedTasks = this.state.pendingTasks.filter((task) => task.dependsOn?.some((depId) => this.state.failedTasks.has(depId)));
+        for (const task of blockedTasks) {
+            const pendingIndex = this.state.pendingTasks.findIndex((candidate) => candidate.id === task.id);
+            if (pendingIndex >= 0) {
+                this.state.pendingTasks.splice(pendingIndex, 1);
+            }
+            this.state.failedTasks.add(task.id);
+            const failedDependency = task.dependsOn?.find((depId) => this.state.failedTasks.has(depId));
+            const error = `Dependency ${failedDependency ?? "unknown"} failed`;
+            this.emit({
+                type: "task_fail",
+                swarmId: this.state.id,
+                teammateId: "dependency",
+                taskId: task.id,
+                error,
+            });
+            if (!this.state.config.continueOnFailure) {
+                this.state.status = "failed";
+            }
+        }
+    }
     /**
      * Spawn a subprocess agent for a teammate.
      */
-    async buildTeammateEnv(teammate, task) {
+    async buildTeammateEnv(teammate, task, dispatch, runtimeSelection) {
         const baseEnv = {
             ...process.env,
             MAESTRO_SWARM_MODE: "1",
             MAESTRO_SWARM_ID: this.state.id,
             MAESTRO_TEAMMATE_ID: teammate.id,
+            ...buildDispatchEnv(dispatch, this.state.config.reasoningEffort, runtimeSelection),
         };
         try {
             const delegation = await issueEvalOpsDelegationToken({
@@ -314,31 +482,302 @@ export class SwarmExecutor {
             return baseEnv;
         }
     }
+    resolveTaskDispatch(task, teammate, options = {}) {
+        const startedAt = Date.now();
+        const subagentType = task.subagentType ?? this.state.config.subagentType;
+        if (!subagentType) {
+            return null;
+        }
+        const mode = this.resolveParentMode();
+        const parentProvider = this.resolveParentModelProvider();
+        const dispatch = resolveSubagentDispatch(mode, subagentType, parentProvider ?? "anthropic");
+        if (!parentProvider && dispatch.modelTier && !options.hasModelOverride) {
+            this.recordTaskDispatch(task, dispatch, Math.max(0, Date.now() - startedAt), false, {
+                parentMode: mode,
+                parentModelProvider: parentProvider,
+                teammateId: teammate.id,
+                reason: "missing_parent_model_provider",
+            });
+            return null;
+        }
+        return {
+            dispatch,
+            startedAt,
+            latencyMs: Math.max(0, Date.now() - startedAt),
+            parentMode: mode,
+            parentModelProvider: parentProvider,
+        };
+    }
+    recordTaskDispatch(task, dispatch, latencyMs, success, options) {
+        recordSubagentDispatch({
+            mode: dispatch.mode,
+            subagentType: dispatch.type,
+            model: options.model ?? dispatch.model,
+            provider: options.provider ?? dispatch.provider,
+            reasoningEffort: this.state.config.reasoningEffort ?? dispatch.reasoningEffort,
+            latencyMs,
+            success,
+            source: options.source ?? dispatch.source,
+            metadata: {
+                swarmId: this.state.id,
+                teammateId: options.teammateId,
+                taskId: task.id,
+                parentMode: options.parentMode,
+                parentModelProvider: options.parentModelProvider,
+                dispatchModel: dispatch.model,
+                dispatchProvider: dispatch.provider,
+                dispatchSource: dispatch.source,
+                modelTier: dispatch.modelTier,
+                modelOverride: options.modelOverride,
+                reason: options.reason,
+            },
+        });
+    }
+    resolveParentMode() {
+        return (this.state.config.mode ??
+            parseAgentMode(process.env.MAESTRO_MODE) ??
+            "smart");
+    }
+    resolveParentModelProvider() {
+        return (this.state.config.modelProvider ??
+            parseModelProvider(process.env.MAESTRO_MODEL_PROVIDER) ??
+            providerFromPrefixedModel(process.env.MAESTRO_MODEL));
+    }
+    resolveA2AConfig() {
+        const transport = this.state.config.transport ??
+            trimString(process.env.MAESTRO_SWARM_TRANSPORT);
+        if (transport !== "a2a") {
+            return null;
+        }
+        const configured = this.state.config.a2a ?? {};
+        const peers = configured.peers ?? parseCSVEnv(getEnvValue(["MAESTRO_SWARM_A2A_PEERS"]));
+        return {
+            ...configured,
+            ...(peers ? { peers } : {}),
+            registryPath: configured.registryPath ??
+                trimString(process.env.MAESTRO_SWARM_A2A_REGISTRY),
+            tasksPath: configured.tasksPath ?? trimString(process.env.MAESTRO_SWARM_A2A_TASKS),
+            skillId: configured.skillId ??
+                trimString(process.env.MAESTRO_SWARM_A2A_SKILL_ID),
+            role: configured.role ?? trimString(process.env.MAESTRO_SWARM_A2A_ROLE),
+            discover: configured.discover ??
+                parseBooleanEnv(process.env.MAESTRO_SWARM_A2A_DISCOVER),
+            workspaceId: configured.workspaceId ??
+                trimString(process.env.MAESTRO_SWARM_A2A_WORKSPACE_ID),
+            capability: configured.capability ??
+                trimString(process.env.MAESTRO_SWARM_A2A_CAPABILITY),
+            surface: configured.surface ?? trimString(process.env.MAESTRO_SWARM_A2A_SURFACE),
+            preferInternalEndpoint: configured.preferInternalEndpoint ??
+                parseBooleanEnv(process.env.MAESTRO_SWARM_A2A_PREFER_INTERNAL),
+            limit: configured.limit ??
+                parsePositiveIntEnv(process.env.MAESTRO_SWARM_A2A_LIMIT),
+            timeoutMs: configured.timeoutMs ??
+                parsePositiveIntEnv(process.env.MAESTRO_SWARM_A2A_TIMEOUT_MS),
+            maxAttempts: configured.maxAttempts ??
+                parsePositiveIntEnv(process.env.MAESTRO_SWARM_A2A_MAX_ATTEMPTS),
+            maxWaitMs: configured.maxWaitMs ??
+                parsePositiveIntEnv(process.env.MAESTRO_SWARM_A2A_MAX_WAIT_MS),
+            pollIntervalMs: configured.pollIntervalMs ??
+                parsePositiveIntEnv(process.env.MAESTRO_SWARM_A2A_POLL_INTERVAL_MS),
+        };
+    }
+    async resolveA2ATeammateRoute(teammate, task, options) {
+        if (options.discover) {
+            return this.resolvePlatformDiscoveredA2ATeammateRoute(teammate, task, options);
+        }
+        const peerName = this.selectA2APeerName(teammate, task, options);
+        const peer = await resolveA2APeer(peerName, {
+            path: options.registryPath,
+            timeoutMs: options.timeoutMs,
+            maxAttempts: options.maxAttempts,
+        });
+        return {
+            name: peer.name,
+            displayName: peer.entry.displayName,
+            config: peer.config,
+            skillId: this.resolveA2ASkillId(task, options, peer),
+            role: options.role ?? task.subagentType,
+            tasksPath: options.tasksPath,
+            source: "registry",
+        };
+    }
+    async resolvePlatformDiscoveredA2ATeammateRoute(teammate, task, options) {
+        const skillId = this.resolveA2ASkillId(task, options);
+        const pinnedPeer = trimString(task.a2aPeer);
+        const routeIndex = pinnedPeer ? 0 : this.nextA2ARouteIndex();
+        const candidates = await listA2APeerCandidatesWithPlatform({
+            workspaceId: options.workspaceId,
+            capability: options.capability,
+            surface: options.surface ?? "a2a",
+            status: PlatformAgentStatusValue.Idle,
+            limit: options.limit ??
+                (pinnedPeer ? undefined : this.defaultA2ADiscoveryLimit()),
+            skillId,
+            preferInternalEndpoint: options.preferInternalEndpoint,
+        });
+        if (!candidates || candidates.length === 0) {
+            throw new Error(`No Platform A2A peers available for swarm task ${task.id}${skillId ? ` with skill ${skillId}` : ""}`);
+        }
+        const candidatePool = pinnedPeer
+            ? candidates.filter((candidate) => platformA2ACandidateMatchesPeer(candidate, pinnedPeer))
+            : candidates;
+        if (candidatePool.length === 0) {
+            throw new Error(`No Platform A2A peer matched task ${task.id} a2aPeer ${pinnedPeer}`);
+        }
+        const rankedCandidates = rankA2ACapabilityPeers(candidatePool, {
+            skillId,
+            taskClass: this.resolveA2ATaskClass(task, options, skillId),
+            preferInternalEndpoint: options.preferInternalEndpoint,
+        });
+        if (rankedCandidates.length === 0) {
+            throw new Error(`No Platform A2A peer satisfied capability policy for swarm task ${task.id}${skillId ? ` with skill ${skillId}` : ""}`);
+        }
+        const candidateIndex = pinnedPeer
+            ? 0
+            : routeIndex % rankedCandidates.length;
+        const ranked = rankedCandidates[candidateIndex];
+        const candidate = ranked?.candidate;
+        if (!candidate || !ranked) {
+            throw new Error("Platform A2A peer discovery returned an invalid candidate");
+        }
+        logger.info("Selected Platform A2A peer through capability market", {
+            swarmId: this.state.id,
+            taskId: task.id,
+            agentId: candidate.agent.id,
+            score: ranked.score,
+            reasons: ranked.reasons,
+            skillId: ranked.selectedSkill?.id ?? skillId,
+        });
+        const config = await this.a2aConfigForPlatformCandidate(candidate, options);
+        return {
+            name: candidate.agent.name ?? candidate.agent.id ?? candidate.endpointUrl,
+            displayName: candidate.agent.name,
+            config,
+            skillId: ranked.selectedSkill?.id ?? skillId,
+            role: options.role ?? task.subagentType,
+            tasksPath: options.tasksPath,
+            source: "platform-agent-registry",
+        };
+    }
+    async a2aConfigForPlatformCandidate(candidate, options) {
+        const platformConfig = await resolveAgentRegistryServiceConfig();
+        if (!platformConfig) {
+            throw new Error("Platform Agent Registry service is not configured for A2A swarm discovery");
+        }
+        return {
+            baseUrl: normalizeA2ABaseUrl(candidate.endpointUrl),
+            ...(platformConfig.token ? { token: platformConfig.token } : {}),
+            ...(platformConfig.organizationId
+                ? { organizationId: platformConfig.organizationId }
+                : {}),
+            workspaceId: candidate.agent.workspaceId ??
+                options.workspaceId ??
+                platformConfig.workspaceId,
+            ...(candidate.agent.id ? { agentId: candidate.agent.id } : {}),
+            actorId: "maestro-swarm",
+            timeoutMs: options.timeoutMs ?? platformConfig.timeoutMs,
+            maxAttempts: options.maxAttempts ?? platformConfig.maxAttempts,
+        };
+    }
+    selectA2APeerName(teammate, task, options) {
+        const peerName = trimString(task.a2aPeer);
+        if (peerName) {
+            return peerName;
+        }
+        const peers = options.peers ?? [];
+        const selected = peers[this.nextA2ARouteIndex() % peers.length];
+        if (!selected) {
+            throw new Error("Remote A2A swarm transport requires a task a2aPeer, a2a.peers, MAESTRO_SWARM_A2A_PEERS, or a2a.discover=true");
+        }
+        return selected;
+    }
+    resolveA2ASkillId(task, options, peer) {
+        const configured = trimString(task.a2aSkillId) ??
+            trimString(options.skillId) ??
+            codexSubagentTypeA2ASkillID(task.subagentType ?? this.state.config.subagentType);
+        if (configured) {
+            return configured;
+        }
+        return peer?.entry.skills?.[0]?.id;
+    }
+    resolveA2ATaskClass(task, options, skillId) {
+        const mappedSkillTaskClass = skillId
+            ? A2A_SKILL_PRIMARY_TASK_CLASSES.get(skillId)
+            : undefined;
+        if (mappedSkillTaskClass) {
+            return mappedSkillTaskClass;
+        }
+        if (skillId &&
+            (trimString(task.a2aSkillId) || trimString(options.skillId))) {
+            return undefined;
+        }
+        const subagentType = trimString(task.subagentType ?? this.state.config.subagentType);
+        return ((subagentType
+            ? SWARM_SUBAGENT_TASK_CLASSES.get(subagentType)
+            : undefined) ?? subagentType);
+    }
+    teammateIndex(teammate) {
+        const index = this.state.teammates.findIndex((item) => item.id === teammate.id);
+        return index >= 0 ? index : 0;
+    }
+    nextA2ARouteIndex() {
+        const index = this.a2aRouteCursor;
+        this.a2aRouteCursor += 1;
+        return index;
+    }
+    defaultA2ADiscoveryLimit() {
+        return Math.max(1, this.state.config.teammateCount, this.state.config.tasks.length);
+    }
     async spawnTeammate(teammate, task) {
         const tmpFile = join(tmpdir(), `${this.state.id}-${toSafeTaskTempBasename(task.id)}`);
-        // Build prompt for the teammate
-        let prompt = `# Swarm Task: ${task.id}\n\n`;
-        prompt += `You are teammate "${teammate.name}" in a swarm working on a plan.\n\n`;
-        prompt += `## Your Task\n\n${task.prompt}\n\n`;
-        if (task.files && task.files.length > 0) {
-            prompt += `## Relevant Files\n\n${task.files.map((f) => `- ${f}`).join("\n")}\n\n`;
-        }
-        prompt += "## Instructions\n\n";
-        prompt += "1. Focus ONLY on your assigned task\n";
-        prompt += "2. Make changes directly - do not ask for confirmation\n";
-        prompt += "3. Report completion by summarizing what you did\n";
+        const delegationPrompt = {
+            goal: `Complete swarm task ${task.id} as teammate "${teammate.name}".`,
+            context: `You are teammate "${teammate.name}" in swarm ${this.state.id}, working from plan file ${this.state.config.planFile}.`,
+            task: task.prompt,
+            evidence: task.files?.length
+                ? task.files.map((file) => `Relevant file: ${file}`)
+                : [],
+            validation: "Make the requested changes directly, add or update focused tests when behavior changes, and run the relevant verification before finishing.",
+            stoppingCondition: "Stop when the assigned task is complete and report what changed, what you verified, and any blockers. Do not broaden into unrelated tasks.",
+        };
+        const prompt = formatDelegation(delegationPrompt);
         writeFileSync(tmpFile, prompt);
+        const a2aConfig = this.resolveA2AConfig();
+        if (a2aConfig) {
+            void this.spawnA2ATeammate(teammate, task, prompt, tmpFile, a2aConfig);
+            return;
+        }
+        const modelOverride = task.model !== undefined
+            ? "task"
+            : this.state.config.model !== undefined
+                ? "config"
+                : undefined;
+        const hasModelOverride = Boolean(modelOverride);
+        const dispatchResolution = this.resolveTaskDispatch(task, teammate, {
+            hasModelOverride,
+        });
+        const dispatch = dispatchResolution?.dispatch ?? null;
+        const model = task.model ?? this.state.config.model ?? dispatch?.model;
+        const overrideProvider = hasModelOverride
+            ? (providerFromPrefixedModel(model) ?? "unknown")
+            : undefined;
+        const telemetryProvider = overrideProvider ?? (hasModelOverride ? "unknown" : dispatch?.provider);
+        const dispatchSource = hasModelOverride ? "override" : dispatch?.source;
+        const provider = hasModelOverride ? undefined : dispatch?.provider;
         const args = [
             "--no-session",
-            ...(task.model
-                ? ["--model", task.model]
-                : this.state.config.model
-                    ? ["--model", this.state.config.model]
-                    : []),
+            ...(provider ? ["--provider", provider] : []),
+            ...(model ? ["--model", model] : []),
             "exec",
             tmpFile,
         ];
-        const env = await this.buildTeammateEnv(teammate, task);
+        const env = await this.buildTeammateEnv(teammate, task, dispatch, dispatch
+            ? {
+                model,
+                provider: telemetryProvider,
+                source: dispatchSource,
+            }
+            : undefined);
         if (this.state.status !== "running" ||
             this.abortController.signal.aborted) {
             try {
@@ -368,6 +807,26 @@ export class SwarmExecutor {
         });
         teammate.pid = proc.pid;
         this.processes.set(teammate.id, proc);
+        let dispatchRecorded = false;
+        const recordDispatchOutcome = (success, reason) => {
+            if (!dispatch || !dispatchResolution || dispatchRecorded) {
+                return;
+            }
+            dispatchRecorded = true;
+            this.recordTaskDispatch(task, dispatch, Math.max(0, Date.now() - dispatchResolution.startedAt), success, {
+                parentMode: dispatchResolution.parentMode,
+                parentModelProvider: dispatchResolution.parentModelProvider,
+                teammateId: teammate.id,
+                model,
+                provider: telemetryProvider,
+                source: dispatchSource,
+                modelOverride,
+                reason,
+            });
+        };
+        proc.once("spawn", () => {
+            recordDispatchOutcome(true);
+        });
         let output = "";
         let errorOutput = "";
         proc.stdout?.on("data", (data) => {
@@ -449,6 +908,7 @@ export class SwarmExecutor {
             }
         });
         proc.on("error", (err) => {
+            recordDispatchOutcome(false, "spawn_error");
             clearTimeout(timeoutHandle);
             this.processes.delete(teammate.id);
             this.state.activeTasks.delete(task.id);
@@ -499,6 +959,291 @@ export class SwarmExecutor {
             }
         });
     }
+    async spawnA2ATeammate(teammate, task, prompt, tmpFile, options) {
+        try {
+            const route = await this.resolveA2ATeammateRoute(teammate, task, options);
+            const messageId = `maestro-swarm-message-${randomUUID()}`;
+            const contextId = `maestro-swarm:${this.state.id}:${task.id}`;
+            const sent = await sendA2AMessage(route.config, {
+                message: buildA2AUserMessage({
+                    messageId,
+                    contextId,
+                    text: prompt,
+                    metadata: this.buildA2ASwarmMessageMetadata(teammate, task, route),
+                }),
+                configuration: {
+                    returnImmediately: true,
+                    acceptedOutputModes: ["text/plain", "application/json"],
+                },
+                metadata: {
+                    route: "maestro_swarm",
+                    transport: "a2a",
+                    swarmId: this.state.id,
+                    taskId: task.id,
+                    teammateId: teammate.id,
+                    peer: route.name,
+                    source: route.source,
+                },
+            });
+            teammate.a2a = {
+                peer: route.name,
+                peerDisplayName: route.displayName,
+                source: route.source,
+                taskId: sent.task.id,
+                contextId: sent.task.contextId ?? contextId,
+                messageId,
+                skillId: route.skillId,
+                role: route.role,
+            };
+            this.remoteA2ATasks.set(teammate.id, {
+                route,
+                taskId: sent.task.id,
+            });
+            await this.recordA2ASwarmTaskStart(route, task, sent.task, {
+                messageId,
+                contextId,
+            });
+            if (this.state.status === "cancelled" ||
+                this.abortController.signal.aborted) {
+                await this.cancelRemoteA2ATask(teammate.id, {
+                    route,
+                    taskId: sent.task.id,
+                });
+                return;
+            }
+            const remoteTask = await this.waitForA2ASwarmTask(route.config, sent.task, options);
+            await this.updateA2ASwarmTaskLedger(route, remoteTask);
+            this.completeA2ATeammate(teammate, task, remoteTask, route);
+        }
+        catch (error) {
+            if (this.state.status !== "cancelled" &&
+                !this.abortController.signal.aborted) {
+                const remoteTask = this.remoteA2ATasks.get(teammate.id);
+                if (remoteTask) {
+                    await this.cancelRemoteA2ATask(teammate.id, remoteTask);
+                }
+            }
+            this.failA2ATeammate(teammate, task, error);
+        }
+        finally {
+            this.remoteA2ATasks.delete(teammate.id);
+            try {
+                unlinkSync(tmpFile);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+    }
+    buildA2ASwarmMessageMetadata(teammate, task, route) {
+        const currentDelegationId = `${this.state.id}:${task.id}`;
+        const lineage = {
+            rootDelegationId: this.state.id,
+            ...(this.state.config.parentSessionId
+                ? { parentDelegationId: this.state.config.parentSessionId }
+                : {}),
+            currentDelegationId,
+            delegationChain: [this.state.id, currentDelegationId],
+            delegationChainDepth: 1,
+            maxDelegationChainDepth: 1,
+        };
+        const subagentRequest = route.skillId
+            ? {
+                skillId: route.skillId,
+                role: route.role,
+                cwd: this.state.config.cwd,
+                taskId: task.id,
+                swarmId: this.state.id,
+            }
+            : undefined;
+        return {
+            requestKind: "maestro-swarm-task",
+            transport: "a2a",
+            relayPeer: route.name,
+            swarmId: this.state.id,
+            teammateId: teammate.id,
+            teammateName: teammate.name,
+            taskId: task.id,
+            ...(route.skillId ? { a2aSkillId: route.skillId } : {}),
+            ...(task.files?.length ? { files: task.files } : {}),
+            swarm: lineage,
+            evalops: {
+                swarm: lineage,
+                transport: "a2a",
+                peer: route.name,
+            },
+            ...(subagentRequest
+                ? { "evalops.subagentRequest": subagentRequest }
+                : {}),
+        };
+    }
+    async waitForA2ASwarmTask(config, initialTask, options) {
+        const maxWaitMs = options.maxWaitMs ??
+            this.state.config.taskTimeout ??
+            DEFAULT_TASK_TIMEOUT_MS;
+        const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_A2A_POLL_INTERVAL_MS;
+        const deadline = Date.now() + maxWaitMs;
+        let task = initialTask;
+        while (!isTerminalA2AState(task.status.state) &&
+            Date.now() < deadline &&
+            !this.abortController.signal.aborted) {
+            await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+            task = await getA2ATask(config, task.id, {
+                signal: this.abortController.signal,
+            });
+        }
+        if (!isTerminalA2AState(task.status.state)) {
+            throw new Error(`Timed out waiting for remote A2A task ${task.id}; last state ${task.status.state}`);
+        }
+        return task;
+    }
+    completeA2ATeammate(teammate, task, remoteTask, route) {
+        this.state.activeTasks.delete(task.id);
+        teammate.completedAt = Date.now();
+        teammate.currentTask = undefined;
+        teammate.output =
+            extractA2ATaskText(remoteTask) ??
+                `Remote A2A task ${remoteTask.id} finished with ${remoteTask.status.state}`;
+        if (this.state.status === "cancelled" || teammate.status === "cancelled") {
+            teammate.status = "cancelled";
+            this.emit({
+                type: "teammate_complete",
+                swarmId: this.state.id,
+                teammate,
+            });
+            return;
+        }
+        if (a2aStateCompleted(remoteTask.status.state)) {
+            teammate.status = "completed";
+            teammate.completedTasks.push(task.id);
+            this.state.completedTasks.add(task.id);
+            this.emit({
+                type: "task_complete",
+                swarmId: this.state.id,
+                teammateId: teammate.id,
+                taskId: task.id,
+                output: teammate.output,
+            });
+        }
+        else {
+            teammate.status = "failed";
+            teammate.error = `Remote A2A task ${remoteTask.id} on ${route.name} ended in ${remoteTask.status.state}`;
+            this.state.failedTasks.add(task.id);
+            this.emit({
+                type: "task_fail",
+                swarmId: this.state.id,
+                teammateId: teammate.id,
+                taskId: task.id,
+                error: teammate.error,
+            });
+            if (!this.state.config.continueOnFailure) {
+                this.state.status = "failed";
+            }
+        }
+        this.emit({
+            type: "teammate_complete",
+            swarmId: this.state.id,
+            teammate,
+        });
+        if (this.state.status === "running" &&
+            (this.state.pendingTasks.length > 0 || this.state.activeTasks.size > 0) &&
+            (teammate.status === "completed" || this.state.config.continueOnFailure)) {
+            teammate.status = "pending";
+            teammate.error = undefined;
+        }
+    }
+    failA2ATeammate(teammate, task, error) {
+        this.state.activeTasks.delete(task.id);
+        teammate.completedAt = Date.now();
+        teammate.currentTask = undefined;
+        if (this.state.status === "cancelled" || teammate.status === "cancelled") {
+            teammate.status = "cancelled";
+            this.emit({
+                type: "teammate_complete",
+                swarmId: this.state.id,
+                teammate,
+            });
+            return;
+        }
+        if (teammate.a2a && !this.remoteA2ATasks.has(teammate.id)) {
+            teammate.a2a = undefined;
+        }
+        teammate.status = "failed";
+        teammate.error = error instanceof Error ? error.message : String(error);
+        this.state.failedTasks.add(task.id);
+        this.emit({
+            type: "task_fail",
+            swarmId: this.state.id,
+            teammateId: teammate.id,
+            taskId: task.id,
+            error: teammate.error,
+        });
+        if (!this.state.config.continueOnFailure) {
+            this.state.status = "failed";
+        }
+        this.emit({
+            type: "teammate_complete",
+            swarmId: this.state.id,
+            teammate,
+        });
+        if (this.state.status === "running" &&
+            (this.state.pendingTasks.length > 0 || this.state.activeTasks.size > 0) &&
+            this.state.config.continueOnFailure) {
+            teammate.status = "pending";
+            teammate.error = undefined;
+            teammate.a2a = undefined;
+        }
+    }
+    async recordA2ASwarmTaskStart(route, task, remoteTask, ids) {
+        try {
+            await recordA2ATaskStart({
+                path: route.tasksPath,
+                peer: route.name,
+                peerDisplayName: route.displayName,
+                task: remoteTask,
+                text: task.prompt,
+                messageId: ids.messageId,
+                contextId: remoteTask.contextId ?? ids.contextId,
+                kind: "delegation",
+                role: route.role,
+                cwd: this.state.config.cwd,
+                metadata: {
+                    requestKind: "maestro-swarm-task",
+                    relayPeer: route.name,
+                    swarmId: this.state.id,
+                    taskId: task.id,
+                    transport: "a2a",
+                    source: route.source,
+                    a2aSkillId: route.skillId,
+                },
+            });
+        }
+        catch (error) {
+            logger.warn("Failed to record remote A2A swarm task in local ledger", {
+                error: error instanceof Error ? error.message : String(error),
+                swarmId: this.state.id,
+                taskId: task.id,
+                peer: route.name,
+            });
+        }
+    }
+    async updateA2ASwarmTaskLedger(route, remoteTask) {
+        try {
+            await updateA2ATaskInLedger({
+                path: route.tasksPath,
+                peer: route.name,
+                task: remoteTask,
+            });
+        }
+        catch (error) {
+            logger.warn("Failed to update remote A2A swarm task in local ledger", {
+                error: error instanceof Error ? error.message : String(error),
+                swarmId: this.state.id,
+                remoteTaskId: remoteTask.id,
+                peer: route.name,
+            });
+        }
+    }
     /**
      * Wait for any active task to complete.
      */
@@ -516,6 +1261,36 @@ export class SwarmExecutor {
         });
     }
 }
+function platformA2ACandidateMatchesPeer(candidate, peer) {
+    const selector = normalizePeerSelector(peer);
+    const selectorBaseUrl = normalizePeerBaseUrl(peer);
+    if (!selector) {
+        return false;
+    }
+    const values = [
+        candidate.agent.id,
+        candidate.agent.name,
+        candidate.endpointUrl,
+        candidate.agentCardUrl,
+    ];
+    return values.some((value) => {
+        const candidateSelector = normalizePeerSelector(value);
+        if (candidateSelector && candidateSelector === selector) {
+            return true;
+        }
+        const candidateBaseUrl = normalizePeerBaseUrl(value);
+        return Boolean(selectorBaseUrl &&
+            candidateBaseUrl &&
+            candidateBaseUrl === selectorBaseUrl);
+    });
+}
+function normalizePeerSelector(value) {
+    return trimString(value)?.toLowerCase();
+}
+function normalizePeerBaseUrl(value) {
+    const trimmed = trimString(value);
+    return trimmed ? normalizeA2ABaseUrl(trimmed).toLowerCase() : undefined;
+}
 /**
  * Create and execute a swarm.
  */