@sema-agent/core 5.14.0 → 5.16.0

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

@@ -38,7 +38,7 @@ import { pathToUri } from "../lsp-protocol.js";
 import { DEFAULT_TOOL_RESULT_THRESHOLD_CHARS, createOffloadPersist, firstPartyOffloadPolicy, InMemoryToolResultStore, RunnerSharedToolResultStore, ScopedToolResultStore, isVolatileOffloadStore, OFFLOAD_TOOL_NAME, createReadToolResultTool, withToolResultOffload, } from "../tool-result-store.js";
 import { OUTPUT_TOOL_NAME, REPORT_FINDINGS_TOOL_NAME, SKILL_CONTENT_MAX_CHARS, SKILL_TOOL_NAME, createOutputTool, createReportBlockedTool, createReportFindingsTool, createSkillTool, normalizeSkills } from "./synthetic-tools.js";
 import { compileOutputSchema } from "./strict-output-schema.js";
-import { TOOL_SEARCH_NAME, buildDeferredRegistry, classifyDeferred, extractDiscoveredToolNames, createPlaceholderTool, createToolSearchTool, } from "./tool-disclosure.js";
+import { TOOL_SEARCH_NAME, buildDeferredRegistry, classifyDeferred, extractDiscoveredToolNames, createPlaceholderTool, createToolSearchTool, staticSchemaRenderable, } from "./tool-disclosure.js";
 import { composeMemoryBlock } from "../memory.js";
 import { preflightLockedConfig } from "../locked-config.js";
 import { COMPLIANCE_CAPABILITIES, WEB_FETCH_TOOL_NAME, complianceCallDenial, resolveComplianceDenies } from "../compliance.js";
@@ -629,6 +629,13 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
     if (extraBodyCollisions.length > 0) {
         deps.onError?.(new Error(`model.extraBody contains reserved key(s) [${extraBodyCollisions.join(", ")}] that core owns and sets itself — they are ignored. Remove them from extraBody.`), { phase: "config", sessionId });
     }
+    if (model.extraBody !== undefined && Object.prototype.hasOwnProperty.call(model.extraBody, "max_completion_tokens")) {
+        const e = new Error(`model.extraBody supplies "max_completion_tokens" — this spelling is engine-owned (the overflow retry ` +
+            `adjusts the per-request output cap, and a constant extraBody value would override that adjustment on ` +
+            `every retry). Set the cap via limits.maxOutputTokens (per request) or model.maxTokens instead.`);
+        e.code = "config.extra_body_output_cap";
+        throw e;
+    }
     const nestedStats = { tokens: 0, turns: 0, tasks: 0, costMicroUsd: 0, anyUnpriced: false };
     if (resume) {
         nestedStats.tokens = resume.seed.nestedStats.tokens;
@@ -1592,6 +1599,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                     return memoryWriteGateRef.current?.(w);
                 },
                 mountBackgroundTaskTools: false,
+                monitorToolActive: backgroundTaskToolsActive && !(toolFaceSnapshot.exclude?.includes("Monitor") ?? false),
             });
             {
                 const bandNames = new Set(band.flatMap((t) => [t.name, ...(t.aliases ?? [])]));
@@ -1844,6 +1852,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             sessionId,
             taskRootPath,
             memoryWriteGateRef,
+            writeToolsMounted: tools.some((t) => t.name === "Write") && !(toolFaceSnapshot.exclude?.includes("Write") ?? false),
             admissionCtx: {
                 orgMemoryDenied: complianceDenies.has("org_memory_mount"),
                 complianceDegraded,
@@ -2282,6 +2291,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             .map((s) => ({ name: inlineUntrusted(s.name, 160), ...(s.error !== undefined ? { error: inlineUntrusted(s.error, 240) } : {}) }));
         let toolsDeltaRef;
         let toolMaterializeStatic = false;
+        const staticFaceForRef = {};
         if (deferred.size > 0 || failedMcpServers.length > 0) {
             toolsDeltaRef = { pending: [], pendingRemoved: [], pendingReadded: [], pendingFailed: failedMcpServers };
         }
@@ -2293,6 +2303,33 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 throw e;
             }
             const registry = buildDeferredRegistry(deferred, tools);
+            const envStrategy = process.env.SEMA_TOOL_MATERIALIZE_STRATEGY;
+            if (envStrategy !== undefined && envStrategy !== "swap" && envStrategy !== "static") {
+                const e = new Error(`SEMA_TOOL_MATERIALIZE_STRATEGY must be "swap" or "static" (got ${JSON.stringify(envStrategy)}).`);
+                e.code = "config.tool_materialize_invalid";
+                throw e;
+            }
+            const requestedStrategy = spec.toolMaterializeStrategy ?? envStrategy ?? "swap";
+            const laneDegrade = requestedStrategy === "static" && spec.deferSelfResolve === false;
+            const materializeStatic = requestedStrategy === "static" && !laneDegrade;
+            toolMaterializeStatic = materializeStatic;
+            promptManifest.toolDisclosure = {
+                deferredTools: deferred.size,
+                strategy: materializeStatic ? "static" : "swap",
+                source: laneDegrade ? "degraded_no_direct_lane" : spec.toolMaterializeStrategy !== undefined ? "spec" : envStrategy !== undefined ? "env" : "default",
+            };
+            const everExempt = new Set();
+            const staticFaceFor = (name) => {
+                if (!materializeStatic)
+                    return false;
+                if (everExempt.has(name))
+                    return false;
+                if (staticSchemaRenderable(tools.find((t) => t.name === name)?.parameters))
+                    return true;
+                everExempt.add(name);
+                return false;
+            };
+            staticFaceForRef.current = staticFaceFor;
             let activationChain = Promise.resolve();
             const serializeActivation = (section) => {
                 const p = activationChain.then(section);
@@ -2314,6 +2351,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                         };
                     },
                     ...(executionMode !== undefined ? { executionMode } : {}),
