@botbotgo/agent-harness 0.0.468 → 0.0.470

package/dist/package-version.d.ts

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

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

@@ -56,7 +56,6 @@ const INITIAL_REQUIRED_PLAN_INSTRUCTION = [
     "Your first action for this request must be write_todos with concrete task steps and statuses.",
     "Do not call any domain/evidence tool and do not provide a final answer before the initial write_todos call succeeds.",
     "After write_todos succeeds, do not call write_todos or read_todos again until one non-planning evidence tool returns.",
-    "Do not use placeholders like '1', '2', '3', 'step 1', or generic labels. Each todo must name the concrete work it represents.",
     "After each evidence step, update the todo board. Before the final answer, close every todo as completed or failed.",
 ].join("\n");
 function buildInitialRequiredPlanInstruction(primaryTools) {

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

@@ -69,13 +69,6 @@ function readTodoContent(todo) {
     }
     return "";
 }
-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);
-}
 function normalizeTodoStatus(value) {
     if (typeof value !== "string") {
         return "pending";
@@ -97,9 +90,6 @@ export function summarizeBuiltinWriteTodosArgs(args) {
             return [];
         }
         const content = readTodoContent(todo);
-        if (isLowSignalTodoContent(content)) {
-            return [];
-        }
         const status = normalizeTodoStatus(todo.status);
         const metadata = isRecord(todo.metadata) ? todo.metadata : undefined;
         return content ? [{

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

@@ -265,6 +265,18 @@ function buildCompactRouterPolicy(routingPolicy) {
         .slice(0, 80)
         .join("\n");
 }
+function looksLikeStructuredMultiItemRequest(requestText) {
+    const lines = requestText
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const numberedItems = lines.filter((line) => /^\d+[\.)、]\s+/u.test(line));
+    if (numberedItems.length >= 2) {
+        return true;
+    }
+    const bulletItems = lines.filter((line) => /^[-*]\s+/u.test(line));
+    return bulletItems.length >= 2;
+}
 function buildDelegatedOwnedTaskInstruction(input) {
     return [
         `Delegated owner: ${input.subagentType}.`,
@@ -1242,6 +1254,7 @@ export class AgentRuntimeAdapter {
         }
         const subagents = getBindingSubagents(binding);
         const subagentNames = new Set(subagents.map((subagent) => subagent.name));
+        const structuredMultiItemRequest = looksLikeStructuredMultiItemRequest(requestText);
         let selection = null;
         const subagentCatalog = subagents
             .map((subagent) => `- ${subagent.name}: ${subagent.description}`)
@@ -1253,6 +1266,7 @@ export class AgentRuntimeAdapter {
             "You are selecting a subagent for a delegation-only agent.",
             "Choose exactly one listed subagent when it can responsibly handle the request.",
             "Use the agent routing policy as authoritative routing configuration when it maps the request meaning to a listed subagent.",
+            "When the routing policy says a request class is owned by one listed subagent, keep that request with the configured owner even if the task mentions supporting evidence from other domains.",
             "Do not refuse while any listed subagent can own the request after applying the routing policy.",
             "Refuse only when the request is outside every listed subagent's configured responsibility.",
             compactRoutingPolicy ? "Agent routing policy:" : "",
@@ -1330,6 +1344,10 @@ export class AgentRuntimeAdapter {
                     continue;
                 }
                 if (parsedSelection.delegations && parsedSelection.delegations.length > 1) {
+                    if (selection?.subagentType
+                        && !parsedSelection.delegations.some((delegation) => delegation.subagentType === selection?.subagentType)) {
+                        continue;
+                    }
                     selection = parsedSelection;
                     break;
                 }
@@ -1340,7 +1358,96 @@ export class AgentRuntimeAdapter {
                 }
             }
         }
-        if (selection?.delegations && selection.delegations.length > 0) {
+        if (selection?.delegations && selection.delegations.length > 1) {
+            const aggregateToolResults = [];
+            const childReports = [];
+            for (const planned of selection.delegations) {
+                const selectedBinding = this.options.bindingResolver(planned.subagentType);
+                if (!selectedBinding) {
+                    const output = `Configured subagent '${planned.subagentType}' could not be resolved.`;
+                    childReports.push({
+                        subagentType: planned.subagentType,
+                        result: {
+                            sessionId,
+                            requestId: `${requestId}:${planned.subagentType}`,
+                            agentId: planned.subagentType,
+                            state: "failed",
+                            output,
+                            finalMessageText: output,
+                            metadata: { executedToolResults: [] },
+                        },
+                        output,
+                    });
+                    continue;
+                }
+                const delegatedResult = await this.invoke(selectedBinding, buildDelegatedOwnedTaskInstruction({
+                    subagentType: planned.subagentType,
+                    taskText: planned.description,
+                    originalRequest: requestText,
+                }), sessionId, `${requestId}:${planned.subagentType}`, undefined, [], {
+                    context: options.context,
+                    state: options.state,
+                    files: options.files,
+                    memoryContext: options.memoryContext,
+                });
+                const executedToolResults = Array.isArray(delegatedResult.metadata?.executedToolResults)
+                    ? delegatedResult.metadata.executedToolResults
+                    : [];
+                aggregateToolResults.push(...executedToolResults);
+                childReports.push({
+                    subagentType: planned.subagentType,
+                    result: delegatedResult,
+                    output: typeof delegatedResult.output === "string" ? delegatedResult.output : String(delegatedResult.output ?? ""),
+                });
+            }
+            const failedChildren = childReports.filter((child) => child.result.state === "failed");
+            const uniqueToolNames = [...new Set(aggregateToolResults.map((toolResult) => toolResult.toolName))];
+            const status = failedChildren.length > 0 ? "failed" : "completed";
+            const report = childReports
+                .map((child) => `## ${child.subagentType}\n${child.output.trim() || "No visible output returned."}`)
+                .join("\n\n");
+            const output = JSON.stringify({
+                status,
+                routing: selection.delegations.map((planned, index) => `${index + 1}) 路由判断: ${planned.subagentType} 负责 ${planned.description.trim() || "该专业域子任务"}。`),
+                plan: selection.delegations.map((planned, index) => `${index + 1}) 委托 ${planned.subagentType}: ${planned.description.trim() || "执行其专业域任务"}。`),
+                execution: childReports.map((child, index) => `${index + 1}) ${child.subagentType} ${child.result.state === "failed" ? "failed" : "completed"}。`),
+                todoTrace: childReports.map((child, index) => `${index + 1}) ${child.subagentType}: ${hasDelegatedPlanEvidence(child.result) ? "TODO evidence observed" : "TODO evidence missing"}。`),
+                stepResults: childReports.map((child, index) => `${index + 1}) ${child.subagentType}: delegated result collected; aggregate tools = ${uniqueToolNames.length > 0 ? uniqueToolNames.join(", ") : "none"}。`),
+                summary: [
+                    status === "failed"
+                        ? `多 specialist 编排完成，但 ${failedChildren.length} 个委托返回 failed。`
+                        : "多 specialist 编排已完成，所有委托均返回 completed。",
+                ],
+                findings: childReports.map((child) => `${child.subagentType}: ${child.output.trim().slice(0, 500) || "No finding text returned."}`),
+                blockers: failedChildren.length > 0
+                    ? failedChildren.map((child) => `${child.subagentType}: delegated execution failed.`)
+                    : ["none"],
+                nextActions: failedChildren.length > 0
+                    ? ["查看 failed specialist 的 blocker 并单独重跑该委托。"]
+                    : ["可基于各 specialist 结果继续做最终修复或发布决策。"],
+                report,
+            });
+            return {
+                toolOutput: output,
+                delegatedSubagentType: "multiple",
+                delegatedResult: {
+                    sessionId,
+                    requestId,
+                    agentId: binding.agent.id,
+                    state: status,
+                    output,
+                    finalMessageText: output,
+                    metadata: {
+                        executedToolResults: aggregateToolResults,
+                        delegations: childReports.map((child) => ({
+                            subagentType: child.subagentType,
+                            state: child.result.state,
+                        })),
+                    },
+                },
+            };
+        }
+        if (selection?.delegations && selection.delegations.length === 1) {
             selection = { subagentType: selection.delegations[0].subagentType };
         }
         if (selection?.refusedReason) {
@@ -1600,6 +1707,7 @@ export class AgentRuntimeAdapter {
         }
         const subagents = getBindingSubagents(binding);
         const subagentNames = new Set(subagents.map((subagent) => subagent.name));
+        const structuredMultiItemRequest = looksLikeStructuredMultiItemRequest(requestText);
         let selection = null;
         const subagentCatalog = subagents
             .map((subagent) => `- ${subagent.name}: ${subagent.description}`)
@@ -1611,9 +1719,14 @@ export class AgentRuntimeAdapter {
             "You are planning delegation for a delegation-only agent.",
             "Choose exactly one listed subagent when one specialist can responsibly handle the request.",
             "If the request naturally requires multiple specialist-owned steps, return an ordered delegation plan instead of one subagent.",
+            "A single objective with multiple evidence requirements is still single-owner when one listed subagent owns the objective.",
+            "Return multi-owner delegations only when the user asks for multiple independently owned specialist work items.",
             "For multi-line or numbered requests, evaluate every requested item semantically before choosing the final owner list.",
             "Use the agent routing policy as authoritative routing configuration when it maps request meaning to listed subagents.",
             "Apply the routing policy and subagent catalog literally; do not assign work to a subagent when the policy says that subagent is not the owner.",
+            "When the routing policy or subagent catalog says a request class routes to one owner only, choose that single owner.",
+            "Evidence dimensions inside one request, such as tools, files, CI, output format, failure states, routing, or runtime paths, are inputs to the selected owner; they do not create extra owners unless the user asks those specialists to do their own work.",
+            "A request made from one specialist perspective is single-owner when that specialist can responsibly handle the whole requested assessment.",
             "Evaluate each listed subagent independently against the request and include every listed owner whose configured responsibility is required.",
             "Do not merge one listed subagent's configured responsibility into another listed subagent's task.",
             "A broad request can still be handleable when multiple listed subagents each own part of it; return a delegation plan in that case.",
@@ -1687,9 +1800,12 @@ export class AgentRuntimeAdapter {
                     primaryModel.init?.think === false ? "/no_think" : "",
                     "Multi-specialist delegation is supported.",
                     "If a request needs multiple listed specialists, that is not a refusal condition.",
+                    "A single objective with multiple evidence requirements is still single-owner when one listed subagent owns the objective.",
+                    "Return multi-owner delegations only when the user asks for multiple independently owned specialist work items.",
                     "Return a delegations array that assigns each specialist-owned work item to listed subagents.",
                     "Evaluate each listed subagent independently against the request and include every listed owner whose configured responsibility is required.",
                     "Do not merge one listed subagent's configured responsibility into another listed subagent's task.",
+                    "Do not turn supporting evidence dimensions into separate owners when one listed subagent owns the requested assessment.",
                     "Never return final response fields such as routing, todoTrace, stepResults, summary, findings, blockers, nextActions, or report.",
                     "Return JSON only with this exact shape:",
                     "{\"delegations\":[{\"subagent_type\":\"<one exact listed name>\",\"description\":\"<owned subtask>\"}]}",
@@ -1719,6 +1835,10 @@ export class AgentRuntimeAdapter {
                     selection = parsedSelection;
                     break;
                 }
+                if (parsedSelection.subagentType && !structuredMultiItemRequest) {
+                    selection = parsedSelection;
+                    break;
+                }
                 if (!selection || selection.refusedReason || parsedSelection.subagentType) {
                     selection = parsedSelection.refusedReason && index < routerPrompts.length - 1
                         ? selection
@@ -1740,10 +1860,14 @@ export class AgentRuntimeAdapter {
                 "Internally review every sentence or list item in the user request before returning JSON.",
                 "Return one corrected JSON object only.",
                 "Keep the candidate plan unchanged when it already covers every specialist-owned work item.",
+                "Return a single subagent_type when one listed subagent owns the whole request and the candidate plan only split supporting evidence dimensions.",
+                "A single objective with multiple evidence requirements is still single-owner when one listed subagent owns the objective.",
+                "Return multi-owner delegations only when the user asks for multiple independently owned specialist work items.",
                 "If the candidate omits a specialist-owned work item, add that listed subagent in the correct user-requested order.",
                 "If the candidate includes a subagent whose described work is not owned by that subagent, remove or replace it.",
                 "Evaluate each listed subagent independently against the request and include every listed owner whose configured responsibility is required.",
                 "Do not merge one listed subagent's configured responsibility into another listed subagent's task.",
+                "Do not turn supporting evidence dimensions into separate owners when one listed subagent owns the requested assessment.",
                 "Do not add a subagent unless the routing policy or subagent catalog makes ownership clear.",
                 "When the routing policy states that a subagent is not the owner for a domain, do not assign that domain to that subagent.",
                 "Use only listed subagent names.",
@@ -1753,7 +1877,8 @@ export class AgentRuntimeAdapter {
                 subagentCatalog,
                 "Candidate delegation plan:",
                 candidatePlan,
-                "Required JSON shape:",
+                "Allowed JSON shapes:",
+                "{\"subagent_type\":\"<listed subagent name>\"}",
                 "{\"delegations\":[{\"subagent_type\":\"<listed subagent name>\",\"description\":\"<only that specialist's owned portion>\"}]}",
                 "User request:",
                 requestText,
@@ -1762,15 +1887,62 @@ export class AgentRuntimeAdapter {
             if (rawCoverage !== null) {
                 const coverageText = readModelText(rawCoverage);
                 const coverageSelection = parseCompactRouterSelection(coverageText, subagentNames);
+                if (coverageSelection?.subagentType && !structuredMultiItemRequest) {
+                    selection = coverageSelection;
+                }
+                if (coverageSelection?.delegations && coverageSelection.delegations.length === 1 && !structuredMultiItemRequest) {
+                    selection = { subagentType: coverageSelection.delegations[0].subagentType };
+                }
                 if (coverageSelection?.delegations && coverageSelection.delegations.length > 1) {
                     const candidateNames = new Set(candidateDelegations.map((item) => item.subagentType));
                     const coverageNames = new Set(coverageSelection.delegations.map((item) => item.subagentType));
                     const preservesCandidateOwners = Array.from(candidateNames).every((name) => coverageNames.has(name));
-                    if (coverageSelection.delegations.length > candidateDelegations.length || preservesCandidateOwners) {
+                    if (preservesCandidateOwners) {
                         selection = coverageSelection;
                     }
                 }
             }
+            if (candidateDelegations.length > 1 && selection?.delegations && selection.delegations.length > 1) {
+                const activePlan = selection.delegations
+                    .map((item, index) => `${index + 1}. ${item.subagentType}: ${item.description}`)
+                    .join("\n");
+                const arbitrationPrompt = [
+                    primaryModel.init?.think === false ? "/no_think" : "",
+                    "Arbitrate whether this delegation plan is over-split.",
+                    "The runtime supports both one-owner and multi-owner delegation.",
+                    "Choose one owner when the routing policy or subagent catalog says one listed subagent owns the whole request.",
+                    "A single objective with multiple evidence requirements is still single-owner when one listed subagent owns the objective.",
+                    "Treat supporting evidence dimensions as inputs to that owner, not as separate owners.",
+                    "Keep multi-owner delegation only when the user asked for multiple independently owned specialist work items.",
+                    "Return exactly one JSON object and no prose.",
+                    "Single-owner shape:",
+                    "{\"subagent_type\":\"<listed subagent name>\"}",
+                    "Multi-owner shape:",
+                    "{\"delegations\":[{\"subagent_type\":\"<listed subagent name>\",\"description\":\"<only that specialist's owned portion>\"}]}",
+                    compactRoutingPolicy ? "Agent routing policy:" : "",
+                    compactRoutingPolicy,
+                    "Available subagents:",
+                    subagentCatalog,
+                    "Candidate plan:",
+                    activePlan,
+                    "User request:",
+                    requestText,
+                ].filter(Boolean).join("\n\n");
+                const rawArbitration = await invokeRouter(arbitrationPrompt, "delegation router over-split arbitration invoke");
+                if (rawArbitration !== null) {
+                    const arbitrationText = readModelText(rawArbitration);
+                    const arbitrationSelection = parseCompactRouterSelection(arbitrationText, subagentNames);
+                    if (arbitrationSelection?.subagentType && !structuredMultiItemRequest) {
+                        selection = arbitrationSelection;
+                    }
+                    else if (arbitrationSelection?.delegations && arbitrationSelection.delegations.length === 1 && !structuredMultiItemRequest) {
+                        selection = { subagentType: arbitrationSelection.delegations[0].subagentType };
+                    }
+                    else if (arbitrationSelection?.delegations && arbitrationSelection.delegations.length > 1) {
+                        selection = arbitrationSelection;
+                    }
+                }
+            }
         }
         if (selection?.delegations?.length === 1) {
             const onlyDelegation = selection.delegations[0];

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

@@ -1,4 +1,4 @@
-export { appendToolRecoveryInstruction, isRepairableWriteTodosContentFailure, isRepairableWriteTodosEmptyFailure, isRepairableWriteTodosPlaceholderFailure, isRetrySafeInvalidToolSelectionError, resolveMissingPlanRecoveryInstruction, isToolCallRecoveryFailure, isToolCallValidationFailure, isWorkspacePathScopeFailure, resolveExecutionWithoutToolEvidenceInstruction, resolveExecutionWithoutToolEvidenceTextInstruction, resolveToolCallRecoveryInstruction, shouldValidateExecutionWithoutToolEvidence, wrapResolvedModel, } from "./output-recovery.js";
-export { BROWSER_CAPABILITY_DISCLAIMER_RECOVERY_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, INVALID_TOOL_SELECTION_RECOVERY_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, } from "../prompts/runtime-prompts.js";
+export { appendToolRecoveryInstruction, isRepairableWriteTodosContentFailure, isRepairableWriteTodosEmptyFailure, isRetrySafeInvalidToolSelectionError, resolveMissingPlanRecoveryInstruction, isToolCallRecoveryFailure, isToolCallValidationFailure, isWorkspacePathScopeFailure, resolveExecutionWithoutToolEvidenceInstruction, resolveExecutionWithoutToolEvidenceTextInstruction, resolveToolCallRecoveryInstruction, shouldValidateExecutionWithoutToolEvidence, wrapResolvedModel, } from "./output-recovery.js";
+export { BROWSER_CAPABILITY_DISCLAIMER_RECOVERY_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION, STRICT_TOOL_JSON_INSTRUCTION, WORKSPACE_RELATIVE_PATH_INSTRUCTION, WRITE_TODOS_FULL_ENTRY_INSTRUCTION, WRITE_TODOS_NON_EMPTY_INITIAL_LIST_INSTRUCTION, } from "../prompts/runtime-prompts.js";
 export { containsLikelySkillDocument, extractContentBlocks, extractEmptyAssistantMessageFailure, extractOutputContent, extractReasoningText, extractToolFallbackContext, extractVisibleOutput, hasToolCalls, readTextContent, sanitizeVisibleText, } from "./output-content.js";
 export { isLikelyToolArgsObject, salvageToolArgs, tryParseJson, } from "./output-tool-args.js";

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

@@ -1,4 +1,4 @@
-export { appendToolRecoveryInstruction, isRepairableWriteTodosContentFailure, isRepairableWriteTodosEmptyFailure, isRepairableWriteTodosPlaceholderFailure, isRetrySafeInvalidToolSelectionError, resolveMissingPlanRecoveryInstruction, isToolCallRecoveryFailure, isToolCallValidationFailure, isWorkspacePathScopeFailure, resolveExecutionWithoutToolEvidenceInstruction, resolveExecutionWithoutToolEvidenceTextInstruction, resolveToolCallRecoveryInstruction, shouldValidateExecutionWithoutToolEvidence, wrapResolvedModel, } from "./output-recovery.js";
-export { BROWSER_CAPABILITY_DISCLAIMER_RECOVERY_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, INVALID_TOOL_SELECTION_RECOVERY_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, } from "../prompts/runtime-prompts.js";
+export { appendToolRecoveryInstruction, isRepairableWriteTodosContentFailure, isRepairableWriteTodosEmptyFailure, isRetrySafeInvalidToolSelectionError, resolveMissingPlanRecoveryInstruction, isToolCallRecoveryFailure, isToolCallValidationFailure, isWorkspacePathScopeFailure, resolveExecutionWithoutToolEvidenceInstruction, resolveExecutionWithoutToolEvidenceTextInstruction, resolveToolCallRecoveryInstruction, shouldValidateExecutionWithoutToolEvidence, wrapResolvedModel, } from "./output-recovery.js";
+export { BROWSER_CAPABILITY_DISCLAIMER_RECOVERY_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_INSTRUCTION, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION, STRICT_TOOL_JSON_INSTRUCTION, WORKSPACE_RELATIVE_PATH_INSTRUCTION, WRITE_TODOS_FULL_ENTRY_INSTRUCTION, WRITE_TODOS_NON_EMPTY_INITIAL_LIST_INSTRUCTION, } from "../prompts/runtime-prompts.js";
 export { containsLikelySkillDocument, extractContentBlocks, extractEmptyAssistantMessageFailure, extractOutputContent, extractReasoningText, extractToolFallbackContext, extractVisibleOutput, hasToolCalls, readTextContent, sanitizeVisibleText, } from "./output-content.js";
 export { isLikelyToolArgsObject, salvageToolArgs, tryParseJson, } from "./output-tool-args.js";

package/dist/runtime/parsing/output-recovery.d.ts

@@ -1,7 +1,6 @@
 export declare function isToolCallValidationFailure(error: unknown): boolean;
 export declare function isWorkspacePathScopeFailure(error: unknown): boolean;
 export declare function isInternalRuntimeSpillPathFailure(error: unknown): boolean;
-export declare function isRepairableWriteTodosPlaceholderFailure(error: unknown): boolean;
 export declare function isRepairableWriteTodosContentFailure(error: unknown): boolean;
 export declare function isRepairableWriteTodosEmptyFailure(error: unknown): boolean;
 export declare function isToolCallRecoveryFailure(error: unknown): boolean;

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

@@ -1,4 +1,4 @@
-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 { 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_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) {
@@ -85,9 +85,6 @@ export function isWorkspacePathScopeFailure(error) {
 export function isInternalRuntimeSpillPathFailure(error) {
     return collectErrorMessages(error).some((message) => /\/large_tool_results\/|internal runtime spill path/i.test(message));
 }
-export function isRepairableWriteTodosPlaceholderFailure(error) {
-    return error instanceof Error && /write_todos/i.test(error.message) && /descriptive task content|placeholder entries/i.test(error.message);
-}
 export function isRepairableWriteTodosContentFailure(error) {
     return error instanceof Error && /write_todos/i.test(error.message) && /todos\[\d+\]\.content/i.test(error.message);
 }
@@ -98,7 +95,6 @@ export function isToolCallRecoveryFailure(error) {
     return (isToolCallParseFailure(error) ||
         isToolCallValidationFailure(error) ||
         isRepairableWriteTodosEmptyFailure(error) ||
-        isRepairableWriteTodosPlaceholderFailure(error) ||
         isInternalRuntimeSpillPathFailure(error) ||
         isWorkspacePathScopeFailure(error));
 }
@@ -160,8 +156,6 @@ export function resolveToolCallRecoveryInstruction(error) {
         return WRITE_TODOS_NON_EMPTY_INITIAL_LIST_INSTRUCTION;
     if (isRepairableWriteTodosContentFailure(error))
         return WRITE_TODOS_FULL_ENTRY_INSTRUCTION;
-    if (isRepairableWriteTodosPlaceholderFailure(error))
-        return WRITE_TODOS_DESCRIPTIVE_CONTENT_INSTRUCTION;
     if (isInternalRuntimeSpillPathFailure(error))
         return INTERNAL_RUNTIME_SPILL_PATH_INSTRUCTION;
     if (isWorkspacePathScopeFailure(error))

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

@@ -6,7 +6,6 @@ export declare const BROWSER_CAPABILITY_DISCLAIMER_RECOVERY_INSTRUCTION: string;
 export declare const INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION: string;
 export declare const WRITE_TODOS_FULL_ENTRY_INSTRUCTION: string;
 export declare const WRITE_TODOS_NON_EMPTY_INITIAL_LIST_INSTRUCTION: string;
-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;

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

@@ -9,7 +9,6 @@ export const BROWSER_CAPABILITY_DISCLAIMER_RECOVERY_INSTRUCTION = readRuntimePro
 export const INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION = readRuntimePrompt("invalid-tool-selection-recovery");
 export const WRITE_TODOS_FULL_ENTRY_INSTRUCTION = readRuntimePrompt("write-todos-full-entry");
 export const WRITE_TODOS_NON_EMPTY_INITIAL_LIST_INSTRUCTION = readRuntimePrompt("write-todos-non-empty-initial-list");
-export const WRITE_TODOS_DESCRIPTIVE_CONTENT_INSTRUCTION = readRuntimePrompt("write-todos-descriptive-content");
 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");

package/package.json

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