@sema-agent/core 2.2.0 → 2.3.0

package/dist/agents/teacher.js

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { mapNestedSuspend, isDurablePause } from "./suspend-guard.js";
+import { isDefineToolProduct, stampDefineToolBrand } from "../core/tools.js";
 import { delimitUntrusted, inlineUntrusted } from "../core/untrusted-text.js";
 export const TEACHER_PROMPT = `You are an expert advisor to a less-capable "student" agent that got stuck.
 You receive the task and the student's recent failed attempts. Your job is to help the student RECOVER,
@@ -119,29 +120,56 @@ async function runTeacherCore(runner, studentSpec, teacher) {
         errorStreak = sig === lastErrSig ? errorStreak + 1 : 1;
         lastErrSig = sig;
     };
-    const wrap = (t) => ({
-        ...t,
-        execute: async (args, ctx) => {
-            try {
-                const out = await t.execute(args, ctx);
-                const text = typeof out === "string"
-                    ? out
-                    : out && typeof out === "object" && "content" in out
-                        ? String(out.content)
-                        : (JSON.stringify(out) ?? "");
-                logTool(t.name, args, text);
-                errorStreak = 0;
-                lastErrSig = "";
-                return out;
-            }
-            catch (e) {
-                const errText = String(e);
-                logTool(t.name, args, `ERROR: ${errText}`);
-                onToolFail(t.name, errText);
-                throw e;
-            }
-        },
-    });
+    const wrap = (t) => {
+        if (isDefineToolProduct(t)) {
+            const product = t;
+            return stampDefineToolBrand({
+                ...t,
+                execute: async (toolCallId, rawParams, signal, onUpdate) => {
+                    try {
+                        const out = await product.execute(toolCallId, rawParams, signal, onUpdate);
+                        const blocks = out && typeof out === "object" && "content" in out ? out.content : out;
+                        const text = Array.isArray(blocks)
+                            ? blocks.map((b) => (b && typeof b === "object" && "text" in b ? String(b.text) : "")).join("\n")
+                            : String(blocks ?? "");
+                        logTool(t.name, rawParams, text);
+                        errorStreak = 0;
+                        lastErrSig = "";
+                        return out;
+                    }
+                    catch (e) {
+                        const errText = String(e);
+                        logTool(t.name, rawParams, `ERROR: ${errText}`);
+                        onToolFail(t.name, errText);
+                        throw e;
+                    }
+                },
+            });
+        }
+        return {
+            ...t,
+            execute: async (args, ctx) => {
+                try {
+                    const out = await t.execute(args, ctx);
+                    const text = typeof out === "string"
+                        ? out
+                        : out && typeof out === "object" && "content" in out
+                            ? String(out.content)
+                            : (JSON.stringify(out) ?? "");
+                    logTool(t.name, args, text);
+                    errorStreak = 0;
+                    lastErrSig = "";
+                    return out;
+                }
+                catch (e) {
+                    const errText = String(e);
+                    logTool(t.name, args, `ERROR: ${errText}`);
+                    onToolFail(t.name, errText);
+                    throw e;
+                }
+            },
+        };
+    };
     const tools = studentSpec.tools?.map(wrap);
     const helperBase = () => teacher.helperModel
         ? { model: teacher.helperModel }

package/dist/core/runner/assemble-result.d.ts

@@ -68,6 +68,7 @@ export interface Stats {
 export interface ResultFlags {
     threw: unknown;
     model?: string;
+    unpricedSpend?: boolean;
     abortedForTimeout: boolean;
     abortedForTurns: boolean;
     abortedLive?: boolean;

package/dist/core/runner/assemble-result.js

@@ -36,14 +36,16 @@ export function assembleResult(spec, sessionId, final, stats, flags) {
     const taskId = spec.taskId ?? sessionId;
     const text = final ? assistantText(final) : "";
     stats.totalInputTokens = stats.promptTokens;
-    const compactionMicroUsd = stats.compactionMicroUsd ?? 0;
-    const nestedSubagentMicroUsd = stats.nested?.costMicroUsd ?? 0;
-    stats.costBreakdown = {
-        llmRootMicroUsd: Math.max(0, stats.costMicroUsd - compactionMicroUsd),
-        nestedSubagentMicroUsd,
-        memoryConsolidationMicroUsd: 0,
-        compactionMicroUsd,
-    };
+    if (!flags.unpricedSpend) {
+        const compactionMicroUsd = stats.compactionMicroUsd ?? 0;
+        const nestedSubagentMicroUsd = stats.nested?.costMicroUsd ?? 0;
+        stats.costBreakdown = {
+            llmRootMicroUsd: Math.max(0, stats.costMicroUsd - compactionMicroUsd),
+            nestedSubagentMicroUsd,
+            memoryConsolidationMicroUsd: 0,
+            compactionMicroUsd,
+        };
+    }
     let status;
     const result = text;
     let errorMessage;
@@ -139,5 +141,7 @@ export function assembleResult(spec, sessionId, final, stats, flags) {
     }
     const { compactionMicroUsd: _internalCompaction, ...publicStats } = stats;
     void _internalCompaction;
+    if (flags.unpricedSpend)
+        delete publicStats.costMicroUsd;
     return { taskId, sessionId, status, ...(flags.model !== undefined ? { model: flags.model } : {}), result: result.trim(), salvagedOutput, blockedReason, errorMessage, errorCode, checkpointToken, checkpointGate, stats: publicStats };
 }

package/dist/core/runner/prepare-task.js

@@ -28,7 +28,7 @@ import { cloneObserverInput, formatHookFeedback, runToolGate } from "../hooks.js
 import { reconcileInterruptedSession } from "../session-reconcile.js";
 import { CacheBreakDetector, toolsToFingerprintInputs } from "../cache-break-detector.js";
 import { reservedCollisions, reservedFor } from "../../brain/request-params.js";
-import { defineTool } from "../tools.js";
+import { defineTool, isDefineToolProduct } from "../tools.js";
 import { canonicalToolName } from "../tool-name-aliases.js";
 import { pathToUri } from "../lsp-protocol.js";
 import { DEFAULT_TOOL_RESULT_THRESHOLD_CHARS, buildToolResultRef, firstPartyOffloadPolicy, InMemoryToolResultStore, RunnerSharedToolResultStore, ScopedToolResultStore, isVolatileOffloadStore, OFFLOAD_TOOL_NAME, createReadToolResultTool, withToolResultOffload, } from "../tool-result-store.js";
@@ -796,10 +796,15 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             requestStopAfterTurn,
             ...(spec.enablePlanMode === true ? { enterPlanMode } : {}),
         });
-        const tools = (spec.tools ?? []).map((t) => maybeOffload(defineTool({
-            ...t,
-            execute: (args, ctx) => t.execute(args, enrichSpecToolCtx(ctx)),
-        }), t));
+        const tools = (spec.tools ?? []).map((t) => {
+            if (isDefineToolProduct(t)) {
+                return maybeOffload(t, t);
+            }
+            return maybeOffload(defineTool({
+                ...t,
+                execute: (args, ctx) => t.execute(args, enrichSpecToolCtx(ctx)),
+            }), t);
+        });
         const blockedRef = {};
         if (spec.enableBlockedReport !== false) {
             tools.push(createReportBlockedTool(blockedRef));
@@ -1217,7 +1222,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         if (backgroundTaskToolsActive || workflowToolsActive) {
             toolEffects.set("TaskOutput", "read");
             toolEffects.set("TaskStop", "write");
-            tools.push(firstPartyOffload(createTaskOutputTool({ registry: defaultTaskRegistry, owner: hostTaskId, scope: taskScope, sessionId, workflowStore: deps.workflowRunStore, agentStore: deps.backgroundAgentStore, notificationWired: internals?.onTaskNotification !== undefined, oneShot: spec.oneShot, ...(callCapRef ? { deadlineMs: () => toolCutDeadlineMs(callCapRef, Date.now()) } : {}) })), firstPartyOffload(createTaskStopTool({ registry: defaultTaskRegistry, owner: hostTaskId, scope: taskScope, sessionId, workflowStore: deps.workflowRunStore, agentStore: deps.backgroundAgentStore })));
+            tools.push(firstPartyOffload(createTaskOutputTool({ registry: defaultTaskRegistry, owner: hostTaskId, scope: taskScope, sessionId, workflowStore: deps.workflowRunStore, agentStore: deps.backgroundAgentStore, notificationWired: internals?.onTaskNotification !== undefined, oneShot: spec.oneShot, toolResultStore: offloadStore, ...(callCapRef ? { deadlineMs: () => toolCutDeadlineMs(callCapRef, Date.now()) } : {}) })), firstPartyOffload(createTaskStopTool({ registry: defaultTaskRegistry, owner: hostTaskId, scope: taskScope, sessionId, workflowStore: deps.workflowRunStore, agentStore: deps.backgroundAgentStore })));
             if (runnerSelf && !(spec.tools ?? []).some((t) => t.name === SEND_MESSAGE_TOOL_NAME)) {
                 const delegationForRevive = (spec.tools ?? []).find((t) => t.agentListing !== undefined);
                 const reviveSpawn = delegationForRevive !== undefined && deps.backgroundAgentStore !== undefined && deps.mailboxStore !== undefined
@@ -1277,6 +1282,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 ...(sessionId !== undefined ? { sessionId } : {}),
                 ...(internals?.onTaskNotification !== undefined ? { onTaskNotification: internals.onTaskNotification } : {}),
                 ...(handsCwdRef !== undefined ? { cwdRef: handsCwdRef } : {}),
+                ...(offloadStore !== undefined ? { toolResultStore: offloadStore } : {}),
             })));
         }
         if (handsCwdRef !== undefined) {

package/dist/core/runner/runtask.js

@@ -45,7 +45,7 @@ import { structuredFrom, toolOutputFrom } from "./tool-output-projection.js";
 export { DEFAULT_MAX_TURNS };
 function createRunState() {
     return {
-        telemetry: { cacheFamily: "input-excludes-cached", pricing: { inputPer1M: 0, outputPer1M: 0 }, tracer: undefined, taskId: "", taskStart: 0, taskStartMonotonic: 0, cacheBreakReported: false },
+        telemetry: { cacheFamily: "input-excludes-cached", pricing: { inputPer1M: 0, outputPer1M: 0 }, pricingConfigured: true, unpricedSpend: false, tracer: undefined, taskId: "", taskStart: 0, taskStartMonotonic: 0, cacheBreakReported: false },
         degrade: { degradeToModel: undefined, degraded: undefined, outputErrorStreak: 0, outputInvalid: false, recordDegraded: () => { } },
         limits: { turnsExceeded: false, budgetHit: undefined, outputRetryCap: 0, effectiveMaxTurns: undefined },
         budget: { remainingMicroUsd: undefined, maxCostMicroUsd: undefined, overBudget: () => false, streamCancel: false, callOutputChars: 0, lastStreamBudgetCheck: 0, projectedOverBudget: () => false },
@@ -788,6 +788,8 @@ function makeHarnessHandlers(prepared, stats, rs, deps) {
             const u = m.usage;
             stats.tokens += u.totalTokens || 0;
             const { totalInputTokens: turnInput, costMicroUsd: turnCostMicroUsd } = usageCostMicroUsd(rs.telemetry.cacheFamily, u, rs.telemetry.pricing);
+            if (!rs.telemetry.pricingConfigured)
+                rs.telemetry.unpricedSpend = true;
             stats.promptTokens += turnInput;
             stats.cachedTokens += u.cacheRead || 0;
             stats.cacheWriteTokens += u.cacheWrite || 0;
@@ -826,7 +828,7 @@ function makeHarnessHandlers(prepared, stats, rs, deps) {
                 latencyMs: rs.turn.callStartAt !== undefined ? callEndAt - rs.turn.callStartAt : 0,
                 firstTokenMs: rs.turn.callStartAt !== undefined && rs.turn.firstTokenAt !== undefined ? rs.turn.firstTokenAt - rs.turn.callStartAt : undefined,
                 ...(callIssuedAt !== undefined ? { callStartedAt: callIssuedAt } : {}),
-                costMicroUsd: turnCostMicroUsd,
+                ...(rs.telemetry.pricingConfigured ? { costMicroUsd: turnCostMicroUsd } : {}),
                 ...(capLast !== undefined ? { callCap: capLast.cap, capThinkingSkipped: capLast.thinkingSkipped } : {}),
                 ...(m.role === "assistant" && typeof m.stopReason === "string"
                     ? { stopReason: m.stopReason }
@@ -1628,6 +1630,7 @@ export class Runner {
         const rs = createRunState();
         rs.telemetry.cacheFamily = cacheFamilyOf(prepared.model);
         rs.telemetry.pricing = this.deps.pricing?.[prepared.model.id] ?? modelCostToPricing(prepared.model.cost);
+        rs.telemetry.pricingConfigured = this.deps.pricing?.[prepared.model.id] !== undefined || prepared.model.cost !== undefined;
         if (spec.degrade) {
             try {
                 rs.degrade.degradeToModel = resolveModel(spec.degrade.to, this.deps.models);
@@ -1669,11 +1672,17 @@ export class Runner {
             }
             if (m) {
                 rs.telemetry.pricing = this.deps.pricing?.[m.id] ?? modelCostToPricing(m.cost);
+                rs.telemetry.pricingConfigured = this.deps.pricing?.[m.id] !== undefined || m.cost !== undefined;
                 rs.telemetry.cacheFamily = cacheFamilyOf(m);
             }
             else {
-                if (this.deps.pricing?.[info.to])
+                if (this.deps.pricing?.[info.to]) {
                     rs.telemetry.pricing = this.deps.pricing[info.to];
+                    rs.telemetry.pricingConfigured = true;
+                }
+                else {
+                    rs.telemetry.pricingConfigured = false;
+                }
                 rs.telemetry.cacheFamily = "input-excludes-cached";
             }
             rs.degrade.degraded = info;
@@ -2076,6 +2085,9 @@ export class Runner {
                 return;
             const fam = cacheFamilyOf(m);
             const price = this.deps.pricing?.[m.id] ?? modelCostToPricing(m.cost);
+            const priced = this.deps.pricing?.[m.id] !== undefined || m.cost !== undefined;
+            if (!priced)
+                rs.telemetry.unpricedSpend = true;
             const { totalInputTokens, costMicroUsd } = usageCostMicroUsd(fam, u, price);
             stats.tokens += u.totalTokens || 0;
             stats.promptTokens += totalInputTokens;
@@ -2088,7 +2100,7 @@ export class Runner {
                 kind: "brain.call", version: 1, taskId: rs.telemetry.taskId, model: m.id, provider: m.provider,
                 promptTokens: totalInputTokens, completionTokens: u.output || 0,
                 cacheRead: u.cacheRead || 0, cacheWrite: u.cacheWrite || 0,
-                latencyMs: 0, costMicroUsd, ...(typeof msg?.stopReason === "string" ? { stopReason: msg.stopReason } : {}), ts: Date.now(),
+                latencyMs: 0, ...(priced ? { costMicroUsd } : {}), ...(typeof msg?.stopReason === "string" ? { stopReason: msg.stopReason } : {}), ts: Date.now(),
             }));
         };
         const compactionBrain = {
@@ -2717,6 +2729,7 @@ export class Runner {
             const result = assembleResult(spec, prepared.sessionId, final, stats, {
                 threw,
                 model: prepared.model.id,
+                unpricedSpend: rs.telemetry.unpricedSpend,
                 abortedForTimeout: timeout.fired,
                 abortedForTurns: rs.limits.turnsExceeded,
                 abortedLive,
@@ -2835,7 +2848,7 @@ export class Runner {
                 errorCode: result.errorCode,
                 turns: stats.turns,
                 tokens: stats.tokens,
-                costMicroUsd: stats.costMicroUsd,
+                ...(rs.telemetry.unpricedSpend ? {} : { costMicroUsd: stats.costMicroUsd }),
                 durationMs: Date.now() - rs.telemetry.taskStart,
                 ...(prepared.outputRef.set ? { hasStructuredOutput: true } : {}),
                 ...(stats.mechanisms !== undefined

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

@@ -1,5 +1,6 @@
 import { type BackgroundAgentRecord, type BackgroundAgentStore } from "./background-agent-store.js";
 import { type StopSource, type TaskAccess, type UnifiedTaskResult, type BackgroundAgentTaskHandle, type DurableAgentCore, type ParkedClaimTicket, type RegisterBackgroundAgentInput } from "./task-registry-shared.js";
+import { type ToolResultStore } from "./tool-result-store.js";
 export declare function ensureDurableHeartbeatLane(core: DurableAgentCore): void;
 export declare function durableAgentWriteLane(handle: BackgroundAgentTaskHandle, patch: Partial<BackgroundAgentRecord>, clear?: (keyof BackgroundAgentRecord)[]): void;
 export declare function durableAgentArmedLane(core: DurableAgentCore, id: string): boolean;
@@ -119,5 +120,6 @@ export declare function notFoundRunningAgentsTail(footer: {
     background: string[];
 }): string;
 export declare function serveDurableAgentRowLane(row: BackgroundAgentRecord): UnifiedTaskResult;
-export declare function pollBackgroundAgentLane(handle: BackgroundAgentTaskHandle, deadline?: number, signal?: AbortSignal, oneShot?: boolean): Promise<UnifiedTaskResult>;
+export declare function spillClippedAgentResult(handle: BackgroundAgentTaskHandle, full: string, clipped: string, store: ToolResultStore | undefined, sessionId: string | undefined): Promise<string>;
+export declare function pollBackgroundAgentLane(handle: BackgroundAgentTaskHandle, deadline?: number, signal?: AbortSignal, oneShot?: boolean, store?: ToolResultStore, sessionId?: string): Promise<UnifiedTaskResult>;
 export declare function stopBackgroundAgentLane(core: DurableAgentCore, handle: BackgroundAgentTaskHandle): Promise<UnifiedTaskResult>;

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

@@ -4,6 +4,7 @@ import { canAccessAgentRecord, BackgroundAgentStoreError, } from "./background-a
 import { shutdownDebug } from "./shutdown-debug.js";
 import { delimitUntrusted } from "./untrusted-text.js";
 import { mintCompletionId, commitCompletionIdIfEmpty, clipTaskOutput, assertOwnership, sleepPollStep, alreadyTerminalStopNote, canAccess, normalizeAgentName, closestName, DURABLE_AGENT_HEARTBEAT_MS, DURABLE_AGENT_HANDLE_RE, BG_AGENT_REAP_STOP_ERROR, } from "./task-registry-shared.js";
+import { buildToolResultRef, OFFLOAD_TOOL_NAME } from "./tool-result-store.js";
 export function ensureDurableHeartbeatLane(core) {
     if (core.durableHeartbeatTimer !== undefined)
         return;
@@ -834,6 +835,7 @@ export function reviveBackgroundAgentLane(core, id, access, abort) {
         handle.abort = abort;
     handle.result = undefined;
     handle.resultFull = undefined;
+    handle.spillRef = undefined;
     handle.error = undefined;
     handle.resultIsPartial = undefined;
     handle.stopSource = undefined;
@@ -1022,7 +1024,19 @@ ${clipTaskOutput(row.finalOutputFull ?? row.finalOutput)}` : "(no result text)"}
         },
     };
 }