+                    staticFace: () => staticFaceFor(name),
                     activate: async () => serializeActivation(async () => {
                         if (activeTools.has(name))
                             return undefined;
@@ -2358,16 +2396,8 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             };
             offloadReachableToolsRef.current = callableToolNames;
             let toolSearch;
-            const envStrategy = process.env.SEMA_TOOL_MATERIALIZE_STRATEGY;
-            if (envStrategy !== undefined && envStrategy !== "swap" && envStrategy !== "static") {
-                const e = new Error(`SEMA_TOOL_MATERIALIZE_STRATEGY must be "swap" or "static" (got ${JSON.stringify(envStrategy)}).`);
-                e.code = "config.tool_materialize_invalid";
-                throw e;
-            }
-            const materializeStatic = (spec.toolMaterializeStrategy ?? envStrategy ?? "static") === "static" && spec.deferSelfResolve !== false;
-            toolMaterializeStatic = materializeStatic;
             const buildToolList = (active) => {
-                const list = tools.map((t) => (deferred.has(t.name) && (materializeStatic || !active.has(t.name)) ? placeholders.get(t.name) : t));
+                const list = tools.map((t) => (deferred.has(t.name) && (staticFaceFor(t.name) || !active.has(t.name)) ? placeholders.get(t.name) : t));
                 list.push(toolSearch);
                 return list;
             };
@@ -2408,8 +2438,9 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 listingRide: (newly) => listingRideRef.current?.(newly),
                 mountedNames: callableToolNames,
                 directCallEnabled: spec.deferSelfResolve !== false,
+                isMounted: (name) => tools.some((t) => t.name === name),
                 ...(materializeStatic
-                    ? { staticSchemaFor: (name) => tools.find((t) => t.name === name)?.parameters }
+                    ? { staticSchemaFor: (name) => (staticFaceFor(name) ? tools.find((t) => t.name === name)?.parameters : undefined) }
                     : {}),
                 serializeActivation,
             });
