@botbotgo/agent-harness 0.0.467 → 0.0.468

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.468";
 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.468";
 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()
@@ -1278,7 +1316,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,9 +1326,18 @@ 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 (!selection || selection.refusedReason || parsedSelection.subagentType) {
+                    selection = parsedSelection.refusedReason && index < routerPrompts.length - 1
+                        ? selection
+                        : parsedSelection;
+                }
             }
         }
         if (selection?.delegations && selection.delegations.length > 0) {
@@ -1564,7 +1611,11 @@ 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.",
+            "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.",
+            "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 +1683,26 @@ 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.",
+                    "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.",
+                    "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 +1712,64 @@ export class AgentRuntimeAdapter {
                 }
                 previousRawText = readModelText(raw);
                 const parsedSelection = parseCompactRouterSelection(previousRawText, subagentNames);
-                selection = parsedSelection?.refusedReason && index < routerPrompts.length - 1
-                    ? null
-                    : 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 = [
-                    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>\"}",
-                    compactRoutingPolicy ? "Agent routing policy:" : "",
-                    compactRoutingPolicy,
-                    "Available subagents:",
-                    subagentCatalog,
-                    "Task:",
-                    clause,
-                ].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;
+                if (!parsedSelection) {
+                    continue;
+                }
+                if (parsedSelection.delegations && parsedSelection.delegations.length > 1) {
+                    selection = parsedSelection;
                     break;
                 }
-                if (routedDelegations.some((item) => item.subagentType === routed.subagentType)) {
-                    continue;
+                if (!selection || selection.refusedReason || parsedSelection.subagentType) {
+                    selection = parsedSelection.refusedReason && index < routerPrompts.length - 1
+                        ? selection
+                        : parsedSelection;
                 }
-                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 || 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.",
+                "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 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,
+                "Required JSON shape:",
+                "{\"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?.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 (coverageSelection.delegations.length > candidateDelegations.length || preservesCandidateOwners) {
+                        selection = coverageSelection;
+                    }
+                }
             }
         }
         if (selection?.delegations?.length === 1) {
@@ -1705,12 +1778,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.468",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",