@botbotgo/agent-harness 0.0.461 → 0.0.463

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.461";
+export declare const AGENT_HARNESS_VERSION = "0.0.463";
 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.461";
+export const AGENT_HARNESS_VERSION = "0.0.463";
 export const AGENT_HARNESS_RELEASE_DATE = "2026-05-04";

package/dist/runtime/adapter/flow/stream-runtime.js

@@ -25,6 +25,8 @@ const RUN_EVIDENCE_AFTER_PREMATURE_PLAN_CLOSE_INSTRUCTION = [
     "The required todo board was closed before any non-TODO evidence tool returned.",
     "Do not call write_todos again yet.",
     "Your next action must be exactly one non-TODO evidence tool call selected from the available tool descriptions and schemas.",
+    "If the current request or todo board explicitly names one available non-TODO tool, call that named tool.",
+    "Do not substitute a neighboring, broader, narrower, or similarly named tool when an exact available tool name is present.",
     "After that evidence tool returns, update the todo board and then provide the final answer required by the agent response format.",
 ].join("\n");
 function readPrimaryToolName(tool) {
@@ -43,11 +45,11 @@ function buildRunEvidenceAfterPlanInstruction(primaryTools) {
         `Available non-planning tool names: ${toolNames.join(", ")}.`,
     ].join("\n");
 }
