@sema-agent/core 7.30.1 → 7.31.1

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

package/dist/core/runner/run-leg.js

@@ -30,7 +30,7 @@ import { nextHumanInputSeq } from "./steer-admission.js";
 import { settleTeardownLeg } from "./teardown-bounded.js";
 import { toolEndBodyFrom, toolResultMsg } from "./tool-end-body.js";
 import { announceListingTruncation } from "../skill-listing-budget.js";
-import { attachmentEnvelopeTags, commitAgentListing, commitSkillsListing, reduceToolEnd, renderAgentListingFrame, renderOrphanedBackgroundTasks, renderSkillsListingFrame, stampWriteAnchor } from "./turn-attachments.js";
+import { attachmentEnvelopeTags, collectDateChange, commitAgentListing, commitSkillsListing, reduceToolEnd, renderAgentListingFrame, renderOrphanedBackgroundTasks, renderSkillsListingFrame, stampWriteAnchor } from "./turn-attachments.js";
 import { flushOwedAnnouncedSnapshot } from "./announce-once-ledger.js";
 import { asThrownError, thrownMarksOf, thrownText } from "../thrown-value.js";
 import { ruleSourcePhrase } from "../rule-denial-sentence.js";
@@ -235,22 +235,6 @@ export async function runLeg(input) {
                         ...ident(),
                     });
                 }
-                if (resume !== undefined)
-                    resume.decisionDelivered = true;
-                if (gitResumeDelivered !== undefined) {
-                    const delivered = gitResumeDelivered;
-                    prepared.gitStatusRef.protectedText = delivered.wrapped;
-                    prepared.frameReceipts.pending.push({
-                        source: "git_status",
-                        text: continuation,
-                        commit: (entryId) => {
-                            prepared.gitStatusRef.announced = { kind: delivered.kind, hash: delivered.hash, entryId };
-                            queue.push({ type: "steering_injected", source: "git_status", preview: GIT_STATUS_ECHO_PREVIEW[delivered.kind], ...ident() });
-                            rs.attach.attachmentsInjected += 1;
-                            prepared.gitStatusRef.mirrorOwed = { kind: delivered.kind, hash: delivered.hash, entryId };
-                        },
-                    });
-                }
                 const pending = resume.cp.pendingAction;
                 const rejectionHalt = pending.kind === "tool_approval" && resume.outcome.gate === "policy_ask"
                     ? maybeHumanRejectionHalt({ gate: resume.outcome.gateOutcome, isDelegatedChild, toolName: pending.toolName, toolCallId: pending.toolCallId })
@@ -258,18 +242,36 @@ export async function runLeg(input) {
                 if (rejectionHalt !== undefined && pending.kind === "tool_approval")
                     prepared.batchHaltRef.current = { rejectedToolCallId: pending.toolCallId };
                 prepared.undeliveredContinuationRef.current = { parkedSteers: resumeFrames.map(({ entry }) => entry).filter((e) => !withheldSteerIds.has(e.inputId)), orphanTasks };
-                final = await withBrainSinks(() => prepared.harness.prompt(continuation, {
-                    engineSegments,
-                    settleUnansweredToolCalls: rejectionHalt !== undefined ? { halt: rejectionHalt } : {},
-                    onDelivered: () => {
-                        prepared.undeliveredContinuationRef.current = { parkedSteers: [], orphanTasks: [] };
-                        for (const e of appliedEvents)
-                            queue.push(e);
-                    },
-                }));
-                await flushGitMirror();
-                if (prepared.gitStatusRef.announced?.pending === true)
-                    await prepared.gitStatusRef.reassert?.();
+                if (!prepared.abortController.signal.aborted) {
+                    if (resume !== undefined)
+                        resume.decisionDelivered = true;
+                    if (gitResumeDelivered !== undefined) {
+                        const delivered = gitResumeDelivered;
+                        prepared.gitStatusRef.protectedText = delivered.wrapped;
+                        prepared.frameReceipts.pending.push({
+                            source: "git_status",
+                            text: continuation,
+                            commit: (entryId) => {
+                                prepared.gitStatusRef.announced = { kind: delivered.kind, hash: delivered.hash, entryId };
+                                queue.push({ type: "steering_injected", source: "git_status", preview: GIT_STATUS_ECHO_PREVIEW[delivered.kind], ...ident() });
+                                rs.attach.attachmentsInjected += 1;
+                                prepared.gitStatusRef.mirrorOwed = { kind: delivered.kind, hash: delivered.hash, entryId };
+                            },
+                        });
+                    }
+                    final = await withBrainSinks(() => prepared.harness.prompt(continuation, {
+                        engineSegments,
+                        settleUnansweredToolCalls: rejectionHalt !== undefined ? { halt: rejectionHalt } : {},
+                        onDelivered: () => {
+                            prepared.undeliveredContinuationRef.current = { parkedSteers: [], orphanTasks: [] };
+                            for (const e of appliedEvents)
+                                queue.push(e);
+                        },
+                    }));
+                    await flushGitMirror();
+                    if (prepared.gitStatusRef.announced?.pending === true)
+                        await prepared.gitStatusRef.reassert?.();
+                }
             }
         }
         else {
@@ -339,6 +341,10 @@ export async function runLeg(input) {
                 }
             }
             const firstFrames = [];
