@sema-agent/core 2.8.0 → 2.10.0

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/assemble-result.d.ts

@@ -69,6 +69,7 @@ export interface ResultFlags {
     threw: unknown;
     model?: string;
     unpricedSpend?: boolean;
+    rewindNotes?: TaskResult["rewindNotes"];
     abortedForTimeout: boolean;
     abortedForTurns: boolean;
     abortedLive?: boolean;

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

@@ -143,5 +143,5 @@ export function assembleResult(spec, sessionId, final, stats, flags) {
     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 };
+    return { taskId, sessionId, status, ...(flags.model !== undefined ? { model: flags.model } : {}), result: result.trim(), salvagedOutput, blockedReason, errorMessage, errorCode, checkpointToken, checkpointGate, ...(flags.rewindNotes !== undefined && flags.rewindNotes.length > 0 ? { rewindNotes: flags.rewindNotes } : {}), stats: publicStats };
 }

package/dist/core/runner/prepare-task.d.ts

@@ -17,7 +17,7 @@ import { type CwdRef } from "../../tools/fs/index.js";
 import type { Runner } from "./runtask.js";
 import { type CheckpointGate, type CheckpointState, type CheckpointToken, type ResourceLedger, type ResourceLimitReason } from "../checkpoint-store.js";
 import type { AgentMessage, AgentTool, ExecutionEnv } from "../../internal/harness.js";
