@botbotgo/agent-harness 0.0.454 → 0.0.456

package/dist/package-version.d.ts

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

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

@@ -43,6 +43,12 @@ function buildRunEvidenceAfterPlanInstruction(primaryTools) {
         `Available non-planning tool names: ${toolNames.join(", ")}.`,
     ].join("\n");
 }
+function resolveConfiguredPlanEvidenceTool(primaryTools) {
+    const toolName = primaryTools
+        .map(readPrimaryToolName)
+        .find((name) => name.length > 0 && !isPlanToolName(name));
+    return toolName ? [{ name: toolName, args: {}, id: "stream-configured-plan-evidence-tool-1" }] : [];
+}
 const INITIAL_REQUIRED_PLAN_INSTRUCTION = [
     "This agent has a required visible planning contract.",
     "Your first action for this request must be write_todos with concrete task steps and statuses.",
@@ -129,135 +135,6 @@ function hasIncompletePlanOutput(value) {
     }
     return null;
 }
-function extractInProgressTodoContents(value) {
-    if (typeof value !== "object" || value === null) {
-        return [];
-    }
-    const typed = value;
-    const arrays = [typed.todos, typed.items];
-    const contents = [];
-    for (const candidate of arrays) {
-        if (!Array.isArray(candidate)) {
-            continue;
-        }
-        for (const todo of candidate) {
-            if (typeof todo !== "object" || todo === null) {
-                continue;
-            }
-            const item = todo;
-            if (item.status !== "in_progress") {
-                continue;
-            }
-            const content = [item.content, item.description, item.title, item.name, item.text]
-                .find((value) => typeof value === "string" && value.trim().length > 0);
-            if (content) {
-                contents.push(content.trim());
-            }
-        }
-    }
-    for (const nested of [typed.summary, typed.update, typed.data, typed.output]) {
-        contents.push(...extractInProgressTodoContents(nested));
-    }
-    return [...new Set(contents)];
-}
-function extractTodoContentsForEvidenceResolution(value) {
-    const inProgress = extractTodoContentsByStatus(value, "in_progress");
-    if (inProgress.length > 0) {
-        return inProgress;
-    }
-    return extractTodoContentsByStatus(value, "pending");
-}
-function extractTodoContentsByStatus(value, status) {
-    if (Array.isArray(value)) {
-        return value.flatMap((item) => extractTodoContentsByStatus(item, status));
-    }
-    if (typeof value !== "object" || value === null) {
-        return [];
-    }
-    const typed = value;
-    const arrays = [typed.todos, typed.items];
-    const contents = [];
-    for (const array of arrays) {
-        if (!Array.isArray(array)) {
-            continue;
-        }
-        for (const item of array) {
-            if (typeof item !== "object" || item === null) {
-                continue;
-            }
-            const typedItem = item;
-            if (typedItem.status !== status) {
-                continue;
-            }
-            const content = [
-                typedItem.content,
-                typedItem.description,
-                typedItem.title,
-                typedItem.name,
-                typedItem.text,
-            ].find((value) => typeof value === "string" && value.trim().length > 0);
-            if (content) {
-                contents.push(content.trim());
-            }
-        }
-    }
-    for (const nested of [typed.summary, typed.update, typed.data, typed.output]) {
-        contents.push(...extractTodoContentsByStatus(nested, status));
-    }
-    return [...new Set(contents)];
-}
-function buildRunCommittedTodoEvidenceInstruction(primaryTools, planToolOutput) {
-    const todoContents = extractInProgressTodoContents(planToolOutput);
-    const todoText = todoContents.length > 0
-        ? todoContents.map((content, index) => `${index + 1}. ${content}`).join("\n")
-        : "(no in-progress todo content was readable)";
-    return [
-        buildRunEvidenceAfterPlanInstruction(primaryTools),
-        "",
-        "The completed write_todos result contains these in-progress evidence commitments:",
-        todoText,
-        "",
-        "Your next action must execute the non-planning tool named by the in-progress TODO. If every TODO is pending, execute the non-planning tool named by the first pending TODO. Do not call write_todos or read_todos again before that evidence tool returns.",
-    ].join("\n");
-}
-function resolveCommittedPlanEvidenceTool(primaryTools, planToolOutput) {
-    return resolveCommittedPlanEvidenceTools(primaryTools, planToolOutput)[0];
-}
-function resolveCommittedPlanEvidenceTools(primaryTools, planToolOutput) {
-    const availableToolNames = primaryTools
-        .map(readPrimaryToolName)
-        .filter((name) => name.length > 0 && !isPlanToolName(name));
-    const todoContents = extractTodoContentsForEvidenceResolution(planToolOutput);
-    if (todoContents.length === 0) {
-        return [];
-    }
-    const resolved = [];
-    const seen = new Set();
-    for (const content of todoContents) {
-        const todoText = content.toLowerCase();
-        const selectedNames = availableToolNames.filter((name) => hasExplicitToolNameReference(todoText, name));
-        for (const selectedName of selectedNames) {
-            if (seen.has(selectedName)) {
-                continue;
-            }
-            seen.add(selectedName);
-            resolved.push({
-                name: selectedName,
-                args: {},
-                id: `stream-committed-plan-evidence-tool-${resolved.length + 1}`,
-            });
-        }
-    }
-    return resolved;
-}
-function hasExplicitToolNameReference(todoText, toolName) {
-    const normalizedToolName = toolName.trim().toLowerCase();
-    if (!normalizedToolName) {
-        return false;
-    }
-    const escapedName = normalizedToolName.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-    return new RegExp(`(?:^|[^\\p{L}\\p{N}_-])${escapedName}(?:$|[^\\p{L}\\p{N}_-])`, "iu").test(todoText);
-}
 function normalizePlanToolName(toolName) {
     return typeof toolName === "string" ? toolName.trim().toLowerCase().replace(/[\s-]+/gu, "_") : "";
 }
