@sema-agent/core 5.65.0 → 7.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,9 +21,10 @@ 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 { normalizePersistedRule } from "../permission-rule-store.js";
 import { ActiveSkillScope, createActiveSkillScopePolicy } from "./active-skill-scope.js";
 import { CHANGED_FILES_MTIME_EPS_MS, fenceMcpServerInstructions, renderAgentListingDelta } from "./turn-attachments.js";
 import { inlineUntrusted } from "../untrusted-text.js";
@@ -49,7 +51,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 +98,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 +220,7 @@ function announceDeclaredMcpContentClasses(args) {
                 toolCount,
                 ...(declaredClass === "execution" ? { execIsExternalContent: args.execIsExternalContent } : {}),
                 sessionId: args.sessionId,
+                runId: args.runId,
             },
         });
     }
@@ -324,7 +327,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 +340,7 @@ function buildMicroCompactState(deps, model, sessionId, offloadStore, knob) {
                 declaredAutoCompactTokens: triggerWindow.declaredAutoCompactTokens,
                 physicalWindow: triggerWindow.physicalWindow,
                 sessionId,
+                runId,
             },
         });
     }
@@ -433,6 +437,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 +693,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 +702,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,7 +859,7 @@ 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 {
@@ -703,6 +888,43 @@ export function placementValueOrAbsent(value) {
 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 : [])]);
+}
+async function spliceSessionOverlayRows(overlay, sessionId, persisted, tracer, hostTaskId) {
+    if (overlay === undefined)
+        return persisted;
+    try {
+        const served = structuredClone(await overlay.read(sessionId));
+        const sessionRows = served.filter((r) => {
+            const scope = r?.scope;
+            return scope?.kind === "session" && scope.sessionId === sessionId && !("reject" in normalizePersistedRule(r));
+        });
+        if (sessionRows.length < served.length) {
+            emitTrace(tracer, () => ({
+                kind: "permission.rule_store_unreadable",
+                version: 1,
+                taskId: hostTaskId,
+                message: `session-rule overlay served ${served.length - sessionRows.length} row(s) that are not canonical session rows of this session — dropped, not adjudicated`,
+                ts: Date.now(),
+            }));
+        }
+        return sessionRows.length > 0 ? [...sessionRows, ...persisted] : persisted;
+    }
+    catch (err) {
+        emitTrace(tracer, () => ({
+            kind: "permission.rule_store_unreadable",
+            version: 1,
+            taskId: hostTaskId,
+            message: `session-rule overlay: ${err instanceof Error ? err.message : String(err)}`,
+            ts: Date.now(),
+        }));
+        return persisted;
+    }
+}
 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)`);
@@ -710,10 +932,13 @@ function refuseRequireExistingWithoutSession(spec) {
         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;
@@ -727,7 +952,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
     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);
@@ -907,79 +1132,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;
@@ -1121,7 +1432,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 } : {}) } }
+                            : {}),
                     },
                 ]
                 : [];
@@ -1135,7 +1448,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 } : {}) } }
+                                : {}),
                         },
                     ]
                     : []),
@@ -1159,6 +1474,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,
@@ -1184,6 +1500,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,
@@ -1262,6 +1591,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;
@@ -1269,6 +1599,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();
@@ -1315,7 +1646,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);
@@ -1340,6 +1671,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;
@@ -1387,6 +1729,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,
@@ -1465,7 +1816,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 });
@@ -1621,9 +1972,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, envHandToolNames } = 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;
@@ -1868,7 +2219,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,
@@ -1879,6 +2239,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) => {
@@ -1937,6 +2311,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) {
@@ -1988,6 +2363,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;
             }
@@ -2052,7 +2428,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
             ? {
@@ -2251,7 +2627,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) {
@@ -2261,8 +2637,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) {
@@ -2272,8 +2649,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}`))
@@ -2282,7 +2659,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;
             }
@@ -2307,6 +2684,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 statuses: mcp?.statuses,
                 execIsExternalContent,
                 sessionId,
+                runId,
                 onNotice: deps.onNotice,
             });
             if (memoryEngineSession?.settlement !== undefined) {
@@ -2470,6 +2848,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                                                 reason: waivedReason,
                                                 ...(typeof requested === "string" ? { subagentType: inlineUntrusted(requested, 120) } : {}),
                                                 sessionId,
+                                                runId,
                                             },
                                         });
                                     }
@@ -2930,7 +3309,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(),
                 }));
@@ -3161,7 +3540,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),
@@ -3247,16 +3626,17 @@ 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(),
                         }));
                         return { unreadable: true };
                     }
-                    const admitting = findAdmittingRule(listed.rules, { tool: req.toolName, command, cwd: root });
+                    const table = await spliceSessionOverlayRows(deps.sessionPermissionRules, sessionId, listed.rules, deps.tracer, hostTaskId);
+                    const admitting = findAdmittingRule(table, { tool: req.toolName, command, cwd: root, sessionId });
                     if (admitting !== undefined)
                         return persistedRuleHitOf(admitting);
-                    const coverage = segmentCoverageOf(command, { persisted: listed.rules }, { tool: req.toolName, cwd: root });
+                    const coverage = segmentCoverageOf(command, { persisted: table }, { tool: req.toolName, cwd: root, sessionId });
                     return coverage !== undefined ? { segmentCoverage: coverage } : undefined;
                 },
             };
@@ -3292,26 +3672,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) => {
@@ -3748,7 +4138,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 } : {}),
@@ -3757,6 +4147,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, () => ({
@@ -3884,7 +4280,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)
@@ -4282,7 +4678,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 &&
@@ -4453,6 +4849,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 } : {}),
                                 }),
@@ -4552,7 +4949,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,
@@ -4581,7 +4978,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],
@@ -4598,7 +4995,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,
@@ -4720,7 +5117,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;
@@ -4735,7 +5132,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,
@@ -4772,11 +5169,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) {
@@ -5011,7 +5408,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;