@botbotgo/agent-harness 0.0.345 → 0.0.347

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

@@ -2,6 +2,7 @@ import { MemorySaver } from "@langchain/langgraph";
 import { UPSTREAM_REQUEST_CONFIG_KEY, UPSTREAM_SESSION_CONFIG_KEY } from "./adapter/upstream-configurable-keys.js";
 import { asStructuredExecutableTool } from "./adapter/tool/resolved-tool.js";
 import { compileInterruptOn } from "./adapter/tool/interrupt-policy.js";
+import { readSkillMetadata } from "./skills/skill-metadata.js";
 import { getBindingBackendConfig, getBindingExecutionKind, getBindingExecutionParams, getBindingInterruptCompatibilityRules, getBindingMemorySources, getBindingMiddlewareConfigs, getBindingPrimaryTools, getBindingSkills, getBindingStoreConfig, } from "./support/compiled-binding.js";
 export const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
 export const DEFAULT_DEEPAGENT_RECURSION_LIMIT = 100;
@@ -37,6 +38,67 @@ export function materializeModelExposedBuiltinMiddlewareTools(input) {
     }
     return tools;
 }
+function formatCapabilityLine(item) {
+    const description = typeof item.description === "string" && item.description.length > 0
+        ? `: ${item.description}`
+        : "";
+    return `- ${JSON.stringify(item.name)}${description}`;
+}
+function buildSkillCatalog(skillPaths) {
+    return skillPaths.map((skillPath) => {
+        const metadata = readSkillMetadata(skillPath);
+        return {
+            name: metadata.name,
+            ...(metadata.description ? { description: metadata.description } : {}),
+        };
+    });
+}
+export function buildDeepAgentSystemPromptWithCapabilityHierarchy(input) {
+    const basePrompt = typeof input.systemPrompt === "string" ? input.systemPrompt : undefined;
+    const skills = buildSkillCatalog(input.skills ?? []);
+    const tools = input.tools ?? [];
+    if (input.subagents.length === 0 && skills.length === 0 && tools.length === 0) {
+        return input.systemPrompt;
+    }
+    const catalogPrompt = [
+        "Capability selection hierarchy:",
+        "1. If the current request fits an available subagent, delegate with the task tool before using local skills or raw tools.",
+        "2. If you are the selected agent and an available skill fits the request, read and follow that skill before calling raw tools.",
+        "3. Use raw tools as execution primitives for the selected agent or skill, or when no listed skill applies.",
+        "Keep each selection inside the selected capability's described responsibility boundary.",
+        "If no listed subagent, skill, or tool can responsibly handle the request, do not invent a path. Return a terminal response with status \"refused\" and explain the missing capability.",
+        "If a selected capability cannot complete after using its available tools, return a terminal response with status \"blocked\" or \"failed\" and include the blocker evidence.",
+        ...(input.subagents.length > 0
+            ? [
+                "",
+                "Available subagents for task delegation:",
+                ...input.subagents.map(formatCapabilityLine),
+                "",
+                "When using the task tool, set subagent_type to exactly one of the listed subagent names. Do not create, translate, alias, or modify subagent names.",
+            ]
+            : [
+                "",
+                "No configured specialist subagents are available for this agent. Do not use task delegation for role-internal work; select a skill first, then tools.",
+            ]),
+        ...(skills.length > 0
+            ? [
+                "",
+                "Available skills for this agent:",
+                ...skills.map(formatCapabilityLine),
+            ]
+            : []),
+        ...(tools.length > 0
+            ? [
+                "",
+                "Raw tools available to this agent:",
+                ...tools.map(formatCapabilityLine),
+            ]
+            : []),
+        "",
+    ].join("\n");
+    return [basePrompt, catalogPrompt].filter((part) => typeof part === "string" && part.length > 0).join("\n\n");
+}
+export const buildDeepAgentSystemPromptWithSubagentCatalog = buildDeepAgentSystemPromptWithCapabilityHierarchy;
 export function resolveRunnableCheckpointer(options, binding) {
     return options.checkpointerResolver ? options.checkpointerResolver(binding) : new MemorySaver();
 }