-import type { RunnerDeps, TaskEvent, TaskSpec, ToolActivity, ToolEffect } from "../types.js";
+import type { RunnerDeps, TaskEvent, TaskResult, TaskSpec, ToolActivity, ToolEffect } from "../types.js";
 import type { RepairBundle } from "../../agents/repair-loop.js";
 export declare const DEFAULT_IRREVERSIBLE_SCOPE = "irreversible";
 export declare function checkpointScopeOf(spec: {
@@ -48,6 +48,7 @@ export interface Prepared {
         tasks: number;
         costMicroUsd: number;
     };
+    rewindNotes?: NonNullable<TaskResult["rewindNotes"]>;
     cwdRef?: CwdRef;
     worktreeSessionRef?: {
         current?: {

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

@@ -616,8 +616,37 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             catch {
             }
         }
-        let rewindTarget = spec.resumeAt !== undefined ? (spec.rewindFiles ? spec.resumeAt : undefined) : spec.rewindFilesTo;
+        const rewindNotes = [];
+        const rewindCaptureRequested = spec.rewindFiles === true;
+        let rewindTarget = spec.resumeAt !== undefined ? (rewindCaptureRequested ? spec.resumeAt : undefined) : spec.rewindFilesTo;
         const rewindBefore = rewindTarget !== undefined && spec.resumeAt !== undefined && spec.resumeAtMode === "before";
+        if (spec.resumeAt !== undefined && !rewindCaptureRequested) {
+            rewindNotes.push({
+                code: "conversation_only",
+                message: `the conversation was branched at entry "${spec.resumeAt}" but the working tree was NOT rewound — this task set resumeAt without rewindFiles, so files remain at their current state`,
+            });
+        }
+        if (!deps.fileSnapshotStore) {
+            if (rewindTarget !== undefined) {
+                const e = new Error(`rewind-files: restoring the working tree to entry "${rewindTarget}" requires a snapshot backend, but this deployment wired no RunnerDeps.fileSnapshotStore — no snapshot was ever captured, so the files were NOT rewound`);
+                e.code = "rewind.store_unconfigured";
+                throw e;
+            }
+            if (rewindCaptureRequested) {
+                rewindNotes.push({
+                    code: "snapshot_store_unconfigured",
+                    message: "rewindFiles was requested but no RunnerDeps.fileSnapshotStore is wired — no working-tree snapshot was captured for this turn, so it cannot be rewound to later",
+                });
+            }
+        }
+        else if (!handsEnabled) {
+            if (rewindTarget !== undefined || rewindCaptureRequested) {
+                rewindNotes.push({
+                    code: "files_env_unsupported",
+                    message: "the file side of rewind was inert: this deployment mounts no filesystem-capable ExecutionEnv, so no working-tree snapshot was captured or restored",
+                });
+            }
+        }
         if (rewindTarget !== undefined && deps.fileSnapshotStore && handsEnabled) {
             if (rewindBefore) {
                 let anchor;
@@ -642,18 +671,13 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             const restoreSignal = spec.signal ? AbortSignal.any([abortController.signal, spec.signal]) : abortController.signal;
             const restored = await deps.fileSnapshotStore.restore(sessionId, rewindTarget, executionEnv, restoreRoot, restoreSignal);
             if (!restored.ok) {
-                if (restored.error.code === "not_found" && rewindBefore) {
-                    const e = new Error(`rewind-files: the resolved "before" snapshot anchor "${rewindTarget}" disappeared before restore — files were NOT rewound`);
+                if (restored.error.code === "not_found") {
+                    const e = new Error(rewindBefore
+                        ? `rewind-files: the resolved "before" snapshot anchor "${rewindTarget}" disappeared before restore — files were NOT rewound`
+                        : `rewind-files: no file snapshot exists for entry "${rewindTarget}" on session "${sessionId}" — the working tree was NOT rewound (only a COMPLETED turn that ran with rewindFiles is snapshotted, and snapshots are keyed by that turn's END leaf; earlier turns that ran without rewindFiles, mid-turn entries, and reaped snapshots have none)`);
                     e.code = "rewind_snapshot.unresolvable";
                     throw e;
                 }
-                if (restored.error.code === "not_found") {
-                    try {
-                        deps.onError?.(new Error(`rewind-files: no snapshot for entry "${rewindTarget}" — files left unchanged`), { phase: "rewind", sessionId });
-                    }
-                    catch {
-                    }
-                }
                 else {
                     const e = new Error(`rewind-files restore failed (${restored.error.code}): ${restored.error.message}`);
                     e.code = "rewind.restore_failed";
@@ -758,6 +782,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 +910,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 +1822,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 +1859,33 @@ 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;
+                            return undefined;
                         activeTools.add(name);
-                        await rematerialize(activeTools);
+                        try {
+                            await rematerialize(activeTools);
+                        }
+                        catch (e) {
+                            activeTools.delete(name);
+                            throw e;
+                        }
+                        return listingRideRef.current?.([name]);
                     },
                 };
             };
@@ -1918,6 +1958,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);
         }
@@ -3341,7 +3382,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             : undefined;
         overheadState.promptChars = systemPrompt.length;
         const preparedHolder = {};
-        const buildPrepared = () => ({ harness, session, sessionId, taskRootPath, model, thinking, compModel, mcp: mcp, blockedRef, outputRef, abortController, conflictRef, blockedToolCalls, nestedStats, cwdRef: handsCwdRef, ...(worktreeSessionRef !== undefined ? { worktreeSessionRef } : {}), ...(workspaceStateSettle !== undefined ? { workspaceStateSettle } : {}), denyNarrowingPolicy, ...(basePolicyForResumeEdit !== undefined ? { basePolicyForResumeEdit } : {}), releaseSignal, cacheBreakDetector, cacheFingerprint, promptManifest, epochDeclaredSections, activeTools, ...(deferred.size > 0 ? { deferredToolNames: deferred } : {}), ownedEnv, suspendRef, reviewRef, reviewRequestRef, suspendLoopRef, suspendForResource, ...(callCapRef ? { callCapRef } : {}), ...(cutKills ? { cutKills } : {}), ...(callCapRef ? { callIssuedAtRef } : {}), suspendForReview, resourceLedger: priorLedger, liveSpendRef, humanReviewRef, now, tools, toolEffects, promptOverheadTokens, readTaskFile, recentlyReadFiles, normalizeAttachmentPath, isDedupStubResult, ...(onCompactionApplied ? { onCompactionApplied } : {}), compactionReuseRef, trimPressureRef, ...(memoryEngineSession ? { memoryEngineSession } : {}), ...(subagentRetain ? { subagentRetain } : {}), ...(lspDiagnostics && nudgeLspOnEdit ? { lspDiagnostics: { registry: lspDiagnostics, nudge: nudgeLspOnEdit } } : {}), planModeRef, ...(dateChange ? { dateChange } : {}), ...(instructionSources ? { instructionSources } : {}), ...(detectExternalChanges ? { detectExternalChanges } : {}), ...(toolsDeltaRef ? { toolsDeltaRef } : {}), ...(agentListing ? { agentListing } : {}), ...(skillsListing ? { skillsListing } : {}), announcedListingsRef, listBackgroundTasks, ...(turnSnapshotRef.current !== undefined ? { turnSnapshot: turnSnapshotRef.current } : {}), ...(centerCompactionCandidate !== undefined ? { centerCompactionCandidate } : {}) });
+        const buildPrepared = () => ({ harness, session, sessionId, taskRootPath, model, thinking, compModel, mcp: mcp, blockedRef, outputRef, abortController, conflictRef, blockedToolCalls, nestedStats, ...(rewindNotes.length > 0 ? { rewindNotes } : {}), cwdRef: handsCwdRef, ...(worktreeSessionRef !== undefined ? { worktreeSessionRef } : {}), ...(workspaceStateSettle !== undefined ? { workspaceStateSettle } : {}), denyNarrowingPolicy, ...(basePolicyForResumeEdit !== undefined ? { basePolicyForResumeEdit } : {}), releaseSignal, cacheBreakDetector, cacheFingerprint, promptManifest, epochDeclaredSections, activeTools, ...(deferred.size > 0 ? { deferredToolNames: deferred } : {}), ownedEnv, suspendRef, reviewRef, reviewRequestRef, suspendLoopRef, suspendForResource, ...(callCapRef ? { callCapRef } : {}), ...(cutKills ? { cutKills } : {}), ...(callCapRef ? { callIssuedAtRef } : {}), suspendForReview, resourceLedger: priorLedger, liveSpendRef, humanReviewRef, now, tools, toolEffects, promptOverheadTokens, readTaskFile, recentlyReadFiles, normalizeAttachmentPath, isDedupStubResult, ...(onCompactionApplied ? { onCompactionApplied } : {}), compactionReuseRef, trimPressureRef, ...(memoryEngineSession ? { memoryEngineSession } : {}), ...(subagentRetain ? { subagentRetain } : {}), ...(lspDiagnostics && nudgeLspOnEdit ? { lspDiagnostics: { registry: lspDiagnostics, nudge: nudgeLspOnEdit } } : {}), planModeRef, ...(dateChange ? { dateChange } : {}), ...(instructionSources ? { instructionSources } : {}), ...(detectExternalChanges ? { detectExternalChanges } : {}), ...(toolsDeltaRef ? { toolsDeltaRef } : {}), ...(agentListing ? { agentListing } : {}), ...(skillsListing ? { skillsListing } : {}), announcedListingsRef, listBackgroundTasks, ...(turnSnapshotRef.current !== undefined ? { turnSnapshot: turnSnapshotRef.current } : {}), ...(centerCompactionCandidate !== undefined ? { centerCompactionCandidate } : {}) });
         const prepared = buildPrepared();
         preparedHolder.current = prepared;
         return prepared;

package/dist/core/runner/runtask.js

@@ -688,13 +688,6 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
                     queue.push({ type: "compaction_outcome", outcome, trigger: passTrigger, ...ident() });
                 }
             }
-            if (comp.compacted && !forceManual) {
-                if (recordCompactionAndCheckRapidRefill(rapidRefill, stats.turns)) {
-                    compactionBreaker.failures = MAX_CONSECUTIVE_COMPACTION_FAILURES;
-                    runnerHooks.onError?.(new Error("compaction.rapid_refill: the context refilled within <3 turns of compaction 3 times in a row — compaction disabled for the rest of this task (thrash spiral; the transcript is dominated by incompressible content)"), { phase: "compaction", sessionId: prepared.sessionId });
-                    queue.push({ type: "compaction_outcome", outcome: "disabled", trigger: passTrigger, reason: "rapid_refill: compaction disabled for the rest of this task", ...ident() });
-                }
-            }
             runnerHooks.recordCompactionReuse(prepared, comp);
             if (comp.compacted) {
                 queue.push({
@@ -713,6 +706,11 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
                     ...(comp.clampReason !== undefined ? { clampReason: comp.clampReason } : {}),
                     ...ident(),
                 });
+                if (!forceManual && recordCompactionAndCheckRapidRefill(rapidRefill, stats.turns)) {
+                    compactionBreaker.failures = MAX_CONSECUTIVE_COMPACTION_FAILURES;
+                    queue.push({ type: "compaction_outcome", outcome: "disabled", trigger: passTrigger, reason: "rapid_refill: compaction disabled for the rest of this task", ...ident() });
+                    runnerHooks.onError?.(new Error("compaction.rapid_refill: the context refilled within <3 turns of compaction 3 times in a row — compaction disabled for the rest of this task (thrash spiral; the transcript is dominated by incompressible content)"), { phase: "compaction", sessionId: prepared.sessionId });
+                }
                 if (comp.phaseDurations !== undefined && comp.durationMs !== undefined) {
                     const pd = comp.phaseDurations;
                     const pdDur = comp.durationMs;
@@ -2074,6 +2072,9 @@ export class Runner {
                 phase: s.phase,
                 ...(s.detail !== undefined ? { detail: s.detail } : {}),
                 ...(s.retryInSec !== undefined ? { retryInSec: s.retryInSec } : {}),
+                ...(s.retryInMs !== undefined ? { retryInMs: s.retryInMs } : {}),
+                ...(s.attempt !== undefined ? { attempt: s.attempt } : {}),
+                ...(s.maxRetries !== undefined ? { maxRetries: s.maxRetries } : {}),
                 ...ident(),
             });
         };
@@ -2675,6 +2676,7 @@ export class Runner {
             minTokens: rs.counters.compactionFloor,
             brain: compactionBrain,
             windowSafety: windowSafetyOptions(prepared.model),
+            onCompactionFailed: (reason) => queue.push({ type: "compaction_outcome", outcome: "failed", trigger: "auto", reason, ...ident() }),
         });
         try {
             if (comp?.compacted) {
@@ -2762,6 +2764,7 @@ export class Runner {
                 threw,
                 model: prepared.model.id,
                 unpricedSpend: rs.telemetry.unpricedSpend,
+                rewindNotes: prepared.rewindNotes,
                 abortedForTimeout: timeout.fired,
                 abortedForTurns: rs.limits.turnsExceeded,
                 abortedLive,
@@ -3043,10 +3046,19 @@ export class Runner {
             if (!leafId)
                 return;
             const root = prepared.taskRootPath;
-            const refusedAt = this.snapshotTooLargeRoots.get(root);
-            if (refusedAt !== undefined) {
-                if (Date.now() - refusedAt < SNAPSHOT_TOO_LARGE_TTL_MS)
+            const refusal = this.snapshotTooLargeRoots.get(root);
+            if (refusal !== undefined) {
+                if (Date.now() - refusal.refusedAt < SNAPSHOT_TOO_LARGE_TTL_MS) {
+                    if (!refusal.skipAnnounced) {
+                        refusal.skipAnnounced = true;
+                        try {
+                            this.deps.onError?.(new Error(`rewind-files snapshot skipped for this working-tree root: a too_large refusal is still inside its ${SNAPSHOT_TOO_LARGE_TTL_MS / 60_000}-minute cooldown (re-probed at ${new Date(refusal.refusedAt + SNAPSHOT_TOO_LARGE_TTL_MS).toISOString()}) — turns completed during the cooldown capture no snapshot and cannot be rewound to. Announced once per cooldown window.`), { phase: "rewind", sessionId: prepared.sessionId, classification: "too_large" });
+                        }
+                        catch {
+                        }
+                    }
                     return;
+                }
                 this.snapshotTooLargeRoots.delete(root);
             }
             const ac = new AbortController();
@@ -3069,11 +3081,14 @@ export class Runner {
             }
             if (!r.ok) {
                 const tooLarge = r.error.code === "too_large";
+                const refusedAt = Date.now();
                 if (tooLarge)
-                    this.snapshotTooLargeRoots.set(root, Date.now());
+                    this.snapshotTooLargeRoots.set(root, { refusedAt, skipAnnounced: false });
                 try {
                     this.deps.onError?.(new Error(`rewind-files snapshot failed (${r.error.code}): ${r.error.message}` +
-                        (tooLarge ? " — skipping further snapshots for this root (this process); raise the store's snapshotBounds or shrink the tree to re-enable rewind" : "")), { phase: "rewind", sessionId: prepared.sessionId, ...(tooLarge ? { classification: "too_large" } : {}) });
+                        (tooLarge
+                            ? ` — skipping further snapshots for this root (this process) during a ${SNAPSHOT_TOO_LARGE_TTL_MS / 60_000}-minute cooldown, until ${new Date(refusedAt + SNAPSHOT_TOO_LARGE_TTL_MS).toISOString()}, when the tree is re-probed automatically. Raise the store's snapshotBounds to accept a tree this size; shrinking the tree also re-enables rewind, but only at that re-probe — not immediately`
+                            : "")), { phase: "rewind", sessionId: prepared.sessionId, ...(tooLarge ? { classification: "too_large" } : {}) });
                 }
                 catch {
                 }
@@ -3516,6 +3531,17 @@ export class Runner {
                 comp = finishComp;
             }
             catch (err) {
+                const failMsg = String(err instanceof Error ? err.message : err);
+                const failReason = failMsg.length > 512 ? `${failMsg.slice(0, 512)}…` : failMsg;
+                emitTrace(spec.tracer ?? this.deps.tracer, () => ({
+                    kind: "compaction.failed",
+                    version: 1,
+                    taskId: spec.taskId ?? prepared.sessionId,
+                    trigger: "auto",
+                    reason: failReason,
+                    ts: Date.now(),
+                }));
+                opts?.onCompactionFailed?.(failReason);
                 this.deps.onError?.(err, { phase: "compaction", sessionId: prepared.sessionId });
             }
         }

package/dist/core/runner/tool-disclosure.d.ts

@@ -1,5 +1,5 @@
 import { type TSchema } from "typebox";
-import type { AgentMessage, AgentTool, AgentToolResult } from "../../internal/harness-types.js";
+import type { AgentMessage, AgentTool, AgentToolResult, AgentToolUpdateCallback, ToolExecutionMode } from "../../internal/harness-types.js";
 import type { Model } from "../../internal/llm.js";
 import type { ToolSpec } from "../types.js";
 export declare const TOOL_SEARCH_NAME = "ToolSearch";
@@ -29,9 +29,13 @@ export declare function buildDeferredRegistry(deferred: ReadonlySet<string>, too
     description: string;
 }>): Map<string, DeferredToolInfo>;
 export interface PlaceholderDirectCall {
+    resolveReal: () => PlaceholderDirectTarget | undefined;
+    executionMode?: ToolExecutionMode;
+    activate: () => Promise<string | undefined>;
+}
+export interface PlaceholderDirectTarget {
     parameters: TSchema;
-    invoke: (toolCallId: string, params: unknown, signal?: AbortSignal) => Promise<AgentToolResult<unknown>>;
-    activate: () => Promise<void>;
+    invoke: (toolCallId: string, params: unknown, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<unknown>) => Promise<AgentToolResult<unknown>>;
 }
 export declare function createPlaceholderTool(info: DeferredToolInfo, direct?: PlaceholderDirectCall): AgentTool;
 export declare function scoreToolMatch(query: string, info: DeferredToolInfo): number;
@@ -52,4 +56,5 @@ export declare function createToolSearchTool(opts: {
     rematerialize: (active: ReadonlySet<string>) => Promise<void>;
     listingRide?: (newlyActivated: readonly string[]) => string | undefined;
     mountedNames?: () => ReadonlySet<string>;
+    directCallEnabled?: boolean;
 }): AgentTool;

package/dist/core/runner/tool-disclosure.js

@@ -43,7 +43,8 @@ export function classifyDeferred(opts) {
             deferred.add(name);
     if (opts.deferMode === "auto") {
         const candidates = opts.fullTools.filter((t) => !deferred.has(t.name) && !pinned.has(t.name));
-        const total = candidates.reduce((n, t) => n + inlinedChars(t), 0);
+        const inlineFace = opts.fullTools.filter((t) => !deferred.has(t.name));
+        const total = inlineFace.reduce((n, t) => n + inlinedChars(t), 0);
         const window = (opts.model.contextTokens ?? opts.model.contextWindow ?? 0) * CHARS_PER_TOKEN;
         if (window > 0 && total > DEFER_AUTO_FRACTION * window) {
             for (const t of candidates)
@@ -70,12 +71,19 @@ export function createPlaceholderTool(info, direct) {
         return {
             name: info.name,
             label: info.name,
-            description: `${info.hint} — deferred: call ${TOOL_SEARCH_NAME}({"query":"select:${sn}"}) to load its parameters before use.`,
+            description: `${info.hint} — deferred: its parameters are not listed here. Call ` +
+                `${TOOL_SEARCH_NAME}({"query":"select:${sn}"}) to load them; a call that already matches this ` +
+                `tool's real parameters runs directly and activates it.`,
             parameters: EMPTY_PARAMS,
-            execute: async (toolCallId, params, signal) => {
-                if (Value.Check(direct.parameters, params)) {
-                    await direct.activate();
-                    return direct.invoke(toolCallId, params, signal);
+            ...(direct.executionMode !== undefined ? { executionMode: direct.executionMode } : {}),
+            execute: async (toolCallId, params, signal, onUpdate) => {
+                const real = direct.resolveReal();
+                if (real !== undefined && Value.Check(real.parameters, params)) {
+                    const ride = await direct.activate();
+                    const result = await real.invoke(toolCallId, params, signal, onUpdate);
+                    if (ride === undefined || ride === "")
+                        return result;
+                    return { ...result, content: [...result.content, { type: "text", text: ride }] };
                 }
                 return teachingRejection();
             },
@@ -163,28 +171,49 @@ export function resolveToolSearch(args, registry) {
 }
 export function extractDiscoveredToolNames(messages, registry) {
     const names = new Set();
+    const pendingDirect = new Map();
     for (const m of messages) {
+        if (m.role === "toolResult") {
+            const name = pendingDirect.get(m.toolCallId);
+            if (name !== undefined && m.isError !== true)
+                names.add(name);
+            continue;
+        }
         if (m.role !== "assistant")
             continue;
         for (const part of m.content) {
-            if (part.type === "toolCall" && part.name === TOOL_SEARCH_NAME) {
+            if (part.type !== "toolCall")
+                continue;
+            if (part.name === TOOL_SEARCH_NAME) {
                 for (const n of resolveToolSearch(part.arguments, registry)) {
                     names.add(n);
                 }
             }
+            else if (registry.has(part.name)) {
+                pendingDirect.set(part.id, part.name);
+            }
         }
     }
     return [...names];
 }
 export function createToolSearchTool(opts) {
     const { registry, active, rematerialize, listingRide, mountedNames } = opts;
+    const directCallEnabled = opts.directCallEnabled !== false;
+    const activationPosture = directCallEnabled
+        ? "Most tools start as name-only placeholders to keep requests small; activating one here loads its full " +
+            "parameter schema. Until you have that schema you cannot reliably form a call, so activate a tool rather " +
+            "than guessing its arguments — a call that does match the real schema executes and activates the tool. " +
+            "When any instruction, reminder, or another tool's description names a deferred tool, activate it here " +
+            'with query "select:<name>". '
+        : "Most tools start as name-only placeholders to keep requests small; to USE one you must activate it here " +
+            "first. When any instruction, reminder, or another tool's description names a deferred tool, activate it " +
+            'with query "select:<name>" before calling it. ';
     let activationChain = Promise.resolve();
     return defineTool({
         name: TOOL_SEARCH_NAME,
         contract: { contractId: "core.tool_search@1", implementationRevision: "1" },
-        description: "Discover and activate deferred tools. Most tools start as name-only placeholders to keep requests " +
-            "small; to USE one you must activate it here first. When any instruction, reminder, or another " +
-            'tool\'s description names a deferred tool, activate it with query "select:<name>" before calling it. ' +
+        description: "Discover and activate deferred tools. " +
+            activationPosture +
             "Query forms: " +
             '"select:ToolA,ToolB" — activate these exact tools by name; ' +
             '"notebook jupyter" — keyword search, up to max_results best matches; ' +

package/dist/core/skills-directory.d.ts

@@ -1,5 +1,5 @@
 import type { SkillSpec } from "./types.js";
-export type SkillsDirectoryWarningCode = "no_skill_file" | "no_frontmatter" | "missing_name" | "invalid_name" | "name_mismatch" | "missing_description" | "description_too_long" | "allowed_tool_not_mounted" | "attachment_skipped" | "read_failed";
+export type SkillsDirectoryWarningCode = "no_skill_file" | "no_frontmatter" | "missing_name" | "invalid_name" | "name_mismatch" | "missing_description" | "description_too_long" | "allowed_tool_not_mounted" | "disallowed_tools_unenforced" | "attachment_skipped" | "read_failed";
 export interface SkillsDirectoryWarning {
     code: SkillsDirectoryWarningCode;
     skill: string;