@botbotgo/agent-harness 0.0.346 → 0.0.348

package/dist/contracts/runtime-requests.d.ts

@@ -17,6 +17,7 @@ export type RequestResult = {
     artifacts?: ArtifactRecord[];
     metadata?: Record<string, unknown>;
 };
+export type TerminalExecutionStatus = "completed" | "blocked" | "failed" | "refused";
 export type UpstreamRuntimeEvent = unknown;
 export type UpstreamRuntimeEventItem = {
     sessionId: string;

package/dist/contracts/workspace.d.ts

@@ -203,6 +203,9 @@ export type CompiledBuiltinToolsConfig = {
     todos?: boolean;
     modelExposed?: boolean | string[];
 };
+export type CompiledExecutionContract = {
+    requiresPlan?: boolean;
+};
 export type LangChainAgentParams = {
     model: CompiledModel;
     tools: CompiledTool[];
@@ -287,6 +290,7 @@ export type CompiledAgentBinding = {
         resilience?: Record<string, unknown>;
         governance?: Record<string, unknown>;
         observability?: Record<string, unknown>;
+        executionContract?: CompiledExecutionContract;
         deepagent?: {
             description?: string;
             passthrough?: Record<string, unknown>;

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.346";
+export declare const AGENT_HARNESS_VERSION = "0.0.348";
 export declare const AGENT_HARNESS_RELEASE_DATE = "2026-04-24";

package/dist/package-version.js

@@ -1,2 +1,2 @@
-export const AGENT_HARNESS_VERSION = "0.0.346";
+export const AGENT_HARNESS_VERSION = "0.0.348";
 export const AGENT_HARNESS_RELEASE_DATE = "2026-04-24";

package/dist/resource/backend/workspace-scoped-backend.d.ts

@@ -1,15 +1,20 @@
 import { CompositeBackend } from "deepagents";
 import type { RuntimeAdapterOptions, WorkspaceBundle } from "../../contracts/types.js";
-export declare function normalizeWorkspaceScopedPath(rootDir: string, inputPath: string): string;
+export declare function normalizeWorkspaceScopedPath(rootDir: string, inputPath: string, options?: {
+    allowVirtualAbsolutePath?: boolean;
+}): string;
 export declare class WorkspaceScopedBackend {
     private readonly backend;
+    private readonly options;
     readonly id?: string;
     readonly cwd: string;
     readonly rootDir: string;
     readonly root: string;
     readonly virtualMode?: boolean;
     readonly execute?: (command: string) => Promise<unknown>;
-    constructor(backend: Record<string, unknown>, rootDir: string);
+    constructor(backend: Record<string, unknown>, rootDir: string, options?: {
+        allowVirtualAbsolutePath?: boolean;
+    });
     ls(filePath: string): unknown;
     read(filePath: string, offset?: number, limit?: number): unknown;
     readRaw(filePath: string): unknown;
@@ -25,7 +30,9 @@ declare class CompatibleCompositeBackend {
     readonly id?: string;
     readonly execute?: (command: string) => ReturnType<CompositeBackend["execute"]>;
     private readonly composite;
+    private readonly routePrefixes;
     constructor(defaultBackend: unknown, routes: Record<string, unknown>);
+    private normalizeCompositePath;
     ls(filePath: string): ReturnType<CompositeBackend["ls"]>;
     read(filePath: string, offset?: number, limit?: number): ReturnType<CompositeBackend["read"]>;
     readRaw(filePath: string): ReturnType<CompositeBackend["readRaw"]>;

package/dist/resource/backend/workspace-scoped-backend.js

@@ -30,7 +30,7 @@ function normalizeVirtualExecuteCommand(command, rootDir) {
         return `${prefix}${quote}${translatedPath}${quote}`;
     });
 }
-export function normalizeWorkspaceScopedPath(rootDir, inputPath) {
+export function normalizeWorkspaceScopedPath(rootDir, inputPath, options = {}) {
     if (typeof inputPath !== "string" || inputPath.length === 0 || !path.isAbsolute(inputPath)) {
         return inputPath;
     }
@@ -53,21 +53,26 @@ export function normalizeWorkspaceScopedPath(rootDir, inputPath) {
     if (normalizedInputPath === normalizedRootDir || normalizedInputPath.startsWith(`${normalizedRootDir}${path.sep}`)) {
         return path.relative(normalizedRootDir, normalizedInputPath) || ".";
     }
+    if (options.allowVirtualAbsolutePath === true) {
+        return inputPath.replace(/\/+/g, "/");
+    }
     throw new Error(`Path '${inputPath}' is outside the workspace root '${normalizedRootDir}'. Use a workspace-relative path instead.`);
 }
-function normalizeWorkspaceScopedNullablePath(rootDir, inputPath) {
-    return typeof inputPath === "string" ? normalizeWorkspaceScopedPath(rootDir, inputPath) : inputPath;
+function normalizeWorkspaceScopedNullablePath(rootDir, inputPath, options = {}) {
+    return typeof inputPath === "string" ? normalizeWorkspaceScopedPath(rootDir, inputPath, options) : inputPath;
 }
 export class WorkspaceScopedBackend {
     backend;
+    options;
     id;
     cwd;
     rootDir;
     root;
     virtualMode;
     execute;
-    constructor(backend, rootDir) {
+    constructor(backend, rootDir, options = {}) {
         this.backend = backend;
+        this.options = options;
         this.rootDir = path.resolve(rootDir);
         this.root = this.rootDir;
         this.cwd = this.rootDir;
@@ -78,34 +83,36 @@ export class WorkspaceScopedBackend {
             : undefined;
     }
     ls(filePath) {
-        return this.backend.ls(normalizeWorkspaceScopedPath(this.rootDir, filePath));
+        return this.backend.ls(normalizeWorkspaceScopedPath(this.rootDir, filePath, this.options));
     }
     read(filePath, offset, limit) {
-        return this.backend.read(normalizeWorkspaceScopedPath(this.rootDir, filePath), offset, limit);
+        return this.backend.read(normalizeWorkspaceScopedPath(this.rootDir, filePath, this.options), offset, limit);
     }
     readRaw(filePath) {
-        return this.backend.readRaw(normalizeWorkspaceScopedPath(this.rootDir, filePath));
+        return this.backend.readRaw(normalizeWorkspaceScopedPath(this.rootDir, filePath, this.options));
     }
     grep(pattern, filePath, glob) {
-        return this.backend.grep(pattern, normalizeWorkspaceScopedNullablePath(this.rootDir, filePath), glob);
+        return this.backend.grep(pattern, normalizeWorkspaceScopedNullablePath(this.rootDir, filePath, this.options), glob);
     }
     grepRaw(pattern, filePath, glob) {
-        return this.backend.grepRaw(pattern, normalizeWorkspaceScopedNullablePath(this.rootDir, filePath), glob);
+        return this.backend.grepRaw(pattern, normalizeWorkspaceScopedNullablePath(this.rootDir, filePath, this.options), glob);
     }
     glob(pattern, filePath) {
-        return this.backend.glob(pattern, typeof filePath === "string" ? normalizeWorkspaceScopedPath(this.rootDir, filePath) : filePath);
+        return this.backend.glob(pattern, typeof filePath === "string" ? normalizeWorkspaceScopedPath(this.rootDir, filePath, this.options) : filePath);
     }
     write(filePath, content) {
-        return this.backend.write(normalizeWorkspaceScopedPath(this.rootDir, filePath), content);
+        return this.backend.write(normalizeWorkspaceScopedPath(this.rootDir, filePath, this.options), content);
     }
     edit(filePath, oldString, newString, replaceAll) {
-        return this.backend.edit(normalizeWorkspaceScopedPath(this.rootDir, filePath), oldString, newString, replaceAll);
+        return this.backend.edit(normalizeWorkspaceScopedPath(this.rootDir, filePath, this.options), oldString, newString, replaceAll);
     }
     uploadFiles(files) {
         return this.backend.uploadFiles(files);
     }
     downloadFiles(paths) {
-        const normalizedPaths = Array.isArray(paths) ? paths.map((currentPath) => normalizeWorkspaceScopedPath(this.rootDir, currentPath)) : paths;
+        const normalizedPaths = Array.isArray(paths)
+            ? paths.map((currentPath) => normalizeWorkspaceScopedPath(this.rootDir, currentPath, this.options))
+            : paths;
         return this.backend.downloadFiles(normalizedPaths);
     }
 }
@@ -113,8 +120,10 @@ class CompatibleCompositeBackend {
     id;
     execute;
     composite;
+    routePrefixes;
     constructor(defaultBackend, routes) {
         this.composite = new CompositeBackend(defaultBackend, routes);
+        this.routePrefixes = Object.keys(routes).filter((route) => route.startsWith("/"));
         const sandboxLike = defaultBackend;
         if (typeof sandboxLike.id === "string" && typeof sandboxLike.execute === "function") {
             this.id = sandboxLike.id;
@@ -125,32 +134,43 @@ class CompatibleCompositeBackend {
                     : (command) => this.composite.execute(command);
         }
     }
+    normalizeCompositePath(filePath) {
+        if (!path.isAbsolute(filePath)) {
+            return filePath;
+        }
+        const normalized = filePath.replace(/\/+/g, "/");
+        if (this.routePrefixes.some((route) => normalized === route || normalized.startsWith(route))) {
+            return normalized;
+        }
+        return path.join(...normalized.split("/").filter(Boolean));
+    }
     ls(filePath) {
-        return this.composite.ls(filePath);
+        return this.composite.ls(this.normalizeCompositePath(filePath));
     }
     read(filePath, offset, limit) {
-        return this.composite.read(filePath, offset, limit);
+        return this.composite.read(this.normalizeCompositePath(filePath), offset, limit);
     }
     readRaw(filePath) {
-        return this.composite.readRaw(filePath);
+        return this.composite.readRaw(this.normalizeCompositePath(filePath));
     }
     grep(pattern, filePath, glob) {
-        return this.composite.grep(pattern, filePath ?? undefined, glob ?? undefined);
+        return this.composite.grep(pattern, filePath ? this.normalizeCompositePath(filePath) : undefined, glob ?? undefined);
     }
     glob(pattern, filePath) {
-        return this.composite.glob(pattern, filePath);
+        return this.composite.glob(pattern, filePath ? this.normalizeCompositePath(filePath) : filePath);
     }
     write(filePath, content) {
-        return this.composite.write(filePath, content);
+        return this.composite.write(this.normalizeCompositePath(filePath), content);
     }
     edit(filePath, oldString, newString, replaceAll) {
-        return this.composite.edit(filePath, oldString, newString, replaceAll);
+        return this.composite.edit(this.normalizeCompositePath(filePath), oldString, newString, replaceAll);
     }
     uploadFiles(files) {
         return this.composite.uploadFiles(files);
     }
     downloadFiles(paths) {
-        return this.composite.downloadFiles(paths);
+        const normalizedPaths = Array.isArray(paths) ? paths.map((currentPath) => this.normalizeCompositePath(currentPath)) : paths;
+        return this.composite.downloadFiles(normalizedPaths);
     }
 }
 function omitKind(config) {
@@ -289,7 +309,7 @@ export function createInlineBackendResolver(workspace) {
                         const routeKind = typeof routeConfig?.kind === "string" ? routeConfig.kind : "StoreBackend";
                         return [route, createInlineBackendInstance(workspace.workspaceRoot, routeKind, routeConfig, runtimeLike)];
                     }));
-                    return new WorkspaceScopedBackend(new CompatibleCompositeBackend(createInlineBackendInstance(workspace.workspaceRoot, defaultBackendKind, stateConfig, runtimeLike), mappedRoutes), workspace.workspaceRoot);
+                    return new WorkspaceScopedBackend(new CompatibleCompositeBackend(createInlineBackendInstance(workspace.workspaceRoot, defaultBackendKind, stateConfig, runtimeLike), mappedRoutes), workspace.workspaceRoot, { allowVirtualAbsolutePath: true });
                 }
                 default:
                     return unsupportedInlineBackend(kind);

package/dist/resources/prompts/runtime/delegated-task-failure-recovery.md

@@ -0,0 +1,8 @@
+The delegated task failed. You are the routing/delegation parent agent, so you must not switch into local execution or start a new local plan.
+
+Your next response has only two valid forms:
+
+1. Call the `task` tool again, preserving the user's original request and delegating to the same specialist or another explicit specialist whose configured responsibility clearly matches the original request.
+2. Return a final blocker report to the user explaining that delegated execution failed.
+
+Do not call local execution tools, repository tools, web tools, shell tools, or `write_todos` from the parent agent after this delegated failure. Do not invent a new topic or downgrade the original request. If you continue execution, it must be through `task`.

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

@@ -1,4 +1,5 @@
 import { extractVisibleOutput, isToolCallRecoveryFailure, isRetrySafeInvalidToolSelectionError, resolveMissingPlanRecoveryInstruction, resolveExecutionWithoutToolEvidenceTextInstruction, shouldValidateExecutionWithoutToolEvidence, resolveToolCallRecoveryInstruction, sanitizeVisibleText, EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION, INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION, } from "../../parsing/output-parsing.js";
+import { DELEGATED_TASK_FAILURE_RECOVERY_INSTRUCTION } from "../../prompts/runtime-prompts.js";
 import { buildInvocationRequest } from "../model/invocation-request.js";
 import { buildRawModelMessages } from "../model/message-assembly.js";
 import { projectRuntimeStreamEvent, createStreamEventProjectionState } from "../stream-event-projection.js";
@@ -55,6 +56,18 @@ function hasSuccessfulNonTodoToolEvidence(executedToolResults) {
 function hasSuccessfulTaskToolEvidence(executedToolResults) {
     return executedToolResults.some((item) => item.isError !== true && item.toolName === "task");
 }
+function requiresPlanEvidence(binding) {
+    return binding.harnessRuntime?.executionContract?.requiresPlan === true;
+}
+function hasParentLocalToolExecutionAfterDelegationFailure(originalEvidence, executedToolResults) {
+    return originalEvidence.hasFailedTaskDelegation
+        && executedToolResults.some((item) => item.toolName !== "task");
+}
+function isDelegationFailureFinalReport(originalEvidence, executedToolResults, visibleOutput) {
+    return originalEvidence.hasFailedTaskDelegation
+        && executedToolResults.length === 0
+        && visibleOutput.trim().length > 0;
+}
 function buildExecutionRecoveryEvidence(params) {
     const { projectionState, executedToolResults = [] } = params;
     return {
@@ -65,7 +78,8 @@ function buildExecutionRecoveryEvidence(params) {
         hasIncompletePlanState: projectionState.hasIncompletePlanState || hasIncompletePlanStateInExecutedToolResults(executedToolResults),
         hasPlanStateEvidence: projectionState.sawPlanState || hasIncompletePlanStateInExecutedToolResults(executedToolResults),
         hasOpenTaskDelegation: projectionState.openTaskDelegations > 0,
-        hasFailedTaskDelegation: projectionState.hasFailedTaskDelegation,
+        hasFailedTaskDelegation: projectionState.hasFailedTaskDelegation
+            || executedToolResults.some((item) => item.toolName === "task" && item.isError === true),
         hasDelegatedAgentWithConfiguredTools: projectionState.sawDelegatedAgentWithConfiguredTools,
         hasDelegatedExecutionToolEvidence: projectionState.emittedDelegatedExecutionToolResult,
         hasOnlyPlaceholderTaskCompletion: projectionState.emittedSuccessfulTaskResult
@@ -98,6 +112,9 @@ function resolveStreamedRuntimeFailureRecoveryInstruction(output, evidence) {
     return hasExecutionEvidence ? null : EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION;
 }
 function resolveDelegatedExecutionRecoveryInstruction(evidence) {
+    if (evidence.hasFailedTaskDelegation) {
+        return DELEGATED_TASK_FAILURE_RECOVERY_INSTRUCTION;
+    }
     if (hasMissingDelegatedFindings(evidence)
         || (evidence.hasOpenTaskDelegation
             && evidence.hasDelegatedAgentWithConfiguredTools
@@ -400,6 +417,7 @@ export async function* streamRuntimeExecution(options) {
                             ? resolveMissingPlanRecoveryInstruction({
                                 request,
                                 assistantText: terminalVisibleOutput,
+                                requiresPlan: requiresPlanEvidence(options.binding),
                                 hasPlanStateEvidence: terminalExecutionEvidence.hasPlanStateEvidence,
                                 hasWriteTodosEvidence: terminalExecutionEvidence.hasPlanStateEvidence,
                                 hasToolResultEvidence: terminalExecutionEvidence.hasSuccessfulNonTodoToolResultEvidence,
@@ -443,8 +461,9 @@ export async function* streamRuntimeExecution(options) {
                 throw error;
             }
             const streamedExecutionEvidence = buildExecutionRecoveryEvidence({ projectionState });
-            const delegatedExecutionRecoveryInstruction = !emittedUnsafeStreamSideEffects
-                ? resolveDelegatedExecutionRecoveryInstruction(streamedExecutionEvidence)
+            const streamedDelegatedRecoveryInstruction = resolveDelegatedExecutionRecoveryInstruction(streamedExecutionEvidence);
+            const delegatedExecutionRecoveryInstruction = !emittedUnsafeStreamSideEffects || streamedDelegatedRecoveryInstruction
+                ? streamedDelegatedRecoveryInstruction
                 : null;
             if (hasUnresolvedExecution(streamedExecutionEvidence) && !delegatedExecutionRecoveryInstruction) {
                 throw createUnresolvedExecutionError(streamedExecutionEvidence);
@@ -453,6 +472,7 @@ export async function* streamRuntimeExecution(options) {
                 ? resolveExecutionWithoutToolEvidenceTextInstruction(request, projectionState.emittedOutput, false, {
                     ...streamedExecutionEvidence,
                     hasMissingDelegatedExecutionEvidence: hasMissingDelegatedExecutionEvidence(streamedExecutionEvidence),
+                    requiresPlan: requiresPlanEvidence(options.binding),
                 })
                 : null;
             const streamedRuntimeFailureRecoveryInstruction = projectionState.emittedOutput
@@ -462,6 +482,7 @@ export async function* streamRuntimeExecution(options) {
                 ? resolveMissingPlanRecoveryInstruction({
                     request,
                     assistantText: projectionState.emittedOutput,
+                    requiresPlan: requiresPlanEvidence(options.binding),
                     hasPlanStateEvidence: streamedExecutionEvidence.hasPlanStateEvidence,
                     hasWriteTodosEvidence: streamedExecutionEvidence.hasPlanStateEvidence,
                     hasToolResultEvidence: streamedExecutionEvidence.hasSuccessfulNonTodoToolResultEvidence,
@@ -484,17 +505,22 @@ export async function* streamRuntimeExecution(options) {
                     projectionState: createStreamEventProjectionState(),
                     executedToolResults,
                 });
+                if (hasParentLocalToolExecutionAfterDelegationFailure(originalExecutionEvidence, executedToolResults)) {
+                    throw new ExecutionReconciliationError("Agent attempted parent-local tool execution after delegated task failure; it must report a blocker or re-delegate with task.");
+                }
                 const retriedVisibleOutput = retried.output ? toVisibleContent(retried.output) : "";
+                const retriedIsDelegationFailureFinalReport = isDelegationFailureFinalReport(originalExecutionEvidence, executedToolResults, retriedVisibleOutput);
                 const retriedCarriesExecutionEvidence = retriedExecutionEvidence.hasToolResultEvidence
                     || retriedExecutionEvidence.hasOpenTaskDelegation
                     || retriedExecutionEvidence.hasDelegatedExecutionToolEvidence;
-                const retriedHasUnresolvedExecution = hasUnresolvedExecution(retriedExecutionEvidence)
-                    || hasMissingDelegatedExecutionEvidence(retriedExecutionEvidence)
-                    || hasMissingDelegatedFindings(retriedExecutionEvidence)
-                    || (!retriedCarriesExecutionEvidence
-                        && (hasUnresolvedExecution(originalExecutionEvidence)
-                            || hasMissingDelegatedExecutionEvidence(originalExecutionEvidence)
-                            || hasMissingDelegatedFindings(originalExecutionEvidence)));
+                const retriedHasUnresolvedExecution = !retriedIsDelegationFailureFinalReport
+                    && (hasUnresolvedExecution(retriedExecutionEvidence)
+                        || hasMissingDelegatedExecutionEvidence(retriedExecutionEvidence)
+                        || hasMissingDelegatedFindings(retriedExecutionEvidence)
+                        || (!retriedCarriesExecutionEvidence
+                            && (hasUnresolvedExecution(originalExecutionEvidence)
+                                || hasMissingDelegatedExecutionEvidence(originalExecutionEvidence)
+                                || hasMissingDelegatedFindings(originalExecutionEvidence))));
                 const effectiveRecoveryEvidence = retriedCarriesExecutionEvidence
                     ? retriedExecutionEvidence
                     : {
@@ -666,18 +692,21 @@ export async function* streamRuntimeExecution(options) {
             ? resolveExecutionWithoutToolEvidenceTextInstruction(request, result.output, false, {
                 ...invokeExecutionEvidence,
                 hasMissingDelegatedExecutionEvidence: hasMissingDelegatedExecutionEvidence(invokeExecutionEvidence),
+                requiresPlan: requiresPlanEvidence(options.binding),
             })
             : resolveDelegatedExecutionRecoveryInstruction(invokeExecutionEvidence);
         const invokeFallbackMissingPlanRecoveryInstruction = !hasUnresolvedExecution(invokeExecutionEvidence) && !invokeFallbackRecoveryInstruction
             ? resolveMissingPlanRecoveryInstruction({
                 request,
                 assistantText: typeof result.output === "string" ? result.output : "",
+                requiresPlan: requiresPlanEvidence(options.binding),
                 hasPlanStateEvidence: invokeExecutionEvidence.hasPlanStateEvidence,
                 hasWriteTodosEvidence: invokeExecutionEvidence.hasPlanStateEvidence,
                 hasToolResultEvidence: invokeExecutionEvidence.hasSuccessfulNonTodoToolResultEvidence,
             })
             : null;
-        const effectiveInvokeFallbackRecoveryInstruction = invokeFallbackMissingPlanRecoveryInstruction ?? invokeFallbackRecoveryInstruction;
+        const effectiveInvokeFallbackRecoveryInstruction = invokeFallbackMissingPlanRecoveryInstruction
+            ?? invokeFallbackRecoveryInstruction;
         if (effectiveInvokeFallbackRecoveryInstruction) {
             const recovered = await options.invoke(options.applyToolRecoveryInstruction(options.binding, effectiveInvokeFallbackRecoveryInstruction), options.input, options.sessionId, options.runtimeOptions.requestId ?? options.sessionId, undefined, options.history, options.runtimeOptions);
             const recoveredToolResults = Array.isArray(recovered.metadata?.executedToolResults)
@@ -688,17 +717,22 @@ export async function* streamRuntimeExecution(options) {
                 projectionState: createStreamEventProjectionState(),
                 executedToolResults: recoveredToolResults,
             });
+            if (hasParentLocalToolExecutionAfterDelegationFailure(originalExecutionEvidence, recoveredToolResults)) {
+                throw new ExecutionReconciliationError("Agent attempted parent-local tool execution after delegated task failure; it must report a blocker or re-delegate with task.");
+            }
             const recoveredVisibleOutput = recovered.output ? toVisibleContent(recovered.output) : "";
+            const recoveredIsDelegationFailureFinalReport = isDelegationFailureFinalReport(originalExecutionEvidence, recoveredToolResults, recoveredVisibleOutput);
             const recoveredCarriesExecutionEvidence = recoveredExecutionEvidence.hasToolResultEvidence
                 || recoveredExecutionEvidence.hasOpenTaskDelegation
                 || recoveredExecutionEvidence.hasDelegatedExecutionToolEvidence;
-            const recoveredHasUnresolvedExecution = hasUnresolvedExecution(recoveredExecutionEvidence)
-                || hasMissingDelegatedExecutionEvidence(recoveredExecutionEvidence)
-                || hasMissingDelegatedFindings(recoveredExecutionEvidence)
-                || (!recoveredCarriesExecutionEvidence
-                    && (hasUnresolvedExecution(originalExecutionEvidence)
-                        || hasMissingDelegatedExecutionEvidence(originalExecutionEvidence)
-                        || hasMissingDelegatedFindings(originalExecutionEvidence)));
+            const recoveredHasUnresolvedExecution = !recoveredIsDelegationFailureFinalReport
+                && (hasUnresolvedExecution(recoveredExecutionEvidence)
+                    || hasMissingDelegatedExecutionEvidence(recoveredExecutionEvidence)
+                    || hasMissingDelegatedFindings(recoveredExecutionEvidence)
+                    || (!recoveredCarriesExecutionEvidence
+                        && (hasUnresolvedExecution(originalExecutionEvidence)
+                            || hasMissingDelegatedExecutionEvidence(originalExecutionEvidence)
+                            || hasMissingDelegatedFindings(originalExecutionEvidence))));
             const effectiveRecoveredEvidence = recoveredCarriesExecutionEvidence
                 ? recoveredExecutionEvidence
                 : {

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

@@ -3,6 +3,7 @@ import { salvageFunctionLikeToolCall } from "../parsing/output-tool-args.js";
 import { buildStateSnapshot } from "./model/message-assembly.js";
 import { asRecord } from "./tool/resolved-tool.js";
 import { renderToolFailure } from "../support/harness-support.js";
+import { mapTerminalStatusToRequestState, readTerminalExecutionStatus } from "./terminal-status.js";
 function looksLikeLeakedToolCallText(value) {
     const normalized = sanitizeVisibleText(value).trim();
     if (!normalized) {
@@ -168,6 +169,29 @@ function extractDeterministicToolFailureReport(executedToolResults) {
         "- none",
     ].join("\n");
 }
+function hasEmptyFinalMessage(result) {
+    const messages = Array.isArray(result.messages) ? result.messages : [];
+    const lastMessage = messages.at(-1);
+    if (!lastMessage || typeof lastMessage !== "object") {
+        return false;
+    }
+    const direct = lastMessage;
+    return direct.content === "" || direct.kwargs?.content === "" || direct.lc_kwargs?.content === "";
+}
+function hasFinalMessageToolCalls(result) {
+    const messages = Array.isArray(result.messages) ? result.messages : [];
+    const lastMessage = messages.at(-1);
+    if (!lastMessage || typeof lastMessage !== "object") {
+        return false;
+    }
+    const direct = lastMessage;
+    return Array.isArray(direct.tool_calls) && direct.tool_calls.length > 0
+        || Array.isArray(direct.invalid_tool_calls) && direct.invalid_tool_calls.length > 0
+        || Array.isArray(direct.kwargs?.tool_calls) && direct.kwargs.tool_calls.length > 0
+        || Array.isArray(direct.kwargs?.invalid_tool_calls) && direct.kwargs.invalid_tool_calls.length > 0
+        || Array.isArray(direct.lc_kwargs?.tool_calls) && direct.lc_kwargs.tool_calls.length > 0
+        || Array.isArray(direct.lc_kwargs?.invalid_tool_calls) && direct.lc_kwargs.invalid_tool_calls.length > 0;
+}
 export function resolveDeterministicFinalOutput(params) {
     const visibleOutput = params.visibleOutput ?? "";
     const toolFallback = params.toolFallback ?? "";
@@ -178,6 +202,9 @@ export function resolveDeterministicFinalOutput(params) {
     const deterministicFailureReport = extractDeterministicToolFailureReport(executedToolResults);
     const delegatedTaskOutput = extractLatestSuccessfulTaskResultText(executedToolResults);
     const successfulToolOutput = extractLatestSuccessfulNonTodoToolResultText(executedToolResults);
+    if (sanitizedVisibleOutput && deterministicFailureReport && hasDelegationBlocker(executedToolResults) && !successfulToolOutput) {
+        return deterministicFailureReport;
+    }
     if (sanitizedVisibleOutput && successfulToolOutput && hasDelegationBlocker(executedToolResults)) {
         return deterministicFailureReport || delegatedTaskOutput || successfulToolOutput;
     }
@@ -215,9 +242,26 @@ export function finalizeRequestResult(params) {
     const visibleOutput = extractedOutput && !isLikelyToolArgsObject(tryParseJson(extractedOutput)) ? extractedOutput : "";
     const emptyAssistantMessageFailure = extractEmptyAssistantMessageFailure(result);
     const toolFallback = extractToolFallbackContext(result);
+    const outputContent = extractOutputContent(result);
+    const contentBlocks = extractContentBlocks(result);
+    const structuredResponse = result.structuredResponse;
+    const structuredTerminalStatus = readTerminalExecutionStatus(structuredResponse) ?? readTerminalExecutionStatus(result);
+    const files = asRecord(result.files);
     if (!visibleOutput && !toolFallback && emptyAssistantMessageFailure) {
         throw new Error(emptyAssistantMessageFailure);
     }
+    if (!visibleOutput
+        && !toolFallback
+        && interruptContent === undefined
+        && outputContent === undefined
+        && contentBlocks.length === 0
+        && structuredResponse === undefined
+        && !files
+        && executedToolResults.length === 0
+        && hasEmptyFinalMessage(result)
+        && !hasFinalMessageToolCalls(result)) {
+        throw new Error("empty_final_output");
+    }
     const serializedResult = JSON.stringify(result, null, 2);
     const output = resolveDeterministicFinalOutput({
         visibleOutput,
@@ -226,17 +270,16 @@ export function finalizeRequestResult(params) {
     })
         || (containsLikelySkillDocument(result) ? "" : serializedResult);
     const finalMessageText = sanitizeVisibleText(output);
-    const outputContent = extractOutputContent(result);
-    const contentBlocks = extractContentBlocks(result);
-    const structuredResponse = result.structuredResponse;
-    const files = asRecord(result.files);
+    const terminalStatus = structuredTerminalStatus ?? readTerminalExecutionStatus(finalMessageText);
     const stateSnapshot = buildStateSnapshot(result);
     const memoryCandidates = executedToolResults.flatMap((toolResult) => toolResult.memoryCandidates ?? []);
     return {
         sessionId,
         requestId,
         agentId: bindingAgentId,
-        state: Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0 ? "waiting_for_approval" : "completed",
+        state: Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0
+            ? "waiting_for_approval"
+            : mapTerminalStatusToRequestState(terminalStatus),
         interruptContent,
         output: finalMessageText,
         finalMessageText,
@@ -247,6 +290,7 @@ export function finalizeRequestResult(params) {
             ...(executedToolResults.length > 0 ? { executedToolResults } : {}),
             ...(memoryCandidates.length > 0 ? { memoryCandidates } : {}),
             ...(structuredResponse !== undefined ? { structuredResponse } : {}),
+            ...(terminalStatus ? { terminalStatus } : {}),
             ...(outputContent !== undefined ? { outputContent } : {}),
             ...(contentBlocks.length > 0 ? { contentBlocks } : {}),
             ...(files ? { files } : {}),

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

@@ -43,6 +43,9 @@ function hasNonTodoToolEvidence(executedToolResults) {
 function hasPlanStateEvidence(executedToolResults) {
     return executedToolResults.some((item) => item.toolName === "write_todos" || item.toolName === "read_todos" || readPlanStateSummary(item.output) !== null);
 }
+function requiresPlanEvidence(binding) {
+    return binding.harnessRuntime.executionContract?.requiresPlan === true;
+}
 function extractLatestUserInput(request) {
     const typedRequest = request;
     const messages = Array.isArray(typedRequest.messages) ? typedRequest.messages : [];
@@ -87,6 +90,7 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
                     hasToolResultEvidence: hasExecutionBeyondTodoPlanning,
                     hasPlanStateEvidence: hasPlanStateEvidence(executedToolResults),
                     hasIncompletePlanState: hasExecutionBeyondTodoPlanning && hasIncompletePlanState,
+                    requiresPlan: requiresPlanEvidence(binding),
                 })
                 : hasIncompletePlanState && hasExecutionBeyondTodoPlanning
                     ? AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION
@@ -102,6 +106,7 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
         }
         const missingPlanRecoveryInstruction = resolveMissingPlanRecoveryInstruction({
             request: activeRequest,
+            requiresPlan: requiresPlanEvidence(binding),
             hasPlanStateEvidence: hasPlanStateEvidence(executedToolResults),
             hasWriteTodosEvidence: executedToolResults.some((item) => item.toolName === "write_todos"),
             hasToolResultEvidence: executedToolResults.length > 0 || toolCalls.length > 0,