+            const legToday = rs.attach.dateState !== undefined ? prepared.dateChange.today() : undefined;
+            const dateFrame = legToday !== undefined ? collectDateChange(rs.attach.dateState, legToday) : undefined;
+            if (dateFrame !== undefined)
+                firstFrames.push({ source: "date_change", body: dateFrame.body, commit: () => void (rs.attach.dateState.announcedDate = legToday), disclose: () => undefined });
             if (rs.attach.attachState !== undefined) {
                 const attach = rs.attach.attachState;
                 if (rs.attach.agentListingOn && prepared.agentListing !== undefined) {
@@ -350,6 +356,7 @@ export async function runLeg(input) {
                             body: frame.text,
                             commit: () => {
                                 commitAgentListing(attach, listing.entries, listing.models);
+                                prepared.frameReceipts.listingSnapshotOwed = true;
                                 prepared.announcedListingsRef.agents = listing.entries.map((e) => e.name);
                                 if (listing.models !== undefined)
                                     prepared.announcedListingsRef.models = [...listing.models];
@@ -367,15 +374,16 @@ export async function runLeg(input) {
                             body: frame.text,
                             commit: () => {
                                 commitSkillsListing(attach, listing.entries);
+                                prepared.frameReceipts.listingSnapshotOwed = true;
                                 prepared.announcedListingsRef.skills = listing.entries.map((e) => e.name);
                             },
                             disclose: () => announceListingTruncation(runner.deps.onNotice, { listing: "skills", total: frame.listed, nameOnly: frame.nameOnly, dropped: frame.dropped, budget: listing.budget, sessionId: prepared.sessionId }),
                         });
                     }
                 }
-                if (firstFrames.length > 0) {
-                    effectiveObjective = `${firstFrames.map((f) => mintSystemReminder(sanitizeUntrustedText(f.body, attachmentEnvelopeTags(f.source)), prepared.reminderMark)).join("\n")}\n${effectiveObjective}`;
-                }
+            }
+            if (firstFrames.length > 0) {
+                effectiveObjective = `${firstFrames.map((f) => mintSystemReminder(sanitizeUntrustedText(f.body, attachmentEnvelopeTags(f.source)), prepared.reminderMark)).join("\n")}\n${effectiveObjective}`;
             }
             if (composeApprovalPostureDirective(prepared.approvalPosture) !== undefined) {
                 const postureDirective = composeApprovalPostureDirective(prepared.approvalPosture, await statedReminderBodiesOf(prepared.session, prepared.reminderMark));
@@ -451,32 +459,33 @@ export async function runLeg(input) {
                             f.commit();
                             queue.push({ type: "steering_injected", source: f.source, preview: redactThenCut(f.body, 220), ...ident() });
                             rs.attach.attachmentsInjected += 1;
-                            prepared.frameReceipts.listingSnapshotOwed = true;
                             f.disclose();
                         },
                     });
                 }
                 const enginePrefixChars = effectiveObjective.length - projectedObjective.length;