-function resolveConfiguredPlanEvidenceTool(primaryTools) {
-    const toolName = primaryTools
+function resolveSingleConfiguredPlanEvidenceTool(primaryTools) {
+    const toolNames = primaryTools
         .map(readPrimaryToolName)
-        .find((name) => name.length > 0 && !isPlanToolName(name));
-    return toolName ? [{ name: toolName, args: {}, id: "stream-configured-plan-evidence-tool-1" }] : [];
+        .filter((name) => name.length > 0 && !isPlanToolName(name));
+    return toolNames.length === 1 ? [{ name: toolNames[0], args: {}, id: "stream-single-plan-evidence-tool-1" }] : [];
 }
 const INITIAL_REQUIRED_PLAN_INSTRUCTION = [
     "This agent has a required visible planning contract.",
@@ -704,7 +706,7 @@ export async function* streamRuntimeExecution(options) {
                             && hadPriorPlanToolResult
                             && projectedChunks.some((chunk) => chunk.kind === "tool-result" && isPlanToolName(chunk.toolName));
                         if (repeatedPlanToolResultBeforeEvidence) {
-                            earlyStreamExternalPlanEvidenceTools = resolveConfiguredPlanEvidenceTool(options.primaryTools);
+                            earlyStreamExternalPlanEvidenceTools = resolveSingleConfiguredPlanEvidenceTool(options.primaryTools);
                             earlyStreamRecoveryInstruction = buildRunEvidenceAfterPlanInstruction(options.primaryTools);
                             earlyStreamRecoverySuppressInitialPlan = true;
                             break;
@@ -750,7 +752,7 @@ export async function* streamRuntimeExecution(options) {
                             && (hadPriorPlanToolResult
                                 || projectedChunks.some((chunk) => isCompletedPlanToolResultChunk(chunk)))
                             && !sawSuccessfulNonTodoToolResult) {
-                            earlyStreamExternalPlanEvidenceTools = resolveConfiguredPlanEvidenceTool(options.primaryTools);
+                            earlyStreamExternalPlanEvidenceTools = resolveSingleConfiguredPlanEvidenceTool(options.primaryTools);
                             earlyStreamRecoveryInstruction = buildRunEvidenceAfterPlanInstruction(options.primaryTools);
                             earlyStreamRecoverySuppressInitialPlan = true;
                             break;

package/dist/runtime/adapter/local-tool-invocation.js

@@ -13,15 +13,21 @@ const TOOL_FOLLOW_UP_INSTRUCTION = "One or more tool results are already availab
 const DEFAULT_MAX_TOOL_ITERATIONS = 10_000;
 const MAX_REPEATED_RECOVERY_WITHOUT_PROGRESS = 2;
 const MAX_REPEATED_PLAN_ONLY_AFTER_PLAN = 2;
-function prioritizeBootstrapEvidenceTools(primaryTools) {
+const REQUIRED_PLAN_CONTRACT_MARKER = "This agent has a required visible planning contract.";
+const INITIAL_WRITE_TODOS_MARKER = "Your first action for this request must be write_todos";
+function resolveSingleBootstrapEvidenceTool(primaryTools) {
     const evidenceTools = primaryTools
         .map((tool) => typeof tool.name === "string" ? tool.name.trim() : "")
         .filter((name) => name.length > 0 && !isPlanToolName(name));
-    return evidenceTools.slice(0, 4);
+    return evidenceTools.length === 1 ? evidenceTools[0] : undefined;
 }
 function createBootstrapTodoPlan(primaryTools) {
-    const evidenceTool = prioritizeBootstrapEvidenceTools(primaryTools)[0];
-    if (!evidenceTool) {
+    const evidenceTool = resolveSingleBootstrapEvidenceTool(primaryTools);
+    const evidenceToolCount = primaryTools
+        .map((tool) => typeof tool.name === "string" ? tool.name.trim() : "")
+        .filter((name) => name.length > 0 && !isPlanToolName(name))
+        .length;
+    if (evidenceToolCount === 0) {
         return [
             {
                 content: "Establish the required visible plan for this request",
@@ -35,7 +41,9 @@ function createBootstrapTodoPlan(primaryTools) {
     }
     return [
         {
-            content: `Run the configured non-planning evidence tool: ${evidenceTool}`,
+            content: evidenceTool
+                ? `Run the only configured non-planning evidence tool: ${evidenceTool}`
+                : "Select and run the appropriate non-planning evidence tool from the declared tool surface",
             status: "in_progress",
         },
         {
@@ -76,6 +84,15 @@ function buildExternalPlanEvidenceToolResult(tools) {
             }],
     };
 }
+function stripSatisfiedInitialPlanInstruction(messages) {
+    return messages.filter((message) => {
+        const typed = typeof message === "object" && message !== null ? message : {};
+        if (typeof typed.content !== "string") {
+            return true;
+        }
+        return !(typed.content.includes(REQUIRED_PLAN_CONTRACT_MARKER) && typed.content.includes(INITIAL_WRITE_TODOS_MARKER));
+    });
+}
 function readPlanStateSummary(output) {
     if (typeof output !== "object" || output === null) {
         return null;
@@ -217,7 +234,7 @@ function debugLocalToolReplay(input) {
     }
     console.error(JSON.stringify({
         type: "local-tool-replay",
-        toolCallNames: input.toolCalls.map((toolCall) => toolCall.name),
+        toolCalls: input.toolCalls.map((toolCall) => ({ name: toolCall.name, args: toolCall.args })),
         resultMessages: summarizeResultMessages(input.result),
         executableToolNames: input.executableToolNames,
         builtinToolNames: input.builtinToolNames,
@@ -534,7 +551,9 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
                 executedToolResults,
             };
         }
-        currentMessages = nextMessages;
+        currentMessages = hasPlanStateEvidence(executedToolResults, externalPlanEvidence)
+            ? stripSatisfiedInitialPlanInstruction(nextMessages)
+            : nextMessages;
         activeRequest = {
             ...activeRequest,
             messages: currentMessages,

package/dist/runtime/adapter/model/model-providers.js

@@ -6,7 +6,7 @@ import { ChatOpenAI } from "@langchain/openai";
 import { AIMessage } from "langchain";
 import { initChatModel } from "langchain";
 import { salvageToolArgs, tryParseJson } from "../../parsing/output-parsing.js";
-import { salvageJsonToolCalls } from "../../parsing/output-tool-args.js";
+import { normalizeKnownToolArgs, salvageJsonToolCalls } from "../../parsing/output-tool-args.js";
 import { normalizeModelFacingToolSchema } from "../tool/resolved-tool.js";
 import { normalizeOpenAICompatibleInit } from "../compat/openai-compatible.js";
 import { recordPromptedJsonToolCall } from "./prompted-json-tool-call-capture.js";
@@ -640,7 +640,7 @@ function normalizeParsedToolCall(payload) {
     const args = Array.isArray(argsCandidate)
         ? { args: argsCandidate }
         : salvageToolArgs(argsCandidate) ?? {};
-    return { name, args };
+    return { name, args: normalizeKnownToolArgs(name, args) };
 }
 function buildFallbackTodoContents() {
     return [
@@ -770,6 +770,8 @@ function withPromptedJsonToolPrompt(input, tools, options = {}) {
             ? [
                 "Required evidence tool call:",
                 "A todo board already exists. Your next action must be exactly one non-planning tool call chosen from the available tool descriptions and schemas.",
+                "If the current request or todo board explicitly names one available non-planning tool, call that named tool.",
+                "Do not substitute a neighboring, broader, narrower, or similarly named tool when an exact available tool name is present.",
                 "Do not call write_todos or read_todos now.",
                 "Do not write prose, markdown, analysis, or a plain-text plan.",
             ].join("\n")

package/dist/runtime/adapter/tool/tool-arguments.js

@@ -1,5 +1,5 @@
 import { salvageToolArgs } from "../../parsing/output-parsing.js";
-import { salvageJsonToolCalls } from "../../parsing/output-tool-args.js";
+import { normalizeKnownToolArgs, salvageJsonToolCalls, salvageResultLabeledToolCall } from "../../parsing/output-tool-args.js";
 import { isRecord } from "../../../utils/object.js";
 import { extractExplicitResourceReferences, hasExplicitResourceReference } from "../../harness/system/runtime-memory-policy.js";
 import { readCapturedPromptedJsonToolCalls } from "../model/prompted-json-tool-call-capture.js";
@@ -175,6 +175,29 @@ function mapDelimitedListLikeArgs(args) {
     }
     return next;
 }
+function dropDelimitedScalarPathArgs(args, shape) {
+    let next = args;
+    for (const [key, schemaPart] of Object.entries(shape)) {
+        const value = next[key];
+        if (typeof value !== "string") {
+            continue;
+        }
+        const normalizedKey = key.trim().toLowerCase();
+        if (!/(?:^path$|path$|^filepath$|^targetpath$)/u.test(normalizedKey)) {
+            continue;
+        }
+        if (schemaPartExpectsArray(schemaPart)) {
+            continue;
+        }
+        const raw = value.trim();
+        if (!/[,;\n]/u.test(raw)) {
+            continue;
+        }
+        const { [key]: _dropped, ...rest } = next;
+        next = rest;
+    }
+    return next;
+}
 export function normalizeToolArgsForSchema(args, schema, rawArgsInput, options = {}) {
     const schemaDef = isObject(schema) ? schema._def : undefined;
     const zodShape = schemaDef
@@ -191,7 +214,7 @@ export function normalizeToolArgsForSchema(args, schema, rawArgsInput, options =
     if (!shape || !isRecord(shape)) {
         return mapDelimitedListLikeArgs(args);
     }
-    const aliasMappedArgs = mapStringArrayFields(mapCommonArgumentAliases(args, shape), shape);
+    const aliasMappedArgs = dropDelimitedScalarPathArgs(mapStringArrayFields(mapCommonArgumentAliases(args, shape), shape), shape);
     const keys = Object.keys(shape);
     if (keys.length !== 1) {
         return fillLatestUserInputForQueryLikeFields(aliasMappedArgs, shape, options.latestUserInput);
@@ -270,7 +293,7 @@ export function extractToolCallsFromResult(result) {
             if (id && answeredToolCallIds.has(id)) {
                 return null;
             }
-            return { id, name, args: rawArgs, rawArgsInput };
+            return { id, name, args: normalizeKnownToolArgs(name, rawArgs), rawArgsInput };
         })
             .filter((item) => item !== null);
         if (extracted.length > 0) {
@@ -296,6 +319,15 @@ export function extractToolCallsFromResult(result) {
         if (!content.trim()) {
             continue;
         }
+        const resultLabeledToolCall = salvageResultLabeledToolCall(content);
+        if (resultLabeledToolCall) {
+            return [{
+                    id: "salvaged-result-label-1",
+                    name: resultLabeledToolCall.name,
+                    args: resultLabeledToolCall.args,
+                    rawArgsInput: content,
+                }];
+        }
         const salvaged = salvageJsonToolCalls(content);
         if (salvaged.length > 0) {
             return salvaged.map((toolCall, salvageIndex) => ({

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

@@ -7,7 +7,6 @@ import { salvageJsonToolCalls } from "./parsing/output-tool-args.js";
 import { extractMessageText } from "../utils/message-content.js";
 import { AGENT_INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildDeepAgentSystemPromptWithCapabilityCatalog, buildLangChainCreateParams, DEFAULT_DEEPAGENT_RECURSION_LIMIT, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, shouldAttachDeepAgentBackend, shouldAttachDeepAgentCheckpointer, shouldAttachDeepAgentStore, } from "./agent-runtime-assembly.js";
 import { resolveDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourceRootPaths, } from "./adapter/compat/deepagent-compat.js";
-import { EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION } from "./prompts/runtime-prompts.js";
 import { buildToolNameMapping, } from "./adapter/tool/tool-name-mapping.js";
 import { executeRequestInvocation } from "./adapter/flow/invocation-flow.js";
 import { streamRuntimeExecution } from "./adapter/flow/stream-runtime.js";
@@ -25,16 +24,6 @@ export { buildAuthOmittingFetch, normalizeOpenAICompatibleInit } from "./adapter
 export { buildToolNameMapping, createModelFacingToolNameCandidates, createModelFacingToolNameLookupCandidates, resolveModelFacingToolName, sanitizeToolNameForModel, } from "./adapter/tool/tool-name-mapping.js";
 export { computeRemainingTimeoutMs, isRetryableProviderError, resolveBindingTimeout, resolveProviderRetryPolicy, resolveStreamIdleTimeout, resolveTimeoutMs, } from "./adapter/resilience.js";
 import { getBindingAdapterKind, getBindingBuiltinToolsConfig, getBindingDeepAgentSubagents, getBindingExecutionParams, getBindingExecutionKind, getBindingFilesystemConfig, getBindingMemorySources, getBindingPrimaryModel, getBindingSkills, getBindingSubagents, getBindingToolCount, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
-function hasDelegatedExecutionToolEvidence(result) {
-    const executedToolResults = Array.isArray(result.metadata?.executedToolResults)
-        ? result.metadata.executedToolResults
-        : [];
-    return executedToolResults.some((toolResult) => (toolResult.isError !== true
-        && !isPlanToolName(toolResult.toolName)));
-}
-function hasRequiredDelegatedExecutionToolEvidence(result) {
-    return hasDelegatedExecutionToolEvidence(result);
-}
 function buildDelegatedPlanEvidenceBlocker(agentId) {
     return JSON.stringify({
         status: "blocked",
@@ -50,30 +39,6 @@ function buildDelegatedPlanEvidenceBlocker(agentId) {
         report: `routing delegated to ${agentId}; todoTrace ${agentId}: TODO evidence 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, 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: [`${agentId}: TODO evidence observed; delegated planning board did not produce 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 ${agentId}: TODO evidence observed but non-planning evidence missing; 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, "_") : "";
 }
@@ -282,6 +247,32 @@ function hasDelegatedPlanEvidence(result) {
     return Array.isArray(toolResults)
         && toolResults.some((item) => isPlanToolName(item.toolName));
 }
+function hasIncompleteDelegatedTodos(value) {
+    if (Array.isArray(value)) {
+        return value.some((item) => hasIncompleteDelegatedTodos(item));
+    }
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const record = value;
+    const status = typeof record.status === "string" ? record.status.trim().toLowerCase() : "";
+    if (status === "pending" || status === "in_progress") {
+        return true;
+    }
+    return hasIncompleteDelegatedTodos(record.todos)
+        || hasIncompleteDelegatedTodos(record.update)
+        || hasIncompleteDelegatedTodos(record.stateSnapshot)
+        || hasIncompleteDelegatedTodos(record.metadata);
+}
+function hasIncompleteDelegatedPlanState(result) {
+    const toolResults = result?.metadata?.executedToolResults;
+    return Array.isArray(toolResults)
+        && toolResults.some((item) => isPlanToolName(item.toolName) && hasIncompleteDelegatedTodos(item.output));
+}
+function needsDelegatedPlanRecovery(binding, result) {
+    return binding?.harnessRuntime.executionContract?.requiresPlan === true
+        && (!hasDelegatedPlanEvidence(result) || hasIncompleteDelegatedPlanState(result));
+}
 function readUpstreamToolEvidence(event) {
     if (typeof event !== "object" || event === null) {
         return null;
@@ -342,6 +333,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");
+const DELEGATED_PLAN_EVIDENCE_FINAL_RETRY_INSTRUCTION = [
+    "The delegated task still has no visible TODO planning evidence.",
+    "Use the actual write_todos tool interface now. Do not print JSON, markdown, or a tool-call transcript as text.",
+    "The next runtime event must be the write_todos tool call result, not an assistant message describing the call.",
+    "After write_todos succeeds, continue the delegated task and close every TODO as completed or failed.",
+].join("\n");
 function looksLikeRawCommandTranscript(value) {
     const normalized = value.trim();
     return /^(?:stdout|stderr)\s*:/iu.test(normalized)
@@ -868,6 +865,28 @@ export class AgentRuntimeAdapter {
         const inlineSubagents = input.resolvedSubagents.filter((subagent) => !("graphId" in subagent));
         const asyncSubagents = input.resolvedSubagents.filter((subagent) => "graphId" in subagent);
         const subagents = inlineSubagents;
+        const subagentDefaultMiddleware = [
+            ...(builtinTools.todos === false ? [] : [todoListMiddleware()]),
+            ...(builtinTools.filesystem === false ? [] : [createFilesystemMiddleware({ backend })]),
+            createSummarizationMiddleware({
+                model: input.resolvedModel,
+                backend,
+            }),
+            createPatchToolCallsMiddleware(),
+        ];
+        const generalPurposeMiddleware = [
+            ...subagentDefaultMiddleware,
+            ...(input.resolvedSkills.length > 0 ? [createSkillsMiddleware({
+                    backend,
+                    sources: resolveDeepAgentSkillSourceRootPaths({
+                        workspaceRoot: binding.harnessRuntime.workspaceRoot,
+                        runtimeRoot: binding.harnessRuntime.runtimeRoot,
+                        ownerId: binding.agent.id,
+                        skillPaths: input.resolvedSkills,
+                    }) ?? input.resolvedSkills,
+                })] : []),
+        ];
+        const hasGeneralPurposeOverride = subagents.some((subagent) => subagent.name === "general-purpose");
         const middleware = [
             ...(builtinTools.todos === false ? [] : [todoListMiddleware()]),
             ...(input.resolvedSkills.length > 0 ? [createSkillsMiddleware({
@@ -880,15 +899,15 @@ export class AgentRuntimeAdapter {
                     }) ?? input.resolvedSkills,
                 })] : []),
             ...(builtinTools.filesystem === false ? [] : [createFilesystemMiddleware({ backend })]),
-            ...(subagents.length > 0
-                ? [createSubAgentMiddleware({
-                        defaultModel: input.resolvedModel,
-                        defaultTools: input.resolvedTools,
-                        defaultInterruptOn: input.resolvedInterruptOn,
-                        subagents: subagents,
-                        generalPurposeAgent: false,
-                    })]
-                : []),
+            createSubAgentMiddleware({
+                defaultModel: input.resolvedModel,
+                defaultTools: input.resolvedTools,
+                defaultMiddleware: subagentDefaultMiddleware,
+                generalPurposeMiddleware: generalPurposeMiddleware,
+                defaultInterruptOn: input.resolvedInterruptOn,
+                subagents: subagents,
+                generalPurposeAgent: !hasGeneralPurposeOverride,
+            }),
             createSummarizationMiddleware({
                 model: input.resolvedModel,
                 backend,
@@ -1224,8 +1243,7 @@ export class AgentRuntimeAdapter {
                 };
             }
         }
-        if (selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
-            && !hasDelegatedPlanEvidence(delegatedResult)) {
+        if (needsDelegatedPlanRecovery(selectedBinding, delegatedResult)) {
             try {
                 delegatedResult = await runDelegatedRequest([requestText, DELEGATED_PLAN_EVIDENCE_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":plan-evidence-retry");
             }
@@ -1243,8 +1261,7 @@ export class AgentRuntimeAdapter {
                 };
             }
         }
-        if (selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
-            && !hasDelegatedPlanEvidence(delegatedResult)) {
+        if (needsDelegatedPlanRecovery(selectedBinding, delegatedResult)) {
             const output = buildDelegatedPlanEvidenceBlocker(selectedBinding.agent.id);
             return {
                 toolOutput: output,
@@ -1635,12 +1652,16 @@ export class AgentRuntimeAdapter {
                     agentId: selectedBinding?.agent.id ?? planned.subagentType,
                 };
                 let delegatedResult = yield* runPlannedDelegation(planned.subagentType, delegatedText);
-                if (selectedBinding?.harnessRuntime.executionContract?.requiresPlan === true && !hasDelegatedPlanEvidence(delegatedResult)) {
+                if (needsDelegatedPlanRecovery(selectedBinding, 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);
                 }
-                if (selectedBinding?.harnessRuntime.executionContract?.requiresPlan === true && !hasDelegatedPlanEvidence(delegatedResult)) {
-                    const output = buildDelegatedPlanEvidenceBlocker(selectedBinding.agent.id);
+                if (needsDelegatedPlanRecovery(selectedBinding, delegatedResult)) {
+                    const previousDelegatedResult = delegatedResult;
+                    delegatedResult = mergeDelegatedResultToolEvidence(yield* runPlannedDelegation(planned.subagentType, [delegatedText, DELEGATED_PLAN_EVIDENCE_FINAL_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":plan-evidence-final-retry"), previousDelegatedResult);
+                }
+                if (needsDelegatedPlanRecovery(selectedBinding, delegatedResult)) {
+                    const output = buildDelegatedPlanEvidenceBlocker(selectedBinding?.agent.id ?? planned.subagentType);
                     delegatedResult = {
                         ...delegatedResult,
                         state: "failed",
@@ -1832,21 +1853,15 @@ export class AgentRuntimeAdapter {
             originalRequest: requestText,
         });
         let delegatedResult = yield* runDelegatedStreamAttempt(delegatedText);
-        const targetRequiresExecutionToolEvidence = getBindingPrimaryTools(selectedBinding).length > 0;
-        if (selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
-            && !hasDelegatedPlanEvidence(delegatedResult)) {
+        if (needsDelegatedPlanRecovery(selectedBinding, delegatedResult)) {
             const previousDelegatedResult = delegatedResult;
             delegatedResult = mergeDelegatedResultToolEvidence(yield* runDelegatedStreamAttempt([delegatedText, DELEGATED_PLAN_EVIDENCE_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":plan-evidence-retry"), previousDelegatedResult);
         }
-        if (targetRequiresExecutionToolEvidence && !hasRequiredDelegatedExecutionToolEvidence(delegatedResult)) {
+        if (needsDelegatedPlanRecovery(selectedBinding, delegatedResult)) {
             const previousDelegatedResult = delegatedResult;
-            delegatedResult = mergeDelegatedResultToolEvidence(yield* runDelegatedStreamAttempt([
-                delegatedText,
-                EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION,
-            ].filter(Boolean).join("\n\n"), ":tool-evidence-retry"), previousDelegatedResult);
+            delegatedResult = mergeDelegatedResultToolEvidence(yield* runDelegatedStreamAttempt([delegatedText, DELEGATED_PLAN_EVIDENCE_FINAL_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":plan-evidence-final-retry"), previousDelegatedResult);
         }
-        if (selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
-            && !hasDelegatedPlanEvidence(delegatedResult)) {
+        if (needsDelegatedPlanRecovery(selectedBinding, delegatedResult)) {
             const output = buildDelegatedPlanEvidenceBlocker(selectedBinding.agent.id);
             delegatedResult = {
                 ...delegatedResult,
@@ -1855,15 +1870,6 @@ export class AgentRuntimeAdapter {
                 finalMessageText: output,
             };
         }
-        if (targetRequiresExecutionToolEvidence && !hasRequiredDelegatedExecutionToolEvidence(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
             : [];

package/dist/runtime/parsing/output-tool-args.d.ts

@@ -7,6 +7,10 @@ export declare function salvageLabeledToolCall(value: unknown): {
     name: string;
     args: Record<string, unknown>;
 } | null;
+export declare function salvageResultLabeledToolCall(value: unknown): {
+    name: string;
+    args: Record<string, unknown>;
+} | null;
 export declare function salvageToolArgs(value: unknown): Record<string, unknown> | null;
 export declare function salvageJsonToolCalls(value: unknown): Array<{
     name: string;

package/dist/runtime/parsing/output-tool-args.js

@@ -179,6 +179,22 @@ export function salvageLabeledToolCall(value) {
     }
     return null;
 }
+export function salvageResultLabeledToolCall(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const lines = value
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const label = lines[0]?.replace(/[*`#]/gu, "").trim() ?? "";
+    const match = /^([A-Za-z_][A-Za-z0-9_]*)\s+result\b/iu.exec(label);
+    if (!match || !isToolName(match[1])) {
+        return null;
+    }
+    const args = salvageToolArgs(lines.slice(1).join("\n")) ?? {};
+    return { name: match[1], args: normalizeKnownToolArgs(match[1], args) };
+}
 function extractBalancedJsonValue(value, openChar, closeChar) {
     const start = value.indexOf(openChar);
     if (start < 0)
@@ -514,12 +530,26 @@ function normalizeWriteTodosArgs(args) {
     if (Array.isArray(args.items) && !Array.isArray(args.todos)) {
         return normalizeWriteTodosArgs({ ...args, todos: args.items });
     }
+    if (Array.isArray(args.tasks) && !Array.isArray(args.todos)) {
+        return normalizeWriteTodosArgs({ ...args, todos: args.tasks });
+    }
+    if (Array.isArray(args.todo) && !Array.isArray(args.todos)) {
+        return normalizeWriteTodosArgs({ ...args, todos: args.todo });
+    }
     if (!Array.isArray(args.todos)) {
         return args;
     }
+    const { items: _items, tasks: _tasks, todo: _todo, ...rest } = args;
     return {
-        ...args,
+        ...rest,
         todos: args.todos.map((todo, index) => {
+            if (typeof todo === "string") {
+                const content = todo.trim();
+                return {
+                    content: content.length > 0 ? content : `Step ${index + 1}`,
+                    status: index === 0 ? "in_progress" : "pending",
+                };
+            }
             if (typeof todo !== "object" || !todo || Array.isArray(todo)) {
                 return todo;
             }
@@ -534,7 +564,13 @@ function normalizeWriteTodosArgs(args) {
                             ? record.name
                             : typeof record.text === "string" && record.text.trim().length > 0
                                 ? record.text
-                                : `Step ${index + 1}`;
+                                : typeof record.task === "string" && record.task.trim().length > 0
+                                    ? record.task
+                                    : typeof record.action === "string" && record.action.trim().length > 0
+                                        ? record.action
+                                        : typeof record.step === "string" && record.step.trim().length > 0
+                                            ? record.step
+                                            : `Step ${index + 1}`;
             const normalized = {};
             if (content !== undefined)
                 normalized.content = content;

package/package.json

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