@sema-agent/core 5.64.0 → 6.0.0

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

@@ -6,6 +6,7 @@ const PROMPT_HASH_SALT = randomBytes(16);
 import { sanitizeCompactionSettings } from "../auto-compaction.js";
 import { projectStaleToolResults, resolveStaleToolResultOffload } from "./compaction-call-options.js";
 import { createAutoModeDecider } from "../auto-mode.js";
+import { autoModeArmingRecipeOf } from "../auto-mode-arming.js";
 import { buildAutoModePrompt, renderAutoModeAction, renderAutoModeWindow } from "../auto-mode-prompt.js";
 import { resolveTaskModel } from "../roles.js";
 import { primaryActivityArg } from "../arg-summary.js";
@@ -20,7 +21,7 @@ import { createSubagentWorktreeHelper, forkGovernanceDenial, resolveDelegationEn
 import { createAgentTranscriptTool, AGENT_TRANSCRIPT_TOOL_NAME } from "../../agents/agent-transcript-tool.js";
 import { createSendMessageTool, SEND_MESSAGE_TOOL_NAME } from "../../agents/send-message-tool.js";
 import { SubagentRetainLedger } from "../../agents/retain-ledger.js";
-import { askApproverIdentity, carriesBidiControls, checkToolPolicyProjection, combinePolicies, constraintChainDigest, constraintChainEntryOf, isApprovalSettledBy, isAskDenyResolution, screenApproverAttribution, createTranscriptIntegrityPolicy, createUnverifiableDeletePolicy, describeThrown, refuseOutOfContractDecision, resolveAsk, toolPolicyNameSets, tryCloneArgs } from "../tool-policy.js";
+import { askApproverIdentity, carriesBidiControls, checkToolPolicyProjection, combinePolicies, constraintChainDigest, constraintChainEntryOfLayer, isApprovalSettledBy, isAskDenyResolution, screenApproverAttribution, createTranscriptIntegrityPolicy, createUnverifiableDeletePolicy, describeThrown, refuseOutOfContractDecision, resolveAsk, toolPolicyNameSets, tryCloneArgs } from "../tool-policy.js";
 const PERSISTED_RULE_TOOL = "Bash";
 import { findAdmittingRule, segmentCoverageOf, suggestRulesForCommand } from "../permission-rule-model.js";
 import { ActiveSkillScope, createActiveSkillScopePolicy } from "./active-skill-scope.js";
@@ -49,7 +50,6 @@ import { TOOL_SEARCH_NAME, buildDeferredRegistry, classifyDeferred, extractDisco
 import { createSharedMemoryTools } from "../shared-memory/tools.js";
 import { SHARED_MEMORY_TOOL_NAMES } from "../shared-memory/types.js";
 import { MEMORY_ENGINE_TOOL_NAMES } from "../memory-engine/tools.js";
-import { memoryRecallDisciplineSegment } from "../memory-engine/engine.js";
 import { classifyToolContentOrigin, contentOriginPollutes, delegationCallIsExternal } from "../memory-engine/content-origin.js";
 import { narrowContentSafety, readCardAttestation } from "../memory-engine/delegation-provenance.js";
 import { recordSyncUnattestable, sessionSettlements } from "../memory-engine/delegation-settlement.js";
@@ -97,6 +97,7 @@ import { countElicitOptIns, deriveWiringManifest, resolveAskSeamForm, resolveDec
 import { durableParkGapFor } from "../park-selfcheck.js";
 import { GLOBAL_USAGE_KEY, usageRetryAfterMs, windowsGovernCost } from "../usage-window-store.js";
 import { deliverEngineNotice } from "../types.js";
+import { resolveTrackKey } from "../file-history-store.js";
 let announcedMaterializeEnvBySink = new WeakMap();
 const announcedMaterializeEnvConsole = new Set();
 function materializeEnvLedger(onNotice) {
@@ -218,6 +219,7 @@ function announceDeclaredMcpContentClasses(args) {
                 toolCount,
                 ...(declaredClass === "execution" ? { execIsExternalContent: args.execIsExternalContent } : {}),
                 sessionId: args.sessionId,
+                runId: args.runId,
             },
         });
     }
@@ -324,7 +326,7 @@ class ParkRefusal extends Error {
 export { resolveCheckpointStore } from "../checkpoint-store.js";
 export { isFableFamilyModelId, resolveAttachmentsConfig, resolveModelPromptTraits, resolveTaskLimits } from "./prepare-config-doors.js";
 export { rebaseWorkspacePath, rebaseWorkspacePathAcross } from "./prepare-workspace-restore.js";
-function buildMicroCompactState(deps, model, sessionId, offloadStore, knob) {
+function buildMicroCompactState(deps, model, sessionId, runId, offloadStore, knob) {
     const triggerWindow = resolveTriggerWindow(model);
     if (triggerWindow.clamped) {
         deliverEngineNotice(deps.onNotice, {
@@ -337,6 +339,7 @@ function buildMicroCompactState(deps, model, sessionId, offloadStore, knob) {
                 declaredAutoCompactTokens: triggerWindow.declaredAutoCompactTokens,
                 physicalWindow: triggerWindow.physicalWindow,
                 sessionId,
+                runId,
             },
         });
     }
@@ -433,6 +436,187 @@ export async function runGuardChain(args) {
     const t = applyGuardTrim(working, anchoredWorking);
     return { working, trimmed: t.trimmed, trimDroppedMessages: t.dropped };
 }
+function restoredAbsPathsOf(restored, root) {
+    const out = [];
+    for (const key of [...restored.filesChanged, ...restored.failed.map((f) => f.path)]) {
+        const abs = resolveTrackKey(root, key);
+        if (abs.ok)
+            out.push(abs.abs);
+    }
+    return out;
+}
+function resolveWiredFileHistoryStore(candidate) {
+    if (candidate === undefined)
+        return undefined;
+    const verbs = ["trackEdit", "annulTrack", "snapshot", "restore", "canRestore", "reap", "adoptScope"];
+    const verbOf = (v) => {
+        try {
+            return candidate[v];
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const probeable = (typeof candidate === "object" && candidate !== null) || typeof candidate === "function";
+    const missing = probeable ? verbs.filter((v) => typeof verbOf(v) !== "function") : [...verbs];
+    if (missing.length > 0) {
+        const shape = candidate === null ? "null" : probeable ? "a value that is not a FileHistoryStore" : `a ${typeof candidate}`;
+        const e = new Error(`RunnerDeps.fileHistoryStore was wired with ${shape} — missing contract verbs: ${missing.join(", ")}. Refusing prepare rather than half-wiring the rewind seat (a present-but-unusable store makes every Edit/Write/NotebookEdit fail its first-touch backup while restore requests report "no store wired"). Omit the key to run without file history.`);
+        e.code = "config.invalid_file_history_store";
+        throw e;
+    }
+    return candidate;
+}
+const LEGACY_PROBE_TIMEOUT_MS = 2_000;
+const LEGACY_PROBE_TIMED_OUT = Symbol("legacy-rewind-probe-timeout");
+async function legacyRewindEpochTail(deps, sessionId, entryId, form) {
+    const probe = deps.legacyRewindBoundaryProbe;
+    let verdict;
+    if (probe !== undefined) {
+        try {
+            let timer;
+            const timeout = new Promise((resolve) => {
+                timer = setTimeout(() => resolve(LEGACY_PROBE_TIMED_OUT), LEGACY_PROBE_TIMEOUT_MS);
+            });
+            try {
+                verdict = await Promise.race([Promise.resolve(probe({ sessionId, entryId })), timeout]);
+            }
+            finally {
+                clearTimeout(timer);
+            }
+            if (verdict === LEGACY_PROBE_TIMED_OUT) {
+                verdict = undefined;
+                try {
+                    deps.onError?.(new Error(`RunnerDeps.legacyRewindBoundaryProbe did not answer within ${LEGACY_PROBE_TIMEOUT_MS}ms while explaining a rewind refusal — the refusal stands and names both possibilities`), { phase: "rewind", sessionId });
+                }
+                catch {
+                }
+            }
+        }
+        catch (err) {
+            verdict = undefined;
+            try {
+                deps.onError?.(new Error(`RunnerDeps.legacyRewindBoundaryProbe threw while explaining a rewind refusal (${err.message}) — the refusal stands and names both possibilities`), { phase: "rewind", sessionId });
+            }
+            catch {
+            }
+        }
+        if (verdict !== undefined && typeof verdict !== "boolean") {
+            try {
+                deps.onError?.(new Error(`RunnerDeps.legacyRewindBoundaryProbe answered ${JSON.stringify(String(verdict))} for entry "${entryId}" — only true/false/undefined are meaningful, so the refusal names both possibilities instead of trusting it`), { phase: "rewind", sessionId });
+            }
+            catch {
+            }
+            verdict = undefined;
+        }
+    }
+    if (verdict === true) {
+        return `This deployment's legacy-epoch probe reports that entry "${entryId}" DOES carry a boundary from the retired whole-tree snapshot era, which this engine's per-edited-file seat does not restore — the two epochs are not interchangeable (a whole-tree manifest carries no tracked-set provenance, so replaying it here would converge files this session never edited). Restore it with the whole-tree-era tooling this deployment kept, or re-run the turns under the current engine.`;
+    }
+    if (verdict === false) {
+        return `This deployment's legacy-epoch probe reports no whole-tree-era boundary for entry "${entryId}" either, so the boundary simply does not exist: its turns ran without a RunnerDeps.fileHistoryStore wired, or it was reaped.`;
+    }
+    return form === "keyed"
+        ? `Boundaries are keyed by a turn's INITIAL entry and exist only for turns that ran with a RunnerDeps.fileHistoryStore wired; a boundary from the retired whole-tree snapshot era is not restorable by this seat, and reaped boundaries have none.`
+        : `Either the boundary does not exist (its turns ran without a RunnerDeps.fileHistoryStore, or it was reaped), or it was produced in the retired whole-tree snapshot era, which this engine's per-edited-file seat does not restore.`;
+}
+const FILE_HISTORY_BOUNDARY_TIMEOUT_MS = 30_000;
+const FILE_HISTORY_CARRY_MEMO = new WeakMap();
+async function adoptForkedFileHistory(store, session, sessionId, onError) {
+    const memo = FILE_HISTORY_CARRY_MEMO.get(store) ?? { settled: new Set(), disclosed: new Set(), inFlight: new Map() };
+    FILE_HISTORY_CARRY_MEMO.set(store, memo);
+    const discloseOnce = (err) => {
+        if (memo.disclosed.has(sessionId))
+            return;
+        memo.disclosed.add(sessionId);
+        onError?.(err, { phase: "rewind", sessionId });
+    };
+    try {
+        if (memo.settled.has(sessionId))
+            return;
+        const forkedFrom = (await session.getMetadata()).forkedFrom;
+        if (forkedFrom === undefined || forkedFrom === sessionId)
+            return;
+        const shared = memo.inFlight.get(sessionId);
+        if (shared !== undefined)
+            return await shared;
+        if (memo.settled.has(sessionId))
+            return;
+        const attempt = store.adoptScope(forkedFrom, sessionId).then((carried) => {
+            if (carried.ok || carried.error.code === "conflict") {
+                memo.settled.add(sessionId);
+                return;
+            }
+            discloseOnce(new Error(`file-history fork carry from session "${forkedFrom}" failed (${carried.error.code}): ${carried.error.message} — this forked session starts with an EMPTY rewind history, so boundaries recorded before the fork are not restorable from it (the run itself proceeds; the carry is retried on this session's next turn while its scope is still empty)`));
+        }, (err) => discloseOnce(err));
+        memo.inFlight.set(sessionId, attempt);
+        try {
+            await attempt;
+        }
+        finally {
+            memo.inFlight.delete(sessionId);
+        }
+    }
+    catch (err) {
+        try {
+            discloseOnce(err);
+        }
+        catch {
+        }
+    }
+}
+function createFileHistoryBoundarySeat(opts) {
+    let inFlight;
+    let begun = false;
+    return {
+        begin(entryId) {
+            if (begun)
+                return;
+            begun = true;
+            const ac = new AbortController();
+            let timer;
+            const timeout = new Promise((resolve) => {
+                timer = setTimeout(() => {
+                    ac.abort();
+                    resolve({ ok: false });
+                }, FILE_HISTORY_BOUNDARY_TIMEOUT_MS);
+            });
+            let work;
+            try {
+                work = opts.store.snapshot(opts.sessionId, entryId, opts.env, opts.root, ac.signal);
+            }
+            catch (err) {
+                work = Promise.resolve({ ok: false, error: { code: "snapshot_failed", message: `history store threw synchronously: ${err.message}` } });
+            }
+            work.catch(() => { });
+            inFlight = Promise.race([
+                work.then((r) => (r.ok ? undefined : `boundary capture failed (${r.error.code}): ${r.error.message}`)),
+                timeout.then(() => `boundary capture timed out after ${FILE_HISTORY_BOUNDARY_TIMEOUT_MS / 1000}s (fenced — the attempt can never publish)`),
+            ])
+                .then((failure) => {
+                if (failure !== undefined) {
+                    try {
+                        opts.onError?.(new Error(`file-history ${failure} — this turn has no boundary and cannot be rewound to (the turn itself proceeds)`), { phase: "rewind", sessionId: opts.sessionId });
+                    }
+                    catch {
+                    }
+                }
+            })
+                .catch((err) => {
+                try {
+                    opts.onError?.(err, { phase: "rewind", sessionId: opts.sessionId });
+                }
+                catch {
+                }
+            })
+                .finally(() => clearTimeout(timer));
+        },
+        async settle() {
+            if (inFlight !== undefined)
+                await inFlight;
+        },
+    };
+}
 export function gatedCallIdOf(p) {
     if (p.suspendRef.token !== undefined)
         return p.suspendRef.gatedCallId;
@@ -508,7 +692,7 @@ function createDenyObserverNotifier(hooks, hookTimeoutMs, signal, report) {
         }
     };
 }
-function mcpRevocationWiring(deps) {
+function mcpRevocationWiring(deps, runId) {
     if (deps.mcpRevocations === undefined)
         return undefined;
     const ledger = deps.mcpRevocations;
@@ -517,7 +701,7 @@ function mcpRevocationWiring(deps) {
         onProbeFailure: (e) => deliverEngineNotice(deps.onNotice, {
             code: "mcp.revocation_probe_failed",
             message: `the mcpRevocations.isRevoked probe threw — MCP dispatch fails OPEN (no server treated as revoked) until the probe recovers: ${e instanceof Error ? e.message : String(e)}`,
-            detail: { message: e instanceof Error ? e.message : String(e) },
+            detail: { message: e instanceof Error ? e.message : String(e), runId },
         }),
     };
 }
@@ -674,43 +858,69 @@ async function derivedRouteFallsBack(args) {
         const verdict = await adjudicateDerivedRoute({ brain: args.brain, model: args.derived, getApiKeyAndHeaders: args.getApiKeyAndHeaders });
         if (verdict === undefined || verdict.ok)
             return false;
-        deliverEngineNotice(args.onNotice, fallbackToPrimaryNotice({ seat: args.seat, from: args.derived.id, to: args.primary.id, verdict, ...(args.sessionId !== undefined ? { sessionId: args.sessionId } : {}) }));
+        deliverEngineNotice(args.onNotice, fallbackToPrimaryNotice({ seat: args.seat, from: args.derived.id, to: args.primary.id, verdict, ...(args.sessionId !== undefined ? { sessionId: args.sessionId } : {}), ...(args.runId !== undefined ? { runId: args.runId } : {}) }));
         return true;
     }
     catch {
         return false;
     }
 }
-function mintPlacementRootSessionId(internals, sessionId) {
-    const placementRootSessionId = internals?.placementRoot ?? internals?.rootSessionId ?? sessionId;
-    if (placementRootSessionId === "") {
+function mintPlacementRootSessionId(placementRootResolved) {
+    if (placementRootResolved === "") {
         const e = new Error("placement root resolved EMPTY (internals.placementRoot / internals.rootSessionId carries an empty string) — an empty fixed point cannot key a placement lookup; fix the spawning lane instead of defaulting around it.");
         e.code = "config.placement_root_invalid";
         throw e;
     }
-    return placementRootSessionId;
+    return placementRootResolved;
+}
+function restorePlacementRoot(internals, seedPlacementRoot) {
+    if (internals?.placementRoot !== undefined)
+        return internals;
+    const seed = placementValueOrAbsent(seedPlacementRoot);
+    if (seed === undefined)
+        return internals;
+    return { ...(internals ?? {}), placementRoot: seed };
+}
+export function placementValueOrAbsent(value) {
+    return value || undefined;
+}
+function stampPlacementRootSessionId(placementRootResolved) {
+    return placementValueOrAbsent(placementRootResolved);
+}
+function explicitlyDeferredMemoryTrio(mounted, roster, deferNames) {
+    return mounted ? MEMORY_ENGINE_TOOL_NAMES.filter((n) => roster.some((t) => t.name === n) && (deferNames ?? []).includes(n)) : [];
+}
+function memoryGroupRetractionSet(builtinDeferPairNames, engineTrioInPlay) {
+    return new Set([...builtinDeferPairNames, ...(engineTrioInPlay ? MEMORY_ENGINE_TOOL_NAMES : [])]);
+}
+function refuseRequireExistingWithoutSession(spec) {
+    if (spec.requireExistingSession && !spec.sessionId) {
+        const e = new Error(`requireExistingSession requires a sessionId — cannot require an existing session without one (design/114 Phase3)`);
+        e.code = "resume.session_not_found";
+        throw e;
+    }
 }
-export async function prepareTask(spec, deps, sessions, resume, internals, runnerSelf) {
+export async function prepareTask(spec, deps, sessions, resume, internals, runnerSelf, runIdSink) {
+    const runId = uuidv7();
+    if (runIdSink !== undefined)
+        runIdSink.runId = runId;
     const doors = prepareConfigDoors({ spec, deps, sessions, resume, internals });
     spec = doors.spec;
-    const { toolFaceSnapshot, promptProfile, lockedPreflight, resolvedInteractionPosture, microCompactKnob, resolvedRole, model, thinking, compModel, fableMitigations, memoryDelegationEvidence, memoryProvenance, usageWindows, brainCallGuardrailRef, brainCallGuardrailMs } = doors;
+    const { toolFaceSnapshot, promptProfile, lockedPreflight, resolvedInteractionPosture, microCompactKnob, resolvedRole, model, thinking, compModel, fableMitigations, memoryDelegationEvidence, memoryProvenance, memoryCapturePolicy, usageWindows, brainCallGuardrailRef, brainCallGuardrailMs } = doors;
     announceToolModelGate(deps.onNotice, model.id, doors.modelGate);
     const { toolEffects, egressTools, irreversibleTools, irreversibilityTier, axisExplicitNegatives, reversibilityProbes, ownToolNames } = prepareSafetyScan({ spec, deps });
     let shellGatedBash = false;
     let shellGatedMonitor = false;
-    if (spec.requireExistingSession && !spec.sessionId) {
-        const e = new Error(`requireExistingSession requires a sessionId — cannot require an existing session without one (design/114 Phase3)`);
-        e.code = "resume.session_not_found";
-        throw e;
-    }
+    refuseRequireExistingWithoutSession(spec);
     const { acquired, session, conflictRef, wakeRecovered, resumeAtBeforeParentId } = await prepareAcquireReconcile({ sessions, spec, resume, toolEffects, ...(internals?.sessionPlacement !== undefined ? { placement: internals.sessionPlacement } : {}), ...(() => { const g = durableParkGapFor(deps, spec); return g !== undefined ? { durableParkGap: g } : {}; })() });
     const sessionId = acquired.sessionId;
     const hostTaskId = spec.taskId ?? sessionId;
     const delegation = effectiveDelegationFacts(internals, resume?.seed.isDelegatedChild);
+    const placementRootResolved = (internals = restorePlacementRoot(internals, resume?.seed.placementRootSessionId))?.placementRoot ?? internals?.rootSessionId ?? sessionId;
     let effectiveCompModel = compModel;
     if (spec.compactionModel === undefined &&
         compModel !== undefined &&
-        (await derivedRouteFallsBack({ seat: "compaction-summary", derived: compModel, primary: model, brain: deps.brain, getApiKeyAndHeaders: spec.getApiKeyAndHeaders, onNotice: deps.onNotice, sessionId }))) {
+        (await derivedRouteFallsBack({ seat: "compaction-summary", derived: compModel, primary: model, brain: deps.brain, getApiKeyAndHeaders: spec.getApiKeyAndHeaders, onNotice: deps.onNotice, sessionId, runId }))) {
         effectiveCompModel = undefined;
     }
     warnCompactionWindowHazard(deps.tracer, spec, model, effectiveCompModel, hostTaskId);
@@ -798,7 +1008,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
     try {
         ownedEnv = deps.executionEnvFactory
             ? await deps.executionEnvFactory({
-                sessionId, placementRootSessionId: mintPlacementRootSessionId(internals, sessionId),
+                sessionId, placementRootSessionId: mintPlacementRootSessionId(placementRootResolved),
                 taskId: spec.taskId,
                 ...(internals?.isolation ? { isolation: internals.isolation } : {}),
                 ...(internals?.parentCwd ? { parentCwd: internals.parentCwd } : {}),
@@ -812,6 +1022,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         throw factoryErr;
     }
     const executionEnv = ownedEnv ?? deps.executionEnv ?? new StubExecutionEnv();
+    const externalContentTargetActive = executionEnv.externalContentTarget === true || resume?.seed.externalContentTarget === true;
     if (internals?.requestedCwd !== undefined) {
         const canon = async (p) => {
             const r = await executionEnv.canonicalPath(p);
@@ -889,79 +1100,165 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         }
         const { taskRootFinal, rebaseRestoredPath } = await prepareWorkspaceRestore({ ownedEnv, deps, spec, internals, resume, taskRootInitial, abortController, sessionId });
         const rewindNotes = [];
-        const rewindCaptureRequested = spec.rewindFiles === true;
+        const onTrackFailure = deps.onTrackFailure === undefined ? "refuse" : deps.onTrackFailure;
+        if (onTrackFailure !== "refuse" && onTrackFailure !== "proceed-unprotected") {
+            const e = new Error(`RunnerDeps.onTrackFailure must be "refuse" or "proceed-unprotected"; got ${JSON.stringify(deps.onTrackFailure)} — refusing prepare rather than silently defaulting a first-touch-failure policy.`);
+            e.code = "config.invalid_on_track_failure";
+            throw e;
+        }
+        const fileHistoryStore = resolveWiredFileHistoryStore(deps.fileHistoryStore);
+        if (fileHistoryStore !== undefined) {
+            await adoptForkedFileHistory(fileHistoryStore, session, sessionId, deps.onError);
+        }
+        const legacyRewindFiles = spec.rewindFiles;
+        if (legacyRewindFiles === true) {
+            if (spec.resumeAt !== undefined) {
+                const e = new Error(`rewind-files: TaskSpec.rewindFiles is retired (design/381 — rewind now converges the per-edited-file history, not a whole-tree snapshot). This request pairs it with resumeAt, i.e. the RESTORE sense: set restoreFiles: true instead. (The capture sense needs no request anymore — first-touch tracking is always on when a RunnerDeps.fileHistoryStore is wired.)`);
+                e.code = "rewind.rewind_files_retired";
+                throw e;
+            }
+            try {
+                deps.onError?.(new Error(`TaskSpec.rewindFiles (capture sense) is retired and was ignored: per-edited-file first-touch tracking is always on when RunnerDeps.fileHistoryStore is wired, so a per-turn capture request has nothing left to ask for. Drop the field; the restore sense moved to TaskSpec.restoreFiles.`), { phase: "config", sessionId });
+            }
+            catch {
+            }
+        }
+        if (spec.restoreFiles === true && spec.resumeAt === undefined) {
+            const e = new Error(`rewind-files: restoreFiles: true needs a resumeAt anchor — restoring files means converging them to a specific prior entry's boundary, and this spec names none. Use resumeAt + restoreFiles to move conversation and files together, or rewindFilesTo alone for a code-only restore.`);
+            e.code = "rewind.invalid_spec";
+            throw e;
+        }
         if (spec.resumeAt !== undefined && spec.rewindFilesTo !== undefined) {
-            const e = new Error(`rewind-files: resumeAt ("${spec.resumeAt}") and rewindFilesTo ("${spec.rewindFilesTo}") were both set — resumeAt already anchors the file restore when rewindFiles is true, so a separate rewindFilesTo target is a conflicting request. Drop one of the two.`);
+            const e = new Error(`rewind-files: resumeAt ("${spec.resumeAt}") and rewindFilesTo ("${spec.rewindFilesTo}") were both set — resumeAt already anchors the file restore when restoreFiles is true, so a separate rewindFilesTo target is a conflicting request. Drop one of the two.`);
             e.code = "rewind.conflicting_targets";
             throw e;
         }
-        let rewindTarget = spec.resumeAt !== undefined ? (rewindCaptureRequested ? spec.resumeAt : undefined) : spec.rewindFilesTo;
+        let rewindTarget = spec.resumeAt !== undefined ? (spec.restoreFiles === true ? spec.resumeAt : undefined) : spec.rewindFilesTo;
         const rewindBefore = rewindTarget !== undefined && spec.resumeAt !== undefined && spec.resumeAtMode === "before";
-        if (spec.resumeAt !== undefined && !rewindCaptureRequested) {
+        if (spec.resumeAt !== undefined && spec.restoreFiles !== true) {
             rewindNotes.push({
                 code: "conversation_only",
-                message: `the conversation was branched at entry "${spec.resumeAt}" but the working tree was NOT rewound — this task set resumeAt without rewindFiles, so files remain at their current state`,
+                message: `the conversation was branched at entry "${spec.resumeAt}" but the working tree was NOT rewound — this task set resumeAt without restoreFiles, so files remain at their current state`,
             });
         }
-        if (!deps.fileSnapshotStore) {
+        const fileHistoryEnabled = fileHistoryStore !== undefined && handsEnabled;
+        let historyRoot = taskRootFinal;
+        if (fileHistoryEnabled) {
+            const canonRoot = await executionEnv.canonicalPath(taskRootFinal);
+            if (canonRoot.ok)
+                historyRoot = canonRoot.value;
+        }
+        if (fileHistoryStore === undefined) {
             if (rewindTarget !== undefined) {
-                const e = new Error(`rewind-files: restoring the working tree to entry "${rewindTarget}" requires a snapshot backend, but this deployment wired no RunnerDeps.fileSnapshotStore — no snapshot was ever captured, so the files were NOT rewound`);
+                const e = new Error(`rewind-files: restoring files to entry "${rewindTarget}" requires a history backend, but this deployment wired no RunnerDeps.fileHistoryStore — no file history was ever recorded, so the files were NOT rewound`);
                 e.code = "rewind.store_unconfigured";
                 throw e;
             }
-            if (rewindCaptureRequested) {
-                rewindNotes.push({
-                    code: "snapshot_store_unconfigured",
-                    message: "rewindFiles was requested but no RunnerDeps.fileSnapshotStore is wired — no working-tree snapshot was captured for this turn, so it cannot be rewound to later",
-                });
-            }
         }
         else if (!handsEnabled) {
-            if (rewindTarget !== undefined || rewindCaptureRequested) {
+            if (rewindTarget !== undefined) {
                 rewindNotes.push({
                     code: "files_env_unsupported",
-                    message: "the file side of rewind was inert: this deployment mounts no filesystem-capable ExecutionEnv, so no working-tree snapshot was captured or restored",
+                    message: "the file side of rewind was inert: this deployment mounts no filesystem-capable ExecutionEnv, so no file history was recorded or restored",
                 });
             }
         }
-        if (rewindTarget !== undefined && deps.fileSnapshotStore && handsEnabled) {
+        const legacyEpochTail = (entryId, form = "at-or-above") => legacyRewindEpochTail(deps, sessionId, entryId, form);
+        let restoredFilePaths = [];
+        if (rewindTarget !== undefined && fileHistoryStore !== undefined && handsEnabled) {
+            const historyStore = fileHistoryStore;
             if (rewindBefore) {
                 let anchor;
-                const walked = new Set();
-                let cursor = resumeAtBeforeParentId;
-                while (cursor !== null && !walked.has(cursor)) {
-                    walked.add(cursor);
-                    if (await deps.fileSnapshotStore.has(sessionId, cursor)) {
-                        anchor = cursor;
-                        break;
+                if (await historyStore.canRestore(sessionId, rewindTarget)) {
+                    anchor = rewindTarget;
+                }
+                else {
+                    const walked = new Set();
+                    let cursor = resumeAtBeforeParentId;
+                    while (cursor !== null && !walked.has(cursor)) {
+                        walked.add(cursor);
+                        if (await historyStore.canRestore(sessionId, cursor)) {
+                            anchor = cursor;
+                            break;
+                        }
+                        cursor = (await session.getEntry(cursor))?.parentId ?? null;
                     }
-                    cursor = (await session.getEntry(cursor))?.parentId ?? null;
                 }
                 if (anchor === undefined) {
-                    const e = new Error(`rewind-files: no file snapshot exists at or above the "before" branch point on session "${sessionId}" — cannot restore files consistent with the rewound context (earlier turns ran without rewindFiles, or their snapshots were reaped)`);
+                    const e = new Error(`rewind-files: no file-history boundary exists at or above the "before" branch point on session "${sessionId}" — cannot restore files consistent with the rewound context. ${await legacyEpochTail(rewindTarget)}`);
                     e.code = "rewind_snapshot.unresolvable";
                     throw e;
                 }
                 rewindTarget = anchor;
             }
-            const restoreRoot = taskRootFinal;
+            const restoreRoot = historyRoot;
             const restoreSignal = spec.signal ? AbortSignal.any([abortController.signal, spec.signal]) : abortController.signal;
-            const restored = await deps.fileSnapshotStore.restore(sessionId, rewindTarget, executionEnv, restoreRoot, restoreSignal);
-            if (!restored.ok) {
-                if (restored.error.code === "not_found") {
+            const restored = await historyStore.restore(sessionId, rewindTarget, executionEnv, restoreRoot, restoreSignal);
+            const ledgerLine = (r) => `applied ${r.filesChanged.length}, identical ${r.identicalSkipped.length}, refused ${r.refused.length}${r.refused.length > 0 ? ` (${r.refused.map((f) => `${f.path}: ${f.reason}`).join("; ")})` : ""}, failed ${r.failed.length}${r.failed.length > 0 ? ` (${r.failed.map((f) => `${f.path}: ${f.reason}`).join("; ")})` : ""}`;
+            if (restored.outcome === "failed") {
+                if (restored.error?.code === "not_found") {
                     const e = new Error(rewindBefore
-                        ? `rewind-files: the resolved "before" snapshot anchor "${rewindTarget}" disappeared before restore — files were NOT rewound`
-                        : `rewind-files: no file snapshot exists for entry "${rewindTarget}" on session "${sessionId}" — the working tree was NOT rewound (only a COMPLETED turn that ran with rewindFiles is snapshotted, and snapshots are keyed by that turn's END leaf; earlier turns that ran without rewindFiles, mid-turn entries, and reaped snapshots have none)`);
+                        ? `rewind-files: the resolved "before" history anchor "${rewindTarget}" disappeared before restore — files were NOT rewound`
+                        : `rewind-files: no file-history boundary exists for entry "${rewindTarget}" on session "${sessionId}" — the working tree was NOT rewound. ${await legacyEpochTail(rewindTarget, "keyed")}`);
                     e.code = "rewind_snapshot.unresolvable";
                     throw e;
                 }
+                const e = new Error(`rewind-files restore failed (${restored.error?.code ?? "restore_failed"}): ${restored.error?.message ?? "unknown"} — ledger: ${ledgerLine(restored)}`);
+                e.code = "rewind.restore_failed";
+                throw e;
+            }
+            if (restored.outcome === "partial") {
+                if (spec.acceptPartialRestore === true) {
+                    rewindNotes.push({
+                        code: "restore_partial",
+                        message: `file restore to entry "${rewindTarget}" was PARTIAL and was tolerated by acceptPartialRestore — ledger: ${ledgerLine(restored)}. Re-running the same restore converges (per-file idempotent).`,
+                    });
+                }
                 else {
-                    const e = new Error(`rewind-files restore failed (${restored.error.code}): ${restored.error.message}`);
+                    const e = new Error(`rewind-files: restore to entry "${rewindTarget}" was PARTIAL — ledger: ${ledgerLine(restored)}. The task is refused rather than run on a mixed-state tree (set acceptPartialRestore: true to tolerate and disclose instead); re-running the same restore converges (per-file idempotent).`);
                     e.code = "rewind.restore_failed";
                     throw e;
                 }
             }
+            restoredFilePaths = restoredAbsPathsOf(restored, restoreRoot);
         }
+        const trackFileEdit = fileHistoryEnabled
+            ? async (req) => {
+                const r = await fileHistoryStore.trackEdit(sessionId, req.key, executionEnv, historyRoot, req.signal);
+                if (r.ok) {
+                    if (!r.minted)
+                        return { ok: true };
+                    return {
+                        ok: true,
+                        annul: async (proof) => {
+                            const a = await fileHistoryStore.annulTrack(sessionId, req.key, historyRoot, proof === "verify" ? { env: executionEnv, ...(req.signal !== undefined ? { signal: req.signal } : {}) } : undefined);
+                            if (a.ok)
+                                return;
+                            try {
+                                deps.onError?.(new Error(`file-history could not retract the first-touch record for "${req.key}" after its edit failed to land (${a.error.code}: ${a.error.message}) — the path stays tracked, so a rewind to a boundary below it may converge bytes this engine never wrote`), { phase: "rewind", sessionId });
+                            }
+                            catch {
+                            }
+                        },
+                    };
+                }
+                if (onTrackFailure === "proceed-unprotected") {
+                    try {
+                        deps.onError?.(new Error(`file-history first-touch backup for "${req.key}" failed (${r.error.code}: ${r.error.message}) — proceeding UNPROTECTED per RunnerDeps.onTrackFailure: the pristine promise for this path is void, and only in this process's memory (no durable trace exists, so after a process restart the next edit can still mint already-modified bytes as pristine v1)`), { phase: "rewind", sessionId });
+                    }
+                    catch {
+                    }
+                    return { ok: true };
+                }
+                return {
+                    ok: false,
+                    refusal: `Error (${req.tool}): the edit was refused because its first-touch file-history backup could not be persisted (${r.error.code}: ${r.error.message}). Proceeding would leave "${req.path}" with no durable pristine record — after the history store recovers, a retried edit would mint already-modified bytes as the pristine baseline. Retry when the file-history store is healthy.`,
+                };
+            }
+            : undefined;
+        const fileHistoryBoundary = fileHistoryEnabled
+            ? createFileHistoryBoundarySeat({ store: fileHistoryStore, sessionId, env: executionEnv, root: historyRoot, onError: deps.onError })
+            : undefined;
         const harnessRef = {};
         const skillScope = new ActiveSkillScope();
         const forwardSink = internals?.onForwardEvent;
@@ -1103,7 +1400,9 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                         ...(frozenOnAsk !== undefined ? { onAsk: frozenOnAsk } : {}),
                         ...(durableMandate ? { durableMandate: true } : {}),
                         ...(contentMandate ? { contentMandate: true } : {}),
-                        ...(autoModeDecider !== undefined ? { autoMode: { decider: autoModeDecider } } : {}),
+                        ...(autoModeDecider !== undefined
+                            ? { autoMode: { decider: autoModeDecider, ...(autoModeArming !== undefined ? { arming: autoModeArming } : {}) } }
+                            : {}),
                     },
                 ]
                 : [];
@@ -1117,7 +1416,9 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                             ...(frozenOnAsk !== undefined ? { onAsk: frozenOnAsk } : {}),
                             ...(durableMandate ? { durableMandate: true } : {}),
                             ...(contentMandate ? { contentMandate: true } : {}),
-                            ...(autoModeDecider !== undefined ? { autoMode: { decider: autoModeDecider } } : {}),
+                            ...(autoModeDecider !== undefined
+                                ? { autoMode: { decider: autoModeDecider, ...(autoModeArming !== undefined ? { arming: autoModeArming } : {}) } }
+                                : {}),
                         },
                     ]
                     : []),
@@ -1141,6 +1442,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             spec.handsReadOnly !== true &&
             !(toolFaceSnapshot.exclude?.includes("Bash") ?? false);
         let autoModeDecider;
+        let autoModeArming;
         const delegationEntryCapsResolved = resolveDelegationEntryCaps(deps.delegationEntryCaps);
         const enrichSpecToolCtx = (ctx) => ({
             ...ctx,
@@ -1166,6 +1468,19 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             ...(spec.additionalReadDirectories !== undefined ? { additionalReadDirectories: Object.freeze([...spec.additionalReadDirectories]) } : {}),
             ...(spec.envFacts !== undefined ? { envFacts: { ...spec.envFacts } } : {}),
             ...(spec.memoryPersistenceCapable !== undefined ? { memoryPersistenceCapable: spec.memoryPersistenceCapable } : {}),
+            get memoryCaptureOptedOut() {
+                return memoryEngineSession?.captureOptOut?.optedOut() === true;
+            },
+            get memoryCaptureIndeterminate() {
+                return memoryEngineSession?.captureOptOut?.indeterminate() === true;
+            },
+            get memoryCaptureControlDir() {
+                return memoryEngineSession?.engine.controlPlaneDir;
+            },
+            get memoryCaptureAncestors() {
+                const ctl = memoryEngineSession?.engine.controlPlaneDir;
+                return [...(internals?.memoryCaptureAncestors ?? []), { sessionId, ...(ctl !== undefined ? { controlDir: ctl } : {}) }];
+            },
             getApiKeyAndHeaders: spec.getApiKeyAndHeaders,
             parentCwd: taskRootFinal,
             reminderMark,
@@ -1244,6 +1559,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             }
         }
         let runtimeCaps;
+        let runtimeCapsFaulted = false;
         if (deps.runtimeCapsResolver) {
             try {
                 runtimeCaps = (await deps.runtimeCapsResolver(spec.principal)) ?? undefined;
@@ -1251,6 +1567,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             catch (err) {
                 deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "config", sessionId });
                 runtimeCaps = { allowWorkflows: false, allowFork: false };
+                runtimeCapsFaulted = true;
             }
         }
         let complianceDenies = new Set();
@@ -1297,7 +1614,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             catch {
                 classifierModel = model;
             }
-            if (await derivedRouteFallsBack({ seat: "auto-mode-classifier", derived: classifierModel, primary: model, brain: deps.brain, getApiKeyAndHeaders: spec.getApiKeyAndHeaders, onNotice: deps.onNotice, sessionId })) {
+            if (await derivedRouteFallsBack({ seat: "auto-mode-classifier", derived: classifierModel, primary: model, brain: deps.brain, getApiKeyAndHeaders: spec.getApiKeyAndHeaders, onNotice: deps.onNotice, sessionId, runId })) {
                 classifierModel = model;
             }
             const classifierSystemPrompt = buildAutoModePrompt(am);
@@ -1322,6 +1639,17 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                         .join("");
                 },
             });
+            if (am.persistArming === true) {
+                autoModeArming = autoModeArmingRecipeOf(am, {
+                    promptDigest: `apv1:${createHash("sha256").update(classifierSystemPrompt).digest("hex")}`,
+                });
+                if (autoModeArming === undefined) {
+                    deps.onError?.(new Error("RunnerDeps.autoMode.persistArming is set but the auto-mode face did not canonicalize into an arming recipe " +
+                        "(a rule list carrying a non-string, or a non-finite/out-of-range timeoutMs / failureThreshold / window bound) — " +
+                        "NO arming recipe is recorded on this run's parked constraint chain, and a cross-process redemption keeps the " +
+                        "conservative behavior (the ancestor classifier answers unavailable and the inherited ask flows to a human)"), { phase: "config", sessionId });
+                }
+            }
         }
         const deploymentWorkflowReady = runnerSelf !== undefined && isSelfOrchestrationActive(spec, deps);
         const selfOrchestrationActive = deploymentWorkflowReady && runtimeCaps?.allowWorkflows !== false;
@@ -1369,6 +1697,15 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 principal: spec.principal,
                 oneShot: spec.oneShot,
                 ...(resolvedInteractionPosture !== undefined ? { parentInteractionPosture: resolvedInteractionPosture } : {}),
+                parentMemoryCaptureState: () => {
+                    const ctl = memoryEngineSession?.engine.controlPlaneDir;
+                    return {
+                        optedOut: memoryEngineSession?.captureOptOut?.optedOut() === true,
+                        indeterminate: memoryEngineSession?.captureOptOut?.indeterminate() === true,
+                        ...(ctl !== undefined ? { controlDir: ctl } : {}),
+                        ancestors: [...(internals?.memoryCaptureAncestors ?? []), { sessionId, ...(ctl !== undefined ? { controlDir: ctl } : {}) }],
+                    };
+                },
                 autoModeReview: () => (autoModeDecider !== undefined ? { decider: autoModeDecider } : undefined),
                 workflowDepth: internals?.workflowDepth,
                 parentCwd: taskRootFinal,
@@ -1447,7 +1784,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             tools.push(createOutputTool(outputRef, spec.outputSchema, compiled.strict ? compiled.modelSchema : undefined));
         }
         mcp = lockedPreflight.mcp?.length
-            ? await materializeMcpTools(lockedPreflight.mcp, spec.principal, deps.onElicit, deps.mcpImageResizer, { reminderMark, counts: reminderDisclosureCounts }, mcpRevocationWiring(deps))
+            ? 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 () => { } };
         for (const w of mcp.warnings)
             deps.onError?.(w, { phase: "mcp", sessionId });
@@ -1603,9 +1940,9 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         foldProtocolAxes(a2a.toolAxes, "A2A");
         const callIssuedAtRef = {};
         const memoryWriteGateRef = {};
-        const handsReadFaceInput = { handsEnabled, executionEnv, taskRootFinal, rebaseRestoredPath, resume, session, sessionId, hostTaskId, taskScope, fullShellReachable, effectiveShellGate, toolFaceSnapshot, model, spec, deps, internals, memoryWriteGateRef, firstPartyOffload, tools, egressTools, irreversibilityTier, irreversibleTools, reversibilityProbes, reminderMark, reminderDisclosureCounts };
+        const handsReadFaceInput = { handsEnabled, executionEnv, taskRootFinal, rebaseRestoredPath, resume, session, sessionId, hostTaskId, taskScope, fullShellReachable, effectiveShellGate, toolFaceSnapshot, model, spec, deps, internals, memoryWriteGateRef, firstPartyOffload, tools, egressTools, irreversibilityTier, irreversibleTools, reversibilityProbes, reminderMark, reminderDisclosureCounts, ...(trackFileEdit !== undefined ? { trackFileEdit } : {}), ...(restoredFilePaths.length > 0 ? { restoredFilePaths } : {}) };
         const handsReadFace = handsEnabled ? await prepareHandsMount(handsReadFaceInput) : resolveHandsLessReadFace(handsReadFaceInput);
-        const { readFileStateForCheckpoint, seedContextFiles, handsCwdRef, workspaceStateSettle, wsSnapshot, rebaseWsPath, backgroundTaskToolsActive, additionalRootsCanonical, additionalReadRootsCanonical, attachmentRootCanonical, readDenyMatcher } = handsReadFace;
+        const { readFileStateForCheckpoint, seedContextFiles, handsCwdRef, workspaceStateSettle, wsSnapshot, rebaseWsPath, backgroundTaskToolsActive, additionalRootsCanonical, additionalReadRootsCanonical, attachmentRootCanonical, readDenyMatcher, envHandToolNames, sealReadStateSeat } = handsReadFace;
         resolvedReadFace = handsReadFace.resolvedReadFace;
         readDenyAdditionsNormalized = handsReadFace.readDenyAdditionsNormalized;
         handsLessResolvedFace = handsReadFace.handsLessResolvedFace;
@@ -1689,6 +2026,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         }
         if (backgroundTaskToolsActive) {
             toolEffects.set("Monitor", "write");
+            envHandToolNames.add("Monitor");
             tools.push(firstPartyOffload(createMonitorTool(executionEnv, {
                 registry: defaultTaskRegistry,
                 owner: hostTaskId,
@@ -1724,7 +2062,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             };
             if (workspaceStateSettle !== undefined)
                 workspaceStateSettle.restoredWorktreeDir = worktreeSessionRef.current?.worktreeDir;
-            tools.push(...createWorktreeTools(executionEnv, { repoRoot: taskRootFinal, cwdRef: handsCwdRef, session: worktreeSessionRef }).map((t) => firstPartyOffload(t)));
+            tools.push(...createWorktreeTools(executionEnv, { repoRoot: taskRootFinal, cwdRef: handsCwdRef, session: worktreeSessionRef }).map((t) => (envHandToolNames.add(t.name), firstPartyOffload(t))));
         }
         if (offloadStore)
             tools.push(createReadToolResultTool(offloadStore));
@@ -1809,7 +2147,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 ...(spec.principal !== undefined ? { principal: spec.principal } : {}),
                 ...(sessionId !== undefined ? { sessionId } : {}),
                 requestStopAfterTurn,
-            }));
+            }).map((t) => (envHandToolNames.add(t.name), t)));
         }
         if (internals?.insideFork !== true &&
             runnerSelf &&
@@ -1823,6 +2161,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         if (lspManager) {
             const lspRoot = taskRootFinal;
             tools.push(createLspTool(lspManager, { isPathIgnored: gitCheckIgnoreFilter(executionEnv, lspRoot), env: executionEnv }));
+            envHandToolNames.add("LSP");
         }
         const lspDiagnostics = spec.lspDiagnostics !== false && lspManager?.diagnostics !== undefined && handsEnabled && spec.handsReadOnly !== true
             ? lspManager.diagnostics
@@ -1848,7 +2187,16 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         const memoryPairExcludedName = MEMORY_ENGINE_TOOL_NAMES.find((n) => (toolFaceSnapshot.exclude ?? []).includes(n));
         const memoryPairOccupiedName = MEMORY_ENGINE_TOOL_NAMES.find((n) => memoryPairNameDomain.has(n));
         const memorySearchToolsPlanned = memoryPairExcludedName === undefined && memoryPairOccupiedName === undefined;
-        const { memoryEngineSession, memoryBlock: memoryBlockFromEngine, memoryTools, seedFiles: memorySeedFiles, admittedOrgScopes: memoryAdmittedOrgScopes, ownOrgVerdict: memoryOwnOrgVerdict, effectiveMemoryScopes: memoryEffectiveScopes, } = await prepareMemory({
+        const captureLineage = await (async () => {
+            try {
+                const ff = (await session.getMetadata()).forkedFrom;
+                return { ...(ff !== undefined && ff !== sessionId ? { origin: ff } : {}), fault: false };
+            }
+            catch {
+                return { fault: true };
+            }
+        })();
+        const { memoryEngineSession, memoryBlock: memoryBlockFromEngine, memoryTools, recallDisciplineSegment: memoryRecallSegment, seedFiles: memorySeedFiles, admittedOrgScopes: memoryAdmittedOrgScopes, ownOrgVerdict: memoryOwnOrgVerdict, effectiveMemoryScopes: memoryEffectiveScopes, } = await prepareMemory({
             spec,
             deps,
             sessionId,
@@ -1859,6 +2207,20 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 !(toolFaceSnapshot.exclude?.includes("Write") ?? false) &&
                 !(handsEnabled && isRemoteExecutionEnv(executionEnv) && spec.memoryPersistenceCapable !== true),
             memoryProvenance,
+            memoryCapturePolicy,
+            memoryCapturePolicyDeclared: deps.memoryCapturePolicy !== undefined,
+            captureEntitlement: {
+                value: typeof runtimeCaps?.allowMemoryOptOut === "boolean" ? runtimeCaps.allowMemoryOptOut : undefined,
+                faulted: runtimeCapsFaulted || (runtimeCaps?.allowMemoryOptOut !== undefined && typeof runtimeCaps.allowMemoryOptOut !== "boolean"),
+            },
+            captureCarrierUnsupported: isRemoteExecutionEnv(executionEnv) && deps.memoryCaptureRecordStore === undefined,
+            ...(internals?.parentSessionId !== undefined ? { parentSessionId: internals.parentSessionId } : {}),
+            captureFloor: internals?.memoryCaptureFloor === true,
+            ...(internals?.memoryCaptureFloorIndeterminate === true ? { captureFloorIndeterminate: true } : {}),
+            ...(captureLineage.origin !== undefined ? { captureForkOrigin: captureLineage.origin } : {}),
+            ...(captureLineage.fault ? { captureLineageFault: true } : {}),
+            ...(internals?.memoryCaptureQueryDir !== undefined ? { parentCaptureQueryDir: internals.memoryCaptureQueryDir } : {}),
+            ...(internals?.memoryCaptureAncestors !== undefined ? { captureAncestors: internals.memoryCaptureAncestors } : {}),
             memoryPersistenceDeclared: spec.memoryPersistenceCapable,
             rosterCanPersist: spec.memoryPersistenceCapable ??
                 tools.some((t) => {
@@ -1917,6 +2279,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             }
         }
         let instructionSources;
+        let projectInstructionContent;
         if (deps.loadProjectMemory) {
             let projectMemoryPhase = spec.sessionId ? "resume" : "fresh";
             if (spec.sessionId) {
@@ -1968,6 +2331,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 }
             }
             if (projectMem != null && projectMem.trim()) {
+                projectInstructionContent = projectMem;
                 const projectBlock = `${PROJECT_CONTEXT_FRAMING}\n\n${composeMemoryBlock(projectMem, "project")}`;
                 memoryBlock = memoryBlock ? `${memoryBlock}\n\n${projectBlock}` : projectBlock;
             }
@@ -2032,7 +2396,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 (memoryPairExcludedName !== undefined
                     ? `excludeTools removes "${memoryPairExcludedName}"`
                     : `this task already declares a tool named "${memoryPairOccupiedName}" (the built-in yields to it)`) +
-                " — the pair mounts together or not at all."), { phase: "config", sessionId, classification: "memory-tools-not-mounted" });
+                " — these tools mount together or not at all."), { phase: "config", sessionId, classification: "memory-tools-not-mounted" });
         }
         const skillsListing = skillSpecs.length > 0
             ? {
@@ -2098,6 +2462,8 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             envFacts.sandboxEgress = spec.envFacts.egress;
         if (spec.envFacts?.scratchpadDir)
             envFacts.scratchpadDir = spec.envFacts.scratchpadDir;
+        if (externalContentTargetActive)
+            envFacts.externalContentTarget = true;
         if (resume !== undefined && spec.envFacts?.resumeFacts) {
             const rf = spec.envFacts.resumeFacts;
             const copy = {};
@@ -2229,7 +2595,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             return deferredSet;
         };
         const sharedMemoryPair = sharedMemoryPairMounted ? SHARED_MEMORY_TOOL_NAMES.filter((n) => tools.some((t) => t.name === n)) : [];
-        const memoryEnginePair = memoryEnginePairMounted ? MEMORY_ENGINE_TOOL_NAMES.filter((n) => tools.some((t) => t.name === n)) : [];
+        const memoryEnginePair = explicitlyDeferredMemoryTrio(memoryEnginePairMounted, tools, toolFaceSnapshot.defer);
         const builtinDeferPairNames = [...sharedMemoryPair, ...memoryEnginePair];
         let deferred;
         if (builtinDeferPairNames.length > 0) {
@@ -2239,8 +2605,9 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             const soleCause = d0.size === 0 && d1.size > 0;
             const supportNameTaken = tools.some((t) => t.name === TOOL_SEARCH_NAME || (t.aliases ?? []).includes(TOOL_SEARCH_NAME));
             if (soleCause && supportNameTaken) {
+                const retractNames = memoryGroupRetractionSet(builtinDeferPairNames, memoryEnginePair.length > 0);
                 for (let i = tools.length - 1; i >= 0; i--) {
-                    if (builtinDeferPairNames.some((n) => n === tools[i].name))
+                    if (retractNames.has(tools[i].name))
                         tools.splice(i, 1);
                 }
                 if (sharedMemoryPair.length > 0) {
@@ -2250,8 +2617,8 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 }
                 if (memoryEnginePair.length > 0) {
                     memoryEnginePairMounted = false;
-                    if (memoryBlock !== undefined) {
-                        const segment = memoryRecallDisciplineSegment(memoryProvenance);
+                    if (memoryBlock !== undefined && memoryRecallSegment !== undefined) {
+                        const segment = memoryRecallSegment;
                         if (memoryBlock === segment)
                             memoryBlock = undefined;
                         else if (memoryBlock.includes(`\n\n${segment}`))
@@ -2260,7 +2627,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                             memoryBlock = memoryBlock.slice(segment.length + 2);
                     }
                     deps.onError?.(new Error(`Memory tools ${MEMORY_ENGINE_TOOL_NAMES.join("/")} were NOT mounted: mounting them would inject ` +
-                        `the "${TOOL_SEARCH_NAME}" tool, whose name this task already declares — the pair mounts together or not at all.`), { phase: "config", sessionId, classification: "memory-tools-not-mounted" });
+                        `the "${TOOL_SEARCH_NAME}" tool, whose name this task already declares — these tools mount together or not at all.`), { phase: "config", sessionId, classification: "memory-tools-not-mounted" });
                 }
                 deferred = d0;
             }
@@ -2278,13 +2645,14 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             let staticMarkWaiverAnnounced = false;
             const effectiveSafety = narrowContentSafety(delegationProvenanceChannel?.contentSafety, memoryEngineSession?.contentSafety);
             const trustedTools = effectiveSafety.trustedTools;
-            const execIsExternalContent = effectiveSafety.execIsExternalContent;
+            const execIsExternalContent = effectiveSafety.execIsExternalContent || externalContentTargetActive;
             provenanceForChildrenRef.current = { trustedTools: [...trustedTools], execIsExternalContent };
             announceDeclaredMcpContentClasses({
                 entries: lockedPreflight.mcp,
                 statuses: mcp?.statuses,
                 execIsExternalContent,
                 sessionId,
+                runId,
                 onNotice: deps.onNotice,
             });
             if (memoryEngineSession?.settlement !== undefined) {
@@ -2300,12 +2668,14 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             };
             const callerToolNames = new Set((spec.tools ?? []).map((t) => t.name));
             const contentOriginWrapped = new WeakSet();
-            const classOf = (t) => classifyToolContentOrigin({
-                declared: t.contentOrigin,
-                isProtocolTool: protocolOf(t.name) !== undefined,
-                isCallerTool: callerToolNames.has(t.name),
-                trusted: trustedTools.has(t.name),
-            });
+            const classOf = (t) => externalContentTargetActive && envHandToolNames.has(t.name)
+                ? "external"
+                : classifyToolContentOrigin({
+                    declared: t.contentOrigin,
+                    isProtocolTool: protocolOf(t.name) !== undefined,
+                    isCallerTool: callerToolNames.has(t.name),
+                    trusted: trustedTools.has(t.name),
+                });
             const delegationByName = new Map();
             for (const t of spec.tools ?? []) {
                 const withFaces = t;
@@ -2446,6 +2816,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                                                 reason: waivedReason,
                                                 ...(typeof requested === "string" ? { subagentType: inlineUntrusted(requested, 120) } : {}),
                                                 sessionId,
+                                                runId,
                                             },
                                         });
                                     }
@@ -2906,7 +3277,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 emitTrace(deps.tracer, () => ({
                     kind: "loop.recovery",
                     version: 1,
-                    taskId: spec.taskId ?? sessionId,
+                    taskId: hostTaskId,
                     reason: step.reason,
                     ts: Date.now(),
                 }));
@@ -3137,7 +3508,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             emitTrace(deps.tracer, () => ({
                 kind: "permission.sandbox_admitted",
                 version: 1,
-                taskId: spec.taskId ?? sessionId,
+                taskId: hostTaskId,
                 toolCallId: info.toolCallId,
                 toolName: info.toolName,
                 askClasses: info.askClasses.map((a) => a.cls),
@@ -3223,7 +3594,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                         emitTrace(deps.tracer, () => ({
                             kind: "permission.rule_store_unreadable",
                             version: 1,
-                            taskId: spec.taskId ?? sessionId,
+                            taskId: hostTaskId,
                             message: err instanceof Error ? err.message : String(err),
                             ts: Date.now(),
                         }));
@@ -3268,26 +3639,36 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 return {};
             if ((spec.principal === undefined || spec.principal === "") && deps.localOwnerRules !== true)
                 return {};
-            if (ask?.requiresRealApproval === true ||
-                ask?.persistedRuleShadowed !== undefined ||
-                ask?.decisionReason === "hook" ||
-                ask?.matchedAskRule !== undefined ||
-                ask?.inheritedUnresolved === true ||
-                ask?.ancestorResolved === true) {
-                return {};
-            }
+            const closedDoor = (() => {
+                if (ask?.requiresRealApproval === true)
+                    return "mandated";
+                if (ask?.persistedRuleShadowed !== undefined)
+                    return "shadowed";
+                if (ask?.decisionReason === "hook")
+                    return "mandated";
+                if (ask?.matchedAskRule !== undefined)
+                    return "shadowed";
+                if (ask?.inheritedUnresolved === true)
+                    return "mandated";
+                if (ask?.ancestorResolved === true)
+                    return "mandated";
+                return undefined;
+            })();
+            if (closedDoor !== undefined)
+                return { ruleOffersAbsence: closedDoor };
             if (persistedRuleMandateOf({
                 egress: egressTools.has(toolName),
                 irreversibility: irreversibilityTier.get(toolName),
                 shellGated: shellGatedBash,
+                probeMandated: ask?.probeMandated === true,
             }) !== undefined) {
-                return {};
+                return { ruleOffersAbsence: "mandated" };
             }
             const command = args?.command;
             if (typeof command !== "string")
-                return {};
+                return { ruleOffersAbsence: "lane_cannot_speak" };
             const offers = suggestRulesForCommand(command, ask?.segmentCoverage !== undefined ? { coverage: ask.segmentCoverage } : undefined);
-            return offers.length > 0 ? { ruleOffers: offers } : {};
+            return offers.length > 0 ? { ruleOffers: offers } : { ruleOffersAbsence: "lane_cannot_speak" };
         };
         const frozenClassifierExcluded = (d) => d.decisionReason === "hook" || d.matchedAskRule !== undefined;
         const recheckApprovedEdit = async (pol, onAskOf, creq, edit, csignal, ancestorDecider) => {
@@ -3724,7 +4105,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         const parkLaneArmed = wiringManifest.parkLane.effective === true;
         const hookIdentity = mintHookInvocationIdentity({
             sessionId,
-            taskId: spec.taskId ?? sessionId,
+            taskId: hostTaskId,
             legKind: wiringManifest.leg.kind,
             isDelegatedChild: delegation.isDelegatedChild,
             ...(internals?.insideFork === true ? { insideFork: true } : {}),
@@ -3733,6 +4114,12 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         });
         const hookContextConsumerWired = hooks?.preToolUse !== undefined || hooks?.postToolUse !== undefined || hooks?.postToolUseFailure !== undefined;
         const hookEnvFace = hookContextConsumerWired && (ownedEnv ?? deps.executionEnv) != null ? createHookEnvCapabilities(executionEnv) : undefined;
+        if (fileHistoryBoundary !== undefined) {
+            harness.on("tool_call", async () => {
+                await fileHistoryBoundary.settle();
+                return undefined;
+            });
+        }
         if (effectivePolicy || hooks?.preToolUse || egressTools.size > 0 || irreversibleTools.size > 0 || resourceSuspendEligible || platformSuspendArmed || spec.enablePlanMode === true) {
             const adjudicate = effectivePolicy
                 ? (req) => raceAbort(Promise.resolve(effectivePolicy.check({ ...req, budget: budgetSnapshot, ...(handsCwdRef !== undefined ? { cwd: handsCwdRef.current } : {}) }, abortController.signal)), abortController.signal, () => ({
@@ -3860,7 +4247,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                     const requiresParentConstraint = (inheritedParentConstraints?.length ?? 0) > 0 || seedInheritedGate?.requiresParentConstraint === true;
                     const parentConstraintCount = (inheritedParentConstraints?.length ?? 0) > 0 ? inheritedParentConstraints.length : seedInheritedGate?.parentConstraintCount;
                     const constraintChain = (inheritedParentConstraints?.length ?? 0) > 0
-                        ? inheritedParentConstraints.map((pc) => constraintChainEntryOf(pc.policy, { ...(pc.autoMode !== undefined ? { autoModeArmed: true } : {}), ...(pc.durableMandate === true ? { durableMandate: true } : {}), ...(pc.contentMandate === true ? { contentMandate: true } : {}) }))
+                        ? inheritedParentConstraints.map((pc) => constraintChainEntryOfLayer(pc))
                         : seedInheritedGate?.constraintChain;
                     const constraintDigest = (inheritedParentConstraints?.length ?? 0) > 0
                         ? constraintChainDigest(constraintChain)
@@ -3897,6 +4284,8 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 gitAnnouncement: gitStatusRef.announced !== undefined ? { ...gitStatusRef.announced } : undefined,
                 delegationProvenance: internals?.delegationProvenance !== undefined ? { ...internals.delegationProvenance.ref.current } : undefined,
                 isDelegatedChild: hookIdentity.isDelegatedChild ? true : undefined,
+                placementRootSessionId: stampPlacementRootSessionId(placementRootResolved),
+                externalContentTarget: externalContentTargetActive ? true : undefined,
             });
             const commitSuspendSaga = async (token, cp, remoteEnv, remoteHandle) => {
                 if (!checkpointStore)
@@ -4256,7 +4645,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 }
             };
             const suspendAsk = parkLaneArmed && checkpointStore !== undefined
-                ? async (req, postHookArgs, safety, liveFaceUnavailable, realApproval, shadowedRule, askDecisionReason, probeReason, probeCause, segmentCoverage, matchedAskRule) => {
+                ? async (req, postHookArgs, safety, liveFaceUnavailable, realApproval, shadowedRule, askDecisionReason, probeReason, probeCause, segmentCoverage, matchedAskRule, probeMandated) => {
                     const syncFirstEligible = req.toolName === ASK_USER_QUESTION_TOOL_NAME ? contentAskRoutable(req.toolCallId) : isLiveApproverSeat(onAsk);
                     if (syncFirstEligible &&
                         runtimeCaps?.forceDurableGate !== true &&
@@ -4427,6 +4816,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                                     ...(shadowedRule !== undefined ? { persistedRuleShadowed: shadowedRule } : {}),
                                     ...(askDecisionReason !== undefined ? { decisionReason: askDecisionReason } : {}),
                                     ...(matchedAskRule !== undefined ? { matchedAskRule } : {}),
+                                    ...(probeMandated === true ? { probeMandated: true } : {}),
                                     ...(inheritedUnavailableAsks.has(req.toolCallId) ? { inheritedUnresolved: true } : {}),
                                     ...(segmentCoverage !== undefined ? { segmentCoverage } : {}),
                                 }),
@@ -4526,7 +4916,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                     let humanBareRejection = false;
                     try {
                         result = await runToolGate({
-                            onNotifyError: (f) => emitTrace(deps.tracer, () => ({ kind: "observer.notify_failed", version: 1, taskId: spec.taskId ?? sessionId, site: f.site, message: f.error.message, ts: Date.now() })),
+                            onNotifyError: (f) => emitTrace(deps.tracer, () => ({ kind: "observer.notify_failed", version: 1, taskId: hostTaskId, site: f.site, message: f.error.message, ts: Date.now() })),
                             event: e,
                             identity: hookIdentity,
                             reminderMark,
@@ -4555,7 +4945,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                                         onResolved: (info) => emitTrace(deps.tracer, () => ({
                                             kind: "permission.persisted_rule_allowed",
                                             version: 2,
-                                            taskId: spec.taskId ?? sessionId,
+                                            taskId: hostTaskId,
                                             toolName: info.toolName,
                                             toolCallId: info.toolCallId,
                                             rules: [...info.rules],
@@ -4572,7 +4962,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                                         onUnavailable: (info) => emitTrace(deps.tracer, () => ({
                                             kind: "permission.org_snapshot_unavailable",
                                             version: 1,
-                                            taskId: spec.taskId ?? sessionId,
+                                            taskId: hostTaskId,
                                             toolName: info.toolName,
                                             toolCallId: info.toolCallId,
                                             message: info.message,
@@ -4694,7 +5084,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         }
         const editAt = editBudget(model);
         const guardAt = guardBudget(model);
-        const microCompact = buildMicroCompactState(deps, model, sessionId, offloadStore, microCompactKnob);
+        const microCompact = buildMicroCompactState(deps, model, sessionId, runId, offloadStore, microCompactKnob);
         const charsPerToken = model.charsPerToken ?? DEFAULT_CHARS_PER_TOKEN;
         harness.on("context", async ({ messages, recheck, signal }) => {
             batchHaltRef.current = undefined;
@@ -4709,7 +5099,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                     onCapped: (info) => pendingProjectionObservations.push(() => emitTrace(deps.tracer, () => ({
                         kind: "tool_result.capped",
                         version: 1,
-                        taskId: spec.taskId ?? sessionId,
+                        taskId: hostTaskId,
                         ...(info.tool !== undefined ? { tool: info.tool } : {}),
                         sizeChars: info.sizeChars,
                         storeFallback: info.storeFallback,
@@ -4746,11 +5136,11 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                         : {}),
                 });
                 if (ccPass !== undefined) {
-                    recordFrontierClears({ pass: ccPass, index: replay.index, edited, ledger: microCompact.ledger, tracer: deps.tracer, taskId: spec.taskId ?? sessionId, trigger: "frontier" });
+                    recordFrontierClears({ pass: ccPass, index: replay.index, edited, ledger: microCompact.ledger, tracer: deps.tracer, taskId: hostTaskId, trigger: "frontier" });
                 }
                 const chain = await runGuardChain({
                     edited, replayed, index: replay.index, microCompact, guardAt, charsPerToken, offloadStore,
-                    sessionId, taskId: spec.taskId ?? sessionId, deps, trimPressureRef, recheck, signal,
+                    sessionId, taskId: hostTaskId, deps, trimPressureRef, recheck, signal,
                     pendingProjectionObservations,
                 });
                 if ("earlyReturn" in chain) {
@@ -4985,7 +5375,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         const effectiveReadFaceObserved = carrierReadFace();
         const effectiveReadDenyObserved = readDenyAdditionsNormalized.length > 0 ? readDenyAdditionsNormalized.map((e) => ({ ...e })) : undefined;
         const preparedHolder = {};
-        const buildPrepared = () => ({ harness, session, sessionId, reminderMark, reminderDisclosureCounts, taskRootPath: taskRootFinal, model, thinking, compModel: effectiveCompModel, mcp: mcp, ...(a2a !== undefined && a2a.tools.length > 0 ? { a2a } : {}), blockedRef, outputRef, abortController, conflictRef, blockedToolCalls, approvalSettlement, batchHaltRef, nestedStats, ...(rewindNotes.length > 0 ? { rewindNotes } : {}), ...(effectiveReadFaceObserved !== undefined ? { effectiveReadFace: effectiveReadFaceObserved } : {}), ...(effectiveReadDenyObserved !== undefined ? { effectiveReadDenyPatterns: effectiveReadDenyObserved } : {}), effectiveMemoryScopes: memoryEffectiveScopes, cwdRef: handsCwdRef, ...(worktreeSessionRef !== undefined ? { worktreeSessionRef } : {}), ...(workspaceStateSettle !== undefined ? { workspaceStateSettle } : {}), denyNarrowingPolicy, ...(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, suspendRef, suspendProgressRef, reviewRef, remoteEnvFailures, reviewRequestRef, suspendLoopRef, suspendForResource, ...(suspendForPlatformLimit !== undefined ? { suspendForPlatformLimit } : {}), ...(envLifetimeSuspendAt !== undefined ? { envLifetimeSuspendAt } : {}), ...(usageGovernance !== undefined ? { usageGovernance } : {}), callIssuedAtRef, brainCallGuardrailRef, suspendForReview, resourceLedger: priorLedger, liveSpendRef, humanReviewRef, now, tools, toolEffects, wakeRecovered, promptOverheadTokens, lastBrainContext, readTaskFile, recentlyReadFiles, normalizeAttachmentPath, isDedupStubResult, ...(onCompactionApplied ? { onCompactionApplied } : {}), compactionReuseRef, trimPressureRef, microCompact, ...(memoryEngineSession ? { memoryEngineSession } : {}), ...(subagentRetain ? { subagentRetain } : {}), ...(lspDiagnostics && nudgeLspOnEdit ? { lspDiagnostics: { registry: lspDiagnostics, nudge: nudgeLspOnEdit, runIdent: lspRunIdent } } : {}), planModeRef, ...(dateChange ? { dateChange } : {}), ...(instructionSources ? { instructionSources } : {}), ...(workflowSizeGuideline ? { workflowSizeGuideline } : {}), ...(detectExternalChanges ? { detectExternalChanges } : {}), ...(toolsDeltaRef ? { toolsDeltaRef } : {}), ...(agentListing ? { agentListing } : {}), ...(skillsListing ? { skillsListing } : {}), announcedListingsRef, gitStatusRef, listBackgroundTasks, hookIdentity, hookTimeoutMs, ...(turnSnapshotRef.current !== undefined ? { turnSnapshot: turnSnapshotRef.current } : {}), ...(centerCompactionCandidate !== undefined ? { centerCompactionCandidate } : {}) });
+        const buildPrepared = () => ({ harness, session, sessionId, runId, reminderMark, reminderDisclosureCounts, taskRootPath: taskRootFinal, model, thinking, compModel: effectiveCompModel, mcp: mcp, ...(a2a !== undefined && a2a.tools.length > 0 ? { a2a } : {}), blockedRef, outputRef, abortController, conflictRef, blockedToolCalls, approvalSettlement, batchHaltRef, nestedStats, ...(rewindNotes.length > 0 ? { rewindNotes } : {}), ...(fileHistoryBoundary !== undefined ? { fileHistoryBoundary } : {}), ...(effectiveReadFaceObserved !== undefined ? { effectiveReadFace: effectiveReadFaceObserved } : {}), ...(effectiveReadDenyObserved !== undefined ? { effectiveReadDenyPatterns: effectiveReadDenyObserved } : {}), effectiveMemoryScopes: memoryEffectiveScopes, cwdRef: handsCwdRef, ...(worktreeSessionRef !== undefined ? { worktreeSessionRef } : {}), ...(workspaceStateSettle !== undefined ? { workspaceStateSettle } : {}), ...(sealReadStateSeat !== undefined ? { sealReadStateSeat } : {}), denyNarrowingPolicy, ...(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, suspendRef, suspendProgressRef, reviewRef, remoteEnvFailures, reviewRequestRef, suspendLoopRef, suspendForResource, ...(suspendForPlatformLimit !== undefined ? { suspendForPlatformLimit } : {}), ...(envLifetimeSuspendAt !== undefined ? { envLifetimeSuspendAt } : {}), ...(usageGovernance !== undefined ? { usageGovernance } : {}), callIssuedAtRef, brainCallGuardrailRef, suspendForReview, resourceLedger: priorLedger, liveSpendRef, humanReviewRef, now, tools, toolEffects, wakeRecovered, promptOverheadTokens, lastBrainContext, readTaskFile, recentlyReadFiles, normalizeAttachmentPath, isDedupStubResult, ...(onCompactionApplied ? { onCompactionApplied } : {}), compactionReuseRef, trimPressureRef, microCompact, ...(memoryEngineSession ? { memoryEngineSession } : {}), ...(subagentRetain ? { subagentRetain } : {}), ...(lspDiagnostics && nudgeLspOnEdit ? { lspDiagnostics: { registry: lspDiagnostics, nudge: nudgeLspOnEdit, runIdent: lspRunIdent } } : {}), planModeRef, ...(dateChange ? { dateChange } : {}), ...(instructionSources ? { instructionSources } : {}), ...(projectInstructionContent !== undefined ? { projectInstructionContent } : {}), ...(workflowSizeGuideline ? { workflowSizeGuideline } : {}), ...(detectExternalChanges ? { detectExternalChanges } : {}), ...(toolsDeltaRef ? { toolsDeltaRef } : {}), ...(agentListing ? { agentListing } : {}), ...(skillsListing ? { skillsListing } : {}), announcedListingsRef, gitStatusRef, listBackgroundTasks, hookIdentity, hookTimeoutMs, ...(turnSnapshotRef.current !== undefined ? { turnSnapshot: turnSnapshotRef.current } : {}), ...(centerCompactionCandidate !== undefined ? { centerCompactionCandidate } : {}) });
         const prepared = buildPrepared();
         preparedHolder.current = prepared;
         return prepared;