@sema-agent/core 7.55.0 → 7.57.0

package/dist/core/runner/run-leg.js

@@ -1,6 +1,6 @@
 import { snapshotActorAssertion } from "../../internal/llm.js";
 import { redactThenCut } from "../../agents/subagent-steps.js";
-import { ASK_USER_QUESTION_TOOL_NAME } from "../ask-question.js";
+import { isEngineQuestionFace } from "../ask-question.js";
 import { CheckpointError, readPendingSteerQueue, realApprovalOrgFact, remainingBudgetMicroUsd } from "../checkpoint-store.js";
 import { normalizePersistedRuleHit } from "../rule-lane-reads.js";
 import { decidersNote, SETTLEMENT_NOBODY_JUDGED } from "../gate-outcome.js";
@@ -21,7 +21,7 @@ import { hasDestroy } from "../remote-env.js";
 import { advertisedWritableRootsSeat, attestationOf, exemptRootsSeat, humanRefusalSentence, licenseCovers, ownedReading, policyCannotAnswer, policyRefusalMessage, refuseOutOfContractDecision } from "../tool-policy.js";
 import { failedJudgmentDeny } from "./policy-throw.js";
 import { pathDenialCardOf } from "../../tools/fs/safety.js";
-import { callFaceSeat, parkedRowLiveFace, rosterEntryNamed } from "../tool-roster.js";
+import { callFaceSeat, parkedRowLiveFace, rosterEntryNamed, rowMember } from "../tool-roster.js";
 import { deliverEngineNotice } from "../types.js";
 import { delimitUntrusted, inlineUntrusted, REVIEWER_NOTE_MAX_BODY, sanitizeUntrustedText } from "../untrusted-text.js";
 import { errorCodeOf } from "./terminal-account.js";
@@ -29,7 +29,8 @@ import { DEFAULT_PRECALL_OUTPUT_TOKENS, platformLimitTerminal } from "./clock-an
 import { legContextOverlayOption } from "./compaction-call-options.js";
 import { mintOutputStyleReminder, owedPostureText } from "./compaction-restate.js";
 import { advisorFrameText, registerAdvisorReceipt } from "./advisor-instructions.js";
-import { deepJsonEqual, resumeContinuation } from "./decide-continuation.js";
+import { resumeContinuation } from "./decide-continuation.js";
+import { editRewrittenSentence, sameBytes } from "../rewrite-rejudge.js";
 import { approvalWordsOf, owedApprovalWords, withApprovalWords } from "./approval-feedback.js";
 import { chainCannotJudge } from "./call-hook-stations.js";
 import { settleExecutionRecord } from "./execution-record.js";
@@ -46,12 +47,11 @@ import { settleTeardownLeg } from "./teardown-bounded.js";
 import { announceToolCall, emitSettled, toolResultMsg } from "./tool-end-body.js";
 import { rowDetailsOf, withRowNotExecuted } from "./tool-not-executed.js";
 import { announceListingTruncation } from "../skill-listing-budget.js";
-import { attachmentEnvelopeTags, collectDateChange, commitAgentListing, commitSkillsListing, reduceToolEnd, renderAgentListingFrame, renderOrphanedBackgroundTasks, renderSkillsListingFrame, stampWriteAnchor } from "./turn-attachments.js";
-import { flushOwedAnnouncedSnapshot } from "./announce-once-ledger.js";
+import { attachmentEnvelopeTags, collectDateChange, commitAgentListing, commitSkillsListing, owedMcpUnavailable, reduceToolEnd, renderAgentListingFrame, renderOrphanedBackgroundTasks, renderSkillsListingFrame, stampWriteAnchor } from "./turn-attachments.js";
+import { flushOwedAnnouncedSnapshot, settleMcpUnavailable } from "./announce-once-ledger.js";
 import { thrownMarksOf } from "../thrown-value.js";
 import { egressThrownText, egressValue } from "../untrusted-egress.js";
 import { ruleSourcePhrase } from "../rule-denial-sentence.js";
