@botbotgo/agent-harness 0.0.420 → 0.0.421

package/dist/runtime/agent-runtime-adapter.js

@@ -41,31 +41,43 @@ function hasDelegatedExecutionToolEvidence(result) {
         && !isPlanToolName(toolResult.toolName)));
 }
 function buildDelegatedPlanEvidenceBlocker(agentId) {
-    return [
-        "Status: blocked",
-        "Summary:",
-        `- Delegated agent ${agentId} ended before producing the required TODO plan evidence.`,
-        "",
-        "Blockers:",
-        "- The delegated run did not expose a valid planning trace, so the framework cannot treat the task as complete.",
-        "",
-        "Next Actions:",
-        "- Retry with the same request or inspect the delegated agent configuration and model/tool-call behavior.",
-    ].join("\n");
+    return JSON.stringify({
+        status: "blocked",
+        routing: [`delegated agent ${agentId}`],
+        plan: ["delegate to specialist", "require visible TODO planning evidence", "return blocker when planning evidence is absent"],
+        execution: [`task delegated to ${agentId}`, `delegated agent ${agentId} ended before producing required TODO plan evidence`],
+        todoTrace: ["TODO evidence missing"],
+        stepResults: ["delegated planning evidence was not observed"],
+        summary: [`Delegated agent ${agentId} ended before producing the required TODO plan evidence.`],
+        findings: ["The delegated run did not expose a valid planning trace, so the framework cannot treat the task as complete."],
+        blockers: ["missing delegated TODO planning evidence"],
+        nextActions: ["Retry with the same request or inspect the delegated agent configuration and model/tool-call behavior."],
+        report: `routing delegated to ${agentId}; todoTrace missing; stepResults blocked; summary missing planning evidence; findings require retry; blockers missing TODO planning evidence; nextActions inspect delegated model/tool behavior; report task delegated to ${agentId}.`,
+    });
 }
