@sema-agent/core 7.21.1 → 7.23.0

package/dist/core/runner/prepare-context-lane.js

@@ -7,8 +7,9 @@ import { createOffloadPersist } from "../tool-result-store.js";
 import { emitTrace } from "../trace.js";
 import { deliverEngineNotice } from "../types.js";
 import { applyGitFrameGuard } from "./git-status-frame.js";
+import { applyContextShrinkToReadFileState } from "../../tools/fs/index.js";
 export function prepareContextLane(input) {
-    const { model, deps, sessionId, runId, hostTaskId, offloadStore, microCompactKnob, harness, batchHaltRef, gitStatusRef, requestLossyRef, trimPressureRef } = input;
+    const { model, deps, sessionId, runId, hostTaskId, offloadStore, microCompactKnob, harness, batchHaltRef, gitStatusRef, requestLossyRef, trimPressureRef, readFileState } = input;
     const editAt = editBudget(model);
     const guardAt = guardBudget(model);
     const microCompact = buildMicroCompactState(deps, model, sessionId, runId, offloadStore, microCompactKnob);
@@ -57,12 +58,13 @@ export function prepareContextLane(input) {
                     : {}),
             });
             if (ccPass !== undefined) {
-                recordFrontierClears({ pass: ccPass, index: replay.index, edited, ledger: microCompact.ledger, tracer: deps.tracer, taskId: hostTaskId, trigger: "frontier" });
+                recordFrontierClears({ pass: ccPass, index: replay.index, edited, ledger: microCompact.ledger, tracer: deps.tracer, taskId: hostTaskId, trigger: "frontier", ...(readFileState !== undefined ? { readFileState } : {}) });
             }
             const chain = await runGuardChain({
                 edited, replayed, index: replay.index, microCompact, guardAt, charsPerToken, offloadStore,
                 sessionId, taskId: hostTaskId, deps, trimPressureRef, recheck, signal,
                 pendingProjectionObservations,
+                ...(readFileState !== undefined ? { readFileState } : {}),
             });
             if ("earlyReturn" in chain) {
                 return chain.earlyReturn;
@@ -138,15 +140,34 @@ function buildMicroCompactState(deps, model, sessionId, runId, offloadStore, kno
         ...(offloadStore ? { offloadPersist: createOffloadPersist(offloadStore, sessionId, deps.onNotice) } : {}),
     };
 }
