@botbotgo/agent-harness 0.0.462 → 0.0.464

package/dist/package-version.d.ts

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

package/dist/resources/prompts/runtime/write-todos-full-entry.md

@@ -1 +1 @@
-When calling write_todos, every todo item must include both content and status. Do not send status-only updates. Retry by resending the full todo entry with the original content preserved.
+When calling write_todos, every todo item must include both content and status. Use only these status values: pending, in_progress, completed. Do not send aliases such as not_started, open, active, done, blocked, failed, or cancelled. Do not send status-only updates. Retry by resending the full todo entry with the original content preserved.

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

@@ -1,5 +1,5 @@
 import { extractVisibleOutput, isToolCallRecoveryFailure, isRetrySafeInvalidToolSelectionError, appendToolRecoveryInstruction, resolveMissingPlanRecoveryInstruction, resolveExecutionWithoutToolEvidenceTextInstruction, shouldValidateExecutionWithoutToolEvidence, resolveToolCallRecoveryInstruction, sanitizeVisibleText, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION, } from "../../parsing/output-parsing.js";
-import { DELEGATED_TASK_FAILURE_RECOVERY_INSTRUCTION, DELEGATION_ONLY_RECOVERY_INSTRUCTION, } from "../../prompts/runtime-prompts.js";
+import { DELEGATED_TASK_FAILURE_RECOVERY_INSTRUCTION, DELEGATION_ONLY_RECOVERY_INSTRUCTION, REQUIRED_EXECUTION_CONTINUATION_INSTRUCTION, } from "../../prompts/runtime-prompts.js";
 import { buildInvocationRequest } from "../model/invocation-request.js";
 import { PROMPTED_JSON_TOOL_POLICY_KEY, withPromptedJsonToolPolicy } from "../model/prompted-json-tool-policy.js";
 import { buildRawModelMessages } from "../model/message-assembly.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.",
@@ -255,6 +257,14 @@ function buildDeterministicFinalFromStreamToolEvidence(executedToolResults) {
         evidence.length > 0 ? evidence.join("\n\n") : "(no non-planning tool evidence captured)",
     ].join("\n");
 }
