@botbotgo/agent-harness 0.0.444 → 0.0.446

package/dist/package-version.d.ts

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

package/dist/resources/prompts/runtime/required-execution-continuation.md

@@ -0,0 +1,8 @@
+The runtime has already observed planning state, tool state, or delegated execution state for this request. Continue from that state instead of restarting the task, broadening the scope, or asking the user to choose the next step.
+
+Use the current todo board, prior tool results, and available configured tools to choose one terminally useful action:
+- If a todo board is incomplete and existing evidence is enough, update the remaining todo items to completed, blocked, or failed as appropriate, then provide the final answer grounded in the observed evidence.
+- If more evidence is required and an available non-planning tool can get it, call that concrete tool next. Do not call write_todos or read_todos again before the evidence tool returns.
+- If no available tool can resolve the remaining work, update the todo board to blocked or failed and return a blocker report with the evidence already gathered.
+
+Never print a tool-call JSON object, function call, or tool name as prose when you intend to use a tool. Actually call the tool. Ask a blocking clarification question only after the available runtime evidence and configured tools are genuinely insufficient to continue.

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

@@ -8,7 +8,7 @@ import { UPSTREAM_REQUEST_CONFIG_KEY, UPSTREAM_SESSION_CONFIG_KEY } from "../ups
 import { appendToolRecoveryInstruction, extractVisibleOutput, tryParseJson } from "../../parsing/output-parsing.js";
 import { salvageJsonToolCalls } from "../../parsing/output-tool-args.js";
 import { isEmptyFinalAiMessageError } from "../resilience.js";
-import { AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, WRITE_TODOS_REQUIRED_PLAN_INSTRUCTION, } from "../../prompts/runtime-prompts.js";
+import { EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, REQUIRED_EXECUTION_CONTINUATION_INSTRUCTION, WRITE_TODOS_REQUIRED_PLAN_INSTRUCTION, } from "../../prompts/runtime-prompts.js";
 const CLOSE_REQUIRED_PLAN_RECOVERY_INSTRUCTION = [
     "The current required todo board still has unfinished work.",
     "Do not broaden the investigation, restart planning, or ask the user what to do next.",
@@ -381,7 +381,7 @@ export async function executeRequestInvocation(options) {
             ? result.messages
             : undefined;
         const recoveryBase = messages ? { messages } : request;
-        const recoveredRequest = appendToolRecoveryInstruction(recoveryBase, AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION);
+        const recoveredRequest = appendToolRecoveryInstruction(recoveryBase, REQUIRED_EXECUTION_CONTINUATION_INSTRUCTION);
         const recoveredInvocation = await invokeOnce(recoveredRequest);
         result = recoveredInvocation.result;
         executedToolResults.splice(0, executedToolResults.length, ...recoveredInvocation.executedToolResults);

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

@@ -8,7 +8,7 @@ import { toolRequiresRuntimeApproval } from "./tool/tool-hitl.js";
 import { validateToolGatewayInput } from "../harness/tool-gateway/index.js";
 import { appendToolRecoveryInstruction, extractVisibleOutput, resolveMissingPlanRecoveryInstruction, resolveExecutionWithoutToolEvidenceTextInstruction, resolveToolCallRecoveryInstruction, sanitizeVisibleText, STRICT_TOOL_JSON_INSTRUCTION, } from "../parsing/output-parsing.js";
 import { salvageJsonToolCalls } from "../parsing/output-tool-args.js";
-import { AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION } from "../prompts/runtime-prompts.js";
+import { REQUIRED_EXECUTION_CONTINUATION_INSTRUCTION } from "../prompts/runtime-prompts.js";
 const TOOL_FOLLOW_UP_INSTRUCTION = "One or more tool results are already available in this conversation. Answer the user's current request directly from the existing context and tool results. Do not ask the user to repeat inputs that are already present above.";
 const DEFAULT_MAX_TOOL_ITERATIONS = 10_000;
 const MAX_REPEATED_RECOVERY_WITHOUT_PROGRESS = 2;
@@ -188,7 +188,7 @@ function latestToolErrorRecoveryInstruction(executedToolResults) {
         return null;
     }
     const message = typeof latest.output === "string" ? latest.output : JSON.stringify(latest.output);
-    return resolveToolCallRecoveryInstruction(new Error(message)) ?? AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION;
+    return resolveToolCallRecoveryInstruction(new Error(message)) ?? REQUIRED_EXECUTION_CONTINUATION_INSTRUCTION;
 }
 function terminalToolErrorRecoveryInstruction(terminalText) {
     return resolveToolCallRecoveryInstruction(new Error(terminalText));
@@ -386,7 +386,7 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
                     requiresPlan: requiresPlanEvidence(binding),
                 })
                 : shouldEnforceIncompletePlan
