@botbotgo/agent-harness 0.0.442 → 0.0.444

package/dist/package-version.d.ts

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

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

@@ -45,13 +45,13 @@ function buildDelegatedPlanEvidenceBlocker(agentId) {
         routing: [`delegated agent ${agentId}`],
         plan: ["delegate to specialist", "require visible TODO planning evidence", "return blocker when planning evidence is absent"],
         execution: [`task delegated to ${agentId}`, `delegated agent ${agentId} ended before producing required TODO plan evidence`],
-        todoTrace: ["TODO evidence missing"],
+        todoTrace: [`${agentId}: TODO evidence missing; delegated agent ended before producing required planning evidence.`],
         stepResults: ["delegated planning evidence was not observed"],
         summary: [`Delegated agent ${agentId} ended before producing the required TODO plan evidence.`],
         findings: ["The delegated run did not expose a valid planning trace, so the framework cannot treat the task as complete."],
         blockers: ["missing delegated TODO planning evidence"],
         nextActions: ["Retry with the same request or inspect the delegated agent configuration and model/tool-call behavior."],
-        report: `routing delegated to ${agentId}; todoTrace missing; stepResults blocked; summary missing planning evidence; findings require retry; blockers missing TODO planning evidence; nextActions inspect delegated model/tool behavior; report task delegated to ${agentId}.`,
+        report: `routing delegated to ${agentId}; todoTrace ${agentId}: TODO evidence missing; stepResults blocked; summary missing planning evidence; findings require retry; blockers missing TODO planning evidence; nextActions inspect delegated model/tool behavior; report task delegated to ${agentId}.`,
     });
 }
 function buildDelegatedExecutionEvidenceBlocker(agentId, expectedToolNames = []) {
@@ -65,7 +65,7 @@ function buildDelegatedExecutionEvidenceBlocker(agentId, expectedToolNames = [])
             `expected evidence tools: ${expectedTools}`,
             `delegated agent ${agentId} did not return any non-planning tool evidence after retry`,
         ],
-        todoTrace: ["TODO board observed without completed non-planning evidence"],
+        todoTrace: [`${agentId}: TODO evidence observed; delegated planning board did not produce completed non-planning evidence.`],
         stepResults: ["delegated execution evidence was not observed"],
         summary: [`Delegated agent ${agentId} did not return any non-planning tool evidence after retry.`],
         findings: [
@@ -75,7 +75,7 @@ function buildDelegatedExecutionEvidenceBlocker(agentId, expectedToolNames = [])
         ],
         blockers: ["missing delegated non-planning tool evidence"],
         nextActions: ["Retry the request or inspect the delegated agent's model/tool-call behavior."],