+function latestStreamToolErrorRecoveryInstruction(executedToolResults) {
+    const latest = [...executedToolResults].reverse().find((item) => item.isError === true);
+    if (!latest) {
+        return null;
+    }
+    const message = typeof latest.output === "string" ? latest.output : JSON.stringify(latest.output);
+    return resolveToolCallRecoveryInstruction(new Error(message)) ?? REQUIRED_EXECUTION_CONTINUATION_INSTRUCTION;
+}
 function hasUsefulVisibleSynthesis(value) {
     const trimmed = value.trim();
     if (trimmed.length < 80) {
@@ -697,6 +707,7 @@ export async function* streamRuntimeExecution(options) {
                         const eventContainsNonRetrySafeChunk = projectedChunks.some((chunk) => chunk.kind !== "upstream-event"
                             && chunk.kind !== "content"
                             && !(chunk.kind === "tool-result" && isPlanToolName(chunk.toolName))
+                            && !(chunk.kind === "tool-result" && chunk.isError === true)
                             && !(chunk.kind === "tool-result" && chunk.isError === true && isRetrySafeInvalidToolSelectionError(chunk.output)));
                         const hadPriorPlanToolResult = completedPlanToolResultCount > 0;
                         const repeatedPlanToolResultBeforeEvidence = requiresPlanEvidence(options.binding)
@@ -704,7 +715,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 +761,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;
@@ -794,10 +805,23 @@ export async function* streamRuntimeExecution(options) {
                                 })
                                 : null;
                             const terminalDelegationOnlyRecoveryInstruction = resolveDelegationOnlyRecoveryInstruction(options.binding, terminalExecutionEvidence);
+                            const terminalPrematurePlanCloseRecoveryInstruction = requiresPlanEvidence(options.binding)
+                                && terminalExecutionEvidence.hasPlanStateEvidence
+                                && !terminalExecutionEvidence.hasSuccessfulNonTodoToolResultEvidence
+                                ? buildRunEvidenceAfterPlanInstruction(options.primaryTools)
+                                : null;
                             if (!emittedUnsafeStreamSideEffects
-                                && (terminalMissingPlanRecoveryInstruction || terminalDelegationOnlyRecoveryInstruction)) {
+                                && (terminalMissingPlanRecoveryInstruction
+                                    || terminalPrematurePlanCloseRecoveryInstruction
+                                    || terminalDelegationOnlyRecoveryInstruction)) {
                                 earlyStreamRecoveryInstruction =
-                                    terminalMissingPlanRecoveryInstruction ?? terminalDelegationOnlyRecoveryInstruction;
+                                    terminalMissingPlanRecoveryInstruction
+                                        ?? terminalPrematurePlanCloseRecoveryInstruction
+                                        ?? terminalDelegationOnlyRecoveryInstruction;
+                                earlyStreamRecoverySuppressInitialPlan = terminalPrematurePlanCloseRecoveryInstruction !== null;
+                                if (terminalPrematurePlanCloseRecoveryInstruction) {
+                                    earlyStreamExternalPlanEvidenceTools = resolveSingleConfiguredPlanEvidenceTool(options.primaryTools);
+                                }
                                 break;
                             }
                             if (requiresPlanEvidence(options.binding) && hasCompletedPlanWithEvidence(terminalExecutionEvidence)) {
@@ -818,6 +842,7 @@ export async function* streamRuntimeExecution(options) {
                                 && !hasMissingDelegatedExecutionEvidence(terminalExecutionEvidence)
                                 && !hasMissingDelegatedFindings(terminalExecutionEvidence)
                                 && !terminalMissingPlanRecoveryInstruction
+                                && !terminalPrematurePlanCloseRecoveryInstruction
                                 && !terminalDelegationOnlyRecoveryInstruction) {
                                 if (deferredStreamContent.length > 0) {
                                     yield* flushDeferredStreamContent();
@@ -929,6 +954,9 @@ export async function* streamRuntimeExecution(options) {
             const streamedRuntimeFailureRecoveryInstruction = projectionState.emittedOutput
                 ? resolveStreamedRuntimeFailureRecoveryInstruction(projectionState.emittedOutput, streamedExecutionEvidence)
                 : null;
+            const streamedToolErrorRecoveryInstruction = !emittedUnsafeStreamSideEffects
+                ? latestStreamToolErrorRecoveryInstruction(streamedToolResults)
+                : null;
             const missingPlanRecoveryInstruction = !hasUnresolvedExecution(streamedExecutionEvidence) && !delegatedExecutionRecoveryInstruction
                 ? resolveMissingPlanRecoveryInstruction({
                     request,
@@ -941,7 +969,8 @@ export async function* streamRuntimeExecution(options) {
                 : null;
             const retryInstruction = !emittedUnsafeStreamSideEffects && sawRetrySafeInvalidToolSelectionError
                 ? INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION
-                : delegatedExecutionRecoveryInstruction
+                : streamedToolErrorRecoveryInstruction
+                    ?? delegatedExecutionRecoveryInstruction
                     ?? streamedIncompletePlanRecoveryInstruction
                     ?? streamedPrematurePlanCloseRecoveryInstruction
                     ?? streamedRuntimeFailureRecoveryInstruction

package/dist/runtime/adapter/invocation-result.js

@@ -39,7 +39,8 @@ function hasIncompleteStateSnapshotPlan(stateSnapshot) {
 function hasStateSnapshotPlan(stateSnapshot) {
     return typeof stateSnapshot === "object"
         && stateSnapshot !== null
-        && Array.isArray(stateSnapshot.todos);
+        && Array.isArray(stateSnapshot.todos)
+        && (stateSnapshot.todos).length > 0;
 }
 function normalizePlanToolName(toolName) {
     return typeof toolName === "string" ? toolName.trim().toLowerCase().replace(/[\s-]+/gu, "_") : "";
@@ -54,7 +55,19 @@ function isPlanToolName(toolName) {
         || normalized === "call_read_todos";
 }
 function hasPlanToolEvidence(executedToolResults) {
-    return executedToolResults.some((item) => isPlanToolName(item.toolName));
+    return executedToolResults.some((item) => {
+        if (!isPlanToolName(item.toolName)) {
+            return false;
+        }
+        const output = typeof item.output === "object" && item.output !== null ? item.output : null;
+        const summaryContainer = typeof output?.summary === "object" && output.summary !== null
+            ? output.summary
+            : null;
+        const counts = typeof summaryContainer?.summary === "object" && summaryContainer.summary !== null
+            ? summaryContainer.summary
+            : null;
+        return !(typeof counts?.total === "number" && counts.total <= 0);
+    });
 }
 function hasExecutionToolEvidence(executedToolResults) {
     return executedToolResults.some((item) => item.isError !== true && !isPlanToolName(item.toolName));

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;
@@ -91,7 +108,11 @@ function readPlanStateSummary(output) {
         return null;
     }
     const typedCounts = counts;
+    if (typeof typedCounts.total === "number" && typedCounts.total <= 0) {
+        return null;
+    }
     return {
+        ...(typeof typedCounts.total === "number" ? { total: typedCounts.total } : {}),
         pending: typeof typedCounts.pending === "number" ? typedCounts.pending : 0,
         inProgress: typeof typedCounts.inProgress === "number" ? typedCounts.inProgress : 0,
     };
@@ -217,7 +238,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 +555,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/runtime-adapter-support.d.ts

@@ -5,7 +5,6 @@ export type BuiltinTodoSnapshot = {
 };
 export declare function truncateLines(lines: string[], maxChars?: number): string;
 export declare function summarizeBuiltinWriteTodosArgs(args: Record<string, unknown>): BuiltinTodoSnapshot;
-export declare function isLowSignalTodoContent(content: string): boolean;
 export declare function formatBuiltinTodoSnapshot(snapshot: BuiltinTodoSnapshot): string;
 export declare function buildRequestPlanState(input: {
     sessionId: string;

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

@@ -119,13 +119,6 @@ export function summarizeBuiltinWriteTodosArgs(args) {
         summary,
     };
 }
-export function isLowSignalTodoContent(content) {
-    const normalized = content.trim().toLowerCase();
-    if (!normalized) {
-        return true;
-    }
-    return /^\d+$/.test(normalized) || /^step\s*\d+$/.test(normalized) || /^todo\s*\d+$/.test(normalized);
-}
 export function formatBuiltinTodoSnapshot(snapshot) {
     if (snapshot.summary.total === 0) {
         return "No todos tracked.";

package/dist/runtime/adapter/stream-event-projection.js

@@ -1,6 +1,5 @@
 import { extractToolFallbackContext, extractVisibleOutput, readTextContent, sanitizeVisibleText } from "../parsing/output-parsing.js";
 import { salvageFunctionLikeToolCall } from "../parsing/output-tool-args.js";
-import { isLowSignalTodoContent, summarizeBuiltinWriteTodosArgs } from "./runtime-adapter-support.js";
 import { computeIncrementalOutput, extractInterruptPayload, extractReasoningStreamOutput, sanitizeRetainedUpstreamEvent, extractStateStreamOutput, extractTerminalStreamOutput, extractToolResult, extractVisibleStreamOutput, normalizeTerminalOutputKey, } from "../parsing/stream-event-parsing.js";
 import { resolveModelFacingToolName } from "./tool/tool-name-mapping.js";
 export function createStreamEventProjectionState() {
@@ -141,6 +140,9 @@ function readSummaryCounts(summary) {
         return null;
     }
     const typed = summary;
+    if (typeof typed.total === "number" && typed.total <= 0) {
+        return null;
+    }
     const hasAnyCountField = typeof typed.pending === "number"
         || typeof typed.inProgress === "number";
     if (!hasAnyCountField) {
@@ -155,6 +157,9 @@ function hasIncompleteTodosArray(value) {
     if (!Array.isArray(value)) {
         return null;
     }
+    if (value.length === 0) {
+        return null;
+    }
     return value.some((item) => {
         if (typeof item !== "object" || item === null) {
             return false;
@@ -394,12 +399,6 @@ function isPlanToolName(toolName) {
         || normalized === "call_write_todos"
         || normalized === "call_read_todos";
 }
-function isWriteTodosToolName(toolName) {
-    const normalized = normalizePlanToolName(toolName);
-    return normalized === "write_todos"
-        || normalized === "tool_call_write_todos"
-        || normalized === "call_write_todos";
-}
 function extractTodoToolStart(event) {
     if (typeof event !== "object" || event === null) {
         return null;
@@ -413,15 +412,6 @@ function extractTodoToolStart(event) {
         return null;
     }
     const input = unwrapPossibleToolInput(typed.data?.input);
-    if (isWriteTodosToolName(toolName) && typeof input === "object" && input !== null && !Array.isArray(input)) {
-        const summary = summarizeBuiltinWriteTodosArgs(input);
-        if (summary.summary.total === 0) {
-            throw new Error("Error invoking tool 'write_todos' with kwargs {\"todos\":[]} with error: Error: Initial write_todos call cannot use an empty todo list. Send the concrete task steps with both content and status.");
-        }
-        if (summary.items.every((item) => isLowSignalTodoContent(item.content))) {
-            throw new Error("Error invoking tool 'write_todos' with placeholder todo content with error: Error: Initial write_todos call must use descriptive task content. Do not use placeholder entries like '1', '2', or 'step 1'.");
-        }
-    }
     return { toolName, input };
 }
 export function projectRuntimeStreamEvent(params) {

package/dist/runtime/adapter/tool/builtin-middleware-tools.js

@@ -2,7 +2,7 @@ import path from "node:path";
 import { z } from "zod";
 import { isSandboxBackend } from "deepagents";
 import { isRecord } from "../../../utils/object.js";
-import { formatBuiltinTodoSnapshot, isLowSignalTodoContent, summarizeBuiltinWriteTodosArgs, truncateLines } from "../runtime-adapter-support.js";
+import { formatBuiltinTodoSnapshot, summarizeBuiltinWriteTodosArgs, truncateLines } from "../runtime-adapter-support.js";
 import { maybePersistLargeToolOutput, resolveToolRuntimeContext } from "./tool-output-artifacts.js";
 function buildTaskToolDescription(subagents) {
     const lines = [
@@ -272,14 +272,6 @@ export async function createBuiltinMiddlewareTools(backend, options) {
         invoke: async (input) => {
             const args = isRecord(input) ? input : {};
             const summary = summarizeBuiltinWriteTodosArgs(args);
-            if (summary.summary.total === 0 && todoSnapshot.summary.total === 0) {
-                throw new Error("Initial write_todos call cannot use an empty todo list. Send the concrete task steps with both content and status.");
-            }
-            if (summary.summary.total > 0 &&
-                todoSnapshot.summary.total === 0 &&
-                summary.items.every((item) => isLowSignalTodoContent(item.content))) {
-                throw new Error("Initial write_todos call must use descriptive task content. Do not use placeholder entries like '1', '2', or 'step 1'.");
-            }
             todoSnapshot = summary;
             return {
                 ok: true,

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

@@ -247,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;
@@ -839,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({
@@ -851,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,
@@ -1195,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");
             }
@@ -1214,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,
@@ -1606,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",
@@ -1803,18 +1853,15 @@ export class AgentRuntimeAdapter {
             originalRequest: requestText,
         });
         let delegatedResult = yield* runDelegatedStreamAttempt(delegatedText);
-        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 (selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
-            && !hasDelegatedPlanEvidence(delegatedResult)) {
+        if (needsDelegatedPlanRecovery(selectedBinding, delegatedResult)) {
             const previousDelegatedResult = delegatedResult;
             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,

package/dist/runtime/parsing/output-recovery.js

@@ -59,7 +59,8 @@ export function isToolCallValidationFailure(error) {
     if (/Invalid input:\s*expected .* received undefined/i.test(message) && /"path"\s*:\s*\[/.test(message)) {
         return true;
     }
-    return /Received tool input did not match expected schema/i.test(message) && /(?:→\s*at|at)\s+[\w[\].]+/i.test(message);
+    return /Received tool input did not match expected schema/i.test(message)
+        && (/(?:→\s*at|at)\s+[\w[\].]+/i.test(message) || /\bDetails:/i.test(message));
 }
 function collectErrorMessages(error) {
     if (!error)

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,15 +564,40 @@ 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;
-            normalized.status = typeof record.status === "string" && record.status.trim().length > 0 ? record.status : "pending";
+            normalized.status = normalizeWriteTodoStatus(record.status);
             return Object.keys(normalized).length > 0 ? normalized : todo;
         }),
     };
 }
+function normalizeWriteTodoStatus(value) {
+    if (typeof value !== "string") {
+        return "pending";
+    }
+    const normalized = value.trim().toLowerCase().replace(/[\s-]+/gu, "_");
+    if (!normalized) {
+        return "pending";
+    }
+    if (normalized === "not_started" || normalized === "todo" || normalized === "open") {
+        return "pending";
+    }
+    if (normalized === "started" || normalized === "active" || normalized === "in_progress") {
+        return "in_progress";
+    }
+    if (normalized === "done" || normalized === "complete" || normalized === "completed") {
+        return "completed";
+    }
+    return normalized;
+}
 function normalizeTaskArgs(args) {
     const description = typeof args.description === "string" && args.description.trim().length > 0
         ? args.description

package/dist/runtime/parsing/stream-event-parsing.js

@@ -1,4 +1,3 @@
-import { isLowSignalTodoContent } from "../adapter/runtime-adapter-support.js";
 import { extractReasoningText, extractVisibleOutput, hasToolCalls, readTextContent } from "./output-parsing.js";
 const MAX_STREAM_INLINE_TEXT_CHARS = 12_000;
 const STREAM_PREVIEW_TEXT_CHARS = 2_000;
@@ -205,31 +204,6 @@ function isErrorLikeToolOutput(value) {
         || /^command failed:/i.test(firstNonEmptyLine)
         || /^stderr:/i.test(firstNonEmptyLine);
 }
-function isEmptyInitialWriteTodosResult(value) {
-    if (typeof value !== "object" || !value || Array.isArray(value)) {
-        return false;
-    }
-    const typed = value;
-    if (typeof typed.summary === "object" && typed.summary && Array.isArray(typed.summary.items)) {
-        return (typed.summary.items).length === 0;
-    }
-    if (typeof typed.update === "object" && typed.update && Array.isArray(typed.update.todos)) {
-        return (typed.update.todos).length === 0;
-    }
-    return false;
-}
-function hasLowSignalInitialWriteTodos(value) {
-    if (typeof value !== "object" || !value || Array.isArray(value)) {
-        return false;
-    }
-    const typed = value;
-    const items = typeof typed.summary === "object" && typed.summary && Array.isArray(typed.summary.items)
-        ? (typed.summary.items ?? [])
-        : typeof typed.update === "object" && typed.update && Array.isArray(typed.update.todos)
-            ? (typed.update.todos ?? [])
-            : [];
-    return items.length > 0 && items.every((item) => typeof item?.content === "string" && isLowSignalTodoContent(item.content));
-}
 function isToolMessageLike(value) {
     if (typeof value !== "object" || value === null) {
         return false;
@@ -326,12 +300,6 @@ export function extractToolResult(event) {
     const normalizedOutput = typeof rawOutput === "string"
         ? parseMaybeJson(rawOutput)
         : unwrapToolMessageOutput(rawOutput);
-    if (!isToolError && toolName === "write_todos" && isEmptyInitialWriteTodosResult(normalizedOutput)) {
-        throw new Error("Error invoking tool 'write_todos' with kwargs {\"todos\":[]} with error: Error: Initial write_todos call cannot use an empty todo list. Send the concrete task steps with both content and status.");
-    }
-    if (!isToolError && toolName === "write_todos" && hasLowSignalInitialWriteTodos(normalizedOutput)) {
-        throw new Error("Error invoking tool 'write_todos' with placeholder todo content with error: Error: Initial write_todos call must use descriptive task content. Do not use placeholder entries like '1', '2', or 'step 1'.");
-    }
     return {
         toolName,
         output: sanitizeStreamPayload(normalizedOutput),

package/package.json

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