@sema-agent/core 7.30.1 → 7.31.0

package/dist/core/runner/prepare-file-history.js

@@ -2,7 +2,7 @@ import { NodeExecutionEnv } from "../../engine/execution-env/node-execution-env.
 import { isRemoteExecutionEnv } from "../remote-env.js";
 import { resolveTrackKey } from "../file-history-store.js";
 export async function prepareFileHistory(input) {
-    const { deps, spec, internals, executionEnv, taskRootFinal, handsEnabled, sessionId, session, resumeAtBeforeParentId, abortController } = input;
+    const { deps, spec, internals, executionEnv, taskRootFinal, handsEnabled, sessionId, session, abortController } = input;
     const rewindNotes = [];
     const onTrackFailure = deps.onTrackFailure === undefined ? "refuse" : deps.onTrackFailure;
     if (onTrackFailure !== "refuse" && onTrackFailure !== "proceed-unprotected") {
@@ -11,16 +11,20 @@ export async function prepareFileHistory(input) {
         throw e;
     }
     const wiredSeat = resolveWiredFileHistoryStore(deps.fileHistoryStore);
-    const fileHistoryStore = wiredSeat === "disabled" ? undefined : wiredSeat;
+    const runDeclaredOff = resolveRunFileHistoryWord(spec.fileHistory);
+    const captureOff = resolveFileHistoryCaptureWord(deps.fileHistoryCapture, wiredSeat);
+    const declaredOff = wiredSeat === "disabled" || runDeclaredOff;
+    const fileHistoryStore = declaredOff ? undefined : wiredSeat;
+    const captureStore = captureOff ? undefined : fileHistoryStore;
     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.)`);
+            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 on whenever a RunnerDeps.fileHistoryStore is wired and neither RunnerDeps.fileHistoryCapture nor TaskSpec.fileHistory turns it off.)`);
             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 });
+            deps.onError?.(new Error(`TaskSpec.rewindFiles (capture sense) is retired and was ignored: per-edited-file first-touch tracking is on whenever RunnerDeps.fileHistoryStore is wired and neither RunnerDeps.fileHistoryCapture nor TaskSpec.fileHistory turns it off, 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 {
         }
@@ -35,7 +39,7 @@ export async function prepareFileHistory(input) {
         e.code = "rewind.conflicting_targets";
         throw e;
     }
-    let rewindTarget = spec.resumeAt !== undefined ? (spec.restoreFiles === true ? spec.resumeAt : undefined) : spec.rewindFilesTo;
+    const 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 && spec.restoreFiles !== true) {
         rewindNotes.push({
@@ -43,9 +47,9 @@ export async function prepareFileHistory(input) {
             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`,
         });
     }
-    const fileHistoryEnabled = fileHistoryStore !== undefined && handsEnabled;
+    const fileHistoryEnabled = captureStore !== undefined && handsEnabled;
     const livenessArm = fileHistoryStore === undefined ? "file-history-no-store" : "file-history-no-env";