@@ -4108,7 +4139,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, ...(a2a !== undefined && a2a.tools.length > 0 ? { a2a } : {}), blockedRef, outputRef, abortController, conflictRef, blockedToolCalls, nestedStats, ...(rewindNotes.length > 0 ? { rewindNotes } : {}), cwdRef: handsCwdRef, ...(worktreeSessionRef !== undefined ? { worktreeSessionRef } : {}), ...(workspaceStateSettle !== undefined ? { workspaceStateSettle } : {}), denyNarrowingPolicy, ...(basePolicyForResumeEdit !== undefined ? { basePolicyForResumeEdit } : {}), releaseSignal, settleContentAskBindings, cacheBreakDetector, cacheFingerprint, wiringManifest, promptManifest, epochDeclaredSections, activeTools, ...(deferred.size > 0 ? { deferredToolNames: deferred } : {}), toolMaterializeStatic, ownedEnv, suspendRef, suspendProgressRef, reviewRef, remoteEnvFailures, reviewRequestRef, suspendLoopRef, suspendForResource, ...(suspendForPlatformLimit !== undefined ? { suspendForPlatformLimit } : {}), ...(envLifetimeSuspendAt !== undefined ? { envLifetimeSuspendAt } : {}), ...(usageGovernance !== undefined ? { usageGovernance } : {}), callIssuedAtRef, brainCallGuardrailRef, suspendForReview, resourceLedger: priorLedger, liveSpendRef, humanReviewRef, now, tools, toolEffects, wakeRecovered, promptOverheadTokens, lastBrainContext, readTaskFile, recentlyReadFiles, normalizeAttachmentPath, isDedupStubResult, ...(onCompactionApplied ? { onCompactionApplied } : {}), compactionReuseRef, trimPressureRef, ...(memoryEngineSession ? { memoryEngineSession } : {}), ...(subagentRetain ? { subagentRetain } : {}), ...(lspDiagnostics && nudgeLspOnEdit ? { lspDiagnostics: { registry: lspDiagnostics, nudge: nudgeLspOnEdit, runIdent: lspRunIdent } } : {}), planModeRef, ...(dateChange ? { dateChange } : {}), ...(instructionSources ? { instructionSources } : {}), ...(workflowSizeGuideline ? { workflowSizeGuideline } : {}), ...(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, ...(a2a !== undefined && a2a.tools.length > 0 ? { a2a } : {}), blockedRef, outputRef, abortController, conflictRef, blockedToolCalls, nestedStats, ...(rewindNotes.length > 0 ? { rewindNotes } : {}), cwdRef: handsCwdRef, ...(worktreeSessionRef !== undefined ? { worktreeSessionRef } : {}), ...(workspaceStateSettle !== undefined ? { workspaceStateSettle } : {}), denyNarrowingPolicy, ...(basePolicyForResumeEdit !== undefined ? { basePolicyForResumeEdit } : {}), releaseSignal, settleContentAskBindings, cacheBreakDetector, cacheFingerprint, wiringManifest, promptManifest, epochDeclaredSections, activeTools, ...(deferred.size > 0 ? { deferredToolNames: deferred } : {}), toolMaterializeStatic, ...(staticFaceForRef.current !== undefined ? { staticFaceFor: staticFaceForRef.current } : {}), ownedEnv, suspendRef, suspendProgressRef, reviewRef, remoteEnvFailures, reviewRequestRef, suspendLoopRef, suspendForResource, ...(suspendForPlatformLimit !== undefined ? { suspendForPlatformLimit } : {}), ...(envLifetimeSuspendAt !== undefined ? { envLifetimeSuspendAt } : {}), ...(usageGovernance !== undefined ? { usageGovernance } : {}), callIssuedAtRef, brainCallGuardrailRef, suspendForReview, resourceLedger: priorLedger, liveSpendRef, humanReviewRef, now, tools, toolEffects, wakeRecovered, promptOverheadTokens, lastBrainContext, readTaskFile, recentlyReadFiles, normalizeAttachmentPath, isDedupStubResult, ...(onCompactionApplied ? { onCompactionApplied } : {}), compactionReuseRef, trimPressureRef, ...(memoryEngineSession ? { memoryEngineSession } : {}), ...(subagentRetain ? { subagentRetain } : {}), ...(lspDiagnostics && nudgeLspOnEdit ? { lspDiagnostics: { registry: lspDiagnostics, nudge: nudgeLspOnEdit, runIdent: lspRunIdent } } : {}), planModeRef, ...(dateChange ? { dateChange } : {}), ...(instructionSources ? { instructionSources } : {}), ...(workflowSizeGuideline ? { workflowSizeGuideline } : {}), ...(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

@@ -172,11 +172,12 @@ function deepJsonEqual(a, b) {
 function isCanonicalIndexKey(key, length) {
     return /^(0|[1-9]\d*)$/.test(key) && Number(key) < length;
 }
-function sameWinner(a, b) {
-    return (a.boundCallId === b.boundCallId &&
-        a.decision === b.decision &&
-        deepJsonEqual(a.updatedInput, b.updatedInput) &&
-        deepJsonEqual(a.answer, b.answer));
+function sameWinner(incoming, persisted) {
+    return (incoming.boundCallId === persisted.boundCallId &&
+        incoming.decision === persisted.decision &&
+        deepJsonEqual(incoming.updatedInput, persisted.updatedInput) &&
+        deepJsonEqual(incoming.answer, persisted.answer) &&
+        (persisted.reason === undefined || incoming.reason === persisted.reason));
 }
 function pendingContentAskCallId(cp) {
     return cp.pendingAction.kind === "tool_approval" && cp.pendingAction.toolName === ASK_USER_QUESTION_TOOL_NAME
@@ -215,6 +216,14 @@ function toolResultMsg(toolCallId, toolName, text, isError) {
         timestamp: Date.now(),
     };
 }
+function describeSuppliedValue(value) {
+    return typeof value === "string" ? value : value === null ? "null" : typeof value;
+}
+function assertOutcomeText(value, field) {
+    if (value !== undefined && typeof value !== "string") {
+        throw new CheckpointError("checkpoint.invalid_outcome", `resume \`${field}\` is not a plain string (got ${typeof value}) — a decide's text payload is an operator's plain data, not a live object; refusing pre-CAS, the checkpoint stays pending`);
+    }
+}
 function resumeContinuation(resume) {
     if (resume.outcome.gate === "wake") {
         return formatHookFeedback("You were WOKEN from a parked pause by an operator. Before continuing, re-orient from the workspace: " +
@@ -575,6 +584,12 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
                     ...(bgTasks !== undefined ? { backgroundTasks: bgTasks } : {}),
                     ...(pendingTools !== undefined ? { newTools: pendingTools } : {}),
                     ...(prepared.toolMaterializeStatic ? { newToolsStaticFace: true } : {}),
+                    ...(prepared.toolMaterializeStatic && pendingTools !== undefined
+                        ? { newToolsSwappedUnderStatic: pendingTools.filter((n) => prepared.staticFaceFor?.(n) !== true) }
+                        : {}),
+                    ...(prepared.toolMaterializeStatic && pendingReaddedTools !== undefined
+                        ? { readdedToolsSwappedUnderStatic: pendingReaddedTools.filter((n) => prepared.staticFaceFor?.(n) !== true) }
+                        : {}),
                     ...(mcpToolsDelta !== undefined ? { mcpToolsDelta } : {}),
                     ...(rs.attach.agentListingOn && prepared.agentListing !== undefined
                         ? {
@@ -593,6 +608,12 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
                     const exact = renderToolsDelta({
                         ...(pendingTools !== undefined ? { added: pendingTools } : {}),
                         ...(prepared.toolMaterializeStatic ? { staticFace: true } : {}),
+                        ...(prepared.toolMaterializeStatic && pendingTools !== undefined
+                            ? { swappedUnderStatic: pendingTools.filter((n) => prepared.staticFaceFor?.(n) !== true) }
+                            : {}),
+                        ...(prepared.toolMaterializeStatic && pendingReaddedTools !== undefined
+                            ? { readdedSwappedUnderStatic: pendingReaddedTools.filter((n) => prepared.staticFaceFor?.(n) !== true) }
+                            : {}),
                         ...(mcpToolsDelta ?? {}),
                     });
                     if (exact !== undefined && due.some((a) => a.source === "tools_delta" && a.body === exact)) {
@@ -2193,6 +2214,7 @@ export class Runner {
             ...(prepared.promptManifest.tools ? { tools: prepared.promptManifest.tools } : {}),
             ...(prepared.promptManifest.snapshot ? { snapshot: prepared.promptManifest.snapshot } : {}),
             ...(prepared.promptManifest.lowering ? { lowering: prepared.promptManifest.lowering } : {}),
+            ...(prepared.promptManifest.toolDisclosure ? { toolDisclosure: prepared.promptManifest.toolDisclosure } : {}),
             totalChars: prepared.promptManifest.blocks.reduce((n, b) => n + b.chars, 0),
             ts: rs.telemetry.taskStart,
         }));
@@ -3376,6 +3398,9 @@ export class Runner {
         return stream.result();
     }
     async resumeStream(token, outcome, taskConfig, internals) {
+        if (outcome === null || typeof outcome !== "object") {
+            throw new CheckpointError("checkpoint.invalid_outcome", `resume outcome must be an object naming its gate (got ${outcome === null ? "null" : typeof outcome})`);
+        }
         const store = resolveCheckpointStore(taskConfig, this.deps);
         if (!store) {
             throw new CheckpointError("checkpoint.not_found", "no CheckpointStore wired — cannot resume (set RunnerDeps.checkpointStore or taskConfig.checkpointStore)");
@@ -3384,6 +3409,13 @@ export class Runner {
         if (!cp) {
             throw new CheckpointError("checkpoint.not_found", "no checkpoint found for the supplied token");
         }
+        if (cp.status !== "pending") {
+            const live = await store.get(token);
+            if (live?.status === "pending") {
+                throw new CheckpointError("checkpoint.reopened_concurrently", "checkpoint changed concurrently (a resolve/reopen cycle landed between this resume's read of the row and its state check) — nothing was validated or executed; re-resume against the current state");
+            }
+            throw new CheckpointError("checkpoint.already_resolved", `checkpoint is ${describeSuppliedValue(live?.status ?? cp.status)} — the token is consumed, so this resume was neither validated nor executed (idempotent); a different outcome cannot redeem it`);
+        }
         if ((internals?.inheritedGate?.parentConstraints?.length ?? 0) === 0) {
             const parked = this.parentConstraintRegistry.get(token);
             if (parked !== undefined) {
@@ -3394,7 +3426,10 @@ export class Runner {
             }
         }
         let wakeMessage;
-        if (outcome.gate === "wake") {
+        const outcomeGate = outcome.gate;
+        let suppliedMessage;
+        if (outcomeGate === "wake") {
+            suppliedMessage = outcome.message;
             const gk = cp.gate.kind;
             const decideEntry = gk === "human" || gk === "irreversible_ask"
                 ? 'a `policy_ask` outcome (decision allow/deny bound to the pending tool call)'
@@ -3427,46 +3462,95 @@ export class Runner {
                         `(newer-version row?) — fail-closed: wake only serves a pure park (pendingAction "task_done")`);
                 }
             }
-            if (outcome.message !== undefined) {
-                wakeMessage = validatePendingSteer(outcome.message);
+            if (suppliedMessage !== undefined) {
+                wakeMessage = validatePendingSteer(suppliedMessage);
             }
             else if (readPendingSteerQueue(cp.state).length === 0) {
                 throw new CheckpointError("wake.nothing_to_deliver", "cannot wake: no message was supplied and the checkpoint holds no parked pendingSteer — an empty " +
                     "wake would burn the checkpoint on a blank continuation; supply `message` or park a steer first");
             }
         }
-        const gateMatch = outcome.gate === "wake" ||
-            (cp.gate.kind === "human" && outcome.gate === "policy_ask") ||
-            (cp.gate.kind === "irreversible_ask" && outcome.gate === "policy_ask") ||
-            (cp.gate.kind === "resource_limit" && outcome.gate === "resource_limit") ||
-            (cp.gate.kind === "needs_review" && outcome.gate === "dry_run_review") ||
-            (cp.gate.kind === "plan_review" && outcome.gate === "plan_review");
+        const gateMatch = outcomeGate === "wake" ||
+            (cp.gate.kind === "human" && outcomeGate === "policy_ask") ||
+            (cp.gate.kind === "irreversible_ask" && outcomeGate === "policy_ask") ||
+            (cp.gate.kind === "resource_limit" && outcomeGate === "resource_limit") ||
+            (cp.gate.kind === "needs_review" && outcomeGate === "dry_run_review") ||
+            (cp.gate.kind === "plan_review" && outcomeGate === "plan_review");
         if (!gateMatch) {
-            throw new CheckpointError("checkpoint.gate_mismatch", `resume outcome (gate "${outcome.gate}") does not match checkpoint gate "${cp.gate.kind}" — resume serves human/policy_ask, irreversible_ask/policy_ask, resource_limit/resource_limit, needs_review/dry_run_review, and plan_review/plan_review`);
+            throw new CheckpointError("checkpoint.gate_mismatch", `resume outcome (gate "${describeSuppliedValue(outcomeGate)}") does not match checkpoint gate "${cp.gate.kind}" — resume serves human/policy_ask, irreversible_ask/policy_ask, resource_limit/resource_limit, needs_review/dry_run_review, and plan_review/plan_review`);
         }
-        const reasonBearing = (outcome.gate === "dry_run_review" && outcome.decision === "reject") ||
-            (outcome.gate === "plan_review" && outcome.decision === "reject");
-        if (reasonBearing && outcome.reason && sanitizeUntrustedText(outcome.reason) !== outcome.reason) {
-            throw new CheckpointError("checkpoint.invalid_outcome", "resume deny/reject reason must not contain a </system-reminder> tag");
+        let plainReviewOutcome;
+        if (cp.gate.kind === "plan_review") {
+            const decide = outcome;
+            const decision = decide.decision;
+            const editedPlan = decide.editedPlan;
+            const reason = decide.reason;
+            if (decision !== "approve" && decision !== "edit" && decision !== "reject") {
+                throw new CheckpointError("checkpoint.invalid_outcome", `resume decision "${describeSuppliedValue(decision)}" is outside the plan_review domain — a plan review is exactly "approve", "edit" or "reject"; refusing pre-CAS, the checkpoint stays pending`);
+            }
+            assertOutcomeText(editedPlan, "editedPlan");
+            assertOutcomeText(reason, "reason");
+            plainReviewOutcome = {
+                gate: "plan_review",
+                decision,
+                ...(editedPlan !== undefined ? { editedPlan } : {}),
+                ...(reason !== undefined ? { reason } : {}),
+            };
         }
-        if (outcome.gate === "plan_review" &&
-            outcome.decision === "edit" &&
-            outcome.editedPlan &&
-            sanitizeUntrustedText(outcome.editedPlan) !== outcome.editedPlan) {
-            throw new CheckpointError("checkpoint.invalid_outcome", "resume editedPlan must not contain a </system-reminder> tag");
+        else if (cp.gate.kind === "needs_review") {
+            const decide = outcome;
+            const decision = decide.decision;
+            const reason = decide.reason;
+            if (decision !== "approve" && decision !== "reject") {
+                throw new CheckpointError("checkpoint.invalid_outcome", `resume decision "${describeSuppliedValue(decision)}" is outside the dry_run_review domain — a dry-run review is exactly "approve" or "reject"; refusing pre-CAS, the checkpoint stays pending`);
+            }
+            assertOutcomeText(reason, "reason");
+            plainReviewOutcome = {
+                gate: "dry_run_review",
+                decision,
+                ...(reason !== undefined ? { reason } : {}),
+            };
         }
-        if ((outcome.gate === "plan_review" || outcome.gate === "dry_run_review") && cp.reopenReason === "env_failed") {
-            const winner = cp.resolvedOutcome;
-            if (winner === undefined) {
-                throw new CheckpointError("checkpoint.reopen_revote", "review checkpoint was reopened after an env-restore failure (env_failed) but carries no persisted winner to replay — refusing to resume (inconsistent row, fail-closed)");
+        if (plainReviewOutcome !== undefined) {
+            const reason = plainReviewOutcome.reason;
+            if (plainReviewOutcome.decision === "reject" && reason && sanitizeUntrustedText(reason) !== reason) {
+                throw new CheckpointError("checkpoint.invalid_outcome", "resume deny/reject reason must not contain a </system-reminder> tag");
+            }
+            const capturedPlan = plainReviewOutcome.gate === "plan_review" ? plainReviewOutcome.editedPlan : undefined;
+            if (plainReviewOutcome.decision === "edit" &&
+                capturedPlan &&
+                sanitizeUntrustedText(capturedPlan) !== capturedPlan) {
+                throw new CheckpointError("checkpoint.invalid_outcome", "resume editedPlan must not contain a </system-reminder> tag");
             }
-            if (winner.decision !== outcome.decision) {
-                throw new CheckpointError("checkpoint.reopen_revote", `an env_failed reopen replays the ALREADY-RECORDED review decision ("${winner.decision}") — refusing a re-vote with a different decision ("${outcome.decision}")`);
+            if (cp.reopenReason === "env_failed") {
+                const winner = cp.resolvedOutcome;
+                if (winner === undefined) {
+                    throw new CheckpointError("checkpoint.reopen_revote", "review checkpoint was reopened after an env-restore failure (env_failed) but carries no persisted winner to replay — refusing to resume (inconsistent row, fail-closed)");
+                }
+                if (winner.decision !== plainReviewOutcome.decision) {
+                    throw new CheckpointError("checkpoint.reopen_revote", `an env_failed reopen replays the ALREADY-RECORDED review decision ("${winner.decision}") — refusing a re-vote with a different decision ("${plainReviewOutcome.decision}")`);
+                }
+                if (winner.updatedInput !== capturedPlan) {
+                    throw new CheckpointError("checkpoint.reopen_revote", "an env_failed reopen replays the ALREADY-RECORDED review decision — refusing a re-vote whose edited plan differs from the recorded one");
+                }
+                if (winner.reason !== undefined && winner.reason !== plainReviewOutcome.reason) {
+                    throw new CheckpointError("checkpoint.reopen_revote", "an env_failed reopen replays the ALREADY-RECORDED review decision — refusing a re-vote whose reviewer note differs from the recorded one");
+                }
             }
-            const replayedPlan = outcome.gate === "plan_review" ? outcome.editedPlan : undefined;
-            if (winner.updatedInput !== replayedPlan) {
-                throw new CheckpointError("checkpoint.reopen_revote", "an env_failed reopen replays the ALREADY-RECORDED review decision — refusing a re-vote whose edited plan differs from the recorded one");
+        }
+        let plainParkOutcome;
+        if (outcomeGate === "wake") {
+            plainParkOutcome = {
+                gate: "wake",
+                ...(wakeMessage !== undefined ? { message: wakeMessage } : {}),
+            };
+        }
+        else if (outcomeGate === "resource_limit") {
+            const decision = outcome.decision;
+            if (decision !== "continue") {
+                throw new CheckpointError("checkpoint.invalid_outcome", `resume decision "${describeSuppliedValue(decision)}" is outside the resource_limit domain — a slice resume is exactly "continue"; refusing pre-CAS, the checkpoint stays pending`);
             }
+            plainParkOutcome = { gate: "resource_limit", decision };
         }
         let suppliedAnswer;
         let redeemedAnswer;
@@ -3498,9 +3582,10 @@ export class Runner {
             }
             const decision = decide.decision;
             if (decision !== "allow" && decision !== "deny") {
-                throw new CheckpointError("checkpoint.invalid_outcome", `resume decision "${String(decision)}" is outside the policy_ask domain — a decide is exactly "allow" or "deny"; refusing pre-CAS, the checkpoint stays pending`);
+                throw new CheckpointError("checkpoint.invalid_outcome", `resume decision "${describeSuppliedValue(decision)}" is outside the policy_ask domain — a decide is exactly "allow" or "deny"; refusing pre-CAS, the checkpoint stays pending`);
             }
             const reason = decide.reason;
+            assertOutcomeText(reason, "reason");
             plainPolicyOutcome = {
                 gate: "policy_ask",
                 boundCallId: decide.boundCallId,
@@ -3588,7 +3673,10 @@ export class Runner {
                     "rejected pre-CAS (the checkpoint stays pending) — re-resume with the full original chain");
             }
         }
-        const outcomeForStore = plainPolicyOutcome ?? outcome;
+        const outcomeForStore = plainPolicyOutcome ?? plainReviewOutcome ?? plainParkOutcome;
+        if (outcomeForStore === undefined) {
+            throw new CheckpointError("checkpoint.invalid_outcome", `resume outcome (gate "${describeSuppliedValue(outcomeGate)}") matched the checkpoint gate but no lane captured it — refusing pre-CAS rather than passing the caller's live object to the store and the resumed run`);
+        }
         const won = await store.resolve(token, cp.scope, outcomeForStore, { rev: cp.rev ?? 0 });
         if (!won) {
             const live = await store.get(token);
@@ -3643,7 +3731,7 @@ export class Runner {
                     ? new CheckpointError("checkpoint.reopen_failed", "the resume was aborted before the approved action could run AND the store refused to reopen the checkpoint — the approval is terminally consumed and the suspended work was not executed; a retry needs a fresh approval")
                     : new CheckpointError("checkpoint.reopen_failed", "the resume was aborted before the approved action could run and the reopen attempt FAILED IN FLIGHT — the checkpoint's state is unprovable from here: it may already be pending again. Re-read it before deciding; do NOT issue a fresh approval on the assumption the old one is dead (the approved action did NOT run either way)");
         }
-        return this.runTaskStream(spec, { cp, outcome: plainPolicyOutcome ?? outcome, onEnvRestoreFailed, ...(wakeMessage !== undefined ? { wakeMessage } : {}) }, internals);
+        return this.runTaskStream(spec, { cp, outcome: outcomeForStore, onEnvRestoreFailed, ...(wakeMessage !== undefined ? { wakeMessage } : {}) }, internals);
     }
     async applyResumeDecision(prepared, resume, emit, emitCommitted, onResolvedToolSuccess, onExecuteStart) {
         const { pendingAction } = resume.cp;

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

@@ -5,6 +5,8 @@ import type { ToolSpec } from "../types.js";
 import type { ToolFingerprintInput } from "../cache-break-detector.js";
 export declare const TOOL_SEARCH_NAME = "ToolSearch";
 export declare const TOOL_SEARCH_DEFAULT_MAX_RESULTS = 5;
+export declare const DEFERRED_NO_PROGRESS_LIMIT = 3;
+export declare const DEFERRED_SCHEMA_INCOMPATIBLE_CODE = "tool.deferred_schema_incompatible";
 export interface DeferredToolInfo {
     name: string;
     hint: string;
@@ -28,12 +30,14 @@ export declare function buildDeferredRegistry(deferred: ReadonlySet<string>, too
 export interface PlaceholderDirectCall {
     resolveReal: () => PlaceholderDirectTarget | undefined;
     executionMode?: ToolExecutionMode;
+    staticFace?: () => boolean;
     activate: () => Promise<string | undefined>;
 }
 export interface PlaceholderDirectTarget {
     parameters: TSchema;
     invoke: (toolCallId: string, params: unknown, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<unknown>) => Promise<AgentToolResult<unknown>>;
 }
+export declare function staticSchemaRenderable(schema: TSchema | undefined): boolean;
 export declare function createPlaceholderTool(info: DeferredToolInfo, direct?: PlaceholderDirectCall): AgentTool;
 export declare function scoreToolMatch(query: string, info: DeferredToolInfo): number;
 export interface ToolSearchArgs {
@@ -53,6 +57,7 @@ export declare function createToolSearchTool(opts: {
     listingRide?: (newlyActivated: readonly string[]) => string | undefined;
     mountedNames?: () => ReadonlySet<string>;
     directCallEnabled?: boolean;
+    isMounted?: (name: string) => boolean;
     serializeActivation?: <T>(section: () => Promise<T>) => Promise<T>;
     staticSchemaFor?: (name: string) => TSchema | undefined;
 }): AgentTool;

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

@@ -7,6 +7,8 @@ const DEFER_AUTO_FRACTION = 0.1;
 const CHARS_PER_TOKEN = 4;
 export const TOOL_SEARCH_DEFAULT_MAX_RESULTS = 5;
 const MAX_QUERY_RESULTS = 25;
+export const DEFERRED_NO_PROGRESS_LIMIT = 3;
+export const DEFERRED_SCHEMA_INCOMPATIBLE_CODE = "tool.deferred_schema_incompatible";
 const EMPTY_PARAMS = Type.Object({});
 export function deferHint(description, max = 120) {
     const first = (description.split("\n").find((l) => l.trim() !== "") ?? "").trim();
@@ -70,7 +72,13 @@ function renderSchemaForModel(schema) {
     catch {
         return undefined;
     }
-    return json === undefined ? undefined : truncateError(json);
+    if (json === undefined)
+        return undefined;
+    const text = truncateError(json);
+    return { text, complete: text === json };
+}
+export function staticSchemaRenderable(schema) {
+    return schema !== undefined && renderSchemaForModel(schema)?.complete === true;
 }
 export function createPlaceholderTool(info, direct) {
     const sn = safeName(info.name);
@@ -78,10 +86,36 @@ export function createPlaceholderTool(info, direct) {
         throw new Error(`Tool "${sn}" is not active yet. Call ${TOOL_SEARCH_NAME} with {"query":"select:${sn}"} ` +
             `(or a keyword \`query\`) to load its full schema, then call ${sn} with the proper arguments.`);
     };
-    const invalidArgumentsRejection = (target, params, schemaJson, ride) => {
-        const text = `Invalid arguments for \`${sn}\`: ${formatZodValidationError(target.parameters, params)} ` +
-            `\`${sn}\` is now active — its full parameter schema is below; use it for this and later calls. ` +
-            `Call \`${sn}\` again with arguments matching it.\nParameter schema: ${schemaJson}`;
+    let lastFailureShape;
+    let repeats = 0;
+    const invalidArgumentsRejection = (target, params, schema, ride) => {
+        const completeness = schema.complete ? "its full parameter schema" : "an ABRIDGED copy of its parameter schema (too large to inline in full)";
+        const durability = !schema.complete
+            ? `${completeness} is below; the tools list carries the complete declaration. `
+            : direct?.staticFace?.() === true
+                ? `${completeness} is below and is carried by THIS result only — the tools list keeps the compact ` +
+                    `placeholder entry, so re-run ${TOOL_SEARCH_NAME} with {"query":"select:${sn}"} if you need the schema again later. `
+                : `${completeness} is below, and the next request's tools list will advertise it too. `;
+        const shape = formatZodValidationError(target.parameters, params);
+        repeats = shape === lastFailureShape ? repeats + 1 : 1;
+        lastFailureShape = shape;
+        if (repeats >= DEFERRED_NO_PROGRESS_LIMIT) {
+            const stuck = `\`${sn}\` rejected the same arguments ${repeats} times in a row and its parameter schema has already ` +
+                `been delivered, so re-sending them will not start working. This usually means the caller cannot ` +
+                `produce arguments outside the compact placeholder entry advertised for \`${sn}\`. \`${sn}\` is ` +
+                `finished for this run — no further call to it will be answered differently. Other tools are ` +
+                `unaffected; if this was the only work left, the run stops here. ` +
+                `(${DEFERRED_SCHEMA_INCOMPATIBLE_CODE})\nLast rejection: ${shape}`;
+            return {
+                content: [{ type: "text", text: stuck }],
+                details: { invalidArguments: true, noProgress: DEFERRED_SCHEMA_INCOMPATIBLE_CODE, repeats },
+                isError: true,
+                terminate: true,
+            };
+        }
+        const text = `Invalid arguments for \`${sn}\`: ${shape} ` +
+            `\`${sn}\` is now active — ${durability}` +
+            `Call \`${sn}\` again with arguments matching it.\nParameter schema: ${schema.text}`;
         return {
             content: ride === undefined || ride === "" ? [{ type: "text", text }] : [{ type: "text", text }, { type: "text", text: ride }],
             details: { invalidArguments: true },
@@ -102,17 +136,19 @@ export function createPlaceholderTool(info, direct) {
                 if (real === undefined)
                     return teachingRejection();
                 if (Value.Check(real.parameters, params)) {
+                    lastFailureShape = undefined;
+                    repeats = 0;
                     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 }] };
                 }
-                const schemaJson = renderSchemaForModel(real.parameters);
-                if (schemaJson === undefined)
+                const schemaRender = renderSchemaForModel(real.parameters);
+                if (schemaRender === undefined)
                     return teachingRejection();
                 const ride = await direct.activate();
-                return invalidArgumentsRejection(real, params, schemaJson, ride);
+                return invalidArgumentsRejection(real, params, schemaRender, ride);
             },
         };
     }
@@ -236,12 +272,13 @@ export function extractDiscoveredToolNames(messages, registry) {
     return [...names];
 }
 export function createToolSearchTool(opts) {
-    const { registry, active, rematerialize, listingRide, mountedNames, staticSchemaFor } = opts;
+    const { registry, active, rematerialize, listingRide, mountedNames, staticSchemaFor, isMounted } = opts;
     const directCallEnabled = opts.directCallEnabled !== false;
     const activationPosture = directCallEnabled
         ? (staticSchemaFor !== undefined
             ? "Most tools start as name-only placeholders to keep requests small; activating one here returns its full " +
-                "parameter schema in the result (the tools list keeps the compact placeholder entry). "
+                "parameter schema in the result (the tools list keeps the compact placeholder entry — except for a " +
+                "declaration too large to inline, which goes to the tools list instead). "
             : "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 " +
@@ -286,14 +323,21 @@ export function createToolSearchTool(opts) {
                     `selection in \`query\` instead: {"query":"select:ToolA,ToolB"}. Nothing was activated.`);
             }
             const args = (raw ?? {});
-            const { matched, missing } = resolveToolSearchDetailed(args, registry);
+            const resolved = resolveToolSearchDetailed(args, registry);
+            const missing = resolved.missing;
+            const withdrawn = isMounted === undefined ? [] : resolved.matched.filter((n) => !isMounted(n));
+            const matched = isMounted === undefined ? resolved.matched : resolved.matched.filter((n) => isMounted(n));
             const mounted = mountedNames?.() ?? new Set();
             const missCallable = missing.filter((n) => mounted.has(n));
             const missUnknown = missing.filter((n) => !mounted.has(n));
             const callableNote = missCallable.length > 0
                 ? `\nAlready available: ${missCallable.map((n) => safeName(n)).join(", ")} — ${missCallable.length > 1 ? "these tools are" : "this tool is"} not deferred; call ${missCallable.length > 1 ? "them" : "it"} directly right now (no activation needed).`
                 : "";
+            const withdrawnNote = withdrawn.length > 0
+                ? `\nNo longer available: ${withdrawn.map((n) => safeName(n)).join(", ")} — ${withdrawn.length > 1 ? "these tools were" : "this tool was"} withdrawn by ${withdrawn.length > 1 ? "their providers" : "its provider"} and cannot be activated or called.`
+                : "";
             const missingNote = callableNote +
+                withdrawnNote +
                 (missUnknown.length > 0
                     ? `\nNot found: ${missUnknown.map((n) => safeName(n)).join(", ")} — not in the deferred registry under this exact name (lookup is case-sensitive). ` +
                         "(Already-active and non-deferred tools are callable directly and don't appear here.)"
@@ -311,7 +355,7 @@ export function createToolSearchTool(opts) {
                         matches: [],
                         query: typeof args.query === "string" ? args.query : "",
                         total_deferred_tools: registry.size,
-                        ...(missing.length > 0 ? { missing: missing.map(safeName) } : {}),
+                        ...(missing.length > 0 || withdrawn.length > 0 ? { missing: [...missing, ...withdrawn].map(safeName) } : {}),
                     },
                 };
             }
@@ -332,6 +376,7 @@ export function createToolSearchTool(opts) {
                 return { newly, ride: newly.length > 0 ? listingRide?.(newly) : undefined };
             });
             const { newly, ride } = await section;
+            let missingSchemaLines = false;
             const lines = matched.map((n) => {
                 const info = registry.get(n);
                 const tag = newly.includes(n) ? "activated" : "already active";
@@ -340,12 +385,16 @@ export function createToolSearchTool(opts) {
                     return base;
                 const schema = staticSchemaFor(n);
                 const json = schema === undefined ? undefined : renderSchemaForModel(schema);
-                return json === undefined ? base : `${base}\n  parameters: ${json}`;
+                if (json === undefined || !json.complete) {
+                    missingSchemaLines = true;
+                    return `${base}\n  parameters: not inlined — this tool's full declaration is in the tools list.`;
+                }
+                return `${base}\n  parameters: ${json.text}`;
             });
             const head = staticSchemaFor !== undefined
                 ? newly.length > 0
-                    ? `Activated ${newly.length} tool(s) — call them directly with arguments matching the parameter schemas below (the tools list keeps compact placeholder entries):`
-                    : "These tools are already active — call them directly; their parameter schemas are repeated below:"
+                    ? `Activated ${newly.length} tool(s) — call them directly with arguments matching the parameter schemas below (the tools list keeps compact placeholder entries${missingSchemaLines ? ", except where a line says otherwise" : ""}):`
+                    : `These tools are already active — call them directly; their parameter schemas are repeated below${missingSchemaLines ? " where they can be inlined" : ""}:`
                 : newly.length > 0
                     ? `Activated ${newly.length} tool(s); they are now available with full parameters — call them directly:`
                     : "These tools are already active — call them directly:";
@@ -358,7 +407,7 @@ export function createToolSearchTool(opts) {
                     matches: matched.map(safeName),
                     query: typeof args.query === "string" ? args.query : "",
                     total_deferred_tools: registry.size,
-                    ...(missing.length > 0 ? { missing: missing.map(safeName) } : {}),
+                    ...(missing.length > 0 || withdrawn.length > 0 ? { missing: [...missing, ...withdrawn].map(safeName) } : {}),
                 },
             };
         },

package/dist/core/runner/turn-attachments.d.ts

@@ -101,6 +101,8 @@ export interface AttachmentInputs {
     backgroundTasks?: ReadonlyArray<BackgroundTaskSnapshot>;
     newTools?: readonly string[];
     newToolsStaticFace?: boolean;
+    newToolsSwappedUnderStatic?: readonly string[];
+    readdedToolsSwappedUnderStatic?: readonly string[];
     mcpToolsDelta?: McpToolsDeltaFacts;
     agentListing?: ReadonlyArray<AgentListingEntry>;
     agentToolName?: string;
@@ -150,6 +152,8 @@ export interface McpToolsDeltaFacts {
 export declare function renderToolsDelta(input: {
     added?: readonly string[];
     staticFace?: boolean;
+    swappedUnderStatic?: readonly string[];
+    readdedSwappedUnderStatic?: readonly string[];
 } & McpToolsDeltaFacts): string | undefined;
 export declare const AGENT_TOOLS_NOTE_DEFAULT = "All tools";
 export declare const AGENT_CONCURRENCY_NOTE = "When you launch multiple agents for independent work, send them in a single message with multiple tool uses so they run concurrently.";