@botbotgo/agent-harness 0.0.467 → 0.0.469

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.467";
+export declare const AGENT_HARNESS_VERSION = "0.0.469";
 export declare const AGENT_HARNESS_RELEASE_DATE = "2026-05-04";

package/dist/package-version.js

@@ -1,2 +1,2 @@
-export const AGENT_HARNESS_VERSION = "0.0.467";
+export const AGENT_HARNESS_VERSION = "0.0.469";
 export const AGENT_HARNESS_RELEASE_DATE = "2026-05-04";

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

@@ -205,6 +205,44 @@ function parseCompactRouterSelection(value, subagentNames) {
             return { delegations: deduped };
         }
     }
+    const routingMap = typeof payload.routing === "object" && payload.routing !== null && !Array.isArray(payload.routing)
+        ? payload.routing
+        : typeof args.routing === "object" && args.routing !== null && !Array.isArray(args.routing)
+            ? args.routing
+            : undefined;
+    if (routingMap) {
+        const nestedSubagents = Array.isArray(routingMap.subagents)
+            ? routingMap.subagents
+                .map((item) => {
+                if (typeof item !== "string") {
+                    return null;
+                }
+                const resolvedName = resolveExactName(item);
+                return resolvedName ? { subagentType: resolvedName, description: "" } : null;
+            })
+                .filter((item) => item !== null)
+            : [];
+        const delegations = Object.entries(routingMap)
+            .map(([rawName, rawDescription]) => {
+            const resolvedName = resolveExactName(rawName);
+            if (!resolvedName) {
+                return null;
+            }
+            const description = typeof rawDescription === "string" && rawDescription.trim()
+                ? rawDescription.trim()
+                : "";
+            return { subagentType: resolvedName, description };
+        })
+            .filter((item) => item !== null);
+        for (const delegation of nestedSubagents) {
+            if (!delegations.some((item) => item.subagentType === delegation.subagentType)) {
+                delegations.push(delegation);
+            }
+        }
+        if (delegations.length > 0) {
+            return { delegations };
+        }
+    }
     const status = typeof payload.status === "string" ? payload.status.trim().toLowerCase() : "";
     if (status === "refused") {
         const reason = typeof payload.reason === "string" && payload.reason.trim()
@@ -227,6 +265,18 @@ function buildCompactRouterPolicy(routingPolicy) {
         .slice(0, 80)
         .join("\n");
 }
+function looksLikeStructuredMultiItemRequest(requestText) {
+    const lines = requestText
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const numberedItems = lines.filter((line) => /^\d+[\.)、]\s+/u.test(line));
+    if (numberedItems.length >= 2) {
+        return true;
+    }
+    const bulletItems = lines.filter((line) => /^[-*]\s+/u.test(line));
+    return bulletItems.length >= 2;
+}
 function buildDelegatedOwnedTaskInstruction(input) {
     return [
         `Delegated owner: ${input.subagentType}.`,
@@ -1204,6 +1254,7 @@ export class AgentRuntimeAdapter {
         }
         const subagents = getBindingSubagents(binding);
         const subagentNames = new Set(subagents.map((subagent) => subagent.name));
+        const structuredMultiItemRequest = looksLikeStructuredMultiItemRequest(requestText);
         let selection = null;
         const subagentCatalog = subagents
             .map((subagent) => `- ${subagent.name}: ${subagent.description}`)
@@ -1215,6 +1266,7 @@ export class AgentRuntimeAdapter {
             "You are selecting a subagent for a delegation-only agent.",
             "Choose exactly one listed subagent when it can responsibly handle the request.",
             "Use the agent routing policy as authoritative routing configuration when it maps the request meaning to a listed subagent.",
+            "When the routing policy says a request class is owned by one listed subagent, keep that request with the configured owner even if the task mentions supporting evidence from other domains.",
             "Do not refuse while any listed subagent can own the request after applying the routing policy.",
             "Refuse only when the request is outside every listed subagent's configured responsibility.",
             compactRoutingPolicy ? "Agent routing policy:" : "",
@@ -1278,7 +1330,7 @@ export class AgentRuntimeAdapter {
                 ].filter(Boolean).join("\n\n"),
             ];
             let previousRawText = "";
-            for (let index = 0; index < routerPrompts.length && !selection; index += 1) {
+            for (let index = 0; index < routerPrompts.length; index += 1) {
                 const activePrompt = index <= 1 || !previousRawText
                     ? routerPrompts[index]
                     : [routerPrompts[index], "Previous output:", previousRawText].join("\n\n");
@@ -1288,12 +1340,114 @@ export class AgentRuntimeAdapter {
                 }
                 previousRawText = readModelText(raw);
                 const parsedSelection = parseCompactRouterSelection(previousRawText, subagentNames);
-                selection = parsedSelection?.refusedReason && index < routerPrompts.length - 1
-                    ? null
-                    : parsedSelection;
+                if (!parsedSelection) {
+                    continue;
+                }
+                if (parsedSelection.delegations && parsedSelection.delegations.length > 1) {
+                    if (selection?.subagentType
+                        && !parsedSelection.delegations.some((delegation) => delegation.subagentType === selection?.subagentType)) {
+                        continue;
+                    }
+                    selection = parsedSelection;
+                    break;
+                }
+                if (!selection || selection.refusedReason || parsedSelection.subagentType) {
+                    selection = parsedSelection.refusedReason && index < routerPrompts.length - 1
+                        ? selection
+                        : parsedSelection;
+                }
             }
         }
-        if (selection?.delegations && selection.delegations.length > 0) {
+        if (selection?.delegations && selection.delegations.length > 1) {
+            const aggregateToolResults = [];
+            const childReports = [];
+            for (const planned of selection.delegations) {
+                const selectedBinding = this.options.bindingResolver(planned.subagentType);
+                if (!selectedBinding) {
+                    const output = `Configured subagent '${planned.subagentType}' could not be resolved.`;
+                    childReports.push({
+                        subagentType: planned.subagentType,
+                        result: {
+                            sessionId,
+                            requestId: `${requestId}:${planned.subagentType}`,
+                            agentId: planned.subagentType,
+                            state: "failed",
+                            output,
+                            finalMessageText: output,
+                            metadata: { executedToolResults: [] },
+                        },
+                        output,
+                    });
+                    continue;
+                }
+                const delegatedResult = await this.invoke(selectedBinding, buildDelegatedOwnedTaskInstruction({
+                    subagentType: planned.subagentType,
+                    taskText: planned.description,
+                    originalRequest: requestText,
+                }), sessionId, `${requestId}:${planned.subagentType}`, undefined, [], {
+                    context: options.context,
+                    state: options.state,
+                    files: options.files,
+                    memoryContext: options.memoryContext,
+                });
+                const executedToolResults = Array.isArray(delegatedResult.metadata?.executedToolResults)
+                    ? delegatedResult.metadata.executedToolResults
+                    : [];
+                aggregateToolResults.push(...executedToolResults);
+                childReports.push({
+                    subagentType: planned.subagentType,
+                    result: delegatedResult,
+                    output: typeof delegatedResult.output === "string" ? delegatedResult.output : String(delegatedResult.output ?? ""),
+                });
+            }
+            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 output = JSON.stringify({
+                status,
+                routing: selection.delegations.map((planned, index) => `${index + 1}) 路由判断: ${planned.subagentType} 负责 ${planned.description.trim() || "该专业域子任务"}。`),
+                plan: selection.delegations.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,
+            });
+            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?.delegations && selection.delegations.length === 1) {
             selection = { subagentType: selection.delegations[0].subagentType };
         }
         if (selection?.refusedReason) {
@@ -1553,6 +1707,7 @@ export class AgentRuntimeAdapter {
         }
         const subagents = getBindingSubagents(binding);
         const subagentNames = new Set(subagents.map((subagent) => subagent.name));
+        const structuredMultiItemRequest = looksLikeStructuredMultiItemRequest(requestText);
         let selection = null;
         const subagentCatalog = subagents
             .map((subagent) => `- ${subagent.name}: ${subagent.description}`)
@@ -1564,7 +1719,16 @@ export class AgentRuntimeAdapter {
             "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.",
+            "A single objective with multiple evidence requirements is still single-owner when one listed subagent owns the objective.",
+            "Return multi-owner delegations only when the user asks for multiple independently owned specialist work items.",
+            "For multi-line or numbered requests, evaluate every requested item semantically before choosing the final owner list.",
             "Use the agent routing policy as authoritative routing configuration when it maps request meaning to listed subagents.",
+            "Apply the routing policy and subagent catalog literally; do not assign work to a subagent when the policy says that subagent is not the owner.",
+            "When the routing policy or subagent catalog says a request class routes to one owner only, choose that single owner.",
+            "Evidence dimensions inside one request, such as tools, files, CI, output format, failure states, routing, or runtime paths, are inputs to the selected owner; they do not create extra owners unless the user asks those specialists to do their own work.",
+            "A request made from one specialist perspective is single-owner when that specialist can responsibly handle the whole requested assessment.",
+            "Evaluate each listed subagent independently against the request and include every listed owner whose configured responsibility is required.",
+            "Do not merge one listed subagent's configured responsibility into another listed subagent's task.",
             "A broad request can still be handleable when multiple listed subagents each own part of it; return a delegation plan in that case.",
             "Do not refuse while any listed subagent can own the request or a subtask after applying the routing policy.",
             "Refuse only when the request is outside every listed subagent's configured responsibility.",
@@ -1632,9 +1796,29 @@ export class AgentRuntimeAdapter {
                     "Request:",
                     requestText,
                 ].filter(Boolean).join("\n\n"),
+                [
+                    primaryModel.init?.think === false ? "/no_think" : "",
+                    "Multi-specialist delegation is supported.",
+                    "If a request needs multiple listed specialists, that is not a refusal condition.",
+                    "A single objective with multiple evidence requirements is still single-owner when one listed subagent owns the objective.",
+                    "Return multi-owner delegations only when the user asks for multiple independently owned specialist work items.",
+                    "Return a delegations array that assigns each specialist-owned work item to listed subagents.",
+                    "Evaluate each listed subagent independently against the request and include every listed owner whose configured responsibility is required.",
+                    "Do not merge one listed subagent's configured responsibility into another listed subagent's task.",
+                    "Do not turn supporting evidence dimensions into separate owners when one listed subagent owns the requested assessment.",
+                    "Never return final response fields such as routing, todoTrace, stepResults, summary, findings, blockers, nextActions, or report.",
+                    "Return JSON only with this exact shape:",
+                    "{\"delegations\":[{\"subagent_type\":\"<one exact listed name>\",\"description\":\"<owned subtask>\"}]}",
+                    compactRoutingPolicy ? "Agent routing policy:" : "",
+                    compactRoutingPolicy,
+                    "Available subagents:",
+                    subagentCatalog,
+                    "User request:",
+                    requestText,
+                ].filter(Boolean).join("\n\n"),
             ];
             let previousRawText = "";
-            for (let index = 0; index < routerPrompts.length && !selection; index += 1) {
+            for (let index = 0; index < routerPrompts.length; index += 1) {
                 const activePrompt = index <= 1 || !previousRawText
                     ? routerPrompts[index]
                     : [routerPrompts[index], "Previous output:", previousRawText].join("\n\n");
@@ -1644,59 +1828,120 @@ export class AgentRuntimeAdapter {
                 }
                 previousRawText = readModelText(raw);
                 const parsedSelection = parseCompactRouterSelection(previousRawText, subagentNames);
-                selection = parsedSelection?.refusedReason && index < routerPrompts.length - 1
-                    ? null
-                    : parsedSelection;
+                if (!parsedSelection) {
+                    continue;
+                }
+                if (parsedSelection.delegations && parsedSelection.delegations.length > 1) {
+                    selection = parsedSelection;
+                    break;
+                }
+                if (parsedSelection.subagentType && !structuredMultiItemRequest) {
+                    selection = parsedSelection;
+                    break;
+                }
+                if (!selection || selection.refusedReason || parsedSelection.subagentType) {
+                    selection = parsedSelection.refusedReason && index < routerPrompts.length - 1
+                        ? selection
+                        : parsedSelection;
+                }
             }
         }
-        const numberedRequestSteps = requestText
-            .split(/\r?\n/u)
-            .map((item) => item.trim())
-            .filter((item) => /^\d+\s*[.)、.]\s*/u.test(item));
-        const shouldRouteNumberedClauses = model
-            && numberedRequestSteps.length > 1
-            && (!selection
-                || Boolean(selection.refusedReason)
-                || (Array.isArray(selection.delegations)
-                    && selection.delegations.length > 1
-                    && selection.delegations.length < numberedRequestSteps.length));
-        if (shouldRouteNumberedClauses || ((!selection || selection.refusedReason) && model)) {
-            const routeClauses = numberedRequestSteps.length > 1 ? numberedRequestSteps : [requestText];
-            const routedDelegations = [];
-            for (const [index, clause] of routeClauses.entries()) {
-                const clausePrompt = [
+        if (selection?.delegations || selection?.subagentType) {
+            const candidateDelegations = selection.delegations ?? [{
+                    subagentType: selection.subagentType,
+                    description: requestText,
+                }];
+            const candidatePlan = candidateDelegations
+                .map((item, index) => `${index + 1}. ${item.subagentType}: ${item.description}`)
+                .join("\n");
+            const coveragePrompt = [
+                primaryModel.init?.think === false ? "/no_think" : "",
+                "Verify this delegation plan against the user request and routing policy.",
+                "Internally review every sentence or list item in the user request before returning JSON.",
+                "Return one corrected JSON object only.",
+                "Keep the candidate plan unchanged when it already covers every specialist-owned work item.",
+                "Return a single subagent_type when one listed subagent owns the whole request and the candidate plan only split supporting evidence dimensions.",
+                "A single objective with multiple evidence requirements is still single-owner when one listed subagent owns the objective.",
+                "Return multi-owner delegations only when the user asks for multiple independently owned specialist work items.",
+                "If the candidate omits a specialist-owned work item, add that listed subagent in the correct user-requested order.",
+                "If the candidate includes a subagent whose described work is not owned by that subagent, remove or replace it.",
+                "Evaluate each listed subagent independently against the request and include every listed owner whose configured responsibility is required.",
+                "Do not merge one listed subagent's configured responsibility into another listed subagent's task.",
+                "Do not turn supporting evidence dimensions into separate owners when one listed subagent owns the requested assessment.",
+                "Do not add a subagent unless the routing policy or subagent catalog makes ownership clear.",
+                "When the routing policy states that a subagent is not the owner for a domain, do not assign that domain to that subagent.",
+                "Use only listed subagent names.",
+                compactRoutingPolicy ? "Agent routing policy:" : "",
+                compactRoutingPolicy,
+                "Available subagents:",
+                subagentCatalog,
+                "Candidate delegation plan:",
+                candidatePlan,
+                "Allowed JSON shapes:",
+                "{\"subagent_type\":\"<listed subagent name>\"}",
+                "{\"delegations\":[{\"subagent_type\":\"<listed subagent name>\",\"description\":\"<only that specialist's owned portion>\"}]}",
+                "User request:",
+                requestText,
+            ].filter(Boolean).join("\n\n");
+            const rawCoverage = await invokeRouter(coveragePrompt, "delegation router coverage invoke");
+            if (rawCoverage !== null) {
+                const coverageText = readModelText(rawCoverage);
+                const coverageSelection = parseCompactRouterSelection(coverageText, subagentNames);
+                if (coverageSelection?.subagentType && !structuredMultiItemRequest) {
+                    selection = coverageSelection;
+                }
+                if (coverageSelection?.delegations && coverageSelection.delegations.length === 1 && !structuredMultiItemRequest) {
+                    selection = { subagentType: coverageSelection.delegations[0].subagentType };
+                }
+                if (coverageSelection?.delegations && coverageSelection.delegations.length > 1) {
+                    const candidateNames = new Set(candidateDelegations.map((item) => item.subagentType));
+                    const coverageNames = new Set(coverageSelection.delegations.map((item) => item.subagentType));
+                    const preservesCandidateOwners = Array.from(candidateNames).every((name) => coverageNames.has(name));
+                    if (preservesCandidateOwners) {
+                        selection = coverageSelection;
+                    }
+                }
+            }
+            if (candidateDelegations.length > 1 && selection?.delegations && selection.delegations.length > 1) {
+                const activePlan = selection.delegations
+                    .map((item, index) => `${index + 1}. ${item.subagentType}: ${item.description}`)
+                    .join("\n");
+                const arbitrationPrompt = [
                     primaryModel.init?.think === false ? "/no_think" : "",
-                    "You are a strict JSON router for one bounded task.",
-                    "Choose exactly one owner from this list:",
-                    Array.from(subagentNames).join(", "),
-                    "Return only JSON with this shape:",
-                    "{\"subagent_type\":\"<one listed subagent name>\"}",
+                    "Arbitrate whether this delegation plan is over-split.",
+                    "The runtime supports both one-owner and multi-owner delegation.",
+                    "Choose one owner when the routing policy or subagent catalog says one listed subagent owns the whole request.",
+                    "A single objective with multiple evidence requirements is still single-owner when one listed subagent owns the objective.",
+                    "Treat supporting evidence dimensions as inputs to that owner, not as separate owners.",
+                    "Keep multi-owner delegation only when the user asked for multiple independently owned specialist work items.",
+                    "Return exactly one JSON object and no prose.",
+                    "Single-owner shape:",
+                    "{\"subagent_type\":\"<listed subagent name>\"}",
+                    "Multi-owner shape:",
+                    "{\"delegations\":[{\"subagent_type\":\"<listed subagent name>\",\"description\":\"<only that specialist's owned portion>\"}]}",
                     compactRoutingPolicy ? "Agent routing policy:" : "",
                     compactRoutingPolicy,
                     "Available subagents:",
                     subagentCatalog,
-                    "Task:",
-                    clause,
+                    "Candidate plan:",
+                    activePlan,
+                    "User request:",
+                    requestText,
                 ].filter(Boolean).join("\n\n");
-                const raw = await invokeRouter(clausePrompt, routeClauses.length > 1
-                    ? `delegation router clause invoke ${index + 1}`
-                    : "delegation router single-clause invoke");
-                const routed = raw === null ? null : parseCompactRouterSelection(readModelText(raw), subagentNames);
-                if (!routed?.subagentType || routed.refusedReason) {
-                    routedDelegations.length = 0;
-                    break;
-                }
-                if (routedDelegations.some((item) => item.subagentType === routed.subagentType)) {
-                    continue;
+                const rawArbitration = await invokeRouter(arbitrationPrompt, "delegation router over-split arbitration invoke");
+                if (rawArbitration !== null) {
+                    const arbitrationText = readModelText(rawArbitration);
+                    const arbitrationSelection = parseCompactRouterSelection(arbitrationText, subagentNames);
+                    if (arbitrationSelection?.subagentType && !structuredMultiItemRequest) {
+                        selection = arbitrationSelection;
+                    }
+                    else if (arbitrationSelection?.delegations && arbitrationSelection.delegations.length === 1 && !structuredMultiItemRequest) {
+                        selection = { subagentType: arbitrationSelection.delegations[0].subagentType };
+                    }
+                    else if (arbitrationSelection?.delegations && arbitrationSelection.delegations.length > 1) {
+                        selection = arbitrationSelection;
+                    }
                 }
-                routedDelegations.push({ subagentType: routed.subagentType, description: clause });
-            }
-            const existingDelegationCount = selection?.delegations?.length ?? 0;
-            if (routedDelegations.length > 1 && routedDelegations.length > existingDelegationCount) {
-                selection = { delegations: routedDelegations };
-            }
-            else if (routedDelegations.length === 1 && existingDelegationCount === 0) {
-                selection = { subagentType: routedDelegations[0].subagentType };
             }
         }
         if (selection?.delegations?.length === 1) {
@@ -1705,12 +1950,7 @@ export class AgentRuntimeAdapter {
         }
         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 && numberedRequestSteps.length < 3;
-            const executableDelegations = shouldCollapseOverbroadPlan ? plannedDelegations.slice(0, 1) : plannedDelegations;
+            const executableDelegations = plannedDelegations;
             const aggregateToolResults = [];
             const childReports = [];
             yield {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.467",
+  "version": "0.0.469",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",