-                queue.push({
-                    ...buildHumanInputEvent({
-                        carrier: "objective",
-                        source: "objective",
-                        delivery: "applied",
-                        sessionSeq: nextHumanInputSeq(prepared.harness),
+                if (!prepared.abortController.signal.aborted) {
+                    queue.push({
+                        ...buildHumanInputEvent({
+                            carrier: "objective",
+                            source: "objective",
+                            delivery: "applied",
+                            sessionSeq: nextHumanInputSeq(prepared.harness),
+                            ...(objectiveActor !== undefined ? { actor: objectiveActor } : {}),
+                            ...(objectiveActor?.issuer !== undefined ? { issuer: objectiveActor.issuer } : {}),
+                            ...(spec.principal !== undefined ? { principal: spec.principal } : {}),
+                        }),
+                        ...ident(),
+                    });
+                    final = await withBrainSinks(() => prepared.harness.prompt(effectiveObjective, {
+                        ...(images && images.length > 0 ? { images } : {}),
+                        ...(enginePrefixChars > 0 ? { enginePrefixChars } : {}),
                         ...(objectiveActor !== undefined ? { actor: objectiveActor } : {}),
-                        ...(objectiveActor?.issuer !== undefined ? { issuer: objectiveActor.issuer } : {}),
-                        ...(spec.principal !== undefined ? { principal: spec.principal } : {}),
-                    }),
-                    ...ident(),
-                });
-                final = await withBrainSinks(() => prepared.harness.prompt(effectiveObjective, {
-                    ...(images && images.length > 0 ? { images } : {}),
-                    ...(enginePrefixChars > 0 ? { enginePrefixChars } : {}),
-                    ...(objectiveActor !== undefined ? { actor: objectiveActor } : {}),
-                }));
-                await flushGitMirror();
-                if (prepared.gitStatusRef.announced?.pending === true)
-                    await prepared.gitStatusRef.reassert?.();
+                    }));
+                    await flushGitMirror();
+                    if (prepared.gitStatusRef.announced?.pending === true)
+                        await prepared.gitStatusRef.reassert?.();
+                }
             }
         }
         loopLatch.ended = true;

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

@@ -19,6 +19,7 @@ import { resumeDecisionWasNegative } from "./decide-continuation.js";
 import { drainForwardedFramesBeforeDone, forwardsSubagentEvents } from "./prepare-run-refs.js";
 import { generatePromptSuggestions } from "./prompt-suggestions.js";
 import { settleTeardownLeg } from "./teardown-bounded.js";
+import { owedDateAnchor } from "./announce-once-ledger.js";
 import { autoRunConsolidationFromRecommendation, autoRunOnRecommendationEffective, scopeHasUnconsumedRecommendation } from "./memory-consolidation-driver.js";
 import { amendTerminal, terminalProjection } from "./terminal-projection.js";
 import { mintCompactedEvent } from "../auto-compaction.js";
