@sema-agent/core 5.9.0 → 5.10.0

package/dist/core/runner/session-file-state-replay.d.ts

@@ -0,0 +1,7 @@
+import type { AgentMessage } from "../../internal/harness.js";
+export interface TranscriptFileRecord {
+    path: string;
+    content: string;
+    at: number;
+}
+export declare function wholeFileRecordsFromTranscript(messages: readonly AgentMessage[]): TranscriptFileRecord[];

package/dist/core/runner/session-file-state-replay.js

@@ -0,0 +1,56 @@
+import { isAbsolutePathForm } from "../../tools/fs/safety.js";
+const READ_TOOL = "Read";
+const WRITE_TOOL = "Write";
+const RETRACTING_RESULTS = [
+    { toolName: "Edit", type: "edit", pathField: "filePath" },
+    { toolName: "NotebookEdit", type: "notebook-edit", pathField: "notebookPath" },
+];
+function cardOf(details) {
+    if (typeof details !== "object" || details === null)
+        return undefined;
+    const rest = details;
+    return typeof rest.type === "string" ? { type: rest.type, rest } : undefined;
+}
+function wholeFileFromReadCard(rest) {
+    const file = rest.file;
+    if (typeof file !== "object" || file === null)
+        return undefined;
+    const f = file;
+    if (typeof f.content !== "string" || f.truncatedByTokenCap === true)
+        return undefined;
+    if (f.startLine !== 1 || typeof f.numLines !== "number" || f.numLines !== f.totalLines)
+        return undefined;
+    return f.content;
+}
+export function wholeFileRecordsFromTranscript(messages) {
+    const byPath = new Map();
+    for (const m of messages) {
+        if (m.role !== "toolResult" || m.isError)
+            continue;
+        const card = cardOf(m.details);
+        if (card === undefined)
+            continue;
+        const { type, rest } = card;
+        const retracts = RETRACTING_RESULTS.find((r) => r.toolName === m.toolName && r.type === type);
+        if (retracts !== undefined) {
+            const changed = rest[retracts.pathField];
+            if (typeof changed === "string")
+                byPath.delete(changed);
+            continue;
+        }
+        const isRead = m.toolName === READ_TOOL && type === "text";
+        const isWrite = m.toolName === WRITE_TOOL && (type === "create" || type === "update");
+        if (!isRead && !isWrite)
+            continue;
+        const nested = rest.file;
+        const holder = isRead ? (typeof nested === "object" && nested !== null ? nested : undefined) : rest;
+        const filePath = holder?.filePath;
+        if (typeof filePath !== "string" || !isAbsolutePathForm(filePath))
+            continue;
+        const content = isRead ? wholeFileFromReadCard(rest) : typeof rest.content === "string" ? rest.content : undefined;
+        if (content === undefined)
+            continue;
+        byPath.set(filePath, { path: filePath, content, at: m.timestamp });
+    }
+    return [...byPath.values()];
+}

package/dist/core/runner/synthetic-tools.js

@@ -78,7 +78,7 @@ export function createReportFindingsTool() {
             const count = findings.length;
             return {
                 content: count === 0 ? "No findings reported." : `${count} finding${count === 1 ? "" : "s"} reported.`,
-                details: { count, ...(level !== undefined ? { level } : {}), findings },
+                details: { type: "report-findings", count, ...(level !== undefined ? { level } : {}), findings },
             };
         },
     });

package/dist/core/runner/tool-output-projection.js

@@ -57,11 +57,12 @@ export const toolOutputFrom = (result) => {
     return { output: raw, truncated: true, totalChars };
 };
 const CC_DETAIL_TYPES = new Set([
-    "edit", "multiedit", "create", "update", "bash", "notebook-edit", "notebook", "file_unchanged", "worktree", "text", "grep", "glob", "mcp",
-    "agent", "task", "task-list", "task-output", "memory-saved", "workflow-run",
+    "edit", "create", "update", "bash", "notebook-edit", "notebook", "file_unchanged", "worktree", "text", "grep", "glob", "mcp",
+    "agent", "task", "task-list", "task-output", "workflow-run",
     "web-fetch", "web-search", "todo", "cron-create", "cron-delete", "cron-list", "image",
-    "task-stop", "tool-search", "memory-recall", "repo-map", "fork", "enter-plan-mode", "exit-plan-mode",
-    "monitor-start", "path_not_in_root",
+    "task-stop", "tool-search", "repo-map", "fork", "enter-plan-mode", "exit-plan-mode",
+    "monitor-start", "path_not_in_root", "readonly_out_of_root",
+    "report-findings", "schedule-wakeup", "send-message", "agent-transcript", "a2a", "document",
 ]);
 export const structuredFrom = (result) => {
     const details = result !== null && typeof result === "object" ? result.details : undefined;

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/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/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[];
@@ -117,6 +120,7 @@ export interface ToolExecuteContext {
         scope: string;
         ttlMs?: number;
     };
+    checkpointStoreDisabledForChildren?: true;
     taskId?: string;
     sessionId?: string;
     backgroundScope?: "task" | "session";
@@ -318,7 +322,7 @@ 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[];
     enablePlanMode?: 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);

package/dist/orchestration/workflow.js

@@ -827,7 +827,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
             rec.toolCalls = result.stats.toolCalls;
         if (activityTail.length > 0)
             rec.activity = activityTail.slice();
-        emit({ type: "agent_end", runId, label: rec.label, phase: rec.phase, ...(rec.groupId !== undefined ? { groupId: rec.groupId } : {}), status: rec.status, output, ...(rec.errorCode !== undefined ? { errorCode: rec.errorCode } : {}), ...(result.stats.toolCalls !== undefined ? { toolCalls: result.stats.toolCalls } : {}), ts: rec.endedAt });
+        emit({ type: "agent_end", runId, label: rec.label, phase: rec.phase, ...(rec.groupId !== undefined ? { groupId: rec.groupId } : {}), status: rec.status, output, ...(rec.errorCode !== undefined ? { errorCode: rec.errorCode } : {}), ...(result.stats.toolCalls !== undefined ? { toolCalls: result.stats.toolCalls } : {}), ...(result.model !== undefined ? { modelResolved: result.model } : {}), ts: rec.endedAt });
         void persist("update");
         bceTerminal(rec.callKey, rec.status === "completed" ? "completed" : "failed", output, result.sessionId || undefined, rec.stats);
         if (journal === "awaited")