-    if (!fileHistoryEnabled && wiredSeat !== "disabled" && (handsEnabled || fileHistoryStore !== undefined) && deps.onError !== undefined && !toldAlready(deps.onError, livenessArm)) {
+    if (!fileHistoryEnabled && !declaredOff && !captureOff && (handsEnabled || fileHistoryStore !== undefined) && deps.onError !== undefined && !toldAlready(deps.onError, livenessArm)) {
         const reason = livenessArm === "file-history-no-store"
             ? `this deployment wired no RunnerDeps.fileHistoryStore, so NOTHING is recorded: no first-touch snapshot before an edit, no turn boundary, and a later restoreFiles / rewindFilesTo has nothing to restore from and will refuse (rewind.store_unconfigured). Supply a store, or accept an unrecoverable working tree knowingly (fileHistoryStore: "disabled" says so and silences this line)`
             : `RunnerDeps.fileHistoryStore is wired but this run mounts no filesystem-capable ExecutionEnv, so the store is INERT: there is no working tree to snapshot and nothing will ever be written to it. Wire RunnerDeps.executionEnv, or drop the store from this deployment shape`;
@@ -55,14 +59,18 @@ export async function prepareFileHistory(input) {
         catch {
         }
     }
-    const { historyRoot, historyScope, historyFs } = await resolveFileHistoryCoordinates(fileHistoryEnabled, executionEnv, taskRootFinal, internals?.fileHistoryLineage, sessionId);
-    if (fileHistoryStore !== undefined && internals?.fileHistoryLineage === undefined)
-        await adoptForkedFileHistory(fileHistoryStore, session, sessionId, deps.onError);
+    const { historyRoot, historyScope, historyFs } = await resolveFileHistoryCoordinates(fileHistoryStore !== undefined && handsEnabled, executionEnv, taskRootFinal, internals?.fileHistoryLineage, sessionId);
+    if (captureStore !== undefined && internals?.fileHistoryLineage === undefined)
+        await adoptForkedFileHistory(captureStore, session, sessionId, deps.onError);
     if (rewindTarget !== undefined && historyScope !== sessionId)
         throw childScopeRewindRefusal(historyScope, rewindTarget);
     if (fileHistoryStore === undefined) {
+        if (rewindTarget !== undefined && runDeclaredOff)
+            throw captureDisabledRefusal(rewindTarget);
         if (rewindTarget !== undefined) {
-            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`);
+            const e = new Error(wiredSeat === "disabled"
+                ? `rewind-files: restoring files to entry "${rewindTarget}" requires a history backend, but this deployment declared file history disabled (RunnerDeps.fileHistoryStore: "disabled"), so there is no history to restore — the files were NOT rewound`
+                : `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;
         }
@@ -78,39 +86,17 @@ export async function prepareFileHistory(input) {
     let restoredFilePaths = [];
     if (rewindTarget !== undefined && fileHistoryStore !== undefined && handsEnabled) {
         const historyStore = fileHistoryStore;
-        if (rewindBefore) {
-            let anchor;
-            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;
-                }
-            }
-            if (anchor === undefined) {
-                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. ${rewindRefusalTail("at-or-above")}`);
-                e.code = "rewind_snapshot.unresolvable";
-                throw e;
-            }
-            rewindTarget = anchor;
-        }
+        if (rewindBefore && !(await historyStore.canRestore(sessionId, rewindTarget)))
+            throw beforeWithoutBoundaryRefusal(rewindTarget, sessionId);
         const restoreRoot = historyRoot;
         const restoreSignal = spec.signal ? AbortSignal.any([abortController.signal, spec.signal]) : abortController.signal;
         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" 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. ${rewindRefusalTail("keyed")}`);
+                if (rewindBefore)
+                    throw beforeWithoutBoundaryRefusal(rewindTarget, sessionId);
+                const e = new Error(`rewind-files: no file-history boundary exists for entry "${rewindTarget}" on session "${sessionId}" — the working tree was NOT rewound. ${rewindRefusalTail()}`);
                 e.code = "rewind_snapshot.unresolvable";
                 throw e;
             }
@@ -170,7 +156,8 @@ export async function prepareFileHistory(input) {
     const fileHistoryBoundary = fileHistoryEnabled && historyScope === sessionId
         ? createFileHistoryBoundarySeat({ store: fileHistoryStore, sessionId, env: executionEnv, root: historyRoot, onError: deps.onError })
         : undefined;
-    return { trackFileEdit, fileHistoryBoundary, restoredFilePaths, rewindNotes, fileHistoryEnabled, historyScope, historyRoot, historyFs };
+    const fileHistoryFact = fileHistoryEnabled ? "on" : "disabled";
+    return { trackFileEdit, fileHistoryBoundary, restoredFilePaths, rewindNotes, fileHistoryEnabled, fileHistoryFact, historyScope, historyRoot, historyFs };
 }
 function restoredAbsPathsOf(restored, root) {
     const out = [];
@@ -203,10 +190,37 @@ function resolveWiredFileHistoryStore(candidate) {
     }
     return candidate;
 }
-function rewindRefusalTail(form) {
-    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.`;
+function resolveRunFileHistoryWord(word) {
+    if (word === undefined || word === "disabled")
+        return word === "disabled";
+    const e = new Error(`rewind-files: TaskSpec.fileHistory holds ${shownWord(word)} — the only value is "disabled"; omit the key to leave the deployment's setting in force`);
+    e.code = "rewind.invalid_spec";
+    throw e;
+}
+function resolveFileHistoryCaptureWord(word, wiredSeat) {
+    if (word === undefined || (word === "off" && wiredSeat !== undefined && wiredSeat !== "disabled"))
+        return word === "off";
+    const e = new Error(word === "off"
+        ? `RunnerDeps.fileHistoryCapture: "off" requires a wired RunnerDeps.fileHistoryStore — nothing to switch off; to drop history entirely write fileHistoryStore: "disabled"`
+        : `RunnerDeps.fileHistoryCapture holds ${shownWord(word)} — the only value is "off"; omit the key to record whenever a fileHistoryStore is wired`);
+    e.code = "config.invalid_file_history_capture";
+    throw e;
+}
+function shownWord(word) {
+    return typeof word === "string" ? JSON.stringify(word.slice(0, 40)) : word === null || typeof word === "boolean" || typeof word === "number" ? String(word) : `a ${typeof word}`;
+}
+function captureDisabledRefusal(target) {
+    const e = new Error(`rewind-files: this run set TaskSpec.fileHistory: "disabled", so it neither records nor restores file history — restoring files to entry "${target}" was refused and the files were NOT rewound`);
+    e.code = "rewind.capture_disabled";
+    return e;
+}
+function rewindRefusalTail() {
+    return `Boundaries are keyed by a turn's INITIAL entry and exist only for turns that recorded history (a RunnerDeps.fileHistoryStore wired, capture on, and the run's file history not disabled); a boundary from the retired whole-tree snapshot era is not restorable by this seat, and reaped boundaries have none.`;
+}
+function beforeWithoutBoundaryRefusal(target, sessionId) {
+    const e = new Error(`rewind-files: entry "${target}" has no file-history boundary on session "${sessionId}" — a before-restore needs the target's own boundary and never crosses into an earlier turn, so the working tree was NOT rewound. ${rewindRefusalTail()}`);
+    e.code = "rewind_snapshot.unresolvable";
+    return e;
 }
 const FILE_HISTORY_BOUNDARY_TIMEOUT_MS = 30_000;
 const FILE_HISTORY_LIVENESS_MEMO = new WeakMap();

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

@@ -218,8 +218,8 @@ export interface PrepareHandsReadFaceInput {
      *  band's Read/notebook/PDF trailer outlets bump keys on it at tool-execute time (the driver owns
      *  the object and folds it into result stats). */
     reminderDisclosureCounts: import("../reminder-disclosure.js").ReminderDisclosureCounts;
-    /** borrowed-readonly — the first-touch history hook prepare built (present iff a fileHistoryStore is
-     *  wired and the run mounts a real fs env); threaded to the write band's trackFileEdit seat. */
+    /** borrowed-readonly — the first-touch history hook prepare built (present iff the run records file history into a
+     *  wired store and mounts a real fs env); threaded to the write band's trackFileEdit seat. */
     trackFileEdit?: import("../types.js").TrackFileEditHook;
     /** borrowed-readonly — the mutation lane's LANDED observation seat (the accumulator behind
      *  `TaskResult.editedFiles`); threaded to the write band's onFileEdited seat. Unlike

package/dist/core/runner/prepare-listings.d.ts

@@ -15,7 +15,7 @@
  */
 import type { AgentTool } from "../../internal/harness.js";
 import type { TaskSpec } from "../types.js";
-import type { AnnounceOnceSink, Prepared, PrepareResume, ToolFaceSnapshot } from "./contracts.js";
+import type { AnnounceOnceSink, DateAnchorRead, Prepared, PrepareResume, ToolFaceSnapshot } from "./contracts.js";
 import type { AnnouncedListingSnapshot } from "../../internal/harness.js";
 import type { ResolvedSkillListingBudget } from "../skill-listing-budget.js";
 export interface PrepareListingsInput {
@@ -65,6 +65,8 @@ export interface PrepareListingsInput {
     tzValid: boolean;
     /** borrowed-readonly — the client's declared zone (used only when `tzValid`). */
     userTz: string | undefined;
+    /** borrowed-readonly — the session's date anchor as the prompt-inputs phase read it (rides the seam). */
+    dateAnchor: DateAnchorRead | undefined;
 }
 export interface PrepareListingsResult {
     /** owned — the agent-listing announce projection (`Prepared.agentListing`): the roster off the

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

@@ -2,7 +2,7 @@ import { formatLocalDate } from "../../prompts/default.js";
 import { SKILL_TOOL_NAME } from "./synthetic-tools.js";
 import { renderAgentListingDelta } from "./turn-attachments.js";
 export function prepareListings(input) {
-    const { spec, tools, onceLedger, sessionId, toolFaceSnapshot, activeTools, resume, skillsListing, listingBudget, listingRideRef, renderWithDate, envFacts, tzValid, userTz } = input;
+    const { spec, tools, onceLedger, sessionId, toolFaceSnapshot, activeTools, resume, skillsListing, listingBudget, listingRideRef, renderWithDate, envFacts, tzValid, userTz, dateAnchor } = input;
     if (spec.agents !== undefined && spec.agents.length > 0) {
         const known = new Set(tools.flatMap((t) => [t.name, ...(t.aliases ?? [])]));
         for (const def of spec.agents) {
@@ -72,7 +72,7 @@ export function prepareListings(input) {
         };
     }
     const dateChange = renderWithDate
-        ? { legDate: envFacts.date, today: () => formatLocalDate(new Date(), tzValid ? userTz : undefined) }
+        ? { legDate: envFacts.date, today: () => formatLocalDate(new Date(), tzValid ? userTz : undefined), anchor: dateAnchor }
         : undefined;
     return { agentListing, announcedListingsRef, dateChange };
 }

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

@@ -81,6 +81,7 @@ export async function prepareMemory(input) {
     let captureIndeterminate = false;
     let captureLineageIndeterminate = false;
     let memoryEngineSession;
+    const openedLegs = [];
     let memoryTools;
     let writeChannelOpen = false;
     let memoryMarkedEntriesServed = false;
@@ -385,6 +386,7 @@ export async function prepareMemory(input) {
                         sessionId,
                         ...(m.write === null && shadowNames !== undefined && shadowNames.size > 0 ? { shadowNames } : {}),
                     });
+                    openedLegs.push(() => void m.engine.endSessionLeg(handle, sessionId));
                     mounted.push(handle);
                     materializedResidue.push(...planeScopes(m.scopes, m.write));
                     if (m.write !== null) {
@@ -425,10 +427,10 @@ export async function prepareMemory(input) {
                         committedHeaders: () => personalEngine.listCommittedHeaders(planeScopes(p.personal, p.writePlane === "personal" ? memorySpec.writeScope : null)),
                     },
                 ];
-                harvestBoth = async () => {
+                harvestBoth = async (phase) => {
                     const writeFirst = writeIsPersonal ? [personalEngine, personalHandle] : [projectEngine, projectHandle];
                     const readOther = writeIsPersonal ? [projectEngine, projectHandle] : [personalEngine, personalHandle];
-                    const writeReport = await writeFirst[0].harvest(writeFirst[1], { ...pollutedOpts(writeFirst[0]), sessionId, ...(await admitNothingOptsNow()) });
+                    const writeReport = await writeFirst[0].harvest(writeFirst[1], { ...pollutedOpts(writeFirst[0]), sessionId, ...(await admitNothingOptsNow()), phase });
                     let readReport;
                     let readFailure;
                     try {
@@ -448,12 +450,13 @@ export async function prepareMemory(input) {
                 const personalEngine = personal.engine;
                 await armCaptureOptOut(personalEngine);
                 const handle = await personalEngine.materialize(memorySpec.scopes, memorySpec.writeScope, { adoptionRestricted: adoptionRestricted || captureOptedOut || captureIndeterminate, sessionId });
+                openedLegs.push(() => void personalEngine.endSessionLeg(handle, sessionId));
                 materializedResidue.push(...planeScopes(memorySpec.scopes, memorySpec.writeScope));
                 memoryMarkedEntriesServed = handle.markedEntriesPresent === true;
                 writeEngine = personalEngine;
                 writeHandle = handle;
                 injectFn = () => personalEngine.inject(handle, { writeToolMounted: writeChannelOpen, reminderMark: input.reminderMark });
-                harvestBoth = async () => personalEngine.harvest(handle, { ...pollutedOpts(personalEngine), sessionId, ...(await admitNothingOptsNow()) });
+                harvestBoth = async (phase) => personalEngine.harvest(handle, { ...pollutedOpts(personalEngine), sessionId, ...(await admitNothingOptsNow()), phase });
                 toolPlanes = [
                     {
                         backend: retrievalBackend(personal.backend, adoptionRestricted || captureOptedOut || captureIndeterminate || memorySpec.writeScope === null),
@@ -477,12 +480,13 @@ export async function prepareMemory(input) {
                 });
                 await armCaptureOptOut(engine);
                 const handle = await engine.materialize(memorySpec.scopes, memorySpec.writeScope, { adoptionRestricted: adoptionRestricted || captureOptedOut || captureIndeterminate, sessionId });
+                openedLegs.push(() => void engine.endSessionLeg(handle, sessionId));
                 materializedResidue.push(...planeScopes(memorySpec.scopes, memorySpec.writeScope));
                 memoryMarkedEntriesServed = handle.markedEntriesPresent === true;
                 writeEngine = engine;
                 writeHandle = handle;
                 injectFn = () => engine.inject(handle, { writeToolMounted: writeChannelOpen, reminderMark: input.reminderMark });
-                harvestBoth = async () => engine.harvest(handle, { ...pollutedOpts(engine), sessionId, ...(await admitNothingOptsNow()) });
+                harvestBoth = async (phase) => engine.harvest(handle, { ...pollutedOpts(engine), sessionId, ...(await admitNothingOptsNow()), phase });
                 toolPlanes = [
                     {
                         backend: retrievalBackend(backend, adoptionRestricted || captureOptedOut || captureIndeterminate || memorySpec.writeScope === null),
@@ -574,7 +578,7 @@ export async function prepareMemory(input) {
             };
             const harvestSafe = async (phase = "terminal") => {
                 try {
-                    const report = await harvestBoth();
+                    const report = await harvestBoth(phase);
                     if (!report.ok && report.incident) {
                         const named = report.reportId !== undefined ? `${report.incident.kind}, report ${report.reportId}` : report.incident.kind;
                         deps.onError?.(new Error(`memory harvest refused (${named}): ${report.incident.detail}`), { phase: "memory", sessionId });
@@ -615,6 +619,10 @@ export async function prepareMemory(input) {
                 handle: writeHandle,
                 inject: injectFn,
                 harvest: harvestSafe,
+                release: () => {
+                    for (const end of openedLegs)
+                        end();
+                },
                 captureOptOut: {
                     optedOut: () => {
                         if (captureOptedOut)
@@ -733,6 +741,9 @@ export async function prepareMemory(input) {
                 memoryTools = createMemoryEngineTools({ planes: toolPlanes, sessionPollution: () => writeEngine.sessionPollution(sessionId), provenance: input.memoryProvenance, writeScope: memorySpec.writeScope });
         }
         catch (err) {
+            if (memoryEngineSession === undefined)
+                for (const end of openedLegs)
+                    end();
             if (typeof err.code === "string" &&
                 (err.code.startsWith("config.memory_scope") ||
                     err.code.startsWith("config.memory_project") ||

package/dist/core/runner/prepare-park-ask.js

@@ -6,6 +6,7 @@ import { boundInputHashOf } from "../canonical-json.js";
 import { buildRiskDescriptor, checkpointVersionFor, debitLedger, encodeAtFidelity, mintCheckpointId, mintCheckpointToken, resolveDeclaredFidelity, samePlainValue, } from "../checkpoint-store.js";
 import { pauseOf } from "../pause-registry.js";
 import { askCarryRowMembers } from "../hooks.js";
+import { askMandateMember, ownedClearanceFacts } from "../ask-origin.js";
 import { defaultTaskRegistry } from "../task-registry.js";
 import { advertisedWritableRootsSeat, isLiveApproverSeat, carriesBidiControls, describeThrown, refuseOutOfContractDecision, tryCloneArgs } from "../tool-policy.js";
 import { InMemoryToolResultStore, ScopedToolResultStore, isVolatileOffloadStore } from "../tool-result-store.js";
@@ -21,6 +22,9 @@ class ParkRefusal extends Error {
         this.name = "ParkRefusal";
     }
 }
+const wordlessDemand = (toolName) => {
+    throw new Error(`a real-approval demand for "${toolName}" reached the park with no origin word — the origin stamp precedes every park`);
+};
 export function prepareParkAsk(input) {
     const { askLane, saga, spec, deps, sessionId, checkpointStore, toolRosterDeltas, parkLaneArmed, contentAskRoutable, liveQuestionFace, mountedQuestionTool, contentAskBindings, lateStrandedAnswers, discloseStrandedAnswers, onAsk, runtimeCaps, inheritedUnavailableAsks, basePolicyForResumeEdit, budgetSnapshot, handsCwdRef, advertisedWritableDirs, offloadStore, ownedEnv, incompleteSuspendAdapter, session, sessions, suspendChainBase, maxSuspends, remoteEnvFailures, shellGatedTools, effectiveShellGate, durableApproval, priorLedger, liveSpendRef, resourceTotal, faceCheckpointState, f012CheckpointState, orgAdmissionCheckpointState, ruleOffersOf, now, humanReviewRef, abortController, harness, pausedRef } = input;
     if (askLane === undefined || saga === undefined)
@@ -148,6 +152,7 @@ export function prepareParkAsk(input) {
                     throw new ParkRefusal(`the arguments of "${req.toolName}" change shape when stored by this checkpoint backend, and no policy is wired to re-adjudicate the stored shape ` +
                         `(no basePolicyForResumeEdit override and no caller toolPolicy) — refusing to file a row whose executable form nothing adjudicated`);
                 }
+                let storedShapeFacts;
                 if (projectionMovedArgs && basePolicyForResumeEdit !== undefined) {
                     const presented = encodeAtFidelity(backendFidelity, parkedArgs);
                     if (!presented.ok) {
@@ -177,7 +182,10 @@ export function prepareParkAsk(input) {
                             `${reprojected.action === "deny" && reprojected.message ? `: ${reprojected.message}` : ""} — ` +
                             `refusing to file a row whose executable form nothing adjudicated`);
                     }
+                    if (reprojected.action === "ask")
+                        storedShapeFacts = ownedClearanceFacts(reprojected);
                 }
+                const rowRealApproval = realApproval ?? (storedShapeFacts?.requiresRealApproval === true ? { origin: carry?.origin ?? wordlessDemand(req.toolName) } : undefined);
                 if (offloadStore && isVolatileOffloadStore(offloadStore) && !offloadStore.isEmpty()) {
                     throw new ParkRefusal("durable suspend requires a durable toolResultStore (the default InMemoryToolResultStore " +
                         "holds offloaded results that are lost across a cross-replica resume); inject " +
@@ -237,15 +245,15 @@ export function prepareParkAsk(input) {
                     shellGateDoctrine: effectiveShellGate,
                 });
                 gate =
-                    safety !== undefined || realApproval !== undefined
+                    safety !== undefined || rowRealApproval !== undefined
                         ? {
                             kind: "irreversible_ask",
                             reason: safety !== undefined
                                 ? `human approval required before safety-tightened tool "${req.toolName}"`
-                                : `real human approval required for tool "${req.toolName}" (non-budgetable: ${realApproval.origin})`,
+                                : `real human approval required for tool "${req.toolName}" (non-budgetable: ${rowRealApproval.origin})`,
                             toolName: req.toolName,
                             ...(safety !== undefined ? { safetyAxis: safety } : {}),
-                            ...(realApproval !== undefined ? { realApproval } : {}),
+                            ...(rowRealApproval !== undefined ? { realApproval: rowRealApproval } : {}),
                             riskDescriptor,
                         }
                         : durableApproval
@@ -264,15 +272,26 @@ export function prepareParkAsk(input) {
                 const scope = durableApproval?.scope || checkpointScopeOf({ principal: spec.principal });
                 const ttlMs = sanitizedTtlMs(durableApproval?.ttlMs);
                 const checkpointState = serializeCheckpointState(remoteHandle, inFlightSpendMicroUsd());
-                if (realApproval !== undefined && checkpointState.readFace !== undefined) {
+                if (rowRealApproval !== undefined && checkpointState.readFace !== undefined) {
                     checkpointState.readFace = { ...checkpointState.readFace, realApproval: true };
                 }
                 const approvalLedger = debitLedger(priorLedger, liveSpendRef.get?.() ?? { costMicroUsd: 0, tokens: 0, turns: 0, walltimeMs: 0 }, resourceTotal, { countSlice: false });
+                const rowMatchedAskRule = matchedAskRule ?? storedShapeFacts?.matchedAskRule;
+                const clearanceFacts = {
+                    ...(carry?.mandated === true || askMandateMember(storedShapeFacts).mandated === true ? { mandated: true } : {}),
+                    ...(rowRealApproval !== undefined ? { requiresRealApproval: true } : {}),
+                    ...(shadowedRule !== undefined ? { persistedRuleShadowed: shadowedRule } : {}),
+                    ...(askDecisionReason !== undefined ? { decisionReason: askDecisionReason } : {}),
+                    ...(rowMatchedAskRule !== undefined ? { matchedAskRule: rowMatchedAskRule } : {}),
+                    ...(probeMandated === true ? { probeMandated: true } : {}),
+                    ...(inheritedUnavailableAsks.has(req.toolCallId) ? { inheritedUnresolved: true } : {}),
+                    ...(segmentCoverage !== undefined ? { segmentCoverage } : {}),
+                };
                 const mintedAt = Date.now();
                 cp = {
                     token,
                     checkpointId: mintCheckpointId(),
-                    version: checkpointVersionFor({ resource: false, binding: true, token: approvalLedger.totalTokens !== undefined, orgAdmission: orgAdmissionCheckpointState(), f012: f012CheckpointState(), realApproval: realApproval !== undefined, face: faceCheckpointState() }),
+                    version: checkpointVersionFor({ resource: false, binding: true, token: approvalLedger.totalTokens !== undefined, orgAdmission: orgAdmissionCheckpointState(), f012: f012CheckpointState(), realApproval: rowRealApproval !== undefined, face: faceCheckpointState() }),
                     scope,
                     sessionId,
                     leafId,
@@ -291,18 +310,10 @@ export function prepareParkAsk(input) {
                                 ...(bidi ? { hasBidiControls: true } : {}),
                             };
                         })(),
-                        ...(realApproval !== undefined ? { requiresRealApproval: true } : {}),
+                        ...(rowRealApproval !== undefined ? { requiresRealApproval: true } : {}),
+                        ...askMandateMember(clearanceFacts),
                         ...askCarryRowMembers(carry),
-                        ...ruleOffersOf(req.toolName, parkedArgs, {
-                            ...(carry?.mandated === true ? { mandated: true } : {}),
-                            ...(realApproval !== undefined ? { requiresRealApproval: true } : {}),
-                            ...(shadowedRule !== undefined ? { persistedRuleShadowed: shadowedRule } : {}),
-                            ...(askDecisionReason !== undefined ? { decisionReason: askDecisionReason } : {}),
-                            ...(matchedAskRule !== undefined ? { matchedAskRule } : {}),
-                            ...(probeMandated === true ? { probeMandated: true } : {}),
-                            ...(inheritedUnavailableAsks.has(req.toolCallId) ? { inheritedUnresolved: true } : {}),
-                            ...(segmentCoverage !== undefined ? { segmentCoverage } : {}),
-                        }),
+                        ...ruleOffersOf(req.toolName, parkedArgs, clearanceFacts),
                         boundInputHash: boundInputHashOf(parkedArgs),
                         batchToolCallIds,
                         completedCallIds,

package/dist/core/runner/prepare-prompt-inputs.d.ts

@@ -27,7 +27,8 @@ import type { LockedPreflight } from "../locked-config.js";
 import type { MaterializedMcp } from "../mcp.js";
 import type { ResolvedRole } from "../roles.js";
 import type { RunnerDeps, TaskSpec } from "../types.js";
-import type { PrepareResume, PromptFeatureFlags, RunInternals, ToolFaceSnapshot } from "./contracts.js";
+import type { SessionTreeEntry } from "../../internal/harness-types.js";
+import type { DateAnchorRead, PrepareResume, PromptFeatureFlags, RunInternals, ToolFaceSnapshot } from "./contracts.js";
 import type { AdvertisedWritableDirs } from "./advertised-writable-dirs.js";
 import { type GitStatusLaneRef } from "./git-status-frame.js";
 import { type ContextWindowOverlay } from "../context-settings.js";
@@ -99,6 +100,10 @@ export interface PreparePromptInputsInput {
     advertisedWritableDirs?: AdvertisedWritableDirs;
     /** borrowed-readonly — the acquired session's id (operator-line context). */
     sessionId: string;
+    /** borrowed-readonly — the acquired session; only `getBranch` is read (the date anchor). */
+    session: {
+        getBranch(): Promise<ReadonlyArray<SessionTreeEntry>>;
+    };
     /** borrowed-readonly — the deployment's window overlay for this leg, as it reads at PREPARE. The prompt's
      *  context-management sentence must not claim mid-task summarization a deployment has turned off for this
      *  model; the seat is live, so a later swap's effect on the SENTENCE lands at the next prepare while its
@@ -123,6 +128,8 @@ export interface PreparePromptInputsResult {
     tzValid: boolean;
     /** owned — the client's declared zone as given (paired with `tzValid`; unvalidated on its own). */
     userTz: string | undefined;
+    /** owned — the session's date anchor as read here; `envFacts.date` is its prefix date when present. */
+    dateAnchor: DateAnchorRead | undefined;
     /** owned — the git-status lane's run-local state (empty on a hands-less leg); the run loop and the checkpoint
      *  serializer mutate its fields from here on (`announced`, `mirrorOwed`, …; the frame's receipt rides the leg's shared `Prepared.frameReceipts`). */
     gitStatusRef: GitStatusLaneRef;

package/dist/core/runner/prepare-prompt-inputs.js

@@ -1,11 +1,12 @@
 import { defaultPromptProvider, formatLocalDate, isValidTimeZone } from "../../prompts/default.js";
 import { isIsolated } from "../remote-env.js";
+import { readDateAnchor } from "./announce-once-ledger.js";
 import { probeGitStatusLane } from "./git-status-frame.js";
 import { fenceMcpServerInstructions } from "./turn-attachments.js";
 const ULTRA_REASONING_TIERS = new Set(["xhigh", "max"]);
 import { compactionEnabled } from "../context-settings.js";
 export async function preparePromptInputs(input) {
-    const { spec, deps, failClosedReason, lockedPreflight, selfOrchestrationActive, executionEnv, reminderMark, resolvedReadFace, resolvedWriteFace, toolFaceSnapshot, promptProfile, fableMitigations, internals, thinking, ownedEnv, delegation, resolvedRole, mcp, model, externalContentTargetActive, resume, handsEnabled, taskRootFinal, additionalRootsCanonical, additionalReadRootsCanonical, sessionId, advertisedWritableDirs } = input;
+    const { spec, deps, failClosedReason, lockedPreflight, selfOrchestrationActive, executionEnv, reminderMark, resolvedReadFace, resolvedWriteFace, toolFaceSnapshot, promptProfile, fableMitigations, internals, thinking, ownedEnv, delegation, resolvedRole, mcp, model, externalContentTargetActive, resume, handsEnabled, taskRootFinal, additionalRootsCanonical, additionalReadRootsCanonical, sessionId, session, advertisedWritableDirs } = input;
     const provider = spec.promptProvider ?? deps.promptProvider ?? defaultPromptProvider;
     const promptPolicyEnabled = Boolean(lockedPreflight.toolPolicy);
     const promptHooks = spec.hooks ?? deps.hooks;
@@ -37,7 +38,8 @@ export async function preparePromptInputs(input) {
         : undefined;
     const userTz = spec.clientContext?.timeZone;
     const tzValid = userTz !== undefined && isValidTimeZone(userTz);
-    const envFacts = { date: formatLocalDate(new Date(), tzValid ? userTz : undefined), modelId: model.id };
+    const dateAnchor = await readDateAnchor(session);
+    const envFacts = { date: dateAnchor?.current?.prefixDate ?? formatLocalDate(new Date(), tzValid ? userTz : undefined), modelId: model.id };
     if (tzValid)
         envFacts.timeZone = userTz;
     if (spec.clientContext?.userEmail)
@@ -141,5 +143,5 @@ export async function preparePromptInputs(input) {
         taskRoot: taskRootFinal,
         onDegrade: (reason) => deps.onError?.(new Error(`env git snapshot degraded — ${reason}`), { phase: "degraded", sessionId, classification: "env-git-snapshot" }),
     });
-    return { provider, featureFlags, userSystemPrompt, userAppendSystemPrompt, mcpInstructionsBlock, envFacts, tzValid, userTz, gitStatusRef };
+    return { provider, featureFlags, userSystemPrompt, userAppendSystemPrompt, mcpInstructionsBlock, envFacts, tzValid, userTz, dateAnchor, gitStatusRef };
 }

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

@@ -283,7 +283,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
     let shellGatedTools = new Set();
     refuseRequireExistingWithoutSession(spec);
     refuseRegistryScopeMismatch(spec, internals);
-    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 { acquired, session, conflictRef, wakeRecovered } = 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 onceLedger = await loadAnnounceOnceLedger(session, resume?.seed.announcedListings, deps.onError);
     const hostTaskId = spec.taskId ?? sessionId;
@@ -382,7 +382,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         const ownedEnv = ownedEnvSeat.current;
         const { taskRootFinal, rebaseRestoredPath } = await prepareWorkspaceRestore({ ownedEnv, deps, spec, internals, resume, taskRootInitial, abortController, sessionId });
         const { canonical: taskRootCanonical } = await resolveTaskRootCanonical({ env: executionEnv, given: taskRootFinal, onNotice: deps.onNotice, sessionId, runId });
-        const { trackFileEdit, fileHistoryBoundary, restoredFilePaths, rewindNotes, fileHistoryEnabled, historyScope, historyRoot, historyFs } = await prepareFileHistory({ deps, spec, internals, executionEnv, taskRootFinal, handsEnabled, sessionId, session, resumeAtBeforeParentId, abortController });
+        const { trackFileEdit, fileHistoryBoundary, restoredFilePaths, rewindNotes, fileHistoryEnabled, fileHistoryFact, historyScope, historyRoot, historyFs } = await prepareFileHistory({ deps, spec, internals, executionEnv, taskRootFinal, handsEnabled, sessionId, session, abortController });
         const { noteFileEdited, editedFilesSnapshot, harnessRef, toolProgressRef, skillScope, forwardEvent, reviewRequestRef, requestReview, stopRequestedRef, requestStopAfterTurn, planModeRef, enterPlanMode, subagentRetain, worktreeIsolation } = prepareRunRefs({ spec, internals, executionEnv, taskRootFinal });
         const legContextOverlay = () => runnerSelf?.contextOverlayOf?.(harnessRef.current?.getModelRef() ?? resolvedRole.modelRef);
         let resolvedReadFace;
@@ -521,6 +521,8 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 governedProvenance: orgGovernedProvenance,
             },
         });
+        if (memoryEngineSession !== undefined)
+            rollback.push(() => memoryEngineSession.release());
         memoryAdmittedOrgScopesRef.current = memoryAdmittedOrgScopes;
         ownOrgVerdictRef.current = memoryOwnOrgVerdict ?? priorOwnOrgVerdict;
         if (internals?.ownOrgAdmissionRef !== undefined && ownOrgVerdictRef.current !== undefined) {
@@ -594,7 +596,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         }
         const projectContext = await prepareProjectContext({ deps, spec, internals, session, sessionId, hostTaskId, taskRootFinal, handsEnabled, delegation, seedContextFiles, memoryBlockFromEngine, skillScope, roster, toolFaceSnapshot, onceLedger, memoryTools, memoryEngineSession, memorySearchToolsPlanned, memoryPairExcludedName, memoryPairOccupiedName, resume, skillListingBudget: doors.skillListingBudget });
         const { memoryBlock: memoryBlockWithProject, instructionSources, projectInstructionContent, hasSkillManifest, skillsListing, sharedMemoryPairMounted, memoryEnginePairMounted } = projectContext;
-        const { provider, featureFlags, userSystemPrompt, userAppendSystemPrompt, mcpInstructionsBlock, envFacts, tzValid, userTz, gitStatusRef } = await preparePromptInputs({ spec, deps, contextOverlay: legContextOverlay(), failClosedReason: selfOrchestrationFailClosedReason(spec, deps), lockedPreflight, selfOrchestrationActive, executionEnv, reminderMark, resolvedReadFace, resolvedWriteFace, toolFaceSnapshot, promptProfile, fableMitigations, internals, thinking, ownedEnv, delegation, resolvedRole, mcp, model, externalContentTargetActive, resume, handsEnabled, taskRootFinal, additionalRootsCanonical, additionalReadRootsCanonical, sessionId, ...(advertisedWritableDirs !== undefined ? { advertisedWritableDirs } : {}) });
+        const { provider, featureFlags, userSystemPrompt, userAppendSystemPrompt, mcpInstructionsBlock, envFacts, tzValid, userTz, dateAnchor, gitStatusRef } = await preparePromptInputs({ spec, deps, contextOverlay: legContextOverlay(), failClosedReason: selfOrchestrationFailClosedReason(spec, deps), lockedPreflight, selfOrchestrationActive, executionEnv, reminderMark, resolvedReadFace, resolvedWriteFace, toolFaceSnapshot, promptProfile, fableMitigations, internals, thinking, ownedEnv, delegation, resolvedRole, mcp, model, externalContentTargetActive, resume, handsEnabled, taskRootFinal, additionalRootsCanonical, additionalReadRootsCanonical, sessionId, session, ...(advertisedWritableDirs !== undefined ? { advertisedWritableDirs } : {}) });
         const { deferred, memoryBlock, toolSearch: toolSearchPolicy } = prepareDeferClassify({ spec, deps, roster, toolFaceSnapshot, handsEnabled, fullShellReachable, promptProfile, model, mcp, a2a, sharedMemoryPairMounted, memoryEnginePairMounted, memoryBlock: memoryBlockWithProject, memoryRecallSegment, onceLedger, sessionId });
         prepareMemoryEngineSession({ memoryEngineSession, internals, memoryDelegationEvidence, externalContentTargetActive, lockedPreflight, mcp, sessionId, runId, deps, provenanceForChildrenRef, delegationSettlementRef, spec, envHandToolNames, roster, contentOriginWrapRef });
         const { systemPromptSeat, renderWithDate, systemBlocks, promptManifest, epochDeclaredSections, epochArtifactDigestForSnapshot, buildAssembleInputs, centerAdoptionRef } = await preparePromptAssembly({ session, deps, internals, resume, provider, userSystemPrompt, userAppendSystemPrompt, featureFlags, mcpInstructionsBlock, memoryBlock, envFacts, promptProfile, fableMitigations, tools, model, sessionId, reminderMark, onceLedger });
@@ -608,7 +610,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             declaredCards: toolRoster.entries.flatMap((e) => e.renderHints?.resultCards ?? []),
             onUndeclared: (type) => deliverEngineNotice(deps.onNotice, { code: "config.tool_card_undeclared", message: `a tool minted a \`details.type\` card ${JSON.stringify(type)} its definition never declared — dropped from tool_end.structured (declare it on the definition's catalog row or the caller's renderHints.resultCards)`, detail: { type, sessionId, runId } }),
         });