@@ -293,6 +294,9 @@ export async function runSettleAndTeardown(input) {
     }
     finally {
         settleOwedUserInput(owedUserInput, !prepared.suspendProgressRef.executedApproved, { taskId: spec.taskId ?? prepared.sessionId, sessionId: prepared.sessionId, runId: prepared.runId }, runner.deps.onNotice);
+        const writeDateAnchor = owedDateAnchor(prepared.session, prepared.dateChange, rs.attach.dateState);
+        if (writeDateAnchor !== undefined)
+            await settleTeardownLeg(writeDateAnchor, "date anchor (settle leg)", (e) => runner.deps.onError?.(e, { phase: "degraded", sessionId: prepared.sessionId }));
         const ownedEnvDying = prepared.ownedEnv !== undefined &&
             hasDestroy(prepared.ownedEnv) &&
             isIsolated(prepared.ownedEnv) &&

package/dist/core/runner/run-turn-boundary.js

@@ -211,7 +211,7 @@ export function createTurnBoundary(input) {
         }
         let boundaryAttachmentBytes = 0;
         let attachmentsPayload;
-        const listingCommits = [];
+        const receiptCommits = [];
         if ((rs.attach.dateState !== undefined ||
             rs.attach.instrState !== undefined ||
             rs.attach.sizeGuidelineState !== undefined ||
@@ -382,7 +382,7 @@ export function createTurnBoundary(input) {
                 if (agentListingDue && due.some((a) => a.source === "agent_listing")) {
                     const listing = prepared.agentListing;
                     const frame = renderAgentListingFrame(attachState, listing.entries, listing.toolName, listing.models, listing.budget);
-                    listingCommits.push({
+                    receiptCommits.push({
                         source: "agent_listing",
                         commit: () => {
                             commitAgentListing(attachState, listing.entries, listing.models);
@@ -397,7 +397,7 @@ export function createTurnBoundary(input) {
                 if (skillsListingDue && due.some((a) => a.source === "skills_listing")) {
                     const listing = prepared.skillsListing;
                     const frame = renderSkillsListingFrame(attachState, listing.entries, listing.budget);
-                    listingCommits.push({
+                    receiptCommits.push({
                         source: "skills_listing",
                         commit: () => {
                             commitSkillsListing(attachState, listing.entries);
@@ -410,12 +410,12 @@ export function createTurnBoundary(input) {
                 if (announcedOnceDirty)
                     prepared.frameReceipts.listingSnapshotOwed = true;
             }
-            if (rs.attach.dateState !== undefined && rs.turn.lastTurnHadToolCalls) {
+            if (rs.attach.dateState !== undefined && rs.turn.lastTurnHadToolCalls && !prepared.frameReceipts.pending.some((r) => r.source === "date_change")) {
                 const today = prepared.dateChange.today();
                 const cand = collectDateChange(rs.attach.dateState, today);
                 if (cand !== undefined) {
                     due.unshift(cand);
-                    rs.attach.dateState.announcedDate = today;
+                    receiptCommits.push({ source: "date_change", commit: () => void (rs.attach.dateState.announcedDate = today) });
                 }
             }
             if (rs.attach.sizeGuidelineState !== undefined && rs.turn.lastTurnHadToolCalls) {
@@ -496,7 +496,7 @@ export function createTurnBoundary(input) {
         }
         if ((attachmentsPayload !== undefined || batchContextBlock !== undefined) && prepared.batchHaltRef.current === undefined) {
             const payload = attachmentsPayload !== undefined && batchContextBlock !== undefined ? `${attachmentsPayload}\n${batchContextBlock}` : (attachmentsPayload ?? batchContextBlock);
-            for (const c of listingCommits)
+            for (const c of receiptCommits)
                 prepared.frameReceipts.pending.push({ source: c.source, text: payload, commit: c.commit });
             void prepared.harness.steer(payload, { engineMinted: true }).catch(() => {
                 prepared.frameReceipts.pending = prepared.frameReceipts.pending.filter((r) => r.text !== payload);

package/dist/core/runner/turn-attachments.d.ts

@@ -309,10 +309,10 @@ export interface AttachmentState {
  * A1-R — the date_change lane's OWN state, deliberately NOT an
  * {@link AttachmentState} member: allocating that for a date-only run would activate the cadence
  * content scan + projection reducers on every non-opted run (the reopen's exact finding). Two
- * fields, zero reducers. `announcedDate` starts at the leg's frozen prefix date; the RUN LOOP
- * commits it (the producer below is pure) — the date block rides ABOVE the 8KB bundle cap as a
- * fixed ~140-byte item, so no clipping face exists and commit-at-append is sound (contrast
- * tools_delta's drain-on-intact, which lives inside the capped bundle).
+ * fields, zero reducers. `announcedDate` starts at the session anchor's announced date; the RUN LOOP
+ * commits it (the producer below is pure) on the carrying message's receipt — the date block rides ABOVE
+ * the 8KB bundle cap as a fixed ~140-byte item, so no clipping face exists (contrast tools_delta's
+ * drain-on-intact, which lives inside the capped bundle).
  */
 export interface DateChangeState {
     announcedDate: string;
@@ -663,11 +663,11 @@ export declare function renderToolSearchUsageReminder(undiscovered: readonly str
 export declare function renderDateChange(newDate: string): string;
 /**
  * A1-R — the date_change producer (CC attachments.ts:1400-1443 parity): the system-prefix
- * date is FROZEN for the leg (upstream: "cached for the duration of the conversation" — re-rendering
+ * date is FROZEN for the session segment (upstream: "cached for the duration of the conversation" — re-rendering
  * the prefix at midnight costs ~920K effective tokens per overnight session, upstream's own comment);
  * when the boundary-time LOCAL date walks away from the last announced one, the model is told at the
  * TAIL instead. String INEQUALITY (backward NTP jumps announce too). PURE — the caller commits
- * `state.announcedDate = today` when it actually appends the attachment (see {@link DateChangeState}).
+ * `state.announcedDate = today` when the carrying message's receipt settles (see {@link DateChangeState}).
  */
 export declare function collectDateChange(state: DateChangeState, today: string): TurnAttachment | undefined;
 /**

package/dist/core/runner-deps.d.ts

@@ -520,7 +520,7 @@ export interface RunnerDeps {
     /**
      * design/381 — the per-edited-file rewind history backend (CC FileHistory topology; replaces the
      * E19 whole-tree `fileSnapshotStore`). WIRING IS THE OPT-IN (DV-9, the reference's own SDK
-     * posture): with a store present, every Edit/Write/NotebookEdit first-touch is backed up before
+     * posture): with a store present (and {@link fileHistoryCapture} not `"off"`), every Edit/Write/NotebookEdit first-touch is backed up before
      * the byte changes, every turn mints a history boundary keyed by its own initial session entry
      * ("file state when this turn began"), and a {@link TaskSpec.resumeAt}+{@link TaskSpec.restoreFiles}
      * (or {@link TaskSpec.rewindFilesTo}) run converges the tracked set back to a boundary. Omitted ⇒
@@ -534,6 +534,8 @@ export interface RunnerDeps {
      * key earns on a filesystem-capable run (`classification: "file-history-no-store"`).
      */
     fileHistoryStore?: import("./file-history-store.js").FileHistoryStore | "disabled";
+    /** The deployment's CAPTURE switch, apart from the store seat: `"off"` (the only word, and only beside a wired store; anything else refuses prepare, `config.invalid_file_history_capture`) ⇒ no run records — no first-touch record, no turn boundary, no fork carry, no liveness advisory, manifest `fileHistory: "disabled"` — while a wired {@link fileHistoryStore} still serves {@link TaskSpec.restoreFiles} / {@link TaskSpec.rewindFilesTo} from what it already holds. */
+    fileHistoryCapture?: "off";
     /**
      * design/381 DV-14 (终审落锤) — what an Edit/Write/NotebookEdit does when its FIRST-TOUCH history
      * record cannot be persisted (`FileHistoryStore.trackEdit` answered `{ok:false}` = NO durable

package/dist/core/secret-env.d.ts

@@ -17,8 +17,9 @@
  * per-adapter concern (each exec env owns how it composes its child env); only the secret PATTERN is shared.
  */
 import type { RedactionConfidence, RedactionSource } from "./arg-summary.js";
+import { type EngineNotice } from "./engine-notice.js";
 /** Which rule classified a key as secret-shaped — the env arm's `kind` vocabulary. */
-export type SecretEnvFindingKind = "suffix-rule" | "exact-name";
+export type SecretEnvFindingKind = "suffix-rule" | "namespace-rule" | "exact-name";
 /** One env entry the `scrub` policy dropped: the key (the VALUE is never carried — this record is meant
  *  to be loggable), the rule that classified it, how strong that claim is, and the minting module. */
 export interface SecretEnvFinding {
@@ -42,3 +43,13 @@ export declare function isSecretEnvKey(key: string): boolean;
  *  dropped and why, read it back after the call. Omitting it leaves this function byte-for-byte what it
  *  was before the channel existed. */
 export declare function scrubSecretEnv(env: NodeJS.ProcessEnv, findings?: SecretEnvFinding[]): NodeJS.ProcessEnv;
+/** Test seam: never called by production code. */
+export declare function __resetSecretEnvScrubNoticeAnnouncement(): void;
+/**
+ * The ONE disclosure point for a scrub's withheld keys. Routed through {@link deliverEngineNotice} — the
+ * engine's one notice throat — so a wired `onNotice` seat REPLACES the console line exactly as every
+ * other `EngineNotice` does, and an absent seat prints the same words `console.warn` always printed here.
+ * `detail.names` carries every withheld key. Once per PROCESS, never per call or per site; an EMPTY
+ * findings array is a no-op.
+ */
+export declare function announceSecretEnvScrub(onNotice: ((notice: EngineNotice) => void) | undefined, findings: readonly SecretEnvFinding[]): void;

package/dist/core/secret-env.js

@@ -1,5 +1,8 @@
+import { deliverEngineNotice } from "./engine-notice.js";
 const TOKEN_COUNT_WORDS = ["MAX", "OUTPUT", "INPUT", "THINKING", "NUM", "TOTAL"];
-const SECRET_ENV_RE = new RegExp(`(^|_)(KEY|KEYS|TOKEN|(?<!(?:^|_)(?:${TOKEN_COUNT_WORDS.join("|")})_)TOKENS|SECRET|SECRETS|PASSWORD|PASSWORDS|PASSWD|CREDENTIAL|CREDENTIALS|PRIVATEKEY|APIKEY|ACCESS_KEY|SESSION_TOKEN)(?:_(?:\\d+|ID))?$`, "i");
+const CREDENTIAL_WORD = `KEY|KEYS|TOKEN|(?<!(?:^|_)(?:${TOKEN_COUNT_WORDS.join("|")})_)TOKENS|SECRET|SECRETS|PASSWORD|PASSWORDS|PASSWD|CREDENTIAL|CREDENTIALS|PRIVATEKEY|APIKEY`;
+const SECRET_ENV_RE = new RegExp(`(^|_)(${CREDENTIAL_WORD})(?:_(?:\\d+|ID))?$`, "i");
+const SEMA_NAMESPACE_SECRET_RE = new RegExp(`^SEMA_(?:.*_)?(?:${CREDENTIAL_WORD})(?:_|$)`, "is");
 const SECRET_ENV_EXACT_NAMES = new Set([
     "DATABASE_URL", "CONNECTION_STRING", "DSN", "NPM_AUTH",
     "PGPASSWORD", "MYSQL_PWD", "SSHPASS", "GPG_PASSPHRASE", "GH_PAT", "GITHUB_PAT",
@@ -7,10 +10,15 @@ const SECRET_ENV_EXACT_NAMES = new Set([
 ]);
 const NON_SECRET_ENV_EXACT_NAMES = new Set([
     "PARTITION_KEY", "SORT_KEY", "RANGE_KEY", "IDEMPOTENCY_KEY", "CACHE_KEY", "ROUTING_KEY",
+    "DB_FOREIGN_KEYS", "JSON_SORT_KEYS",
+    "MAX_NEW_TOKENS", "MAX_COMPLETION_TOKENS", "AIDER_MAP_TOKENS", "AIDER_MAX_CHAT_HISTORY_TOKENS",
+    "MAX_BATCH_PREFILL_TOKENS", "MAX_WAITING_TOKENS", "MAX_TOP_N_TOKENS", "RATE_LIMIT_TOKENS",
+    "PROMPT_TOKENS", "CONTEXT_TOKENS",
 ]);
 const SECRET_ENV_KIND_CONFIDENCE = {
     "exact-name": "high",
     "suffix-rule": "medium",
+    "namespace-rule": "medium",
 };
 export function classifyExactEnvName(key, credentialNames, exemptNames) {
     const upper = key.toUpperCase();
@@ -26,7 +34,9 @@ function classifySecretEnvKey(key) {
         return "exact-name";
     if (byExactName === "exempt")
         return undefined;
-    return SECRET_ENV_RE.test(key) ? "suffix-rule" : undefined;
+    if (SECRET_ENV_RE.test(key))
+        return "suffix-rule";
+    return SEMA_NAMESPACE_SECRET_RE.test(key) ? "namespace-rule" : undefined;
 }
 export function isSecretEnvKey(key) {
     return classifySecretEnvKey(key) !== undefined;
@@ -45,3 +55,18 @@ export function scrubSecretEnv(env, findings) {
     }
     return out;
 }
+let secretEnvScrubNoticeAnnounced = false;
+export function __resetSecretEnvScrubNoticeAnnouncement() {
+    secretEnvScrubNoticeAnnounced = false;
+}
+export function announceSecretEnvScrub(onNotice, findings) {
+    if (findings.length === 0 || secretEnvScrubNoticeAnnounced)
+        return;
+    secretEnvScrubNoticeAnnounced = true;
+    const names = findings.map((f) => f.key);
+    deliverEngineNotice(onNotice, {
+        code: "config.secret_env_scrubbed",
+        message: `secret_env_scrubbed: ${findings.length} env key(s) withheld from a spawned child's environment (${names.join(", ")}) — once per process; wire onNotice for the structured form`,
+        detail: { names },
+    });
+}

package/dist/core/store-contracts/checkpoint-store-contract.d.ts

@@ -50,6 +50,7 @@ export declare const EXPECTED_LISTBYSCOPE_SUMMARIES: ({
     toolCallId: string;
     toolName: string;
     toolInput: string;
+    mandated: boolean;
     origin: string;
     spentMicroUsd?: undefined;
 } | {
@@ -66,5 +67,6 @@ export declare const EXPECTED_LISTBYSCOPE_SUMMARIES: ({
     toolCallId?: undefined;
     toolName?: undefined;
     toolInput?: undefined;
+    mandated?: undefined;
     origin?: undefined;
 })[];

package/dist/core/store-contracts/checkpoint-store-contract.js

@@ -343,6 +343,26 @@ export async function checkpointStoreContract(make, runAssertion) {
         assert.equal("previewWithheld" in byId.get("pw-absent"), false, "absent must project the key OMITTED, not null/empty");
         assert.equal("previewWithheld" in byId.get("pw-bogus"), false, "an out-of-contract spelling must read as absent, never project verbatim");
     });
+    run("#1079 mandated presence bit: a row's `true` survives + projects; absent stays absent; an out-of-contract `false` or string reads as absent", async () => {
+        const store = make();
+        const asserted = createCheckpointFixture({ token: mintCheckpointToken(), sessionId: "md-true" });
+        asserted.pendingAction.mandated = true;
+        const absent = createCheckpointFixture({ token: mintCheckpointToken(), sessionId: "md-absent" });
+        const falsed = createCheckpointFixture({ token: mintCheckpointToken(), sessionId: "md-false" });
+        falsed.pendingAction.mandated = false;
+        const stringed = createCheckpointFixture({ token: mintCheckpointToken(), sessionId: "md-string" });
+        stringed.pendingAction.mandated = "yes";
+        for (const cp of [asserted, absent, falsed, stringed])
+            await store.put(cp.token, cp);
+        const back = (await store.get(asserted.token)).pendingAction;
+        assert.equal(back.mandated, true, "the row's mandated bit must survive the round-trip verbatim");
+        assert.equal("mandated" in (await store.get(absent.token)).pendingAction, false, "an absent bit must stay OMITTED on the row");
+        const byId = new Map((await store.listByScope("tenant-a")).map((s) => [s.sessionId, s]));
+        assert.equal(byId.get("md-true")?.mandated, true);
+        assert.equal("mandated" in byId.get("md-absent"), false, "absent must project the key OMITTED, not null/false");
+        assert.equal("mandated" in byId.get("md-false"), false, "a written false is out-of-contract and must read as absent, never project");
+        assert.equal("mandated" in byId.get("md-string"), false, "a non-boolean spelling must read as absent, never project verbatim");
+    });
     await settle();
 }
 const sortByToken = (a, b) => a.token.localeCompare(b.token);
@@ -367,6 +387,7 @@ export async function checkpointListByScopeSummaries(store) {
         pendingAction: {
             kind: "tool_approval",
             origin: "policy",
+            mandated: true,
             toolCallId: "call-pr",
             toolName: "open_pr",
             args: { repo: "x" },
@@ -406,6 +427,7 @@ export const EXPECTED_LISTBYSCOPE_SUMMARIES = [
         toolCallId: "call-pr",
         toolName: "open_pr",
         toolInput: '{"repo":"x"}',
+        mandated: true,
         origin: "policy",
     },
     {

package/dist/core/task-result.d.ts

@@ -402,7 +402,7 @@ export interface TaskResult {
      * ignores the field is unchanged. A rewind that could NOT be delivered as asked is NOT a note — it is a
      * terminal failure (`rewind_snapshot.unresolvable` / `rewind.store_unconfigured` /
      * `rewind.restore_failed` / `rewind.invalid_spec` / `rewind.rewind_files_retired` /
-     * `rewind.conflicting_targets` / `rewind.child_scope_unsupported`).
+     * `rewind.conflicting_targets` / `rewind.child_scope_unsupported` / `rewind.capture_disabled`).
      *
      * - `conversation_only` — {@link TaskSpec.resumeAt} branched the transcript WITHOUT
      *   {@link TaskSpec.restoreFiles}, so the working tree was deliberately left where it was (CC's