@sema-agent/core 5.9.0 → 5.11.0

package/dist/core/session-reconcile.d.ts

@@ -6,10 +6,14 @@ export interface OrphanToolCall {
     toolName: string;
     kind?: "result";
 }
+export type ReconciledErrorKind = "interrupted_never_started" | "interrupted_outcome_unknown";
+export type RecoveredOrphan = OrphanToolCall & {
+    entryId: string;
+    text: string;
+    errorKind: ReconciledErrorKind;
+};
 export interface ReconcileReport {
-    recovered: Array<OrphanToolCall & {
-        entryId: string;
-    }>;
+    recovered: RecoveredOrphan[];
 }
 export declare function findOrphanToolCalls(messages: AgentMessage[], suspendedBatch?: ReadonlySet<string>): OrphanToolCall[];
 export declare function reconcileInterruptedSession(session: Session, toolEffects?: Map<string, ToolEffect>, suspendedBatch?: ReadonlySet<string>, startedToolCallIds?: ReadonlySet<string>): Promise<ReconcileReport>;

package/dist/core/session-reconcile.js

@@ -75,16 +75,17 @@ export async function reconcileInterruptedSession(session, toolEffects, suspende
         const effectText = effect === "read" ? INTERRUPTED_SAFE : effect === "idempotent" ? INTERRUPTED_IDEMPOTENT : INTERRUPTED_UNKNOWN;
         const neverStarted = startedToolCallIds !== undefined && !startedToolCallIds.has(orphan.toolCallId);
         const text = neverStarted ? INTERRUPTED_NEVER_STARTED : effectText;
+        const errorKind = neverStarted ? "interrupted_never_started" : "interrupted_outcome_unknown";
         const entryId = await session.appendMessage({
             role: "toolResult",
             toolCallId: orphan.toolCallId,
             toolName: orphan.toolName,
             content: [{ type: "text", text }],
-            details: { errorKind: neverStarted ? "interrupted_never_started" : "interrupted_outcome_unknown" },
+            details: { errorKind },
             isError: true,
             timestamp: Date.now(),
         });
-        recovered.push({ ...orphan, entryId });
+        recovered.push({ ...orphan, entryId, text, errorKind });
     }
     return { recovered };
 }

package/dist/core/strategy-store.d.ts