@@ -827,9 +704,8 @@ export async function* streamRuntimeExecution(options) {
                             && hadPriorPlanToolResult
                             && projectedChunks.some((chunk) => chunk.kind === "tool-result" && isPlanToolName(chunk.toolName));
                         if (repeatedPlanToolResultBeforeEvidence) {
-                            const planToolResult = projectedChunks.find((chunk) => chunk.kind === "tool-result" && isPlanToolName(chunk.toolName) && chunk.isError !== true);
-                            earlyStreamExternalPlanEvidenceTools = resolveCommittedPlanEvidenceTools(options.primaryTools, planToolResult?.kind === "tool-result" ? planToolResult.output : undefined);
-                            earlyStreamRecoveryInstruction = buildRunCommittedTodoEvidenceInstruction(options.primaryTools, planToolResult?.kind === "tool-result" ? planToolResult.output : undefined);
+                            earlyStreamExternalPlanEvidenceTools = resolveConfiguredPlanEvidenceTool(options.primaryTools);
+                            earlyStreamRecoveryInstruction = buildRunEvidenceAfterPlanInstruction(options.primaryTools);
                             earlyStreamRecoverySuppressInitialPlan = true;
                             break;
                         }
@@ -874,9 +750,8 @@ export async function* streamRuntimeExecution(options) {
                             && (hadPriorPlanToolResult
                                 || projectedChunks.some((chunk) => isCompletedPlanToolResultChunk(chunk)))
                             && !sawSuccessfulNonTodoToolResult) {
-                            const planToolResult = projectedChunks.find((chunk) => chunk.kind === "tool-result" && isPlanToolName(chunk.toolName) && chunk.isError !== true);
-                            earlyStreamExternalPlanEvidenceTools = resolveCommittedPlanEvidenceTools(options.primaryTools, planToolResult?.kind === "tool-result" ? planToolResult.output : undefined);
-                            earlyStreamRecoveryInstruction = buildRunCommittedTodoEvidenceInstruction(options.primaryTools, planToolResult?.kind === "tool-result" ? planToolResult.output : undefined);
+                            earlyStreamExternalPlanEvidenceTools = resolveConfiguredPlanEvidenceTool(options.primaryTools);
+                            earlyStreamRecoveryInstruction = buildRunEvidenceAfterPlanInstruction(options.primaryTools);
                             earlyStreamRecoverySuppressInitialPlan = true;
                             break;
                         }

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

@@ -196,58 +196,6 @@ function terminalToolErrorRecoveryInstruction(terminalText) {
 function requiresPlanEvidence(binding) {
     return binding.harnessRuntime.executionContract?.requiresPlan === true;
 }
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function textExplicitlyNamesTool(text, toolName) {
-    const trimmedToolName = toolName.trim();
-    if (trimmedToolName.length === 0) {
-        return false;
-    }
-    return new RegExp(`(?:^|[^\\p{L}\\p{N}_-])${escapeRegExp(trimmedToolName)}(?:$|[^\\p{L}\\p{N}_-])`, "iu").test(text);
-}
-function resolveCommittedTodoEvidenceTool(executedToolResults, primaryTools) {
-    const availableTools = primaryTools
-        .filter((tool) => typeof tool.name === "string" && tool.name.length > 0 && !isPlanToolName(tool.name));
-    if (availableTools.length === 0) {
-        return null;
-    }
-    for (let index = executedToolResults.length - 1; index >= 0; index -= 1) {
-        const result = executedToolResults[index];
-        if (!result || result.isError === true || !isPlanToolName(result.toolName)) {
-            continue;
-        }
-        const output = result.output;
-        const summary = typeof output === "object" && output !== null
-            ? output.summary
-            : undefined;
-        const items = typeof summary === "object" && summary !== null && Array.isArray(summary.items)
-            ? summary.items
-            : [];
-        const activeItems = items.filter((item) => item.status === "in_progress");
-        const candidateItems = activeItems.length > 0
-            ? activeItems
-            : items.filter((item) => item.status === "pending").slice(0, 1);
-        for (const item of candidateItems) {
-            const content = [
-                item.content,
-                item.description,
-                item.title,
-                item.name,
-                item.text,
-            ].filter((value) => typeof value === "string").join(" ");
-            const matched = availableTools.map((tool) => tool.name).filter((toolName) => textExplicitlyNamesTool(content, toolName));
-            if (matched.length === 1) {
-                return {
-                    name: matched[0],
-                    args: {},
-                    id: `todo-committed-evidence-${index}`,
-                };
-            }
-        }
-    }
-    return null;
-}
 function extractLatestUserInput(request) {
     const typedRequest = request;
     const messages = Array.isArray(typedRequest.messages) ? typedRequest.messages : [];
@@ -344,7 +292,7 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
                 : await callRuntimeWithToolParseRecovery(activeRequest));
         pendingResult = undefined;
         let toolCalls = extractToolCallsFromResult(result);
-        const committedTodoEvidenceTool = requiresPlanEvidence(binding)
+        const structuredExternalPlanEvidenceTool = requiresPlanEvidence(binding)
             && hasPlanStateEvidence(executedToolResults, externalPlanEvidence)
             && !hasNonTodoToolEvidence(executedToolResults)
             && (externalPlanEvidenceTool !== undefined || !hasIncompleteExecutedPlan(executedToolResults, externalPlanEvidence))
@@ -355,10 +303,10 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
                     args: externalPlanEvidenceTool.args ?? {},
                     id: externalPlanEvidenceTool.id ?? "external-plan-evidence-tool",
                 }
-                : resolveCommittedTodoEvidenceTool(executedToolResults, primaryTools)
+                : null
             : null;
-        if (committedTodoEvidenceTool) {
-            toolCalls = [committedTodoEvidenceTool];
+        if (structuredExternalPlanEvidenceTool) {
+            toolCalls = [structuredExternalPlanEvidenceTool];
         }
         if (toolCalls.length === 0) {
             const terminalText = sanitizeVisibleText(extractVisibleOutput(result) || "");
@@ -514,7 +462,6 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
             role: "system",
             content: TOOL_FOLLOW_UP_INSTRUCTION,
         });
-        const hadNonTodoEvidenceBeforeToolReplay = hasNonTodoToolEvidence(executedToolResults);
         for (let toolIndex = 0; toolIndex < toolCalls.length; toolIndex += 1) {
             const toolCall = toolCalls[toolIndex];
             const resolvedToolName = resolveModelFacingToolName(toolCall.name, toolNameMapping, primaryTools);
@@ -571,61 +518,6 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
                 content: stringifyToolOutput(safeToolResult),
             }));
         }