-                    ? AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION
+                    ? REQUIRED_EXECUTION_CONTINUATION_INSTRUCTION
                     : null);
             if (requiresPlanEvidence(binding)
                 && !hasPlanStateEvidence(executedToolResults, externalPlanEvidence)
@@ -477,7 +477,7 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
                     executedToolResults,
                 });
             }
-            activeRequest = appendToolRecoveryInstruction(activeRequest, AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION);
+            activeRequest = appendToolRecoveryInstruction(activeRequest, REQUIRED_EXECUTION_CONTINUATION_INSTRUCTION);
             pendingResult = undefined;
             continue;
         }

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

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { createHash } from "node:crypto";
 import { createAsyncSubAgentMiddleware, createFilesystemMiddleware, createMemoryMiddleware, createPatchToolCallsMiddleware, createSkillsMiddleware, createSummarizationMiddleware, createSubAgentMiddleware, FilesystemBackend, StateBackend, } from "deepagents";
-import { createAgent, createMiddleware, humanInTheLoopMiddleware, todoListMiddleware, ToolMessage } from "langchain";
+import { createAgent, humanInTheLoopMiddleware, todoListMiddleware } from "langchain";
 import { sanitizeVisibleText, tryParseJson, wrapResolvedModel, } from "./parsing/output-parsing.js";
 import { salvageJsonToolCalls } from "./parsing/output-tool-args.js";
 import { extractMessageText } from "../utils/message-content.js";
