@sema-agent/core 2.8.0 → 2.9.0

package/dist/agents/send-message-tool.js

@@ -1,7 +1,7 @@
 import { Type } from "typebox";
 import { defineTool } from "../core/tools.js";
 import { normalizeAgentName, DURABLE_AGENT_HANDLE_RE, DURABLE_AGENT_HEARTBEAT_MS } from "../core/task-registry.js";
-import { canAccessAgentRecord } from "../core/background-agent-store.js";
+import { canAccessAgentRecord, clearRevivedRowTerminalPayload } from "../core/background-agent-store.js";
 import { escapeAttributeValue, escapeEnvelopeTag, isObserverTaskId, OBSERVER_SENDMESSAGE_SENDER_REFUSAL, OBSERVER_SENDMESSAGE_TARGET_REFUSAL, } from "./observer.js";
 import { SUBAGENT_RESUME_CAP, SubagentRetainLedger, getSessionRetainLedger } from "./retain-ledger.js";
 import { createSubagentResume } from "./subagent.js";
@@ -91,8 +91,9 @@ export function createSendMessageTool(opts) {
             }
             const senderId = ctx.taskId ?? opts.owner;
             const [parentTaskId, parentSessionId] = ctx.parentTaskId !== undefined ? [ctx.parentTaskId, ctx.parentSessionId] : [opts.parentTaskId, opts.parentSessionId];
-            const senderIsChild = parentTaskId !== undefined || opts.uplink !== undefined || opts.senderName !== undefined || opts.siblingRetain !== undefined;
-            const senderLabel = opts.senderName ?? (senderIsChild ? senderId ?? "main" : "main");
+            const senderName = ctx.spawnedAgentName ?? opts.senderName;
+            const senderIsChild = parentTaskId !== undefined || opts.uplink !== undefined || senderName !== undefined || opts.siblingRetain !== undefined;
+            const senderLabel = senderName ?? (senderIsChild ? senderId ?? "main" : "main");
             if (senderId !== undefined && isObserverTaskId(senderId)) {
                 return { content: OBSERVER_SENDMESSAGE_SENDER_REFUSAL, details: { error: "observer_sender" }, isError: true };
             }