-        report: `routing delegated to ${agentId}; todoTrace observed planning only; stepResults blocked; summary missing non-planning tool evidence; findings expected evidence tools ${expectedTools}; blockers missing execution evidence; nextActions inspect delegated model/tool behavior; report task delegated to ${agentId}.`,
+        report: `routing delegated to ${agentId}; todoTrace ${agentId}: TODO evidence observed but non-planning evidence missing; stepResults blocked; summary missing non-planning tool evidence; findings expected evidence tools ${expectedTools}; blockers missing execution evidence; nextActions inspect delegated model/tool behavior; report task delegated to ${agentId}.`,
     });
 }
 function normalizePlanToolName(toolName) {
@@ -1562,8 +1562,8 @@ export class AgentRuntimeAdapter {
         const fallbackTodoTrace = [
             `1) TODO observed: delegated to ${delegatedSubagentType}.`,
             uniqueToolNames.some((toolName) => isPlanToolName(toolName))
-                ? "2) TODO evidence: delegated specialist invoked write_todos."
-                : "2) TODO evidence missing: delegated specialist did not expose write_todos in returned metadata.",
+                ? `2) ${delegatedSubagentType}: TODO evidence observed; delegated specialist invoked write_todos.`
+                : `2) ${delegatedSubagentType}: TODO evidence missing; delegated specialist did not expose write_todos in returned metadata.`,
             state === "failed"
                 ? "3) TODO closed: delegated execution failed; blocker reported."
                 : "3) TODO closed: delegated execution completed; synthesis returned.",

package/dist/runtime/harness/run/stream-run.js

@@ -35,17 +35,23 @@ function planStateHasUnfinishedItems(planState) {
 function planStateHasActiveItems(planState) {
     return planStateHasUnfinishedItems(planState);
 }
+function isPlanToolName(toolName) {
+    const normalized = typeof toolName === "string" ? toolName.trim().toLowerCase().replace(/[\s-]+/gu, "_") : "";
+    return normalized === "write_todos"
+        || normalized === "read_todos"
+        || normalized === "tool_call_write_todos"
+        || normalized === "tool_call_read_todos"
+        || normalized === "call_write_todos"
+        || normalized === "call_read_todos";
+}
 function isSubstantiveTerminalAssistantOutput(value) {
     const normalized = sanitizeVisibleText(value).trim();
     if (normalized.length < 80) {
         return false;
     }
-    if (/\b(?:delegated|waiting|wait for|initiated)\b/i.test(normalized) && !/\b(?:finding|summary|root cause|evidence|completed|result|issue)\b/i.test(normalized)) {
-        return false;
-    }
     return true;
 }
-function inferPlanItemStatusFromTerminalAssistantOutput(value) {
+function inferPlanItemStatusFromTerminalAssistantOutput(value, options = {}) {
     const terminalStatus = readTerminalExecutionStatus(value);
     if (terminalStatus) {
         return mapTerminalStatusToPlanItemStatus(terminalStatus);
@@ -54,12 +60,12 @@ function inferPlanItemStatusFromTerminalAssistantOutput(value) {
     if (!normalized) {
         return null;
     }
-    if (normalized.startsWith("runtime_error=")
-        || /\bterminated\b/i.test(normalized)
-        || /\b(?:blocked|blocker|failed|failure|refused|unable to complete|could not complete)\b/i.test(normalized)
-        || /(?:执行失败|未能完成|无法完成|阻塞|失败)/u.test(normalized)) {
+    if (normalized.startsWith("runtime_error=")) {
         return "failed";
     }
+    if (options.hasSuccessfulExecutionEvidence !== true) {
+        return null;
+    }
     return isSubstantiveTerminalAssistantOutput(value) ? "completed" : null;
 }
 function mapTerminalStatusToObservedPlanItemStatus(status, sawSuccessfulToolResult) {
@@ -678,6 +684,7 @@ export async function* streamHarnessRun(options) {
     let syntheticFallback;
     const toolErrors = [];
     let sawSuccessfulToolResult = false;
+    let sawSuccessfulExecutionToolResult = false;
     let lastToolResultKey = null;
     const executedToolResults = [];
     const emittedCommentary = new Set();
@@ -876,6 +883,9 @@ export async function* streamHarnessRun(options) {
                 }
                 else {
                     sawSuccessfulToolResult = true;
+                    if (!isPlanToolName(normalizedChunk.toolName) && normalizedChunk.toolName !== "task") {
+                        sawSuccessfulExecutionToolResult = true;
+                    }
                 }
                 yield {
                     type: "tool-result",
@@ -1058,14 +1068,16 @@ export async function* streamHarnessRun(options) {
         }
         currentPlanState = await refreshPlanStateFromPersistence(options, currentPlanState);
         const explicitTerminalAssistantStatus = readTerminalExecutionStatus(assistantOutput);
-        let terminalAssistantPlanItemStatus = inferPlanItemStatusFromTerminalAssistantOutput(assistantOutput);
-        if (explicitTerminalAssistantStatus === "blocked" && sawSuccessfulToolResult) {
+        let terminalAssistantPlanItemStatus = inferPlanItemStatusFromTerminalAssistantOutput(assistantOutput, {
+            hasSuccessfulExecutionEvidence: sawSuccessfulExecutionToolResult,
+        });
+        if (explicitTerminalAssistantStatus === "blocked" && sawSuccessfulExecutionToolResult) {
             terminalAssistantPlanItemStatus = "completed";
         }
         if (terminalAssistantPlanItemStatus === "failed"
-            && sawSuccessfulToolResult
+            && sawSuccessfulExecutionToolResult
             && !explicitTerminalAssistantStatus
-            && !/^\s*terminated\b|\bBlockers?:\b|(?:委托执行失败|未能完成|无法完成)/iu.test(assistantOutput)
+            && !sanitizeVisibleText(assistantOutput).trim().toLowerCase().startsWith("runtime_error=")
             && assistantOutput.trim()) {
             terminalAssistantPlanItemStatus = "completed";
         }

package/package.json

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