-import { wireOf } from "../tool-name-readings.js";
 export async function runLeg(input) {
     const { spec, queue, prepared, resume, rs, entryActor, effectiveTimeoutMs, timeout, pushContent, ident, emitCommitted, writeFamilyOf, startedToolCallIds, announceWorkspaceMove, withBrainSinks, flushGitMirror, loopLatch, notificationLane, unsubscribeTaskNotifications, unsubGitRetry, unsubBoundary, unsub, runner, next } = input;
     let final;
@@ -69,7 +69,6 @@ export async function runLeg(input) {
             const walltimeExhaustedResume = effectiveTimeoutMs !== undefined && effectiveTimeoutMs <= 0;
             const approvalWords = approvalWordsOf(resume.outcome);
             const approvalFrames = owedApprovalWords(approvalWords, uuidv7());
-            let approvalCommitted = false;
             prepared.undeliveredContinuationRef.current.parkedSteers.push(...approvalFrames);
             const resumeWindowRetryAfterMs = !walltimeExhaustedResume && prepared.usageGovernance !== undefined ? await prepared.usageGovernance.check(Date.now()) : undefined;
             if (resumeWindowRetryAfterMs !== undefined) {
@@ -164,6 +163,9 @@ export async function runLeg(input) {
                 const outputStyleWrapped = mintOutputStyleReminder(prepared);
                 if (outputStyleWrapped !== undefined)
                     continuation += "\n\n" + outputStyleWrapped;
+                const unavailableResume = owedMcpUnavailable(prepared, rs.attach.attachmentsCfg);
+                if (unavailableResume !== undefined)
+                    continuation += "\n\n" + mintSystemReminder(sanitizeUntrustedText(unavailableResume.body, attachmentEnvelopeTags("mcp_unavailable")), prepared.reminderMark);
                 const advisorResumeFrame = advisorFrameText(prepared);
                 if (advisorResumeFrame !== undefined)
                     continuation += "\n\n" + advisorResumeFrame;
@@ -241,10 +243,10 @@ export async function runLeg(input) {
                             (steer.trusted ? formatHookFeedback(projected, prepared.reminderMark) : delimitUntrusted("supervisor steering message", projected));
                     if (steer.trusted)
                         engineSegments.push({ start, end: continuation.length });
-                    appliedEvents.push({
+                    appliedEvents.push(() => ({
                         ...buildAppliedHumanInputEvent({ carrier: source, source, sessionSeq: nextHumanInputSeq(prepared.harness), inputId: steer.inputId, actor: steer.actor, principal: spec.principal }),
                         ...ident(),
-                    });
+                    }));
                 }
                 if (approvalWords !== undefined)
                     continuation = withApprovalWords(continuation, engineSegments, approvalWords);
@@ -256,8 +258,6 @@ export async function runLeg(input) {
                     prepared.batchHaltRef.current = { rejectedToolCallId: pending.toolCallId };
                 prepared.undeliveredContinuationRef.current = { parkedSteers: [...resumeFrames.map(({ entry }) => entry).filter((e) => !withheldSteerIds.has(e.inputId)), ...approvalFrames], orphanTasks };
                 if (!prepared.abortController.signal.aborted) {
-                    if (resume !== undefined)
-                        resume.decisionDelivered = true;
                     registerAdvisorReceipt(prepared, continuation);
                     if (gitResumeDelivered !== undefined) {
                         const delivered = gitResumeDelivered;
@@ -279,24 +279,17 @@ export async function runLeg(input) {
                     }
                     if (postureText !== undefined)
                         prepared.frameReceipts.pending.push({ source: "posture", text: continuation, commit: () => undefined });
-                    if (approvalFrames.length > 0) {
-                        prepared.frameReceipts.pending.push({
-                            source: "approval_feedback",
-                            text: continuation,
-                            commit: () => {
-                                approvalCommitted = true;
-                                const seat = prepared.undeliveredContinuationRef.current;
-                                seat.parkedSteers = seat.parkedSteers.filter((f) => !approvalFrames.includes(f));
-                            },
-                        });
-                    }
+                    if (unavailableResume !== undefined)
+                        prepared.frameReceipts.pending.push({ source: "mcp_unavailable", text: continuation, commit: () => void (settleMcpUnavailable(prepared, unavailableResume.entries), queue.push({ type: "steering_injected", source: "mcp_unavailable", preview: redactThenCut(unavailableResume.body, 220), ...ident() }), (rs.attach.attachmentsInjected += 1)) });
                     final = await withBrainSinks(() => prepared.harness.prompt(continuation, {
                         engineSegments,
                         settleUnansweredToolCalls: rejectionHalt !== undefined ? { halt: rejectionHalt } : {},
-                        onDelivered: () => {
-                            prepared.undeliveredContinuationRef.current = { parkedSteers: approvalCommitted ? [] : [...approvalFrames], orphanTasks: [] };
-                            for (const e of appliedEvents)
-                                queue.push(e);
+                        onCommitted: () => {
+                            if (resume !== undefined)
+                                resume.decisionDelivered = true;
+                            prepared.undeliveredContinuationRef.current = { parkedSteers: [], orphanTasks: [] };
+                            for (const applied of appliedEvents)
+                                queue.push(applied());
                         },
                     }));
                     await flushGitMirror();
@@ -361,6 +354,9 @@ export async function runLeg(input) {
             const dateFrame = legToday !== undefined ? collectDateChange(rs.attach.dateState, legToday) : undefined;
             if (dateFrame !== undefined)
                 firstFrames.push({ source: "date_change", body: dateFrame.body, commit: () => void (rs.attach.dateState.announcedDate = legToday), disclose: () => undefined });
+            const unavailable = owedMcpUnavailable(prepared, rs.attach.attachmentsCfg);
+            if (unavailable !== undefined)
+                firstFrames.push({ source: "mcp_unavailable", body: unavailable.body, commit: () => settleMcpUnavailable(prepared, unavailable.entries), disclose: () => undefined });
             if (rs.attach.attachState !== undefined) {
                 const attach = rs.attach.attachState;
                 if (rs.attach.agentListingOn && prepared.agentListing !== undefined) {
@@ -450,7 +446,7 @@ export async function runLeg(input) {
             }
             else {
                 const images = spec.images
-                    ? await Promise.all(spec.images.map((img) => toImageContent(img, runner.deps.allowImageUrl)))
+                    ? await Promise.all(spec.images.map((img) => toImageContent(img, prepared.hostFloor)))
                     : undefined;
                 if (gitLegDelivered !== undefined) {
                     const delivered = gitLegDelivered;
@@ -570,7 +566,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
     const { outcome } = resume;
     if (pendingAction.kind !== "tool_approval" || outcome.gate !== "policy_ask")
         return;
-    const mounted = () => { const tool = prepared.tools.find((x) => x.name === pendingAction.toolName); const roster = prepared.toolRosterDeltas.current; return tool === undefined || roster === undefined ? {} : { tool, entry: rosterEntryNamed(roster, pendingAction.toolName) }; };
+    const mounted = () => { const roster = prepared.toolRosterDeltas.current; const entry = roster === undefined ? undefined : rosterEntryNamed(roster, pendingAction.toolName); const tool = entry?.name === pendingAction.toolName ? rowMember(entry) : undefined; return tool === undefined ? {} : { tool, entry }; };
     const reopen = (miss) => { throw Object.assign(new Error(miss.message), { code: miss.code }); };
     const liveTool = mounted().tool;
     const atSession = outcome.decision === "allow" ? judgeApprovalObject(pendingAction, { tool: mounted().entry }, "session") : "match";
@@ -580,7 +576,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
     if (decidedGate === undefined) {
         throw new CheckpointError("checkpoint.invalid_outcome", "pending action reached the resolver with no settlement record on its decision (gateOutcome) — refusing to execute or settle a decision that carries no record");
     }
-    const humanRewrite = wireOf("resume.questionArgsShown", pendingAction) === ASK_USER_QUESTION_TOOL_NAME ? undefined : outcome.updatedInput;
+    const humanRewrite = isEngineQuestionFace(parkedRowLiveFace(prepared.toolRosterDeltas.current, pendingAction)) ? undefined : outcome.updatedInput;
     const reading = liveTool === undefined ? undefined : ownedReading((a) => readToolCallArguments(liveTool, { type: "toolCall", id: pendingAction.toolCallId, name: pendingAction.toolName, arguments: {} }, a));
     const beltFace = () => { const f = parkedRowLiveFace(prepared.toolRosterDeltas.current, pendingAction); if (f !== undefined && reading !== undefined)
         stampArgsReading(f, reading); return f; };
@@ -652,9 +648,14 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
         emitCommitted(await prepared.session.appendMessage(resultRow(hookDenial, true)), "toolResult", pendingAction.toolCallId);
         return;
     }
-    const rescreened = humanRewrite === undefined && screened !== undefined ? tryRead(screened.args) : undefined;
+    const rescreened = screened !== undefined ? tryRead(screened.args) : undefined;
     if (rescreened?.unread !== undefined)
         return settleUnreadable(rescreened.unread.error, "the arguments a PreToolUse hook rewrote it to");
+    if (humanRewrite !== undefined && rescreened !== undefined && !sameBytes({}, resolvedArgs, rescreened.args)) {
+        const text = formatHookFeedback(`${editRewrittenSentence(pendingAction.toolName)}, which a PreToolUse hook wrote — this approval is spent; the call has to be re-issued.`, prepared.reminderMark);
+        await settleEnd(true, { content: text, details: { editRewritten: { acceptableForm: rescreened.args } } }, "hook");
+        return emitCommitted(await prepared.session.appendMessage(resultRow(text, true)), "toolResult", pendingAction.toolCallId);
+    }
     const executedArgs = rescreened !== undefined ? rescreened.args : resolvedArgs;
     const unseen = !licenseCovers(pendingAction.boundInputHash, executedArgs);
     let beltReading;
@@ -687,19 +688,18 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
     if (unseen && prepared.basePolicyForResumeEdit) {
         const rechecked = refuseOutOfContractDecision(await beltCheck((signal) => prepared.basePolicyForResumeEdit.check(beltReq(), signal), "the deployment's tool policy re-checking a resumed call"));
         const personUnanswered = policyCannotAnswer(rechecked, outcome.hostDecision.decidedBy);
-        const beltUnsafe = rechecked.action === "deny" ||
-            (rechecked.updatedInput !== undefined && ((read) => read.unread !== undefined || !deepJsonEqual(read.args, executedArgs))(tryRead(rechecked.updatedInput))) ||
-            personUnanswered;
-        if (beltUnsafe) {
+        const rewrite = rechecked.updatedInput !== undefined ? tryRead(rechecked.updatedInput) : undefined;
+        const rewrote = rewrite !== undefined && (rewrite.unread !== undefined || !sameBytes({}, rewrite.args, executedArgs));
+        if (rechecked.action === "deny" || rewrote || personUnanswered) {
             const why = rechecked.action === "deny"
                 ? (rechecked.message ? `: ${rechecked.message}` : "")
                 : personUnanswered
                     ? " (the call as it would run requires a person's approval, and this decision was the deployment's policy)"
                     : " (the policy rewrote these bytes to a value that was not approved)";
             const editedDenial = formatHookFeedback(`${outcome.updatedInput !== undefined ? "The approver EDITED this call's input; the edited call" : "A PreToolUse hook REWROTE this approved call's input; the rewritten call"} is refused by the deployment's tool policy and was not executed${why}.`, prepared.reminderMark);
-            await settleEnd(true, { content: editedDenial, ...denialCard(rechecked) }, "policy");
-            const eid = await prepared.session.appendMessage(resultRow(editedDenial, true));
-            emitCommitted(eid, "toolResult", pendingAction.toolCallId);
+            const outlet = rechecked.action !== "deny" && !personUnanswered && humanRewrite !== undefined && rewrite?.unread === undefined && rewrite !== undefined ? { details: { editRewritten: { acceptableForm: rewrite.args } } } : denialCard(rechecked);
+            await settleEnd(true, { content: editedDenial, ...outlet }, "policy");
+            emitCommitted(await prepared.session.appendMessage(resultRow(editedDenial, true)), "toolResult", pendingAction.toolCallId);
             return;
         }
     }
@@ -818,7 +818,8 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
     for (;;) {
         const { targetReading: _belts, ...unread } = beltReq();
         const targetReading = (await prepared.stampCallTarget?.(unread, prepared.abortController.signal))?.targetReading;
-        const atExecution = judgeApprovalObject(pendingAction, { tool: mounted().entry, args: executedArgs, skills: prepared.skillSpecs, skillToolName: SKILL_TOOL_NAME, ...(humanRewrite !== undefined ? { decided: resolvedArgs } : {}), targetReading }, "execution");
+        const reads = prepared.shellReadLandings?.(pendingAction.toolCallId);
+        const atExecution = judgeApprovalObject(pendingAction, { tool: mounted().entry, args: executedArgs, skills: prepared.skillSpecs, skillToolName: SKILL_TOOL_NAME, ...(humanRewrite !== undefined ? { decided: resolvedArgs } : {}), targetReading, reads }, "execution");
         if (atExecution !== "match")
             return atExecution.disposition === "reopen" ? reopen(atExecution) : vetoApproval(atExecution);
         tool = mounted().tool;
@@ -841,7 +842,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
     const finalize = (executed) => prepared.harness.finalizeToolCall({ type: "toolCall", id: pendingAction.toolCallId, name: spelledName, arguments: executedArgs }, executedArgs, executed);
     let res;
     try {
-        res = await tool.execute(pendingAction.toolCallId, args, prepared.abortController.signal);
+        res = await (prepared.toolCallStation ?? ((_c, run) => run()))({ toolCallId: pendingAction.toolCallId, toolName: tool.name, args }, () => tool.execute(pendingAction.toolCallId, args, prepared.abortController.signal), prepared.abortController.signal);
     }
     catch (err) {
         const execError = `Error: ${egressThrownText("same-principal", err)}`;

package/dist/core/runner/run-notification-lane.d.ts

@@ -19,6 +19,8 @@ export interface RunNotificationLaneInput<R> {
     taskIdRef: TaskIdRef | undefined;
     /** borrowed-readonly — the stream layer's session-lock verb, handed to prepare; absent when the spec named its session. */
     holdSessionLock: ((sessionId: string) => Promise<void>) | undefined;
+    /** borrowed-mutable (the Runner's) — this leg's view of the session write ledger, handed to prepare; the stream layer closes it at the leg's end. */
+    legWrites: import("./session-write-ledger.js").LegWrites;
     /** borrowed-readonly — the Runner's deployment deps, read LIVE (`onError` in the park closure — after the run, on a swapped
      *  catalog it is still the CURRENT sink; `models` and prepare's `deps` at the natural-snapshot pin); the one home of why it
      *  is a seat and not a captured object is {@link RunnerDepsSeat}. */

package/dist/core/runner/run-notification-lane.js

@@ -8,7 +8,7 @@ export function runNotificationLane(input) {
     return obligations.run(() => runNotificationLaneAs(input, obligations));
 }
 async function runNotificationLaneAs(input, obligations) {
-    const { spec, queue, resume, internals, taskIdRef, holdSessionLock, runner, self, sessions, sessionReadStates, sessionModeSeats, pendingSessionNotifications, prepareTask, next } = input;
+    const { spec, queue, resume, internals, taskIdRef, holdSessionLock, legWrites, runner, self, sessions, sessionReadStates, sessionModeSeats, pendingSessionNotifications, prepareTask, next } = input;
     const prepareResume = resume
         ? {
             leafId: resume.cp.leafId,
@@ -128,7 +128,7 @@ async function runNotificationLaneAs(input, obligations) {
             }
             return injectTaskNotification(notification, opts);
         },
-    }, self, taskIdRef, holdSessionLock);
+    }, self, taskIdRef, holdSessionLock, legWrites);
     pendingSessionNotifications.bindSessionBox(prepared.sessionId, prepared.sessionBox);
     const notificationLane = {
         get harness() { return notificationHarness; }, set harness(h) { notificationHarness = h; },

package/dist/core/runner/run-recovery-lanes.js

@@ -2,7 +2,7 @@ import { compactionKindOf } from "../task-notification.js";
 import { planRejectionClears } from "../context-edit.js";
 import { rosterToolName } from "../tool-roster.js";
 import { landStaleResultClears } from "./prepare-context-lane.js";
-import { compactionPassReport, DEFAULT_COMPACTION_INSTRUCTIONS, isCompactionManualCancel, maybeCompact, mintCompactedEvent } from "../auto-compaction.js";
+import { compactionFailureReason, compactionPassReport, DEFAULT_COMPACTION_INSTRUCTIONS, isCompactionManualCancel, maybeCompact, mintCompactedEvent } from "../auto-compaction.js";
 import { emitTrace } from "../trace.js";
 import { isDegenerateCutMessage } from "../../brain/terminal-cause.js";
 import { rebaseCadenceWindows } from "./turn-attachments.js";
@@ -11,7 +11,7 @@ import { compactionEnabled } from "../context-settings.js";
 import { compactionRestateOptions } from "./compaction-restate.js";
 import { COMPACTION_FREED_EPSILON, COMPACTION_REGROWTH_FACTOR, MAX_CONSECUTIVE_COMPACTION_FAILURES } from "./compaction-knobs.js";
 import { compactionHookOptions, recordCompactionReuse, seamCCompactionOptions } from "./compaction-seams.js";
-import { asThrownError, thrownText } from "../thrown-value.js";
+import { asThrownError } from "../thrown-value.js";
 export function runRecoveryLanes(input) {
     const { spec, prepared, queue, rs, ident, compactionBrain, compactionBreaker, windowSafetyOptions, callerStop, runner } = input;
     const runForcedCompactionPass = async (lane, turnSignal) => {
@@ -102,8 +102,7 @@ export function runRecoveryLanes(input) {
             }
             compactionBreaker.failures += 1;
             runner.deps.onError?.(asThrownError(err), { phase: "compaction", sessionId: prepared.sessionId });
-            const msg = thrownText(err);
-            queue.push({ type: "compaction_outcome", outcome: "failed", trigger: "forced", reason: msg.length > 512 ? `${msg.slice(0, 512)}…` : msg, ...passReport.end, ...ident() });
+            queue.push({ type: "compaction_outcome", outcome: "failed", trigger: "forced", reason: compactionFailureReason(err), ...passReport.end, ...ident() });
             return false;
         }
     };

package/dist/core/runner/run-settle-and-teardown.js

@@ -5,7 +5,7 @@ import { adjudicateDerivedRoute, fallbackToPrimaryNotice, sameRouteIdentity } fr
 import { isDegenerateCutMessage } from "../../brain/terminal-cause.js";
 import { hasBackgroundShell, sweepRunBoundaryBackgroundShells } from "../background-shell.js";
 import { resolveCheckpointStore } from "../checkpoint-store.js";
-import { reopenReasonOf, reopenedUnstartedSentence, resumeStartupCauseOf } from "../resume-startup-cause.js";
+import { compensateUnstarted, reopenReasonOf, resumeStartupCauseOf, unstartedRowSentence } from "../resume-startup-cause.js";
 import { classicEventBase, observeClassic } from "../mods/stations.js";
 import { modelCostToPricing } from "../pricing.js";
 import { hasDestroy, isIsolated } from "../remote-env.js";
@@ -96,6 +96,7 @@ export async function runSettleAndTeardown(input) {
             editedFiles: prepared.editedFilesSnapshot(),
             haltedOnUserRejection: prepared.batchHaltRef.current !== undefined,
             haltConsumption: prepared.harness.haltConsumption(),
+            answerEntryIds: prepared.harness.answerEntryIdsOf(final),
             strandedHumanAnswers,
             remoteEnvFailures: prepared.remoteEnvFailures,
             effectiveReadFace: prepared.effectiveReadFace,
@@ -138,17 +139,11 @@ export async function runSettleAndTeardown(input) {
             resume.pendingActionStarted !== true &&
             result.terminal.kind !== "completed" &&
             result.terminal.kind !== "paused" &&
-            !(resumeDecisionWasNegative(resume) && resume.decisionDelivered === true) &&
-            resume.onEnvRestoreFailed !== undefined) {
+            !(resumeDecisionWasNegative(resume) && resume.decisionDelivered === true)) {
             const reopenReason = reopenReasonOf(resumeStartupCauseOf(result.terminal.kind === "failed" ? result.terminal.code : undefined));
-            try {
-                await resume.onEnvRestoreFailed(reopenReason);
-                rowReturned = true;
-                amendTerminal(result, "resume.reopened_unstarted", (m) => `${m ?? "the resume leg did not complete"} — ${reopenedUnstartedSentence(reopenReason)}`);
-            }
-            catch {
-                amendTerminal(result, "resume.reopen_failed_unstarted", (m) => `${m ?? "the resume leg did not complete"} — the approved action never started, and reopening the checkpoint FAILED: its state is unprovable from here. Re-read it before deciding; do NOT issue a fresh approval on the assumption the old one is dead`);
-            }
+            const row = await compensateUnstarted(resume.reopenUnstarted, reopenReason);
+            rowReturned = row.kind === "reopened";
+            amendTerminal(result, rowReturned ? "resume.reopened_unstarted" : "resume.reopen_failed_unstarted", (m) => `${m ?? "the resume leg did not complete"} — ${unstartedRowSentence(row)}`);
         }
         settleOwedUserInput(owedUserInput, rowReturned, { taskId: spec.taskId ?? prepared.sessionId, sessionId: prepared.sessionId, runId: prepared.runId, parent: parentLegIds(internals) }, runner.deps.onNotice);
         prepared.sealReadStateSeat?.(ownCommittedTailRef.current);
@@ -283,7 +278,7 @@ export async function runSettleAndTeardown(input) {
         if (writeDateAnchor !== undefined)
             await settleTeardownLeg(writeDateAnchor, "date anchor (settle leg)", (e) => runner.deps.onError?.(e, { phase: "degraded", sessionId: prepared.sessionId }));
         if (prepared.crossBoundary !== undefined)
-            await prepared.crossBoundary.settle();
+            await prepared.crossBoundary.settle(() => defaultTaskRegistry.owedDeliveries({ ...prepared.registryAccess, sessionId: prepared.sessionId }));
         const ownedEnvDying = prepared.ownedEnv !== undefined &&
             hasDestroy(prepared.ownedEnv) &&
             isIsolated(prepared.ownedEnv) &&

package/dist/core/runner/run-terminal-adoption.js

@@ -1,4 +1,4 @@
-import { compactionPassReport, DEFAULT_COMPACTION_INSTRUCTIONS, isCompactionManualCancel, maybeCompact } from "../auto-compaction.js";
+import { compactionFailureReason, compactionPassReport, DEFAULT_COMPACTION_INSTRUCTIONS, isCompactionManualCancel, maybeCompact } from "../auto-compaction.js";
 import { eventDefaultOn } from "../../prompt-assembly/event-registry.js";
 import { appendInterruptionMarker, reconcileInterruptedSession } from "../session-reconcile.js";
 import { emitTrace } from "../trace.js";
@@ -11,7 +11,7 @@ import { compactionRestateOptions } from "./compaction-restate.js";
 import { MAX_CONSECUTIVE_COMPACTION_FAILURES } from "./compaction-knobs.js";
 import { emitSettled, reconciledEnd } from "./tool-end-body.js";
 import { isApprovalWordsFrame } from "./approval-feedback.js";
-import { asThrownError, thrownText } from "../thrown-value.js";
+import { asThrownError } from "../thrown-value.js";
 export async function runTerminalAdoption(input) {
     const { spec, queue, prepared, rs, stats, ident, emitCommitted, startedToolCallIds, toolLabels, timeout, compactionBrain, compactionBreaker, windowSafetyOptions, undrainedUserAtEnd, userInputLostAtEnd, final, abortedLive, userInterruptedLive, callerStop, runner, sessions, next } = input;
     let { threw } = input;
@@ -185,8 +185,7 @@ async function finish(spec, prepared, opts, runner, sessions) {
                 opts?.onCompactionOutcome?.("mooted", "cancelled", opts.passReport.end);
             }
             else {
-                const failMsg = thrownText(err);
-                const failReason = failMsg.length > 512 ? `${failMsg.slice(0, 512)}…` : failMsg;
+                const failReason = compactionFailureReason(err);
                 emitTrace(opts?.telemetry?.tracer ?? spec.tracer ?? runner.deps.tracer, () => ({
                     kind: "compaction.failed",
                     version: 1,

package/dist/core/runner/run-turn-boundary.js

@@ -1,7 +1,7 @@
 import { compactionKindOf } from "../task-notification.js";
 import { mintSystemReminder } from "../reminder-mint.js";
 import { eventDefaultOn } from "../../prompt-assembly/event-registry.js";
-import { compactionPassReport, DEFAULT_COMPACTION_INSTRUCTIONS, isCompactionManualCancel, maybeCompact, mintCompactedEvent, nextTrimForceBackoff, recordCompactionAndCheckRapidRefill } from "../auto-compaction.js";
+import { compactionFailureReason, compactionPassReport, DEFAULT_COMPACTION_INSTRUCTIONS, isCompactionManualCancel, manualCompactOutcomeOf, maybeCompact, mintCompactedEvent, nextTrimForceBackoff, recordCompactionAndCheckRapidRefill } from "../auto-compaction.js";
 import { emitTrace } from "../trace.js";
 import { redactThenCut } from "../../agents/subagent-steps.js";
 import { ATTACHMENT_BYTE_CAP, CHANGED_FILES_MAX, TOTAL_TOKENS_REMINDER_DEFAULT_MODE, attachmentEnvelopeTags, clipToBytes, collectDateChange, collectDueAttachments, collectInstructionsChange, commitAgentListing, commitInstructionsChange, commitSkillsListing, isIntactSource, rebaseCadenceWindows, renderAgentListingFrame, renderMcpDroppedTools, renderMcpInstructionsDelta, selectMcpDroppedBatch, renderSkillsListingFrame, renderToolsDelta } from "./turn-attachments.js";
@@ -18,7 +18,6 @@ import { COMPACTION_FREED_EPSILON, COMPACTION_REGROWTH_FACTOR, MAX_CONSECUTIVE_C
 import { compactionHookOptions, recordCompactionReuse, seamCCompactionOptions } from "./compaction-seams.js";
 import { contextUsageSections } from "../../prompt-assembly/section-usage.js";
 import { asThrownError } from "../thrown-value.js";
-import { egressThrownText } from "../untrusted-egress.js";
 const BATCH_CONTEXT_MIN_KEEP_BYTES = 160;
 const BATCH_TRUNCATION_MARKER = "\n…[truncated]";
 export function createTurnBoundary(input) {
@@ -255,12 +254,10 @@ export function createTurnBoundary(input) {
                 const pendingTools = tdRef !== undefined && tdRef.pending.length > 0 ? [...tdRef.pending] : undefined;
                 const pendingRemovedTools = tdRef !== undefined && tdRef.pendingRemoved.length > 0 ? [...tdRef.pendingRemoved] : undefined;
                 const pendingReaddedTools = tdRef !== undefined && tdRef.pendingReadded.length > 0 ? [...tdRef.pendingReadded] : undefined;
-                const pendingFailedMcp = tdRef !== undefined && tdRef.pendingFailed.length > 0 ? tdRef.pendingFailed.map((f) => ({ ...f })) : undefined;
-                const mcpToolsDelta = pendingRemovedTools !== undefined || pendingReaddedTools !== undefined || pendingFailedMcp !== undefined
+                const mcpToolsDelta = pendingRemovedTools !== undefined || pendingReaddedTools !== undefined
                     ? {
                         ...(pendingRemovedTools !== undefined ? { removed: pendingRemovedTools } : {}),
                         ...(pendingReaddedTools !== undefined ? { readded: pendingReaddedTools } : {}),
-                        ...(pendingFailedMcp !== undefined ? { failedServers: pendingFailedMcp } : {}),
                     }
                     : undefined;
                 const mcpInstructionsOn = rs.attach.attachmentsCfg?.mcpInstructions === true;
@@ -359,13 +356,6 @@ export function createTurnBoundary(input) {
                             ref.pendingRemoved.splice(0, pendingRemovedTools.length);
                         if (pendingReaddedTools !== undefined)
                             ref.pendingReadded.splice(0, pendingReaddedTools.length);
-                        if (pendingFailedMcp !== undefined) {
-                            ref.pendingFailed.splice(0, pendingFailedMcp.length);
-                            if (!noNextRequest()) {
-                                prepared.announcedListingsRef.mcpFailed = [...(prepared.announcedListingsRef.mcpFailed ?? []), ...pendingFailedMcp];
-                                announcedOnceDirty = true;
-                            }
-                        }
                     }
                 }
                 if ((mcpAdds !== undefined || mcpRemovals !== undefined) &&
@@ -623,7 +613,7 @@ export function createTurnBoundary(input) {
                     ts: Date.now(),
                 }));
             }
-            manualOutcome = comp.compacted ? "compacted" : comp.blocked ? "blocked" : comp.disabled ? "disabled" : "noop";
+            manualOutcome = manualCompactOutcomeOf(comp);
             if (forceManual && !comp.compacted && !comp.blocked) {
                 if (comp.disabled) {
                     emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.disabled", version: 1, taskId: rs.telemetry.taskId, ts: Date.now() }));
@@ -680,8 +670,7 @@ export function createTurnBoundary(input) {
             else if (!prepared.abortController.signal.aborted) {
                 compactionBreaker.failures += 1;
                 runnerHooks.onError?.(err, { phase: "compaction", sessionId: prepared.sessionId });
-                const msg = egressThrownText("same-principal", err);
-                const failReason = msg.length > 512 ? `${msg.slice(0, 512)}…` : msg;
+                const failReason = compactionFailureReason(err);
                 emitTrace(rs.telemetry.tracer, () => ({
                     kind: "compaction.failed",
                     version: 1,

package/dist/core/runner/runtask.d.ts

@@ -8,6 +8,8 @@ import type { AgentDefinition, ModelRef, ModelRoles, RunnerDeps, TaskEvent, Task
 import { type ContextSettings, type ContextWindowOverlay } from "../context-settings.js";
 import type { ResumeRun, ResumeTaskConfig, RunInternals, RunnerSelfSeat } from "./contracts.js";
 export type { ResumeTaskConfig } from "./contracts.js";
+import type { CompactSessionRequest, CompactSessionResult } from "../auto-compaction.js";
+import type { RewindFilesRequest, RewindFilesResult } from "../file-history-store.js";
 /**
  * A stateless task runner. Holds shared deps (the external brain, model catalog) and an
  * in-memory session store so that passing a `sessionId` continues a prior conversation.
@@ -17,6 +19,10 @@ export declare class Runner implements RunnerSelfSeat {
     readonly sessions: SessionStore;
     /** Per-sessionId serialization so two tasks never mutate one session concurrently. */
     private sessionLocks;
+    /** The lock's tail: the session writes this Runner's legs issued that have not settled — a session's next holder starts after them. */
+    private readonly sessionWrites;
+    /** The session-lock seats every out-of-run verb (`rewindFiles`, `compactSession`) is lent — ONE reading of "busy": a leg holds or awaits the lock, or a write issued to the session has not settled. */
+    private readonly verbLockSeats;
     /** Per-session read-file-state seats (CC parity: readFileState is session-scoped;
      *  sema's map stays per-task, so the session scope lives here). A bounded CACHE, never an
      *  authority: a durable resume's checkpoint seed wins on its leg, and a miss (cross-process,
@@ -133,6 +139,10 @@ export declare class Runner implements RunnerSelfSeat {
      *  the same model resolution as tasks, returns real usage/model. No session, no tool execution, no
      *  policy gate, no accounting — caller-trusted. */
     sideQuery(spec: SideQuerySpec): Promise<SideQueryResult>;
+    /** The out-of-run code-only rewind, no model call and no session entry — the contract is {@link rewindSessionFiles}'s (refused while a leg of this Runner holds or awaits the session's lock, or a write issued to it has not settled). */
+    rewindFiles(request: RewindFilesRequest): Promise<RewindFilesResult>;
+    /** The out-of-run manual compaction, no run and no user turn — the contract is {@link compactIdleSession}'s (the one pass every lane runs; refused while a leg of this Runner holds or awaits the session's lock, or a write issued to it has not settled). */
+    compactSession(request: CompactSessionRequest): Promise<CompactSessionResult>;
     /** Run a task and stream live events; await `.result()` for the final TaskResult. `resume` (internal)
      *  drives a durable resume through the same loop instead of a fresh objective prompt.
      *  `internals` (internal) is a TRUSTED run-scoped channel for live per-task state the