@sema-agent/core 7.30.1 → 7.31.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,6 +17,7 @@
  * 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";
 /** One env entry the `scrub` policy dropped: the key (the VALUE is never carried — this record is meant
@@ -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,3 +1,4 @@
+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 SECRET_ENV_EXACT_NAMES = new Set([
@@ -7,6 +8,10 @@ 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",
@@ -45,3 +50,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

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

@@ -213,12 +213,12 @@ export interface TaskSpec {
      *   that could support this without a second root is a recorded design candidate, not built.)
      *
      * File-history interaction (design/381): with {@link restoreFiles}, the `"before"` file anchor is the
-     * target's OWN entry id first — history boundaries are keyed by a turn's initial entry and mean "file
-     * state when that turn began", so B(target) IS the before-state. When the target carries no boundary
-     * (a mixed-epoch session, or a non-turn-initial target), the anchor falls back to the nearest
-     * boundary-carrying ANCESTOR, so files and context land on the same side of the cut. If no such
-     * boundary exists, prepare fails loud (`rewind_snapshot.unresolvable`) instead of silently leaving
-     * the files at their pre-rewind state while the conversation moved back.
+     * target's OWN entry id — history boundaries are keyed by a turn's initial entry and mean "file state
+     * when that turn began", so B(target) IS the before-state. A target with no boundary of its own (a
+     * steer / follow-up entry, a turn that recorded no history, a mixed-epoch session) refuses at prepare
+     * (`rewind_snapshot.unresolvable`) with the files untouched: an earlier boundary would also revert edits
+     * the conversation keeps, so the anchor never falls back to an ancestor and never crosses into an
+     * earlier turn.
      * Fail-loud: setting this without {@link resumeAt}, or an unknown mode value, rejects at prepare.
      */
     resumeAtMode?: "at" | "before";
@@ -311,6 +311,15 @@ export interface TaskSpec {
         count?: number;
         role?: ModelRole;
     };
+    /**
+     * The per-run OFF SWITCH for file history (`"disabled"`, the only word; `checkpointStore`'s spelling). Omitted ⇒
+     * the deployment (`RunnerDeps.fileHistoryStore` / `fileHistoryCapture`) decides. `"disabled"` ⇒ this run makes no history-store call: no first-touch record
+     * (the edit proceeds), no turn boundary, no fork carry, no liveness advisory; a restore request ({@link restoreFiles}
+     * / {@link rewindFilesTo}) refuses `rewind.capture_disabled` (the store may be wired; the request turned it off).
+     * The manifest reports `fileHistory: "disabled"`. Children inherit it (parent spec seat; a retained child woken by
+     * such a run, for that cycle); no word turns it back on below. Any other value refuses (`rewind.invalid_spec`).
+     */
+    fileHistory?: "disabled";
     /**
      * design/381 (DV-9) — the RESTORE half of file rewind: when this task uses {@link resumeAt} to branch at
      * a prior entry, ALSO converge the working tree's **agent-edited files** (the tracked set — files this
@@ -323,8 +332,8 @@ export interface TaskSpec {
      * Fail-loud: setting this without {@link resumeAt} rejects at prepare (`rewind.invalid_spec`) — a
      * restore with no anchor is a contradiction, not a default.
      *
-     * There is NO capture flag anymore: first-touch tracking is ALWAYS ON whenever a
-     * `RunnerDeps.fileHistoryStore` is wired (per-edited-file backups are near-zero cost — no tree walk,
+     * There is NO capture request anymore: first-touch tracking is ON whenever a `RunnerDeps.fileHistoryStore`
+     * is wired, `RunnerDeps.fileHistoryCapture` is not `"off"`, and no {@link fileHistory} off switch is set (per-edited-file backups are near-zero cost — no tree walk,
      * no size gate), which is what retired the old `rewindFiles` capture request. The retired
      * `rewindFiles` spelling is handled at prepare: its capture sense (true, no `resumeAt`) is a
      * tolerated no-op with a deprecation disclosure (the intent is structurally satisfied); its restore

package/dist/core/tool-spec.d.ts

@@ -752,7 +752,7 @@ export interface ToolExecuteContext {
     parentCwd?: string;
     /**
      * The RUNNING task's file-history LINEAGE (Runner-filled, read-only, never a model/tool argument;
-     * present iff a `RunnerDeps.fileHistoryStore` is live for the run): the history scope this run
+     * present iff the run records file history — a `RunnerDeps.fileHistoryStore` wired, capture not `"off"`, not `"disabled"`): the history scope this run
      * records its first-touch edits into and the TREE those records' keys are minted against — the
      * canonical root spelling plus the env's filesystem identity (`fs`: a remote workspace's handle,
      * `"host"` for the control-plane host's filesystem, else a per-env-instance token).

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

@@ -407,6 +407,14 @@ export interface WiringManifest {
     autoConsolidation?: {
         onRecommendation: true;
     };
+    /**
+     * EFFECTIVE half only, ALWAYS present on an engine-minted effective manifest: does this leg capture file history.
+     * `"on"` — it records (store wired, neither layer declared it off, a filesystem env mounted). `"disabled"` — it does
+     * not, whichever layer or missing half made it so (`TaskSpec.fileHistory`, `RunnerDeps.fileHistoryStore: "disabled"`, `RunnerDeps.fileHistoryCapture: "off"`,
+     * no store, no filesystem env); the host knows its own deployment seat. ABSENT = an older mint or an external
+     * derivation, never a state. Out of {@link configFingerprint}: the request word is a per-task seat (`hooks` reasoning).
+     */
+    fileHistory?: "on" | "disabled";
     /** EFFECTIVE half only — a short, non-sensitive fingerprint (sha256 prefix over the canonical
      *  JSON of this manifest's own resolved facts; every field here is an enum/boolean/count, no
      *  secrets) so an operator can correlate legs that ran under the same resolved assembly. */
