@sema-agent/core 7.30.1 → 7.31.1

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

@@ -176,11 +176,22 @@ export interface CommittedPause {
     scope: string;
     gatedCallId?: string;
 }
+/** The session's date anchor as prepare read it off the branch. The system-prefix date is frozen per
+ *  SEGMENT — from session start, or from the latest landed compaction, to the next one. */
+export interface DateAnchorRead {
+    /** The anchor written for the current segment; undefined ⇒ the leg renders today and anchors it. */
+    current: {
+        prefixDate: string;
+        announcedDate: string;
+    } | undefined;
+    /** The current segment: the nearest compaction entry's id, null before the first compaction. */
+    segment: string | null;
+}
 /**
  * One engine frame whose commit waits for the receipt of the message carrying it.
  *
  * @contract frames.commit_on_receipt — an engine-minted frame that rides a user message (the git-status
- * frame, an `agent_listing` or `skills_listing` frame) is recorded as announced ONLY when the run loop's
+ * frame, an `agent_listing`, `skills_listing` or `date_change` frame) is recorded as announced ONLY when the run loop's
  * `message_end` walk sees a persisted user entry whose text equals the carrying text it was registered
  * with; every receipt with that text settles on that one entry. Until then nothing is recorded — a
  * message that never reaches the transcript (a pre-append failure, a suppressed or undrained steer, a
@@ -193,7 +204,7 @@ export interface FrameReceipt {
     text: string;
     /** Which frame this receipt settles. A boundary collector must not render a listing whose receipt is
      *  still pending (the frame is queued, not yet in the transcript). */
-    source: "git_status" | "agent_listing" | "skills_listing";
+    source: "git_status" | "agent_listing" | "skills_listing" | "date_change";
     /** Runs inside the `message_end` walk (synchronous, never awaited): advances the run-local record
      *  and parks any session write for the next serialization point. */
     commit: (entryId: string) => void;