-export async function pollBackgroundAgentLane(handle, deadline, signal, oneShot) {
+export async function spillClippedAgentResult(handle, full, clipped, store, sessionId) {
+    if (clipped === full)
+        return clipped;
+    if (store === undefined)
+        return clipped;
+    if (handle.spillRef === undefined) {
+        const ref = buildToolResultRef(sessionId ?? "no-session", `${handle.id}_c${handle.reviveCycle ?? 0}`);
+        await store.put(ref, full);
+        handle.spillRef = ref;
+    }
+    return `${clipped}\n\n[full output persisted — call ${OFFLOAD_TOOL_NAME} with ref "${handle.spillRef}" to read it back.]`;
+}
+export async function pollBackgroundAgentLane(handle, deadline, signal, oneShot, store, sessionId) {
     while (handle.status === "running" && deadline !== undefined && Date.now() < deadline && !signal?.aborted) {
         await sleepPollStep(deadline, signal);
     }
@@ -1041,6 +1055,8 @@ 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 body = running
         ? oneShot === true
             ? `status: running
@@ -1050,7 +1066,7 @@ The agent is still working — you will be notified when it completes.`
         : `status: ${handle.status}
 ${handle.error ? `error: ${handle.error}
 ` : ""}${handle.result ? `--- result${handle.resultIsPartial ? " (partial — produced before the task was stopped)" : ""} ---
-${clipTaskOutput(handle.resultFull ?? handle.result, handle.outputFile)}` : "(no result text)"}`;
+${resultText}` : "(no result text)"}`;
     return {
         content: delimitUntrusted(`TaskOutput ${handle.id}`, body),
         details: {

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

@@ -1,5 +1,6 @@
 import { delimitUntrusted } from "./untrusted-text.js";
-import { assertOwnership, defaultMonitorTimers, MONITOR_MAX_TIMEOUT_MS, MONITOR_DEFAULT_TIMEOUT_MS, MONITOR_BATCH_WINDOW_MS, MONITOR_MAX_BATCHES_PER_MINUTE, MONITOR_STORM_BURST, MONITOR_STORM_KILL_AFTER_MS, MONITOR_LINE_BUF_CAP, TASK_OUTPUT_MAX_CHARS, mintCompletionId, clipMonitorEvent, clipMonitorLine, terminalTaskSummary, accountDroppedBytes, rollSpoolText, statusFromBackground, droppedGapNote, firstDropNote, alreadyTerminalStopNote, clipTaskOutput, sleepPollStep, } from "./task-registry-shared.js";
+import { assertOwnership, defaultMonitorTimers, MONITOR_MAX_TIMEOUT_MS, MONITOR_DEFAULT_TIMEOUT_MS, MONITOR_BATCH_WINDOW_MS, MONITOR_MAX_BATCHES_PER_MINUTE, MONITOR_STORM_BURST, MONITOR_STORM_KILL_AFTER_MS, MONITOR_LINE_BUF_CAP, MONITOR_SPILL_CAP_BYTES, TASK_OUTPUT_MAX_CHARS, mintCompletionId, clipMonitorEvent, clipMonitorLine, terminalTaskSummary, accountDroppedBytes, rollSpoolText, statusFromBackground, droppedGapNote, firstDropNote, alreadyTerminalStopNote, clipTaskOutput, sleepPollStep, } from "./task-registry-shared.js";
+import { buildToolResultRef, OFFLOAD_TOOL_NAME } from "./tool-result-store.js";
 export function registerMonitorLane(core, input) {
     assertOwnership(input, "registerMonitor");
     const id = core.mintTaskId("monitor");
@@ -37,17 +38,66 @@ export function registerMonitorLane(core, input) {
         ...(timeoutMs !== undefined ? { timeoutMs, deadlineAt: timers.now() + timeoutMs } : {}),
         timers,
         ...(input.onEvent !== undefined ? { onEvent: input.onEvent } : {}),
+        ...(input.toolResultStore !== undefined ? { toolResultStore: input.toolResultStore } : {}),
+        ...(input.sessionId !== undefined ? { spillSessionId: input.sessionId } : {}),
     };
     core.handles.set(id, handle);
     startMonitorWatcherLane(core, id);
     return id;
 }
+function spillRolledMonitorChunk(handle, stream, dropped) {
+    const store = handle.toolResultStore;
+    if (store === undefined)
+        return;
+    const used = handle.spillBytesUsed ?? 0;
+    if (used >= MONITOR_SPILL_CAP_BYTES) {
+        handle.spillCapped = true;
+        return;
+    }
+    const n = stream === "out" ? (handle.spillSegCount ?? 0) : (handle.spillErrSegCount ?? 0);
+    const ref = buildToolResultRef(handle.spillSessionId ?? "no-session", `${handle.id}_${stream}_seg${n}`);
+    handle.spillBytesUsed = used + dropped.length;
+    if (stream === "out")
+        handle.spillSegCount = n + 1;
+    else
+        handle.spillErrSegCount = n + 1;
+    try {
+        void Promise.resolve(store.put(ref, dropped)).catch(() => {
+            handle.spillFailed = true;
+        });
+    }
+    catch {
+        handle.spillFailed = true;
+    }
+}
+function monitorSpillNote(handle) {
+    const outN = handle.spillSegCount ?? 0;
+    const errN = handle.spillErrSegCount ?? 0;
+    if (outN === 0 && errN === 0)
+        return "";
+    const sid = handle.spillSessionId ?? "no-session";
+    const segLabel = (stream, n) => {
+        const first = buildToolResultRef(sid, `${handle.id}_${stream}_seg0`);
+        return n <= 1 ? `ref "${first}"` : `refs "${first}" .. "${buildToolResultRef(sid, `${handle.id}_${stream}_seg${n - 1}`)}"`;
+    };
+    const clauses = [];
+    if (outN > 0)
+        clauses.push(`stdout ${segLabel("out", outN)}`);
+    if (errN > 0)
+        clauses.push(`stderr ${segLabel("err", errN)}`);
+    const coverage = handle.spillFailed === true
+        ? " — a write failed partway through; the ref chain may be INCOMPLETE, read what is there"
+        : handle.spillCapped === true
+            ? ` — spill cap (${MONITOR_SPILL_CAP_BYTES} bytes) reached; earlier segments retained, later rolls were not spilled`
+            : "";
+    return `; spilled to ${clauses.join(", ")} (read back via ${OFFLOAD_TOOL_NAME})${coverage}`;
+}
 export function absorbMonitorPollLane(handle, v) {
     const spool = handle.spool;
     accountDroppedBytes(spool, v);
     const ROLL_CAP = 2 * TASK_OUTPUT_MAX_CHARS;
-    spool.stdout = rollSpoolText(spool, spool.stdout + v.stdout, ROLL_CAP);
-    spool.stderr = rollSpoolText(spool, spool.stderr + v.stderr, ROLL_CAP);
+    spool.stdout = rollSpoolText(spool, spool.stdout + v.stdout, ROLL_CAP, (dropped) => spillRolledMonitorChunk(handle, "out", dropped));
+    spool.stderr = rollSpoolText(spool, spool.stderr + v.stderr, ROLL_CAP, (dropped) => spillRolledMonitorChunk(handle, "err", dropped));
     handle.lineBuf += v.stdout;
     if (handle.lineBuf.length > MONITOR_LINE_BUF_CAP)
         handle.lineBuf = handle.lineBuf.slice(-MONITOR_LINE_BUF_CAP);
@@ -264,7 +314,7 @@ export async function pollMonitorLane(handle, filter, deadline, signal) {
     const retrieval = running && deadline !== undefined && Date.now() >= deadline ? "timeout" : "success";
     const timedOutClause = spool.timedOut === true ? ` (timed out after ${spool.timeoutSec !== undefined ? `${spool.timeoutSec}s` : "its background time budget"})` : "";
     const displayStatus = (spool.exitCode !== undefined ? `exited(code ${spool.exitCode})` : running ? "running" : handle.status) + timedOutClause;
-    const rolledNote = spool.rolledChars > 0 ? `[!] ${spool.rolledChars} earlier char(s) dropped from the spool (memory bound)\n` : "";
+    const rolledNote = spool.rolledChars > 0 ? `[!] ${spool.rolledChars} earlier char(s) dropped from the spool (memory bound)${monitorSpillNote(handle)}\n` : "";
     const droppedNote = (spool.droppedBytes ?? 0) > 0
         ? `[!] ${spool.droppedBytes} earlier byte(s) permanently dropped before this window (8MB buffer evicted)\n`
         : spool.dropUnknown === true
@@ -299,6 +349,21 @@ function consumePendingSuppressionNote(handle) {
     handle.suppressedBatches = 0;
     return ` [${suppressed} event batch(es) suppressed before the watch ended — output rate was too high; the suppressed output is still readable via TaskOutput.]`;
 }
+function explicitStopTerminalNote(handle, alreadyGone) {
+    const label = (handle.description ?? "monitor").slice(0, 200);
+    const detail = alreadyGone
+        ? "killed before completion (stopped via TaskStop; the process was already gone); watch ended."
+        : "killed before completion (stopped via TaskStop); watch ended.";
+    emitMonitorEventLane(handle, {
+        task_id: handle.id,
+        task_type: "monitor",
+        ...(handle.toolUseId !== undefined ? { toolUseId: handle.toolUseId } : {}),
+        status: "killed",
+        stoppedBy: handle.stoppedBy,
+        summary: `${terminalTaskSummary("monitor", label, "killed")} — ${detail}${droppedGapNote(handle.spool)}`,
+        ...(handle.completionId !== undefined ? { completionId: handle.completionId } : {}),
+    });
+}
 export async function stopMonitorLane(core, handle) {
     const wasRunning = handle.status === "running";
     if (handle.watcher !== undefined) {
@@ -358,7 +423,7 @@ export async function stopMonitorLane(core, handle) {
             handle.status = "killed";
             handle.updatedAt = Date.now();
             mintCompletionId(handle);
-            core.pokeBgQuiescence(handle.owner);
+            core.notifyTerminalOnce(handle, () => explicitStopTerminalNote(handle, true));
             return {
                 content: `Terminated ${handle.id} (the process was already gone).${drainNote}${consumePendingSuppressionNote(handle)}`,
                 details: {
@@ -386,7 +451,7 @@ export async function stopMonitorLane(core, handle) {
         handle.status = "killed";
         handle.updatedAt = Date.now();
         mintCompletionId(handle);
-        core.pokeBgQuiescence(handle.owner);
+        core.notifyTerminalOnce(handle, () => explicitStopTerminalNote(handle, false));
     }
     return {
         content: `Terminated ${handle.id}.${drainNote}${consumePendingSuppressionNote(handle)}`,

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

@@ -4,6 +4,7 @@ import { type WorkflowRunStore } from "./workflow-run-store.js";
 import type { BackgroundAgentRecord, BackgroundAgentStore } from "./background-agent-store.js";
 import type { WorkflowHandle, WorkflowRun } from "../orchestration/workflow.js";
 import type { TaskNotificationPayload } from "./task-notification.js";
+import type { ToolResultStore } from "./tool-result-store.js";
 export type SemaTaskType = "background_bash" | "workflow" | "background_agent" | "monitor";
 export type StopSource = "user" | "parent" | "system" | (string & {});
 export type SemaTaskStatus = "pending" | "running" | "parked" | "completed" | "failed" | "killed" | "cancelled";
@@ -132,6 +133,7 @@ export interface BackgroundAgentTaskHandle extends SemaTaskHandle {
     sessionScoped?: true;
     result?: string;
     resultFull?: string;
+    spillRef?: string;
     error?: string;
     resultIsPartial?: boolean;
     stopSource?: StopSource;
@@ -182,6 +184,13 @@ export interface MonitorTaskHandle extends SemaTaskHandle {
     stopSource?: StopSource;
     stoppedBy?: StopSource;
     terminalNotified?: true;
+    toolResultStore?: ToolResultStore;
+    spillSessionId?: string;
+    spillSegCount?: number;
+    spillErrSegCount?: number;
+    spillBytesUsed?: number;
+    spillCapped?: true;
+    spillFailed?: true;
 }
 export type RegisteredTaskHandle = BackgroundBashTaskHandle | WorkflowTaskHandle | BackgroundAgentTaskHandle | MonitorTaskHandle;
 export interface RegisterMonitorInput extends TaskAccess {
@@ -198,6 +207,7 @@ export interface RegisterMonitorInput extends TaskAccess {
     maxBatchesPerMinute?: number;
     stormBurst?: number;
     now?: number;
+    toolResultStore?: ToolResultStore;
 }
 export interface RegisterWorkflowInput extends TaskAccess {
     runId: string;
@@ -226,7 +236,8 @@ export declare function clipTaskOutput(s: string, fullOutputPath?: string): stri
 export declare function statusFromBackground(status: string, exitCode?: number): SemaTaskStatus;
 export declare function rollSpoolText(spool: {
     rolledChars: number;
-}, s: string, cap: number): string;
+}, s: string, cap: number, onDrop?: (dropped: string) => void): string;
+export declare const MONITOR_SPILL_CAP_BYTES: number;
 export declare function accountDroppedBytes(spool: {
     droppedBytes?: number;
     dropUnknown?: true;

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

@@ -85,13 +85,16 @@ export function statusFromBackground(status, exitCode) {
         return exitCode === 0 ? "completed" : "failed";
     return "failed";
 }
-export function rollSpoolText(spool, s, cap) {
+export function rollSpoolText(spool, s, cap, onDrop) {
     if (s.length <= cap)
         return s;
     const half = Math.floor(cap / 2);
-    spool.rolledChars += s.length - 2 * half;
+    const dropped = s.slice(half, s.length - half);
+    spool.rolledChars += dropped.length;
+    onDrop?.(dropped);
     return s.slice(0, half) + s.slice(s.length - half);
 }
+export const MONITOR_SPILL_CAP_BYTES = 64 * 1024 * 1024;
 export function accountDroppedBytes(spool, poll) {
     const d = poll.bytesDroppedBeforeCursor ?? 0;
     if (d > 0)

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

@@ -4,6 +4,7 @@ import { type BackgroundShellCapability, type BackgroundShellId } from "./backgr
 import type { WorkflowRunStore } from "./workflow-run-store.js";
 import { type BackgroundAgentStore } from "./background-agent-store.js";
 import type { TaskNotificationPayload } from "./task-notification.js";
+import type { ToolResultStore } from "./tool-result-store.js";
 import { type SemaTaskType, type StopSource, type SemaTaskStatus, type TaskRetrievalStatus, type UnifiedTaskOutput, type UnifiedTaskResult, type SemaTaskHandle, type TaskAccess, type BackgroundAgentTaskHandle, type MonitorTimers, type RegisterMonitorInput, type RegisterWorkflowInput, canAccessWorkflowRun, clipTaskOutput, MONITOR_BATCH_WINDOW_MS, MONITOR_DEFAULT_TIMEOUT_MS, MONITOR_MAX_TIMEOUT_MS, MONITOR_MAX_BATCHES_PER_MINUTE } from "./task-registry-shared.js";
 export { normalizeAgentName, DURABLE_AGENT_HEARTBEAT_MS, DURABLE_AGENT_HANDLE_RE, BG_AGENT_REAP_STOP_ERROR } from "./task-registry-shared.js";
 export type { ParkedClaimTicket, RegisterBackgroundAgentInput } from "./task-registry-shared.js";
@@ -33,6 +34,7 @@ export interface TaskPollOptions {
     timeoutMs?: number;
     signal?: AbortSignal;
     oneShot?: boolean;
+    toolResultStore?: ToolResultStore;
 }
 export interface TaskStopOptions {
     workflowStore?: WorkflowRunStore;
@@ -45,6 +47,7 @@ export interface TaskToolOptions extends TaskAccess {
     deadlineMs?: () => number | undefined;
     notificationWired?: boolean;
     oneShot?: boolean;
+    toolResultStore?: ToolResultStore;
 }
 export interface AccessibleTaskRow {
     task_id: string;

package/dist/core/task-registry.js

@@ -151,8 +151,8 @@ export class TaskRegistry {
     runningBackgroundAgentLabels(access) {
         return runningBackgroundAgentLabelsLane(this.core, access);
     }
-    async pollBackgroundAgent(handle, deadline, signal, oneShot) {
-        return pollBackgroundAgentLane(handle, deadline, signal, oneShot);
+    async pollBackgroundAgent(handle, deadline, signal, oneShot, toolResultStore, sessionId) {
+        return pollBackgroundAgentLane(handle, deadline, signal, oneShot, toolResultStore, sessionId);
     }
     async stopBackgroundAgent(handle) {
         return stopBackgroundAgentLane(this.core, handle);
@@ -748,7 +748,7 @@ export class TaskRegistry {
             if (handle.type === "background_bash")
                 return this.pollBackgroundBash(handle, taskId, access, opts.filter, deadline, opts.signal);
             if (handle.type === "background_agent")
-                return this.pollBackgroundAgent(handle, deadline, opts.signal, opts.oneShot);
+                return this.pollBackgroundAgent(handle, deadline, opts.signal, opts.oneShot, opts.toolResultStore, access.sessionId);
             if (handle.type === "monitor")
                 return this.pollMonitor(handle, opts.filter, deadline, opts.signal);
             return this.pollWorkflow(handle, access, deadline, opts.signal);
@@ -1214,6 +1214,7 @@ export function createTaskOutputTool(opts) {
                 timeoutMs: effectiveTimeoutMs,
                 signal: ctx.signal,
                 oneShot: opts.oneShot,
+                toolResultStore: opts.toolResultStore,
             });
             const { type: taskType, ...rest } = r.details;
             return {

package/dist/core/tools.d.ts

@@ -6,4 +6,6 @@ export declare function errorResult(text: string, details?: unknown): {
     isError: true;
     details?: unknown;
 };
+export declare function isDefineToolProduct(x: unknown): x is AgentTool;
+export declare function stampDefineToolBrand<T extends object>(tool: T): T;
 export declare function defineTool<TParams extends TSchema = TSchema>(spec: ToolSpec<TParams>): AgentTool<TParams>;

package/dist/core/tools.js

@@ -25,6 +25,14 @@ function isEmptyToolContent(content) {
 export function errorResult(text, details) {
     return details === undefined ? { content: text, isError: true } : { content: text, isError: true, details };
 }
+const DEFINE_TOOL_BRAND = Symbol("sema.core.defineTool.product");
+export function isDefineToolProduct(x) {
+    return typeof x === "object" && x !== null && x[DEFINE_TOOL_BRAND] === true;
+}
+export function stampDefineToolBrand(tool) {
+    Object.defineProperty(tool, DEFINE_TOOL_BRAND, { value: true, enumerable: false });
+    return tool;
+}
 export function defineTool(spec) {
     const executionMode = spec.executionMode ?? (spec.effect === "read" ? "parallel" : "sequential");
     const tool = {
@@ -72,5 +80,6 @@ export function defineTool(spec) {
             ...(spec.aliases && spec.aliases.length > 0 ? { aliases: spec.aliases } : {}),
         });
     }
+    stampDefineToolBrand(tool);
     return tool;
 }

package/dist/core/workflow-journal-store.d.ts

@@ -26,8 +26,24 @@ export declare function oversizeJournalResult(serialized: string): boolean;
 export declare function callKeyOrdinal(callKey: string): number;
 export declare const JOURNAL_OVERSIZE_ERROR_CODE = "workflow.journal_oversize";
 export declare function journalOversizeTombstone(result: TaskResult, bytes: number): TaskResult;
+export declare const IN_MEMORY_RESUME_CLAIM_TTL_MS: number;
 export declare class InMemoryWorkflowJournalStore implements WorkflowJournalStore {
     private readonly runs;
+    private readonly resumeClaims;
+    private claimsForScope;
+    resumeClaim(input: {
+        sourceRunId: string;
+        newRunId: string;
+        scope: string;
+    }): Promise<{
+        granted: boolean;
+        holder?: string;
+    }>;
+    releaseResumeClaim(input: {
+        sourceRunId: string;
+        newRunId: string;
+        scope: string;
+    }): Promise<void>;
     load(runId: string, scope: string): Promise<WorkflowJournalEntry[]>;
     append(runId: string, scope: string, entry: WorkflowJournalEntry): Promise<void>;
 }

package/dist/core/workflow-journal-store.js

@@ -29,8 +29,36 @@ function snapshot(entry) {
         return JSON.parse(JSON.stringify(entry));
     }
 }
+export const IN_MEMORY_RESUME_CLAIM_TTL_MS = 60 * 60 * 1000;
 export class InMemoryWorkflowJournalStore {
     runs = new Map();
+    resumeClaims = new Map();
+    claimsForScope(scope) {
+        let m = this.resumeClaims.get(scope);
+        if (m === undefined) {
+            m = new Map();
+            this.resumeClaims.set(scope, m);
+        }
+        return m;
+    }
+    async resumeClaim(input) {
+        const table = this.claimsForScope(input.scope);
+        const now = Date.now();
+        const existing = table.get(input.sourceRunId);
+        if (existing !== undefined && existing.expiresAt > now && existing.holder !== input.newRunId) {
+            return { granted: false, holder: existing.holder };
+        }
+        table.set(input.sourceRunId, { holder: input.newRunId, expiresAt: now + IN_MEMORY_RESUME_CLAIM_TTL_MS });
+        return { granted: true };
+    }
+    async releaseResumeClaim(input) {
+        const table = this.resumeClaims.get(input.scope);
+        if (table === undefined)
+            return;
+        const existing = table.get(input.sourceRunId);
+        if (existing !== undefined && existing.holder === input.newRunId)
+            table.delete(input.sourceRunId);
+    }
     async load(runId, scope) {
         const rec = this.runs.get(runId);
         if (!rec || rec.scope !== scope)

package/dist/orchestration/workflow.d.ts

@@ -129,5 +129,20 @@ export interface WorkflowTimers {
     setTimeout(fn: () => void, ms: number): unknown;
     clearTimeout(handle: unknown): void;
 }
+export declare const workflowResumeClaimFallback: {
+    acquire(store: WorkflowJournalStore, input: {
+        sourceRunId: string;
+        newRunId: string;
+        scope: string;
+    }): {
+        granted: boolean;
+        holder?: string;
+    };
+    release(store: WorkflowJournalStore, input: {
+        sourceRunId: string;
+        newRunId: string;
+        scope: string;
+    }): void;
+};
 export declare function startWorkflow<T>(runner: Runner, fn: (ctx: WorkflowRunContext) => Promise<T>, opts?: RunWorkflowOptions, internals?: WorkflowInternals): WorkflowHandle<T>;
 export declare function runWorkflow<T>(runner: Runner, fn: (ctx: WorkflowRunContext) => Promise<T>, opts?: RunWorkflowOptions, internals?: WorkflowInternals): Promise<RunWorkflowResult<T>>;

package/dist/orchestration/workflow.js

@@ -20,6 +20,7 @@ const MAX_TRANSCRIPT_CHARS = 4000;
 const WORKFLOW_RESULT_MAX = 4000;
 const WORKFLOW_RESULT_FULL_MAX = 200_000;
 const MAX_ACTIVITY = 30;
+const RUNNING_AGENT_PERSIST_EVERY_BEATS = 4;
 function workflowModelLabel(spec) {
     const model = spec.model;
     if (model === undefined)
@@ -206,6 +207,33 @@ function createSemaphore(max) {
 function clampRunIdText(raw) {
     return raw.replace(/[^A-Za-z0-9_.:-]/g, "").slice(0, 64);
 }
+const fallbackResumeClaimTables = new WeakMap();
+function fallbackResumeClaimKey(scope, sourceRunId) {
+    return JSON.stringify([scope, sourceRunId]);
+}
+export const workflowResumeClaimFallback = {
+    acquire(store, input) {
+        let table = fallbackResumeClaimTables.get(store);
+        if (table === undefined) {
+            table = new Map();
+            fallbackResumeClaimTables.set(store, table);
+        }
+        const key = fallbackResumeClaimKey(input.scope, input.sourceRunId);
+        const holder = table.get(key);
+        if (holder !== undefined && holder !== input.newRunId)
+            return { granted: false, holder };
+        table.set(key, input.newRunId);
+        return { granted: true };
+    },
+    release(store, input) {
+        const table = fallbackResumeClaimTables.get(store);
+        if (table === undefined)
+            return;
+        const key = fallbackResumeClaimKey(input.scope, input.sourceRunId);
+        if (table.get(key) === input.newRunId)
+            table.delete(key);
+    },
+};
 export function startWorkflow(runner, fn, opts = {}, internals) {
     const alsDepth = currentWorkflowDepth();
     const internalDepth = internals?.workflowDepth;
@@ -566,8 +594,9 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
             throw err;
         }
     };
-    const createActivityCapture = (callKey, label, groupId) => {
+    const createActivityCapture = (callKey, label, groupId, rec) => {
         const tail = [];
+        let beatCount = 0;
         const onActivity = (a) => {
             if (finalized)
                 return;
@@ -587,6 +616,13 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
             tail.push(a);
             if (tail.length > MAX_ACTIVITY)
                 tail.shift();
+            if (a.phase === "start")
+                rec.toolCalls = (rec.toolCalls ?? 0) + 1;
+            rec.activity = tail;
+            beatCount += 1;
+            if (beatCount === 1 || beatCount % RUNNING_AGENT_PERSIST_EVERY_BEATS === 0) {
+                void persist("update");
+            }
         };
         return { tail, onActivity };
     };
@@ -734,8 +770,8 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
             if (budgetTotal !== null && spent() >= budgetTotal) {
                 throw new WorkflowBudgetExceededError(spent(), budgetTotal);
             }
-            const { tail: activityTail, onActivity } = createActivityCapture(callKey, label, groupId);
             const rec = { label, callKey, ...(groupId !== undefined ? { groupId } : {}), phase, prompt, ...(model !== undefined ? { model } : {}), status: "running", queuedAt: now() };
+            const { tail: activityTail, onActivity } = createActivityCapture(callKey, label, groupId, rec);
             run.agents.push(rec);
             if (phaseInstance)
                 agentPhaseOf.set(rec, phaseInstance);
@@ -1047,8 +1083,8 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
             const model = workflowModelLabel(specForIdentity);
             noteDivergence(run.agents.length, "ctx.agentStream results are never replayed");
             diverged = true;
-            const { tail: activityTail, onActivity } = createActivityCapture(callKey, label, groupId);
             const rec = { label, callKey, ...(groupId !== undefined ? { groupId } : {}), phase, prompt, ...(model !== undefined ? { model } : {}), status: "running", queuedAt: now() };
+            const { tail: activityTail, onActivity } = createActivityCapture(callKey, label, groupId, rec);
             run.agents.push(rec);
             if (phaseInstance)
                 agentPhaseOf.set(rec, phaseInstance);
@@ -1388,18 +1424,19 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
         try {
             const runBody = async () => {
                 if (opts.resumeFromRunId !== undefined && journalStore) {
-                    if (journalStore.resumeClaim) {
-                        const verdict = journalStore.resumeClaim({ sourceRunId: opts.resumeFromRunId, newRunId: runId, scope });
-                        resumeClaim = { sourceRunId: opts.resumeFromRunId, verdict };
-                        const decision = await verdict;
-                        if (!decision.granted) {
-                            const holder = decision.holder !== undefined ? clampRunIdText(decision.holder) : "";
-                            throw new Error(`startWorkflow: resume from "${clampRunIdText(opts.resumeFromRunId)}" was REFUSED — ` +
-                                `another run already holds the resume claim on it${holder ? ` (holder: ${holder})` : " (holder unknown to the store)"}. ` +
-                                "Two concurrent resumes of one source run fork its execution: both replay the same prefix and then " +
-                                "re-run the whole suffix live, duplicating every side effect. Wait for the holder to reach a terminal " +
-                                "state (or stop it) and resume again.");
-                        }
+                    const usingFallback = journalStore.resumeClaim === undefined;
+                    const verdict = usingFallback
+                        ? Promise.resolve(workflowResumeClaimFallback.acquire(journalStore, { sourceRunId: opts.resumeFromRunId, newRunId: runId, scope }))
+                        : journalStore.resumeClaim({ sourceRunId: opts.resumeFromRunId, newRunId: runId, scope });
+                    resumeClaim = { sourceRunId: opts.resumeFromRunId, verdict, fallback: usingFallback };
+                    const decision = await verdict;
+                    if (!decision.granted) {
+                        const holder = decision.holder !== undefined ? clampRunIdText(decision.holder) : "";
+                        throw new Error(`startWorkflow: resume from "${clampRunIdText(opts.resumeFromRunId)}" was REFUSED — ` +
+                            `another run already holds the resume claim on it${holder ? ` (holder: ${holder})` : " (holder unknown to the store)"}. ` +
+                            "Two concurrent resumes of one source run fork its execution: both replay the same prefix and then " +
+                            "re-run the whole suffix live, duplicating every side effect. Wait for the holder to reach a terminal " +
+                            "state (or stop it) and resume again.");
                     }
                     const entries = await journalStore.load(opts.resumeFromRunId, scope);
                     for (const e of entries)
@@ -1501,13 +1538,20 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
         finally {
             finalized = true;
             await journalTail.catch(() => undefined);
-            if (resumeClaim !== undefined && journalStore?.releaseResumeClaim) {
+            if (resumeClaim !== undefined) {
                 const granted = await finalizeWithin(timers, resumeClaim.verdict.then((v) => v.granted, () => false), false);
                 if (granted) {
-                    try {
-                        await finalizeWithin(timers, journalStore.releaseResumeClaim({ sourceRunId: resumeClaim.sourceRunId, newRunId: runId, scope }), undefined);
+                    if (resumeClaim.fallback) {
+                        if (journalStore) {
+                            workflowResumeClaimFallback.release(journalStore, { sourceRunId: resumeClaim.sourceRunId, newRunId: runId, scope });
+                        }
                     }
-                    catch {
+                    else if (journalStore?.releaseResumeClaim) {
+                        try {
+                            await finalizeWithin(timers, journalStore.releaseResumeClaim({ sourceRunId: resumeClaim.sourceRunId, newRunId: runId, scope }), undefined);
+                        }
+                        catch {
+                        }
                     }
                 }
             }

package/dist/tools/monitor.d.ts

@@ -1,6 +1,7 @@
 import type { AgentTool, ExecutionEnv } from "../internal/harness-types.js";
 import { type MonitorTimers, type TaskRegistry } from "../core/task-registry.js";
 import type { TaskNotificationPayload } from "../core/task-notification.js";
+import type { ToolResultStore } from "../core/tool-result-store.js";
 export interface MonitorToolOptions {
     registry: TaskRegistry;
     owner?: string;
@@ -15,5 +16,6 @@ export interface MonitorToolOptions {
     timers?: MonitorTimers;
     batchWindowMs?: number;
     maxBatchesPerMinute?: number;
+    toolResultStore?: ToolResultStore;
 }
 export declare function createMonitorTool(env: ExecutionEnv, opts: MonitorToolOptions): AgentTool;

package/dist/tools/monitor.js

@@ -82,6 +82,8 @@ export function createMonitorTool(env, opts) {
                     ...(opts.timers !== undefined ? { timers: opts.timers } : {}),
                     ...(opts.batchWindowMs !== undefined ? { batchWindowMs: opts.batchWindowMs } : {}),
                     ...(opts.maxBatchesPerMinute !== undefined ? { maxBatchesPerMinute: opts.maxBatchesPerMinute } : {}),
+                    ...(opts.sessionId !== undefined ? { sessionId: opts.sessionId } : {}),
+                    ...(opts.toolResultStore !== undefined ? { toolResultStore: opts.toolResultStore } : {}),
                 });
             }
             catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/core",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "Stateless, task-oriented AI agent core",
   "type": "module",
   "license": "BUSL-1.1",