@@ -498,6 +506,8 @@ export interface WiringFacts {
     /** Effective half only — `RunnerDeps.autoRunOnRecommendation === true`
      *  ({@link WiringManifest.autoConsolidation}); false ⇒ no section (byte-identical manifest). */
     autoConsolidationOnRecommendation?: boolean;
+    /** Effective half only — the file-history phase's word ({@link WiringManifest.fileHistory}); the engine always passes it. */
+    fileHistory?: "on" | "disabled";
 }
 /** Named view of the deps seats the static half reads (a `Pick` of the real {@link RunnerDeps} —
  *  single-source shapes, no parallel hand-copied interface). */

package/dist/core/wiring-manifest.js

@@ -84,6 +84,11 @@ function readAutoModeFact(fact) {
     }
     return { armed, reason, ...(deniedSource !== undefined ? { deniedSource } : {}) };
 }
+function readFileHistoryFact(word) {
+    if (word !== "on" && word !== "disabled")
+        throw new Error(`the file-history wiring fact ${JSON.stringify(word)} is not one of on|disabled`);
+    return word;
+}
 export function deriveWiringManifest(facts) {
     if (facts.half === "static" && facts.leg !== undefined) {
         throw new Error("a static wiring manifest has no leg — leg identity is an effective-half fact");
@@ -146,13 +151,14 @@ export function deriveWiringManifest(facts) {
             ? { readDeny: { builtinTiers: [...facts.readDenyBuiltinTiersActive] } }
             : {}),
         ...(facts.half === "effective" && facts.autoConsolidationOnRecommendation === true ? { autoConsolidation: { onRecommendation: true } } : {}),
+        ...(facts.half === "effective" && facts.fileHistory !== undefined ? { fileHistory: readFileHistoryFact(facts.fileHistory) } : {}),
         ...(facts.half === "effective" && facts.teamRole !== undefined ? { teamRole: facts.teamRole } : {}),
         ...(facts.half === "effective" && facts.peerPresence !== undefined && (facts.peerPresence.agent !== undefined || facts.peerPresence.intent !== undefined)
             ? { peerPresence: { ...(facts.peerPresence.agent !== undefined ? { agent: facts.peerPresence.agent } : {}), ...(facts.peerPresence.intent !== undefined ? { intent: facts.peerPresence.intent } : {}) } }
             : {}),
     };
     if (facts.half === "effective") {
-        const { leg: _leg, mcp: _mcp, tools: _tools, lsp: _lsp, hooks: _hooks, teamRole: _teamRole, peerPresence: _peerPresence, ...assembly } = manifest;
+        const { leg: _leg, mcp: _mcp, tools: _tools, lsp: _lsp, hooks: _hooks, teamRole: _teamRole, peerPresence: _peerPresence, fileHistory: _fileHistory, ...assembly } = manifest;
         const { provenance: _askSeat, ...askForHash } = assembly.ask;
         const { provenance: _questionSeat, ...questionForHash } = assembly.question;
         manifest.configFingerprint = createHash("sha256")

package/dist/engine/execution-env/node-execution-env.d.ts

@@ -1,5 +1,6 @@
 import { type ExecResult, type ExecutionEnv, ExecutionError, type ExecutionEnvExecOptions, FileError, type FileInfo, type Result } from "../harness/types.js";
 import { type SecretEnvFinding } from "../../core/secret-env.js";
+import type { EngineNotice } from "../../core/engine-notice.js";
 import type { SymlinkChain } from "../harness/types.js";
 import type { BackgroundShellCapability, BackgroundShellId, BackgroundPoll, BackgroundSpawnOptions } from "../../core/background-shell.js";
 import { BackgroundShellError } from "../../core/background-shell.js";
@@ -106,6 +107,7 @@ export declare class NodeExecutionEnv implements ExecutionEnv, BackgroundShellCa
     private bgCounter;
     private readonly retainBackgroundProcesses;
     private readonly onSecretEnvScrub?;
+    private readonly onNotice?;
     /** design/128 T1-1: lazily-created env-owned spool dir (mkdtemp under os tmp — unpredictable, never the cwd). */
     private bgSpoolDir?;
     readonly backgroundCapabilities: BackgroundShellCapability["backgroundCapabilities"];
@@ -135,6 +137,10 @@ export declare class NodeExecutionEnv implements ExecutionEnv, BackgroundShellCa
          *  "scrub" leg withholds from a shell child. Absent ⇒ a once-per-process console summary (loud
          *  enough to notice, quiet enough not to spam). Never called on the "all"/allowlist legs. */
         onSecretEnvScrub?: (findings: readonly SecretEnvFinding[]) => void;
+        /** #1081 — the structured-notice seat for the SAME withheld-keys disclosure (`EngineNotice`,
+         *  `code: "config.secret_env_scrubbed"`, `detail.names`); independent of `onSecretEnvScrub` (a raw
+         *  findings collector) except: that seat wired alone stays console-silent, as before this existed. */
+        onNotice?: (notice: EngineNotice) => void;
     });
     get schedulerCapabilities(): SchedulerCapability["schedulerCapabilities"];
     schedule(intent: ScheduledIntent, ctx: SchedulerContext): Promise<Result<{