@@ -14,8 +14,8 @@ export interface StrategyStore {
     prune?(scope: string, maxSize: number): Promise<void> | void;
 }
 export declare class InMemoryStrategyStore implements StrategyStore {
-    private readonly maxPerScope;
     private byScope;
+    private readonly maxPerScope;
     constructor(maxPerScope?: number);
     save(s: StoredStrategy): void;
     find(scope: string, query: string, limit: number): StoredStrategy[];

package/dist/core/strategy-store.js

@@ -1,3 +1,25 @@
+function invalidKnob(message, code) {
+    const e = new Error(message);
+    e.code = code;
+    return e;
+}
+function resolveFindLimit(limit) {
+    if (limit === Number.POSITIVE_INFINITY)
+        return limit;
+    if (!Number.isInteger(limit) || limit < 0) {
+        throw invalidKnob(`StrategyStore.find: limit must be a non-negative integer, or Infinity for "no cap" (got ${String(limit)})`, "config.strategy_find_limit_invalid");
+    }
+    return limit;
+}
+function resolveCapacityCap(name, cap) {
+    if (cap === Number.POSITIVE_INFINITY) {
+        throw invalidKnob(`InMemoryStrategyStore ${name} cannot be Infinity — a per-scope capacity cap can be widened but not turned off; pass a large finite integer instead`, "config.strategy_max_size_invalid");
+    }
+    if (!Number.isInteger(cap) || cap < 0) {
+        throw invalidKnob(`InMemoryStrategyStore ${name} must be a non-negative integer (got ${String(cap)})`, "config.strategy_max_size_invalid");
+    }
+    return cap;
+}
 const STOP = new Set([
     "the", "and", "for", "with", "from", "this", "that", "into", "your", "you", "are", "was", "were", "has",
     "have", "had", "not", "but", "all", "any", "can", "use", "using", "via", "then", "than", "out", "get",
@@ -24,10 +46,10 @@ function score(s) {
     return (s.confidence + 1) * (1 / (1 + ageDays(s.ts)));
 }
 export class InMemoryStrategyStore {
-    maxPerScope;
     byScope = new Map();
+    maxPerScope;
     constructor(maxPerScope = 100) {
-        this.maxPerScope = maxPerScope;
+        this.maxPerScope = resolveCapacityCap("maxPerScope", maxPerScope);
     }
     save(s) {
         const arr = this.byScope.get(s.scope) ?? [];
@@ -49,6 +71,7 @@ export class InMemoryStrategyStore {
         this.byScope.set(s.scope, arr);
     }
     find(scope, query, limit) {
+        const cap = resolveFindLimit(limit);
         const arr = this.byScope.get(scope);
         if (!arr || arr.length === 0) {
             return [];
@@ -61,11 +84,11 @@ export class InMemoryStrategyStore {
             const probTokens = new Set(tokens(s.problem));
             return qSig.every((t) => probTokens.has(t));
         });
-        return matches.sort((a, b) => score(b) - score(a)).slice(0, Math.max(0, Number.isFinite(limit) ? limit : 0));
+        return matches.sort((a, b) => score(b) - score(a)).slice(0, cap);
     }
     prune(scope, maxSize) {
+        const n = resolveCapacityCap("maxSize", maxSize);
         const arr = this.byScope.get(scope);
-        const n = Math.max(0, maxSize);
         if (arr && arr.length > n) {
             arr.sort((a, b) => score(b) - score(a));
             arr.length = n;

package/dist/core/task-registry-agent.d.ts

@@ -69,6 +69,7 @@ export declare function settleBackgroundAgentLane(core: DurableAgentCore, id: st
     errorCode?: string;
     retryable?: boolean;
     errorKind?: string;
+    retryAfterMs?: number;
     stoppedBy?: StopSource;
     seq?: number;
     cycle?: number;
@@ -105,6 +106,7 @@ export declare function settleRevivedAgentLane(core: DurableAgentCore, id: strin
     errorCode?: string;
     retryable?: boolean;
     errorKind?: string;
+    retryAfterMs?: number;
 }): "completed" | "failed" | "killed" | undefined;
 export declare function noteBackgroundAgentActivityLane(core: DurableAgentCore, id: string, now?: number): void;
 export declare function reapStaleSessionBackgroundAgentsLane(core: DurableAgentCore, staleMs: number, now?: number, onTerminal?: (note: () => void) => void): number;
@@ -137,6 +139,7 @@ export interface AgentPollDetailsInput {
     error?: string;
     errorCode?: string;
     errorRetryable?: boolean;
+    errorRetryAfterMs?: number;
     resultIsPartial?: boolean;
     completionId?: string;
 }

package/dist/core/task-registry-agent.js

@@ -713,6 +713,8 @@ export function settleBackgroundAgentLane(core, id, outcome) {
             handle.errorRetryable = outcome.retryable;
         if (outcome.errorKind !== undefined)
             handle.errorKind = outcome.errorKind;
+        if (outcome.retryAfterMs !== undefined)
+            handle.errorRetryAfterMs = outcome.retryAfterMs;
     }
     handle.updatedAt = Date.now();
     if (outcome.seq !== undefined)
@@ -731,6 +733,7 @@ export function settleBackgroundAgentLane(core, id, outcome) {
         ...(handle.errorCode !== undefined ? { errorCode: handle.errorCode } : {}),
         ...(handle.errorRetryable !== undefined ? { errorRetryable: handle.errorRetryable } : {}),
         ...(handle.errorKind !== undefined ? { errorKind: handle.errorKind } : {}),
+        ...(handle.errorRetryAfterMs !== undefined ? { errorRetryAfterMs: handle.errorRetryAfterMs } : {}),
     }, ["parkedCheckpointToken", "parkClaimId", "parkedAt"]);
     return outcome.status;
 }
@@ -857,6 +860,7 @@ export function reviveBackgroundAgentLane(core, id, access, abort) {
     handle.errorCode = undefined;
     handle.errorRetryable = undefined;
     handle.errorKind = undefined;
+    handle.errorRetryAfterMs = undefined;
     handle.resultIsPartial = undefined;
     handle.stopSource = undefined;
     handle.completionId = undefined;
@@ -1052,6 +1056,7 @@ export function buildAgentPollDetails(input) {
         ...(failed && input.error !== undefined ? { error: delimitUntrusted("agent error", boundedRedactedSummary(input.error, 300)) } : {}),
         ...(failed && input.errorCode !== undefined ? { errorCode: input.errorCode } : {}),
         ...(failed && input.errorRetryable !== undefined ? { retryable: input.errorRetryable } : {}),
+        ...(failed && input.errorRetryAfterMs !== undefined ? { retryAfterMs: input.errorRetryAfterMs } : {}),
         ...(input.resultIsPartial === true ? { partial_result: true } : {}),
         ...(input.completionId !== undefined ? { completionId: input.completionId } : {}),
     };
@@ -1070,7 +1075,7 @@ The agent is durably suspended, waiting for an approval decision. It resumes whe
         };
     }
     const kindClause = row.status === "failed" && row.errorKind !== undefined && row.errorRetryable !== undefined
-        ? ` (error_kind: ${row.errorKind}, retryable: ${row.errorRetryable})`
+        ? ` (error_kind: ${row.errorKind}, retryable: ${row.errorRetryable}${row.errorRetryAfterMs !== undefined ? `, retry_after_ms: ${row.errorRetryAfterMs}` : ""})`
         : "";
     const body = `status: ${row.status}
 ${row.error ? `error: ${row.error}${kindClause}
@@ -1087,6 +1092,7 @@ ${clipTaskOutput(row.finalOutputFull ?? row.finalOutput)}` : "(no result text)"}
             ...(row.error !== undefined ? { error: row.error } : {}),
             ...(row.errorCode !== undefined ? { errorCode: row.errorCode } : {}),
             ...(row.errorRetryable !== undefined ? { errorRetryable: row.errorRetryable } : {}),
+            ...(row.errorRetryAfterMs !== undefined ? { errorRetryAfterMs: row.errorRetryAfterMs } : {}),
             ...(row.resultIsPartial === true ? { resultIsPartial: true } : {}),
             ...(row.completionId !== undefined ? { completionId: row.completionId } : {}),
         }),
@@ -1126,7 +1132,7 @@ The agent is durably suspended, waiting for an approval decision. It resumes whe
     const fullResult = handle.result ? (handle.resultFull ?? handle.result) : undefined;
     const resultText = fullResult !== undefined ? await spillClippedAgentResult(handle, fullResult, clipTaskOutput(fullResult, handle.outputFile), store, sessionId) : undefined;
     const kindClause = handle.status === "failed" && handle.errorKind !== undefined && handle.errorRetryable !== undefined
-        ? ` (error_kind: ${handle.errorKind}, retryable: ${handle.errorRetryable})`
+        ? ` (error_kind: ${handle.errorKind}, retryable: ${handle.errorRetryable}${handle.errorRetryAfterMs !== undefined ? `, retry_after_ms: ${handle.errorRetryAfterMs}` : ""})`
         : "";
     const body = running
         ? oneShot === true
@@ -1149,6 +1155,7 @@ ${resultText}` : "(no result text)"}`;
             ...(handle.error !== undefined ? { error: handle.error } : {}),
             ...(handle.errorCode !== undefined ? { errorCode: handle.errorCode } : {}),
             ...(handle.errorRetryable !== undefined ? { errorRetryable: handle.errorRetryable } : {}),
+            ...(handle.errorRetryAfterMs !== undefined ? { errorRetryAfterMs: handle.errorRetryAfterMs } : {}),
             ...(handle.resultIsPartial === true ? { resultIsPartial: true } : {}),
             ...(handle.completionId !== undefined ? { completionId: handle.completionId } : {}),
         }),

package/dist/core/task-registry-shared.d.ts

@@ -139,6 +139,7 @@ export interface BackgroundAgentTaskHandle extends SemaTaskHandle {
     errorCode?: string;
     errorRetryable?: boolean;
     errorKind?: string;
+    errorRetryAfterMs?: number;
     resultIsPartial?: boolean;
     stopSource?: StopSource;
     stoppedBy?: StopSource;

package/dist/core/task-registry.d.ts

@@ -141,6 +141,7 @@ export declare class TaskRegistry {
         errorCode?: string;
         retryable?: boolean;
         errorKind?: string;
+        retryAfterMs?: number;
         stoppedBy?: StopSource;
         seq?: number;
         cycle?: number;
@@ -180,6 +181,7 @@ export declare class TaskRegistry {
         errorCode?: string;
         retryable?: boolean;
         errorKind?: string;
+        retryAfterMs?: number;
     }): "completed" | "failed" | "killed" | undefined;
     unmarkRetainedContinuation(id: string): void;
     attachAgentNotify(id: string, notify: NonNullable<BackgroundAgentTaskHandle["notify"]>, cycle?: number): void;

package/dist/core/tools.js

@@ -64,7 +64,15 @@ export function defineTool(spec, options) {
                 ret = await spec.execute(params, options?.enrichCtx ? { ...options.enrichCtx(baseCtx), toolCallId, signal } : baseCtx);
             }
             catch (err) {
-                throw new Error(formatToolError(err));
+                const wrapped = new Error(formatToolError(err));
+                if (err !== null && typeof err === "object") {
+                    const src = err;
+                    if (src.details !== undefined)
+                        wrapped.details = src.details;
+                    if (typeof src.errorKind === "string")
+                        wrapped.errorKind = src.errorKind;
+                }
+                throw wrapped;
             }
             const { content, details, terminate, isError } = normalizeContent(ret);
             const guarded = isEmptyToolContent(content)

package/dist/core/trace.d.ts

@@ -94,6 +94,7 @@ export type TraceEvent = {
     kind: "config.additional_directory_skipped";
     version: 1;
     taskId: string;
+    field?: "additionalReadDirectories";
     entry: string;
     reason: string;
     ts: number;

package/dist/core/types.d.ts

@@ -99,6 +99,9 @@ export interface ToolExecuteContext {
     thinkingLevel?: ThinkingLevel;
     principal?: string;
     onAsk?: import("./tool-policy.js").OnAsk;
+    onQuestion?: import("./ask-question.js").OnQuestion;
+    handsReadOnly?: true;
+    interactiveTools?: false;
     oneShot?: boolean;
     clientContext?: TaskSpec["clientContext"];
     excludeTools?: readonly string[];
@@ -106,6 +109,7 @@ export interface ToolExecuteContext {
     alwaysLoadTools?: readonly string[];
     promptProfile?: "simple" | "classic";
     additionalDirectories?: readonly string[];
+    additionalReadDirectories?: readonly string[];
     envFacts?: TaskSpec["envFacts"];
     getApiKeyAndHeaders?: TaskSpec["getApiKeyAndHeaders"];
     activeSkillScope?: () => readonly unknown[];
@@ -117,6 +121,7 @@ export interface ToolExecuteContext {
         scope: string;
         ttlMs?: number;
     };
+    checkpointStoreDisabledForChildren?: true;
     taskId?: string;
     sessionId?: string;
     backgroundScope?: "task" | "session";
@@ -293,6 +298,7 @@ export interface TaskSpec {
     tools?: ToolSpec[];
     excludeTools?: string[];
     deferTools?: string[];
+    toolMaterializeStrategy?: "swap" | "static";
     alwaysLoadTools?: string[];
     deferSelfResolve?: boolean;
     promptProfile?: "simple" | "classic";
@@ -318,9 +324,10 @@ export interface TaskSpec {
     resilience?: ResilienceOptions;
     finalVerification?: boolean;
     maxSuspends?: number;
-    checkpointStore?: import("./checkpoint-store.js").CheckpointStore;
+    checkpointStore?: import("./checkpoint-store.js").CheckpointStore | null;
     handsReadOnly?: boolean;
     additionalDirectories?: string[];
+    additionalReadDirectories?: string[];
     enablePlanMode?: boolean;
     interactiveTools?: boolean;
     enableFork?: boolean;

package/dist/engine/loop/agent-loop.js

@@ -208,6 +208,7 @@ async function runSingleTurn(state, signal, emit, streamFn, runtime, trace) {
     finally {
         await executor.settle();
     }
+    raiseFatalCancellation(executor);
     {
         if (ptl) {
             const detect = ptlDetect;
@@ -245,6 +246,7 @@ async function runSingleTurn(state, signal, emit, streamFn, runtime, trace) {
                 finally {
                     await executor.settle();
                 }
+                raiseFatalCancellation(executor);
             }
         }
     }
@@ -495,8 +497,7 @@ async function executeToolCallsSequential(currentContext, assistantMessage, tool
             };
         }
         else {
-            const executed = await executePreparedToolCall(preparation, signal, emit, config.abortResultDetails);
-            finalized = await finalizeExecutedToolCall(currentContext, assistantMessage, preparation, executed, config, signal);
+            finalized = await executePreparedWithDisclosure(currentContext, assistantMessage, preparation, config, signal, emit);
         }
         await emitToolExecutionEnd(finalized, emit);
         const toolResultMessage = createToolResultMessage(finalized);
@@ -559,15 +560,25 @@ function resolveToolConcurrency(configured) {
 }
 async function runCapped(thunks, limit) {
     const results = new Array(thunks.length);
+    const failures = new Array(thunks.length);
     let next = 0;
     const width = Number.isFinite(limit) ? Math.max(1, Math.min(limit, thunks.length)) : 1;
     const workers = Array.from({ length: width }, async () => {
         while (next < thunks.length) {
             const i = next++;
-            results[i] = await thunks[i]();
+            try {
+                results[i] = await thunks[i]();
+            }
+            catch (error) {
+                failures[i] = { error };
+            }
         }
     });
     await Promise.all(workers);
+    const firstFailure = failures.find((failure) => failure !== undefined);
+    if (firstFailure !== undefined) {
+        throw firstFailure.error;
+    }
     return results;
 }
 async function executeToolCallsPartitioned(currentContext, assistantMessage, toolCalls, config, signal, emit, executor) {
@@ -625,8 +636,11 @@ async function executeToolCallsPartitioned(currentContext, assistantMessage, too
     return { messages, terminate: shouldTerminateToolBatch(allFinalized) };
     async function settleBatch(entries, concurrent) {
         const runOne = (entry) => async () => {
-            const executed = await executePreparedToolCall(entry.prepared, signal, emit, config.abortResultDetails);
-            const finalized = await finalizeExecutedToolCall(currentContext, assistantMessage, entry.prepared, executed, config, signal);
+            const prepared = entry.prepared;
+            if (!prepared) {
+                throw new Error(`tool call ${entry.toolCall.id} reached execution without a preparation`);
+            }
+            const finalized = await executePreparedWithDisclosure(currentContext, assistantMessage, prepared, config, signal, emit);
             await emitToolExecutionEnd(finalized, emit);
             return finalized;
         };
@@ -662,6 +676,7 @@ class StreamToolExecutor {
     admittedOrder = [];
     barrier = false;
     inFlight = 0;
+    fatalCancellation;
     constructor(context, config, signal, emit) {
         this.context = context;
         this.config = config;
@@ -707,9 +722,11 @@ class StreamToolExecutor {
                 return;
             }
             entry.prepared = preparation;
-            entry.executed = await executePreparedToolCall(preparation, this.signal, this.emit, this.config.abortResultDetails);
+            entry.executed = await executePreparedToolCall(preparation, this.signal, this.emit, this.config.abortResultDetails, (error) => this.retainCancellation(error));
         }
         catch (error) {
+            if (isAbortSemanticsError(error))
+                this.retainCancellation(error);
             entry.immediate = {
                 kind: "immediate",
                 result: createErrorToolResult(error instanceof Error ? error.message : String(error), error),
@@ -724,6 +741,15 @@ class StreamToolExecutor {
         this.barrier = true;
         await Promise.all([...this.entries.values()].map((e) => e.promise));
     }
+    retainCancellation(error) {
+        this.fatalCancellation ??= error;
+        this.barrier = true;
+    }
+    takeFatalCancellation() {
+        const cancellation = this.fatalCancellation;
+        this.fatalCancellation = undefined;
+        return cancellation;
+    }
     take(id) {
         const entry = this.entries.get(id);
         if (entry)
@@ -829,7 +855,7 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
             if (signal?.aborted) {
                 return {
                     kind: "immediate",
-                    result: createErrorToolResult("Operation aborted", { details: config.abortResultDetails?.() }),
+                    result: createErrorToolResult("Operation aborted", { details: safeAbortDetails(config.abortResultDetails) }),
                     isError: true,
                 };
             }
@@ -869,44 +895,134 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
         };
     }
 }
-async function executePreparedToolCall(prepared, signal, emit, abortResultDetails) {
+async function executePreparedToolCall(prepared, signal, emit, abortResultDetails, onLateCancellation) {
     const updateEvents = [];
     let acceptingUpdates = true;
     if (signal?.aborted) {
-        return { result: createErrorToolResult("operation aborted before execution", { details: abortResultDetails?.() }), isError: true };
+        return { result: createErrorToolResult("operation aborted before execution", { details: safeAbortDetails(abortResultDetails) }), isError: true };
     }
     const work = (async () => {
+        let outcome;
         try {
             const result = await prepared.tool.execute(prepared.toolCall.id, prepared.args, signal, (partialResult) => {
                 if (!acceptingUpdates) {
                     return;
                 }
-                updateEvents.push(Promise.resolve(emit({
-                    type: "tool_execution_update",
-                    toolCallId: prepared.toolCall.id,
-                    toolName: prepared.toolCall.name,
-                    args: prepared.toolCall.arguments,
-                    partialResult,
-                })));
+                let delivery;
+                try {
+                    delivery = Promise.resolve(emit({
+                        type: "tool_execution_update",
+                        toolCallId: prepared.toolCall.id,
+                        toolName: prepared.toolCall.name,
+                        args: prepared.toolCall.arguments,
+                        partialResult,
+                    }));
+                }
+                catch (error) {
+                    delivery = Promise.reject(error);
+                }
+                void delivery.catch((reason) => {
+                    if (isAbortSemanticsError(reason))
+                        onLateCancellation?.(reason);
+                });
+                updateEvents.push(delivery);
             });
-            acceptingUpdates = false;
-            await Promise.all(updateEvents);
-            return { result, isError: result.isError === true };
+            outcome = { result, isError: result.isError === true };
         }
         catch (error) {
-            acceptingUpdates = false;
-            await Promise.all(updateEvents);
-            return {
+            outcome = {
                 result: createErrorToolResult(error instanceof Error ? error.message : String(error), error),
                 isError: true,
             };
         }
+        acceptingUpdates = false;
+        const deliveryFailure = await settleUpdateDeliveries(updateEvents);
+        if (!deliveryFailure)
+            return outcome;
+        const reason = deliveryFailure.reason;
+        const details = annotateDeliveryFailure(outcome.result, {
+            message: reason instanceof Error ? reason.message : String(reason),
+        });
+        return details === UNANNOTATED ? outcome : { result: { ...outcome.result, details }, isError: outcome.isError };
     })();
     return work;
 }
+const TOOL_PROGRESS_DELIVERY_FAILED = "toolProgressDeliveryFailed";
+const UNANNOTATED = Symbol("unannotated");
+function annotateDeliveryFailure(result, mark) {
+    try {
+        const raw = result.details;
+        const prior = raw === undefined ? {} : raw;
+        const proto = prior === null || typeof prior !== "object" ? undefined : Object.getPrototypeOf(prior);
+        if (proto !== Object.prototype && proto !== null)
+            return UNANNOTATED;
+        const details = { ...prior };
+        if (TOOL_PROGRESS_DELIVERY_FAILED in details)
+            return UNANNOTATED;
+        details[TOOL_PROGRESS_DELIVERY_FAILED] = mark;
+        return details;
+    }
+    catch {
+        return UNANNOTATED;
+    }
+}
+function readDeliveryFailureMark(details) {
+    try {
+        if (details === null || typeof details !== "object")
+            return undefined;
+        const mark = details[TOOL_PROGRESS_DELIVERY_FAILED];
+        return mark;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function settleUpdateDeliveries(updateEvents) {
+    if (updateEvents.length === 0)
+        return undefined;
+    let reportFailure;
+    const firstFailure = new Promise((resolve) => {
+        reportFailure = resolve;
+    });
+    for (const delivery of updateEvents) {
+        void delivery.catch((reason) => reportFailure({ reason }));
+    }
+    const allSettled = Promise.allSettled(updateEvents).then((entries) => {
+        for (const entry of entries) {
+            if (entry.status === "rejected")
+                return { reason: entry.reason };
+        }
+        return undefined;
+    });
+    const failure = await Promise.race([firstFailure, allSettled]);
+    if (failure && isAbortSemanticsError(failure.reason))
+        throw failure.reason;
+    return failure;
+}
+function raiseFatalCancellation(executor) {
+    const cancellation = executor.takeFatalCancellation();
+    if (cancellation !== undefined)
+        throw cancellation;
+}
+async function executePreparedWithDisclosure(currentContext, assistantMessage, prepared, config, signal, emit) {
+    let executed;
+    try {
+        executed = await executePreparedToolCall(prepared, signal, emit, config.abortResultDetails);
+    }
+    catch (error) {
+        if (isAbortSemanticsError(error))
+            throw error;
+        executed = {
+            result: createErrorToolResult(`[tool execution harness failed: ${error instanceof Error ? error.message : String(error)}]`, error),
+            isError: true,
+        };
+    }
+    return finalizeExecutedToolCall(currentContext, assistantMessage, prepared, executed, config, signal);
+}
 async function finalizeExecutedToolCall(currentContext, assistantMessage, prepared, executed, config, signal) {
     let result = executed.result;
     let isError = executed.isError;
+    const deliveryMark = readDeliveryFailureMark(executed.result.details);
     if (config.afterToolCall) {
         try {
             const afterResult = await config.afterToolCall({
@@ -930,6 +1046,11 @@ async function finalizeExecutedToolCall(currentContext, assistantMessage, prepar
             const note = `[post-tool processing failed (the tool already executed): ${error instanceof Error ? error.message : String(error)}]`;
             result = { ...result, content: [...result.content, { type: "text", text: note }] };
         }
+        if (deliveryMark !== undefined && readDeliveryFailureMark(result.details) === undefined) {
+            const details = annotateDeliveryFailure(result, deliveryMark);
+            if (details !== UNANNOTATED)
+                result = { ...result, details };
+        }
     }
     return {
         toolCall: prepared.toolCall,
@@ -937,6 +1058,31 @@ async function finalizeExecutedToolCall(currentContext, assistantMessage, prepar
         isError,
     };
 }
+function safeAbortDetails(fn) {
+    try {
+        return fn?.();
+    }
+    catch {
+        return undefined;
+    }
+}
+function isAbortSemanticsError(error) {
+    try {
+        let cursor = error;
+        for (let depth = 0; depth < 8 && cursor instanceof Error; depth++) {
+            if (cursor.name === "AbortError")
+                return true;
+            const next = cursor.cause;
+            if (next === cursor)
+                break;
+            cursor = next;
+        }
+    }
+    catch {
+        return false;
+    }
+    return false;
+}
 function createErrorToolResult(message, source) {
     let details = {};
     if (source !== null && typeof source === "object") {

package/dist/orchestration/run-workflow-tool.js

@@ -380,7 +380,7 @@ export async function createRunWorkflowTool(d) {
                 return structuredError(`workflow script failed to compile: ${err instanceof Error ? err.message : String(err)}`);
             }
             const scriptFn = (wfCtx) => {
-                const primitives = buildWorkflowPrimitives(wfCtx, governance, d.onAgentSpawn, d.parentThinking, principal);
+                const primitives = buildWorkflowPrimitives(wfCtx, governance, d.onAgentSpawn, d.parentThinking, principal, ctx.checkpointStoreDisabledForChildren === true);
                 return d.scriptRunner.run({ scriptSource: script, primitives, scriptArgs: effectiveArgs, signal: wfCtx.signal }).then((r) => r.result);
             };
             if (ctx.signal?.aborted) {

package/dist/orchestration/workflow-governance.js

@@ -118,6 +118,25 @@ function pickWhitelist(scriptSpec) {
     return { safe, modelName };
 }
 function clampResourceLimits(safe, base, caps) {
+    const trustedCandidates = [
+        ["baseline.limits.maxCostUsd", base.limits?.maxCostUsd],
+        ["baseline.limits.maxTokens", base.limits?.maxTokens],
+        ["baseline.limits.maxWalltimeMs", base.limits?.maxWalltimeMs],
+        ["baseline.limits.maxTurns", base.limits?.maxTurns],
+        ["caps.childMaxCostUsd", caps?.childMaxCostUsd],
+        ["caps.childMaxTokens", caps?.childMaxTokens],
+        ["caps.perAgentMaxWalltimeMs", caps?.perAgentMaxWalltimeMs],
+        ["caps.childMaxTurns", caps?.childMaxTurns],
+    ];
+    for (const [label, value] of trustedCandidates) {
+        if (value === undefined)
+            continue;
+        if (typeof value !== "number" || Number.isNaN(value) || value === Infinity || value === -Infinity) {
+            const e = new Error(`workflow governance: ${label} must be a real number (got ${String(value)}) — an unevaluable ceiling is not a ceiling, and dropping it would let a child run this axis unbounded under a limit nobody chose. Use 0 or a negative number to declare "no ceiling from this source" explicitly.`);
+            e.code = "config.limit_invalid";
+            throw e;
+        }
+    }
     const notes = [];
     const requestedCost = safe.limits?.maxCostUsd;
     const requestedTokens = safe.limits?.maxTokens;

package/dist/orchestration/workflow-primitives.d.ts

@@ -8,4 +8,4 @@ export interface WorkflowGovernance {
     models?: Record<string, Model>;
     caps?: WorkflowChildCaps;
 }
-export declare function buildWorkflowPrimitives(ctx: WorkflowRunContext, governance?: WorkflowGovernance, onAgentSpawn?: (handle: WorkflowAgentHandle) => void, parentThinking?: () => TaskSpec["thinking"], parentPrincipal?: string): WorkflowPrimitives;
+export declare function buildWorkflowPrimitives(ctx: WorkflowRunContext, governance?: WorkflowGovernance, onAgentSpawn?: (handle: WorkflowAgentHandle) => void, parentThinking?: () => TaskSpec["thinking"], parentPrincipal?: string, parentCheckpointStoreDisabled?: boolean): WorkflowPrimitives;

package/dist/orchestration/workflow-primitives.js

@@ -22,7 +22,7 @@ function formatResourceClampNote(notes) {
     const parts = notes.map((n) => `${n.field}: requested ${n.requested === undefined ? "unset" : n.requested} → applied ${n.applied}`);
     return `workflow governance tightened this agent's resource limits (${parts.join("; ")})`;
 }
-export function buildWorkflowPrimitives(ctx, governance, onAgentSpawn, parentThinking, parentPrincipal) {
+export function buildWorkflowPrimitives(ctx, governance, onAgentSpawn, parentThinking, parentPrincipal, parentCheckpointStoreDisabled) {
     const agent = (spec, opts) => {
         if (typeof spec === "string")
             spec = { objective: spec };
@@ -39,6 +39,9 @@ export function buildWorkflowPrimitives(ctx, governance, onAgentSpawn, parentThi
         if (childSpec.principal === undefined && parentPrincipal !== undefined) {
             childSpec.principal = parentPrincipal;
         }
+        if (parentCheckpointStoreDisabled === true) {
+            childSpec.checkpointStore = null;
+        }
         if (onAgentSpawn) {
             return ctx.agentStream(childSpec, agentOpts).then((handle) => {
                 onAgentSpawn(handle);