@sema-agent/core 7.54.1 → 7.55.0

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

@@ -0,0 +1,77 @@
+import { valveLeaves } from "../../agents/tool-filter.js";
+import { ADVISOR_TOOL_NAME, advisorAttachVerdict, advisorHoldOf, advisorNotAttachedNotice, advisorReasonTold } from "../advisor-verdict.js";
+import { deliverEngineNotice } from "../types.js";
+import { advisorInstructionFrame } from "./advisor-instructions.js";
+import { createAdvisorTool } from "./advisor-tool.js";
+import { announceDigest } from "./announce-once-ledger.js";
+import { conversationSegmentOf } from "./conversation-segment.js";
+import { derivedRouteFallsBack } from "./derived-route-fallback.js";
+import { derivedLegBrain } from "./side-call-account.js";
+import { withBrainCallGuardrail } from "../../brain/timeout.js";
+export async function prepareAdvisor(input) {
+    const { spec, deps, model, onceLedger, sessionId, runId } = input;
+    const told = onceLedger.arms().advisor;
+    if (spec.advisorModel === undefined && told === undefined)
+        return { manifest: undefined, instruction: undefined };
+    const requested = spec.advisorModel === undefined || input.advisorTool === "disabled" ? undefined : typeof spec.advisorModel === "string" ? spec.advisorModel : spec.advisorModel.id;
+    const fact = (f) => ({ ...(requested !== undefined ? { requested } : {}), main: model.id, ...f });
+    const notAttached = (reason, extra = {}) => {
+        if (input.rootLeg && requested !== undefined && advisorReasonTold(reason)) {
+            onceLedger.oncePerSession(announceDigest("advisor.not_attached", `${reason}\n${requested}\n${model.id}`), () => deliverEngineNotice(deps.onNotice, advisorNotAttachedNotice({ reason, advisorModel: requested, mainModel: model.id, sessionId, ...(runId !== undefined ? { runId } : {}) })));
+        }
+        return fact({ state: "not_attached", reason, ...extra });
+    };
+    let branch;
+    const readBranch = async () => (branch ??= await input.session.getBranch().catch(() => undefined));
+    let mounted = false;
+    const mount = async (advisor) => {
+        if ((spec.tools ?? []).some((t) => t.name === ADVISOR_TOOL_NAME)) {
+            const e = new Error(`Tool name "${ADVISOR_TOOL_NAME}" is reserved when TaskSpec.advisorModel attaches the advisor tool.`);
+            e.code = "config.reserved_tool_name";
+            throw e;
+        }
+        if (!valveLeaves(spec, input.selector)({ name: ADVISOR_TOOL_NAME }))
+            return fact({ state: "not_attached", reason: "excluded" });
+        const entries = await readBranch();
+        if (entries === undefined)
+            return notAttached("hold_unknown");
+        const held = advisorHoldOf(entries);
+        if (held !== undefined)
+            return fact({ state: "held", model: advisor.id, hold: held });
+        const route = await derivedRouteFallsBack({ seat: "advisor", derived: advisor, primary: model, brain: deps.brain, getApiKeyAndHeaders: spec.getApiKeyAndHeaders, onNotice: deps.onNotice, sessionId, ...(runId !== undefined ? { runId } : {}), onBrokenPairing: "detach" });
+        if (route.action === "detach")
+            return notAttached("route_refused", { routeCode: route.cause });
+        input.roster.mount(createAdvisorTool(advisorSeat(input, advisor)), { source: "builtin", mountedBy: "optional" });
+        mounted = true;
+        return fact({ state: "on", model: advisor.id });
+    };
+    let manifest;
+    if (spec.advisorModel !== undefined) {
+        const verdict = advisorAttachVerdict({ deps: { ...deps, ...(input.advisorTool !== undefined ? { advisorTool: input.advisorTool } : {}) }, main: model, advisor: spec.advisorModel });
+        manifest = verdict.state === "on" ? await mount(verdict.model) : notAttached(verdict.reason);
+    }
+    const entries = told !== undefined || mounted ? await readBranch() : undefined;
+    if (entries === undefined)
+        return { manifest, instruction: undefined };
+    const segment = conversationSegmentOf(entries);
+    const owed = advisorInstructionFrame(told !== undefined && told.segment === segment ? told.state : undefined, mounted);
+    return { manifest, instruction: { ...(owed !== undefined ? { owed } : {}), segment, mounted } };
+}
+function advisorSeat(input, model) {
+    const book = (lane, m, reply) => {
+        const door = input.sideCallBookRef.book;
+        if (door === undefined)
+            throw new Error("the advisor was consulted before the run body bound the leg's usage account, which it does before any tool call");
+        door(lane, m, reply);
+    };
+    const ms = input.brainCallGuardrailMs;
+    const guarded = (b) => (ms === undefined ? b : { ...b, stream: withBrainCallGuardrail((m, c, o) => b.stream(m, c, o), ms, {}) });
+    return {
+        model,
+        brain: derivedLegBrain(() => guarded(input.deps.brain), "advisor", book),
+        lastSentRequest: input.lastSentRequest,
+        readBranch: () => input.session.getBranch(),
+        getApiKeyAndHeaders: input.spec.getApiKeyAndHeaders,
+        markUsageUnknown: () => book("advisor", model, undefined),
+    };
+}

package/dist/core/runner/prepare-caps-and-workflow.js