-        const { agentListing, announcedListingsRef, dateChange } = prepareListings({ spec, tools, onceLedger, sessionId, toolFaceSnapshot, activeTools, resume, skillsListing, listingBudget: doors.skillListingBudget, listingRideRef, renderWithDate, envFacts, tzValid, userTz });
+        const { agentListing, announcedListingsRef, dateChange } = prepareListings({ spec, tools, onceLedger, sessionId, toolFaceSnapshot, activeTools, resume, skillsListing, listingBudget: doors.skillListingBudget, listingRideRef, renderWithDate, envFacts, tzValid, userTz, dateAnchor });
         const lastBrainContextRef = {};
         const requestLossyRef = { current: false };
         const staleOffloadWrittenRefs = new Set();
@@ -707,7 +709,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             }
         }
         const { hooks, hookTimeoutMs, preToolUseObservational, ownGatePreToolUse, basePolicyForResumeEdit, denyNarrowingPolicy, policyLayers, effectivePolicy, inheritedUnavailableAsks, inheritedAskGrants, askSourceIdentity, riskAxesOf, ruleOffersOf, permissionRuleLane, permissionRuleOrgLane, sandboxAdmissionArmed, sandboxBoundaryCapable, emitSandboxAdmitted, foldAskClasses, ancestorSandboxAdmissions } = await preparePolicyChain({ spec, deps, internals, sessionId, runId, hostTaskId, taskRootFinal, executionEnv, lockedPreflight, tools, harnessTools, toolEffects, egressTools, irreversibilityTier, axisExplicitNegatives, shellGatedTools, envHandToolNames, handsCwdRef, readDenyMatcher, questionToolMounted, runtimeCaps, inheritedAncestorRules, ancestorSessionRulesRef, inheritedParentConstraints, seedInheritedGate, hasSkillManifest, skillScope, frozenOnAsk, hookEnvSource, notifyOwnHookCrash, autoModeDecider, stopForDenialLimit, delegation, abortController, now, ownSessionRulesRef });