@@ -17,7 +17,6 @@ import { extractSubagentRequestText, invokeBuiltinTaskTool as invokeBuiltinTaskT
 import { isEmptyFinalAiMessageError, resolveBindingTimeout, resolveStreamIdleTimeout, } from "./adapter/resilience.js";
 import { createResolvedModel } from "./adapter/model/model-providers.js";
 import { appendProviderToolCallAliasTools, resolveAdapterTools } from "./adapter/tool-resolution.js";
-import { normalizeToolArgsForSchema } from "./adapter/tool/tool-arguments.js";
 import { resolveRuntimeStreamExecutionContext, } from "./adapter/flow/execution-context.js";
 import { isRetryableProviderError } from "./adapter/resilience.js";
 import { UPSTREAM_REQUEST_CONFIG_KEY, UPSTREAM_SESSION_CONFIG_KEY } from "./adapter/upstream-configurable-keys.js";
@@ -39,6 +38,61 @@ function hasDelegatedExecutionToolEvidence(result) {
     return executedToolResults.some((toolResult) => (toolResult.isError !== true
         && !isPlanToolName(toolResult.toolName)));
 }
+function normalizeEvidenceToolName(toolName) {
+    return typeof toolName === "string" ? toolName.trim().toLowerCase() : "";
+}
+function collectSuccessfulDelegatedExecutionToolNames(result) {
+    const executedToolResults = Array.isArray(result.metadata?.executedToolResults)
+        ? result.metadata.executedToolResults
+        : [];
+    return new Set(executedToolResults
+        .filter((toolResult) => toolResult.isError !== true && !isPlanToolName(toolResult.toolName))
+        .map((toolResult) => normalizeEvidenceToolName(toolResult.toolName))
+        .filter((toolName) => toolName.length > 0));
+}
+function textExplicitlyNamesConfiguredTool(text, toolName) {
+    const name = toolName.trim();
+    if (!name) {
+        return false;
+    }
+    const pattern = new RegExp(`(?:^|[^\\p{L}\\p{N}_-])${escapeRegExp(name)}(?:$|[^\\p{L}\\p{N}_-])`, "iu");
+    return pattern.test(text);
+}
+function resolveExplicitRequestedExecutionToolNames(binding, requestText) {
+    const text = requestText.trim();
+    if (!text) {
+        return [];
+    }
+    return getBindingPrimaryTools(binding)
+        .map((tool) => tool.name)
+        .filter((toolName) => typeof toolName === "string" && toolName.trim().length > 0)
+        .filter((toolName) => !isPlanToolName(toolName))
+        .filter((toolName) => textExplicitlyNamesConfiguredTool(text, toolName));
+}
+function listMissingDelegatedExecutionToolEvidence(result, requiredToolNames = []) {
+    if (requiredToolNames.length === 0) {
+        return hasDelegatedExecutionToolEvidence(result) ? [] : ["configured non-planning tools"];
+    }
+    const observed = collectSuccessfulDelegatedExecutionToolNames(result);
+    return requiredToolNames.filter((toolName) => !observed.has(normalizeEvidenceToolName(toolName)));
+}
+function hasRequiredDelegatedExecutionToolEvidence(result, requiredToolNames = []) {
+    return hasDelegatedExecutionToolEvidence(result)
+        && listMissingDelegatedExecutionToolEvidence(result, requiredToolNames).length === 0;
+}
+function buildExplicitExecutionToolRetryInstruction(missingToolNames) {
+    const tools = missingToolNames
+        .filter((toolName) => toolName !== "configured non-planning tools")
+        .join(", ");
+    if (!tools) {
+        return "";
+    }
+    return [
+        `The request explicitly named configured evidence tool(s): ${tools}.`,
+        "Before the final answer, call every listed non-planning tool that has not already produced a successful tool result.",
+        "Do not substitute a different evidence tool for an explicitly named configured tool unless that tool invocation itself fails and the blocker is reported.",
+    ].join("\n");
+}
 function buildDelegatedPlanEvidenceBlocker(agentId) {
     return JSON.stringify({
         status: "blocked",
@@ -97,245 +151,6 @@ function readConfiguredToolName(value) {
     const typed = value;
     return typeof typed.name === "string" ? typed.name.trim() : "";
 }
-function readMessageContentText(message) {
-    if (typeof message !== "object" || message === null) {
-        return "";
-    }
-    const content = message.content;
-    if (typeof content === "string") {
-        return content.trim();
-    }
-    if (!Array.isArray(content)) {
-        return "";
-    }
-    return content
-        .map((part) => typeof part === "object" && part !== null && typeof part.text === "string"
-        ? part.text
-        : "")
-        .join("")
-        .trim();
-}
-function hasExternalPlanEvidenceInstruction(messages) {
-    return messages.some((message) => {
-        const text = readMessageContentText(message);
-        return /todo board already exists|required todo board already exists|non[-\s]?planning tool call/iu.test(text);
-    });
-}
-function parseToolCallArgs(value) {
-    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-        return value;
-    }
-    if (typeof value !== "string" || value.trim().length === 0) {
-        return {};
-    }
-    try {
-        const parsed = JSON.parse(value);
-        return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
-            ? parsed
-            : {};
-    }
-    catch {
-        return {};
-    }
-}
-function readMessageToolCalls(message) {
-    if (typeof message !== "object" || message === null) {
-        return [];
-    }
-    const typed = message;
-    const raw = Array.isArray(typed.tool_calls) ? typed.tool_calls
-        : Array.isArray(typed.kwargs?.tool_calls) ? typed.kwargs.tool_calls
-            : Array.isArray(typed.additional_kwargs?.tool_calls) ? typed.additional_kwargs.tool_calls
-                : Array.isArray(typed.kwargs?.additional_kwargs?.tool_calls) ? typed.kwargs.additional_kwargs.tool_calls
-                    : Array.isArray(typed.lc_kwargs?.tool_calls) ? typed.lc_kwargs.tool_calls
-                        : Array.isArray(typed.lc_kwargs?.additional_kwargs?.tool_calls) ? typed.lc_kwargs.additional_kwargs.tool_calls
-                            : [];
-    return raw
-        .map((toolCall) => {
-        if (typeof toolCall !== "object" || toolCall === null) {
-            return null;
-        }
-        const call = toolCall;
-        const name = typeof call.name === "string"
-            ? call.name
-            : typeof call.function?.name === "string"
-                ? call.function.name
-                : undefined;
-        const args = parseToolCallArgs(call.args ?? call.function?.arguments);
-        return {
-            ...(typeof call.id === "string" ? { id: call.id } : {}),
-            ...(name ? { name } : {}),
-            args,
-        };
-    })
-        .filter((toolCall) => toolCall !== null);
-}
-function todoToolCallIsTerminal(toolCall) {
-    const todos = toolCall.args?.todos;
-    if (!Array.isArray(todos) || todos.length === 0) {
-        return false;
-    }
-    return todos.every((todo) => {
-        if (typeof todo !== "object" || todo === null || typeof todo.status !== "string") {
-            return false;
-        }
-        const status = todo.status.trim().toLowerCase();
-        return status !== "pending" && status !== "in_progress";
-    });
-}
-function readToolResultName(message) {
-    if (typeof message !== "object" || message === null) {
-        return "";
-    }
-    const typed = message;
-    const messageType = typeof typed.type === "string"
-        ? typed.type
-        : typeof typed._getType === "function"
-            ? String(typed._getType())
-            : "";
-    if (messageType !== "tool" && typeof typed.tool_call_id !== "string") {
-        return "";
-    }
-    return typeof typed.name === "string" ? typed.name : "";
-}
-function createPlanGuardToolError(toolCallId, content, fallbackPrefix) {
-    return new ToolMessage({
-        content,
-        tool_call_id: typeof toolCallId === "string" ? toolCallId : `${fallbackPrefix}-${Math.random().toString(36).slice(2, 10)}`,
-        status: "error",
-    });
-}
-function isPromiseLike(value) {
-    return typeof value === "object" && value !== null && typeof value.then === "function";
-}
-function renderToolInvocationError(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    const cause = typeof error === "object" && error !== null && "cause" in error
-        ? error.cause
-        : undefined;
-    const causeMessage = cause instanceof Error ? cause.message : "";
-    return [message, causeMessage]
-        .map((value) => value.trim())
-        .filter(Boolean)
-        .join("\n");
-}
-function createToolInvocationErrorMessage(toolCallId, toolName, error) {
-    const rendered = renderToolInvocationError(error);
-    return createPlanGuardToolError(toolCallId, `Error invoking tool '${toolName}' with error: ${rendered || "tool invocation failed"}`, "tool-invocation-error");
-}
-function createTodoPlanGuardMiddleware(options = {}) {
-    let observedPlanToolResult = false;
-    let observedNonPlanToolResult = false;
-    return createMiddleware({
-        name: "harnessTodoPlanGuard",
-        wrapToolCall: ((request, handler) => {
-            const toolName = typeof request.toolCall?.name === "string"
-                ? request.toolCall.name
-                : typeof request.tool?.name === "string"
-                    ? request.tool.name
-                    : "";
-            const messages = Array.isArray(request.state?.messages) ? request.state.messages : [];
-            const toolResultNames = messages.map(readToolResultName).filter((name) => name.length > 0);
-            const hasPlanToolResult = toolResultNames.some(isPlanToolName);
-            const hasNonPlanToolResult = toolResultNames.some((resultToolName) => !isPlanToolName(resultToolName));
-            const hasExternalPlanEvidence = hasExternalPlanEvidenceInstruction(messages);
-            if (options.requiresPlan === true
-                && !(observedPlanToolResult || hasPlanToolResult || hasExternalPlanEvidence)
-                && toolName.length > 0
-                && !isPlanToolName(toolName)) {
-                return createPlanGuardToolError(request.toolCall?.id, "Error: this agent has a required visible planning contract. Your first action must be write_todos with concrete task steps and statuses. Do not call non-planning tools before the initial todo board exists.", "todo-initial-plan-guard");
-            }
-            if (options.requiresPlan === true
-                && (observedPlanToolResult || hasPlanToolResult || hasExternalPlanEvidence)
-                && !(observedNonPlanToolResult || hasNonPlanToolResult)
-                && isPlanToolName(toolName)) {
-                return createPlanGuardToolError(request.toolCall?.id, "Error: the required todo board already exists, but no non-planning evidence tool has returned yet. Do not call write_todos or read_todos again. Your next action must be exactly one non-planning tool call selected from the available tool descriptions and schemas.", "todo-plan-evidence-guard");
-            }
-            if (options.requiresPlan === true
-                && !(observedNonPlanToolResult || hasNonPlanToolResult)
-                && isPlanToolName(toolName)
-                && normalizePlanToolName(toolName).includes("write_todos")
-                && todoToolCallIsTerminal({ args: parseToolCallArgs(request.toolCall?.args) })) {
-                return createPlanGuardToolError(request.toolCall?.id, "Error: write_todos cannot mark every todo as terminal before any non-planning evidence tool returns. Keep one todo in_progress and the remaining todos pending until evidence tools return.", "write-todos-tool-guard");
-            }
-            const markObservedToolResult = () => {
-                if (isPlanToolName(toolName)) {
-                    observedPlanToolResult = true;
-                }
-                else if (toolName.length > 0) {
-                    observedNonPlanToolResult = true;
-                }
-            };
-            const normalizedArgs = normalizeToolArgsForSchema(parseToolCallArgs(request.toolCall?.args), request.tool?.schema, request.toolCall?.args);
-            const normalizedRequest = {
-                ...request,
-                toolCall: request.toolCall
-                    ? {
-                        ...request.toolCall,
-                        args: normalizedArgs,
-                    }
-                    : request.toolCall,
-            };
-            try {
-                const result = handler(normalizedRequest);
-                if (isPromiseLike(result)) {
-                    return result
-                        .then((value) => {
-                        markObservedToolResult();
-                        return value;
-                    })
-                        .catch((error) => createToolInvocationErrorMessage(request.toolCall?.id, toolName || "unknown", error));
-                }
-                markObservedToolResult();
-                return result;
-            }
-            catch (error) {
-                return createToolInvocationErrorMessage(request.toolCall?.id, toolName || "unknown", error);
-            }
-        }),
-        afterModel: (state) => {
-            if (!Array.isArray(state.messages) || state.messages.length === 0) {
-                return;
-            }
-            const hasNonPlanToolResult = state.messages.some((message) => {
-                if (typeof message !== "object" || message === null) {
-                    return false;
-                }
-                const typed = message;
-                const messageType = typeof typed.type === "string"
-                    ? typed.type
-                    : typeof typed._getType === "function"
-                        ? String(typed._getType())
-                        : "";
-                if (messageType !== "tool" && typeof typed.tool_call_id !== "string") {
-                    return false;
-                }
-                const toolName = typeof typed.name === "string" ? typed.name : "";
-                return toolName.length > 0 && !isPlanToolName(toolName);
-            });
-            if (hasNonPlanToolResult) {
-                return;
-            }
-            const lastAiMessage = [...state.messages].reverse().find((message) => readMessageToolCalls(message).length > 0);
-            const lastToolCalls = readMessageToolCalls(lastAiMessage);
-            if (!lastAiMessage) {
-                return;
-            }
-            const writeTodosCalls = lastToolCalls.filter((toolCall) => isPlanToolName(toolCall.name));
-            const prematureCompletedCalls = writeTodosCalls.filter(todoToolCallIsTerminal);
-            if (prematureCompletedCalls.length === 0) {
-                return;
-            }
-            return {
-                messages: prematureCompletedCalls.map((toolCall, index) => new ToolMessage({
-                    content: "Error: write_todos cannot mark every todo as terminal before any non-planning evidence tool returns. Keep one todo in_progress and the remaining todos pending until evidence tools return.",
-                    tool_call_id: toolCall.id ?? `write-todos-plan-guard-${index}`,
-                    status: "error",
-                })),
-            };
-        },
-    });
-}
 function shouldUseConfigurableDeepAgentAssembly(binding) {
     return getBindingExecutionKind(binding) === "deepagent";
 }
@@ -933,9 +748,15 @@ export class AgentRuntimeAdapter {
                             const runDelegatedRequest = (text, requestSuffix = "") => this.invoke(targetBinding, text, childSessionId, `${childRequestId}${requestSuffix}`, undefined, [], invokeOptions);
                             let result = await runDelegatedRequest(requestText);
                             const targetRequiresExecutionToolEvidence = getBindingPrimaryTools(targetBinding).length > 0;
-                            if (targetRequiresExecutionToolEvidence && !hasDelegatedExecutionToolEvidence(result)) {
-                                result = await runDelegatedRequest([requestText, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":tool-evidence-retry");
-                                if (!hasDelegatedExecutionToolEvidence(result)) {
+                            const requiredExecutionToolNames = resolveExplicitRequestedExecutionToolNames(targetBinding, requestText);
+                            if (targetRequiresExecutionToolEvidence && !hasRequiredDelegatedExecutionToolEvidence(result, requiredExecutionToolNames)) {
+                                const missingToolNames = listMissingDelegatedExecutionToolEvidence(result, requiredExecutionToolNames);
+                                result = await runDelegatedRequest([
+                                    requestText,
+                                    EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION,
+                                    buildExplicitExecutionToolRetryInstruction(missingToolNames),
+                                ].filter(Boolean).join("\n\n"), ":tool-evidence-retry");
+                                if (!hasRequiredDelegatedExecutionToolEvidence(result, requiredExecutionToolNames)) {
                                     throw new DelegatedExecutionNoToolEvidenceError(targetBinding.agent.id);
                                 }
                             }
@@ -1446,6 +1267,7 @@ export class AgentRuntimeAdapter {
             }
         }
         const targetRequiresExecutionToolEvidence = getBindingPrimaryTools(selectedBinding).length > 0;
+        const requiredExecutionToolNames = resolveExplicitRequestedExecutionToolNames(selectedBinding, requestText);
         if (selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
             && !hasDelegatedPlanEvidence(delegatedResult)) {
             try {
@@ -1465,9 +1287,14 @@ export class AgentRuntimeAdapter {
                 };
             }
         }
-        if (targetRequiresExecutionToolEvidence && !hasDelegatedExecutionToolEvidence(delegatedResult)) {
+        if (targetRequiresExecutionToolEvidence && !hasRequiredDelegatedExecutionToolEvidence(delegatedResult, requiredExecutionToolNames)) {
+            const missingToolNames = listMissingDelegatedExecutionToolEvidence(delegatedResult, requiredExecutionToolNames);
             try {
-                delegatedResult = await runDelegatedRequest([requestText, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":tool-evidence-retry", selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
+                delegatedResult = await runDelegatedRequest([
+                    requestText,
+                    EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION,
+                    buildExplicitExecutionToolRetryInstruction(missingToolNames),
+                ].filter(Boolean).join("\n\n"), ":tool-evidence-retry", selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
                     ? {
                         suppressInitialRequiredPlanInstruction: true,
                         externalPlanEvidence: hasDelegatedPlanEvidence(delegatedResult),
@@ -1502,8 +1329,10 @@ export class AgentRuntimeAdapter {
                 },
             };
         }
-        if (targetRequiresExecutionToolEvidence && !hasDelegatedExecutionToolEvidence(delegatedResult)) {
-            const output = buildDelegatedExecutionEvidenceBlocker(selectedBinding.agent.id, getBindingPrimaryTools(selectedBinding).map((tool) => tool.name));
+        if (targetRequiresExecutionToolEvidence && !hasRequiredDelegatedExecutionToolEvidence(delegatedResult, requiredExecutionToolNames)) {
+            const output = buildDelegatedExecutionEvidenceBlocker(selectedBinding.agent.id, requiredExecutionToolNames.length > 0
+                ? requiredExecutionToolNames
+                : getBindingPrimaryTools(selectedBinding).map((tool) => tool.name));
             return {
                 toolOutput: output,
                 delegatedSubagentType: subagentType,
@@ -1898,9 +1727,17 @@ export class AgentRuntimeAdapter {
                     delegatedResult = mergeDelegatedResultToolEvidence(yield* runPlannedDelegation(planned.subagentType, [delegatedText, DELEGATED_PLAN_EVIDENCE_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":plan-evidence-retry"), previousDelegatedResult);
                 }
                 const targetRequiresExecutionToolEvidence = selectedBinding ? getBindingPrimaryTools(selectedBinding).length > 0 : false;
-                if (targetRequiresExecutionToolEvidence && !hasDelegatedExecutionToolEvidence(delegatedResult)) {
+                const requiredExecutionToolNames = selectedBinding
+                    ? resolveExplicitRequestedExecutionToolNames(selectedBinding, planned.description)
+                    : [];
+                if (targetRequiresExecutionToolEvidence && !hasRequiredDelegatedExecutionToolEvidence(delegatedResult, requiredExecutionToolNames)) {
+                    const missingToolNames = listMissingDelegatedExecutionToolEvidence(delegatedResult, requiredExecutionToolNames);
                     const previousDelegatedResult = delegatedResult;
-                    delegatedResult = mergeDelegatedResultToolEvidence(yield* runPlannedDelegation(planned.subagentType, [delegatedText, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":tool-evidence-retry"), previousDelegatedResult);
+                    delegatedResult = mergeDelegatedResultToolEvidence(yield* runPlannedDelegation(planned.subagentType, [
+                        delegatedText,
+                        EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION,
+                        buildExplicitExecutionToolRetryInstruction(missingToolNames),
+                    ].filter(Boolean).join("\n\n"), ":tool-evidence-retry"), previousDelegatedResult);
                 }
                 if (selectedBinding?.harnessRuntime.executionContract?.requiresPlan === true && !hasDelegatedPlanEvidence(delegatedResult)) {
                     const output = buildDelegatedPlanEvidenceBlocker(selectedBinding.agent.id);
@@ -1911,8 +1748,10 @@ export class AgentRuntimeAdapter {
                         finalMessageText: output,
                     };
                 }
-                if (targetRequiresExecutionToolEvidence && !hasDelegatedExecutionToolEvidence(delegatedResult)) {
-                    const output = buildDelegatedExecutionEvidenceBlocker(selectedBinding.agent.id, getBindingPrimaryTools(selectedBinding).map((tool) => tool.name));
+                if (targetRequiresExecutionToolEvidence && !hasRequiredDelegatedExecutionToolEvidence(delegatedResult, requiredExecutionToolNames)) {
+                    const output = buildDelegatedExecutionEvidenceBlocker(selectedBinding.agent.id, requiredExecutionToolNames.length > 0
+                        ? requiredExecutionToolNames
+                        : getBindingPrimaryTools(selectedBinding).map((tool) => tool.name));
                     delegatedResult = {
                         ...delegatedResult,
                         state: "failed",
@@ -2105,14 +1944,20 @@ export class AgentRuntimeAdapter {
         });
         let delegatedResult = yield* runDelegatedStreamAttempt(delegatedText);
         const targetRequiresExecutionToolEvidence = getBindingPrimaryTools(selectedBinding).length > 0;
+        const requiredExecutionToolNames = resolveExplicitRequestedExecutionToolNames(selectedBinding, requestText);
         if (selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
             && !hasDelegatedPlanEvidence(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 && !hasDelegatedExecutionToolEvidence(delegatedResult)) {
+        if (targetRequiresExecutionToolEvidence && !hasRequiredDelegatedExecutionToolEvidence(delegatedResult, requiredExecutionToolNames)) {
+            const missingToolNames = listMissingDelegatedExecutionToolEvidence(delegatedResult, requiredExecutionToolNames);
             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,
+                EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION,
+                buildExplicitExecutionToolRetryInstruction(missingToolNames),
+            ].filter(Boolean).join("\n\n"), ":tool-evidence-retry"), previousDelegatedResult);
         }
         if (selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
             && !hasDelegatedPlanEvidence(delegatedResult)) {
@@ -2124,8 +1969,10 @@ export class AgentRuntimeAdapter {
                 finalMessageText: output,
             };
         }
-        if (targetRequiresExecutionToolEvidence && !hasDelegatedExecutionToolEvidence(delegatedResult)) {
-            const output = buildDelegatedExecutionEvidenceBlocker(selectedBinding.agent.id, getBindingPrimaryTools(selectedBinding).map((tool) => tool.name));
+        if (targetRequiresExecutionToolEvidence && !hasRequiredDelegatedExecutionToolEvidence(delegatedResult, requiredExecutionToolNames)) {
+            const output = buildDelegatedExecutionEvidenceBlocker(selectedBinding.agent.id, requiredExecutionToolNames.length > 0
+                ? requiredExecutionToolNames
+                : getBindingPrimaryTools(selectedBinding).map((tool) => tool.name));
             delegatedResult = {
                 ...delegatedResult,
                 state: "failed",

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

@@ -1,4 +1,4 @@
-import { AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, INTERNAL_RUNTIME_SPILL_PATH_INSTRUCTION, STRICT_TOOL_JSON_INSTRUCTION, WORKSPACE_RELATIVE_PATH_INSTRUCTION, WRITE_TODOS_DESCRIPTIVE_CONTENT_INSTRUCTION, WRITE_TODOS_FULL_ENTRY_INSTRUCTION, WRITE_TODOS_NON_EMPTY_INITIAL_LIST_INSTRUCTION, WRITE_TODOS_REQUIRED_PLAN_INSTRUCTION, } from "../prompts/runtime-prompts.js";
+import { EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, INTERNAL_RUNTIME_SPILL_PATH_INSTRUCTION, REQUIRED_EXECUTION_CONTINUATION_INSTRUCTION, STRICT_TOOL_JSON_INSTRUCTION, WORKSPACE_RELATIVE_PATH_INSTRUCTION, WRITE_TODOS_DESCRIPTIVE_CONTENT_INSTRUCTION, WRITE_TODOS_FULL_ENTRY_INSTRUCTION, WRITE_TODOS_NON_EMPTY_INITIAL_LIST_INSTRUCTION, WRITE_TODOS_REQUIRED_PLAN_INSTRUCTION, } from "../prompts/runtime-prompts.js";
 import { wrapNormalizedMessage, readTextContent } from "./output-content.js";
 import { salvageJsonToolCalls } from "./output-tool-args.js";
 function collectRequestMessages(request) {
@@ -153,7 +153,7 @@ export function resolveExecutionWithoutToolEvidenceTextInstruction(request, assi
         return null;
     }
     return hasExecutionEvidence
-        ? AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION
+        ? REQUIRED_EXECUTION_CONTINUATION_INSTRUCTION
         : EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION;
 }
 export function resolveToolCallRecoveryInstruction(error) {

package/dist/runtime/prompts/runtime-prompts.d.ts

@@ -10,7 +10,7 @@ export declare const WRITE_TODOS_DESCRIPTIVE_CONTENT_INSTRUCTION: string;
 export declare const WRITE_TODOS_REQUIRED_PLAN_INSTRUCTION: string;
 export declare const EXECUTION_WITH_TOOL_EVIDENCE_INSTRUCTION: string;
 export declare const EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION: string;
-export declare const AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION: string;
+export declare const REQUIRED_EXECUTION_CONTINUATION_INSTRUCTION: string;
 export declare const DELEGATED_TASK_FAILURE_RECOVERY_INSTRUCTION: string;
 export declare const DELEGATION_ONLY_RECOVERY_INSTRUCTION: string;
 export declare const INTERNAL_RUNTIME_SPILL_PATH_INSTRUCTION: string;

package/dist/runtime/prompts/runtime-prompts.js

@@ -13,7 +13,7 @@ export const WRITE_TODOS_DESCRIPTIVE_CONTENT_INSTRUCTION = readRuntimePrompt("wr
 export const WRITE_TODOS_REQUIRED_PLAN_INSTRUCTION = readRuntimePrompt("write-todos-required-plan");
 export const EXECUTION_WITH_TOOL_EVIDENCE_INSTRUCTION = readRuntimePrompt("execution-with-tool-evidence");
 export const EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION = readRuntimePrompt("execution-with-tool-evidence-retry");
-export const AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION = readRuntimePrompt("autonomous-investigation-recovery");
+export const REQUIRED_EXECUTION_CONTINUATION_INSTRUCTION = readRuntimePrompt("required-execution-continuation");
 export const DELEGATED_TASK_FAILURE_RECOVERY_INSTRUCTION = readRuntimePrompt("delegated-task-failure-recovery");
 export const DELEGATION_ONLY_RECOVERY_INSTRUCTION = readRuntimePrompt("delegation-only-recovery");
 export const INTERNAL_RUNTIME_SPILL_PATH_INSTRUCTION = readRuntimePrompt("internal-runtime-spill-path");

package/package.json

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

package/dist/resources/prompts/runtime/autonomous-investigation-recovery.md

@@ -1,10 +0,0 @@
-Do not stop at a plan or ask the user to choose the next obvious diagnostic step when the request is for deep investigation, root-cause analysis, or step-by-step execution. Do not ask for more background, scope, logs, or environment details until you have first exhausted the context and tools already available in this runtime.
-
-If no concrete execution has happened yet, start from the current workspace, shell, and attached runtime/tool context by default, then continue the investigation yourself with the next concrete tool call. If the user explicitly asked for a plan, or if the task is clearly non-trivial and multi-step, call write_todos first with concrete investigation/execution steps before any other tool call or final answer.
-
-If a todo board already exists, do not restart planning and do not repeat the same clarification request. Use the current todo board and prior tool results to choose one of these terminally useful actions:
-- If more evidence is genuinely needed and an available tool can get it, make the next concrete tool call.
-- If the existing evidence is enough to answer, update the todo board to completed or blocked as appropriate, then provide the final answer grounded in the tool results.
-- If the available tools cannot resolve the remaining work, update the todo board to blocked or failed and provide a blocker report with the evidence.
-
-Never print a tool-call JSON object, function call, or tool name as prose when you intend to use a tool. Actually call the tool. Ask a blocking clarification question only after the available evidence is genuinely insufficient to continue.