@@ -102,7 +103,7 @@ export function createSendMessageTool(opts) {
             if (normalizeAgentName(to) === "main") {
                 if (opts.uplink && senderId !== undefined) {
                     const uplinkSummaryRaw = typeof a.summary === "string" && a.summary.trim() !== "" ? clipSendMessageSummary(a.summary.trim()) : message.slice(0, 80);
-                    const fromLabel = opts.senderName !== undefined ? opts.senderName : senderId;
+                    const fromLabel = senderName ?? senderId;
                     try {
                         opts.uplink({
                             task_id: senderId,
@@ -140,6 +141,9 @@ export function createSendMessageTool(opts) {
                 scope: ctx.principal ?? opts.scope,
                 ...((ctx.sessionId ?? opts.sessionId) !== undefined ? { sessionId: ctx.sessionId ?? opts.sessionId } : {}),
             };
+            const parentAccess = parentTaskId !== undefined
+                ? { ...access, owner: parentTaskId, ...(parentSessionId !== undefined ? { sessionId: parentSessionId } : {}) }
+                : undefined;
             const tier3Revive = async (handle) => {
                 if (opts.agentStore === undefined || opts.mailbox === undefined || opts.reviveSpawn === undefined)
                     return undefined;
@@ -156,10 +160,9 @@ export function createSendMessageTool(opts) {
                 if (!row)
                     return undefined;
                 if (!canAccessAgentRecord(row, access)) {
-                    if (parentTaskId === undefined)
+                    if (parentAccess === undefined)
                         return undefined;
-                    const parentView = { ...access, owner: parentTaskId, ...(parentSessionId !== undefined ? { sessionId: parentSessionId } : {}) };
-                    if (!canAccessAgentRecord(row, parentView))
+                    if (!canAccessAgentRecord(row, parentAccess))
                         return undefined;
                 }
                 if (row.name === undefined || row.agentType === "fork")
@@ -213,15 +216,7 @@ export function createSendMessageTool(opts) {
                     const now = Date.now();
                     const nextSeq = (row.seq ?? 1) + 1;
                     const claimed = { ...row, status: "running", writerId: opts.registry.writerId, writerEpoch: (row.writerEpoch ?? 0) + 1, updatedAt: now, seq: nextSeq };
-                    delete claimed.settledAt;
-                    delete claimed.stoppedBy;
-                    delete claimed.finalOutput;
-                    delete claimed.error;
-                    delete claimed.resultIsPartial;
-                    delete claimed.summary;
-                    delete claimed.recentSteps;
-                    delete claimed.editedFiles;
-                    delete claimed.usage;
+                    clearRevivedRowTerminalPayload(claimed);
                     let won = false;
                     try {
                         won = await opts.agentStore.update(handle, scope, claimed, { rev: row.rev });
@@ -345,12 +340,11 @@ export function createSendMessageTool(opts) {
             };
             let idRow = opts.registry.getAccessibleTask(to, access);
             let resolvedAccess = access;
-            if (!idRow && parentTaskId !== undefined) {
-                const parentView = { ...access, owner: parentTaskId, ...(parentSessionId !== undefined ? { sessionId: parentSessionId } : {}) };
-                const siblingById = opts.registry.getAccessibleTask(to, parentView);
+            if (!idRow && parentAccess !== undefined) {
+                const siblingById = opts.registry.getAccessibleTask(to, parentAccess);
                 if (siblingById) {
                     idRow = siblingById;
-                    resolvedAccess = parentView;
+                    resolvedAccess = parentAccess;
                 }
             }
             if (!idRow && DURABLE_AGENT_HANDLE_RE.test(to)) {
@@ -361,12 +355,13 @@ export function createSendMessageTool(opts) {
             let target = idRow;
             if (!target) {
                 let byName = opts.registry.resolveBackgroundAgentByName(to, access);
-                if (byName.status === "not_found" && parentTaskId !== undefined) {
-                    const parentView = { ...access, owner: parentTaskId, ...(parentSessionId !== undefined ? { sessionId: parentSessionId } : {}) };
-                    const sibling = opts.registry.resolveBackgroundAgentByName(to, parentView);
+                let parentByName;
+                if (byName.status === "not_found" && parentAccess !== undefined) {
+                    const sibling = opts.registry.resolveBackgroundAgentByName(to, parentAccess);
+                    parentByName = sibling;
                     if (sibling.status === "found" || sibling.status === "ambiguous") {
                         byName = sibling;
-                        resolvedAccess = parentView;
+                        resolvedAccess = parentAccess;
                     }
                 }
                 if (byName.status === "ambiguous") {
@@ -381,6 +376,8 @@ export function createSendMessageTool(opts) {
                     if (opts.roster) {
                         try {
                             rosterHit = await opts.roster.resolve(to, access);
+                            if (rosterHit === undefined && parentAccess !== undefined)
+                                rosterHit = await opts.roster.resolve(to, parentAccess);
                         }
                         catch {
                         }
@@ -396,13 +393,17 @@ export function createSendMessageTool(opts) {
                             isError: true,
                         };
                     }
-                    const labels = opts.registry.runningBackgroundAgentLabels(access);
+                    const suggestion = byName.suggestion ?? (parentByName?.status === "not_found" ? parentByName.suggestion : undefined);
+                    const ownLabels = opts.registry.runningBackgroundAgentLabels(access);
+                    const labels = parentAccess !== undefined
+                        ? [...ownLabels, ...opts.registry.runningBackgroundAgentLabels(parentAccess).filter((l) => !ownLabels.includes(l))]
+                        : ownLabels;
                     return {
                         content: `Message not sent: no agent matches "${to}" (unknown id or name, not yours, or expired).` +
-                            (byName.suggestion !== undefined ? ` Did you mean: ${byName.suggestion}?` : "") +
+                            (suggestion !== undefined ? ` Did you mean: ${suggestion}?` : "") +
                             (labels.length > 0 ? ` Running background agents: ${labels.join(", ")}.` : "") +
                             ` Note: a completed foreground agent is not resumable (its transcript is not retained) — spawn with run_in_background to keep an agent addressable, or launch a new agent.`,
-                        details: { error: "not_found", to, ...(byName.suggestion !== undefined ? { suggestion: byName.suggestion } : {}) },
+                        details: { error: "not_found", to, ...(suggestion !== undefined ? { suggestion } : {}) },
                         isError: true,
                     };
                 }
@@ -424,7 +425,7 @@ export function createSendMessageTool(opts) {
                         : message;
                     const teammateXml = frameTeammateMessage({ from: fromLabel, ...(s2Summary !== undefined ? { summary: s2Summary } : {}), text: s2Clipped });
                     const delivered = await opts.registry.deliverToRunningAgent(targetId, resolvedAccess, {
-                        task_id: senderId ?? "main",
+                        task_id: senderLabel,
                         task_type: "background_agent",
                         status: "event",
                         summary: `message from ${fromLabel}${s2Summary !== undefined ? `: ${s2Summary}` : ""}`,
@@ -450,6 +451,13 @@ export function createSendMessageTool(opts) {
                         };
                     }
                     const nowRow = opts.registry.getAccessibleTask(targetId, resolvedAccess);
+                    if (nowRow?.status === "parked") {
+                        return {
+                            content: `Message not sent: ${who} is parked on a pending approval — it resumes when the approval is decided, not by message delivery. Send again after it resumes.`,
+                            details: { error: "parked_pending_approval", to },
+                            isError: true,
+                        };
+                    }
                     const stillLive = nowRow !== undefined && (nowRow.status === "running" || nowRow.status === "pending");
                     return stillLive
                         ? {
@@ -524,7 +532,7 @@ export function createSendMessageTool(opts) {
                     ...(opts.notify ? { currentParentNotify: opts.notify } : {}),
                 });
                 const summary = typeof a.summary === "string" && a.summary.trim() !== "" ? clipSendMessageSummary(a.summary.trim()) : undefined;
-                const fromPrefix = parentTaskId !== undefined ? `(message from teammate "${opts.senderName ?? senderId ?? "unknown"}")\n` : "";
+                const fromPrefix = parentTaskId !== undefined ? `(message from teammate "${senderName ?? senderId ?? "unknown"}")\n` : "";
                 try {
                     const safeSummary = summary !== undefined ? escapeEnvelopeTag(TEAMMATE_MESSAGE_TAG, summary) : undefined;
                     const safeMessage = escapeEnvelopeTag(TEAMMATE_MESSAGE_TAG, message);

package/dist/agents/subagent.js

@@ -1201,6 +1201,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                     tools: [reportTool],
                     ...(ctx.excludeTools !== undefined ? { excludeTools: [...ctx.excludeTools] } : {}),
                     ...(ctx.deferTools !== undefined ? { deferTools: [...ctx.deferTools] } : {}),
+                    ...(ctx.alwaysLoadTools !== undefined ? { alwaysLoadTools: [...ctx.alwaysLoadTools] } : {}),
                     ...(ctx.promptProfile !== undefined ? { promptProfile: ctx.promptProfile } : {}),
                     enableBlockedReport: false,
                     limits: { maxTurns: observerDef.maxTurns ?? 8, timeoutSec: 120 },
@@ -1344,9 +1345,17 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                 parentToolCallId: ctx.toolCallId,
                 ...(childAgentName ? { agentName: childAgentName } : {}),
                 ...(agentName !== undefined ? { explicitAgentName: agentName } : {}),
-                ...(ctx.taskId !== undefined ? { parentTaskId: ctx.taskId } : {}),
-                ...(ctx.sessionId !== undefined ? { parentSessionId: ctx.sessionId } : {}),
-                ...((ctx.rootSessionId ?? ctx.sessionId) !== undefined ? { rootSessionId: ctx.rootSessionId ?? ctx.sessionId } : {}),
+                ...(reviveClaim !== undefined
+                    ? {
+                        ...(reviveClaim.row.parentTaskId !== undefined ? { parentTaskId: reviveClaim.row.parentTaskId } : {}),
+                        ...(reviveClaim.row.parentSessionId !== undefined ? { parentSessionId: reviveClaim.row.parentSessionId } : {}),
+                        ...(reviveClaim.row.rootSessionId !== undefined ? { rootSessionId: reviveClaim.row.rootSessionId } : {}),
+                    }
+                    : {
+                        ...(ctx.taskId !== undefined ? { parentTaskId: ctx.taskId } : {}),
+                        ...(ctx.sessionId !== undefined ? { parentSessionId: ctx.sessionId } : {}),
+                        ...((ctx.rootSessionId ?? ctx.sessionId) !== undefined ? { rootSessionId: ctx.rootSessionId ?? ctx.sessionId } : {}),
+                    }),
                 ...(ctx.centerArtifactDigest !== undefined ? { parentCenterArtifactDigest: ctx.centerArtifactDigest } : {}),
                 ...(ctx.centerSourceRevision !== undefined ? { parentCenterSourceRevision: ctx.centerSourceRevision } : {}),
                 ...(ctx.onTaskNotification !== undefined ? { parentNotify: ctx.onTaskNotification } : {}),
@@ -1375,6 +1384,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                 ...(ctx.clientContext !== undefined ? { clientContext: ctx.clientContext } : {}),
                 ...(ctx.excludeTools !== undefined ? { excludeTools: [...ctx.excludeTools] } : {}),
                 ...(ctx.deferTools !== undefined ? { deferTools: [...ctx.deferTools] } : {}),
+                ...(ctx.alwaysLoadTools !== undefined ? { alwaysLoadTools: [...ctx.alwaysLoadTools] } : {}),
                 ...(ctx.promptProfile !== undefined ? { promptProfile: ctx.promptProfile } : {}),
                 ...(ctx.additionalDirectories !== undefined ? { additionalDirectories: [...ctx.additionalDirectories] } : {}),
                 ...(ctx.envFacts !== undefined ? { envFacts: { ...ctx.envFacts } } : {}),
@@ -1402,6 +1412,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                         ...(plainSpec.clientContext !== undefined ? { clientContext: { ...plainSpec.clientContext } } : {}),
                         ...(plainSpec.excludeTools !== undefined ? { excludeTools: [...plainSpec.excludeTools] } : {}),
                         ...(plainSpec.deferTools !== undefined ? { deferTools: [...plainSpec.deferTools] } : {}),
+                        ...(plainSpec.alwaysLoadTools !== undefined ? { alwaysLoadTools: [...plainSpec.alwaysLoadTools] } : {}),
                     }),
                     internalsSnapshot: { ...childInternals },
                     release: async () => {
@@ -1482,6 +1493,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                             ...(plainSpec.clientContext !== undefined ? { clientContext: { ...plainSpec.clientContext } } : {}),
                             ...(plainSpec.excludeTools !== undefined ? { excludeTools: [...plainSpec.excludeTools] } : {}),
                             ...(plainSpec.deferTools !== undefined ? { deferTools: [...plainSpec.deferTools] } : {}),
+                            ...(plainSpec.alwaysLoadTools !== undefined ? { alwaysLoadTools: [...plainSpec.alwaysLoadTools] } : {}),
                         }),
                         internalsSnapshot: { ...childInternals },
                         release: releaseChild,

package/dist/brain/circuit-breaker.js

@@ -42,20 +42,23 @@ export function createCircuitBreakerBrain(inner, opts = {}) {
     const tryPass = (key) => {
         const s = snap(key);
         if (s.phase === "closed")
-            return true;
+            return { pass: true };
         if (s.phase === "open") {
-            if (s.openedAt !== undefined && now() - s.openedAt >= cooldownMs) {
+            if (s.openedAt === undefined)
+                return { pass: false };
+            const elapsed = now() - s.openedAt;
+            if (elapsed >= cooldownMs) {
                 setState(key, s.phase, { ...s, phase: "half-open", halfOpenInFlight: 1 });
-                return true;
+                return { pass: true };
             }
-            return false;
+            return { pass: false, retryInMs: cooldownMs - elapsed };
         }
         const inFlight = s.halfOpenInFlight ?? 0;
         if (inFlight < halfOpenProbes) {
             state.set(key, { ...s, halfOpenInFlight: inFlight + 1 });
-            return true;
+            return { pass: true };
         }
-        return false;
+        return { pass: false };
     };
     const record = (key, failedCode, viaProbe = true) => {
         const s = snap(key);
@@ -81,8 +84,15 @@ export function createCircuitBreakerBrain(inner, opts = {}) {
         const key = keyOf(model);
         void (async () => {
             const bypass = options?.resilience?.bypassBreaker === true;
-            if (!bypass && !tryPass(key)) {
-                emitBrainStatus({ phase: "circuit_open", detail: "repeated errors, pausing briefly" });
+            const decision = bypass ? { pass: true } : tryPass(key);
+            if (!decision.pass) {
+                emitBrainStatus({
+                    phase: "circuit_open",
+                    detail: "repeated errors, pausing briefly",
+                    ...(decision.retryInMs !== undefined
+                        ? { retryInMs: decision.retryInMs, retryInSec: Math.ceil(decision.retryInMs / 1000) }
+                        : {}),
+                });
                 out.push({ type: "error", reason: "error", error: errorAssistantMessage(model, "network", `${CIRCUIT_OPEN_MARKER}${key}`) });
                 return;
             }

package/dist/brain/retry.d.ts

@@ -1,2 +1,3 @@
 export declare function parseRetryAfter(res: Response | undefined): number | undefined;
+export declare function parseRateLimitReset(res: Response | undefined): number | undefined;
 export declare function retryBackoffMs(baseDelayMs: number, attempt: number, res?: Response, rand?: () => number): number;

package/dist/brain/retry.js

@@ -1,5 +1,7 @@
-const MAX_BACKOFF_MS = 30_000;
-const MAX_RETRY_AFTER_MS = 120_000;
+const MAX_BACKOFF_MS = 32_000;
+const JITTER_FRACTION = 0.25;
+const MAX_HEADER_WAIT_MS = 60_000;
+const RATE_LIMIT_STATUS = 429;
 export function parseRetryAfter(res) {
     const h = res?.headers?.get?.("retry-after");
     if (!h)
@@ -12,11 +14,31 @@ export function parseRetryAfter(res) {
         return Math.max(0, date - Date.now());
     return undefined;
 }
+export function parseRateLimitReset(res) {
+    const h = res?.headers?.get?.("anthropic-ratelimit-unified-reset");
+    if (!h)
+        return undefined;
+    const epochSecs = Number(h);
+    if (!Number.isFinite(epochSecs))
+        return undefined;
+    const ms = Math.round(epochSecs * 1000 - Date.now());
+    return ms > 0 ? ms : undefined;
+}
+function providerWaitHintMs(res) {
+    const hints = [];
+    const retryAfter = parseRetryAfter(res);
+    if (retryAfter !== undefined)
+        hints.push(Math.min(MAX_HEADER_WAIT_MS, retryAfter));
+    if (res?.status === RATE_LIMIT_STATUS) {
+        const reset = parseRateLimitReset(res);
+        if (reset !== undefined)
+            hints.push(Math.min(MAX_HEADER_WAIT_MS, reset));
+    }
+    return hints.length === 0 ? undefined : Math.max(...hints);
+}
 export function retryBackoffMs(baseDelayMs, attempt, res, rand = Math.random) {
     const exp = Math.min(MAX_BACKOFF_MS, baseDelayMs * 2 ** attempt);
-    const jittered = rand() * exp;
-    const retryAfter = parseRetryAfter(res);
-    if (retryAfter === undefined)
-        return jittered;
-    return Math.max(Math.min(MAX_RETRY_AFTER_MS, retryAfter), jittered);
+    const computed = Math.round(exp + rand() * JITTER_FRACTION * exp);
+    const hint = providerWaitHintMs(res);
+    return hint === undefined ? computed : Math.max(hint, computed);
 }

package/dist/brain/stream-engine.d.ts

@@ -4,6 +4,7 @@ export interface StreamEngineConfig extends BrainTimeoutConfig {
     maxRetries?: number;
     retryDelayMs?: number;
 }
+export declare function resolveMaxRetries(configured: number | undefined): number;
 export interface SSERequest {
     url: string;
     headers: Record<string, string>;

package/dist/brain/stream-engine.js

@@ -4,6 +4,22 @@ import { retryBackoffMs } from "./retry.js";
 import { emitBrainStatus, emitBrainTelemetry } from "./status-sink.js";
 import { createConnectController } from "./timeout.js";
 import { WALLTIME_CUTOFF_MESSAGE } from "./walltime.js";
+const DEFAULT_MAX_RETRIES = 10;
+const MAX_RETRIES_ENV_CEILING = 15;
+const MAX_RETRIES_ENV = "SEMA_MAX_RETRIES";
+export function resolveMaxRetries(configured) {
+    if (configured !== undefined)
+        return configured;
+    const raw = process.env[MAX_RETRIES_ENV];
+    if (raw !== undefined && raw.trim() !== "") {
+        const parsed = Number(raw);
+        if (Number.isFinite(parsed) && parsed >= 0)
+            return Math.min(Math.floor(parsed), MAX_RETRIES_ENV_CEILING);
+    }
+    return DEFAULT_MAX_RETRIES;
+}
+const RETRY_STATUS_SLICE_MS = 30_000;
+const THINKING_RETRY_BUDGET = 2;
 const EMPTY_USAGE = {
     input: 0,
     output: 0,
@@ -43,25 +59,54 @@ function sleep(ms, signal) {
         signal?.addEventListener("abort", onAbort, { once: true });
     });
 }
+async function sleepAnnouncingRetry(totalMs, signal, frame) {
+    let remaining = Math.max(0, totalMs);
+    for (;;) {
+        if (signal?.aborted)
+            return;
+        emitBrainStatus(frame(remaining));
+        if (remaining <= 0)
+            return;
+        const slice = Math.min(remaining, RETRY_STATUS_SLICE_MS);
+        await sleep(slice, signal);
+        remaining -= slice;
+        if (remaining <= 0)
+            return;
+    }
+}
 export function runStreamingBrain(args) {
     const { model, doFetch, signal, config, httpLabel, buildRequest, makeParser, callDeadlineMs, stallTimeouts } = args;
     const out = createAssistantMessageEventStream();
     let cleanup;
+    let announcedRetry = false;
+    let terminalRetryPhase = "recovered";
+    let terminalRetryDetail = "recovered after retrying";
     void run()
         .catch((err) => {
         const aborted = signal?.aborted === true || isAbortError(err);
+        terminalRetryPhase = "gave_up";
+        terminalRetryDetail = aborted ? "cancelled while retrying" : "retries exhausted";
         const errorMsg = emptyAssistant(model);
         errorMsg.stopReason = aborted ? "aborted" : "error";
         errorMsg.errorMessage = err instanceof Error ? err.message : String(err);
         errorMsg.usageMissing = true;
         out.push({ type: "error", reason: aborted ? "aborted" : "error", error: errorMsg });
     })
-        .finally(() => cleanup?.());
+        .finally(() => {
+        cleanup?.();
+        if (!announcedRetry)
+            return;
+        try {
+            emitBrainStatus({ phase: terminalRetryPhase, detail: terminalRetryDetail });
+        }
+        catch {
+        }
+    });
     return out;
     async function run() {
         const req = buildRequest();
-        const maxRetries = config.maxRetries ?? 2;
-        const baseDelay = config.retryDelayMs ?? 400;
+        const maxRetries = resolveMaxRetries(config.maxRetries);
+        const baseDelay = config.retryDelayMs ?? 500;
         const firstTokenTimeoutMs = config.firstTokenTimeoutMs ?? stallTimeouts?.firstTokenMs;
         const idleTimeoutMs = config.idleTimeoutMs ?? stallTimeouts?.idleMs;
         const connectTimeoutMs = config.connectTimeoutMs ?? stallTimeouts?.connectMs;
@@ -126,16 +171,19 @@ export function runStreamingBrain(args) {
                     }
                     const statusPhase = r?.status === 429 ? "rate_limited" : netErr !== undefined ? "reconnecting" : "retrying";
                     emitBrainTelemetry({ kind: "retry", attempt: attempt + 1, phase: "connect" });
-                    emitBrainStatus({
+                    announcedRetry = true;
+                    await sleepAnnouncingRetry(delayMs, signal, (remainingMs) => ({
                         phase: statusPhase,
                         detail: statusPhase === "rate_limited"
                             ? "rate limited, backing off"
                             : statusPhase === "reconnecting"
                                 ? "connection lost, reconnecting"
                                 : "transient error, retrying",
-                        retryInSec: Math.ceil(delayMs / 1000),
-                    });
-                    await sleep(delayMs, signal);
+                        retryInSec: Math.ceil(remainingMs / 1000),
+                        retryInMs: remainingMs,
+                        attempt: attempt + 1,
+                        maxRetries,
+                    }));
                     continue;
                 }
                 if (netErr)
@@ -311,14 +359,21 @@ export function runStreamingBrain(args) {
             cleanup?.();
             cleanup = undefined;
             if (snap.hasOnlyThinking) {
-                if (thinkingRetries >= 2)
+                if (thinkingRetries >= THINKING_RETRY_BUDGET)
                     throw failure.err;
                 thinkingRetries++;
                 parser.sealForRetry();
                 const delayMs = 100 * thinkingRetries;
                 emitBrainTelemetry({ kind: "retry", attempt: thinkingRetries, phase: "midstream" });
-                emitBrainStatus({ phase: "reconnecting", detail: "connection lost, reconnecting", retryInSec: Math.ceil(delayMs / 1000) });
-                await sleep(delayMs, signal);
+                announcedRetry = true;
+                await sleepAnnouncingRetry(delayMs, signal, (remainingMs) => ({
+                    phase: "reconnecting",
+                    detail: "connection lost, reconnecting",
+                    retryInSec: Math.ceil(remainingMs / 1000),
+                    retryInMs: remainingMs,
+                    attempt: thinkingRetries,
+                    maxRetries: THINKING_RETRY_BUDGET,
+                }));
                 continue;
             }
             if (attempt >= maxRetries)
@@ -326,8 +381,15 @@ export function runStreamingBrain(args) {
             const delayMs = retryBackoffMs(baseDelay, attempt);
             attempt++;
             emitBrainTelemetry({ kind: "retry", attempt, phase: "midstream" });
-            emitBrainStatus({ phase: "reconnecting", detail: "connection lost, reconnecting", retryInSec: Math.ceil(delayMs / 1000) });
-            await sleep(delayMs, signal);
+            announcedRetry = true;
+            await sleepAnnouncingRetry(delayMs, signal, (remainingMs) => ({
+                phase: "reconnecting",
+                detail: "connection lost, reconnecting",
+                retryInSec: Math.ceil(remainingMs / 1000),
+                retryInMs: remainingMs,
+                attempt,
+                maxRetries,
+            }));
         }
     }
 }

package/dist/core/auto-compaction.js

@@ -1,4 +1,4 @@
-import { DEFAULT_CHARS_PER_TOKEN, DEFAULT_CLAMP_TOLERANCE, DEFAULT_COMPACTION_SETTINGS, CompactionError, compact, computeFileLists, dryRunSummarizationClamp, estimateContextTokens, estimateTokens, prepareCompaction, shouldCompact, } from "../internal/harness.js";
+import { DEFAULT_CHARS_PER_TOKEN, DEFAULT_CLAMP_TOLERANCE, DEFAULT_COMPACTION_SETTINGS, CompactionError, compact, computeFileLists, dryRunSummarizationClamp, estimateContextTokens, estimateTokens, formatPersistedOutputRefs, prepareCompaction, shouldCompact, } from "../internal/harness.js";
 import { fileArgPath } from "../tools/fs/safety.js";
 import { contextEditFrontier } from "./context-edit.js";
 import { selectCompactionEpoch } from "../prompt-assembly/epoch.js";
@@ -155,6 +155,14 @@ export async function maybeCompact(opts) {
         if (prep.value.invokedSkills.length > 0) {
             details.invokedSkills = prep.value.invokedSkills;
         }
+        const reusedRefs = prep.value.persistedOutputRefs ?? [];
+        if (reusedRefs.length > 0) {
+            details.persistedOutputRefs = reusedRefs;
+            summary += formatPersistedOutputRefs(reusedRefs);
+        }
+        if (prep.value.elidedMessages !== undefined && prep.value.elidedMessages > 0) {
+            details.elidedMessages = prep.value.elidedMessages;
+        }
     }
     else {
         let summaryModel = opts.compactionModel ?? opts.model;

package/dist/core/background-agent-store.d.ts

@@ -46,6 +46,8 @@ export interface BackgroundAgentRecord {
     usage?: BackgroundAgentUsage;
     rev: number;
 }
+export declare const REVIVED_ROW_CLEARED_FIELDS: readonly ["settledAt", "stoppedBy", "completionId", "finalOutput", "finalOutputFull", "error", "errorCode", "errorRetryable", "errorKind", "resultIsPartial", "summary", "recentSteps", "editedFiles", "usage"];
+export declare function clearRevivedRowTerminalPayload(record: BackgroundAgentRecord): void;
 export interface BackgroundAgentRowSummary {
     handle: string;
     owner: string;

package/dist/core/background-agent-store.js

@@ -1,4 +1,24 @@
 import { uuidv7 } from "../internal/harness.js";
+export const REVIVED_ROW_CLEARED_FIELDS = [
+    "settledAt",
+    "stoppedBy",
+    "completionId",
+    "finalOutput",
+    "finalOutputFull",
+    "error",
+    "errorCode",
+    "errorRetryable",
+    "errorKind",
+    "resultIsPartial",
+    "summary",
+    "recentSteps",
+    "editedFiles",
+    "usage",
+];
+export function clearRevivedRowTerminalPayload(record) {
+    for (const field of REVIVED_ROW_CLEARED_FIELDS)
+        delete record[field];
+}
 export class BackgroundAgentStoreError extends Error {
     code;
     constructor(code, message) {

package/dist/core/mcp.js

@@ -145,6 +145,11 @@ const MCP_SPEC_ERROR_CODE_NAMES = new Map([
 export function describeMcpSpecErrorCode(code) {
     return typeof code === "number" ? MCP_SPEC_ERROR_CODE_NAMES.get(code) : undefined;
 }
+function namedMcpFailureText(err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    const condition = err instanceof McpError ? describeMcpSpecErrorCode(err.code) : undefined;
+    return condition !== undefined ? `${condition}: ${detail}` : detail;
+}
 function isTransportLost(err) {
     if (err instanceof McpError && err.code === ErrorCode.ConnectionClosed)
         return true;
@@ -555,7 +560,7 @@ export async function materializeMcpTools(specs, principal, onElicit, imageResiz
             }
             else {
                 warnings.push(asServerWarning(spec, r.reason));
-                statuses.push({ name: spec.name, status: "failed", error: r.reason instanceof Error ? r.reason.message : String(r.reason) });
+                statuses.push({ name: spec.name, status: "failed", error: namedMcpFailureText(r.reason) });
             }
         }
         const resourceTools = buildResourceTools(resourceServers);
@@ -614,7 +619,7 @@ export async function materializeMcpTools(specs, principal, onElicit, imageResiz
                         toolCount: h.toolNames.length,
                         added: [],
                         removed: [],
-                        error: inlineUntrusted(err instanceof Error ? err.message : String(err), 240),
+                        error: inlineUntrusted(namedMcpFailureText(err), 240),
                     });
                 }
             }
@@ -1155,9 +1160,7 @@ function intakeListedTools(listed, spec, client, health, imageResizer) {
     return { serverTools, serverAxes, dropped };
 }
 function asServerWarning(spec, err) {
-    const detail = err instanceof Error ? err.message : String(err);
-    const condition = err instanceof McpError ? describeMcpSpecErrorCode(err.code) : undefined;
-    const warning = new Error(`mcp: server "${spec.name}" failed to connect — skipped (${condition !== undefined ? `${condition}: ` : ""}${detail})`, { cause: err });
+    const warning = new Error(`mcp: server "${spec.name}" failed to connect — skipped (${namedMcpFailureText(err)})`, { cause: err });
     warning.code = "mcp.server_unavailable";
     return warning;
 }

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

@@ -758,6 +758,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             clientContext: spec.clientContext,
             excludeTools: toolFaceSnapshot.exclude,
             deferTools: toolFaceSnapshot.defer,
+            alwaysLoadTools: toolFaceSnapshot.alwaysLoad,
             promptProfile,
             ...(spec.additionalDirectories !== undefined ? { additionalDirectories: Object.freeze([...spec.additionalDirectories]) } : {}),
             ...(spec.envFacts !== undefined ? { envFacts: { ...spec.envFacts } } : {}),
@@ -885,6 +886,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 governanceBaseline: deps.workflowGovernanceBaseline,
                 parentExcludeTools: toolFaceSnapshot.exclude,
                 parentDeferTools: toolFaceSnapshot.defer,
+                parentAlwaysLoadTools: toolFaceSnapshot.alwaysLoad,
                 parentPromptProfile: promptProfile,
                 models: deps.models,
                 agents: deps.agents,
@@ -1796,7 +1798,9 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             deferNames: (toolFaceSnapshot.defer ?? []).filter((n) => tools.some((t) => t.name === n)),
             alwaysLoadNames: [
                 ...(toolFaceSnapshot.alwaysLoad ?? []),
-                ...mcp.tools.filter((t) => t.mcpAlwaysLoad === true).map((t) => t.name),
+                ...mcp.tools
+                    .filter((t) => t.mcpAlwaysLoad === true && !(toolFaceSnapshot.defer ?? []).includes(t.name))
+                    .map((t) => t.name),
             ],
         });
         for (const n of [...deferred]) {
@@ -1831,21 +1835,32 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 throw e;
             }
             const registry = buildDeferredRegistry(deferred, tools);
-            const realByName = new Map(tools.map((t) => [t.name, t]));
             const directCallFor = (name) => {
                 if (spec.deferSelfResolve === false)
                     return undefined;
-                const real = realByName.get(name);
-                if (real === undefined)
-                    return undefined;
+                const executionMode = tools.find((t) => t.name === name)?.executionMode;
                 return {
-                    parameters: real.parameters,
-                    invoke: (toolCallId, params, signal) => real.execute(toolCallId, params, signal),
+                    resolveReal: () => {
+                        const real = tools.find((t) => t.name === name);
+                        if (real === undefined)
+                            return undefined;
+                        return {
+                            parameters: real.parameters,
+                            invoke: (toolCallId, params, signal, onUpdate) => real.execute(toolCallId, params, signal, onUpdate),
+                        };
+                    },
+                    ...(executionMode !== undefined ? { executionMode } : {}),
                     activate: async () => {
                         if (activeTools.has(name))
                             return;
                         activeTools.add(name);
-                        await rematerialize(activeTools);
+                        try {
+                            await rematerialize(activeTools);
+                        }
+                        catch (e) {
+                            activeTools.delete(name);
+                            throw e;
+                        }
                     },
                 };
             };
@@ -1918,6 +1933,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 rematerialize,
                 listingRide: (newly) => listingRideRef.current?.(newly),
                 mountedNames: () => new Set(buildToolList(activeTools).map((t) => t.name).filter((n) => !registry.has(n) || activeTools.has(n))),
+                directCallEnabled: spec.deferSelfResolve !== false,
             });
             harnessTools = buildToolList(activeTools);
         }