@botbotgo/agent-harness 0.0.377 → 0.0.378

package/dist/cli/chat-stream.js

@@ -20,6 +20,8 @@ export async function streamChatMessage(input) {
     let announcedRunningState = false;
     let requestTreeVisible = false;
     let requestTreePersisted = false;
+    let todoPanelVisible = false;
+    let lastRenderedTodoPanelLineCount = 0;
     let liveRequestAnnotations = [];
     let persistedRequestTreeEventCount = 0;
     let persistedRequestTreeTodoSignature = "";
@@ -155,6 +157,7 @@ export async function streamChatMessage(input) {
         stdoutWriteChain = enqueueChatWrite(input.stdout, input.stdoutStream, barrier, message);
     };
     const writeChatStdout = (message) => {
+        todoPanelVisible = false;
         if (input.requestEvents && input.liveRequestTree && !suppressRequestTreeRendering) {
             clearLiveRequestTree();
             enqueueOrderedStdout(message);
@@ -168,6 +171,7 @@ export async function streamChatMessage(input) {
         stdoutWriteChain = enqueueChatWrite(input.stdout, input.stdoutStream, stdoutWriteChain, message);
     };
     const writeChatStderr = (message) => {
+        todoPanelVisible = false;
         if (input.requestEvents && input.liveRequestTree && !suppressRequestTreeRendering) {
             clearLiveRequestTree();
             stderrWriteChain = enqueueChatWrite(input.stderr, input.stderrStream, stderrWriteChain, message);
@@ -176,6 +180,61 @@ export async function streamChatMessage(input) {
         }
         stderrWriteChain = enqueueChatWrite(input.stderr, input.stderrStream, stderrWriteChain, message);
     };
+    const parseTerminalTodoPanel = (rawText) => {
+        const lines = rawText.split("\n");
+        if (lines[0]?.trim() !== "TODO") {
+            return null;
+        }
+        const items = lines.slice(1).map((line) => {
+            const match = line.match(/^\s*\[([ x~!-])\]\s+(.+?)\s*$/);
+            if (!match) {
+                return null;
+            }
+            const marker = match[1];
+            const status = marker === "x"
+                ? "completed"
+                : marker === "~"
+                    ? "in_progress"
+                    : marker === "!"
+                        ? "failed"
+                        : marker === "-"
+                            ? "cancelled"
+                            : "pending";
+            return {
+                marker: marker === " " ? " " : marker,
+                content: match[2],
+                status,
+            };
+        }).filter((item) => item !== null);
+        return items.length > 0 ? items : null;
+    };
+    const renderTerminalTodoPanel = (items, agentId) => {
+        const now = Date.now();
+        const completed = items.filter((item) => item.status === "completed").length;
+        const inProgress = items.filter((item) => item.status === "in_progress").length;
+        const failed = items.filter((item) => item.status === "failed").length;
+        const cancelled = items.filter((item) => item.status === "cancelled").length;
+        const pending = items.filter((item) => item.status === "pending").length;
+        const summary = [
+            `${completed}/${items.length} done`,
+            `${inProgress} active`,
+            `${pending} pending`,
+            failed > 0 ? `${failed} failed` : null,
+            cancelled > 0 ? `${cancelled} cancelled` : null,
+        ].filter((part) => part !== null).join(" | ");
+        const header = `[${formatPerfClock(now)} +${formatElapsed(now)}]${formatAgentProgressLabel(agentId || latestAgentId)} TODO Burn Down | ${summary}`;
+        const rows = items.map((item) => `  [${item.marker}] ${item.content}`);
+        return `${header}\n${rows.join("\n")}\n`;
+    };
+    const drawTerminalTodoPanel = (items, agentId) => {
+        const panel = renderTerminalTodoPanel(items, agentId);
+        const clearPreviousPanel = todoPanelVisible && lastRenderedTodoPanelLineCount > 0
+            ? `\x1b[${lastRenderedTodoPanelLineCount}F\x1b[0J`
+            : "";
+        stderrWriteChain = enqueueChatWrite(input.stderr, input.stderrStream, stderrWriteChain, `${clearPreviousPanel}${panel}`);
+        lastRenderedTodoPanelLineCount = countRenderedLines(panel);
+        todoPanelVisible = true;
+    };
     const emitProgressCommentary = (rawText, agentId) => {
         const lines = rawText.split("\n").filter((line) => line.length > 0);
         if (lines.length === 0) {
@@ -393,6 +452,11 @@ export async function streamChatMessage(input) {
                 if (wroteContent || wroteRenderableBlocks) {
                     return;
                 }
+                const todoItems = !input.requestEvents ? parseTerminalTodoPanel(delta.text) : null;
+                if (todoItems) {
+                    drawTerminalTodoPanel(todoItems, delta.agentId);
+                    return;
+                }
                 emitProgressCommentary(delta.text, delta.agentId);
             }
         },

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.377";
+export declare const AGENT_HARNESS_VERSION = "0.0.378";
 export declare const AGENT_HARNESS_RELEASE_DATE = "2026-04-30";

package/dist/package-version.js

@@ -1,2 +1,2 @@
-export const AGENT_HARNESS_VERSION = "0.0.377";
+export const AGENT_HARNESS_VERSION = "0.0.378";
 export const AGENT_HARNESS_RELEASE_DATE = "2026-04-30";

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

@@ -1360,61 +1360,87 @@ export class AgentRuntimeAdapter {
             agentId: selectedBinding.agent.id,
         };
         const childRequestId = `${requestId}:${subagentType}`;
-        const executedToolResults = [];
-        let output = "";
-        try {
-            for await (const chunk of this.stream(selectedBinding, requestText, sessionId, [], {
-                context: options.context,
-                state: options.state,
-                files: options.files,
-                requestId: childRequestId,
-                memoryContext: options.memoryContext,
-                profiling: options.profiling,
-                toolRuntimeContext: options.toolRuntimeContext,
-            })) {
-                if (typeof chunk === "string") {
-                    output += chunk;
-                    continue;
-                }
-                if (chunk.kind === "content") {
-                    output += chunk.content ?? "";
-                    continue;
-                }
-                if (chunk.kind === "tool-result") {
-                    executedToolResults.push({
-                        toolName: chunk.toolName,
-                        output: chunk.output,
-                        ...(chunk.isError !== undefined ? { isError: chunk.isError } : {}),
-                    });
+        const runDelegatedStreamAttempt = async function* (text, requestIdSuffix = "") {
+            const executedToolResults = [];
+            let output = "";
+            try {
+                for await (const chunk of this.stream(selectedBinding, text, sessionId, [], {
+                    context: options.context,
+                    state: options.state,
+                    files: options.files,
+                    requestId: `${childRequestId}${requestIdSuffix}`,
+                    memoryContext: options.memoryContext,
+                    profiling: options.profiling,
+                    toolRuntimeContext: options.toolRuntimeContext,
+                })) {
+                    if (typeof chunk === "string") {
+                        output += chunk;
+                        continue;
+                    }
+                    if (chunk.kind === "content") {
+                        output += chunk.content ?? "";
+                        continue;
+                    }
+                    if (chunk.kind === "tool-result") {
+                        executedToolResults.push({
+                            toolName: chunk.toolName,
+                            output: chunk.output,
+                            ...(chunk.isError !== undefined ? { isError: chunk.isError } : {}),
+                        });
+                    }
+                    yield { ...chunk, agentId: chunk.agentId ?? selectedBinding.agent.id };
                 }
-                yield { ...chunk, agentId: chunk.agentId ?? selectedBinding.agent.id };
             }
-        }
-        catch (error) {
-            output = error instanceof Error ? error.message : String(error);
-            return {
-                toolOutput: output,
-                delegatedSubagentType: subagentType,
-                delegatedResult: {
+            catch (error) {
+                output = error instanceof Error ? error.message : String(error);
+                return {
                     sessionId,
-                    requestId: childRequestId,
+                    requestId: `${childRequestId}${requestIdSuffix}`,
                     agentId: selectedBinding.agent.id,
                     state: "failed",
                     output,
                     finalMessageText: output,
                     metadata: { executedToolResults },
-                },
+                };
+            }
+            return {
+                sessionId,
+                requestId: `${childRequestId}${requestIdSuffix}`,
+                agentId: selectedBinding.agent.id,
+                state: "completed",
+                output: sanitizeVisibleText(output),
+                finalMessageText: sanitizeVisibleText(output),
+                metadata: { executedToolResults },
+            };
+        }.bind(this);
+        let delegatedResult = yield* runDelegatedStreamAttempt(requestText);
+        const targetRequiresExecutionToolEvidence = getBindingPrimaryTools(selectedBinding).length > 0;
+        if (selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
+            && !hasDelegatedPlanEvidence(delegatedResult)) {
+            delegatedResult = yield* runDelegatedStreamAttempt([requestText, DELEGATED_PLAN_EVIDENCE_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":plan-evidence-retry");
+        }
+        if (targetRequiresExecutionToolEvidence && !hasDelegatedExecutionToolEvidence(delegatedResult)) {
+            delegatedResult = yield* runDelegatedStreamAttempt([requestText, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION].filter(Boolean).join("\n\n"), ":tool-evidence-retry");
+        }
+        if (selectedBinding.harnessRuntime.executionContract?.requiresPlan === true
+            && !hasDelegatedPlanEvidence(delegatedResult)) {
+            const output = "runtime_error=Delegated agent ended before producing required plan evidence.";
+            delegatedResult = {
+                ...delegatedResult,
+                state: "failed",
+                output,
+                finalMessageText: output,
+            };
+        }
+        if (targetRequiresExecutionToolEvidence && !hasDelegatedExecutionToolEvidence(delegatedResult)) {
+            const output = `runtime_error=Delegated agent ${selectedBinding.agent.id} completed without tool execution evidence.`;
+            delegatedResult = {
+                ...delegatedResult,
+                state: "failed",
+                output,
+                finalMessageText: output,
             };
         }
-        const delegatedResult = {
-            sessionId,
-            requestId: childRequestId,
-            agentId: selectedBinding.agent.id,
-            state: "completed",
-            output: sanitizeVisibleText(output),
-            finalMessageText: sanitizeVisibleText(output),
-            metadata: { executedToolResults },
-        };
         return {
             toolOutput: resolveDelegatedResultOutput(delegatedResult),
             delegatedSubagentType: subagentType,

package/package.json

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