-        const { onAsk, preToolContexts, blockedToolCalls, gateOutcomes, batchHaltRef, blockedTracked, incompleteSuspendAdapter, durableSuspendInfraReady, resourceSuspendEligible, usageGovernance, durableApproval, wiringManifest, writeProtectionCheck, parkLaneArmed, gateMachineryActive, hookIdentity, hookEnvFace, sessionBoxBound } = prepareWiringManifest({ spec, deps, internals, resume, sessionId, runId, hostTaskId, taskScope, hooks, preToolUseObservational, policyLayers, effectivePolicy, handsEnabled, taskRootFinal, mcp, irreversibleTools, egressTools, shellReadStationArmed: shellReadCheck !== undefined, toolEffects, ownedEnv, executionEnv, offloadStore, onceLedger, usageWindows, envLifetimeSuspendAt, runtimeCaps, resolvedInteractionPosture, durableQuestionFace, liveQuestionFace, checkpointStore, sessions, modelGateManifest, autoModeArmReason, lockedPreflight, peerLaneRefs, frameSettlement, harness, pausedRef, frozenOnAsk, liveInheritedGate, delegation, toolRoster, readDenyBuiltinTiersActive: handsReadFace.readDenyBuiltinTiersActive, lspManagerWired, lspDiagnosticsLive: lspDiagnostics !== undefined, sessionBox });
+        const { onAsk, preToolContexts, blockedToolCalls, gateOutcomes, batchHaltRef, blockedTracked, incompleteSuspendAdapter, durableSuspendInfraReady, resourceSuspendEligible, usageGovernance, durableApproval, wiringManifest, writeProtectionCheck, parkLaneArmed, gateMachineryActive, hookIdentity, hookEnvFace, sessionBoxBound } = prepareWiringManifest({ spec, deps, internals, resume, sessionId, runId, hostTaskId, taskScope, hooks, preToolUseObservational, policyLayers, effectivePolicy, handsEnabled, taskRootFinal, mcp, irreversibleTools, egressTools, shellReadStationArmed: shellReadCheck !== undefined, toolEffects, ownedEnv, executionEnv, offloadStore, onceLedger, usageWindows, envLifetimeSuspendAt, runtimeCaps, resolvedInteractionPosture, durableQuestionFace, liveQuestionFace, checkpointStore, sessions, modelGateManifest, autoModeArmReason, lockedPreflight, peerLaneRefs, frameSettlement, harness, pausedRef, frozenOnAsk, liveInheritedGate, delegation, toolRoster, readDenyBuiltinTiersActive: handsReadFace.readDenyBuiltinTiersActive, lspManagerWired, lspDiagnosticsLive: lspDiagnostics !== undefined, fileHistoryFact, sessionBox });
         if (fileHistoryBoundary !== undefined) {
             harness.on("tool_call", async () => {
                 await fileHistoryBoundary.settle();

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

@@ -118,6 +118,7 @@ export interface PrepareWiringManifestInput {
     readDenyBuiltinTiersActive: readonly string[];
     /** borrowed-readonly — from the LSP phase's manager fold: gates the manifest's LSP section (absent ⇒ byte-identical manifest). */ lspManagerWired: boolean;
     /** borrowed-readonly — from the LSP phase: is the diagnostics lane live? The `lane` word's only input. */ lspDiagnosticsLive: boolean;
+    /** borrowed-readonly — from the file-history phase's one fold of the two off switches: the manifest's word, relayed. */ fileHistoryFact: NonNullable<WiringManifest["fileHistory"]>;
     /** borrowed-readonly — the arming outcome the caps phase minted (the manifest's auto-mode face). */
     autoModeArmReason: AutoModeArmFact;
     /** borrowed-readonly — the frozen preflight; only `mcp` (the declared servers the manifest face joins). */

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

@@ -116,7 +116,7 @@ function announceDurableGateUnavailable(args) {
     });
 }
 export function prepareWiringManifest(input) {
-    const { spec, deps, internals, resume, sessionId, runId, hostTaskId, taskScope, hooks, preToolUseObservational, policyLayers, effectivePolicy, handsEnabled, taskRootFinal, mcp, irreversibleTools, egressTools, toolEffects, ownedEnv, executionEnv, offloadStore, onceLedger, usageWindows, envLifetimeSuspendAt, runtimeCaps, resolvedInteractionPosture, durableQuestionFace, liveQuestionFace, checkpointStore, sessions, modelGateManifest, autoModeArmReason, lockedPreflight, peerLaneRefs, frameSettlement, sessionBox, harness, pausedRef, frozenOnAsk, liveInheritedGate, delegation, toolRoster, readDenyBuiltinTiersActive, lspManagerWired, shellReadStationArmed, lspDiagnosticsLive } = input;
+    const { spec, deps, internals, resume, sessionId, runId, hostTaskId, taskScope, hooks, preToolUseObservational, policyLayers, effectivePolicy, handsEnabled, taskRootFinal, mcp, irreversibleTools, egressTools, toolEffects, ownedEnv, executionEnv, offloadStore, onceLedger, usageWindows, envLifetimeSuspendAt, runtimeCaps, resolvedInteractionPosture, durableQuestionFace, liveQuestionFace, checkpointStore, sessions, modelGateManifest, autoModeArmReason, lockedPreflight, peerLaneRefs, frameSettlement, sessionBox, harness, pausedRef, frozenOnAsk, liveInheritedGate, delegation, toolRoster, readDenyBuiltinTiersActive, lspManagerWired, shellReadStationArmed, lspDiagnosticsLive, fileHistoryFact } = input;
     const onAsk = spec.onAsk ?? deps.onAsk;
     const handWriteTools = toolRoster.entries.filter((e) => e.mountedBy === "hands" && (e.effect === "write" || e.effect === "idempotent")).map((e) => e.name);
     const hasEffectAwareGate = Boolean(policyLayers.length > 0 || (hooks?.preToolUse !== undefined && !preToolUseObservational));
@@ -218,6 +218,7 @@ export function prepareWiringManifest(input) {
         tools: toolRoster,
         hooks: wiredHookEntries(hooks, spec.hooks !== undefined ? "spec" : "deps", preToolUseObservational),
         ...(lspManagerWired ? { lsp: deriveLspSeam(toolRoster.entries.some((e) => e.contract.contractId === LSP_CONTRACT_ID), lspDiagnosticsLive) } : {}),
+        fileHistory: fileHistoryFact,
     });
     peerLaneRefs.askEffective = wiringManifest.ask.effective;
     const sessionBoxBound = sessionBox !== undefined && internals?.onTaskNotification !== undefined ? sessionBox : undefined;

package/dist/core/runner/run-attachment-seats.js

@@ -14,7 +14,7 @@ export async function runAttachmentSeats(input) {
     const listingsLive = (rs.attach.agentListingOn && prepared.agentListing !== undefined) || (rs.attach.skillsListingOn && prepared.skillsListing !== undefined);
     const backgroundTasksLive = (rs.attach.attachmentsCfg?.backgroundTasks ?? eventDefaultOn("background_tasks")) === true;
     rs.attach.attachState = rs.attach.attachmentsCfg !== undefined || listingsLive || backgroundTasksLive ? createAttachmentState() : undefined;
-    rs.attach.dateState = prepared.dateChange !== undefined ? { announcedDate: prepared.dateChange.legDate } : undefined;
+    rs.attach.dateState = prepared.dateChange !== undefined ? { announcedDate: prepared.dateChange.anchor?.current?.announcedDate ?? prepared.dateChange.legDate } : undefined;
     rs.attach.instrProbe = runner.deps.probeInstructionSources;
     rs.attach.instrState =
         rs.attach.instrProbe !== undefined && prepared.instructionSources !== undefined && prepared.instructionSources.length > 0