@botbotgo/agent-harness 0.0.353 → 0.0.355

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.353";
-export declare const AGENT_HARNESS_RELEASE_DATE = "2026-04-24";
+export declare const AGENT_HARNESS_VERSION = "0.0.355";
+export declare const AGENT_HARNESS_RELEASE_DATE = "2026-04-25";

package/dist/package-version.js

@@ -1,2 +1,2 @@
-export const AGENT_HARNESS_VERSION = "0.0.353";
-export const AGENT_HARNESS_RELEASE_DATE = "2026-04-24";
+export const AGENT_HARNESS_VERSION = "0.0.355";
+export const AGENT_HARNESS_RELEASE_DATE = "2026-04-25";

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

@@ -1 +1,10 @@
-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. 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 the todo board already exists, do not restart planning and do not repeat the same clarification request; your next response must continue execution with a concrete diagnostic tool call. When prior tool results or triage evidence already exist, your next response must contain tool calls only and must advance the investigation from that evidence. Then keep executing the next diagnostic steps until you can explain the likely causes, impact, and recommended next actions. Ask a blocking clarification question only after the available evidence is genuinely insufficient to continue.
+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.

package/dist/runtime/adapter/compat/deepagent-compat.d.ts

@@ -11,3 +11,9 @@ export declare function resolveDeepAgentSkillSourcePaths(options: {
     ownerId: string;
     skillPaths?: string[];
 }): string[] | undefined;
+export declare function resolveDeepAgentSkillSourceRootPaths(options: {
+    workspaceRoot?: string;
+    runtimeRoot?: string;
+    ownerId: string;
+    skillPaths?: string[];
+}): string[] | undefined;