+export function landStaleResultClears(args) {
+    const clearedToolCallIds = [];
+    for (const c of args.cleared) {
+        args.ledger.entries.set(c.key, { marker: c.marker, groupCount: c.groupCount, fp: c.fp });
+        if (c.toolCallId !== undefined)
+            clearedToolCallIds.push(c.toolCallId);
+    }
+    if (args.readFileState !== undefined) {
+        applyContextShrinkToReadFileState(args.readFileState, { kind: "tool-results-cleared", clearedToolCallIds });
+    }
+}
 function recordFrontierClears(args) {
+    const landed = [];
     for (const { index } of args.pass.clears) {
         const at = args.index.keyAt(index);
         const clearedMsg = args.edited[index];
         const markerText = clearedMsg.content?.[0]?.text;
         if (at !== undefined && typeof markerText === "string") {
-            args.ledger.entries.set(at.key, { marker: markerText, groupCount: at.groupCount, fp: at.fp });
+            landed.push({
+                key: at.key,
+                marker: markerText,
+                groupCount: at.groupCount,
+                fp: at.fp,
+                ...(typeof clearedMsg.toolCallId === "string" ? { toolCallId: clearedMsg.toolCallId } : {}),
+            });
         }
     }
+    landStaleResultClears({ ledger: args.ledger, cleared: landed, ...(args.readFileState !== undefined ? { readFileState: args.readFileState } : {}) });
     emitTrace(args.tracer, () => ({
         kind: "context.mc_clear",
         version: 1,
@@ -198,7 +219,7 @@ export async function runGuardChain(args) {
             ...(args.offloadStore ? { offload: { persist: createOffloadPersist(args.offloadStore, args.sessionId, deps.onNotice) } } : {}),
         });
         if (blockingPass !== undefined) {
-            recordFrontierClears({ pass: blockingPass, index: args.index, edited: blockingEdited, ledger: microCompact.ledger, tracer: deps.tracer, taskId, trigger: "blocking" });
+            recordFrontierClears({ pass: blockingPass, index: args.index, edited: blockingEdited, ledger: microCompact.ledger, tracer: deps.tracer, taskId, trigger: "blocking", ...(args.readFileState !== undefined ? { readFileState: args.readFileState } : {}) });
             working = blockingEdited;
             anchoredWorking = estimateContextTokens(working, charsPerToken).tokens;
         }

package/dist/core/runner/prepare-hands-readface.d.ts

@@ -284,6 +284,9 @@ export interface PrepareHandsReadFaceResult {
         pattern: string;
         caseSensitive: boolean;
     }>;
+    /** owned — the built-in deny TIERS this leg MATERIALLY activated, off the same snapshot the compile
+     *  judged with; empty ⇒ none. Relayed to the wiring manifest, never re-derived from `deps` there. */
+    readDenyBuiltinTiersActive: readonly string[];
     /** write-back (D-3 hold) — the hands-LESS legs' resolved face (the read posture is a
      *  property of the RUN, not the mount). Driver assigns onto its outer `let`. */
     handsLessResolvedFace: ContainmentFace | undefined;

package/dist/core/runner/prepare-hands-readface.js

@@ -3,7 +3,7 @@ import { StubExecutionEnv } from "../stub-env.js";
 import { hasBackgroundShell } from "../background-shell.js";
 import { boundaryIsTheSandbox } from "../remote-env.js";
 import { defaultTaskRegistry } from "../task-registry.js";
-import { bashReadBoundaryProbe, bashReversibilityProbe, compileReadDeny, createHandsToolkit, deploymentFaceClampNotice, pdfModelCapabilitiesOf, resolveReadDenyBuiltins, inheritSessionReadFileState, resolveContainmentFace, seedReadFileStateFromContext, seedReadFileStateFromTranscript, } from "../../tools/fs/index.js";
+import { bashReadBoundaryProbe, bashReversibilityProbe, activeReadDenyBuiltinTiers, compileReadDeny, createHandsToolkit, deploymentFaceClampNotice, pdfModelCapabilitiesOf, inheritSessionReadFileState, resolveContainmentFace, seedReadFileStateFromContext, seedReadFileStateFromTranscript, } from "../../tools/fs/index.js";
 import { resolveKey, sha256 } from "../../tools/fs/safety.js";
 import { normalizeFileText } from "../../tools/fs/encoding.js";
 import { wholeFileRecordsFromTranscript } from "./session-file-state-replay.js";
@@ -98,6 +98,7 @@ export function resolveHandsLessReadFace(input) {
     let handsLessResolvedFace;
     let handsLessResolvedWriteFace;
     let readDenyAdditionsNormalized = [];
+    let readDenyBuiltinTiersActive = [];
     {
         const liveFace = resolveContainmentFace({
             kind: "read",
@@ -120,7 +121,7 @@ export function resolveHandsLessReadFace(input) {
         const seedWrite = resume?.seed.writeFace;
         handsLessResolvedWriteFace = resume !== undefined && (seedWrite === undefined || seedWrite.face === "roots") ? "roots" : liveWriteFace;
         const denyAdditions = [...(deps.readDenyPatterns ?? []), ...(spec.readDenyPatterns ?? []), ...(seed?.denyEntries ?? [])];
-        resolveReadDenyBuiltins({
+        readDenyBuiltinTiersActive = activeReadDenyBuiltinTiers({
             ...(deps.readDenyBuiltinTiers !== undefined ? { tiers: deps.readDenyBuiltinTiers } : {}),
             ...(deps.readDenyBuiltinExclude !== undefined ? { exclude: deps.readDenyBuiltinExclude } : {}),
         });
@@ -139,6 +140,7 @@ export function resolveHandsLessReadFace(input) {
         resolvedReadFace: undefined,
         resolvedWriteFace: undefined,
         readDenyAdditionsNormalized,
+        readDenyBuiltinTiersActive,
         handsLessResolvedFace,
         handsLessResolvedWriteFace,
         additionalRootsCanonical: [],
@@ -168,6 +170,7 @@ export async function prepareHandsMount(input) {
     let resolvedReadFace;
     let resolvedWriteFace;
     let readDenyAdditionsNormalized = [];
+    let readDenyBuiltinTiersActive = [];
     let handsLessResolvedFace;
     const handsLessResolvedWriteFace = undefined;
     const shellGatedTools = new Set();
@@ -245,6 +248,7 @@ export async function prepareHandsMount(input) {
             ...(deps.readDenyBuiltinExclude !== undefined ? { exclude: [...deps.readDenyBuiltinExclude] } : {}),
         };
         readDenyMatcher = compileReadDeny(readDenyAdditions, "readDenyPatterns", readDenyBuiltinCfg);
+        readDenyBuiltinTiersActive = activeReadDenyBuiltinTiers(readDenyBuiltinCfg);
         readDenyAdditionsNormalized = compileReadDeny(readDenyAdditions, "readDenyPatterns", { tiers: [] }).entries;
         let liveReadFace = resolveContainmentFace({
             kind: "read",
@@ -323,11 +327,16 @@ export async function prepareHandsMount(input) {
                         sessionSeats.reanchor(sessionId, readFileState, ownCommittedTailEntryId);
                 }
                 : undefined;
+        const compiledDeny = readDenyMatcher;
+        const denySeatJudge = compiledDeny !== undefined && compiledDeny.entries.length > 0
+            ? (p) => compiledDeny.matchPath(p)?.pattern ?? null
+            : undefined;
         const shellReadBoundary = () => ({
             roots: [rootCanonical, ...additionalRootsCanonical, ...additionalReadRootsCanonical],
             ...(handsCwdRef?.current !== undefined ? { cwd: handsCwdRef.current } : {}),
             ...(executionEnv.homeDir !== undefined ? { homeDir: executionEnv.homeDir } : {}),
-            denyMatch: (p) => readDenyMatcher?.matchPath(p)?.pattern ?? null,
+            ...(denySeatJudge !== undefined ? { denyMatch: denySeatJudge } : {}),
+            denyEntries: (compiledDeny?.entries ?? []).map((e) => e.pattern),
             ...(resolvedReadFace !== undefined ? { face: resolvedReadFace } : {}),
         });
         const band = createHandsToolkit(executionEnv, readFileState, rootCanonical, {
@@ -421,6 +430,7 @@ export async function prepareHandsMount(input) {
         resolvedWriteFace,
         handsLessResolvedWriteFace,
         readDenyAdditionsNormalized,
+        readDenyBuiltinTiersActive,
         handsLessResolvedFace,
         additionalRootsCanonical,
         additionalReadRootsCanonical,

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

@@ -171,7 +171,7 @@ export async function prepareMemory(input) {
             const choosePersonalBackend = () => typeof pinned === "string" && pinned ? new FileMemoryEngineBackend(personalMemoryDir, { controlDir: personalControlDir }) : backend;
             const createPersonalEngine = (personalBackend) => {
                 return {
-                    engine: new MemoryEngine({ backend: personalBackend, memoryDir: personalMemoryDir, controlDir: personalControlDir, onIncident: onEngineIncident, provenance: input.memoryProvenance, ...captureStoreOpt(personalBackend, personalControlDir), ...(input.deps.memoryConsolidation !== undefined ? { consolidation: input.deps.memoryConsolidation } : {}) }),
+                    engine: new MemoryEngine({ backend: personalBackend, memoryDir: personalMemoryDir, controlDir: personalControlDir, onIncident: onEngineIncident, provenance: input.memoryProvenance, ...captureStoreOpt(personalBackend, personalControlDir), ...(deps.memorySessionIncarnation !== undefined ? { sessionIncarnation: deps.memorySessionIncarnation } : {}), ...(input.deps.memoryConsolidation !== undefined ? { consolidation: input.deps.memoryConsolidation } : {}) }),
                     backend: personalBackend,
                 };
             };
@@ -359,7 +359,7 @@ export async function prepareMemory(input) {
                     controlDir: identityKey !== undefined ? deriveProjectControlDir(engineRoot, identityKey) : deriveRepoControlPlaneDir(engineRoot, repoRoot),
                     onIncident: onEngineIncident,
                     provenance: input.memoryProvenance,
-                    ...captureStoreOpt(backend, identityKey !== undefined ? deriveProjectControlDir(engineRoot, identityKey) : deriveRepoControlPlaneDir(engineRoot, repoRoot)),
+                    ...captureStoreOpt(backend, identityKey !== undefined ? deriveProjectControlDir(engineRoot, identityKey) : deriveRepoControlPlaneDir(engineRoot, repoRoot)), ...(deps.memorySessionIncarnation !== undefined ? { sessionIncarnation: deps.memorySessionIncarnation } : {}),
                     ...(input.deps.memoryConsolidation !== undefined ? { consolidation: input.deps.memoryConsolidation } : {}),
                 });
                 const personal = createPersonalEngine(personalBackendChosen);
@@ -439,7 +439,7 @@ export async function prepareMemory(input) {
                     controlDir: identityKey !== undefined ? deriveProjectControlDir(engineRoot, identityKey) : deriveRepoControlPlaneDir(engineRoot, repoRoot),
                     onIncident: onEngineIncident,
                     provenance: input.memoryProvenance,
-                    ...captureStoreOpt(backend, identityKey !== undefined ? deriveProjectControlDir(engineRoot, identityKey) : deriveRepoControlPlaneDir(engineRoot, repoRoot)),
+                    ...captureStoreOpt(backend, identityKey !== undefined ? deriveProjectControlDir(engineRoot, identityKey) : deriveRepoControlPlaneDir(engineRoot, repoRoot)), ...(deps.memorySessionIncarnation !== undefined ? { sessionIncarnation: deps.memorySessionIncarnation } : {}),
                     ...(input.deps.memoryConsolidation !== undefined ? { consolidation: input.deps.memoryConsolidation } : {}),
                 });
                 await armCaptureOptOut(engine);

package/dist/core/runner/prepare-protocol-tools.d.ts

@@ -1,5 +1,5 @@
 import type { AgentTool } from "../../internal/harness.js";
-import { type MaterializedMcp, type McpDroppedTool } from "../mcp.js";
+import { type MaterializedMcp, type McpDroppedTool, type McpReconnectResult } from "../mcp.js";
 import { type MaterializedA2a } from "../a2a.js";
 import type { LockedPreflight } from "../locked-config.js";
 import type { RunnerDeps, TaskSpec, ToolEffect } from "../types.js";
@@ -90,6 +90,11 @@ export interface PrepareProtocolToolsResult {
     toolCallGateArmedRef: {
         armed: boolean;
     };
+    /** owned — the run handle's `reconnectMcpServer` implementation, present ONLY when this leg declared
+     *  MCP servers (a leg with none has nothing to re-dial, and the stream verb refuses typed rather
+     *  than answering about a materialization that was never made). The driver projects it onto
+     *  `Prepared.mcpRedial`, from which the run's wiring binds the verb's seat. */
+    mcpRedial?: (server: string) => Promise<McpReconnectResult>;
 }
 /** The M5 phase body — prepareTask's protocol-tools stretch, verbatim (see the module header). */
 export declare function prepareProtocolTools(input: PrepareProtocolToolsInput): Promise<PrepareProtocolToolsResult>;

package/dist/core/runner/prepare-protocol-tools.js

@@ -1,5 +1,6 @@
 import { Type } from "typebox";
 import { materializeMcpTools } from "../mcp.js";
+import { applyMcpRosterDelta, commitMcpRosterChanges, redialMcpServer } from "./mcp-redial.js";
 import { materializeA2aTools } from "../a2a.js";
 import { deliverEngineNotice } from "../types.js";
 import { RosterBuilder } from "../tool-roster.js";
@@ -16,7 +17,8 @@ export async function prepareProtocolTools(input) {
     }
     const mcp = lockedPreflight.mcp?.length
         ? await materializeMcpTools(lockedPreflight.mcp, spec.principal, deps.onElicit, deps.mcpImageResizer, { reminderMark, counts: reminderDisclosureCounts }, mcpRevocationWiring(deps, runId))
-        : { tools: [], toolAxes: [], warnings: [], serverInstructions: [], instructionsDelta: { pendingAdds: [], pendingRemovals: [] }, droppedTools: [], statuses: [], refresh: async () => [], dispose: async () => { } };
+        :
+            { tools: [], toolAxes: [], warnings: [], serverInstructions: [], instructionsDelta: { pendingAdds: [], pendingRemovals: [] }, droppedTools: [], statuses: [], refresh: async () => [], reconnect: async (server) => ({ server, prefix: mintNamespacePrefix(MCP_NAMESPACE, server), outcome: "not_declared", reason: "this task declared no MCP servers", toolCount: 0, added: [], removed: [] }), dispose: async () => { } };
     if (lockedPreflight.mcp?.length)
         rollback.push(function mcpDispose() { return mcp.dispose(); });
     for (const w of mcp.warnings)
@@ -58,6 +60,10 @@ export async function prepareProtocolTools(input) {
     const rebuildHarnessToolsRef = {};
     const contentOriginWrapRef = {};
     const toolCallGateArmedRef = { armed: false };
+    const rosterApply = { toolFaceSnapshot, withFaces, remoteToolOffload, foldProtocolAxes: (axes, label) => foldProtocolAxes(axes, label), toolEffects, axisExplicitNegatives, roster };
+    const rosterCommit = { rebuildHarnessToolsRef, rosterSeat, toolCallGateArmedRef, irreversibleTools, egressTools };
+    const redialInput = { ...rosterApply, ...rosterCommit, mcp, deps, sessionId, runId, irreversibilityTier };
+    const mcpRedial = lockedPreflight.mcp?.length ? (server) => redialMcpServer(redialInput, server) : undefined;
     if (lockedPreflight.mcp?.length) {
         roster.mount({
             ...toolFace("refresh-mcp-tools"),
@@ -73,42 +79,20 @@ export async function prepareProtocolTools(input) {
                 const lines = [];
                 let changed = false;
                 let anyActiveFailure = false;
+                const excludedSet = new Set(toolFaceSnapshot.exclude ?? []);
                 for (const r of results) {
-                    if (r.status !== "refreshed" || r.tools === undefined) {
+                    if (r.tools === undefined) {
                         lines.push(`${r.server}: ${r.status}${r.error !== undefined ? ` (${r.error})` : ""}`);
                         if (r.status === "failed")
                             anyActiveFailure = true;
                         continue;
                     }
-                    const excludedSet = new Set(toolFaceSnapshot.exclude ?? []);
-                    const pushable = r.tools.filter((t) => !excludedSet.has(t.name));
-                    const excludedNow = r.tools.filter((t) => excludedSet.has(t.name)).map((t) => t.name);
-                    const domainSnapshot = (m) => new Map([...m].filter(([name]) => name.startsWith(r.prefix)));
-                    const restoreDomain = (m, snap) => {
-                        for (const name of [...m.keys()])
-                            if (name.startsWith(r.prefix))
-                                m.delete(name);
-                        for (const [name, v] of snap)
-                            m.set(name, v);
-                    };
-                    const priorDomainEffects = domainSnapshot(toolEffects);
-                    const priorDomainNegatives = domainSnapshot(axisExplicitNegatives);
-                    for (const name of priorDomainEffects.keys())
-                        toolEffects.delete(name);
-                    for (const name of priorDomainNegatives.keys())
-                        axisExplicitNegatives.delete(name);
-                    try {
-                        foldProtocolAxes((r.axes ?? []).filter((a) => !excludedSet.has(a.name)), "MCP");
-                    }
-                    catch (foldErr) {
-                        restoreDomain(toolEffects, priorDomainEffects);
-                        restoreDomain(axisExplicitNegatives, priorDomainNegatives);
-                        lines.push(`${r.server}: failed (${foldErr instanceof Error ? foldErr.message : String(foldErr)})`);
+                    const applied = applyMcpRosterDelta(rosterApply, { server: r.server, prefix: r.prefix, tools: r.tools, axes: r.axes ?? [], dropped: r.dropped ?? [] });
+                    if (!applied.applied) {
+                        lines.push(`${r.server}: failed (${applied.foldError})`);
                         anyActiveFailure = true;
                         continue;
                     }
-                    const refreshedMounts = withFaces(pushable, r.server).map((t) => remoteToolOffload(t));
-                    roster.replaceDomain(r.prefix, refreshedMounts, { source: "mcp", mountedBy: "optional", origin: { peer: r.server } });
                     changed = true;
                     const detail = [];
                     const shownAdded = r.added.filter((n) => !excludedSet.has(n));
@@ -116,18 +100,16 @@ export async function prepareProtocolTools(input) {
                         detail.push(`added: ${shownAdded.join(", ")}`);
                     if (r.removed.length > 0)
                         detail.push(`removed: ${r.removed.join(", ")}`);
-                    if (excludedNow.length > 0)
-                        detail.push(`excluded by deployment config (not mounted): ${excludedNow.join(", ")}`);
+                    if (applied.excluded.length > 0)
+                        detail.push(`excluded by deployment config (not mounted): ${applied.excluded.join(", ")}`);
                     if ((r.dropped?.length ?? 0) > 0)
                         detail.push(`dropped: ${r.dropped.map((d) => `${d.tool} (${d.reason.length > 90 ? `${d.reason.slice(0, 90)}…` : d.reason})`).join("; ")}`);
-                    lines.push(`${r.server}: refreshed — ${pushable.length} tool${pushable.length === 1 ? "" : "s"}${detail.length > 0 ? ` (${detail.join("; ")})` : ""}`);
+                    lines.push(`${r.server}: refreshed — ${applied.pushed} tool${applied.pushed === 1 ? "" : "s"}${detail.length > 0 ? ` (${detail.join("; ")})` : ""}`);
                 }
-                if (changed)
-                    await rebuildHarnessToolsRef.current?.();
-                if (changed)
-                    rosterSeat.republish();
-                if (changed && !toolCallGateArmedRef.armed && (irreversibleTools.size > 0 || egressTools.size > 0)) {
-                    lines.push("WARNING: refreshed tools declare irreversible/egress safety hints, but this task started with no approval gate registered (no policy/hooks and no gated tools at start) — these hints cannot arm a gate mid-task (RB-46); the refreshed tools run ungated on this deployment shape.");
+                if (changed) {
+                    const ungated = await commitMcpRosterChanges(rosterCommit);
+                    if (ungated !== undefined)
+                        lines.push(ungated);
                 }
                 const text = lines.length === 0 ? "No connected MCP servers to refresh." : lines.join("\n");
                 return {
@@ -184,7 +166,7 @@ export async function prepareProtocolTools(input) {
     for (const t of a2a.tools)
         roster.mount(remoteToolOffload(t), { source: "a2a", mountedBy: "optional", origin: { peer: A2A_NAMESPACE.parse(t.name)?.peer ?? t.name } });
     foldProtocolAxes(a2a.toolAxes, "A2A");
-    return { mcp, a2a, rebuildHarnessToolsRef, contentOriginWrapRef, toolCallGateArmedRef };
+    return { mcp, a2a, rebuildHarnessToolsRef, contentOriginWrapRef, toolCallGateArmedRef, ...(mcpRedial !== undefined ? { mcpRedial } : {}) };
 }
 function mcpRevocationWiring(deps, runId) {
     if (deps.mcpRevocations === undefined)

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

@@ -436,7 +436,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             roster.mount(createOutputTool(outputRef, spec.outputSchema, compiled.strict ? compiled.modelSchema : undefined), { source: "synthetic", mountedBy: "optional" });
         }
         const rosterSeat = new ToolRosterDeltaSeat();
-        const { mcp, a2a, rebuildHarnessToolsRef, contentOriginWrapRef, toolCallGateArmedRef } = await prepareProtocolTools({ lockedPreflight, spec, deps, reminderMark, reminderDisclosureCounts, runId, sessionId, onceLedger, roster, rosterSeat, remoteToolOffload, toolFaceSnapshot, toolEffects, axisExplicitNegatives, irreversibilityTier, irreversibleTools, egressTools, abortController, rollback });
+        const { mcp, a2a, rebuildHarnessToolsRef, contentOriginWrapRef, toolCallGateArmedRef, mcpRedial } = await prepareProtocolTools({ lockedPreflight, spec, deps, reminderMark, reminderDisclosureCounts, runId, sessionId, onceLedger, roster, rosterSeat, remoteToolOffload, toolFaceSnapshot, toolEffects, axisExplicitNegatives, irreversibilityTier, irreversibleTools, egressTools, abortController, rollback });
         const callIssuedAtRef = {};
         const workCutRef = { continuation: false, abortedBeforeTurnEnd: false };
         const advertisedWritableDirs = handsEnabled
@@ -690,7 +690,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             }
         }
         const { hooks, hookTimeoutMs, preToolUseObservational, ownGatePreToolUse, basePolicyForResumeEdit, denyNarrowingPolicy, policyLayers, effectivePolicy, inheritedUnavailableAsks, inheritedAskGrants, askSourceIdentity, riskAxesOf, ruleOffersOf, permissionRuleLane, permissionRuleOrgLane, sandboxAdmissionArmed, sandboxBoundaryCapable, emitSandboxAdmitted, foldAskClasses, ancestorSandboxAdmissions } = await preparePolicyChain({ spec, deps, internals, sessionId, runId, hostTaskId, taskRootFinal, executionEnv, lockedPreflight, tools, harnessTools, toolEffects, egressTools, irreversibilityTier, axisExplicitNegatives, shellGatedTools, envHandToolNames, handsCwdRef, readDenyMatcher, questionToolMounted, runtimeCaps, inheritedAncestorRules, inheritedParentConstraints, seedInheritedGate, hasSkillManifest, skillScope, frozenOnAsk, hookEnvSource, notifyOwnHookCrash, autoModeDecider, stopForDenialLimit, delegation, abortController, now, ownSessionRulesRef });
-        const { onAsk, preToolContexts, blockedToolCalls, gateOutcomes, batchHaltRef, blockedTracked, incompleteSuspendAdapter, durableSuspendInfraReady, resourceSuspendEligible, usageGovernance, durableApproval, wiringManifest, writeProtectionCheck, parkLaneArmed, gateMachineryActive, hookIdentity, hookEnvFace } = prepareWiringManifest({ spec, deps, internals, resume, sessionId, runId, hostTaskId, taskScope, hooks, preToolUseObservational, policyLayers, effectivePolicy, handsEnabled, taskRootFinal, mcp, irreversibleTools, egressTools, toolEffects, ownedEnv, executionEnv, offloadStore, onceLedger, usageWindows, envLifetimeSuspendAt, runtimeCaps, resolvedInteractionPosture, durableQuestionFace, liveQuestionFace, checkpointStore, sessions, modelGateManifest, autoModeArmReason, lockedPreflight, peerLaneRefs, peerLaneActive, harness, pausedRef, frozenOnAsk, liveInheritedGate, delegation, toolRoster, lspManagerWired, lspDiagnosticsLive: lspDiagnostics !== undefined });
+        const { onAsk, preToolContexts, blockedToolCalls, gateOutcomes, batchHaltRef, blockedTracked, incompleteSuspendAdapter, durableSuspendInfraReady, resourceSuspendEligible, usageGovernance, durableApproval, wiringManifest, writeProtectionCheck, parkLaneArmed, gateMachineryActive, hookIdentity, hookEnvFace } = prepareWiringManifest({ spec, deps, internals, resume, sessionId, runId, hostTaskId, taskScope, hooks, preToolUseObservational, policyLayers, effectivePolicy, handsEnabled, taskRootFinal, mcp, irreversibleTools, egressTools, toolEffects, ownedEnv, executionEnv, offloadStore, onceLedger, usageWindows, envLifetimeSuspendAt, runtimeCaps, resolvedInteractionPosture, durableQuestionFace, liveQuestionFace, checkpointStore, sessions, modelGateManifest, autoModeArmReason, lockedPreflight, peerLaneRefs, peerLaneActive, harness, pausedRef, frozenOnAsk, liveInheritedGate, delegation, toolRoster, readDenyBuiltinTiersActive: handsReadFace.readDenyBuiltinTiersActive, lspManagerWired, lspDiagnosticsLive: lspDiagnostics !== undefined });
         if (fileHistoryBoundary !== undefined) {
             harness.on("tool_call", async () => {
                 await fileHistoryBoundary.settle();
@@ -702,11 +702,11 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         const { suspendForResource, suspendForPlatformLimit, suspendForReview } = prepareBoundaryParks({ saga, spec, checkpointStore, abortController, harness, session, sessions, sessionId, deps, priorLedger, maxSlices, maxSuspends, resourceTotal, priorSuspendCount, suspendChainBase, humanReviewRef, liveSpendRef, now, faceCheckpointState, f012CheckpointState, orgAdmissionCheckpointState, pausedRef, remoteEnvFailures, resourceSuspendEligible, durableSuspendInfraReady, incompleteSuspendAdapter });
         const { parkAsk } = prepareParkAsk({ askLane, saga, spec, deps, sessionId, checkpointStore, toolRosterDeltas: rosterSeat, parkLaneArmed, contentAskRoutable, liveQuestionFace, mountedQuestionTool, contentAskBindings, lateStrandedAnswers, discloseStrandedAnswers, onAsk, runtimeCaps, inheritedUnavailableAsks, basePolicyForResumeEdit, budgetSnapshot, handsCwdRef, advertisedWritableDirs, offloadStore, ownedEnv, incompleteSuspendAdapter, session, sessions, suspendChainBase, maxSuspends, remoteEnvFailures, shellGatedTools, effectiveShellGate, durableApproval, priorLedger, liveSpendRef, resourceTotal, faceCheckpointState, f012CheckpointState, orgAdmissionCheckpointState, ruleOffersOf, now, humanReviewRef, abortController, harness, pausedRef });
         prepareGateStations({ askLane, parkAsk, tools, toolRosterDeltas: rosterSeat, toolEffects, deps, toolCallGateArmedRef, effectivePolicy, hooks, egressTools, irreversibleTools, spec, complianceDenies, harness, blockedToolCalls, inheritedAskGrants, inheritedUnavailableAsks, foldAskClasses, ancestorSandboxAdmissions, preToolContexts, gateOutcomes, batchHaltRef, blockedTracked, hookIdentity, reminderMark, planModeRef, hostTaskId, sessionId, ownGatePreToolUse, hookTimeoutMs, handsCwdRef, hookEnvFace, writeProtectionCheck, irreversibilityTier, reversibilityProbes, abortController, shellGatedTools, autoModeDecider, autoModeDenialTracking, stopForDenialLimit, permissionRuleLane, permissionRuleOrgLane, questionToolMounted, sandboxAdmissionArmed, sandboxBoundaryCapable, emitSandboxAdmitted, delegation, notifyOwnHookCrash });
-        const { microCompact, charsPerToken } = prepareContextLane({ model, deps, sessionId, runId, hostTaskId, offloadStore, microCompactKnob, harness, batchHaltRef, gitStatusRef, requestLossyRef, trimPressureRef });
+        const { microCompact, charsPerToken } = prepareContextLane({ model, deps, sessionId, runId, hostTaskId, offloadStore, microCompactKnob, harness, batchHaltRef, gitStatusRef, requestLossyRef, trimPressureRef, ...(readFileStateForCheckpoint !== undefined ? { readFileState: readFileStateForCheckpoint } : {}) });
         const preparedHolder = {};
         const { cacheBreakDetector, cacheFingerprint, promptOverheadTokens, readTaskFile, normalizeAttachmentPath, isDedupStubResult, recentlyReadFiles, onCompactionApplied, detectExternalChanges, listBackgroundTasks, centerCompactionCandidate, effectiveReadFaceObserved, effectiveWriteFaceObserved, effectiveReadDenyObserved } = prepareTurnWiring({ deps, systemPromptSeat, harnessTools, fpRef, model, epochArtifactDigestForSnapshot, promptProfile, fableMitigations, systemBlocks, thinking, spec, sessionId, turnSnapshotRef, promptManifest, charsPerToken, handsEnabled, executionEnv, attachmentRootCanonical, additionalRootsCanonical, additionalReadRootsCanonical, readDenyMatcher, resolvedReadFace, handsCwdRef, readFileStateForCheckpoint, denyNarrowingPolicy, abortController, hostTaskId, taskScope, buildAssembleInputs, centerAdoptionRef, harnessRef, epochDeclaredSections, carrierReadFace, carrierWriteFace, readDenyAdditionsNormalized, preparedHolder });
         await onceLedger.settle(session, announcedListingsRef);
-        const buildPrepared = () => ({ harness, session, sessionId, runId, reminderMark, reminderDisclosureCounts, editedFilesSnapshot, taskRootPath: taskRootFinal, model, thinking, compModel: effectiveCompModel, mcp, ...(a2a.tools.length > 0 ? { a2a } : {}), blockedRef, outputRef, abortController, conflictRef, blockedToolCalls, gateOutcomes, batchHaltRef, nestedStats, ...(rewindNotes.length > 0 ? { rewindNotes } : {}), ...(fileHistoryBoundary !== undefined ? { fileHistoryBoundary } : {}), ...(effectiveReadFaceObserved !== undefined ? { effectiveReadFace: effectiveReadFaceObserved, effectiveWriteFace: effectiveWriteFaceObserved } : {}), ...(effectiveReadDenyObserved !== undefined ? { effectiveReadDenyPatterns: effectiveReadDenyObserved } : {}), effectiveMemoryScopes: memoryEffectiveScopes, cwdRef: handsCwdRef, toolProgressRef, ...(advertisedWritableDirs !== undefined ? { advertisedWritableDirs } : {}), ...(worktreeSessionRef !== undefined ? { worktreeSessionRef } : {}), ...(workspaceStateSettle !== undefined ? { workspaceStateSettle } : {}), ...(sealReadStateSeat !== undefined ? { sealReadStateSeat } : {}), denyNarrowingPolicy, ...(permissionRuleLane !== undefined ? { persistedRuleLane: permissionRuleLane } : {}), ...(basePolicyForResumeEdit !== undefined ? { basePolicyForResumeEdit } : {}), ...(permissionRuleOrgLane !== undefined ? { permissionRuleOrg: permissionRuleOrgLane } : {}), releaseSignal, settleContentAskBindings, cacheBreakDetector, cacheFingerprint, wiringManifest, promptManifest, epochDeclaredSections, activeTools, ...(deferred.size > 0 ? { deferredToolNames: deferred } : {}), toolMaterializeStatic, deferDirectCall, ...(staticFaceForRef.current !== undefined ? { staticFaceFor: staticFaceForRef.current } : {}), ownedEnv, pausedRef, undeliveredContinuationRef, suspendProgressRef, remoteEnvFailures, reviewRequestRef, suspendLoopRef, suspendForResource, ...(suspendForPlatformLimit !== undefined ? { suspendForPlatformLimit } : {}), ...(envLifetimeSuspendAt !== undefined ? { envLifetimeSuspendAt } : {}), ...(usageGovernance !== undefined ? { usageGovernance } : {}), callIssuedAtRef, workCutRef, brainCallGuardrailRef, gateStopRef, suspendForReview, resourceLedger: priorLedger, liveSpendRef, humanReviewRef, now, tools, toolRoster, toolRosterDeltas: rosterSeat, structuredProjector, toolEffects, wakeRecovered, promptOverheadTokens, lastBrainContext, readTaskFile, recentlyReadFiles, normalizeAttachmentPath, isDedupStubResult, ...(onCompactionApplied ? { onCompactionApplied } : {}), compactionReuseRef, trimPressureRef, microCompact, ...(memoryEngineSession ? { memoryEngineSession } : {}), ...(subagentRetain ? { subagentRetain } : {}), ...(lspDiagnostics && nudgeLspOnEdit ? { lspDiagnostics: { registry: lspDiagnostics, nudge: nudgeLspOnEdit, runIdent: lspRunIdent } } : {}), planModeRef, stopRequestedRef, announcedSnapshotRecovered: onceLedger.recovered, ...(dateChange ? { dateChange } : {}), ...(instructionSources ? { instructionSources } : {}), ...(projectInstructionContent !== undefined ? { projectInstructionContent } : {}), ...(workflowSizeGuideline ? { workflowSizeGuideline } : {}), ...(detectExternalChanges ? { detectExternalChanges } : {}), ...(toolsDeltaRef ? { toolsDeltaRef } : {}), ...(agentListing ? { agentListing } : {}), ...(skillsListing ? { skillsListing } : {}), announcedListingsRef, frameReceipts: { pending: [], listingSnapshotOwed: false }, gitStatusRef, listBackgroundTasks, hookIdentity, hookTimeoutMs, ...(turnSnapshotRef.current !== undefined ? { turnSnapshot: turnSnapshotRef.current } : {}), ...(centerCompactionCandidate !== undefined ? { centerCompactionCandidate } : {}), ...(toolDisclosureSeat !== undefined ? { toolDisclosure: toolDisclosureSeat } : {}) });
+        const buildPrepared = () => ({ harness, session, sessionId, runId, reminderMark, reminderDisclosureCounts, editedFilesSnapshot, taskRootPath: taskRootFinal, model, thinking, compModel: effectiveCompModel, mcp, ...(mcpRedial !== undefined ? { mcpRedial } : {}), ...(a2a.tools.length > 0 ? { a2a } : {}), blockedRef, outputRef, abortController, conflictRef, blockedToolCalls, gateOutcomes, batchHaltRef, nestedStats, ...(rewindNotes.length > 0 ? { rewindNotes } : {}), ...(fileHistoryBoundary !== undefined ? { fileHistoryBoundary } : {}), ...(effectiveReadFaceObserved !== undefined ? { effectiveReadFace: effectiveReadFaceObserved, effectiveWriteFace: effectiveWriteFaceObserved } : {}), ...(effectiveReadDenyObserved !== undefined ? { effectiveReadDenyPatterns: effectiveReadDenyObserved } : {}), effectiveMemoryScopes: memoryEffectiveScopes, cwdRef: handsCwdRef, toolProgressRef, ...(advertisedWritableDirs !== undefined ? { advertisedWritableDirs } : {}), ...(worktreeSessionRef !== undefined ? { worktreeSessionRef } : {}), ...(workspaceStateSettle !== undefined ? { workspaceStateSettle } : {}), ...(sealReadStateSeat !== undefined ? { sealReadStateSeat } : {}), denyNarrowingPolicy, ...(permissionRuleLane !== undefined ? { persistedRuleLane: permissionRuleLane } : {}), ...(basePolicyForResumeEdit !== undefined ? { basePolicyForResumeEdit } : {}), ...(permissionRuleOrgLane !== undefined ? { permissionRuleOrg: permissionRuleOrgLane } : {}), releaseSignal, settleContentAskBindings, cacheBreakDetector, cacheFingerprint, wiringManifest, promptManifest, epochDeclaredSections, activeTools, ...(deferred.size > 0 ? { deferredToolNames: deferred } : {}), toolMaterializeStatic, deferDirectCall, ...(staticFaceForRef.current !== undefined ? { staticFaceFor: staticFaceForRef.current } : {}), ownedEnv, pausedRef, undeliveredContinuationRef, suspendProgressRef, remoteEnvFailures, reviewRequestRef, suspendLoopRef, suspendForResource, ...(suspendForPlatformLimit !== undefined ? { suspendForPlatformLimit } : {}), ...(envLifetimeSuspendAt !== undefined ? { envLifetimeSuspendAt } : {}), ...(usageGovernance !== undefined ? { usageGovernance } : {}), callIssuedAtRef, workCutRef, brainCallGuardrailRef, gateStopRef, suspendForReview, ...(readFileStateForCheckpoint !== undefined ? { readFileState: readFileStateForCheckpoint } : {}), resourceLedger: priorLedger, liveSpendRef, humanReviewRef, now, tools, toolRoster, toolRosterDeltas: rosterSeat, structuredProjector, toolEffects, wakeRecovered, promptOverheadTokens, lastBrainContext, readTaskFile, recentlyReadFiles, normalizeAttachmentPath, isDedupStubResult, ...(onCompactionApplied ? { onCompactionApplied } : {}), compactionReuseRef, trimPressureRef, microCompact, ...(memoryEngineSession ? { memoryEngineSession } : {}), ...(subagentRetain ? { subagentRetain } : {}), ...(lspDiagnostics && nudgeLspOnEdit ? { lspDiagnostics: { registry: lspDiagnostics, nudge: nudgeLspOnEdit, runIdent: lspRunIdent } } : {}), planModeRef, stopRequestedRef, announcedSnapshotRecovered: onceLedger.recovered, ...(dateChange ? { dateChange } : {}), ...(instructionSources ? { instructionSources } : {}), ...(projectInstructionContent !== undefined ? { projectInstructionContent } : {}), ...(workflowSizeGuideline ? { workflowSizeGuideline } : {}), ...(detectExternalChanges ? { detectExternalChanges } : {}), ...(toolsDeltaRef ? { toolsDeltaRef } : {}), ...(agentListing ? { agentListing } : {}), ...(skillsListing ? { skillsListing } : {}), announcedListingsRef, frameReceipts: { pending: [], listingSnapshotOwed: false }, gitStatusRef, listBackgroundTasks, hookIdentity, hookTimeoutMs, ...(turnSnapshotRef.current !== undefined ? { turnSnapshot: turnSnapshotRef.current } : {}), ...(centerCompactionCandidate !== undefined ? { centerCompactionCandidate } : {}), ...(toolDisclosureSeat !== undefined ? { toolDisclosure: toolDisclosureSeat } : {}) });
         rollback.commit();
         const prepared = buildPrepared();
         preparedHolder.current = prepared;

package/dist/core/runner/prepare-turn-wiring.js

@@ -6,7 +6,7 @@ import { CacheBreakDetector, toolsToFingerprintInputs } from "../cache-break-det
 import { defaultTaskRegistry } from "../task-registry.js";
 import { refuseOutOfContractDecision } from "../tool-policy.js";
 import { decodeTextBytes } from "../../tools/fs/encoding.js";
-import { applyCompactionToReadFileState, isReadDedupStubResult } from "../../tools/fs/index.js";
+import { applyContextShrinkToReadFileState, isReadDedupStubResult } from "../../tools/fs/index.js";
 import { resolveKey } from "../../tools/fs/safety.js";
 import { PROMPT_HASH_SALT } from "./prompt-hash-salt.js";
 import { CHANGED_FILES_MTIME_EPS_MS } from "./turn-attachments.js";
@@ -98,7 +98,7 @@ export function prepareTurnWiring(input) {
             .map(([path]) => path)
         : undefined;
     const onCompactionApplied = handsEnabled && readFileStateForCheckpoint
-        ? (attachedComplete, preserveReadState) => applyCompactionToReadFileState(readFileStateForCheckpoint, attachedComplete, preserveReadState)
+        ? (attachedComplete, preserveReadState) => applyContextShrinkToReadFileState(readFileStateForCheckpoint, { kind: "summarized", attachedComplete, ...(preserveReadState !== undefined ? { preserveKeys: preserveReadState } : {}) })
         : undefined;
     const changedFilesReadDenied = denyNarrowingPolicy === undefined
         ? undefined

package/dist/core/runner/prepare-wiring-manifest.d.ts

@@ -108,6 +108,10 @@ export interface PrepareWiringManifestInput {
     /** borrowed-readonly — the leg's minted tool roster: rides the manifest's `tools` section and is the
      *  source of the hand band's write-capable names for the ungated-write warning (what actually MOUNTED). */
     toolRoster: ToolRoster;
+    /** borrowed-readonly — from the read-face phase: the built-in read-deny TIERS that leg's own
+     *  resolution materially activated; relayed onto the manifest (present iff non-empty), never
+     *  re-derived from `deps` here (which by this phase sits past that phase's await). */
+    readDenyBuiltinTiersActive: readonly string[];
     /** borrowed-readonly — from the LSP phase's manager fold: gates the manifest's LSP section (absent ⇒ byte-identical manifest). */ lspManagerWired: boolean;
     /** borrowed-readonly — from the LSP phase: is the diagnostics lane live? The `lane` word's only input. */ lspDiagnosticsLive: boolean;
     /** borrowed-readonly — the arming outcome the caps phase minted (the manifest's auto-mode face). */

package/dist/core/runner/prepare-wiring-manifest.js

@@ -113,7 +113,7 @@ function announceDurableGateUnavailable(args) {
     });
 }
 export function prepareWiringManifest(input) {
-    const { spec, deps, internals, resume, sessionId, runId, hostTaskId, taskScope, hooks, preToolUseObservational, policyLayers, effectivePolicy, handsEnabled, taskRootFinal, mcp, irreversibleTools, egressTools, toolEffects, ownedEnv, executionEnv, offloadStore, onceLedger, usageWindows, envLifetimeSuspendAt, runtimeCaps, resolvedInteractionPosture, durableQuestionFace, liveQuestionFace, checkpointStore, sessions, modelGateManifest, autoModeArmReason, lockedPreflight, peerLaneRefs, peerLaneActive, harness, pausedRef, frozenOnAsk, liveInheritedGate, delegation, toolRoster, lspManagerWired, lspDiagnosticsLive } = input;
+    const { spec, deps, internals, resume, sessionId, runId, hostTaskId, taskScope, hooks, preToolUseObservational, policyLayers, effectivePolicy, handsEnabled, taskRootFinal, mcp, irreversibleTools, egressTools, toolEffects, ownedEnv, executionEnv, offloadStore, onceLedger, usageWindows, envLifetimeSuspendAt, runtimeCaps, resolvedInteractionPosture, durableQuestionFace, liveQuestionFace, checkpointStore, sessions, modelGateManifest, autoModeArmReason, lockedPreflight, peerLaneRefs, peerLaneActive, harness, pausedRef, frozenOnAsk, liveInheritedGate, delegation, toolRoster, readDenyBuiltinTiersActive, lspManagerWired, lspDiagnosticsLive } = input;
     const onAsk = spec.onAsk ?? deps.onAsk;
     const handWriteTools = toolRoster.entries.filter((e) => e.mountedBy === "hands" && (e.effect === "write" || e.effect === "idempotent")).map((e) => e.name);
     const hasEffectAwareGate = Boolean(policyLayers.length > 0 || (hooks?.preToolUse !== undefined && !preToolUseObservational));
@@ -208,6 +208,7 @@ export function prepareWiringManifest(input) {
         autoMode: { ...autoModeArmReason },
         mcp: mcpManifestEntries(lockedPreflight.mcp, mcp.statuses),
         ...(writeProtection !== undefined ? { writeProtectionTargetView: writeProtection.targetView } : {}),
+        readDenyBuiltinTiersActive,
         autoConsolidationOnRecommendation: autoRunOnRecommendationEffective(deps),
         tools: toolRoster,
         hooks: wiredHookEntries(hooks, spec.hooks !== undefined ? "spec" : "deps", preToolUseObservational),

package/dist/core/runner/run-harness-handlers.js

@@ -2,6 +2,7 @@ import { createSafeNotifier, observeThenableRejection } from "../safe-notify.js"
 import { forwardSafely } from "./forward-sink.js";
 import { emitTrace } from "../trace.js";
 import { primaryActivityArg } from "../arg-summary.js";
+import { redactSecrets } from "../untrusted-egress.js";
 import { readDegradation } from "../../brain/degrading.js";
 import { OUTPUT_TOOL_NAME } from "./synthetic-tools.js";
 import { usageCostMicroUsd } from "./usage-accounting.js";
@@ -157,8 +158,9 @@ export function createHarnessHandlers(input) {
                         rs.counters.repetitionCuts += 1;
                     else
                         rs.counters.repetitionSpared += 1;
+                    const segment = redactSecrets(e.segment);
                     if (rs.counters.repetitionEvents.length < rs.counters.REPETITION_EVENTS_CAP) {
-                        rs.counters.repetitionEvents.push({ turn: stats.turns + 1, action, rule: e.rule, period: e.period, reps: e.reps, segment: e.segment });
+                        rs.counters.repetitionEvents.push({ turn: stats.turns + 1, action, rule: e.rule, period: e.period, reps: e.reps, segment });
                     }
                     emitTrace(rs.telemetry.tracer, () => ({
                         kind: "repetition.detected",
@@ -169,7 +171,7 @@ export function createHarnessHandlers(input) {
                         rule: e.rule,
                         period: e.period,
                         reps: e.reps,
-                        segment: e.segment,
+                        segment,
                         ts: Date.now(),
                     }));
                 }

package/dist/core/runner/run-identity-wiring.d.ts

@@ -3,7 +3,7 @@ import { type PendingSessionNotifications, type SystemInjectionPriority, type Ta
 import type { PushQueue } from "../push-queue.js";
 import type { TaskEvent, TaskSpec } from "../types.js";
 import type { Stats } from "./assemble-result.js";
-import type { CaptureOptOutRef, LiveHandle, ManualCompactRef, NotificationLaneBindings, NotifyRef, Prepared, RunInternals, RunnerDepsSeat, TaskIdRef } from "./contracts.js";
+import type { CaptureOptOutRef, LiveHandle, ManualCompactRef, McpRedialRef, NotificationLaneBindings, NotifyRef, Prepared, RunInternals, RunnerDepsSeat, TaskIdRef } from "./contracts.js";
 export interface RunIdentityWiringInput {
     /** borrowed-readonly — the task spec: the task id and the memory / notification seats it names. */
     spec: TaskSpec;
@@ -27,6 +27,8 @@ export interface RunIdentityWiringInput {
     notifyRef: NotifyRef | undefined;
     /** borrowed-mutable — the capture opt-out bridge: `flip` is bound here when a memory session mounted. */
     captureOptOutRef: CaptureOptOutRef | undefined;
+    /** borrowed-mutable — the MCP re-dial bridge: `redial` is bound here when the leg declared MCP servers. */
+    mcpRedialRef: McpRedialRef | undefined;
     /** borrowed-readonly — the notification lane's ONE injection entry (the R0 lane's). */
     injectTaskNotification: (notification: TaskNotificationPayload, opts?: {
         priority?: SystemInjectionPriority;

package/dist/core/runner/run-identity-wiring.js

@@ -3,7 +3,7 @@ import { createSafeNotifier } from "../safe-notify.js";
 import { discloseDroppedPending, renderTaskNotificationXml, taskNotificationDedupKey } from "../task-notification.js";
 import { deliverDelegationLifecycle, deliverEngineNotice, undrainedUserInputNotices } from "../types.js";
 export function runIdentityWiring(input) {
-    const { spec, queue, prepared, internals, taskIdRef, onReady, manualCompactRef, notifyRef, captureOptOutRef, injectTaskNotification, deliveredAtTurnOpen, peerInboundChainRef, notificationLane, pendingSessionNotifications, runner } = input;
+    const { spec, queue, prepared, internals, taskIdRef, onReady, manualCompactRef, notifyRef, captureOptOutRef, mcpRedialRef, injectTaskNotification, deliveredAtTurnOpen, peerInboundChainRef, notificationLane, pendingSessionNotifications, runner } = input;
     notificationLane.harness = prepared.harness;
     notificationLane.sessionId = prepared.sessionId;
     if (taskIdRef)
@@ -66,6 +66,9 @@ export function runIdentityWiring(input) {
     if (captureOptOutRef && prepared.memoryEngineSession?.captureOptOut !== undefined) {
         captureOptOutRef.flip = prepared.memoryEngineSession.captureOptOut.flip;
     }
+    if (mcpRedialRef && prepared.mcpRedial !== undefined) {
+        mcpRedialRef.redial = prepared.mcpRedial;
+    }
     try {
         internals?.onNotifyInjectorReady?.(injectTaskNotification);
     }

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

@@ -1,5 +1,6 @@
 import { DEFAULT_COMPACTION_SETTINGS } from "../../internal/harness.js";
 import { planRejectionClears } from "../context-edit.js";
+import { landStaleResultClears } from "./prepare-context-lane.js";
 import { DEFAULT_COMPACTION_INSTRUCTIONS, maybeCompact } from "../auto-compaction.js";
 import { emitTrace } from "../trace.js";
 import { isDegenerateCutMessage } from "../../brain/terminal-cause.js";
@@ -145,9 +146,11 @@ export function runRecoveryLanes(input) {
                         }));
                     }
                     else {
-                        for (const e of plan.cleared) {
-                            prepared.microCompact.ledger.entries.set(e.key, { marker: e.marker, groupCount: e.groupCount, fp: e.fp });
-                        }
+                        landStaleResultClears({
+                            ledger: prepared.microCompact.ledger,
+                            cleared: plan.cleared,
+                            ...(prepared.readFileState !== undefined ? { readFileState: prepared.readFileState } : {}),
+                        });
                         emitTrace(rs.telemetry.tracer, () => ({
                             kind: "context.mc_clear",
                             version: 1,

package/dist/core/runner/run-settle-and-teardown.d.ts

@@ -23,7 +23,7 @@ import type { AssistantMessage } from "../../internal/llm.js";
 import type { ResolvedReasoning } from "../../brain/reasoning.js";
 import type { PushQueue } from "../push-queue.js";
 import type { SessionStore } from "../session.js";
-import { type CompactOutcome, type DelegationLifecycleEvent, type TaskEvent, type TaskResult, type TaskSpec } from "../types.js";
+import { type CompactOutcome, type DelegationLifecycleEvent, type OwedUserInputAccount, type TaskEvent, type TaskResult, type TaskSpec } from "../types.js";
 import { type Stats } from "./assemble-result.js";
 import type { EndOfTaskCompaction, InstallingPhaseResult, ManualCompactRef, Prepared, ResumeRun, RunInternals, RunnerDepsSeat, RunState, SuspendReap, TaskIdRef } from "./contracts.js";
 export interface RunSettleAndTeardownInput {
@@ -94,6 +94,8 @@ export interface RunSettleAndTeardownInput {
     };
     /** borrowed-readonly — the end-of-task compaction's outcome (the terminal-adoption lane's `finish` call). */
     comp: EndOfTaskCompaction;
+    /** borrowed-readonly — the adoption lane's unsettled undrained-input account, closed below (after the reopen). */
+    owedUserInput: OwedUserInputAccount;
     /** borrowed-readonly — the stream's result setter: the assembled TaskResult is published through it exactly once. */
     setResult: (r: TaskResult) => void;
     /** borrowed-readonly — the stream's suggestions seat: the fire-and-forget suggestion pass's promise is handed to it. */

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

@@ -9,7 +9,7 @@ import { hasDestroy, isIsolated } from "../remote-env.js";
 import { resolveTaskModel } from "../roles.js";
 import { defaultTaskRegistry } from "../task-registry.js";
 import { emitTrace } from "../trace.js";
-import { deliverEngineNotice } from "../types.js";
+import { deliverEngineNotice, settleOwedUserInput } from "../types.js";
 import { assembleResult } from "./assemble-result.js";
 import { discloseUnconsumedHalt } from "./halt-attribution.js";
 import { forwardSafely } from "./forward-sink.js";
@@ -21,7 +21,7 @@ import { settleTeardownLeg } from "./teardown-bounded.js";
 import { autoRunConsolidationFromRecommendation, autoRunOnRecommendationEffective, scopeHasUnconsumedRecommendation } from "./memory-consolidation-driver.js";
 import { amendTerminal, terminalProjection } from "./terminal-projection.js";
 export async function runSettleAndTeardown(input) {
-    const { spec, queue, prepared, resume, internals, rs, stats, ident, parentToolCallId, subagentName, loopLatch, timeout, ownCommittedTailRef, emitDelegationLifecycle, taskIdRef, manualCompactRef, drainManualCompact, final, threw, abortedLive, userInterruptedLive, answerSettled, strandedHumanAnswers, reasoningResolution, comp, setResult, onSuggestions, onSuspend, runner, sessions } = input;
+    const { spec, queue, prepared, resume, internals, rs, stats, ident, parentToolCallId, subagentName, loopLatch, timeout, ownCommittedTailRef, emitDelegationLifecycle, taskIdRef, manualCompactRef, drainManualCompact, final, threw, abortedLive, userInterruptedLive, answerSettled, strandedHumanAnswers, reasoningResolution, comp, owedUserInput, setResult, onSuggestions, onSuspend, runner, sessions } = input;
     try {
         if (comp?.compacted) {
             queue.push({
@@ -141,6 +141,7 @@ export async function runSettleAndTeardown(input) {
             });
         }
         discloseUnconsumedHalt({ accepted: loopLatch.userHalted, consumption: prepared.harness.haltConsumption(), onNotice: runner.deps.onNotice, sessionId: prepared.sessionId, runId: rs.telemetry.runId, taskId: spec.taskId });
+        let rowReturned = false;
         if (resume !== undefined &&
             resume.pendingActionStarted !== true &&
             result.terminal.kind !== "completed" &&
@@ -149,12 +150,14 @@ export async function runSettleAndTeardown(input) {
             resume.onEnvRestoreFailed !== undefined) {
             try {
                 await resume.onEnvRestoreFailed("env_failed");
+                rowReturned = true;
                 amendTerminal(result, "resume.reopened_unstarted", (m) => `${m ?? "the resume leg did not complete"} — the approved action never started, so the checkpoint was REOPENED (pending): the same approval can be resumed again, do not ask for a fresh one`);
             }
             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`);
             }
         }
+        settleOwedUserInput(owedUserInput, rowReturned, { taskId: spec.taskId ?? prepared.sessionId, sessionId: prepared.sessionId, runId: prepared.runId }, runner.deps.onNotice);
         prepared.sealReadStateSeat?.(ownCommittedTailRef.current);
         {
             const wss = prepared.workspaceStateSettle;
@@ -299,6 +302,7 @@ export async function runSettleAndTeardown(input) {
         }
     }
     finally {
+        settleOwedUserInput(owedUserInput, !prepared.suspendProgressRef.executedApproved, { taskId: spec.taskId ?? prepared.sessionId, sessionId: prepared.sessionId, runId: prepared.runId }, runner.deps.onNotice);
         const ownedEnvDying = prepared.ownedEnv !== undefined &&
             hasDestroy(prepared.ownedEnv) &&
             isIsolated(prepared.ownedEnv) &&

package/dist/core/runner/run-telemetry-and-budget-seats.js

@@ -1,3 +1,4 @@
+import { primaryActivityArg } from "../arg-summary.js";
 import { remainingBudgetMicroUsd, remainingTokens } from "../checkpoint-store.js";
 import { computeCostMicroUsd, isModelPriced, malformedPricingField, modelCostToPricing } from "../pricing.js";
 import { resolveModel } from "../roles.js";
@@ -19,7 +20,16 @@ export function runTelemetryAndBudgetSeats(input) {
         prepared.humanReviewRef.count += 1;
         prepared.humanReviewRef.totalWaitMs += waitMs;
         const gateToolName = "toolName" in resume.cp.gate ? resume.cp.gate.toolName : undefined;
-        prepared.humanReviewRef.gates.push({ kind: resume.cp.gate.kind, waitMs, ...(decision !== undefined ? { decision } : {}), ...(gateToolName !== undefined ? { toolName: gateToolName } : {}) });
+        const gatedCall = resume.cp.pendingAction.kind === "tool_approval" ? resume.cp.pendingAction : undefined;
+        const gateToolArg = gatedCall === undefined ? undefined : primaryActivityArg(gatedCall.args);
+        prepared.humanReviewRef.gates.push({
+            kind: resume.cp.gate.kind,
+            waitMs,
+            ...(decision !== undefined ? { decision } : {}),
+            ...(gateToolName !== undefined ? { toolName: gateToolName } : {}),
+            ...(gatedCall !== undefined ? { toolCallId: gatedCall.toolCallId } : {}),
+            ...(gateToolArg !== undefined ? { toolArg: gateToolArg } : {}),
+        });
     }
     if (resume !== undefined && resume.outcome.gate === "plan_review" && resume.outcome.decision === "reject") {
         prepared.planModeRef.active = true;