-function buildDelegatedExecutionEvidenceBlocker(agentId) {
-    return [
-        "Status: blocked",
-        "Summary:",
-        `- Delegated agent ${agentId} did not return any non-planning tool evidence after retry.`,
-        "",
-        "Blockers:",
-        "- The TODO board alone is not execution evidence.",
-        "- The framework cannot mark the delegated task complete without a non-planning tool result or an explicit blocker from that tool path.",
-        "",
-        "Next Actions:",
-        "- Retry the request or inspect the delegated agent's model/tool-call behavior.",
-    ].join("\n");
+function buildDelegatedExecutionEvidenceBlocker(agentId, expectedToolNames = []) {
+    const expectedTools = expectedToolNames.length > 0 ? expectedToolNames.join(", ") : "configured non-planning tools";
+    return JSON.stringify({
+        status: "blocked",
+        routing: [`delegated agent ${agentId}`],
+        plan: ["delegate to specialist", "require non-planning tool evidence", "return blocker when evidence is absent"],
+        execution: [
+            `task delegated to ${agentId}`,
+            `expected evidence tools: ${expectedTools}`,
+            `delegated agent ${agentId} did not return any non-planning tool evidence after retry`,
+        ],
+        todoTrace: ["TODO board observed without completed non-planning evidence"],
+        stepResults: ["delegated execution evidence was not observed"],
+        summary: [`Delegated agent ${agentId} did not return any non-planning tool evidence after retry.`],
+        findings: [
+            `Expected evidence tools from configuration: ${expectedTools}.`,
+            "The TODO board alone is not execution evidence.",
+            "The framework cannot mark the delegated task complete without a non-planning tool result or an explicit blocker from that tool path.",
+        ],
+        blockers: ["missing delegated non-planning tool evidence"],
+        nextActions: ["Retry the request or inspect the delegated agent's model/tool-call behavior."],
+        report: `routing delegated to ${agentId}; todoTrace observed planning only; stepResults blocked; summary missing non-planning tool evidence; findings expected evidence tools ${expectedTools}; blockers missing execution evidence; nextActions inspect delegated model/tool behavior; report task delegated to ${agentId}.`,
+    });
 }
 function normalizePlanToolName(toolName) {
     return typeof toolName === "string" ? toolName.trim().toLowerCase().replace(/[\s-]+/gu, "_") : "";
@@ -398,15 +410,14 @@ function parseCompactRouterSelection(value, subagentNames) {
     if (subagentNames.has(trimmed)) {
         return { subagentType: trimmed };
     }
-    const lowered = trimmed.toLowerCase();
-    const relaxedMatch = Array.from(subagentNames).find((name) => {
-        const lowerName = name.toLowerCase();
-        return lowerName.length > 0
-            && (trimmed === name || lowered.includes(lowerName));
-    });
-    if (relaxedMatch) {
-        return { subagentType: relaxedMatch };
-    }
+    const resolveRelaxedMatch = () => {
+        const lowered = trimmed.toLowerCase();
+        return Array.from(subagentNames).find((name) => {
+            const lowerName = name.toLowerCase();
+            return lowerName.length > 0
+                && (trimmed === name || lowered.includes(lowerName));
+        });
+    };
     const parsed = parseFirstJsonObject(trimmed);
     const toolCall = salvageJsonToolCalls(trimmed).at(0);
     const payload = typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
@@ -415,7 +426,8 @@ function parseCompactRouterSelection(value, subagentNames) {
             ? { name: toolCall.name, arguments: toolCall.args }
             : null;
     if (!payload) {
-        return null;
+        const relaxedMatch = resolveRelaxedMatch();
+        return relaxedMatch ? { subagentType: relaxedMatch } : null;
     }
     const args = typeof payload.arguments === "object" && payload.arguments !== null && !Array.isArray(payload.arguments)
         ? payload.arguments
@@ -430,6 +442,48 @@ function parseCompactRouterSelection(value, subagentNames) {
     if (subagentNames.has(subagentType)) {
         return { subagentType };
     }
+    const rawDelegations = Array.isArray(payload.delegations)
+        ? payload.delegations
+        : Array.isArray(args.delegations)
+            ? args.delegations
+            : undefined;
+    if (rawDelegations) {
+        const delegations = rawDelegations
+            .map((item) => {
+            if (typeof item !== "object" || item === null || Array.isArray(item)) {
+                return null;
+            }
+            const typed = item;
+            const rawName = typeof typed.subagent_type === "string"
+                ? typed.subagent_type.trim()
+                : typeof typed.subagent === "string"
+                    ? typed.subagent.trim()
+                    : "";
+            const resolvedName = Array.from(subagentNames).find((name) => name.toLowerCase() === rawName.toLowerCase());
+            if (!resolvedName) {
+                return null;
+            }
+            const description = typeof typed.description === "string" && typed.description.trim()
+                ? typed.description.trim()
+                : typeof typed.task === "string" && typed.task.trim()
+                    ? typed.task.trim()
+                    : typeof typed.instruction === "string" && typed.instruction.trim()
+                        ? typed.instruction.trim()
+                        : "";
+            return { subagentType: resolvedName, description };
+        })
+            .filter((item) => item !== null);
+        const deduped = [];
+        for (const delegation of delegations) {
+            if (deduped.some((item) => item.subagentType === delegation.subagentType)) {
+                continue;
+            }
+            deduped.push(delegation);
+        }
+        if (deduped.length > 0) {
+            return { delegations: deduped };
+        }
+    }
     const status = typeof payload.status === "string" ? payload.status.trim().toLowerCase() : "";
     if (status === "refused") {
         const reason = typeof payload.reason === "string" && payload.reason.trim()
@@ -437,6 +491,10 @@ function parseCompactRouterSelection(value, subagentNames) {
             : "No configured subagent can handle the request.";
         return { refusedReason: reason };
     }
+    const relaxedMatch = resolveRelaxedMatch();
+    if (relaxedMatch) {
+        return { subagentType: relaxedMatch };
+    }
     return null;
 }
 function inferCompactRouterSelectionFromRequest(requestText, subagents) {
@@ -468,6 +526,176 @@ function inferCompactRouterSelectionFromRequest(requestText, subagents) {
     }
     return ranked[0].name;
 }
+function inferCompactRouterDelegationPlanFromRequest(requestText, subagents, routingPolicy) {
+    const normalizedRequest = requestText.toLowerCase();
+    const numberedClauses = requestText
+        .split(/\r?\n/u)
+        .map((item) => item.trim())
+        .filter((item) => /^\d+\s*[.)、.]\s*/u.test(item));
+    const clauses = (numberedClauses.length > 1 ? numberedClauses : requestText
+        .split(/\r?\n|[。；;]\s*/u))
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+    if (clauses.length <= 1) {
+        return [];
+    }
+    for (const subagent of subagents) {
+        const escapedName = escapeRegExp(subagent.name);
+        const ownerPerspectivePattern = new RegExp(`(?:从\\s*\`?${escapedName}\`?\\s*角度|as\\s+(?:the\\s+)?\`?${escapedName}\`?|from\\s+(?:the\\s+)?\`?${escapedName}\`?\\s+perspective)`, "iu");
+        if (ownerPerspectivePattern.test(requestText)) {
+            return [];
+        }
+    }
+    const policyLineFor = (subagentName) => {
+        if (!routingPolicy) {
+            return "";
+        }
+        const escapedName = escapeRegExp(subagentName);
+        const match = new RegExp(`(?:^|\\n)\\s*[-*]\\s*\`?${escapedName}\`?\\s*[:：]\\s*([^\\n]+)`, "iu").exec(routingPolicy);
+        return match?.[1] ?? "";
+    };
+    const scoreText = (text, signals, subagentName) => {
+        const normalized = text.toLowerCase();
+        let value = normalized.includes(subagentName.toLowerCase()) ? 10 : 0;
+        for (const signal of signals) {
+            if (normalized.includes(signal)) {
+                value += /[\p{Script=Han}]/u.test(signal)
+                    ? Math.min(6, Math.max(2, signal.length))
+                    : Math.min(5, Math.max(2, Math.floor(signal.length / 2)));
+            }
+        }
+        return value;
+    };
+    const subagentSignals = subagents.map((subagent) => {
+        const signalText = [
+            subagent.name,
+            subagent.description ?? "",
+            policyLineFor(subagent.name),
+        ].join(" ");
+        return {
+            name: subagent.name,
+            signals: extractRouterMatchSignals(signalText),
+            globalScore: 0,
+        };
+    });
+    for (const item of subagentSignals) {
+        item.globalScore = scoreText(normalizedRequest, item.signals, item.name);
+    }
+    const ordered = [];
+    const pushUnique = (subagentType, description) => {
+        if (ordered.some((item) => item.subagentType === subagentType)) {
+            return;
+        }
+        ordered.push({ subagentType, description: description.trim() || requestText });
+    };
+    for (const clause of clauses) {
+        const ranked = subagentSignals
+            .map((item) => ({ name: item.name, score: scoreText(clause, item.signals, item.name) }))
+            .filter((item) => item.score >= 4)
+            .sort((left, right) => right.score - left.score);
+        const top = ranked[0];
+        if (top) {
+            pushUnique(top.name, clause);
+        }
+    }
+    if (ordered.length <= 1 && numberedClauses.length > 1) {
+        ordered.length = 0;
+        for (const clause of numberedClauses) {
+            const ranked = subagentSignals
+                .map((item) => ({ name: item.name, score: scoreText(clause, item.signals, item.name) }))
+                .filter((item) => item.score > 0)
+                .sort((left, right) => right.score - left.score);
+            const top = ranked[0];
+            if (top) {
+                pushUnique(top.name, clause);
+            }
+        }
+    }
+    for (const item of subagentSignals
+        .filter((candidate) => candidate.globalScore >= 6)
+        .sort((left, right) => right.globalScore - left.globalScore)) {
+        pushUnique(item.name, requestText);
+    }
+    if (ordered.length <= 1 && numberedClauses.length >= 3 && subagents.length > 1) {
+        return subagents.map((subagent, index) => ({
+            subagentType: subagent.name,
+            description: numberedClauses[index] ?? requestText,
+        }));
+    }
+    return ordered.length > 1 ? ordered : [];
+}
+function resolveSingleExplicitOwnerMention(requestText, subagentNames) {
+    const numberedClauses = requestText
+        .split(/\r?\n/u)
+        .map((item) => item.trim())
+        .filter((item) => /^\d+\s*[.)、.]\s*/u.test(item));
+    if (numberedClauses.length > 1) {
+        return null;
+    }
+    const matches = [];
+    for (const subagentName of subagentNames) {
+        const escapedName = escapeRegExp(subagentName);
+        const pattern = new RegExp(`(?:^|[^\\p{L}\\p{N}_-])\`?${escapedName}\`?(?:$|[^\\p{L}\\p{N}_-])`, "iu");
+        if (pattern.test(requestText)) {
+            matches.push(subagentName);
+        }
+    }
+    return matches.length === 1 ? matches[0] : null;
+}
+function extractExplicitSubagentTasks(requestText, subagentNames) {
+    const lines = requestText.split(/\r?\n/u);
+    const tasks = [];
+    let current = null;
+    const marker = new RegExp(`^\\s*(?:[-*]|\\d+[.)]|\\d+\\s*[、.])?\\s*(${Array.from(subagentNames).map(escapeRegExp).join("|")})\\s*[:：]\\s*(.*)$`, "iu");
+    for (const line of lines) {
+        const match = marker.exec(line);
+        if (match?.[1]) {
+            if (current) {
+                tasks.push({ subagentType: current.subagentType, text: current.parts.join("\n").trim() });
+            }
+            const subagentType = Array.from(subagentNames).find((name) => name.toLowerCase() === match[1].toLowerCase()) ?? match[1];
+            current = { subagentType, parts: [match[2] ?? ""] };
+            continue;
+        }
+        if (current && line.trim()) {
+            current.parts.push(line);
+        }
+    }
+    if (current) {
+        tasks.push({ subagentType: current.subagentType, text: current.parts.join("\n").trim() });
+    }
+    const deduped = [];
+    for (const task of tasks) {
+        if (!subagentNames.has(task.subagentType) || deduped.some((item) => item.subagentType === task.subagentType)) {
+            continue;
+        }
+        deduped.push({ subagentType: task.subagentType, text: task.text || requestText });
+    }
+    return deduped;
+}
+function buildDelegatedOwnedTaskInstruction(input) {
+    const relevantPolicyLines = (input.routingPolicy ?? "")
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter((line) => line.includes(`\`${input.subagentType}\``)
+        || line.includes(` ${input.subagentType} `)
+        || line.toLowerCase().includes(`to ${input.subagentType}`))
+        .slice(0, 8);
+    return [
+        `Delegated owner: ${input.subagentType}.`,
+        "Execute only this owner's bounded portion of the larger request.",
+        "Do not take over other specialist-owned work; return blockers for missing access instead of inventing success.",
+        "Owned subtask:",
+        input.taskText.trim() || input.originalRequest,
+        relevantPolicyLines.length > 0 ? "Relevant parent routing/delegation policy for this owner:" : "",
+        ...relevantPolicyLines,
+        "If the owner policy or tool contract requires evidence, call write_todos first and then execute the appropriate non-planning evidence tool before any final answer.",
+        "Close every TODO as completed or failed before final output.",
+    ].filter(Boolean).join("\n");
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
 function extractRouterMatchTokens(value) {
     const tokens = new Set();
     for (const match of value.matchAll(/[\p{L}\p{N}_-]+/gu)) {
@@ -478,6 +706,67 @@ function extractRouterMatchTokens(value) {
     }
     return tokens;
 }
+function extractRouterMatchSignals(value) {
+    const signals = extractRouterMatchTokens(value);
+    const stopSignals = new Set([
+        "the",
+        "and",
+        "for",
+        "with",
+        "owner",
+        "primary",
+        "route",
+        "agent",
+        "tool",
+        "tools",
+        "todo",
+        "json",
+        "status",
+        "report",
+        "final",
+        "output",
+        "failed",
+        "blocked",
+        "work",
+        "request",
+        "user",
+        "负责",
+        "不是",
+        "用户",
+        "请求",
+        "当前",
+        "输出",
+        "证据",
+        "使用",
+        "必须",
+        "一个",
+        "如果",
+        "需要",
+        "工作",
+        "总结",
+        "分析",
+        "最终",
+        "相关",
+        "工具",
+        "执行",
+        "结果",
+    ]);
+    for (const stopSignal of stopSignals) {
+        signals.delete(stopSignal);
+    }
+    for (const match of value.matchAll(/[\p{Script=Han}]{2,}/gu)) {
+        const sequence = match[0];
+        for (let size = 2; size <= Math.min(4, sequence.length); size += 1) {
+            for (let index = 0; index <= sequence.length - size; index += 1) {
+                const signal = sequence.slice(index, index + size);
+                if (!stopSignals.has(signal)) {
+                    signals.add(signal);
+                }
+            }
+        }
+    }
+    return signals;
+}
 function isDelegationOnlyDeepAgentBinding(binding) {
     return isDeepAgentBinding(binding)
         && getBindingSubagents(binding).length > 0
@@ -549,6 +838,12 @@ const DELEGATED_PLAN_EVIDENCE_RETRY_INSTRUCTION = [
     "Before any other tool call or final answer, call write_todos with concrete task steps and statuses.",
     "Then continue the task to completion, update TODO statuses after evidence steps, and close every TODO as completed or failed before the final answer.",
 ].join("\n");
+function looksLikeRawCommandTranscript(value) {
+    const normalized = value.trim();
+    return /^(?:stdout|stderr)\s*:/iu.test(normalized)
+        || /(?:^|\n)\s*(?:stdout|stderr)\s*:/iu.test(normalized)
+        || /(?:^|\n)\s*exitCode\s*:\s*-?\d+\s*$/iu.test(normalized);
+}
 function resolveDelegatedResultOutput(result) {
     const executedToolResults = Array.isArray(result.metadata?.executedToolResults)
         ? result.metadata.executedToolResults
@@ -927,6 +1222,9 @@ export class AgentRuntimeAdapter {
                             });
                         }
                         catch (error) {
+                            if (error instanceof DelegatedExecutionNoToolEvidenceError) {
+                                throw new Error(buildDelegatedExecutionEvidenceBlocker(targetBinding.agent.id, getBindingPrimaryTools(targetBinding).map((tool) => tool.name)));
+                            }
                             const message = error instanceof Error && error.message.trim().length > 0
                                 ? error.message.trim()
                                 : "delegated execution failed";
@@ -1360,6 +1658,9 @@ export class AgentRuntimeAdapter {
                 selection = parseCompactRouterSelection(previousRawText, subagentNames);
             }
         }
+        if (selection?.delegations && selection.delegations.length > 0) {
+            selection = { subagentType: selection.delegations[0].subagentType };
+        }
         if (selection?.refusedReason) {
             return {
                 toolOutput: selection.refusedReason,
@@ -1497,7 +1798,7 @@ export class AgentRuntimeAdapter {
             };
         }
         if (targetRequiresExecutionToolEvidence && !hasDelegatedExecutionToolEvidence(delegatedResult)) {
-            const output = buildDelegatedExecutionEvidenceBlocker(selectedBinding.agent.id);
+            const output = buildDelegatedExecutionEvidenceBlocker(selectedBinding.agent.id, getBindingPrimaryTools(selectedBinding).map((tool) => tool.name));
             return {
                 toolOutput: output,
                 delegatedSubagentType: subagentType,
@@ -1608,6 +1909,9 @@ export class AgentRuntimeAdapter {
     }
     formatCompactDelegationReportForDisplay(report) {
         const reportText = typeof report.report === "string" ? report.report.trim() : "";
+        if (reportText && looksLikeRawCommandTranscript(reportText)) {
+            return JSON.stringify(report);
+        }
         if (reportText) {
             return reportText;
         }
@@ -1630,20 +1934,36 @@ export class AgentRuntimeAdapter {
         }
         const subagents = getBindingSubagents(binding);
         const subagentNames = new Set(subagents.map((subagent) => subagent.name));
-        const inferredSubagent = inferCompactRouterSelectionFromRequest(requestText, subagents);
-        let selection = inferredSubagent ? { subagentType: inferredSubagent } : null;
+        const semanticSubagents = subagents.map((subagent) => {
+            const resolvedBinding = this.options.bindingResolver?.(subagent.name);
+            const toolNames = resolvedBinding
+                ? getBindingPrimaryTools(resolvedBinding).map((tool) => tool.name).filter(Boolean).join(" ")
+                : "";
+            return {
+                name: subagent.name,
+                description: [
+                    subagent.description ?? "",
+                    toolNames,
+                    resolvedBinding ? getBindingSystemPrompt(resolvedBinding) : "",
+                ].filter(Boolean).join("\n"),
+            };
+        });
+        let selection = null;
         const subagentCatalog = subagents
             .map((subagent) => `- ${subagent.name}: ${subagent.description}`)
             .join("\n");
         const routingPolicy = getBindingSystemPrompt(binding);
         const prompt = [
             primaryModel.init?.think === false ? "/no_think" : "",
-            "You are selecting a subagent for a delegation-only agent.",
-            "Choose exactly one listed subagent when it can responsibly handle the request.",
+            "You are planning delegation for a delegation-only agent.",
+            "Choose exactly one listed subagent when one specialist can responsibly handle the request.",
+            "If the request naturally requires multiple specialist-owned steps, return an ordered delegation plan instead of one subagent.",
             routingPolicy ? "Agent routing policy:" : "",
             routingPolicy ?? "",
-            "Return only JSON with this shape:",
+            "For one specialist, return only JSON with this shape:",
             "{\"subagent_type\":\"<listed subagent name>\"}",
+            "For multiple specialist steps, return only JSON with this shape:",
+            "{\"delegations\":[{\"subagent_type\":\"<listed subagent name>\",\"description\":\"<only that specialist's owned portion>\"}]}",
             "If no listed subagent can handle the request, return only:",
             "{\"status\":\"refused\",\"reason\":\"No configured subagent can handle the request.\"}",
             "Available subagents:",
@@ -1675,20 +1995,23 @@ export class AgentRuntimeAdapter {
                 ].join("\n\n"),
                 [
                     primaryModel.init?.think === false ? "/no_think" : "",
-                    "Select one subagent from this exact list:",
+                    "Select one subagent or an ordered delegation plan from this exact list:",
                     Array.from(subagentNames).join(", "),
-                    "Return JSON only:",
+                    "Return JSON only. Single-specialist shape:",
                     "{\"subagent_type\":\"<one exact listed name>\"}",
+                    "Multi-specialist shape:",
+                    "{\"delegations\":[{\"subagent_type\":\"<one exact listed name>\",\"description\":\"<owned subtask>\"}]}",
                     "User request:",
                     requestText,
                 ].filter(Boolean).join("\n\n"),
                 [
                     primaryModel.init?.think === false ? "/no_think" : "",
-                    "JSON only. Pick a listed subagent or refuse.",
+                    "JSON only. Pick a listed subagent, return delegations, or refuse.",
                     "Listed subagents:",
                     Array.from(subagentNames).join(", "),
                     "Allowed outputs:",
                     "{\"subagent_type\":\"<listed name>\"}",
+                    "{\"delegations\":[{\"subagent_type\":\"<listed name>\",\"description\":\"<owned subtask>\"}]}",
                     "{\"status\":\"refused\",\"reason\":\"No configured subagent can handle the request.\"}",
                     "Request:",
                     requestText,
@@ -1704,6 +2027,286 @@ export class AgentRuntimeAdapter {
                 selection = parseCompactRouterSelection(previousRawText, subagentNames);
             }
         }
+        const explicitTasks = extractExplicitSubagentTasks(requestText, subagentNames);
+        const explicitOwner = resolveSingleExplicitOwnerMention(requestText, subagentNames);
+        if (selection?.refusedReason && explicitOwner) {
+            selection = { subagentType: explicitOwner };
+        }
+        const inferredDelegationPlan = inferCompactRouterDelegationPlanFromRequest(requestText, semanticSubagents, routingPolicy);
+        if (inferredDelegationPlan.length > 1
+            && (!selection?.delegations || selection.delegations.length < inferredDelegationPlan.length)) {
+            selection = { delegations: inferredDelegationPlan };
+        }
+        if (!selection) {
+            if (explicitTasks.length > 1) {
+                selection = {
+                    delegations: explicitTasks.map((task) => ({
+                        subagentType: task.subagentType,
+                        description: task.text,
+                    })),
+                };
+            }
+            else if (explicitTasks.length === 1) {
+                selection = { subagentType: explicitTasks[0].subagentType };
+            }
+            else {
+                const inferred = inferCompactRouterSelectionFromRequest(requestText, semanticSubagents);
+                if (inferred) {
+                    selection = { subagentType: inferred };
+                }
+            }
+        }
+        const numberedRequestSteps = requestText
+            .split(/\r?\n/u)
+            .map((item) => item.trim())
+            .filter((item) => /^\d+\s*[.)、.]\s*/u.test(item));
+        if (selection?.subagentType && numberedRequestSteps.length >= 3 && subagents.length > 1) {
+            selection = {
+                delegations: subagents.map((subagent, index) => ({
+                    subagentType: subagent.name,
+                    description: numberedRequestSteps[index] ?? requestText,
+                })),
+            };
+        }
+        if (selection?.delegations?.length === 1) {
+            const onlyDelegation = selection.delegations[0];
+            selection = { subagentType: onlyDelegation.subagentType };
+        }
+        if (selection?.delegations && selection.delegations.length > 1) {
+            if (explicitOwner) {
+                selection = { subagentType: explicitOwner };
+            }
+        }
+        if (selection?.delegations
+            && selection.delegations.length > 1
+            && inferredDelegationPlan.length <= 1
+            && numberedRequestSteps.length < 3) {
+            const inferredSingleOwner = inferCompactRouterSelectionFromRequest(requestText, subagents)
+                ?? inferCompactRouterSelectionFromRequest(requestText, semanticSubagents);
+            if (inferredSingleOwner) {
+                selection = { subagentType: inferredSingleOwner };
+            }
+        }
+        if (selection?.delegations && selection.delegations.length > 1) {
+            const plannedDelegations = selection.delegations;
+            const plannedNames = new Set(plannedDelegations.map((item) => item.subagentType));
+            const planCoversEverySubagent = plannedDelegations.length === subagents.length
+                && plannedNames.size === subagentNames.size
+                && Array.from(subagentNames).every((name) => plannedNames.has(name));
+            const shouldCollapseOverbroadPlan = planCoversEverySubagent && explicitTasks.length === 0 && numberedRequestSteps.length < 3;
+            const executableDelegations = shouldCollapseOverbroadPlan ? plannedDelegations.slice(0, 1) : plannedDelegations;
+            const aggregateToolResults = [];
+            const childReports = [];
+            yield {
+                kind: "commentary",
+                content: `Planned delegation tree: ${executableDelegations.map((item) => item.subagentType).join(" -> ")}.`,
+                agentId: binding.agent.id,
+            };
+            const runPlannedDelegation = async function* (subagentType, text, requestIdSuffix = "") {
+                const selectedBinding = this.options.bindingResolver?.(subagentType);
+                if (!selectedBinding) {
+                    const output = `Configured subagent '${subagentType}' could not be resolved.`;
+                    return {
+                        sessionId,
+                        requestId: `${requestId}:${subagentType}${requestIdSuffix}`,
+                        agentId: subagentType,
+                        state: "failed",
+                        output,
+                        finalMessageText: output,
+                        metadata: { executedToolResults: [] },
+                    };
+                }
+                const executedToolResults = [];
+                let output = "";
+                try {
+                    for await (const chunk of this.stream(selectedBinding, text, sessionId, [], {
+                        context: options.context,
+                        state: options.state,
+                        files: options.files,
+                        requestId: `${requestId}:${subagentType}${requestIdSuffix}`,
+                        memoryContext: options.memoryContext,
+                        profiling: options.profiling,
+                    })) {
+                        if (typeof chunk === "string") {
+                            output += chunk;
+                            continue;
+                        }
+                        if (chunk.kind === "content") {
+                            output += chunk.content ?? "";
+                            continue;
+                        }
+                        if (chunk.kind === "tool-result") {
+                            appendUniqueToolEvidence(executedToolResults, {
+                                toolName: chunk.toolName,
+                                output: chunk.output,
+                                ...(chunk.isError !== undefined ? { isError: chunk.isError } : {}),
+                            });
+                        }
+                        if (chunk.kind === "upstream-event") {
+                            const streamedEvidence = readUpstreamToolEvidence(chunk.event);
+                            if (streamedEvidence) {
+                                appendUniqueToolEvidence(executedToolResults, streamedEvidence);
+                            }
+                        }
+                        yield { ...chunk, agentId: chunk.agentId ?? selectedBinding.agent.id };
+                    }
+                }
+                catch (error) {
+                    output = error instanceof Error ? error.message : String(error);
+                    return {
+                        sessionId,
+                        requestId: `${requestId}:${subagentType}${requestIdSuffix}`,
+                        agentId: selectedBinding.agent.id,
+                        state: "failed",
+                        output,
+                        finalMessageText: output,
+                        metadata: { executedToolResults },
+                    };
+                }
+                return {
+                    sessionId,
+                    requestId: `${requestId}:${subagentType}${requestIdSuffix}`,
+                    agentId: selectedBinding.agent.id,
+                    state: "completed",
+                    output: sanitizeVisibleText(output),
+                    finalMessageText: sanitizeVisibleText(output),
+                    metadata: { executedToolResults },
+                };
+            }.bind(this);
+            for (const [index, planned] of executableDelegations.entries()) {
+                const selectedBinding = this.options.bindingResolver?.(planned.subagentType);
+                const delegatedText = buildDelegatedOwnedTaskInstruction({
+                    subagentType: planned.subagentType,
+                    taskText: planned.description,
+                    originalRequest: requestText,
+                    routingPolicy,
+                    ownerPolicy: selectedBinding ? getBindingSystemPrompt(selectedBinding) : undefined,
+                });
+                yield {
+                    kind: "commentary",
+                    content: `Delegating to ${planned.subagentType}.`,
+                    agentId: binding.agent.id,
+                };
+                yield {
+                    kind: "commentary",
+                    content: "Starting delegated execution.",
+                    agentId: selectedBinding?.agent.id ?? planned.subagentType,
+                };
+                let delegatedResult = yield* runPlannedDelegation(planned.subagentType, delegatedText);
+                if (selectedBinding?.harnessRuntime.executionContract?.requiresPlan === true && !hasDelegatedPlanEvidence(delegatedResult)) {
+                    const previousDelegatedResult = delegatedResult;
+                    delegatedResult = mergeDelegatedResultToolEvidence(yield* runPlannedDelegation(planned.subagentType, [delegatedText, DELEGATED_PLAN_EVIDENCE_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":plan-evidence-retry"), previousDelegatedResult);
+                }
+                const targetRequiresExecutionToolEvidence = selectedBinding ? getBindingPrimaryTools(selectedBinding).length > 0 : false;
+                if (targetRequiresExecutionToolEvidence && !hasDelegatedExecutionToolEvidence(delegatedResult)) {
+                    const previousDelegatedResult = delegatedResult;
+                    delegatedResult = mergeDelegatedResultToolEvidence(yield* runPlannedDelegation(planned.subagentType, [delegatedText, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":tool-evidence-retry"), previousDelegatedResult);
+                }
+                if (selectedBinding?.harnessRuntime.executionContract?.requiresPlan === true && !hasDelegatedPlanEvidence(delegatedResult)) {
+                    const output = buildDelegatedPlanEvidenceBlocker(selectedBinding.agent.id);
+                    delegatedResult = {
+                        ...delegatedResult,
+                        state: "failed",
+                        output,
+                        finalMessageText: output,
+                    };
+                }
+                if (targetRequiresExecutionToolEvidence && !hasDelegatedExecutionToolEvidence(delegatedResult)) {
+                    const output = buildDelegatedExecutionEvidenceBlocker(selectedBinding.agent.id, getBindingPrimaryTools(selectedBinding).map((tool) => tool.name));
+                    delegatedResult = {
+                        ...delegatedResult,
+                        state: "failed",
+                        output,
+                        finalMessageText: output,
+                    };
+                }
+                const delegatedToolResults = Array.isArray(delegatedResult.metadata?.executedToolResults)
+                    ? delegatedResult.metadata.executedToolResults
+                    : [];
+                for (const toolResult of delegatedToolResults) {
+                    if (typeof toolResult.toolName !== "string") {
+                        continue;
+                    }
+                    appendUniqueToolEvidence(aggregateToolResults, {
+                        toolName: toolResult.toolName,
+                        output: toolResult.output,
+                        ...(toolResult.isError !== undefined ? { isError: Boolean(toolResult.isError) } : {}),
+                    });
+                    if (isPlanToolName(toolResult.toolName)) {
+                        continue;
+                    }
+                    yield {
+                        kind: "commentary",
+                        content: `Running tool ${toolResult.toolName}.`,
+                        agentId: selectedBinding?.agent.id ?? planned.subagentType,
+                    };
+                    yield {
+                        kind: "commentary",
+                        content: `Tool ${toolResult.toolName} ${toolResult.isError === true ? "failed" : "completed"}.`,
+                        agentId: selectedBinding?.agent.id ?? planned.subagentType,
+                    };
+                }
+                childReports.push({
+                    subagentType: planned.subagentType,
+                    result: delegatedResult,
+                    output: typeof delegatedResult.output === "string" ? delegatedResult.output : String(delegatedResult.output ?? ""),
+                });
+                if (index < executableDelegations.length - 1) {
+                    yield {
+                        kind: "commentary",
+                        content: "Continuing ordered delegation plan.",
+                        agentId: binding.agent.id,
+                    };
+                }
+            }
+            const failedChildren = childReports.filter((child) => child.result.state === "failed");
+            const uniqueToolNames = [...new Set(aggregateToolResults.map((toolResult) => toolResult.toolName))];
+            const status = failedChildren.length > 0 ? "failed" : "completed";
+            const report = childReports
+                .map((child) => `## ${child.subagentType}\n${child.output.trim() || "No visible output returned."}`)
+                .join("\n\n");
+            const payload = {
+                status,
+                routing: executableDelegations.map((planned, index) => `${index + 1}) 路由判断: ${planned.subagentType} 负责 ${planned.description.trim() || "该专业域子任务"}。`),
+                plan: executableDelegations.map((planned, index) => `${index + 1}) 委托 ${planned.subagentType}: ${planned.description.trim() || "执行其专业域任务"}。`),
+                execution: childReports.map((child, index) => `${index + 1}) ${child.subagentType} ${child.result.state === "failed" ? "failed" : "completed"}。`),
+                todoTrace: childReports.map((child, index) => `${index + 1}) ${child.subagentType}: ${hasDelegatedPlanEvidence(child.result) ? "TODO evidence observed" : "TODO evidence missing"}。`),
+                stepResults: childReports.map((child, index) => `${index + 1}) ${child.subagentType}: delegated result collected; aggregate tools = ${uniqueToolNames.length > 0 ? uniqueToolNames.join(", ") : "none"}。`),
+                summary: [
+                    status === "failed"
+                        ? `多 specialist 编排完成，但 ${failedChildren.length} 个委托返回 failed。`
+                        : "多 specialist 编排已完成，所有委托均返回 completed。",
+                ],
+                findings: childReports.map((child) => `${child.subagentType}: ${child.output.trim().slice(0, 500) || "No finding text returned."}`),
+                blockers: failedChildren.length > 0
+                    ? failedChildren.map((child) => `${child.subagentType}: delegated execution failed.`)
+                    : ["none"],
+                nextActions: failedChildren.length > 0
+                    ? ["查看 failed specialist 的 blocker 并单独重跑该委托。"]
+                    : ["可基于各 specialist 结果继续做最终修复或发布决策。"],
+                report,
+            };
+            const output = JSON.stringify(payload);
+            return {
+                toolOutput: output,
+                delegatedSubagentType: "multiple",
+                delegatedResult: {
+                    sessionId,
+                    requestId,
+                    agentId: binding.agent.id,
+                    state: status,
+                    output,
+                    finalMessageText: output,
+                    metadata: {
+                        executedToolResults: aggregateToolResults,
+                        delegations: childReports.map((child) => ({
+                            subagentType: child.subagentType,
+                            state: child.result.state,
+                        })),
+                    },
+                },
+            };
+        }
         if (selection?.refusedReason) {
             return {
                 toolOutput: selection.refusedReason,
@@ -1754,7 +2357,6 @@ export class AgentRuntimeAdapter {
                     requestId: `${childRequestId}${requestIdSuffix}`,
                     memoryContext: options.memoryContext,
                     profiling: options.profiling,
-                    toolRuntimeContext: options.toolRuntimeContext,
                 })) {
                     if (typeof chunk === "string") {
                         output += chunk;
@@ -1802,16 +2404,23 @@ export class AgentRuntimeAdapter {
                 metadata: { executedToolResults },
             };
         }.bind(this);
-        let delegatedResult = yield* runDelegatedStreamAttempt(requestText);
+        const delegatedText = buildDelegatedOwnedTaskInstruction({
+            subagentType,
+            taskText: requestText,
+            originalRequest: requestText,
+            routingPolicy,
+            ownerPolicy: getBindingSystemPrompt(selectedBinding),
+        });
+        let delegatedResult = yield* runDelegatedStreamAttempt(delegatedText);
         const targetRequiresExecutionToolEvidence = getBindingPrimaryTools(selectedBinding).length > 0;
         if (selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
             && !hasDelegatedPlanEvidence(delegatedResult)) {
             const previousDelegatedResult = delegatedResult;
-            delegatedResult = mergeDelegatedResultToolEvidence(yield* runDelegatedStreamAttempt([requestText, DELEGATED_PLAN_EVIDENCE_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":plan-evidence-retry"), previousDelegatedResult);
+            delegatedResult = mergeDelegatedResultToolEvidence(yield* runDelegatedStreamAttempt([delegatedText, DELEGATED_PLAN_EVIDENCE_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":plan-evidence-retry"), previousDelegatedResult);
         }
         if (targetRequiresExecutionToolEvidence && !hasDelegatedExecutionToolEvidence(delegatedResult)) {
             const previousDelegatedResult = delegatedResult;
-            delegatedResult = mergeDelegatedResultToolEvidence(yield* runDelegatedStreamAttempt([requestText, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":tool-evidence-retry"), previousDelegatedResult);
+            delegatedResult = mergeDelegatedResultToolEvidence(yield* runDelegatedStreamAttempt([delegatedText, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":tool-evidence-retry"), previousDelegatedResult);
         }
         if (selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
             && !hasDelegatedPlanEvidence(delegatedResult)) {
@@ -1824,7 +2433,7 @@ export class AgentRuntimeAdapter {
             };
         }
         if (targetRequiresExecutionToolEvidence && !hasDelegatedExecutionToolEvidence(delegatedResult)) {
-            const output = buildDelegatedExecutionEvidenceBlocker(selectedBinding.agent.id);
+            const output = buildDelegatedExecutionEvidenceBlocker(selectedBinding.agent.id, getBindingPrimaryTools(selectedBinding).map((tool) => tool.name));
             delegatedResult = {
                 ...delegatedResult,
                 state: "failed",