@@ -344,7 +355,7 @@ export interface Prepared {
      *  than a snapshot, so the throw-path backstop terminal reports the same ledger the ordinary
      *  assembly would. Always present on Prepared; independent of whether a fileHistoryStore is wired. */
     editedFilesSnapshot: () => TaskResult["editedFiles"];
-    /** The run's turn-start boundary seat (present iff a fileHistoryStore is wired and
+    /** The run's turn-start boundary seat (present iff the run records file history into a wired store and
      *  the run mounts a real fs env). runtask calls begin() at the first committed user entry and
      *  awaits settle() at the lease close + the finish tail. */
     fileHistoryBoundary?: FileHistoryBoundarySeat;
@@ -623,6 +634,9 @@ export interface Prepared {
         /** Merged injection across all planes (single-root sessions: identical to engine.inject(handle)). */
         inject: () => import("../memory-engine/engine.js").MemoryInjection;
         harvest: (phase?: "checkpoint" | "terminal") => Promise<HarvestReport | undefined>;
+        /** End this mount's session leg WITHOUT a harvest: the run that mounted it will never reach its
+         *  terminal harvest (a prepare that failed after the mount). Never throws. */
+        release: () => void;
         /**
          * The session's capture opt-out face (the `TaskStream.optOutMemoryCapture`
          * verb's target; host-API only — no tool face reads it, §2.6). `flip` re-adjudicates the
@@ -1027,10 +1041,13 @@ export interface Prepared {
     /** The date-flip detector seam: `legDate` = the date frozen
      *  into this leg's system prefix; `today()` = the boundary-time LOCAL date (user-zone-bound closure).
      *  The run loop feeds both to the `date_change` attachment producer; the prefix itself never
-     *  re-renders mid-leg (cache preservation, CC parity). Present only when the prompt carries a date. */
+     *  re-renders mid-leg (cache preservation, CC parity). Present only when the prompt carries a date.
+     *  `anchor` = the session's date anchor as prepare read it (undefined ⇒ the branch was unreadable
+     *  and the leg writes none); the settle lane persists it when it is new or the announced date moved. */
     dateChange?: {
         legDate: string;
         today: () => string;
+        anchor: DateAnchorRead | undefined;
     };
     /** [A2] C-4 (design-A §4) — the loadProjectMemory snapshot's declared instruction sources
      *  (`ProjectMemoryLoad.instructionSources`): the probe input AND the lane's per-path baseline
@@ -2066,7 +2083,7 @@ export interface RunInternals {
      * re-exposes the SAME triple on its own ctx, so every same-tree descendant of a root session — at
      * any depth — lands in the root session's scope (the fixed point), while a descendant on another
      * tree (worktree isolation, explicit `cwd`, a fresh per-task sandbox) becomes the root of its own
-     * subtree's history. Absent on a top-level run, on a run with no live history store, and on a
+     * subtree's history. Absent on a top-level run, on a run that records no file history, and on a
      * tier-3 revival (the reviver's lineage says nothing about the revived row's tree).
      */
     fileHistoryLineage?: {

package/dist/core/runner/denial-limit-arms.d.ts

@@ -60,8 +60,8 @@ export declare function attachRebuiltDenialTrackers<T extends {
  * in headless mode"). Once per run leg (the first such fallback owns the terminal); the deny that
  * triggered it stands as that call's result. Minted once so every mint site — the main gate's seat, the
  * inherited-lane arms, and the durable resume station — stops the SAME leg through the SAME seat.
- * `abort` is the run's own abort (controller + harness), handed in because the harness is built after
- * the seat is.
+ * `abort` is the run's own abort (controller + harness — the one a cancel fires; handed in because the harness
+ * is built after the seat): the durable stop fires it before the resume leg's prompt, whose door reads it.
  *
  * TWO LANES, ONE SENTENCE. The synchronous lane reached no approver at all; the durable lane parked the
  * fallback, and the decide that came back named a settlement word the ONE table

package/dist/core/runner/prepare-acquire-reconcile.d.ts

@@ -75,10 +75,6 @@ export interface PrepareAcquireReconcileResult {
      *  SUCCEEDS (a conflict-losing attempt re-wakes and re-derives the whole set from the fresh
      *  branch), and stays empty for a fresh session / a clean one with nothing to reconcile. */
     wakeRecovered: RecoveredOrphan[];
-    /** owned — §E18 `"before"` mode: the validated target's parentId — the new conversation leaf, and
-     *  the E19 file-anchor walk's starting point (consumed by the rewind-restore block after env
-     *  setup). `null` outside `"before"` mode. */
-    resumeAtBeforeParentId: string | null;
 }
 /** The B-3 phase body — the acquire+reconcile slice, verbatim (see the module header for the contract). */
 export declare function prepareAcquireReconcile(input: PrepareAcquireReconcileInput): Promise<PrepareAcquireReconcileResult>;

package/dist/core/runner/prepare-acquire-reconcile.js

@@ -32,7 +32,6 @@ export async function prepareAcquireReconcile(input) {
     let session;
     let conflictRef;
     let wakeRecovered = [];
-    let resumeAtBeforeParentId = null;
     for (let attempt = 0;; attempt++) {
         try {
             acquired = await sessions.acquire(spec.sessionId, spec.requireExistingSession ? { requireExisting: true } : input.placement !== undefined ? { placement: input.placement } : undefined);
@@ -105,7 +104,6 @@ export async function prepareAcquireReconcile(input) {
                         e.code = "resume_at.before_root_unsupported";
                         throw e;
                     }
-                    resumeAtBeforeParentId = entry.parentId;
                 }
                 await session.getStorage().setLeafId(spec.resumeAtMode === "before" ? entry.parentId : spec.resumeAt);
             }
@@ -123,5 +121,5 @@ export async function prepareAcquireReconcile(input) {
             throw err;
         }
     }
-    return { acquired, session, conflictRef, wakeRecovered, resumeAtBeforeParentId };
+    return { acquired, session, conflictRef, wakeRecovered };
 }

package/dist/core/runner/prepare-file-history.d.ts

@@ -1,6 +1,6 @@
 /**
  * PrepareTask's file-history phase, verbatim from the driver: the DV-14 first-touch
- * policy door, the `RunnerDeps.fileHistoryStore` bad-value door, the retired `rewindFiles` two-sense
+ * policy door, the `RunnerDeps.fileHistoryStore` / `fileHistoryCapture` and `TaskSpec.fileHistory` bad-value doors, the retired `rewindFiles` two-sense
  * split, the restoreFiles / resumeAt / rewindFilesTo combination gates, the run's history coordinates
  * (canonical root, recording scope, filesystem identity), the fork carry, the child-scope refusal, the
  * rewind RESTORE itself (anchor translation in "before" mode, the per-file ledger, partial-restore
@@ -23,12 +23,12 @@ import type { StoredSession } from "../../engine/session/session.js";
 import type { RunnerDeps, TaskResult, TaskSpec, TrackFileEditHook } from "../types.js";
 import type { FileHistoryBoundarySeat, RunInternals } from "./contracts.js";
 export interface PrepareFileHistoryInput {
-    /** borrowed-readonly — the deployment seats this phase reads: the first-touch failure policy and the
-     *  history store (both validated HERE, once), the incident sink, and the retired-epoch diagnostic probe. */
-    deps: Pick<RunnerDeps, "onTrackFailure" | "fileHistoryStore" | "onError">;
-    /** borrowed-readonly — the REBOUND spec's rewind request fields (the retired `rewindFiles` spelling is
-     *  read off the same object as an unknown key) and the caller's cancel signal for the restore. */
-    spec: Pick<TaskSpec, "resumeAt" | "resumeAtMode" | "restoreFiles" | "rewindFilesTo" | "acceptPartialRestore" | "signal">;
+    /** borrowed-readonly — the deployment seats this phase reads: the first-touch failure policy, the history
+     *  store and its capture switch (all validated HERE, once), the incident sink, and the retired-epoch diagnostic probe. */
+    deps: Pick<RunnerDeps, "onTrackFailure" | "fileHistoryStore" | "fileHistoryCapture" | "onError">;
+    /** borrowed-readonly — the REBOUND spec's rewind request fields and off-switch word (the retired `rewindFiles`
+     *  spelling is read off the same object as an unknown key) and the caller's cancel signal for the restore. */
+    spec: Pick<TaskSpec, "resumeAt" | "resumeAtMode" | "restoreFiles" | "rewindFilesTo" | "acceptPartialRestore" | "signal" | "fileHistory">;
     /** borrowed-readonly — the trusted lineage a delegating parent handed this run (absent for a root run
      *  and for a host's own fork), read for the recording-scope decision only. */
     internals: Pick<RunInternals, "fileHistoryLineage"> | undefined;
@@ -41,19 +41,15 @@ export interface PrepareFileHistoryInput {
     handsEnabled: boolean;
     /** borrowed-readonly — the acquired session id: the run's OWN history scope and the restore's session key. */
     sessionId: string;
-    /** borrowed-readonly — the acquired session, read for the fork lineage (`getMetadata`) and the "before"
-     *  anchor walk (`getEntry`); never written here. */
-    session: Pick<StoredSession, "getEntry" | "getMetadata">;
-    /** borrowed-readonly — §E18 "before" mode: the validated target's parentId (the acquire phase's output);
-     *  `null` outside "before" mode. */
-    resumeAtBeforeParentId: string | null;
+    /** borrowed-readonly — the acquired session, read for the fork lineage (`getMetadata`); never written here. */
+    session: Pick<StoredSession, "getMetadata">;
     /** borrowed-readonly — the run's abort controller (driver-minted); only its `signal` is read, composed
      *  with `spec.signal` for the restore. */
     abortController: AbortController;
 }
 export interface PrepareFileHistoryResult {
     /** borrowed-readonly — the hook the hands band calls before every mutation lane; `undefined` when the
-     *  machinery is not live (no store, or no real fs env). */
+     *  run does not record (no store, capture turned off by any layer, or no real fs env). */
     trackFileEdit: TrackFileEditHook | undefined;
     /** borrowed-readonly — the turn-start boundary seat runtask drives; `undefined` when not live or when
      *  this run records into its ROOT session's scope (a child mints no boundaries). */
@@ -64,8 +60,10 @@ export interface PrepareFileHistoryResult {
     /** borrowed-mutable — the non-fatal rewind disclosures (`TaskResult.rewindNotes`). Mutation owners after
      *  this call: none — every push happens inside this phase; the driver only reads it into `Prepared`. */
     rewindNotes: NonNullable<TaskResult["rewindNotes"]>;
-    /** borrowed-readonly — whether the file-history machinery is LIVE for this run (store wired AND hands). */
+    /** borrowed-readonly — whether this run RECORDS file history (store wired, no layer turned capture off, AND hands); restore reads the store seat. */
     fileHistoryEnabled: boolean;
+    /** borrowed-readonly — the manifest's word: `"on"` iff live, else `"disabled"` (whichever layer or missing half). */
+    fileHistoryFact: "on" | "disabled";
     /** borrowed-readonly — the scope this run's first-touch records land in (own session, or the root
      *  session's for a same-tree delegated child). */
     historyScope: string;

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,