package/dist/runtime/adapter/compat/deepagent-compat.js

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { existsSync } from "node:fs";
 export function relativizeDeepAgentSkillSourcePaths(workspaceRoot, skillPaths) {
     if (!workspaceRoot || !skillPaths) {
         return skillPaths;
@@ -24,3 +25,18 @@ export function resolveDeepAgentSkillSourcePaths(options) {
     }
     return relativizeDeepAgentSkillSourcePaths(workspaceRoot, skillPaths) ?? skillPaths;
 }
+export function resolveDeepAgentSkillSourceRootPaths(options) {
+    const { workspaceRoot, skillPaths } = options;
+    if (!skillPaths) {
+        return skillPaths;
+    }
+    const sourceRoots = Array.from(new Set(skillPaths.map((skillPath) => {
+        const absolutePath = path.isAbsolute(skillPath) || !workspaceRoot
+            ? skillPath
+            : path.resolve(workspaceRoot, skillPath);
+        return existsSync(path.join(absolutePath, "SKILL.md"))
+            ? path.dirname(absolutePath)
+            : absolutePath;
+    })));
+    return relativizeDeepAgentSkillSourcePaths(workspaceRoot, sourceRoots) ?? sourceRoots;
+}

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

@@ -4,9 +4,10 @@ import { finalizeRequestResult } from "../invocation-result.js";
 import { invokeRuntimeWithLocalTools } from "./invoke-runtime.js";
 import { buildInvocationRequest } from "../model/invocation-request.js";
 import { UPSTREAM_REQUEST_CONFIG_KEY, UPSTREAM_SESSION_CONFIG_KEY } from "../upstream-configurable-keys.js";
-import { extractVisibleOutput, tryParseJson } from "../../parsing/output-parsing.js";
+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 } from "../../prompts/runtime-prompts.js";
 function readBindingExecutionParams(binding) {
     const params = binding.execution?.params ?? binding.deepAgentParams ?? binding.langchainAgentParams;
     return {
@@ -36,6 +37,29 @@ function isDelegationOnlyBinding(binding) {
 function hasTaskDelegationEvidence(executedToolResults) {
     return executedToolResults.some((item) => item.toolName === "task");
 }
+function hasIncompleteTodos(value) {
+    if (!Array.isArray(value)) {
+        return false;
+    }
+    return value.some((todo) => {
+        if (typeof todo !== "object" || todo === null) {
+            return false;
+        }
+        const status = typeof todo.status === "string"
+            ? todo.status.trim().toLowerCase()
+            : "";
+        return status === "pending" || status === "in_progress";
+    });
+}
+function hasIncompleteUpstreamPlan(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const typed = value;
+    return hasIncompleteTodos(typed.todos)
+        || hasIncompleteTodos(typed.stateSnapshot?.todos)
+        || hasIncompleteTodos(typed.metadata?.stateSnapshot?.todos);
+}
 function hasNativeTaskDelegationIntent(value) {
     if (typeof value !== "object" || value === null) {
         return false;
@@ -285,11 +309,25 @@ export async function executeRequestInvocation(options) {
             toolRuntimeContext: invokeOptions.toolRuntimeContext,
         });
     }
-    const result = localOrUpstreamInvocation.result;
+    let result = localOrUpstreamInvocation.result;
     const executedToolResults = [...localOrUpstreamInvocation.executedToolResults];
     if (!result) {
         throw new Error("Agent invocation returned no result");
     }
+    if (options.resumePayload === undefined
+        && options.binding.harnessRuntime.executionContract?.requiresPlan === true
+        && hasIncompleteUpstreamPlan(result)
+        && !extractVisibleOutput(result).trim()) {
+        const messages = Array.isArray(result.messages)
+            ? result.messages
+            : undefined;
+        const recoveryBase = messages ? { messages } : request;
+        const recoveredRequest = appendToolRecoveryInstruction(recoveryBase, AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION);
+        const recoveredInvocation = await invokeOnce(recoveredRequest);
+        localOrUpstreamInvocation = recoveredInvocation;
+        result = recoveredInvocation.result;
+        executedToolResults.splice(0, executedToolResults.length, ...recoveredInvocation.executedToolResults);
+    }
     try {
         return finalizeRequestResult({
             bindingAgentId: options.binding.agent.id,

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

@@ -57,6 +57,17 @@ function looksLikeToolBlocker(value) {
         || /invalid tool call/iu.test(normalized)
         || /tool call.*schema/iu.test(normalized);
 }
+function isSubstantiveFinalOutput(value) {
+    const normalized = sanitizeVisibleText(value).trim();
+    if (normalized.length < 80) {
+        return false;
+    }
+    return !looksLikeLeakedToolCallText(normalized)
+        && !looksLikeToolBlocker(normalized)
+        && !looksLikeClarificationQuestion(normalized)
+        && !looksLikeNonEvidenceApology(normalized)
+        && !isLowSignalStructuredCompletion(normalized);
+}
 function normalizeToolOutputText(output) {
     const directText = typeof output === "string"
         ? sanitizeVisibleText(output).trim()
@@ -343,18 +354,30 @@ export function finalizeRequestResult(params) {
         && !hasFinalMessageToolCalls(result)) {
         throw new Error("empty_final_output");
     }
+    const stateSnapshot = buildStateSnapshot(result);
+    const hasIncompleteRequiredPlan = binding?.harnessRuntime?.executionContract?.requiresPlan === true
+        && hasIncompleteStateSnapshotPlan(stateSnapshot);
     const serializedResult = JSON.stringify(result, null, 2);
-    const output = resolveDeterministicFinalOutput({
+    let output = resolveDeterministicFinalOutput({
         visibleOutput,
         toolFallback,
         executedToolResults: allExecutedToolResults,
     })
         || (containsLikelySkillDocument(result) ? "" : serializedResult);
+    const preliminaryTerminalStatus = readTerminalExecutionStatus(output);
+    const hasMissingRequiredFinalAnswer = binding?.harnessRuntime?.executionContract?.requiresPlan === true
+        && !visibleOutput
+        && !preliminaryTerminalStatus
+        && allExecutedToolResults.some((toolResult) => toolResult.isError !== true && toolResult.toolName !== "write_todos" && toolResult.toolName !== "read_todos");
+    if (hasIncompleteRequiredPlan && !visibleOutput) {
+        output = "runtime_error=Agent ended while required plan still had unfinished work.";
+    }
+    else if (hasMissingRequiredFinalAnswer) {
+        output = "runtime_error=Agent ended after tool execution without producing a final answer.";
+    }
     const finalMessageText = sanitizeVisibleText(output);
     const terminalStatus = structuredTerminalStatus ?? readTerminalExecutionStatus(finalMessageText);
-    const stateSnapshot = buildStateSnapshot(result);
-    const hasIncompleteRequiredPlan = binding?.harnessRuntime?.executionContract?.requiresPlan === true
-        && hasIncompleteStateSnapshotPlan(stateSnapshot);
+    const hasSubstantiveFinalOutput = Boolean(visibleOutput) && isSubstantiveFinalOutput(finalMessageText);
     const hasTerminalToolBlocker = looksLikeToolBlocker(finalMessageText);
     const memoryCandidates = allExecutedToolResults.flatMap((toolResult) => toolResult.memoryCandidates ?? []);
     return {
@@ -363,7 +386,7 @@ export function finalizeRequestResult(params) {
         agentId: bindingAgentId,
         state: Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0
             ? "waiting_for_approval"
-            : hasIncompleteRequiredPlan
+            : (hasIncompleteRequiredPlan && !hasSubstantiveFinalOutput) || hasMissingRequiredFinalAnswer
                 ? "failed"
                 : hasTerminalToolBlocker
                     ? "failed"

package/dist/runtime/adapter/model/model-providers.js

@@ -23,6 +23,7 @@ const PROMPTED_JSON_FINAL_TOOL_CALL_REMINDER = [
     "If a TOOL_RESULT is already present for the requested work, do not repeat that tool call; answer normally.",
     'Shape: {"name":"tool_name","arguments":{}}',
 ].join("\n");
+const NO_THINK_CONTROL_TOKEN = "/no_think";
 function readModelText(value) {
     if (typeof value === "string") {
         return value.trim();
@@ -455,16 +456,21 @@ function formatBoundToolInstruction(tool) {
         `Arguments JSON schema: ${JSON.stringify(schema)}`,
     ].filter(Boolean).join("\n");
 }
-function withPromptedJsonToolPrompt(input, tools) {
+function withPromptedJsonToolPrompt(input, tools, options = {}) {
     const toolInstructions = tools.map((tool) => formatBoundToolInstruction(tool)).filter((value) => Boolean(value));
     if (toolInstructions.length === 0) {
         return stringifyNodeLlamaCppInput(input);
     }
     const systemContent = `${NODE_LLAMA_CPP_TOOL_CALL_INSTRUCTION}\n\n${toolInstructions.join("\n\n")}`;
     const prompt = stringifyNodeLlamaCppInput(input);
-    return [systemContent, prompt, PROMPTED_JSON_FINAL_TOOL_CALL_REMINDER].filter(Boolean).join("\n\n");
+    return [
+        options.suppressThinking ? NO_THINK_CONTROL_TOKEN : "",
+        systemContent,
+        prompt,
+        PROMPTED_JSON_FINAL_TOOL_CALL_REMINDER,
+    ].filter(Boolean).join("\n\n");
 }
-function createPromptedJsonToolBindableModel(model, boundTools = []) {
+function createPromptedJsonToolBindableModel(model, boundTools = [], options = {}) {
     return new Proxy(model, {
         has(target, prop) {
             if (prop === "bindTools" || prop === "invoke" || prop === "stream" || prop === "withConfig") {
@@ -474,11 +480,11 @@ function createPromptedJsonToolBindableModel(model, boundTools = []) {
         },
         get(target, prop, receiver) {
             if (prop === "bindTools") {
-                return (tools) => createPromptedJsonToolBindableModel(target, tools);
+                return (tools) => createPromptedJsonToolBindableModel(target, tools, options);
             }
             if (prop === "invoke") {
                 return async (input, config) => {
-                    const rawResult = await target.invoke(boundTools.length > 0 ? withPromptedJsonToolPrompt(input, boundTools) : input, config);
+                    const rawResult = await target.invoke(boundTools.length > 0 ? withPromptedJsonToolPrompt(input, boundTools, options) : input, config);
                     if (boundTools.length === 0) {
                         return rawResult;
                     }
@@ -510,7 +516,7 @@ function createPromptedJsonToolBindableModel(model, boundTools = []) {
                 };
             }
             if (prop === "withConfig" && typeof target.withConfig === "function") {
-                return (config) => createPromptedJsonToolBindableModel(target.withConfig(config), boundTools);
+                return (config) => createPromptedJsonToolBindableModel(target.withConfig(config), boundTools, options);
             }
             const member = Reflect.get(target, prop, receiver);
             return typeof member === "function" ? member.bind(target) : member;
@@ -559,7 +565,7 @@ export async function createResolvedModel(model, modelResolver) {
         const { toolCallingMode, ...init } = model.init ?? {};
         const resolved = new ChatOllama({ model: model.model, ...init });
         if (toolCallingMode === "prompted-json") {
-            return createPromptedJsonToolBindableModel(resolved);
+            return createPromptedJsonToolBindableModel(resolved, [], { suppressThinking: init.think === false });
         }
         return createProviderToolMessageCompatModel(resolved);
     }

package/dist/runtime/adapter/resilience.js

@@ -42,6 +42,9 @@ export function isEmptyFinalAiMessageError(error) {
     const message = error instanceof Error ? error.message : String(error);
     return message.toLowerCase().startsWith("empty_final_ai_message:");
 }
+function isRuntimeOperationTimeoutError(error) {
+    return typeof error === "object" && error !== null && error.name === "RuntimeOperationTimeoutError";
+}
 function isRetryableHttpStatus(status) {
     return typeof status === "number" && Number.isInteger(status) && status >= 500 && status <= 599;
 }
@@ -84,6 +87,9 @@ export function resolveProviderRetryPolicy(binding) {
     };
 }
 export function isRetryableProviderError(binding, error) {
+    if (isRuntimeOperationTimeoutError(error)) {
+        return false;
+    }
     if (isEmptyFinalAiMessageError(error)) {
         return true;
     }

package/dist/runtime/agent-runtime-adapter.d.ts

@@ -2,7 +2,7 @@ import type { CompiledAgentBinding, MessageContent, RequestResult, RuntimeAdapte
 import { type RuntimeStreamChunk } from "./parsing/stream-event-parsing.js";
 import { AGENT_INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, DEFAULT_DEEPAGENT_RECURSION_LIMIT, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn } from "./agent-runtime-assembly.js";
 import { RuntimeOperationTimeoutError } from "./adapter/runtime-shell.js";
-export { materializeDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourcePaths, relativizeDeepAgentSkillSourcePaths, } from "./adapter/compat/deepagent-compat.js";
+export { materializeDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourceRootPaths, relativizeDeepAgentSkillSourcePaths, } from "./adapter/compat/deepagent-compat.js";
 export { buildAuthOmittingFetch, normalizeOpenAICompatibleInit } from "./adapter/compat/openai-compatible.js";
 export { buildToolNameMapping, createModelFacingToolNameCandidates, createModelFacingToolNameLookupCandidates, resolveModelFacingToolName, sanitizeToolNameForModel, } from "./adapter/tool/tool-name-mapping.js";
 export { computeRemainingTimeoutMs, isRetryableProviderError, resolveBindingTimeout, resolveProviderRetryPolicy, resolveStreamIdleTimeout, resolveTimeoutMs, } from "./adapter/resilience.js";
@@ -57,6 +57,7 @@ export declare class AgentRuntimeAdapter {
         files?: Record<string, unknown>;
         memoryContext?: string;
     }): Promise<RequestResult>;
+    private tryDelegateWithCompactRouter;
     stream(binding: CompiledAgentBinding, input: MessageContent, sessionId: string, history?: TranscriptMessage[], options?: {
         context?: Record<string, unknown>;
         state?: Record<string, unknown>;

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

@@ -1,9 +1,10 @@
 import path from "node:path";
 import { createAsyncSubAgentMiddleware, createFilesystemMiddleware, createMemoryMiddleware, createPatchToolCallsMiddleware, createSkillsMiddleware, createSummarizationMiddleware, createSubAgentMiddleware, FilesystemBackend, StateBackend, } from "deepagents";
 import { createAgent, humanInTheLoopMiddleware, todoListMiddleware } from "langchain";
-import { wrapResolvedModel, } from "./parsing/output-parsing.js";
+import { sanitizeVisibleText, tryParseJson, wrapResolvedModel, } from "./parsing/output-parsing.js";
+import { extractMessageText } from "../utils/message-content.js";
 import { AGENT_INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildDeepAgentSystemPromptWithCapabilityHierarchy, buildLangChainCreateParams, DEFAULT_DEEPAGENT_RECURSION_LIMIT, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, shouldAttachDeepAgentBackend, shouldAttachDeepAgentCheckpointer, shouldAttachDeepAgentStore, } from "./agent-runtime-assembly.js";
-import { resolveDeepAgentSkillSourcePaths, } from "./adapter/compat/deepagent-compat.js";
+import { resolveDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourceRootPaths, } from "./adapter/compat/deepagent-compat.js";
 import { EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION } from "./prompts/runtime-prompts.js";
 import { buildToolNameMapping, } from "./adapter/tool/tool-name-mapping.js";
 import { executeRequestInvocation } from "./adapter/flow/invocation-flow.js";
@@ -17,11 +18,11 @@ import { resolveAdapterTools } from "./adapter/tool-resolution.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";
-export { materializeDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourcePaths, relativizeDeepAgentSkillSourcePaths, } from "./adapter/compat/deepagent-compat.js";
+export { materializeDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourceRootPaths, relativizeDeepAgentSkillSourcePaths, } from "./adapter/compat/deepagent-compat.js";
 export { buildAuthOmittingFetch, normalizeOpenAICompatibleInit } from "./adapter/compat/openai-compatible.js";
 export { buildToolNameMapping, createModelFacingToolNameCandidates, createModelFacingToolNameLookupCandidates, resolveModelFacingToolName, sanitizeToolNameForModel, } from "./adapter/tool/tool-name-mapping.js";
 export { computeRemainingTimeoutMs, isRetryableProviderError, resolveBindingTimeout, resolveProviderRetryPolicy, resolveStreamIdleTimeout, resolveTimeoutMs, } from "./adapter/resilience.js";
-import { getBindingAdapterKind, getBindingBuiltinToolsConfig, getBindingDeepAgentSubagents, getBindingExecutionParams, getBindingExecutionKind, getBindingFilesystemConfig, getBindingMemorySources, getBindingPrimaryModel, getBindingSkills, getBindingToolCount, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
+import { getBindingAdapterKind, getBindingBuiltinToolsConfig, getBindingDeepAgentSubagents, getBindingExecutionParams, getBindingExecutionKind, getBindingFilesystemConfig, getBindingMemorySources, getBindingPrimaryModel, getBindingSkills, getBindingSubagents, getBindingToolCount, getBindingPrimaryTools, getBindingSystemPrompt, isDeepAgentBinding, isLangChainBinding, } from "./support/compiled-binding.js";
 class DelegatedExecutionNoToolEvidenceError extends Error {
     constructor(agentId) {
         super(`Delegated agent ${agentId} completed without tool execution evidence.`);
@@ -39,6 +40,77 @@ function hasDelegatedExecutionToolEvidence(result) {
 function shouldUseConfigurableDeepAgentAssembly(binding) {
     return getBindingExecutionKind(binding) === "deepagent";
 }
+function readModelText(value) {
+    if (typeof value === "string") {
+        return value.trim();
+    }
+    if (typeof value !== "object" || value === null) {
+        return "";
+    }
+    const content = value.content;
+    if (typeof content === "string") {
+        return content.trim();
+    }
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => {
+            if (typeof part === "string")
+                return part;
+            if (typeof part === "object" && part !== null && typeof part.text === "string") {
+                return part.text;
+            }
+            return "";
+        })
+            .join("")
+            .trim();
+    }
+    return "";
+}
+function parseFirstJsonObject(value) {
+    let depth = 0;
+    let start = -1;
+    let inString = false;
+    let escaping = false;
+    for (let index = 0; index < value.length; index += 1) {
+        const char = value[index];
+        if (inString) {
+            if (escaping) {
+                escaping = false;
+            }
+            else if (char === "\\") {
+                escaping = true;
+            }
+            else if (char === "\"") {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === "\"") {
+            inString = true;
+            continue;
+        }
+        if (char === "{") {
+            if (depth === 0) {
+                start = index;
+            }
+            depth += 1;
+            continue;
+        }
+        if (char === "}" && depth > 0) {
+            depth -= 1;
+            if (depth === 0 && start >= 0) {
+                return tryParseJson(value.slice(start, index + 1));
+            }
+        }
+    }
+    return null;
+}
+function isDelegationOnlyDeepAgentBinding(binding) {
+    return isDeepAgentBinding(binding)
+        && getBindingSubagents(binding).length > 0
+        && getBindingPrimaryTools(binding).length === 0
+        && getBindingSkills(binding).length === 0;
+}
 export class AgentRuntimeAdapter {
     options;
     modelCache = new Map();
@@ -437,13 +509,17 @@ export class AgentRuntimeAdapter {
             ? resolveRunnableCheckpointer(this.options, binding)
             : undefined;
         const resolvedStore = shouldAttachDeepAgentStore(binding) ? this.options.storeResolver?.(binding) : undefined;
-        const resolvedBackend = shouldAttachDeepAgentBackend(binding) ? this.options.backendResolver?.(binding) : undefined;
         const resolvedSkills = resolveDeepAgentSkillSourcePaths({
             workspaceRoot: binding.harnessRuntime.workspaceRoot,
             runtimeRoot: binding.harnessRuntime.runtimeRoot,
             ownerId: binding.agent.id,
             skillPaths: getBindingSkills(binding),
         }) ?? [];
+        const resolvedBackend = shouldAttachDeepAgentBackend(binding)
+            ? (this.options.backendResolver?.(binding) ?? (resolvedSkills.length > 0 ? this.resolveFilesystemBackend(binding, {
+                sessionId: options.sessionId ?? options.legacySessionId,
+            }) : undefined))
+            : undefined;
         if (shouldUseConfigurableDeepAgentAssembly(binding)) {
             return this.createConfigurableDeepAgentRunnable(binding, {
                 resolvedModel,
@@ -467,7 +543,15 @@ export class AgentRuntimeAdapter {
         const subagents = inlineSubagents;
         const middleware = [
             ...(builtinTools.todos === false ? [] : [todoListMiddleware()]),
-            ...(input.resolvedSkills.length > 0 ? [createSkillsMiddleware({ backend, sources: input.resolvedSkills })] : []),
+            ...(input.resolvedSkills.length > 0 ? [createSkillsMiddleware({
+                    backend,
+                    sources: resolveDeepAgentSkillSourceRootPaths({
+                        workspaceRoot: binding.harnessRuntime.workspaceRoot,
+                        runtimeRoot: binding.harnessRuntime.runtimeRoot,
+                        ownerId: binding.agent.id,
+                        skillPaths: input.resolvedSkills,
+                    }) ?? input.resolvedSkills,
+                })] : []),
             ...(builtinTools.filesystem === false ? [] : [createFilesystemMiddleware({ backend })]),
             ...(subagents.length > 0
                 ? [createSubAgentMiddleware({
@@ -557,6 +641,36 @@ export class AgentRuntimeAdapter {
                 },
             };
         }
+        const compactDelegation = await this.tryDelegateWithCompactRouter(binding, input, sessionId, requestId, {
+            ...options,
+            sessionId,
+            requestId,
+        });
+        if (compactDelegation) {
+            const output = typeof compactDelegation.toolOutput === "string"
+                ? compactDelegation.toolOutput
+                : JSON.stringify(compactDelegation.toolOutput);
+            const delegatedToolResults = Array.isArray(compactDelegation.delegatedResult?.metadata?.executedToolResults)
+                ? compactDelegation.delegatedResult.metadata.executedToolResults
+                : [];
+            return {
+                sessionId,
+                requestId,
+                agentId: binding.agent.id,
+                state: compactDelegation.delegatedResult?.state ?? "completed",
+                output: sanitizeVisibleText(output),
+                finalMessageText: sanitizeVisibleText(output),
+                metadata: {
+                    executedToolResults: [
+                        {
+                            toolName: "task",
+                            output: compactDelegation.toolOutput,
+                        },
+                        ...delegatedToolResults,
+                    ],
+                },
+            };
+        }
         const callRuntime = async (activeBinding, activeRequest) => {
             return this.invokeWithProviderRetry(activeBinding, async () => {
                 const runnable = await this.create(activeBinding, { sessionId });
@@ -612,6 +726,74 @@ export class AgentRuntimeAdapter {
             return invokeRequest();
         }
     }
+    async tryDelegateWithCompactRouter(binding, input, sessionId, requestId, options = {}) {
+        if (!isDelegationOnlyDeepAgentBinding(binding)) {
+            return null;
+        }
+        if (!this.options.bindingResolver) {
+            return null;
+        }
+        const primaryModel = getBindingPrimaryModel(binding);
+        if (!primaryModel) {
+            return null;
+        }
+        const requestText = extractMessageText(input).trim();
+        if (!requestText) {
+            return null;
+        }
+        const subagents = getBindingSubagents(binding);
+        const subagentCatalog = subagents
+            .map((subagent) => `- ${subagent.name}: ${subagent.description}`)
+            .join("\n");
+        const prompt = [
+            primaryModel.init?.think === false ? "/no_think" : "",
+            "You are selecting a subagent for a delegation-only agent.",
+            "Choose exactly one listed subagent when it can responsibly handle the request.",
+            "Return only JSON with this shape:",
+            "{\"subagent_type\":\"<listed subagent name>\"}",
+            "If no listed subagent can handle the request, return only:",
+            "{\"status\":\"refused\",\"reason\":\"No configured subagent can handle the request.\"}",
+            "Available subagents:",
+            subagentCatalog,
+            "User request:",
+            requestText,
+        ].filter(Boolean).join("\n\n");
+        const model = await this.resolveModel(primaryModel);
+        if (typeof model.invoke !== "function") {
+            return null;
+        }
+        const raw = await this.invokeWithProviderRetry(binding, () => this.withTimeout(() => model.invoke(prompt, resolveLangChainInvocationConfig(binding, {
+            sessionId,
+            requestId,
+            context: options.context,
+            toolRuntimeContext: this.buildFunctionToolRuntimeContext(binding, {
+                ...options,
+                sessionId,
+                requestId,
+            }),
+        })), resolveBindingTimeout(binding), "delegation router invoke", "invoke"));
+        const parsed = parseFirstJsonObject(readModelText(raw));
+        if (typeof parsed !== "object" || parsed === null) {
+            return null;
+        }
+        const subagentType = typeof parsed.subagent_type === "string"
+            ? parsed.subagent_type
+            : "";
+        if (!subagents.some((subagent) => subagent.name === subagentType)) {
+            return null;
+        }
+        const selectedBinding = this.options.bindingResolver(subagentType);
+        if (!selectedBinding) {
+            return null;
+        }
+        const delegatedResult = await this.invoke(selectedBinding, requestText, sessionId, `${requestId}:${subagentType}`, undefined, [], {
+            context: options.context,
+            state: options.state,
+            files: options.files,
+            memoryContext: options.memoryContext,
+        });
+        return { toolOutput: delegatedResult.output, delegatedResult };
+    }
     async *stream(binding, input, sessionId, history = [], options = {}) {
         const directListing = await this.tryHandleDirectWorkspaceListing(binding, input, {
             ...options,
@@ -630,6 +812,25 @@ export class AgentRuntimeAdapter {
             };
             return;
         }
+        const compactDelegation = await this.tryDelegateWithCompactRouter(binding, input, sessionId, options.requestId ?? sessionId, {
+            ...options,
+            sessionId,
+            requestId: options.requestId,
+        });
+        if (compactDelegation) {
+            yield {
+                kind: "tool-result",
+                toolName: "task",
+                output: compactDelegation.toolOutput,
+            };
+            yield {
+                kind: "content",
+                content: typeof compactDelegation.toolOutput === "string"
+                    ? compactDelegation.toolOutput
+                    : JSON.stringify(compactDelegation.toolOutput),
+            };
+            return;
+        }
         const invokeTimeoutMs = resolveBindingTimeout(binding);
         const streamIdleTimeoutMs = resolveStreamIdleTimeout(binding);
         const streamDeadlineAt = invokeTimeoutMs ? Date.now() + invokeTimeoutMs : undefined;

package/dist/runtime/agent-runtime-assembly.d.ts

@@ -8,6 +8,7 @@ export declare function materializeModelExposedBuiltinMiddlewareTools(input: {
     explicitToolNames?: string[];
     modelExposed?: boolean | string[];
 }): unknown[];
+export declare function buildRuntimeTemporalContext(now?: Date): string;
 export declare function buildDeepAgentSystemPromptWithCapabilityHierarchy(input: {
     systemPrompt?: unknown;
     subagents: Array<Pick<UpstreamSubagentConfig, "name" | "description"> | Pick<CompiledAsyncSubAgent, "name" | "description">>;

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

@@ -53,6 +53,21 @@ function buildSkillCatalog(skillPaths) {
         };
     });
 }
+export function buildRuntimeTemporalContext(now = new Date()) {
+    const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone || "system local time";
+    return [
+        "Runtime temporal context:",
+        `- Current date/time: ${now.toISOString()}`,
+        `- Local time zone: ${timeZone}`,
+        "Use the runtime date/time above as authoritative for interpreting current, latest, recent, today, tomorrow, yesterday, and tool-returned dates.",
+        "Do not reject tool evidence as future-dated solely because it is newer than the model's training data.",
+    ].join("\n");
+}
+function appendRuntimeTemporalContext(systemPrompt) {
+    return [typeof systemPrompt === "string" ? systemPrompt : undefined, buildRuntimeTemporalContext()]
+        .filter((part) => typeof part === "string" && part.length > 0)
+        .join("\n\n");
+}
 export function buildDeepAgentSystemPromptWithCapabilityHierarchy(input) {
     const basePrompt = typeof input.systemPrompt === "string" ? input.systemPrompt : undefined;
     const skills = buildSkillCatalog(input.skills ?? []);
@@ -122,7 +137,7 @@ export function buildDeepAgentSystemPromptWithCapabilityHierarchy(input) {
             : []),
         "",
     ].join("\n");
-    return [basePrompt, catalogPrompt].filter((part) => typeof part === "string" && part.length > 0).join("\n\n");
+    return appendRuntimeTemporalContext([basePrompt, catalogPrompt].filter((part) => typeof part === "string" && part.length > 0).join("\n\n"));
 }
 export const buildDeepAgentSystemPromptWithSubagentCatalog = buildDeepAgentSystemPromptWithCapabilityHierarchy;
 export function resolveRunnableCheckpointer(options, binding) {
@@ -175,7 +190,7 @@ export function buildLangChainCreateParams(input) {
         ...(legacyPassthrough ?? {}),
         ...(langchainPassthrough ?? {}),
         ...(input.passthroughOverride ?? {}),
-        systemPrompt: input.systemPromptOverride ?? executionParams.systemPrompt,
+        systemPrompt: appendRuntimeTemporalContext(input.systemPromptOverride ?? executionParams.systemPrompt),
         model: input.resolvedModel,
         tools: input.resolvedTools,
         middleware: input.resolvedMiddleware,

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

@@ -517,6 +517,15 @@ function createProfileStepCommentary(step) {
     if (step.kind === "memory") {
         return `Checking memory ${name}.`;
     }
+    if (step.kind === "agent" && step.action === "invoke") {
+        return "Running model invocation.";
+    }
+    if (step.kind === "agent" && step.action === "start") {
+        return "Starting runtime stream.";
+    }
+    if (step.kind === "agent" && step.action === "startup") {
+        return `Preparing ${name}.`;
+    }
     return null;
 }
 function isOpenAICompatibleStreamingCompatibilityError(binding, error) {
@@ -1083,8 +1092,9 @@ export async function* streamHarnessRun(options) {
             visibleOutput: assistantOutput,
             executedToolResults,
         });
-        if (!assistantOutput && sawSuccessfulToolResult && deterministicToolEvidenceOutput) {
-            const terminalStructuredStatus = readTerminalExecutionStatus(deterministicToolEvidenceOutput);
+        const terminalStructuredStatus = readTerminalExecutionStatus(deterministicToolEvidenceOutput);
+        const canUseDeterministicToolEvidenceOutput = !currentPlanState || !planStateHasActiveItems(currentPlanState) || Boolean(terminalStructuredStatus);
+        if (!assistantOutput && sawSuccessfulToolResult && deterministicToolEvidenceOutput && canUseDeterministicToolEvidenceOutput) {
             if (terminalStructuredStatus && currentPlanState && planStateHasActiveItems(currentPlanState)) {
                 const reconciledPlanState = reconcilePlanStateToTerminalStatus(currentPlanState, mapTerminalStatusToPlanItemStatus(terminalStructuredStatus), new Date().toISOString());
                 const signature = buildPlanStateSignature(reconciledPlanState);

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

@@ -59,6 +59,9 @@ function consumeLeadingFunctionLikeToolCall(value) {
 function stripVisibleFunctionLikeToolCallText(value) {
     let remaining = value.trim();
     let removedLeadingCall = false;
+    if (salvageJsonToolCalls(remaining).length > 0) {
+        return "";
+    }
     while (remaining.length > 0) {
         const consumed = consumeLeadingFunctionLikeToolCall(remaining);
         if (!consumed) {
@@ -84,6 +87,7 @@ function stripVisibleFunctionLikeToolCallText(value) {
 }
 export function sanitizeVisibleText(value) {
     return stripVisibleFunctionLikeToolCallText(value
+        .replace(/<agent_memory>[\s\S]*?<\/agent_memory>/giu, "")
         .replace(/[A-Za-z0-9_]*Middleware\.after_model/g, "")
         .replace(/todoListMiddleware\.after_model/g, "")
         .replace(/__end__+/g, "")

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

@@ -205,6 +205,43 @@ function closeJsonContainerSuffix(value) {
     }
     return `${trimmed}${stack.reverse().join("")}`;
 }
+function normalizePythonLikeJson(value) {
+    const trimmed = value.trim();
+    if (!trimmed.includes("'")) {
+        return null;
+    }
+    let output = "";
+    let inSingle = false;
+    let inDouble = false;
+    let escaping = false;
+    for (const char of trimmed) {
+        if (escaping) {
+            output += char;
+            escaping = false;
+            continue;
+        }
+        if (char === "\\") {
+            output += char;
+            escaping = true;
+            continue;
+        }
+        if (char === "\"" && !inSingle) {
+            inDouble = !inDouble;
+            output += char;
+            continue;
+        }
+        if (char === "'" && !inDouble) {
+            inSingle = !inSingle;
+            output += "\"";
+            continue;
+        }
+        output += char;
+    }
+    if (inSingle || inDouble) {
+        return null;
+    }
+    return output;
+}
 export function salvageToolArgs(value) {
     if (typeof value === "object" && value && !Array.isArray(value)) {
         return value;
@@ -255,6 +292,13 @@ export function salvageJsonToolCalls(value) {
             if (direct) {
                 return direct;
             }
+            const pythonLike = normalizePythonLikeJson(trimmed);
+            if (pythonLike) {
+                const parsed = tryParseJson(pythonLike);
+                if (parsed) {
+                    return parsed;
+                }
+            }
             const closed = closeJsonContainerSuffix(trimmed);
             if (closed) {
                 const parsed = tryParseJson(closed);

package/package.json

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