@@ -146,6 +208,12 @@ export function buildDeepAgentCreateParams(input) {
     ]);
     return {
         ...upstreamParams,
+        systemPrompt: buildDeepAgentSystemPromptWithSubagentCatalog({
+            systemPrompt: upstreamParams.systemPrompt,
+            subagents: input.resolvedSubagents,
+            skills: input.resolvedSkills,
+            tools: getBindingPrimaryTools(input.binding),
+        }),
         skills: input.resolvedSkills,
         model: input.resolvedModel,
         tools: input.resolvedTools,

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

@@ -2,6 +2,7 @@ import { resolveDeterministicFinalOutput, } from "../../adapter/invocation-resul
 import { AGENT_INTERRUPT_SENTINEL_PREFIX, RuntimeOperationTimeoutError } from "../../agent-runtime-adapter.js";
 import { ExecutionReconciliationError } from "../../adapter/flow/stream-runtime.js";
 import { buildRequestPlanState, summarizeBuiltinWriteTodosArgs } from "../../adapter/runtime-adapter-support.js";
+import { mapTerminalStatusToPlanItemStatus, mapTerminalStatusToRequestState, readTerminalExecutionStatus, } from "../../adapter/terminal-status.js";
 import { sanitizeVisibleText } from "../../parsing/output-parsing.js";
 import { describeRuntimeError, renderRuntimeFailure, renderToolFailure } from "../../support/harness-support.js";
 import { getBindingPrimaryModel } from "../../support/compiled-binding.js";
@@ -37,27 +38,6 @@ function planStateHasActiveItems(planState) {
     }
     return planState.summary.pending > 0 || planState.summary.inProgress > 0;
 }