@@ -223,7 +223,7 @@ export async function prepareCapsAndWorkflow(input) {
         const am = autoModeFace;
         const classifierSeat = classifierSeatModel({ deps, main: model });
         let classifierModel = classifierSeat.model;
-        if (await derivedRouteFallsBack({ seat: "auto-mode-classifier", derived: classifierModel, primary: model, brain: deps.brain, getApiKeyAndHeaders: spec.getApiKeyAndHeaders, onNotice: deps.onNotice, sessionId, runId, onBrokenPairing: autoModeClassifierFallbackOf(am.classifierFallback) === "none" ? "refuse" : "fall_back" })) {
+        if ((await derivedRouteFallsBack({ seat: "auto-mode-classifier", derived: classifierModel, primary: model, brain: deps.brain, getApiKeyAndHeaders: spec.getApiKeyAndHeaders, onNotice: deps.onNotice, sessionId, runId, onBrokenPairing: autoModeClassifierFallbackOf(am.classifierFallback) === "none" ? "refuse" : "fall_back" })).action === "fall_back") {
             classifierModel = model;
         }
         announceClassifierRoleDefaulted({ onNotice: deps.onNotice, seat: { ...classifierSeat, model: classifierModel }, ...(sessionId !== undefined ? { sessionId } : {}), ...(runId !== undefined ? { runId } : {}) });

package/dist/core/runner/prepare-config-doors.d.ts

@@ -86,7 +86,7 @@ export declare function resolveTaskLimits(limits: TaskLimits | undefined): TaskL
  */
 export declare function resolveAttachmentsConfig(attachments: TaskSpec["attachments"]): TaskSpec["attachments"];
 /**
- * R2 双形轴(追加令 2026-07-18): CC 2.1.212's fable-variant prompt gate (b9e —
+ * R2 双形轴(追加令 2026-07-18): the reference's fable-variant prompt gate (
  * `fable_5_mitigations` capability / claude-mythos-5), ORTHOGONAL to the simple/classic profile.
  * sema is BYOM, so the id may carry provider prefixes ("anthropic/claude-fable-5",
  * "openrouter/anthropic/claude-fable-5"): BOUNDARY-AWARE family match on the last path segment
@@ -99,8 +99,8 @@ export declare function isFableFamilyModelId(id: string): boolean;
  * The SINGLE decision point for the two prompt-shape axes.
  * Both were resolved in separate places with different mechanisms — `promptProfile` off a TaskSpec field,
  * `fableMitigations` off a raw model-id prefix test — so "which shape does this task speak" had no one
- * place to read. CC 2.1.220's counterpart is a model-registry `capabilities` array (one table drives
- * `lean_prompt` + `fable_5_mitigations` alike; anchors/2.1.220/CC-218-220-DIFF.md §2).
+ * place to read. The reference's counterpart is a model-registry `capabilities` array (one table drives
+ * `lean_prompt` + `fable_5_mitigations` alike).
  *
  * sema stays BYOM: we cannot key off a capability table for arbitrary model ids, so the RESOLUTION RULES
  * are unchanged — profile: spec > inherited internals > "simple"; mitigations: model family. This is a
@@ -213,6 +213,7 @@ export interface PrepareConfigDoorsResult {
     brainCallGuardrailMs: number | undefined;
     /** owned — the screened cross-boundary posture: the deps seat read ONCE, a bad value refused; absent stays `undefined` (undeclared is its own fact). */
     crossBoundaryPosture: CrossBoundaryPosture | undefined;
+    advisorTool: "disabled" | undefined;
 }
 /** The microCompact knob door (坏值响亮度默认律, the sibling knob doors' form:
  *  interactionPosture / toolModelGate / staleToolResultOffload). Placement is load-bearing:
@@ -237,12 +238,13 @@ export declare const checkpointStoreSeat: (spec: {
 export declare function assertResumeConfigRecord(config: unknown): void;
 /** The spec the value doors read: a prepare's (its roster is faces) or a resume's re-supplied config (no objective, no session id). */
 type ValueDoorSpec = Omit<TaskSpec, "tools" | "objective" | "sessionId" | "userAttachments"> & Partial<Pick<TaskSpec, "objective" | "sessionId">>;
-type ConfigValueDoorsResult = Pick<PrepareConfigDoorsResult, "toolFaceLists" | "promptHost" | "promptBinding" | "lockedPreflight" | "microCompactKnob" | "memoryDelegationEvidence" | "memoryProvenance" | "memoryCapturePolicy" | "usageWindows" | "brainCallGuardrailMs" | "crossBoundaryPosture"> & {
+type ConfigValueDoorsResult = Pick<PrepareConfigDoorsResult, "toolFaceLists" | "promptHost" | "promptBinding" | "lockedPreflight" | "microCompactKnob" | "memoryDelegationEvidence" | "memoryProvenance" | "memoryCapturePolicy" | "usageWindows" | "brainCallGuardrailMs" | "crossBoundaryPosture" | "advisorTool"> & {
     skillListingSeats: {
         fraction: unknown;
         maxDescChars: unknown;
     };
     skills: TaskSpec["skills"];
+    projectMemory: TaskSpec["projectMemory"];
 };
 /**
  * The phase's VALUE doors as ONE function with two callers — each judges a declared value against its own vocabulary, reading only the

package/dist/core/runner/prepare-config-doors.js

@@ -18,6 +18,7 @@ import { assertRetentionCapability } from "../retention.js";
 import { resolveModel, resolveTaskModel, roleModelIfSet } from "../roles.js";
 import { resolveSkillListingBudget } from "../skill-listing-budget.js";
 import { describeRejectedValue } from "../tool-search-setting.js";
+import { assertAdvisorModelShape } from "../advisor-verdict.js";
 import { applyToolModelGate, assertRestoreGatedToolsValue, modelIdTail } from "../tool-model-gate.js";
 import { resolveUsageWindows } from "../usage-window-store.js";
 import { deriveAskEffective, resolveAskSeat, resolveQuestionSeam, screenApprovalReach } from "../wiring-manifest.js";
@@ -155,7 +156,7 @@ function resolveClearOnRejection(bag) {
     }
     return declared ?? true;
 }
-function deploymentWord(raw, seat, words, absent, code, why) {
+function closedWord(raw, seat, words, absent, code, why) {
     if (raw === undefined)
         return absent;
     const word = words.find((w) => w === raw);
@@ -163,7 +164,7 @@ function deploymentWord(raw, seat, words, absent, code, why) {
         return word;
     const got = typeof raw === "string" ? JSON.stringify(raw.length > 64 ? `${raw.slice(0, 64)}…` : raw) : raw === null ? "null" : Array.isArray(raw) ? "an array" : typeof raw;
     const spelled = words.map((w) => `"${w}"`);
-    throw limitConfigError(code, `RunnerDeps.${seat} must be ${spelled.slice(0, -1).join(", ")} or ${spelled.at(-1)} when present (got ${got}) — ${why}`);
+    throw limitConfigError(code, `${seat} must be ${spelled.length > 1 ? `${spelled.slice(0, -1).join(", ")} or ` : ""}${spelled.at(-1)} when present (got ${got}) — ${why}`);
 }
 export const checkpointStoreSeat = (spec) => (spec.checkpointStore !== undefined ? "taskConfig" : "deps");
 export function assertResumeConfigRecord(config) {
@@ -231,10 +232,14 @@ export function configValueDoors(input, enter = ENTER_AS_IS) {
     enter("taskConfig", () => assertContainmentFaceValue(spec.writeFace, "write", "spec"));
     enter("deps", () => assertContainmentFaceValue(deps.writeFace, "write", "deps"));
     enter("taskConfig", () => assertAddOnlySeats(spec));
-    const memoryDelegationEvidence = enter("deps", () => deploymentWord(deps.memoryDelegationEvidence, "memoryDelegationEvidence", ["static-face", "attested-only"], "static-face", "config.memory_delegation_evidence", "an unevaluable evidence standard is refused loudly, never folded to either standard."));
-    const memoryProvenance = enter("deps", () => deploymentWord(deps.memoryProvenance, "memoryProvenance", ["off", "carry"], "carry", "config.memory_provenance", "an unevaluable provenance mode is refused loudly, never folded to either mode."));
-    const memoryCapturePolicy = enter("deps", () => deploymentWord(deps.memoryCapturePolicy, "memoryCapturePolicy", ["open", "governed", "capture-required"], "open", "config.memory_capture_policy", "an unevaluable capture posture is refused loudly, never folded to any posture (the fault arms differ per posture, so a guess would pick a polarity nobody configured)."));
-    const crossBoundaryPosture = enter("deps", () => deploymentWord(deps.crossBoundaryPosture, "crossBoundaryPosture", CROSS_BOUNDARY_POSTURES, undefined, "config.cross_boundary_posture", "an unevaluable posture is refused loudly, never folded to either word (an absent seat is undeclared, which is its own fact)."));
+    const memoryDelegationEvidence = enter("deps", () => closedWord(deps.memoryDelegationEvidence, "RunnerDeps.memoryDelegationEvidence", ["static-face", "attested-only"], "static-face", "config.memory_delegation_evidence", "an unevaluable evidence standard is refused loudly, never folded to either standard."));
+    const memoryProvenance = enter("deps", () => closedWord(deps.memoryProvenance, "RunnerDeps.memoryProvenance", ["off", "carry"], "carry", "config.memory_provenance", "an unevaluable provenance mode is refused loudly, never folded to either mode."));
+    const memoryCapturePolicy = enter("deps", () => closedWord(deps.memoryCapturePolicy, "RunnerDeps.memoryCapturePolicy", ["open", "governed", "capture-required"], "open", "config.memory_capture_policy", "an unevaluable capture posture is refused loudly, never folded to any posture (the fault arms differ per posture, so a guess would pick a polarity nobody configured)."));
+    const crossBoundaryPosture = enter("deps", () => closedWord(deps.crossBoundaryPosture, "RunnerDeps.crossBoundaryPosture", CROSS_BOUNDARY_POSTURES, undefined, "config.cross_boundary_posture", "an unevaluable posture is refused loudly, never folded to either word (an absent seat is undeclared, which is its own fact)."));
+    const advisorTool = enter("deps", () => closedWord(deps.advisorTool, "RunnerDeps.advisorTool", ["disabled"], undefined, "config.advisor_tool_invalid", "the switch has one word; anything else is refused, never read as either state."));
+    if (advisorTool === undefined)
+        enter("taskConfig", () => assertAdvisorModelShape(spec.advisorModel));
+    const projectMemory = enter("taskConfig", () => closedWord(spec.projectMemory, "TaskSpec.projectMemory", ["disabled"], undefined, "config.invalid_argument", "the switch has one word; omit the key to leave the deployment's project context in force."));
     enter("deps", () => assertAutoConsolidationWirable(deps));
     if (spec.resumeAtMode !== undefined)
         enter("taskConfig", () => {
@@ -317,7 +322,7 @@ export function configValueDoors(input, enter = ENTER_AS_IS) {
     }));
     if (taskStore !== undefined)
         enter("taskConfig", () => assertRetentionCapability({ ...retention, stores: [{ name: "checkpointStore", store: taskStore }] }));
-    return { toolFaceLists, promptHost, promptBinding, lockedPreflight, skillListingSeats, skills, microCompactKnob, memoryDelegationEvidence, memoryProvenance, memoryCapturePolicy, usageWindows, brainCallGuardrailMs, crossBoundaryPosture };
+    return { toolFaceLists, promptHost, promptBinding, lockedPreflight, skillListingSeats, skills, projectMemory, microCompactKnob, memoryDelegationEvidence, memoryProvenance, memoryCapturePolicy, usageWindows, brainCallGuardrailMs, crossBoundaryPosture, advisorTool };
 }
 export function refuseResumeDoors(config, recordedGate, deps, sessions) {
     asResumeConfigRefusal("taskConfig", () => {
@@ -336,8 +341,9 @@ export function prepareConfigDoors(input) {
     const { deps, sessions, resume, internals } = input;
     assertToolBoundaryLegs(input.spec.tools);
     let spec = input.spec;
-    const { toolFaceLists, promptHost, promptBinding, lockedPreflight, skillListingSeats, skills, microCompactKnob, memoryDelegationEvidence, memoryProvenance, memoryCapturePolicy, usageWindows, brainCallGuardrailMs, crossBoundaryPosture } = configValueDoors({ spec, deps, resumeLeg: resume !== undefined, sessions });
-    spec = Object.create(Object.getPrototypeOf(spec), { ...Object.getOwnPropertyDescriptors(spec), skills: { value: skills, enumerable: skills !== undefined, writable: false, configurable: false } });
+    const { toolFaceLists, promptHost, promptBinding, lockedPreflight, skillListingSeats, skills, projectMemory, microCompactKnob, memoryDelegationEvidence, memoryProvenance, memoryCapturePolicy, usageWindows, brainCallGuardrailMs, crossBoundaryPosture, advisorTool } = configValueDoors({ spec, deps, resumeLeg: resume !== undefined, sessions });
+    const doorRead = (value) => ({ value, enumerable: value !== undefined, writable: false, configurable: false });
+    spec = Object.create(Object.getPrototypeOf(spec), { ...Object.getOwnPropertyDescriptors(spec), skills: doorRead(skills), projectMemory: doorRead(projectMemory) });
     const promptProfile = resolveModelPromptTraits({ id: "" }, spec, internals).promptProfile;
     const resolvedInteractionPosture = spec.interactionPosture ?? internals?.parentInteractionPosture ?? deps.interactionPosture;
     const askSeat = resolveAskSeat(spec, deps);
@@ -459,8 +465,8 @@ export function prepareConfigDoors(input) {
         discardedEnvRaw: gateDecision.discardedEnvRaw,
     });
     const thinking = spec.thinking ?? resolvedRole.thinking ?? model.defaultThinking;
-    const compModel = spec.compactionModel
-        ? resolveModel(spec.compactionModel, deps.models)
+    const compModel = spec.compactionModel !== undefined
+        ? resolveModel(spec.compactionModel, deps.models, "TaskSpec.compactionModel")
         : roleModelIfSet("summarize", spec, deps);
     return {
         spec,
@@ -481,7 +487,7 @@ export function prepareConfigDoors(input) {
         memoryDelegationEvidence,
         skillListingBudget,
         memoryProvenance,
-        memoryCapturePolicy, crossBoundaryPosture,
+        memoryCapturePolicy, crossBoundaryPosture, advisorTool,
         usageWindows,
         brainCallGuardrailRef,
         brainCallGuardrailMs,

package/dist/core/runner/prepare-delegation-surface.d.ts

@@ -32,9 +32,9 @@ export interface PrepareDelegationSurfaceInput {
      *  `handsReadOnly` is NOT read here (the hands mount decided the surface). Never mutated. */
     spec: Pick<TaskSpec, "tools" | "oneShot" | "retainBackgroundProcesses" | "excludeAllTools">;
     /** borrowed-readonly — the deployment seats the mounts read: `workflowRunStore` / `backgroundAgentStore` / `mailboxStore` (the
-     *  read/kill faces and the tier-3 revival seams), `rosterStore`, `peerLane`, `peerDirectory`, `onNotice`,
+     *  read/kill faces and the tier-3 revival seams), `rosterStore`, `peerLane`, `peerDirectory`, `peerChannel`, `onNotice`,
      *  `onBackgroundChildEvent`, `tracer`. */
-    deps: Pick<RunnerDeps, "workflowRunStore" | "backgroundAgentStore" | "mailboxStore" | "rosterStore" | "peerLane" | "peerDirectory" | "principalInboxConsumer" | "onNotice" | "onBackgroundChildEvent" | "tracer">;
+    deps: Pick<RunnerDeps, "workflowRunStore" | "backgroundAgentStore" | "mailboxStore" | "rosterStore" | "peerLane" | "peerDirectory" | "peerChannel" | "principalInboxConsumer" | "onNotice" | "onBackgroundChildEvent" | "tracer">;
     /** borrowed-readonly — the trusted spawn-side channel: `parentNotify` (the delegated-child door), the uplink / sibling /
      *  identity seats the SendMessage mount forwards, `onTaskNotification`, `onSubagentSpawn`. Never mutated. */
     internals: Pick<RunInternals, "parentNotify" | "parentPeerRef" | "uplinkSessionId" | "parentRetainLedger" | "explicitAgentName" | "parentTaskId" | "parentSessionId" | "peerSelfRef" | "peerInboundChainRef" | "onTaskNotification" | "onSubagentSpawn"> | undefined;

package/dist/core/runner/prepare-delegation-surface.js

@@ -56,7 +56,7 @@ export function prepareDelegationSurface(input) {
                 ...(deps.backgroundAgentStore !== undefined ? { agentStore: deps.backgroundAgentStore } : {}),
                 ...(deps.mailboxStore !== undefined ? { mailbox: deps.mailboxStore } : {}),
                 ...(reviveSpawn !== undefined ? { reviveSpawn } : {}),
-                ...(peerLaneActive ? peerLaneSendMessageSeats({ peerDirectory: deps.peerDirectory, sessionId, scope: taskScope, ...(internals?.explicitAgentName !== undefined ? { name: internals.explicitAgentName } : {}), refs: peerLaneRefs, listingMounted: listAgentsMountable({ leaves, specTools: spec.tools ?? [] }) }) : {}),
+                ...(peerLaneActive ? peerLaneSendMessageSeats({ peerDirectory: deps.peerDirectory, ...(deps.peerChannel !== undefined ? { peerChannel: deps.peerChannel } : {}), sessionId, scope: taskScope, ...(internals?.explicitAgentName !== undefined ? { name: internals.explicitAgentName } : {}), refs: peerLaneRefs, listingMounted: listAgentsMountable({ leaves, specTools: spec.tools ?? [] }) }) : {}),
                 onNotifyError: (f) => emitTrace(deps.tracer, () => ({ kind: "observer.notify_failed", version: 1, taskId: hostTaskId, site: f.site, message: f.error.message, ts: Date.now() })),
                 onTranscriptIntegrityGap: (handle, scope) => deliverEngineNotice(deps.onNotice, {
                     code: "delegation.transcript_integrity",

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

@@ -1,6 +1,8 @@
 import { NodeExecutionEnv } from "../../engine/execution-env/node-execution-env.js";
 import { isRemoteExecutionEnv } from "../remote-env.js";
-import { resolveTrackKey } from "../file-history-store.js";
+import { FILE_HISTORY_ERROR_CODES, FileHistoryStoreError, resolveTrackKey } from "../file-history-store.js";
+import { readMember, thrownText } from "../thrown-value.js";
+import { isGovernanceRetryClass } from "../governance-codes.js";
 export async function prepareFileHistory(input) {
     const { deps, spec, request, internals, executionEnv, taskRootFinal, handsEnabled, sessionId, session, abortController } = input;
     const rewindNotes = [];
@@ -45,12 +47,8 @@ export async function prepareFileHistory(input) {
     }
     let restoredFilePaths = [];
     if (rewindTarget !== undefined && fileHistoryStore !== undefined && handsEnabled) {
-        const historyStore = fileHistoryStore;
-        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 restored = await fileHistoryStore.restore(sessionId, rewindTarget, executionEnv, historyRoot, 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") {
@@ -62,6 +60,8 @@ export async function prepareFileHistory(input) {
             }
             const e = new Error(`rewind-files restore failed (${restored.error?.code ?? "restore_failed"}): ${restored.error?.message ?? "unknown"} — ledger: ${ledgerLine(restored)}`);
             e.code = "rewind.restore_failed";
+            if (restored.error !== undefined)
+                e.detail = { code: restored.error.code, ...(isGovernanceRetryClass(restored.error.permanence) ? { permanence: restored.error.permanence } : {}) };
             throw e;
         }
         if (restored.outcome === "partial") {
@@ -77,22 +77,22 @@ export async function prepareFileHistory(input) {
                 throw e;
             }
         }
-        restoredFilePaths = restoredAbsPathsOf(restored, restoreRoot);
+        restoredFilePaths = restoredAbsPathsOf(restored, historyRoot);
     }
     const trackFileEdit = fileHistoryEnabled
         ? async (req) => {
-            const r = await fileHistoryStore.trackEdit(historyScope, req.key, executionEnv, historyRoot, req.signal);
+            const r = await answerOf(() => fileHistoryStore.trackEdit(historyScope, req.key, executionEnv, historyRoot, req.signal), "track_failed");
             if (r.ok) {
                 if (!r.minted)
                     return { ok: true };
                 return {
                     ok: true,
                     annul: async (proof) => {
-                        const a = await fileHistoryStore.annulTrack(historyScope, req.key, historyRoot, proof === "verify" ? { env: executionEnv, ...(req.signal !== undefined ? { signal: req.signal } : {}) } : undefined);
+                        const a = await answerOf(() => fileHistoryStore.annulTrack(historyScope, req.key, historyRoot, proof === "verify" ? { env: executionEnv, ...(req.signal !== undefined ? { signal: req.signal } : {}) } : undefined), "track_failed");
                         if (a.ok)
                             return;
                         try {
-                            deps.onError?.(new Error(`file-history could not retract the first-touch record for "${req.key}" after its edit failed to land (${a.error.code}: ${a.error.message}) — the path stays tracked, so a rewind to a boundary below it may converge bytes this engine never wrote`), { phase: "rewind", sessionId });
+                            deps.onError?.(new FileHistoryStoreError(a.error, `file-history could not retract the first-touch record for "${req.key}" after its edit failed to land (${a.error.code}: ${a.error.message}) — the path stays tracked, so a rewind to a boundary below it may converge bytes this engine never wrote`, "thrown" in a ? a.thrown : undefined), { phase: "rewind", sessionId });
                         }
                         catch {
                         }
@@ -101,16 +101,14 @@ export async function prepareFileHistory(input) {
             }
             if (onTrackFailure === "proceed-unprotected") {
                 try {
-                    deps.onError?.(new Error(`file-history first-touch backup for "${req.key}" failed (${r.error.code}: ${r.error.message}) — proceeding UNPROTECTED per RunnerDeps.onTrackFailure: the pristine promise for this path is void, and only in this process's memory (no durable trace exists, so after a process restart the next edit can still mint already-modified bytes as pristine v1)`), { phase: "rewind", sessionId });
+                    deps.onError?.(new FileHistoryStoreError(r.error, `file-history first-touch backup for "${req.key}" failed (${r.error.code}: ${r.error.message}) — proceeding UNPROTECTED per RunnerDeps.onTrackFailure: the pristine promise for this path is void, and only in this process's memory (no durable trace exists, so after a process restart the next edit can still mint already-modified bytes as pristine v1)`, "thrown" in r ? r.thrown : undefined), { phase: "rewind", sessionId });
                 }
                 catch {
                 }
                 return { ok: true };
             }
-            return {
-                ok: false,
-                refusal: `Error (${req.tool}): the edit was refused because its first-touch file-history backup could not be persisted (${r.error.code}: ${r.error.message}). Proceeding would leave "${req.path}" with no durable pristine record — after the history store recovers, a retried edit would mint already-modified bytes as the pristine baseline. Retry when the file-history store is healthy.`,
-            };
+            const lead = r.error.permanence === "terminal" ? "The history store reports this failure as permanent: do not retry this edit until the store is fixed." : "Retry when the file-history store is healthy.";
+            return { ok: false, refusal: `Error (${req.tool}): the edit was refused because its first-touch file-history backup could not be persisted (${r.error.code}). ${lead} Proceeding would leave the file with no durable pristine record. ${r.error.message}` };
         }
         : undefined;
     const fileHistoryBoundary = fileHistoryEnabled && historyScope === sessionId
@@ -147,6 +145,21 @@ function toldAlready(sink, arm) {
     return false;
 }
 const FILE_HISTORY_CARRY_MEMO = new WeakMap();
+function answerOf(call, code) {
+    const unanswered = (message, thrown) => ({ ok: false, error: { code, message }, ...(thrown === undefined ? {} : { thrown }) });
+    return Promise.resolve().then(call).then((r) => {
+        const ok = readMember(r, "ok");
+        if (ok === true)
+            return { ok: true, minted: readMember(r, "minted") === true };
+        const error = readMember(r, "error"), stated = readMember(error, "code"), message = readMember(error, "message"), permanence = readMember(error, "permanence");
+        if (ok !== false || typeof stated !== "string")
+            return unanswered("the history store answered something that is not a result");
+        const text = typeof message === "string" ? message : "(the history store gave no message)", known = FILE_HISTORY_ERROR_CODES.find((c) => c === stated);
+        if (known === undefined)
+            return unanswered(`the history store answered a code outside the closed set (${JSON.stringify(stated)}): ${text}`);
+        return { ok: false, error: { code: known, message: text, ...(isGovernanceRetryClass(permanence) ? { permanence } : {}) } };
+    }, (value) => unanswered(`the history store threw: ${thrownText(value)}`, { value }));
+}
 async function adoptForkedFileHistory(store, session, sessionId, onError) {
     const memo = FILE_HISTORY_CARRY_MEMO.get(store) ?? { settled: new Set(), disclosed: new Set(), inFlight: new Map() };
     FILE_HISTORY_CARRY_MEMO.set(store, memo);
@@ -156,6 +169,7 @@ async function adoptForkedFileHistory(store, session, sessionId, onError) {
         memo.disclosed.add(sessionId);
         onError?.(err, { phase: "rewind", sessionId });
     };
+    const threw = (err) => new FileHistoryStoreError({ code: "adopt_failed" }, `file-history fork carry could not run: ${thrownText(err)} — the parent's history was not carried into this session (the run itself proceeds)`, { value: err });
     try {
         if (memo.settled.has(sessionId))
             return;
@@ -167,13 +181,13 @@ async function adoptForkedFileHistory(store, session, sessionId, onError) {
             return await shared;
         if (memo.settled.has(sessionId))
             return;
-        const attempt = store.adoptScope(forkedFrom, sessionId).then((carried) => {
+        const attempt = answerOf(() => store.adoptScope(forkedFrom, sessionId), "adopt_failed").then((carried) => {
             if (carried.ok || carried.error.code === "conflict") {
                 memo.settled.add(sessionId);
                 return;
             }
-            discloseOnce(new Error(`file-history fork carry from session "${forkedFrom}" failed (${carried.error.code}): ${carried.error.message} — this forked session starts with an EMPTY rewind history, so boundaries recorded before the fork are not restorable from it (the run itself proceeds; the carry is retried on this session's next turn while its scope is still empty)`));
-        }, (err) => discloseOnce(err));
+            discloseOnce(new FileHistoryStoreError(carried.error, `file-history fork carry from session "${forkedFrom}" failed (${carried.error.code}): ${carried.error.message} — the parent's history was not carried, so boundaries recorded before the fork are not restorable from this session (the run itself proceeds; the carry is retried on this session's next turn)`, "thrown" in carried ? carried.thrown : undefined));
+        });
         memo.inFlight.set(sessionId, attempt);
         try {
             await attempt;
@@ -184,7 +198,7 @@ async function adoptForkedFileHistory(store, session, sessionId, onError) {
     }
     catch (err) {
         try {
-            discloseOnce(err);
+            discloseOnce(threw(err));
         }
         catch {
         }
@@ -206,30 +220,16 @@ function createFileHistoryBoundarySeat(opts) {
                     resolve({ ok: false });
                 }, FILE_HISTORY_BOUNDARY_TIMEOUT_MS);
             });
-            let work;
-            try {
-                work = opts.store.snapshot(opts.sessionId, entryId, opts.env, opts.root, ac.signal);
-            }
-            catch (err) {
-                work = Promise.resolve({ ok: false, error: { code: "snapshot_failed", message: `history store threw synchronously: ${err.message}` } });
-            }
-            work.catch(() => { });
+            const work = answerOf(() => opts.store.snapshot(opts.sessionId, entryId, opts.env, opts.root, ac.signal), "snapshot_failed");
+            const disclose = (failure, what, thrown) => new FileHistoryStoreError(failure, `file-history ${what} — this turn has no boundary and cannot be rewound to (the turn itself proceeds)`, thrown);
             inFlight = Promise.race([
-                work.then((r) => (r.ok ? undefined : `boundary capture failed (${r.error.code}): ${r.error.message}`)),
-                timeout.then(() => `boundary capture timed out after ${FILE_HISTORY_BOUNDARY_TIMEOUT_MS / 1000}s (fenced — the attempt can never publish)`),
+                work.then((r) => (r.ok ? undefined : disclose(r.error, `boundary capture failed (${r.error.code}): ${r.error.message}`, "thrown" in r ? r.thrown : undefined))),
+                timeout.then(() => disclose({ code: "aborted" }, `boundary capture timed out after ${FILE_HISTORY_BOUNDARY_TIMEOUT_MS / 1000}s (fenced — the attempt can never publish)`)),
             ])
                 .then((failure) => {
-                if (failure !== undefined) {
-                    try {
-                        opts.onError?.(new Error(`file-history ${failure} — this turn has no boundary and cannot be rewound to (the turn itself proceeds)`), { phase: "rewind", sessionId: opts.sessionId });
-                    }
-                    catch {
-                    }
-                }
-            })
-                .catch((err) => {
                 try {
-                    opts.onError?.(err, { phase: "rewind", sessionId: opts.sessionId });
+                    if (failure !== undefined)
+                        opts.onError?.(failure, { phase: "rewind", sessionId: opts.sessionId });
                 }
                 catch {
                 }

package/dist/core/runner/prepare-gate-stations.d.ts

@@ -34,7 +34,7 @@ import type { InheritedToolCheck, LegModBus } from "../mods/stations.js";
 import { type HookEnvCapabilities, type HookInvocationIdentity } from "../hooks.js";
 import type { ToolPolicy } from "../tool-policy.js";
 import { type GateOutcome } from "../gate-outcome.js";
-import type { RunnerDeps, TaskSpec, ToolEffect } from "../types.js";
+import type { RunnerDeps, TaskSpec } from "../types.js";
 import { type WiringManifest } from "../wiring-manifest.js";
 import type { WriteProtectionCheck } from "../write-protect.js";
 import type { ShellReadCheck } from "../../tools/fs/shell-read-check.js";
@@ -82,9 +82,6 @@ export interface PrepareGateStationsInput {
     tools: readonly AgentTool[];
     /** borrowed-readonly — the leg's delta seat: its current roster is the face source for every gated call. */
     toolRosterDeltas: ToolRosterDeltaSeat;
-    /** borrowed-mutable — the effect collection. Writer here: the final-roster sync fills MISSING entries from each
-     *  first-party tool's declared effect (never overrides a scanned one); the plan-mode deny reads it per call. */
-    toolEffects: Map<string, ToolEffect>;
     /** borrowed-readonly — the deployment seats these stations read, as a Pick over the SAME `deps` object (receiver
      *  preserved for `deps.onError?.()`): the write-protection table and its data root, the tracer, the error face, and
      *  the notice sink (the gate's unresolvable-ask exit delivers `delegation.ask_unresolvable` through it). */

package/dist/core/runner/prepare-gate-stations.js

@@ -10,7 +10,7 @@ import { askUnresolvableNotice } from "../ask-unresolvable-notice.js";
 import { approvalRouteOf } from "../wiring-manifest.js";
 import { classifierUnavailableSeat } from "./classifier-ladder.js";
 import { PATH_CONFINABLE_WRITE_TOOLS } from "./session-rule-policy.js";
-import { callFaceSeat, rosterToolName, survivorsByName, toolCallFaceOf } from "../tool-roster.js";
+import { callFaceSeat, rosterToolName, toolCallFaceOf } from "../tool-roster.js";
 import { heldBy, heldValues, seatOf, wireOf } from "../tool-name-readings.js";
 import { createApprovedCallScreen, createToolResultStation } from "./call-hook-stations.js";
 const PEER_MESSAGE_NAMES = new Set([SEND_MESSAGE_TOOL_NAME]);
@@ -46,7 +46,7 @@ export function maybeHumanRejectionHalt(input) {
     };
 }
 export function prepareGateStations(input) {
-    const { askLane, parkAsk, tools, toolRosterDeltas, toolEffects, deps, toolCallGateArmedRef, effectivePolicy, egressTools, irreversibleTools, spec, complianceDenies, harness, blockedToolCalls, inheritedAskGrants, inheritedUnavailableAsks, foldAskClasses, ancestorSandboxAdmissions, preToolContexts, toolOccurrences, batchHaltRef, blockedTracked, hookIdentity, reminderMark, hostTaskId, sessionId, handsCwdRef, stampCallTarget, hookEnvFace, writeProtectionCheck, shellReadCheck, crossBoundaryCheck, readFace, irreversibilityTier, reversibilityProbes, abortController, shellGatedTools, autoModeDecider, autoModeDenialTracking, askRoute, permissionMode, toolMarkSources, a2aIsolatePeers, ancestorArbitrations, runId, stopForDenialLimit, permissionRuleLane, permissionRuleOrgLane, questionToolMounted, sandboxAdmissionArmed, sandboxBoundaryCapable, emitSandboxAdmitted, delegation, frameSettlement, seatInputsFor, modBus, inheritedToolChecks } = input;
+    const { askLane, parkAsk, tools, toolRosterDeltas, deps, toolCallGateArmedRef, effectivePolicy, egressTools, irreversibleTools, spec, complianceDenies, harness, blockedToolCalls, inheritedAskGrants, inheritedUnavailableAsks, foldAskClasses, ancestorSandboxAdmissions, preToolContexts, toolOccurrences, batchHaltRef, blockedTracked, hookIdentity, reminderMark, hostTaskId, sessionId, handsCwdRef, stampCallTarget, hookEnvFace, writeProtectionCheck, shellReadCheck, crossBoundaryCheck, readFace, irreversibilityTier, reversibilityProbes, abortController, shellGatedTools, autoModeDecider, autoModeDenialTracking, askRoute, permissionMode, toolMarkSources, a2aIsolatePeers, ancestorArbitrations, runId, stopForDenialLimit, permissionRuleLane, permissionRuleOrgLane, questionToolMounted, sandboxAdmissionArmed, sandboxBoundaryCapable, emitSandboxAdmitted, delegation, frameSettlement, seatInputsFor, modBus, inheritedToolChecks } = input;
     const releasesAnnounced = new Map();
     const onModeReleased = (info) => {
         const table = info.readUnestablished === true ? input.readDenyInForce(info.toolCallId) : undefined;
@@ -72,11 +72,6 @@ export function prepareGateStations(input) {
     if (askLane !== undefined && parkAsk !== undefined) {
         const { adjudicate, resolveAskBound, notifyPermissionDenied, notifyHookError } = askLane;
         const { resolveContentAsk, suspendAsk } = parkAsk;
-        for (const t of survivorsByName(tools).values()) {
-            const eff = t.effect;
-            if (eff !== undefined && !toolEffects.has(t.name))
-                toolEffects.set(t.name, eff);
-        }
         const writeProtectionArmed = writeProtectionCheck !== undefined && tools.some((t) => PATH_CONFINABLE_WRITE_TOOLS.has(t.name));
         toolCallGateArmedRef.armed =
             effectivePolicy !== undefined ||

package/dist/core/runner/prepare-inherited-gate.d.ts

@@ -43,7 +43,7 @@ import { type ChildClampSource } from "../child-clamp-seats.js";
 import type { LockedPreflight } from "../locked-config.js";
 import type { OwnOrgAdmissionVerdict } from "../memory-admission.js";
 import type { DelegationContentSafety } from "../memory-engine/delegation-provenance.js";
-import { type SessionPermissionRules } from "../session-policy-store.js";
+import type { SessionPermissionRules } from "../session-policy-store.js";
 import type { SessionStore } from "../session.js";
 import { type OnAsk, type ToolPolicy } from "../tool-policy.js";
 import type { PathRuleBases } from "../permission-rule-model.js";
@@ -228,9 +228,10 @@ export interface PrepareInheritedGateResult {
     orgGovernedProvenance: boolean;
     /** owned — the operator's shell floor in force (the spec's, or the chain's); undefined = no floor. */
     effectiveShellGate: ShellGateDoctrine | undefined;
-    /** borrowed-mutable — THIS task's own session-rule snapshot for its children's chain. Writers (R-3): the policy-chain
-     *  station's session-policy read, once per leg, when a store is wired and the task carries its own sessionId. Read by
-     *  `inheritedGateForChildren` at spawn time. */
+    /** borrowed-mutable — THIS task's own session-rule snapshot for its children's chain: present iff the leg enforces its
+     *  own session-rule layer (a store is wired and the task carries its own sessionId), from prepare on. Writer (R-3): the
+     *  policy-chain station — the layer's seed (the empty rev-0 row when the session has none), then each row it comes to
+     *  enforce. Read by `inheritedGateForChildren` at spawn time. */
     ownSessionRulesRef: {
         current?: {
             sessionId: string;

package/dist/core/runner/prepare-inherited-gate.js

@@ -4,7 +4,7 @@ import { parentSpecSeatOf } from "../parent-spec-seat.js";
 import { createPreToolUseConstraintPolicy } from "../hooks.js";
 import { chainJudges, sameInstallation } from "../mods/stations.js";
 import { childClampSeats, clampSourceOf } from "../child-clamp-seats.js";
-import { continuesLineage } from "../session-policy-store.js";
+import { rowFollowsFloor } from "./session-rule-policy.js";
 import { StubExecutionEnv } from "../stub-env.js";
 import { durableMandateSourceOf } from "../tool-policy.js";
 import { chainAnchorRecords } from "./child-tree.js";
@@ -30,8 +30,8 @@ export function prepareInheritedGate(input) {
             return [...seedRules];
         const merged = seedRules.map((s) => {
             const live = liveRules.find((l) => l.sessionId === s.sessionId && l.principal === s.principal);
-            const sameLineage = live === undefined || continuesLineage(live, s);
-            return live !== undefined && sameLineage && live.rev >= s.rev ? live : s;
+            const follows = live !== undefined && rowFollowsFloor(live, s);
+            return follows && live.rev >= s.rev ? live : s;
         });
         const extras = liveRules.filter((l) => !seedRules.some((s) => s.sessionId === l.sessionId && s.principal === l.principal));
         return [...merged, ...extras];

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

@@ -5,13 +5,13 @@ import { Value } from "typebox/value";
 import { classifyQuestionOutcome, validateAskQuestions } from "../ask-question.js";
 import { hasBackgroundShell, sweepBackgroundShells, sweepRunBoundaryBackgroundShells } from "../background-shell.js";
 import { boundInputHashOf, exactBoundInputHashOf } from "../canonical-json.js";
-import { unencodableIn } from "../checkpoint-requirements.js";
-import { buildRiskDescriptor, debitLedger, encodeAtFidelity, mintCheckpointId, mintCheckpointToken, resolveDeclaredFidelity, samePlainValue, } from "../checkpoint-store.js";
+import { buildRiskDescriptor, debitLedger, encodeAtFidelity, mintCheckpointId, mintCheckpointToken, resolveDeclaredFidelity, } from "../checkpoint-store.js";
 import { pauseOf } from "../pause-registry.js";
+import { samePlainValue } from "../same-plain-value.js";
 import { askCarryRowMembers } from "../hooks.js";
 import { askMandateMember, ownedClearanceFacts } from "../ask-origin.js";
 import { defaultTaskRegistry } from "../task-registry.js";
-import { advertisedWritableRootsSeat, exemptRootsSeat, isLiveApproverSeat, licenseCovers, carriesBidiControls, describeThrown, ownArgs, refuseOutOfContractDecision, tryCloneArgs } from "../tool-policy.js";
+import { advertisedWritableRootsSeat, bindableArgsOf, exemptRootsSeat, isLiveApproverSeat, licenseCovers, carriesBidiControls, describeThrown, ownArgs, refuseOutOfContractDecision, tryCloneArgs } from "../tool-policy.js";
 import { InMemoryToolResultStore, ScopedToolResultStore, isVolatileOffloadStore } from "../tool-result-store.js";
 import { raceAbort, raceSettlementAgainstSignal } from "./abort-race.js";
 import { CONTENT_ASK_BINDING_CAP } from "./content-ask-bindings.js";
@@ -146,12 +146,12 @@ export function prepareParkAsk(input) {
                         `a durable approval row must hold an inert snapshot of exactly what a human approves and a resume executes`, { cause: captured.cause });
                 }
                 const parkedArgs = captured.value;
-                const unencodable = unencodableIn(parkedArgs, "pendingAction.args");
-                if (unencodable !== undefined)
-                    throw new ParkRefusal(`the arguments of "${req.toolName}" cannot be bound into the approval row's digest (${unencodable.kind} at ${unencodable.path}) — a durable approval row must hold an inert snapshot of exactly what a human approves and a resume executes`);
+                const bindable = bindableArgsOf(req.toolName, parkedArgs);
+                if (!bindable.ok)
+                    throw new ParkRefusal(bindable.refusal);
                 const parkedHash = exactBoundInputHashOf(parkedArgs);
                 if (parkedHash === undefined)
-                    throw new ParkRefusal(`the arguments of "${req.toolName}" hold a value no exact digest binds — no approval row can be bound to them`);
+                    throw new ParkRefusal(`the canonical form of the arguments of "${req.toolName}" cannot be built — no approval row can be bound to them`);
                 const projectionMovedArgs = backendFidelity !== "structured-clone" && !samePlainValue(parked.value, parkedArgs);
                 if (projectionMovedArgs && basePolicyForResumeEdit === undefined) {
                     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 ` +

package/dist/core/runner/prepare-policy-chain.d.ts

@@ -177,7 +177,7 @@ export interface PreparePolicyChainInput {
     /** borrowed-readonly — the injectable wall-clock (the inherited arms' human-wait timing). */
     now: () => number;
     /** borrowed-mutable — the own session-rules snapshot seat (the inherited-gate phase mints it; `inheritedGateForChildren`
-     *  reads it late). Writer: THIS phase, once, when the store returns this task's own rules. */
+     *  reads it late). Writer: THIS phase — the own layer's seed at prepare, then each row the layer comes to enforce. */
     ownSessionRulesRef: {
         current?: {
             sessionId: string;

package/dist/core/runner/prepare-policy-chain.js

@@ -55,7 +55,7 @@ export async function preparePolicyChain(input) {
             for (const g of nameGroups) {
                 for (const [kind, list] of [["deny", g.deny], ["ask", g.ask], ["allow", g.allow]]) {
                     for (const n of list ?? []) {
-                        const verdict = judgeRuleToolName(n, known);
+                        const verdict = judgeRuleToolName(n, known, kind);
                         const twin = verdict.kind === "current" && !inherited ? nearMissSpellingOf(n, rootFacing) : undefined;
                         const stale = verdict.kind !== "current" ? verdict : twin !== undefined ? { kind: "case_twin", twin, carrier: known.has(twin) || callerNames.has(twin) ? "run" : pool.names.has(twin) ? "pool" : "catalog" } : undefined;
                         if (stale !== undefined) {
@@ -85,7 +85,7 @@ export async function preparePolicyChain(input) {
                         }
                         if (known.has(n))
                             continue;
-                        if (isNamespacedCoveringRuleName(n) && [...known].some((k) => namespacedRuleNameCovers(n, k)))
+                        if (isNamespacedCoveringRuleName(n, kind) && [...known].some((k) => namespacedRuleNameCovers(n, k)))
                             continue;
                         unmatched.add(`"${n}" (${kind})`);
                     }
@@ -138,8 +138,7 @@ export async function preparePolicyChain(input) {
             };
         };
         sessionRulePolicy = createSessionRulePolicy({ seed, read: createLiveSessionRules(store, { ...sessionRuleKey, seed }, { onUnreadable: announceSessionRulesUnreadable, onEnforced: publishOwnRules }) }, { env: executionEnv, rootPath: taskRootFinal, toolEffects, anchors: pathRuleAnchors.leg, onEarlierGrammar: announceEarlierGrammar(sessionRuleKey.sessionId) });
-        if (rules)
-            publishOwnRules(rules);
+        publishOwnRules(seed);
     }
     const ancestorRulePolicies = [];
     for (const [position, snap] of (inheritedAncestorRules ?? []).entries()) {
@@ -153,12 +152,7 @@ export async function preparePolicyChain(input) {
                 rules: row,
             });
         };
-        ancestorRulePolicies.push(createSessionRulePolicy({
-            seed,
-            ...(deps.sessionPolicyStore
-                ? { read: createLiveSessionRules(deps.sessionPolicyStore, { sessionId: snap.sessionId, ...(snap.principal !== undefined ? { principal: snap.principal } : {}), seed }, { onUnreadable: announceSessionRulesUnreadable, onEnforced: publishAncestorRules }) }
-                : {}),
-        }, { env: executionEnv, rootPath: taskRootFinal, toolEffects, anchors: pathRuleAnchors.leg, onEarlierGrammar: announceEarlierGrammar(snap.sessionId) }));
+        ancestorRulePolicies.push(createSessionRulePolicy({ seed, read: createLiveSessionRules(deps.sessionPolicyStore, { sessionId: snap.sessionId, ...(snap.principal !== undefined ? { principal: snap.principal } : {}), seed }, { onUnreadable: announceSessionRulesUnreadable, onEnforced: publishAncestorRules }) }, { env: executionEnv, rootPath: taskRootFinal, toolEffects, anchors: pathRuleAnchors.leg, onEarlierGrammar: announceEarlierGrammar(snap.sessionId) }));
     }
     const frozenConstraintLayers = (seedInheritedGate?.constraintChain ?? [])
         .filter((e) => !("opaque" in e))