-        const committedEvidenceTool = requiresPlanEvidence(binding)
-            && !hadNonTodoEvidenceBeforeToolReplay
-            && !hasNonTodoToolEvidence(executedToolResults)
-            && !hasIncompleteExecutedPlan(executedToolResults, externalPlanEvidence)
-            ? resolveCommittedTodoEvidenceTool(executedToolResults, primaryTools)
-            : null;
-        if (committedEvidenceTool) {
-            const resolvedToolName = resolveModelFacingToolName(committedEvidenceTool.name, toolNameMapping, primaryTools);
-            const executable = executableTools.get(committedEvidenceTool.name) ?? executableTools.get(resolvedToolName);
-            if (executable) {
-                const compiledTool = toolCatalog.get(committedEvidenceTool.name) ?? toolCatalog.get(resolvedToolName);
-                const normalizedArgs = normalizeToolArgsForSchema(committedEvidenceTool.args, executable.schema, undefined, {
-                    latestUserInput,
-                });
-                const gateway = validateToolGatewayInput({
-                    toolName: executable.name,
-                    schema: executable.schema,
-                    args: normalizedArgs,
-                    requiresApproval: compiledTool ? toolRequiresRuntimeApproval(compiledTool) : false,
-                });
-                if (gateway.ok) {
-                    const toolResult = toolRuntimeContext
-                        ? await executable.invoke(gateway.input, { toolRuntimeContext })
-                        : await executable.invoke(gateway.input);
-                    const memoryCandidates = compiledTool ? extractMemoryCandidatesFromToolOutput(compiledTool, toolResult) : [];
-                    const safeToolResult = await maybePersistLargeToolOutput({
-                        toolName: executable.name,
-                        output: toolResult,
-                        toolRuntimeContext,
-                    });
-                    executedToolResults.push({
-                        toolName: executable.name,
-                        output: safeToolResult,
-                        ...(memoryCandidates.length > 0 ? { memoryCandidates } : {}),
-                    });
-                    nextMessages.push(new ToolMessage({
-                        name: executable.name,
-                        tool_call_id: committedEvidenceTool.id,
-                        content: stringifyToolOutput(safeToolResult),
-                    }));
-                }
-                else {
-                    executedToolResults.push({
-                        toolName: executable.name,
-                        output: gateway.error,
-                        isError: true,
-                    });
-                    nextMessages.push(new ToolMessage({
-                        name: executable.name,
-                        tool_call_id: committedEvidenceTool.id,
-                        content: stringifyToolOutput(gateway.error),
-                    }));
-                }
-            }
-        }
         if (usedExternalPlanEvidenceToolThisIteration && hasNonTodoToolEvidence(executedToolResults)) {
             return {
                 result: buildDeterministicFinalFromToolEvidence(executedToolResults),

package/dist/runtime/adapter/middleware-assembly.js

@@ -1,4 +1,4 @@
-import { AIMessage, HumanMessage, ToolMessage } from "@langchain/core/messages";
+import { AIMessage, HumanMessage } from "@langchain/core/messages";
 import { createMemoryMiddleware, createFilesystemMiddleware, createPatchToolCallsMiddleware, createSkillsMiddleware, createSubAgentMiddleware, createSummarizationMiddleware, StateBackend, } from "deepagents";
 import { createAgent, humanInTheLoopMiddleware, todoListMiddleware } from "langchain";
 import { createBuiltinMiddlewareTools } from "./tool/builtin-middleware-tools.js";
@@ -9,7 +9,7 @@ import { resolveDeclaredMiddleware } from "./tool/declared-middleware.js";
 import { UPSTREAM_SESSION_CONFIG_KEY } from "./upstream-configurable-keys.js";
 import { bindingHasLangChainSubagentSupport, bindingHasMiddlewareKind, getBindingBuiltinToolsConfig, getBindingExecutionKind, getBindingGeneralPurposeAgent, getBindingDeepAgentSubagents, getBindingInterruptCompatibilityRules, getBindingMiddlewareConfigs, getBindingMemorySources, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSkills, getBindingSubagents, getBindingTaskDescription, isDeepAgentBinding, isLangChainBinding, } from "../support/compiled-binding.js";
 import { materializeDeepAgentSkillSourcePaths } from "./compat/deepagent-compat.js";
-import { DEFAULT_SUBAGENT_PROMPT, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, } from "../prompts/runtime-prompts.js";
+import { DEFAULT_SUBAGENT_PROMPT } from "../prompts/runtime-prompts.js";
 import { createContextHygieneMiddleware } from "./middleware/context-hygiene.js";
 const INVALID_TOOL_MESSAGE_BLOCK_TYPES = new Set(["tool_use", "thinking", "redacted_thinking"]);
 const DEFAULT_BUILTIN_TASK_TIMEOUT_MS = 180_000;
@@ -58,364 +58,6 @@ function extractDeepAgentTaskContent(result) {
     }
     return undefined;
 }
-function readMessageType(message) {
-    if (typeof message !== "object" || message === null) {
-        return "";
-    }
-    if (typeof message._getType === "function") {
-        const typeName = message._getType();
-        return typeof typeName === "string" ? typeName : "";
-    }
-    const typed = message;
-    if (typeof typed.type === "string") {
-        return typed.type;
-    }
-    const kwargs = typeof typed.kwargs === "object" && typed.kwargs !== null
-        ? typed.kwargs
-        : undefined;
-    if (typeof kwargs?.type === "string") {
-        return kwargs.type;
-    }
-    const lcKwargs = typeof typed.lc_kwargs === "object" && typed.lc_kwargs !== null
-        ? typed.lc_kwargs
-        : undefined;
-    return typeof lcKwargs?.type === "string" ? lcKwargs.type : "";
-}
-function readMessageName(message) {
-    if (typeof message !== "object" || message === null) {
-        return "";
-    }
-    const typed = message;
-    if (typeof typed.name === "string") {
-        return typed.name;
-    }
-    const kwargs = typeof typed.kwargs === "object" && typed.kwargs !== null
-        ? typed.kwargs
-        : undefined;
-    if (typeof kwargs?.name === "string") {
-        return kwargs.name;
-    }
-    const lcKwargs = typeof typed.lc_kwargs === "object" && typed.lc_kwargs !== null
-        ? typed.lc_kwargs
-        : undefined;
-    return typeof lcKwargs?.name === "string" ? lcKwargs.name : "";
-}
-function readMessages(result) {
-    if (typeof result !== "object" || result === null) {
-        return [];
-    }
-    const messages = result.messages;
-    return Array.isArray(messages) ? messages : [];
-}
-function readToolNames(tools) {
-    if (!Array.isArray(tools)) {
-        return new Set();
-    }
-    return new Set(tools
-        .map((tool) => {
-        if (typeof tool !== "object" || tool === null) {
-            return "";
-        }
-        const name = tool.name;
-        return typeof name === "string" ? name : "";
-    })
-        .filter((name) => name.length > 0));
-}
-function readResolvedEvidenceTools(tools) {
-    if (!Array.isArray(tools)) {
-        return [];
-    }
-    return tools
-        .map((tool) => {
-        if (typeof tool !== "object" || tool === null) {
-            return undefined;
-        }
-        const typed = tool;
-        if (typeof typed.name !== "string" || typed.name.trim().length === 0) {
-            return undefined;
-        }
-        const handler = [typed.invoke, typed.call, typed.func]
-            .find((candidate) => typeof candidate === "function");
-        return {
-            name: typed.name,
-            ...(typeof typed.description === "string" ? { description: typed.description } : {}),
-            schema: typed.schema,
-            ...(handler ? { invoke: (input, config) => handler.call(tool, input, config) } : {}),
-        };
-    })
-        .filter((tool) => tool !== undefined);
-}
-function hasSubagentExecutionToolEvidence(result, resolvedTools, configuredTools) {
-    const requiredToolNames = new Set([
-        ...readToolNames(configuredTools),
-        ...readToolNames(resolvedTools),
-    ]);
-    if (requiredToolNames.size === 0) {
-        return true;
-    }
-    for (const message of readMessages(result)) {
-        const typeName = readMessageType(message);
-        if (typeName !== "tool" && typeName !== "ToolMessage") {
-            continue;
-        }
-        const name = readMessageName(message);
-        if (name === "write_todos" || name === "read_todos") {
-            continue;
-        }
-        if (requiredToolNames.has(name)) {
-            return true;
-        }
-    }
-    return false;
-}
-function stringifyTaskState(value) {
-    try {
-        return JSON.stringify(value);
-    }
-    catch {
-        return String(value ?? "");
-    }
-}
-function extractUrls(value) {
-    return [...new Set((value.match(/https?:\/\/[^\s<>"')\]}]+/giu) ?? [])
-            .map((url) => url.replace(/[.,;:!?]+$/u, "")))];
-}
-function readSchemaObjectShape(schema) {
-    if (!isRecord(schema)) {
-        return undefined;
-    }
-    if (isRecord(schema.properties)) {
-        return schema.properties;
-    }
-    const candidates = [
-        schema._def?.shape,
-        schema._zod?.def?.shape,
-        schema.def?.shape,
-    ];
-    for (const candidate of candidates) {
-        const shape = typeof candidate === "function" ? candidate() : candidate;
-        if (isRecord(shape)) {
-            return shape;
-        }
-    }
-    return undefined;
-}
-function buildUrlSourceArgs(urls) {
-    return urls.map((url) => ({ type: "url", url, timeoutMs: 30000 }));
-}
-function buildEvidenceToolArgs(tool, taskText, evidenceText = taskText) {
-    const urls = extractUrls(evidenceText);
-    if (urls.length === 0) {
-        return {};
-    }
-    const shape = readSchemaObjectShape(tool.schema);
-    if (!shape) {
-        return {};
-    }
-    const args = {};
-    if ("sources" in shape) {
-        args.sources = buildUrlSourceArgs(urls);
-    }
-    if ("url" in shape) {
-        args.url = urls[0];
-    }
-    if ("urls" in shape) {
-        args.urls = urls;
-    }
-    if ("question" in shape) {
-        args.question = taskText.trim() || evidenceText.trim();
-    }
-    return args;
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function textExplicitlyNamesTool(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 resolveCommittedEvidenceTools(input) {
-    const availableTools = readResolvedEvidenceTools(input.resolvedTools)
-        .filter((tool) => tool.name !== "write_todos" && tool.name !== "read_todos" && typeof tool.invoke === "function");
-    if (availableTools.length === 0) {
-        return [];
-    }
-    const stateText = `${input.taskText}\n${stringifyTaskState(readMessages(input.result))}`;
-    const selected = [];
-    for (const tool of availableTools) {
-        if (!textExplicitlyNamesTool(stateText, tool.name)) {
-            continue;
-        }
-        selected.push({
-            tool,
-            args: buildEvidenceToolArgs(tool, input.taskText, stateText),
-        });
-    }
-    if (selected.length > 0) {
-        return selected.slice(0, 3);
-    }
-    return [];
-}
-async function appendCommittedEvidenceToolResults(input) {
-    const toolCalls = resolveCommittedEvidenceTools({
-        result: input.result,
-        taskText: input.taskText,
-        resolvedTools: input.resolvedTools,
-    });
-    if (process.env.AGENT_HARNESS_PROMPTED_JSON_DEBUG === "1") {
-        console.error(JSON.stringify({
-            type: "builtin-task-committed-evidence",
-            selectedTools: toolCalls.map((item) => item.tool.name),
-            availableTools: readResolvedEvidenceTools(input.resolvedTools).map((tool) => ({
-                name: tool.name,
-                hasInvoke: typeof tool.invoke === "function",
-            })),
-        }));
-    }
-    if (toolCalls.length === 0) {
-        return input.result;
-    }
-    const messages = [...readMessages(input.result)];
-    for (const [index, item] of toolCalls.entries()) {
-        const toolCallId = `committed-evidence-${item.tool.name}-${index + 1}`;
-        messages.push(new AIMessage({
-            content: "",
-            tool_calls: [{
-                    id: toolCallId,
-                    name: item.tool.name,
-                    args: item.args,
-                    type: "tool_call",
-                }],
-        }));
-        try {
-            const output = await item.tool.invoke(item.args, input.invokeConfig);
-            messages.push(new ToolMessage({
-                name: item.tool.name,
-                tool_call_id: toolCallId,
-                content: stringifyVisibleTaskContent(output) || stringifyTaskState(output),
-            }));
-        }
-        catch (error) {
-            messages.push(new ToolMessage({
-                name: item.tool.name,
-                tool_call_id: toolCallId,
-                content: error instanceof Error ? error.message : String(error),
-            }));
-        }
-    }
-    return {
-        ...(typeof input.result === "object" && input.result !== null ? input.result : {}),
-        messages,
-    };
-}
-function hasFinalAssistantAfterExecutionTool(result) {
-    const messages = readMessages(result);
-    const lastMessage = messages.at(-1);
-    const lastTypeName = readMessageType(lastMessage);
-    if (lastTypeName === "tool" || lastTypeName === "ToolMessage") {
-        return false;
-    }
-    let sawExecutionTool = false;
-    for (const message of messages) {
-        const typeName = readMessageType(message);
-        if (typeName === "tool" || typeName === "ToolMessage") {
-            const name = readMessageName(message);
-            if (name !== "write_todos" && name !== "read_todos") {
-                sawExecutionTool = true;
-            }
-            continue;
-        }
-        if (!sawExecutionTool) {
-            continue;
-        }
-        if (typeName === "ai" || typeName === "AIMessage" || typeName === "assistant") {
-            const content = typeof message === "object" && message !== null && "content" in message
-                ? message.content
-                : undefined;
-            if (typeof content === "string" && content.trim().length > 0) {
-                return true;
-            }
-            if (Array.isArray(content) && content.length > 0) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-const FINALIZE_AFTER_TOOL_EVIDENCE_INSTRUCTION = [
-    "You have already gathered the required non-planning tool evidence.",
-    "Now produce the final answer for the delegated task.",
-    "Do not return raw command stdout as the final answer.",
-    "Do not stop at a tool result.",
-    "Update TODO statuses if needed, then return the configured response format with concise findings, blockers, next actions, and report.",
-].join("\n");
-function stringifyVisibleTaskContent(value) {
-    if (typeof value === "string") {
-        return value;
-    }
-    if (Array.isArray(value)) {
-        return value
-            .map((block) => {
-            if (typeof block === "string") {
-                return block;
-            }
-            if (isRecord(block) && typeof block.text === "string") {
-                return block.text;
-            }
-            return "";
-        })
-            .filter(Boolean)
-            .join("\n");
-    }
-    return "";
-}
-function looksLikeRawToolOutput(value) {
-    const normalized = value.trim();
-    return /^(?:stdout|stderr)\s*:/iu.test(normalized)
-        || /(?:^|\n)\s*(?:stdout|stderr)\s*:/iu.test(normalized)
-        || /(?:^|\n)\s*exitCode\s*:\s*-?\d+\s*$/iu.test(normalized);
-}
-function collectNonPlanningToolNames(result) {
-    const names = [];
-    for (const message of readMessages(result)) {
-        const typeName = readMessageType(message);
-        if (typeName !== "tool" && typeName !== "ToolMessage") {
-            continue;
-        }
-        const name = readMessageName(message);
-        if (!name || name === "write_todos" || name === "read_todos") {
-            continue;
-        }
-        if (!names.includes(name)) {
-            names.push(name);
-        }
-    }
-    return names;
-}
-function formatDelegatedRawToolEvidenceReport(input) {
-    const toolNames = collectNonPlanningToolNames(input.result);
-    const excerpt = input.output.trim().slice(0, 4000);
-    return JSON.stringify({
-        status: "completed",
-        routing: [`task delegated to ${input.subagentName}`],
-        plan: ["Delegate to specialist", "Collect required tool evidence", "Return synthesized result"],
-        execution: [
-            `task invoked ${input.subagentName}`,
-            `tool evidence: ${toolNames.length > 0 ? toolNames.join(", ") : "non-planning tool"}`,
-        ],
-        todoTrace: ["specialist TODO plan was created and completed"],
-        stepResults: [`${input.subagentName} completed delegated tool evidence collection`],
-        summary: ["Delegated specialist completed the required evidence tool path."],
-        findings: ["The delegated agent ended on raw tool output, so the runtime wrapped that evidence in a structured completion report."],
-        blockers: ["none"],
-        nextActions: ["Use the captured evidence for final parent synthesis."],
-        report: excerpt,
-    });
-}
 export function extractSubagentRequestText(state) {
     if (!isRecord(state)) {
         return "";
@@ -693,27 +335,7 @@ export async function invokeBuiltinTaskTool(input) {
             new HumanMessage({ content }),
         ],
     }, invokeConfig), taskTimeoutMs, selectedSubagent.name);
-    let result = await invokeSubagent(description);
-    if (!hasSubagentExecutionToolEvidence(result, resolvedSubagentTools, selectedCompiledSubagent?.tools)) {
-        result = await invokeSubagent([description, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"));
-        if (!hasSubagentExecutionToolEvidence(result, resolvedSubagentTools, selectedCompiledSubagent?.tools)) {
-            result = await appendCommittedEvidenceToolResults({
-                result,
-                taskText: description,
-                resolvedTools: resolvedSubagentTools,
-                invokeConfig,
-            });
-        }
-        if (!hasSubagentExecutionToolEvidence(result, resolvedSubagentTools, selectedCompiledSubagent?.tools)) {
-            throw new Error(`Delegated agent ${selectedSubagent.name} completed without tool execution evidence: lacked non-planning tool evidence.`);
-        }
-    }
-    if (!hasFinalAssistantAfterExecutionTool(result)
-        || looksLikeRawToolOutput(stringifyVisibleTaskContent(extractDeepAgentTaskContent(result)))
-        || looksLikeRawToolOutput(extractVisibleOutput(result))
-        || looksLikeRawToolOutput(extractToolFallbackContext(result))) {
-        result = await invokeSubagent(FINALIZE_AFTER_TOOL_EVIDENCE_INSTRUCTION, readMessages(result));
-    }
+    const result = await invokeSubagent(description);
     const structuredResponse = typeof result === "object" && result !== null && "structuredResponse" in result
         ? result.structuredResponse
         : undefined;
@@ -721,14 +343,6 @@ export async function invokeBuiltinTaskTool(input) {
         return JSON.stringify(structuredResponse);
     }
     const taskContent = extractDeepAgentTaskContent(result);
-    const taskContentText = stringifyVisibleTaskContent(taskContent);
-    if (looksLikeRawToolOutput(taskContentText)) {
-        return formatDelegatedRawToolEvidenceReport({
-            subagentName: selectedSubagent.name,
-            output: taskContentText,
-            result,
-        });
-    }
     if (Array.isArray(taskContent)) {
         const filtered = taskContent.filter((block) => {
             const blockType = typeof block === "object" && block !== null && "type" in block
@@ -744,24 +358,10 @@ export async function invokeBuiltinTaskTool(input) {
         return taskContent;
     }
     const visibleOutput = extractVisibleOutput(result);
-    if (looksLikeRawToolOutput(visibleOutput)) {
-        return formatDelegatedRawToolEvidenceReport({
-            subagentName: selectedSubagent.name,
-            output: visibleOutput,
-            result,
-        });
-    }
     if (visibleOutput) {
         return visibleOutput;
     }
     const fallbackOutput = extractToolFallbackContext(result);
-    if (looksLikeRawToolOutput(fallbackOutput)) {
-        return formatDelegatedRawToolEvidenceReport({
-            subagentName: selectedSubagent.name,
-            output: fallbackOutput,
-            result,
-        });
-    }
     return fallbackOutput || "Task completed";
 }
 export async function resolveBuiltinMiddlewareTools(input) {

package/package.json

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