-function readTerminalStructuredStatus(value) {
-    if (typeof value === "string") {
-        try {
-            return readTerminalStructuredStatus(JSON.parse(value));
-        }
-        catch {
-            return /^\s*Status:\s*completed\b/im.test(value) ? "completed" : null;
-        }
-    }
-    if (typeof value !== "object" || value === null) {
-        return null;
-    }
-    const typed = value;
-    if (typed.status === "completed") {
-        return typed.status;
-    }
-    return (readTerminalStructuredStatus(typed.structuredResponse)
-        ?? readTerminalStructuredStatus(typed.content)
-        ?? readTerminalStructuredStatus(typed.output)
-        ?? readTerminalStructuredStatus(typed.data));
-}
 function isSubstantiveTerminalAssistantOutput(value) {
     const normalized = sanitizeVisibleText(value).trim();
     if (normalized.length < 80) {
@@ -372,7 +352,7 @@ function summarizePlanState(planState) {
     const suffix = planState.items.length > items.length ? [`  ... ${planState.items.length - items.length} more`] : [];
     return ["TODO", ...items, ...suffix].join("\n");
 }
-function summarizePlanStateTerminalTransitions(previousPlanState, nextPlanState) {
+function summarizePlanStateTerminalTransitionEntries(previousPlanState, nextPlanState) {
     const previousByKey = new Map((previousPlanState?.items ?? []).map((item) => [normalizePlanItemKey(item), item]));
     const terminalLabel = (status) => {
         switch (status) {
@@ -395,9 +375,70 @@ function summarizePlanStateTerminalTransitions(previousPlanState, nextPlanState)
         if (previousStatus === item.status) {
             return [];
         }
-        return [`TODO ${label}: ${item.content}.`];
+        return [{
+                key: normalizePlanItemKey(item),
+                text: `TODO ${label}: ${item.content}.`,
+                item,
+            }];
     });
 }
+function buildPlanStateProgression(previousPlanState, nextPlanState) {
+    if (!previousPlanState) {
+        return [{ planState: nextPlanState }];
+    }
+    const terminalEntries = summarizePlanStateTerminalTransitionEntries(previousPlanState, nextPlanState);
+    if (terminalEntries.length === 0) {
+        return [{ planState: nextPlanState }];
+    }
+    const mergedPlanState = mergePartialPlanState(previousPlanState, nextPlanState);
+    const workingItems = [];
+    const workingItemByKey = new Map();
+    const previousItems = previousPlanState?.items ?? [];
+    const nextItems = mergedPlanState?.items ?? [];
+    for (const item of previousItems) {
+        workingItemByKey.set(normalizePlanItemKey(item), workingItems.length);
+        workingItems.push({ ...item });
+    }
+    for (const item of nextItems) {
+        const key = normalizePlanItemKey(item);
+        const index = workingItemByKey.get(key);
+        if (index === undefined) {
+            workingItemByKey.set(key, workingItems.length);
+            workingItems.push({ ...item });
+        }
+    }
+    const seenTransitionKeys = new Set();
+    const result = [];
+    for (const entry of terminalEntries) {
+        if (!entry.item || seenTransitionKeys.has(entry.key)) {
+            continue;
+        }
+        seenTransitionKeys.add(entry.key);
+        const index = workingItems.findIndex((item) => normalizePlanItemKey(item) === entry.key);
+        const nextItem = nextPlanState.items.find((item) => normalizePlanItemKey(item) === entry.key);
+        if (!nextItem) {
+            continue;
+        }
+        if (index >= 0) {
+            workingItems[index] = { ...workingItems[index], ...nextItem };
+        }
+        else {
+            workingItems.push({ ...nextItem });
+        }
+        result.push({
+            planState: {
+                ...nextPlanState,
+                items: workingItems.map((item) => ({ ...item })),
+                summary: recomputePlanSummary(workingItems),
+            },
+            commentary: entry.text,
+        });
+    }
+    if (result.length === 0) {
+        return [{ planState: nextPlanState }];
+    }
+    return result;
+}
 function createSurfaceCommentary(surfaceItem) {
     const name = normalizeCommentaryText(surfaceItem.name);
     if (!name) {
@@ -656,13 +697,16 @@ export async function* streamHarnessRun(options) {
                         planStateVersion = mergedPlanState.version;
                         lastPlanStateSignature = signature;
                         currentPlanState = mergedPlanState;
-                        for (const item of await emitPlanStateUpdate(options, currentAgentId, mergedPlanState)) {
-                            yield item;
+                        const progression = buildPlanStateProgression(previousPlanState, currentPlanState);
+                        for (const progressionStep of progression) {
+                            for (const item of await emitPlanStateUpdate(options, currentAgentId, progressionStep.planState)) {
+                                yield item;
+                            }
+                            if (progressionStep.commentary) {
+                                yield* emitCommentary(progressionStep.commentary);
+                            }
                         }
-                        for (const commentary of summarizePlanStateTerminalTransitions(previousPlanState, mergedPlanState)) {
-                            yield* emitCommentary(commentary);
-                        }
-                        const commentary = summarizePlanState(mergedPlanState);
+                        const commentary = summarizePlanState(currentPlanState);
                         if (commentary) {
                             yield* emitCommentary(commentary);
                         }
@@ -818,36 +862,42 @@ export async function* streamHarnessRun(options) {
                         const previousPlanState = currentPlanState;
                         lastPlanStateSignature = signature;
                         currentPlanState = mergedPlanState;
-                        for (const item of await emitPlanStateUpdate(options, currentAgentId, mergedPlanState)) {
-                            yield item;
+                        const progression = buildPlanStateProgression(previousPlanState, currentPlanState);
+                        for (const progressionStep of progression) {
+                            for (const item of await emitPlanStateUpdate(options, currentAgentId, progressionStep.planState)) {
+                                yield item;
+                            }
+                            if (progressionStep.commentary) {
+                                yield* emitCommentary(progressionStep.commentary);
+                            }
                         }
-                        for (const commentary of summarizePlanStateTerminalTransitions(previousPlanState, mergedPlanState)) {
-                            yield* emitCommentary(commentary);
-                        }
-                        const commentary = summarizePlanState(mergedPlanState);
+                        const commentary = summarizePlanState(currentPlanState);
                         if (commentary) {
                             yield* emitCommentary(commentary);
                         }
                     }
                 }
                 const terminalStructuredStatus = normalizedChunk.toolName === "task"
-                    ? readTerminalStructuredStatus(normalizedChunk.output)
+                    ? readTerminalExecutionStatus(normalizedChunk.output)
                     : null;
                 if (terminalStructuredStatus && currentPlanState && planStateHasActiveItems(currentPlanState)) {
-                    const reconciledPlanState = reconcilePlanStateToTerminalStatus(currentPlanState, terminalStructuredStatus, new Date().toISOString());
+                    const reconciledPlanState = reconcilePlanStateToTerminalStatus(currentPlanState, mapTerminalStatusToPlanItemStatus(terminalStructuredStatus), new Date().toISOString());
                     const signature = buildPlanStateSignature(reconciledPlanState);
                     if (signature !== lastPlanStateSignature) {
                         const previousPlanState = currentPlanState;
                         planStateVersion = reconciledPlanState.version;
                         lastPlanStateSignature = signature;
                         currentPlanState = reconciledPlanState;
-                        for (const item of await emitPlanStateUpdate(options, currentAgentId, reconciledPlanState)) {
-                            yield item;
-                        }
-                        for (const commentary of summarizePlanStateTerminalTransitions(previousPlanState, reconciledPlanState)) {
-                            yield* emitCommentary(commentary);
+                        const progression = buildPlanStateProgression(previousPlanState, currentPlanState);
+                        for (const progressionStep of progression) {
+                            for (const item of await emitPlanStateUpdate(options, currentAgentId, progressionStep.planState)) {
+                                yield item;
+                            }
+                            if (progressionStep.commentary) {
+                                yield* emitCommentary(progressionStep.commentary);
+                            }
                         }
-                        const commentary = summarizePlanState(reconciledPlanState);
+                        const commentary = summarizePlanState(currentPlanState);
                         if (commentary) {
                             yield* emitCommentary(commentary);
                         }
@@ -919,35 +969,41 @@ export async function* streamHarnessRun(options) {
                     planStateVersion = mergedPlanState.version;
                     lastPlanStateSignature = signature;
                     currentPlanState = mergedPlanState;
-                    for (const item of await emitPlanStateUpdate(options, currentAgentId, mergedPlanState)) {
-                        yield item;
-                    }
-                    for (const commentary of summarizePlanStateTerminalTransitions(previousPlanState, mergedPlanState)) {
-                        yield* emitCommentary(commentary);
+                    const progression = buildPlanStateProgression(previousPlanState, currentPlanState);
+                    for (const progressionStep of progression) {
+                        for (const item of await emitPlanStateUpdate(options, currentAgentId, progressionStep.planState)) {
+                            yield item;
+                        }
+                        if (progressionStep.commentary) {
+                            yield* emitCommentary(progressionStep.commentary);
+                        }
                     }
-                    const commentary = summarizePlanState(mergedPlanState);
+                    const commentary = summarizePlanState(currentPlanState);
                     if (commentary) {
                         yield* emitCommentary(commentary);
                     }
                 }
             }
             currentPlanState = await refreshPlanStateFromPersistence(options, currentPlanState);
-            const terminalStructuredStatus = readTerminalStructuredStatus(actual.structuredResponse);
+            const terminalStructuredStatus = readTerminalExecutionStatus(actual.structuredResponse);
             if (terminalStructuredStatus && currentPlanState && planStateHasActiveItems(currentPlanState)) {
-                const reconciledPlanState = reconcilePlanStateToTerminalStatus(currentPlanState, terminalStructuredStatus, new Date().toISOString());
+                const reconciledPlanState = reconcilePlanStateToTerminalStatus(currentPlanState, mapTerminalStatusToPlanItemStatus(terminalStructuredStatus), new Date().toISOString());
                 const signature = buildPlanStateSignature(reconciledPlanState);
                 if (signature !== lastPlanStateSignature) {
                     const previousPlanState = currentPlanState;
                     planStateVersion = reconciledPlanState.version;
                     lastPlanStateSignature = signature;
                     currentPlanState = reconciledPlanState;
-                    for (const item of await emitPlanStateUpdate(options, currentAgentId, reconciledPlanState)) {
-                        yield item;
-                    }
-                    for (const commentary of summarizePlanStateTerminalTransitions(previousPlanState, reconciledPlanState)) {
-                        yield* emitCommentary(commentary);
+                    const progression = buildPlanStateProgression(previousPlanState, currentPlanState);
+                    for (const progressionStep of progression) {
+                        for (const item of await emitPlanStateUpdate(options, currentAgentId, progressionStep.planState)) {
+                            yield item;
+                        }
+                        if (progressionStep.commentary) {
+                            yield* emitCommentary(progressionStep.commentary);
+                        }
                     }
-                    const commentary = summarizePlanState(reconciledPlanState);
+                    const commentary = summarizePlanState(currentPlanState);
                     if (commentary) {
                         yield* emitCommentary(commentary);
                     }
@@ -963,13 +1019,16 @@ export async function* streamHarnessRun(options) {
                 planStateVersion = reconciledPlanState.version;
                 lastPlanStateSignature = signature;
                 currentPlanState = reconciledPlanState;
-                for (const item of await emitPlanStateUpdate(options, currentAgentId, reconciledPlanState)) {
-                    yield item;
-                }
-                for (const commentary of summarizePlanStateTerminalTransitions(previousPlanState, reconciledPlanState)) {
-                    yield* emitCommentary(commentary);
+                const progression = buildPlanStateProgression(previousPlanState, currentPlanState);
+                for (const progressionStep of progression) {
+                    for (const item of await emitPlanStateUpdate(options, currentAgentId, progressionStep.planState)) {
+                        yield item;
+                    }
+                    if (progressionStep.commentary) {
+                        yield* emitCommentary(progressionStep.commentary);
+                    }
                 }
-                const commentary = summarizePlanState(reconciledPlanState);
+                const commentary = summarizePlanState(currentPlanState);
                 if (commentary) {
                     yield* emitCommentary(commentary);
                 }
@@ -996,8 +1055,10 @@ export async function* streamHarnessRun(options) {
                 content: assistantOutput,
             };
         }
+        const terminalStatus = readTerminalExecutionStatus(assistantOutput);
+        const terminalRequestState = mapTerminalStatusToRequestState(terminalStatus);
         await options.appendAssistantMessage(options.sessionId, options.requestId, assistantOutput);
-        const completedEvent = await options.setRequestStateAndEmit(options.sessionId, options.requestId, 6, "completed", {
+        const completedEvent = await options.setRequestStateAndEmit(options.sessionId, options.requestId, 6, terminalRequestState, {
             previousState: "running",
         });
         yield {
@@ -1010,9 +1071,10 @@ export async function* streamHarnessRun(options) {
                 sessionId: options.sessionId,
                 requestId: options.requestId,
                 agentId: currentAgentId,
-                state: "completed",
+                state: terminalRequestState,
                 output: assistantOutput,
                 finalMessageText: assistantOutput,
+                ...(terminalStatus ? { metadata: { terminalStatus } } : {}),
             },
         };
     }
@@ -1022,22 +1084,25 @@ export async function* streamHarnessRun(options) {
             executedToolResults,
         });
         if (!assistantOutput && sawSuccessfulToolResult && deterministicToolEvidenceOutput) {
-            const terminalStructuredStatus = readTerminalStructuredStatus(deterministicToolEvidenceOutput);
+            const terminalStructuredStatus = readTerminalExecutionStatus(deterministicToolEvidenceOutput);
             if (terminalStructuredStatus && currentPlanState && planStateHasActiveItems(currentPlanState)) {
-                const reconciledPlanState = reconcilePlanStateToTerminalStatus(currentPlanState, terminalStructuredStatus, new Date().toISOString());
+                const reconciledPlanState = reconcilePlanStateToTerminalStatus(currentPlanState, mapTerminalStatusToPlanItemStatus(terminalStructuredStatus), new Date().toISOString());
                 const signature = buildPlanStateSignature(reconciledPlanState);
                 if (signature !== lastPlanStateSignature) {
                     const previousPlanState = currentPlanState;
                     planStateVersion = reconciledPlanState.version;
                     lastPlanStateSignature = signature;
                     currentPlanState = reconciledPlanState;
-                    for (const item of await emitPlanStateUpdate(options, currentAgentId, reconciledPlanState)) {
-                        yield item;
-                    }
-                    for (const commentary of summarizePlanStateTerminalTransitions(previousPlanState, reconciledPlanState)) {
-                        yield* emitCommentary(commentary);
+                    const progression = buildPlanStateProgression(previousPlanState, currentPlanState);
+                    for (const progressionStep of progression) {
+                        for (const item of await emitPlanStateUpdate(options, currentAgentId, progressionStep.planState)) {
+                            yield item;
+                        }
+                        if (progressionStep.commentary) {
+                            yield* emitCommentary(progressionStep.commentary);
+                        }
                     }
-                    const commentary = summarizePlanState(reconciledPlanState);
+                    const commentary = summarizePlanState(currentPlanState);
                     if (commentary) {
                         yield* emitCommentary(commentary);
                     }
@@ -1055,7 +1120,9 @@ export async function* streamHarnessRun(options) {
                 agentId: currentAgentId,
                 content: deterministicToolEvidenceOutput,
             };
-            const completedEvent = await options.setRequestStateAndEmit(options.sessionId, options.requestId, 6, "completed", {
+            const terminalStatus = readTerminalExecutionStatus(deterministicToolEvidenceOutput);
+            const terminalRequestState = mapTerminalStatusToRequestState(terminalStatus);
+            const completedEvent = await options.setRequestStateAndEmit(options.sessionId, options.requestId, 6, terminalRequestState, {
                 previousState: "running",
             });
             yield {
@@ -1068,11 +1135,12 @@ export async function* streamHarnessRun(options) {
                     sessionId: options.sessionId,
                     requestId: options.requestId,
                     agentId: currentAgentId,
-                    state: "completed",
+                    state: terminalRequestState,
                     output: deterministicToolEvidenceOutput,
                     finalMessageText: deterministicToolEvidenceOutput,
                     metadata: {
                         executedToolResults,
+                        ...(terminalStatus ? { terminalStatus } : {}),
                     },
                 },
             };

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

@@ -7,10 +7,10 @@ export declare function isRepairableWriteTodosEmptyFailure(error: unknown): bool
 export declare function isToolCallRecoveryFailure(error: unknown): boolean;
 export declare function isRetrySafeInvalidToolSelectionError(value: unknown): boolean;
 export declare function shouldValidateExecutionWithoutToolEvidence(request: unknown): boolean;
-export declare function shouldRequireVisibleTodoPlan(request: unknown): boolean;
 export declare function resolveMissingPlanRecoveryInstruction(params: {
     request: unknown;
     assistantText?: string;
+    requiresPlan?: boolean;
     hasPlanStateEvidence?: boolean;
     hasWriteTodosEvidence?: boolean;
     hasToolResultEvidence?: boolean;
@@ -23,6 +23,7 @@ export declare function resolveExecutionWithoutToolEvidenceTextInstruction(reque
     hasPlanStateEvidence?: boolean;
     hasOpenTaskDelegation?: boolean;
     hasMissingDelegatedExecutionEvidence?: boolean;
+    requiresPlan?: boolean;
 }): string | null;
 export declare function resolveToolCallRecoveryInstruction(error: unknown): string | null;
 export declare function appendToolRecoveryInstruction(input: unknown, instruction: string): unknown;

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

@@ -111,34 +111,10 @@ export function shouldValidateExecutionWithoutToolEvidence(request) {
     }
     return readSystemInstructionText(request).length > 0;
 }
-export function shouldRequireVisibleTodoPlan(request) {
-    const userText = readLatestUserRequestText(request).toLowerCase();
-    if (!userText) {
-        return false;
-    }
-    return [
-        "investigate",
-        "investigation",
-        "issue",
-        "issues",
-        "rca",
-        "root cause",
-        "go deeper",
-        "deep research",
-        "debug",
-        "排查",
-        "调查",
-        "问题",
-        "根因",
-        "故障",
-        "集群",
-        "cluster",
-    ].some((keyword) => userText.includes(keyword));
-}
 export function resolveMissingPlanRecoveryInstruction(params) {
     const hasPlanEvidence = params.hasWriteTodosEvidence === true
         || params.hasPlanStateEvidence === true;
-    if (!shouldRequireVisibleTodoPlan(params.request) || hasPlanEvidence) {
+    if (params.requiresPlan !== true || hasPlanEvidence) {
         return null;
     }
     if (params.hasToolResultEvidence === true) {
@@ -158,6 +134,7 @@ export function resolveExecutionWithoutToolEvidenceTextInstruction(request, assi
     const missingPlanRecoveryInstruction = resolveMissingPlanRecoveryInstruction({
         request,
         assistantText: normalizedText,
+        requiresPlan: resultEvidence.requiresPlan,
         hasWriteTodosEvidence: resultEvidence.hasWriteTodosEvidence,
         hasPlanStateEvidence: resultEvidence.hasIncompletePlanState === true || resultEvidence.hasPlanStateEvidence === true,
         hasToolResultEvidence: resultEvidence.hasToolResultEvidence,

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

@@ -11,6 +11,7 @@ export declare const WRITE_TODOS_REQUIRED_PLAN_INSTRUCTION: string;
 export declare const EXECUTION_WITH_TOOL_EVIDENCE_INSTRUCTION: string;
 export declare const EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION: string;
 export declare const AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION: string;
+export declare const DELEGATED_TASK_FAILURE_RECOVERY_INSTRUCTION: string;
 export declare const INTERNAL_RUNTIME_SPILL_PATH_INSTRUCTION: string;
 export declare const WORKSPACE_RELATIVE_PATH_INSTRUCTION: string;
 export declare function renderDurableMemoryContextPrompt(memoryContext: string): string;

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

@@ -14,6 +14,7 @@ export const WRITE_TODOS_REQUIRED_PLAN_INSTRUCTION = readRuntimePrompt("write-to
 export const EXECUTION_WITH_TOOL_EVIDENCE_INSTRUCTION = readRuntimePrompt("execution-with-tool-evidence");
 export const EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION = readRuntimePrompt("execution-with-tool-evidence-retry");
 export const AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION = readRuntimePrompt("autonomous-investigation-recovery");
+export const DELEGATED_TASK_FAILURE_RECOVERY_INSTRUCTION = readRuntimePrompt("delegated-task-failure-recovery");
 export const INTERNAL_RUNTIME_SPILL_PATH_INSTRUCTION = readRuntimePrompt("internal-runtime-spill-path");
 export const WORKSPACE_RELATIVE_PATH_INSTRUCTION = readRuntimePrompt("workspace-relative-path");
 export function renderDurableMemoryContextPrompt(memoryContext) {

package/dist/workspace/agent-binding-compiler.js

@@ -199,6 +199,15 @@ function resolveResponseFormat(agent) {
 function resolveContextSchema(agent) {
     return getAgentExecutionConfigValue(agent, "contextSchema");
 }
+function resolveExecutionContract(agent) {
+    const value = getAgentExecutionObject(agent, "executionContract");
+    if (!value) {
+        return undefined;
+    }
+    return {
+        ...(value.requiresPlan === true ? { requiresPlan: true } : {}),
+    };
+}
 function resolveCompiledMiddleware(agent, models) {
     const middleware = getAgentExecutionConfigValue(agent, "middleware");
     return compileMiddlewareConfigs(middleware, models, agent.id);
@@ -399,6 +408,7 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
         : undefined;
     const runtimeGovernanceDefaults = asObject(runtimeDefaults?.governance);
     const runtimeObservabilityDefaults = asObject(runtimeDefaults?.observability);
+    const executionContract = resolveExecutionContract(agent);
     const compiledFilesystemConfig = agent.executionMode === "langchain-v1"
         ? mergeConfigObjects(runtimeFilesystemDefaults, getAgentExecutionObject(agent, "filesystem", { executionMode: "langchain-v1" }))
         : undefined;
@@ -417,6 +427,7 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
             resilience,
             ...(runtimeGovernanceDefaults ? { governance: runtimeGovernanceDefaults } : {}),
             ...(runtimeObservabilityDefaults ? { observability: runtimeObservabilityDefaults } : {}),
+            ...(executionContract ? { executionContract } : {}),
             ...(agent.executionMode === "deepagent"
                 ? {
                     deepagent: {