@sema-agent/core 7.54.1 → 7.55.0

package/dist/core/runner/prepare-project-context.d.ts

@@ -13,8 +13,9 @@ export interface PrepareProjectContextInput {
     deps: Pick<RunnerDeps, "loadProjectMemory" | "onError" | "sharedMemoryStores" | "onNotice" | "allowedTools">;
     /** borrowed-readonly — the REBOUND spec (`spec′`). Read: `sessionId` (phase derivation + the
      *  continuation projections), `skills` (the roster), `userInvokedSkills` (the person's invoked skills — their
-     *  rows are written here), `principal` (the shared-memory tools' trusted identity). Never mutated. */
-    spec: Pick<TaskSpec, "sessionId" | "skills" | "userInvokedSkills" | "principal" | "excludeAllTools">;
+     *  rows are written here), `principal` (the shared-memory tools' trusted identity), `projectMemory` (the request's
+     *  off switch for the seam — the config door's one reading). Never mutated. */
+    spec: Pick<TaskSpec, "sessionId" | "skills" | "userInvokedSkills" | "principal" | "excludeAllTools" | "projectMemory">;
     /** borrowed-readonly — trusted internals: `agentName` (seam ctx), `inheritedSkillGrants` (the parent's captured
      *  skill grant rows, seeded as `inherited`), `inheritedAllowedTools` (the parent's request entries, seeded as this leg's
      *  own). `undefined` on a standalone prepare. */
@@ -95,6 +96,8 @@ export interface PrepareProjectContextResult {
         path: string;
         contentHash: string | null;
     }> | undefined;
+    /** owned — `"on"` iff this phase called the deployment's seam, `"disabled"` the request turned a wired one off, `"absent"` none is wired. */
+    projectMemoryFact: NonNullable<import("../wiring-manifest.js").WiringManifest["projectMemory"]>;
     /** owned — the RAW snapshot text (pre-compose) for the compaction lanes' instruction-file seat
      *  (`Prepared.projectInstructionContent`). */
     projectInstructionContent: string | undefined;

package/dist/core/runner/prepare-project-context.js

@@ -22,7 +22,10 @@ export async function prepareProjectContext(input) {
     let memoryBlock = memoryBlockFromEngine;
     let instructionSources;
     let projectInstructionContent;
-    if (deps.loadProjectMemory) {
+    const seam = deps.loadProjectMemory;
+    const loadProjectMemory = seam && spec.projectMemory === undefined ? seam : undefined;
+    const projectMemoryFact = loadProjectMemory ? "on" : seam ? "disabled" : "absent";
+    if (loadProjectMemory) {
         let projectMemoryPhase = spec.sessionId ? "resume" : "fresh";
         if (spec.sessionId) {
             try {
@@ -47,7 +50,7 @@ export async function prepareProjectContext(input) {
         }
         let loaded = null;
         try {
-            loaded = await Promise.resolve(deps.loadProjectMemory({
+            loaded = await Promise.resolve(loadProjectMemory.call(deps, {
                 cwd: taskRootFinal,
                 handsEnabled,
                 isSubagent: delegation.isNonForkChild,
@@ -158,5 +161,5 @@ export async function prepareProjectContext(input) {
                 ?
                     { entries: [], seedAnnounced: true, budget: skillListingBudget }
                 : undefined;
-    return { memoryBlock, instructionSources, projectInstructionContent, skillSpecs, skillSeatOf, skillsListing, sharedMemoryPairMounted, memoryEnginePairMounted };
+    return { memoryBlock, instructionSources, projectMemoryFact, projectInstructionContent, skillSpecs, skillSeatOf, skillsListing, sharedMemoryPairMounted, memoryEnginePairMounted };
 }

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

@@ -3,7 +3,7 @@ import { sugarOverlays } from "../../prompt-assembly/sugar.js";
 import { valveLeaves } from "../../agents/tool-filter.js";
 import { instructionsTaught, toldAtStart } from "../mounted-mcp.js";
 import { isIsolated } from "../remote-env.js";
-import { readDateAnchor } from "./announce-once-ledger.js";
+import { readDateAnchor } from "./conversation-segment.js";
 import { probeGitStatusLane } from "./git-status-frame.js";
 import { renderMcpInstructionsEntry } from "./turn-attachments.js";
 const ULTRA_REASONING_TIERS = new Set(["xhigh", "max"]);

package/dist/core/runner/prepare-protocol-tools.d.ts

@@ -38,8 +38,8 @@ export interface PrepareProtocolToolsInput {
     lockedPreflight: Pick<LockedPreflight, "mcp" | "a2a">;
     /** borrowed-readonly — the REBOUND spec. Read: `principal` (the MCP header / the A2A identity), `tools`
      *  (the caller names both reserved-name guards check against), `excludeAllTools` (the valve's whole-face switch: the live roster lane's
-     *  reading, and the first-dial gate). */
-    spec: Pick<TaskSpec, "principal" | "tools" | "excludeAllTools">;
+     *  reading, and the first-dial gate), `signal` (the host's abort, which stops an MCP dial). */
+    spec: Pick<TaskSpec, "principal" | "tools" | "excludeAllTools" | "signal">;
     /** borrowed-readonly — the deployment seats the materializers and their operator faces read: `onElicit`
      *  and `mcpImageResizer` ride into the MCP intake; `onError` takes the A2A warnings (no ledger — a peer is
      *  re-read every prepare); `mcpRevocations` + `onNotice` make the revocation wiring. */

package/dist/core/runner/prepare-protocol-tools.js

@@ -7,7 +7,7 @@ import { materializeA2aTools } from "../a2a.js";
 import { deliverEngineNotice } from "../types.js";
 import { RosterBuilder } from "../tool-roster.js";
 import { TOOL_WIRE_NAME_MAX_CHARS } from "../tool-face.js";
-import { REFRESH_MCP_TOOLS_TOOL_NAME, toolFace } from "../tool-catalog-entries.js";
+import { REFRESH_MCP_TOOLS_TOOL_NAME, mountRuleFace, toolFace } from "../tool-catalog-entries.js";
 import { MCP_NAMESPACE, A2A_NAMESPACE } from "../protocol-table.js";
 import { mintNamespacePrefix } from "../protocol-naming.js";
 import { applyMcpToolFaces } from "./tool-face-overlay.js";
@@ -30,7 +30,7 @@ export async function prepareProtocolTools(input) {
     const leaves = valveLeaves(spec, toolFaceSnapshot.selector);
     const resourcesReached = resourceFacesLeft(leaves);
     const mcp = lockedPreflight.mcp?.length
-        ? await materializeMcpTools(lockedPreflight.mcp, spec.principal, deps.onElicit, deps.mcpImageResizer, { reminderMark, counts: reminderDisclosureCounts }, mcpRevocationWiring(deps, runId), mcpPool === undefined ? undefined : { pool: mcpPool.pool, ownsPool: mcpPool.owned }, sectionDisposerOf(input.modBus, abortController.signal), (entry) => resourcesReached || serverReached(mintNamespacePrefix(MCP_NAMESPACE, entry.name)))
+        ? await materializeMcpTools(lockedPreflight.mcp, spec.principal, deps.onElicit, deps.mcpImageResizer, { reminderMark, counts: reminderDisclosureCounts }, mcpRevocationWiring(deps, runId), mcpPool === undefined ? undefined : { pool: mcpPool.pool, ownsPool: mcpPool.owned }, sectionDisposerOf(input.modBus, abortController.signal), (entry) => resourcesReached || serverReached(mintNamespacePrefix(MCP_NAMESPACE, entry.name)), AbortSignal.any([abortController.signal, ...(spec.signal !== undefined ? [spec.signal] : [])]))
         :
             { tools: [], toolAxes: [], warnings: [], serverInstructions: [], instructionsDelta: { pendingAdds: [], pendingRemovals: [] }, droppedTools: [], statuses: [], refresh: async () => [], reconnect: async (server) => ({ server, prefix: mintNamespacePrefix(MCP_NAMESPACE, server), outcome: "not_declared", reason: "this task declared no MCP servers", toolCount: 0, added: [], removed: [] }), dispose: async () => { } };
     if (lockedPreflight.mcp?.length)
@@ -81,6 +81,7 @@ export async function prepareProtocolTools(input) {
     if (lockedPreflight.mcp?.length) {
         roster.mount({
             ...toolFace("refresh-mcp-tools"),
+            ...{ ruleFace: mountRuleFace("refresh-mcp-tools") },
             name: REFRESH_MCP_TOOLS_TOOL_NAME,
             label: REFRESH_MCP_TOOLS_TOOL_NAME,
             description: "Refresh the tool list of connected MCP servers. Never dials or re-dials connections — it only re-reads the tool list over the existing connection. The refreshed tools are available immediately; you can call them on your next step. Use when a server's expected tool is missing, or the tool list looks stale after a connection recovered. Omit `server` to refresh every connected server.",

package/dist/core/runner/prepare-safety-scan.d.ts

@@ -1,7 +1,7 @@
 import type { RunnerDeps, ToolEffect } from "../types.js";
 import type { IrreversibilityTier, ReversibilityProbes } from "./contracts.js";
 import type { ToolMarkSource } from "../ask-origin.js";
-import type { RosterSpec } from "./caller-roster.js";
+import { type RosterSpec } from "./caller-roster.js";
 export interface PrepareSafetyScanInput {
     /** borrowed-readonly — the REBOUND spec (`spec′`, the config-doors result). The scan reads
      *  `tools`, `handsReadOnly` and `enablePlanMode`; it never mutates. Typed as a spec whose roster is snapshot faces. */
@@ -16,22 +16,19 @@ export interface PrepareSafetyScanInput {
  * The six collections are **borrowed-mutable**: the driver and later phases fold into them IN
  * PLACE (identity is part of the contract — closures alias these exact objects). Mutation owners
  * after this phase, in driver order:
- *  · the workflow mount (registers the run-workflow tool's write effect);
- *  · the MCP/A2A materialize fold + the runtime refresh seam (protocol-axis tighten registration;
+ *  · the roster builder (`toolEffects`: every mount and unmount; the aliases' axes on a non-caller mount and on an unmount);
+ *  · the MCP/A2A materialize fold + the runtime refresh seam (protocol-axis tighten registration and a protocol tool's effect;
  *    on refresh, `toolEffects.delete` resets a replaced tool's effect record for the fresh fold —
  *    the irreversible/egress sets deliberately KEEP their entries, the tighten-only residue);
- *  · the hands/read-face block's shellGate fold (Bash/Monitor tier escalation + probe seeding);
- *  · the background-task / Monitor / worktree mounts (fixed-name effect registration);
- *  · the prepare-final effect sync (fills MISSING entries from the final tool set — never
- *    overrides a scanned value).
+ *  · the hands/read-face block's shellGate fold (Bash/Monitor tier escalation + probe seeding).
  */
 export interface PrepareSafetyScanResult {
-    /** borrowed-mutable — per-tool effect registry (alias-complete), the path-policy / gate read. This scan writes the caller tools'
-     *  own declarations (the roster's kept instance); every engine effect arrives with its tool's mount, never by name beforehand. Open
-     *  defect #2107 (7.55.0, design ticket): a selector that keeps a caller instance under a name and unmounts only the engine's leaves the engine's entry. */
+    /** borrowed-mutable — per-tool effect registry (alias-complete), the path-policy / gate read. Minted EMPTY here: the roster
+     *  builder writes every entry, a caller tool's included, from the member that answers to the name after each mount or unmount. */
     toolEffects: Map<string, ToolEffect>;
-    /** owned, read once — the wake reconcile's reading (`wakeEffectsOf`): `toolEffects` as this scan leaves it, with every catalog
-     *  definition this leg may still mount (`engineCandidatesOf`) folded in as a candidate. Built before any mount; no later phase writes it. */
+    /** owned, read once — the wake reconcile's reading (`wakeEffectsOf`): the caller tools' own declarations (each name's kept
+     *  instance, each alias's first claimer), with every catalog definition this leg may still mount (`engineCandidatesOf`) folded
+     *  in as a candidate. Built before any mount; no later phase writes it. */
     wakeEffects: Map<string, ToolEffect>;
     /** borrowed-mutable — egress-marked tools (external writes; the gate never auto-allows them). */
     egressTools: Set<string>;

package/dist/core/runner/prepare-safety-scan.js

@@ -2,6 +2,7 @@ import { callerToolNameProblem } from "../caller-tool-name.js";
 import { describeToolCatalog } from "../tool-registry.js";
 import { callerCardIdOf, rosterMemberBoundProblem, schemaKeyBoundProblem, survivorsByName } from "../tool-roster.js";
 import { toolFaceProblem } from "./tool-face-overlay.js";
+import { callerEngineContractProblem } from "./caller-roster.js";
 const REPEAT_RISK = { read: 0, idempotent: 1, write: 2 };
 const leastRepeatSafe = (a, b) => (REPEAT_RISK[a] >= REPEAT_RISK[b] ? a : b);
 function engineCandidatesOf(spec, deps) {
@@ -31,7 +32,7 @@ function wakeEffectsOf(table, claimed, candidates) {
 const tierOf = (t) => t.irreversibility ?? (t.reversibilityProbe ? "maybe" : undefined);
 export function prepareSafetyScan(input) {
     const { spec, deps } = input;
-    const toolEffects = new Map();
+    const declared = new Map();
     const survivors = survivorsByName(spec.tools ?? []);
     const claimedAliases = new Set();
     const aliasClaims = [];
@@ -55,7 +56,7 @@ export function prepareSafetyScan(input) {
                 aliases: t.aliases,
                 ...(t.contract !== undefined ? { contractId: t.contract.contractId, implementationRevision: t.contract.implementationRevision } : {}),
                 ...(typeof t.modelGate === "string" ? { modelGate: t.modelGate } : {}),
-            });
+            }) ?? callerEngineContractProblem(t);
             if (bound !== undefined) {
                 const e = new Error(`A caller tool cannot ride a roster row: ${bound.message}.`);
                 e.code = bound.code;
@@ -72,6 +73,7 @@ export function prepareSafetyScan(input) {
             const declared = {
                 ...(t.family !== undefined ? { family: t.family } : {}),
                 ...(t.pathTarget !== undefined ? { pathTarget: t.pathTarget } : {}),
+                ...(t.hostTarget !== undefined ? { hostTarget: t.hostTarget } : {}),
                 ...(t.ruleFace !== undefined ? { ruleFace: t.ruleFace } : {}),
                 ...(t.renderHints !== undefined ? { renderHints: t.renderHints } : {}),
             };
@@ -91,7 +93,7 @@ export function prepareSafetyScan(input) {
             throw e;
         }
         if (t.effect && survivors.get(t.name) === t) {
-            toolEffects.set(t.name, t.effect);
+            declared.set(t.name, t.effect);
         }
         const tier = tierOf(t);
         if (tier !== undefined) {
@@ -125,7 +127,7 @@ export function prepareSafetyScan(input) {
                 continue;
             claimedAliases.add(alias);
             if (t.effect)
-                toolEffects.set(alias, t.effect);
+                declared.set(alias, t.effect);
             if (engineNames.has(alias))
                 continue;
             if (tier !== undefined) {
@@ -144,8 +146,8 @@ export function prepareSafetyScan(input) {
         }
     }
     return {
-        toolEffects,
-        wakeEffects: wakeEffectsOf(toolEffects, [...claimedAliases, ...survivors.keys()], [...aliasClaims, ...candidates]),
+        toolEffects: new Map(),
+        wakeEffects: wakeEffectsOf(declared, [...claimedAliases, ...survivors.keys()], [...aliasClaims, ...candidates]),
         egressTools,
         irreversibleTools,
         irreversibilityTier,

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

@@ -22,8 +22,10 @@ import { recordedModeSeed } from "../checkpoint-store.js";
 import { emitTrace } from "../trace.js";
 import { personPathRowsOfTask, ruleRowsDroppedNotice, ruleStoreUnreadableNotice } from "./person-path-rows.js";
 import { STALL_FIRST_BYTE_MS, STALL_FIRST_TOKEN_MS, STALL_IDLE_MS, withBrainCallGuardrail } from "../../brain/timeout.js";
+import { judgeExtraBody } from "../../brain/request-params.js";
 import { OFFLOAD_TOOL_NAME } from "../tool-result-store.js";
-import { OUTPUT_TOOL_NAME, SKILL_TOOL_NAME, createOutputTool } from "./synthetic-tools.js";
+import { SKILL_TOOL_NAME, createOutputTool } from "./synthetic-tools.js";
+import { OUTPUT_TOOL_NAME } from "../tool-catalog-entries.js";
 import { compileSkillGrant, skillGateWiring } from "../skill-grant.js";
 import { legCallTargetStamp, validatePath } from "../effective-path-target.js";
 import { AllowEntryTable, screenAllowedToolsValue } from "../allow-entry.js";
@@ -72,6 +74,7 @@ import { checkpointScopeOf, placementValueOrAbsent } from "./checkpoint-scope.js
 export { DEFAULT_IRREVERSIBLE_SCOPE, checkpointScopeOf, placementValueOrAbsent } from "./checkpoint-scope.js";
 export { mcpManifestEntries } from "./prepare-wiring-manifest.js";
 import { derivedRouteFallsBack } from "./derived-route-fallback.js";
+import { prepareAdvisor } from "./prepare-advisor.js";
 import { prepareProtocolTools } from "./prepare-protocol-tools.js";
 import { prepareQuestionFace } from "./prepare-question-face.js";
 import { prepareLsp } from "./prepare-lsp.js";
@@ -311,13 +314,9 @@ export async function prepareTask(request, deps, sessions, resume, internals, ru
     refuseRequireExistingWithoutSession(spec);
     refuseRegistryScopeMismatch(spec, internals);
     const ownToolLists = boundOwnToolLists(internals?.ownToolLists ?? resume?.seed.ownToolLists, toolFaceLists);
-    if (model.extraBody !== undefined && Object.prototype.hasOwnProperty.call(model.extraBody, "max_completion_tokens")) {
-        const e = new Error(`model.extraBody supplies "max_completion_tokens" — this spelling is engine-owned (the overflow retry ` +
-            `adjusts the per-request output cap, and a constant extraBody value would override that adjustment on ` +
-            `every retry). Set the cap via limits.maxOutputTokens (per request) or model.maxTokens instead.`);
-        e.code = "config.extra_body_output_cap";
-        throw e;
-    }
+    const extraBodyRefusal = judgeExtraBody(model.extraBody, model.id).refused;
+    if (extraBodyRefusal !== undefined)
+        throw Object.assign(new Error(extraBodyRefusal.sentence), { code: extraBodyRefusal.code, ...(extraBodyRefusal.field !== undefined ? { detail: { field: extraBodyRefusal.field } } : {}) });
     const fileHistoryRequest = resolveFileHistoryRequest(spec, deps);
     const { acquired, session, conflictRef, wakeRecovered, branch } = await prepareAcquireReconcile({ sessions, spec, resume, wakeEffects, report: (e, id) => deps.onError?.(e, { phase: "config", sessionId: id }), ...(internals?.sessionPlacement !== undefined ? { placement: internals.sessionPlacement } : {}), ...(() => { const g = durableParkGapFor(deps, spec); return g !== undefined ? { durableParkGap: g } : {}; })() });
     const sessionId = acquired.sessionId;
@@ -344,7 +343,7 @@ export async function prepareTask(request, deps, sessions, resume, internals, ru
     let effectiveCompModel = compModel;
     if (spec.compactionModel === undefined &&
         compModel !== undefined &&
-        (await derivedRouteFallsBack({ seat: "compaction-summary", derived: compModel, primary: model, brain: deps.brain, getApiKeyAndHeaders: spec.getApiKeyAndHeaders, onNotice: deps.onNotice, sessionId, runId }))) {
+        (await derivedRouteFallsBack({ seat: "compaction-summary", derived: compModel, primary: model, brain: deps.brain, getApiKeyAndHeaders: spec.getApiKeyAndHeaders, onNotice: deps.onNotice, sessionId, runId })).action === "fall_back") {
         effectiveCompModel = undefined;
     }
     warnCompactionWindowHazard(deps.tracer, spec, model, effectiveCompModel, hostTaskId, runnerSelf?.contextOverlayOf?.(resolvedRole.modelRef));
@@ -673,8 +672,9 @@ export async function prepareTask(request, deps, sessions, resume, internals, ru
             }
         }
         const projectContext = await prepareProjectContext({ deps, spec, internals, session, sessionId, runId, hostTaskId, taskRootFinal, handsEnabled, delegation, seedContextFiles, memoryBlockFromEngine, skillGrants, allowedTools, allowedToolTables, roster, toolFaceSnapshot, onceLedger, memoryTools, memoryEngineSession, memorySearchToolsPlanned, memoryPairExcludedName, memoryPairOccupiedName, resume, skillListingBudget: doors.skillListingBudget });
-        const { memoryBlock: memoryBlockWithProject, instructionSources, projectInstructionContent, skillSpecs, skillSeatOf, skillsListing, sharedMemoryPairMounted, memoryEnginePairMounted } = projectContext;
+        const { memoryBlock: memoryBlockWithProject, instructionSources, projectMemoryFact, projectInstructionContent, skillSpecs, skillSeatOf, skillsListing, sharedMemoryPairMounted, memoryEnginePairMounted } = projectContext;
         const { featureFlags, sugar, mcpInstructionsBlock, envFacts, tzValid, userTz, dateAnchor, gitStatusRef } = await preparePromptInputs({ modBus: legMods.bus, spec, deps, contextOverlay: legContextOverlay(), failClosedReason: selfOrchestrationFailClosedReason(spec, deps), lockedPreflight, selfOrchestrationActive, executionEnv, reminderMark, resolvedReadFace, resolvedWriteFace: resolvedWriteFace?.inForce(), toolFaceSnapshot, promptProfile, fableMitigations, internals, thinking, ownedEnv, delegation, resolvedRole, mcp, roster, model, externalContentTargetActive, resume, handsEnabled, taskRootFinal, additionalRootsCanonical, additionalReadRootsCanonical: (await readRoots.ready().then(readRoots)).filter((r) => !additionalRootsCanonical.includes(r)), sessionId, session, ...(advertisedWritableDirs !== undefined ? { advertisedWritableDirs } : {}) });
+        const advisor = await prepareAdvisor({ spec, advisorTool: doors.advisorTool, deps, model, roster, selector: toolFaceSnapshot.selector, session, onceLedger, rootLeg: !delegation.isDelegatedChild, sessionId, runId, sideCallBookRef, lastSentRequest: () => lastBrainContextRef.current, brainCallGuardrailMs });
         judgeRunToolLists({ spec, tools: roster.tools, declaredPeers: { mcp: lockedPreflight.mcp, a2a: a2a.statuses }, own: { allow: toolFaceLists.allow, exclude: toolFaceLists.exclude }, layers: toolFaceSnapshot.selector.layers, legs: toolLegs, judgedUpstream: toolListsJudged !== undefined, toldUpstream: internals?.ownToolLists !== undefined && ownToolLists !== undefined && toolCeiling !== undefined, ownBy: ownToolLists, onceLedger, sessionId });
         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, ...(mountedMcpNow !== undefined ? { mountedMcp: mountedMcpNow } : {}), sessionId, runId, deps, provenanceForChildrenRef, delegationSettlementRef, spec, envHandToolNames, roster, contentOriginWrapRef });
@@ -693,12 +693,9 @@ export async function prepareTask(request, deps, sessions, resume, internals, ru
         const lastBrainContextRef = {};
         const requestLossyRef = { current: false };
         const staleOffloadWrittenRefs = new Set();
-        const lastBrainContext = () => lastBrainContextRef.current;
+        const lastBrainContext = () => (lastBrainContextRef.lossy === true ? undefined : lastBrainContextRef.current);
         const recordBrainContext = (servedModelId, c) => {
-            if (requestLossyRef.current) {
-                lastBrainContextRef.current = undefined;
-                return;
-            }
+            lastBrainContextRef.lossy = requestLossyRef.current;
             lastBrainContextRef.current = {
                 ...(c.systemPrompt !== undefined ? { systemPrompt: c.systemPrompt } : {}),
                 ...(c.systemBlocks !== undefined ? { systemBlocks: [...c.systemBlocks] } : {}),
@@ -789,7 +786,7 @@ export async function prepareTask(request, deps, sessions, resume, internals, ru
             }
         }
         const { basePolicyForResumeEdit, denyNarrowingPolicy, skillGrantLane, allowEntryLanes, policyLayers, effectivePolicy, inheritedUnavailableAsks, inheritedAskGrants, askSourceIdentity, riskAxesOf, ruleOffersOf, grantBindingOf, permissionRuleLane, ruleLaneFacts, permissionRuleOrgLane, sandboxAdmissionArmed, sandboxBoundaryCapable, emitSandboxAdmitted, foldAskClasses, ancestorSandboxAdmissions, ancestorArbitrations, inheritedToolChecks } = await preparePolicyChain({ spec, deps, internals, sessionId, runId, hostTaskId, taskRootFinal, additionalRootsCanonical, executionEnv, lockedPreflight: installedPreflight, pathRuleAnchors: { leg: legAnchors, chainTop }, headLeads, tools, harnessTools, selector: toolFaceSnapshot.selector, toolEffects, egressTools, irreversibilityTier, axisExplicitNegatives, shellGatedTools, toolMarkSources, envHandToolNames, handsCwdRef, readDenyMatcher, personRows, questionToolMounted, runtimeCaps, inheritedAncestorRules, ancestorSessionRulesRef, inheritedParentConstraints, seedInheritedGate, skillGrants, skillSpecs, allowedToolTables, frozenOnAsk, hookEnvSource, notifyOwnHookCrash, modBus: legMods.bus, ownModChain, autoModeDecider: () => autoModeDeciderRef.current, readFace: () => resolvedReadFace, permissionMode, scratchpadDir: spec.envFacts?.scratchpadDir, toolRosterDeltas: rosterSeat, stopForDenialLimit, delegation, abortController, now, ownSessionRulesRef });
-        const { onAsk, preToolContexts, blockedToolCalls, batchHaltRef, blockedTracked, incompleteSuspendAdapter, durableSuspendInfraReady, resourceSuspendEligible, usageGovernance, durableApproval, wiringManifest, writeProtection, parkLaneArmed, gateMachineryActive, hookIdentity, hookEnvFace, sessionBoxBound } = prepareWiringManifest({ spec, deps, askSeat: doors.askSeat, crossBoundaryStationEngaged: crossBoundary.stationEngaged, internals, resume, sessionId, runId, hostTaskId, taskScope, modBus: legMods.bus, policyLayers, effectivePolicy, handsEnabled, taskRootFinal, legWriteGuard, mcp, irreversibleTools, egressTools, shellReadStationArmed: handsReadFace.shellReadStationArmed, toolEffects, ownedEnv, executionEnv, offloadStore, onceLedger, usageWindows, envLifetimeSuspendAt, runtimeCaps, resolvedInteractionPosture, durableQuestionFace, liveQuestionFace, checkpointStore, sessions, modelGateManifest, autoModeArmReason, permissionMode, lockedPreflight, peerLaneRefs, frameSettlement, harness, pausedRef, liveInheritedGate, delegation, toolRoster, readDenyBuiltinTiersActive: handsReadFace.readDenyBuiltinTiersActive, lspManagerWired, lspDiagnosticsLive: lspDiagnostics !== undefined, fileHistoryFact, sessionBox, checkpointScope, memoryPollution: () => memoryEngineSession?.pollution });
+        const { onAsk, preToolContexts, blockedToolCalls, batchHaltRef, blockedTracked, incompleteSuspendAdapter, durableSuspendInfraReady, resourceSuspendEligible, usageGovernance, durableApproval, wiringManifest, writeProtection, parkLaneArmed, gateMachineryActive, hookIdentity, hookEnvFace, sessionBoxBound } = prepareWiringManifest({ spec, deps, askSeat: doors.askSeat, crossBoundaryStationEngaged: crossBoundary.stationEngaged, internals, resume, sessionId, runId, hostTaskId, taskScope, modBus: legMods.bus, policyLayers, effectivePolicy, handsEnabled, taskRootFinal, legWriteGuard, mcp, irreversibleTools, egressTools, shellReadStationArmed: handsReadFace.shellReadStationArmed, toolEffects, ownedEnv, executionEnv, offloadStore, onceLedger, usageWindows, envLifetimeSuspendAt, runtimeCaps, resolvedInteractionPosture, durableQuestionFace, liveQuestionFace, checkpointStore, sessions, modelGateManifest, autoModeArmReason, permissionMode, lockedPreflight, peerLaneRefs, frameSettlement, harness, pausedRef, liveInheritedGate, delegation, toolRoster, readDenyBuiltinTiersActive: handsReadFace.readDenyBuiltinTiersActive, lspManagerWired, lspDiagnosticsLive: lspDiagnostics !== undefined, fileHistoryFact, projectMemoryFact, sessionRulesChildrenReadLive: ownSessionRulesRef.current !== undefined, sessionBox, checkpointScope, memoryPollution: () => memoryEngineSession?.pollution, advisorFact: advisor.manifest });
         const writeProtectionCheck = writeProtection.mount?.check;
         writeTargetJudgeRef.current = writeProtection.judgeWriteTarget;
         if (fileHistoryBoundary !== undefined) {
@@ -806,13 +803,13 @@ export async function prepareTask(request, deps, sessions, resume, internals, ru
         const { suspendForResource, suspendForPlatformLimit, suspendForReview } = prepareBoundaryParks({ saga, spec, checkpointStore, checkpointScope, abortController, harness, session, sessions, sessionId, deps, priorLedger, maxSlices, maxSuspends, resourceTotal, priorSuspendCount, suspendChainBase, humanReviewRef, liveSpendRef, now, pausedRef, remoteEnvFailures, resourceSuspendEligible, durableSuspendInfraReady, incompleteSuspendAdapter });
         const { parkAsk } = prepareParkAsk({ askLane, saga, spec, deps, sessionId, checkpointStore, checkpointScope, toolRosterDeltas: rosterSeat, parkLaneArmed, contentAskRoutable, liveQuestionFace, mountedQuestionTool, contentAskBindings, lateStrandedAnswers, discloseStrandedAnswers, onAsk, runtimeCaps, inheritedUnavailableAsks, basePolicyForResumeEdit, budgetSnapshot, handsCwdRef, handsRoot: attachmentRootCanonical, stampCallTarget, advertisedWritableDirs, exemptRoots: legExemptRoots, offloadStore, ownedEnv, incompleteSuspendAdapter, session, sessions, suspendChainBase, maxSuspends, remoteEnvFailures, shellGatedTools, irreversibilityTier, toolMarkSources, effectiveShellGate, durableApproval, priorLedger, liveSpendRef, resourceTotal, ruleOffersOf, grantBindingOf, now, humanReviewRef, abortController, harness, pausedRef });
         const seatInputsFor = skillGateWiring({ tools, skillToolName: SKILL_TOOL_NAME, seatOf: skillSeatOf, mode: () => permissionMode.current, lane: skillGrantLane, onAllowed: (info) => emitTrace(deps.tracer, () => ({ kind: "permission.skill_allowed", version: 1, taskId: hostTaskId, ...info, entries: [...info.entries], ts: Date.now() })), allowEntries: { deploymentAllows: { ...allowEntryLanes.deployment, onAllowed: (info) => emitTrace(deps.tracer, () => ({ kind: "permission.allowed_tools_allowed", version: 1, taskId: hostTaskId, source: "deployment", ...info, entries: [...info.entries], ts: Date.now() })) }, requestAllows: { ...allowEntryLanes.request, onAllowed: (info) => emitTrace(deps.tracer, () => ({ kind: "permission.allowed_tools_allowed", version: 1, taskId: hostTaskId, source: "request", ...info, entries: [...info.entries], ts: Date.now() })) } } });
-        const { approvedCallScreen } = prepareGateStations({ askLane, parkAsk, tools, toolRosterDeltas: rosterSeat, crossBoundaryCheck: crossBoundary.seat({ tools, roster: rosterSeat }), toolEffects, deps, toolCallGateArmedRef, effectivePolicy, modBus: legMods.bus, inheritedToolChecks, egressTools, irreversibleTools, spec, complianceDenies, harness, blockedToolCalls, inheritedAskGrants, inheritedUnavailableAsks, foldAskClasses, ancestorSandboxAdmissions, preToolContexts, toolOccurrences, batchHaltRef, blockedTracked, hookIdentity, reminderMark, hostTaskId, sessionId, handsCwdRef, stampCallTarget, readDenyInForce: (toolCallId) => ({ tiers: handsReadFace.readDenyBuiltinTiersActive, rows: [...readDenyAdditionsNormalized.map((e) => e.pattern), ...(pathTables?.forCall(toolCallId).ruleRows ?? handsReadFaceInput.denyRuleRows).filter((r) => r.faces.includes("read")).map((r) => r.rule)] }), hookEnvFace, writeProtectionCheck, shellReadCheck, readFace: () => resolvedReadFace, irreversibilityTier, reversibilityProbes, abortController, shellGatedTools, autoModeDecider: autoModeDeciderRef, autoModeDenialTracking: autoModeDenialTrackingRef, askRoute: { ...wiringManifest.ask, effective: askSeatEffective(wiringManifest) }, permissionMode, toolMarkSources, ...(deps.a2a?.isolatePeers === true ? { a2aIsolatePeers: true } : {}), ancestorArbitrations, runId, stopForDenialLimit, permissionRuleLane, seatInputsFor, permissionRuleOrgLane, questionToolMounted, sandboxAdmissionArmed, sandboxBoundaryCapable, emitSandboxAdmitted, delegation, frameSettlement });
+        const { approvedCallScreen } = prepareGateStations({ askLane, parkAsk, tools, toolRosterDeltas: rosterSeat, crossBoundaryCheck: crossBoundary.seat({ tools, roster: rosterSeat }), deps, toolCallGateArmedRef, effectivePolicy, modBus: legMods.bus, inheritedToolChecks, egressTools, irreversibleTools, spec, complianceDenies, harness, blockedToolCalls, inheritedAskGrants, inheritedUnavailableAsks, foldAskClasses, ancestorSandboxAdmissions, preToolContexts, toolOccurrences, batchHaltRef, blockedTracked, hookIdentity, reminderMark, hostTaskId, sessionId, handsCwdRef, stampCallTarget, readDenyInForce: (toolCallId) => ({ tiers: handsReadFace.readDenyBuiltinTiersActive, rows: [...readDenyAdditionsNormalized.map((e) => e.pattern), ...(pathTables?.forCall(toolCallId).ruleRows ?? handsReadFaceInput.denyRuleRows).filter((r) => r.faces.includes("read")).map((r) => r.rule)] }), hookEnvFace, writeProtectionCheck, shellReadCheck, readFace: () => resolvedReadFace, irreversibilityTier, reversibilityProbes, abortController, shellGatedTools, autoModeDecider: autoModeDeciderRef, autoModeDenialTracking: autoModeDenialTrackingRef, askRoute: { ...wiringManifest.ask, effective: askSeatEffective(wiringManifest) }, permissionMode, toolMarkSources, ...(deps.a2a?.isolatePeers === true ? { a2aIsolatePeers: true } : {}), ancestorArbitrations, runId, stopForDenialLimit, permissionRuleLane, seatInputsFor, permissionRuleOrgLane, questionToolMounted, sandboxAdmissionArmed, sandboxBoundaryCapable, emitSandboxAdmitted, delegation, frameSettlement });
         const postureFrameRef = { report: (err) => deps.onError?.(err, { phase: "degraded", sessionId }) };
         const { microCompact, charsPerToken } = prepareContextLane({ model, deps, sessionId, runId, hostTaskId, offloadStore, toolRosterDeltas: rosterSeat, microCompactKnob, harness, batchHaltRef, gitStatusRef, postureFrameRef, requestLossyRef, trimPressureRef, contextOverlay: legContextOverlay, ...(readFileStateForCheckpoint !== undefined ? { readFileState: readFileStateForCheckpoint } : {}) });
         const preparedHolder = {};
         const { cacheBreakDetector, cacheFingerprint, promptOverheadTokens, compactionRestore, normalizeAttachmentPath, isDedupStubResult, recentlyReadFiles, onCompactionApplied, detectExternalChanges, syntheticReadVerdict, consolidationWriteJudge, listBackgroundTasks, centerCompactionCandidate, effectiveReadFaceObserved, effectiveWriteFaceObserved, effectiveReadDenyObserved } = prepareTurnWiring({ deps, systemPromptSeat, harnessTools, fpRef, model, promptIdentityDigest: promptManifest.identity.artifact, promptProfile, fableMitigations, systemBlocks, thinking, spec, sessionId, turnSnapshotRef, promptManifest, charsPerToken, handsEnabled, executionEnv, attachmentRootCanonical, readRoots, modelFileReader: modelFileReaderSeat.current, reminderMark, reminderDisclosureCounts, resolvedReadFace, handsCwdRef, readFileStateForCheckpoint, denyNarrowingPolicy, skillGrants: skillGrantLane, callerPolicy: installedToolPolicy, inheritedPolicies: (inheritedParentConstraints ?? []).map((c) => c.policy), persistedRuleLane: permissionRuleLane, ruleLaneFacts, personRowsBeyondRun, orgRuleLane: permissionRuleOrgLane, stampCallTarget, abortController, hostTaskId, taskScope, buildAssembleInputs, identityFor, adoptsCandidates, centerAdoptionRef, harnessRef, carrierReadFace, carrierWriteFace, readDenyAdditionsNormalized, preparedHolder });
         await onceLedger.settle(session, announcedListingsRef);
-        const buildPrepared = () => ({ harness, session, sessionId, runId, crossBoundary, registryAccess: { owner: hostTaskId, scope: taskScope }, reminderMark, reminderDisclosureCounts, fullShellReachable, approvalPosture: { get mode() { return permissionMode.current; }, askEffective: askSeatEffective(wiringManifest) }, ...(outputStyleFrame !== undefined ? { outputStyleFrame } : {}), permissionMode, editedFilesSnapshot, taskRootPath: taskRootFinal, model, thinking, compModel: effectiveCompModel, mcp, ...(mcpRedial !== undefined ? { mcpRedial } : {}), ...(a2a.tools.length > 0 ? { a2a } : {}), blockedRef, outputRef, abortController, conflictRef, blockedToolCalls, toolOccurrences, batchHaltRef, nestedStats, ...(rewindNotes.length > 0 ? { rewindNotes } : {}), ...(fileHistoryBoundary !== undefined ? { fileHistoryBoundary } : {}), ...(effectiveReadFaceObserved !== undefined ? { effectiveReadFace: effectiveReadFaceObserved, effectiveWriteFace: effectiveWriteFaceObserved } : {}), ...(effectiveReadDenyObserved !== undefined ? { effectiveReadDenyPatterns: effectiveReadDenyObserved } : {}), effectiveMemoryScopes: memoryEffectiveScopes, cwdRef: handsCwdRef, ...(attachmentRootCanonical !== undefined ? { handsRoot: attachmentRootCanonical } : {}), ...(stampCallTarget !== undefined ? { stampCallTarget } : {}), toolProgressRef, ...(advertisedWritableDirs !== undefined ? { advertisedWritableDirs } : {}), exemptRoots: legExemptRoots, ...(worktreeSessionRef !== undefined ? { worktreeSessionRef } : {}), ...(workspaceStateSettle !== undefined ? { workspaceStateSettle } : {}), ...(sealReadStateSeat !== undefined ? { sealReadStateSeat } : {}), denyNarrowingPolicy, skillGrants: skillGrantLane, skillSpecs, ...(permissionRuleLane !== undefined ? { persistedRuleLane: permissionRuleLane } : {}), ...(basePolicyForResumeEdit !== undefined ? { basePolicyForResumeEdit } : {}), consolidationWriteJudge, ...(permissionRuleOrgLane !== undefined ? { permissionRuleOrg: permissionRuleOrgLane } : {}), releaseSignal, endModeCeiling, settleContentAskBindings, cacheBreakDetector, cacheFingerprint, wiringManifest, promptManifest, promptIdentity, activeTools, ...(deferred.size > 0 ? { deferredToolNames: deferred } : {}), toolMaterializeStatic, deferDirectCall, ...(staticFaceForRef.current !== undefined ? { staticFaceFor: staticFaceForRef.current } : {}), ownedEnv, pausedRef, undeliveredContinuationRef, suspendProgressRef, remoteEnvFailures, reviewRequestRef, suspendLoopRef, suspendForResource, ...(suspendForPlatformLimit !== undefined ? { suspendForPlatformLimit } : {}), ...(envLifetimeSuspendAt !== undefined ? { envLifetimeSuspendAt } : {}), ...(usageGovernance !== undefined ? { usageGovernance } : {}), callIssuedAtRef, workCutRef, brainCallGuardrailRef, gateStopRef, stopForDenialLimit, suspendForReview, ...(readFileStateForCheckpoint !== undefined ? { readFileState: readFileStateForCheckpoint } : {}), resourceLedger: priorLedger, liveSpendRef, humanReviewRef, now, tools, toolRoster, toolRosterDeltas: rosterSeat, structuredProjector, toolEffects, wakeRecovered, promptOverheadTokens, lastBrainContext, ...(compactionRestore !== undefined ? { compactionRestore } : {}), recentlyReadFiles, normalizeAttachmentPath, isDedupStubResult, ...(onCompactionApplied ? { onCompactionApplied } : {}), compactionReuseRef, trimPressureRef, microCompact, ...(memoryEngineSession ? { memoryEngineSession } : {}), ...(subagentRetain ? { subagentRetain } : {}), ...(lspDiagnostics && nudgeLspOnEdit && withheldDiagnosticsOf ? { lspDiagnostics: { registry: lspDiagnostics, nudge: nudgeLspOnEdit, runIdent: lspRunIdent, withheldOf: withheldDiagnosticsOf } } : {}), stopRequestedRef, announcedSnapshotRecovered: onceLedger.recovered, ...(dateChange ? { dateChange } : {}), ...(instructionSources ? { instructionSources } : {}), ...(projectInstructionContent !== undefined ? { projectInstructionContent } : {}), ...(workflowSizeGuideline ? { workflowSizeGuideline } : {}), ...(detectExternalChanges ? { detectExternalChanges } : {}), ...(toolsDeltaRef ? { toolsDeltaRef } : {}), ...(agentListing ? { agentListing } : {}), ...(skillsListing ? { skillsListing } : {}), announcedListingsRef, frameReceipts: { pending: [], listingSnapshotOwed: false }, frameSettlement, ...(userAttachmentsSeat !== undefined ? { userAttachments: userAttachmentsSeat } : {}), attachmentDelivery: createAttachmentDelivery(), ...(modelFileReaderSeat.current !== undefined ? { modelFileReader: modelFileReaderSeat.current } : {}), syntheticReadVerdict, ...(peerLaneRefs.boundaryRound !== undefined ? { peerBoundaryRound: peerLaneRefs.boundaryRound } : {}), gitStatusRef, postureFrameRef, listBackgroundTasks, hookIdentity, modBus: legMods.bus, sideCallBookRef, ...(sessionBoxBound !== undefined ? { sessionBox: sessionBoxBound } : {}), ...(turnSnapshotRef.current !== undefined ? { turnSnapshot: turnSnapshotRef.current } : {}), ...(centerCompactionCandidate !== undefined ? { centerCompactionCandidate } : {}), ...(shellReadCheck !== undefined ? { shellReadCheck } : {}), ...(toolDisclosureSeat !== undefined ? { toolDisclosure: toolDisclosureSeat } : {}), ...(approvedCallScreen !== undefined ? { approvedCallScreen } : {}) });
+        const buildPrepared = () => ({ harness, session, sessionId, runId, crossBoundary, registryAccess: { owner: hostTaskId, scope: taskScope }, reminderMark, reminderDisclosureCounts, fullShellReachable, approvalPosture: { get mode() { return permissionMode.current; }, askEffective: askSeatEffective(wiringManifest) }, ...(outputStyleFrame !== undefined ? { outputStyleFrame } : {}), permissionMode, editedFilesSnapshot, taskRootPath: taskRootFinal, model, thinking, compModel: effectiveCompModel, mcp, ...(mcpRedial !== undefined ? { mcpRedial } : {}), ...(a2a.tools.length > 0 ? { a2a } : {}), blockedRef, outputRef, abortController, conflictRef, blockedToolCalls, toolOccurrences, batchHaltRef, nestedStats, ...(rewindNotes.length > 0 ? { rewindNotes } : {}), ...(fileHistoryBoundary !== undefined ? { fileHistoryBoundary } : {}), ...(effectiveReadFaceObserved !== undefined ? { effectiveReadFace: effectiveReadFaceObserved, effectiveWriteFace: effectiveWriteFaceObserved } : {}), ...(effectiveReadDenyObserved !== undefined ? { effectiveReadDenyPatterns: effectiveReadDenyObserved } : {}), effectiveMemoryScopes: memoryEffectiveScopes, cwdRef: handsCwdRef, ...(attachmentRootCanonical !== undefined ? { handsRoot: attachmentRootCanonical } : {}), ...(stampCallTarget !== undefined ? { stampCallTarget } : {}), toolProgressRef, ...(advertisedWritableDirs !== undefined ? { advertisedWritableDirs } : {}), exemptRoots: legExemptRoots, ...(worktreeSessionRef !== undefined ? { worktreeSessionRef } : {}), ...(workspaceStateSettle !== undefined ? { workspaceStateSettle } : {}), ...(sealReadStateSeat !== undefined ? { sealReadStateSeat } : {}), denyNarrowingPolicy, skillGrants: skillGrantLane, skillSpecs, ...(permissionRuleLane !== undefined ? { persistedRuleLane: permissionRuleLane } : {}), ...(basePolicyForResumeEdit !== undefined ? { basePolicyForResumeEdit } : {}), consolidationWriteJudge, ...(permissionRuleOrgLane !== undefined ? { permissionRuleOrg: permissionRuleOrgLane } : {}), releaseSignal, endModeCeiling, settleContentAskBindings, cacheBreakDetector, cacheFingerprint, wiringManifest, promptManifest, promptIdentity, activeTools, ...(deferred.size > 0 ? { deferredToolNames: deferred } : {}), toolMaterializeStatic, deferDirectCall, ...(staticFaceForRef.current !== undefined ? { staticFaceFor: staticFaceForRef.current } : {}), ownedEnv, pausedRef, undeliveredContinuationRef, suspendProgressRef, remoteEnvFailures, reviewRequestRef, suspendLoopRef, suspendForResource, ...(suspendForPlatformLimit !== undefined ? { suspendForPlatformLimit } : {}), ...(envLifetimeSuspendAt !== undefined ? { envLifetimeSuspendAt } : {}), ...(usageGovernance !== undefined ? { usageGovernance } : {}), callIssuedAtRef, workCutRef, brainCallGuardrailRef, gateStopRef, stopForDenialLimit, suspendForReview, ...(readFileStateForCheckpoint !== undefined ? { readFileState: readFileStateForCheckpoint } : {}), resourceLedger: priorLedger, liveSpendRef, humanReviewRef, now, tools, toolRoster, toolRosterDeltas: rosterSeat, structuredProjector, toolEffects, wakeRecovered, promptOverheadTokens, lastBrainContext, lastSentRequest: () => lastBrainContextRef.current, ...(advisor.instruction !== undefined ? { advisorInstruction: advisor.instruction } : {}), ...(compactionRestore !== undefined ? { compactionRestore } : {}), recentlyReadFiles, normalizeAttachmentPath, isDedupStubResult, ...(onCompactionApplied ? { onCompactionApplied } : {}), compactionReuseRef, trimPressureRef, microCompact, ...(memoryEngineSession ? { memoryEngineSession } : {}), ...(subagentRetain ? { subagentRetain } : {}), ...(lspDiagnostics && nudgeLspOnEdit && withheldDiagnosticsOf ? { lspDiagnostics: { registry: lspDiagnostics, nudge: nudgeLspOnEdit, runIdent: lspRunIdent, withheldOf: withheldDiagnosticsOf } } : {}), stopRequestedRef, announcedSnapshotRecovered: onceLedger.recovered, ...(dateChange ? { dateChange } : {}), ...(instructionSources ? { instructionSources } : {}), ...(projectInstructionContent !== undefined ? { projectInstructionContent } : {}), ...(workflowSizeGuideline ? { workflowSizeGuideline } : {}), ...(detectExternalChanges ? { detectExternalChanges } : {}), ...(toolsDeltaRef ? { toolsDeltaRef } : {}), ...(agentListing ? { agentListing } : {}), ...(skillsListing ? { skillsListing } : {}), announcedListingsRef, frameReceipts: { pending: [], listingSnapshotOwed: false }, frameSettlement, ...(userAttachmentsSeat !== undefined ? { userAttachments: userAttachmentsSeat } : {}), attachmentDelivery: createAttachmentDelivery(), ...(modelFileReaderSeat.current !== undefined ? { modelFileReader: modelFileReaderSeat.current } : {}), syntheticReadVerdict, ...(peerLaneRefs.boundaryRound !== undefined ? { peerBoundaryRound: peerLaneRefs.boundaryRound } : {}), gitStatusRef, postureFrameRef, listBackgroundTasks, hookIdentity, modBus: legMods.bus, sideCallBookRef, ...(sessionBoxBound !== undefined ? { sessionBox: sessionBoxBound } : {}), ...(turnSnapshotRef.current !== undefined ? { turnSnapshot: turnSnapshotRef.current } : {}), ...(centerCompactionCandidate !== undefined ? { centerCompactionCandidate } : {}), ...(shellReadCheck !== undefined ? { shellReadCheck } : {}), ...(toolDisclosureSeat !== undefined ? { toolDisclosure: toolDisclosureSeat } : {}), ...(approvedCallScreen !== undefined ? { approvedCallScreen } : {}) });
         refuseLateRosterChanges(callerRoster.roster);
         rollback.commit();
         commitModeSeats(abortController.signal);

package/dist/core/runner/prepare-tool-disclosure-mount.js

@@ -1,5 +1,6 @@
 import { readCompactionActiveTools } from "../../internal/harness.js";
 import { toolsToFingerprintInputs } from "../cache-break-detector.js";
+import { survivorsByName } from "../tool-roster.js";
 import { deliverEngineNotice } from "../types.js";
 import { TOOL_SEARCH_NAME, buildDeferredRegistry, extractDiscoveredToolNames, createPlaceholderTool, createToolSearchTool, staticSchemaRenderable } from "./tool-disclosure.js";
 import { createDeferralCensus } from "./deferral-census.js";
@@ -83,12 +84,13 @@ export async function prepareToolDisclosureMount(input) {
         toolDisclosureSeat = census.seat;
         const publishCensus = () => census.publish(activeTools);
         const everExempt = new Set();
+        const answering = (name) => survivorsByName(tools).get(name);
         const staticFaceFor = (name) => {
             if (!materializeStatic)
                 return false;
             if (everExempt.has(name))
                 return false;
-            if (staticSchemaRenderable(tools.find((t) => t.name === name)?.parameters))
+            if (staticSchemaRenderable(answering(name)?.parameters))
                 return true;
             everExempt.add(name);
             return false;
@@ -103,10 +105,10 @@ export async function prepareToolDisclosureMount(input) {
         const directCallFor = (name) => {
             if (spec.deferSelfResolve === false)
                 return undefined;
-            const executionMode = tools.find((t) => t.name === name)?.executionMode;
+            const executionMode = answering(name)?.executionMode;
             return {
                 resolveReal: () => {
-                    const real = tools.find((t) => t.name === name);
+                    const real = answering(name);
                     if (real === undefined)
                         return undefined;
                     return {
@@ -206,7 +208,7 @@ export async function prepareToolDisclosureMount(input) {
             directCallEnabled: spec.deferSelfResolve !== false,
             isMounted: (name) => tools.some((t) => t.name === name),
             ...(materializeStatic
-                ? { staticSchemaFor: (name) => (staticFaceFor(name) ? tools.find((t) => t.name === name)?.parameters : undefined) }
+                ? { staticSchemaFor: (name) => (staticFaceFor(name) ? answering(name)?.parameters : undefined) }
                 : {}),
             onActivationCommitted: publishCensus,
             serializeActivation,

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

@@ -121,9 +121,12 @@ export interface PrepareWiringManifestInput {
      *  resolution materially activated; relayed onto the manifest (present iff non-empty), never
      *  re-derived from `deps` here (which by this phase sits past that phase's await). */
     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 — 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 — from the project-context phase: did it call the deployment's seam (the arm's own predicate), relayed. */
+    projectMemoryFact: NonNullable<WiringManifest["projectMemory"]>;
+    /** borrowed-readonly — from the policy-chain phase: this leg's own session-rule layer published its key for the children's chain (`ownSessionRulesRef.current !== undefined`), relayed as `sessionRules.childrenReadLive`. */ sessionRulesChildrenReadLive: boolean;
+    /** borrowed-readonly — the advisor phase's answer, relayed. */ advisorFact?: WiringManifest["advisor"];
     /** borrowed-readonly — the arming outcome the caps phase reads live (the manifest's auto-mode face at this leg's start). */
     autoModeArmReason: () => AutoModeArmFact;
     /** borrowed-readonly — the leg's live permission-mode seat: its receipt at this leg's start rides the manifest, and the

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

@@ -117,7 +117,7 @@ function announceDurableGateUnavailable(args) {
     });
 }
 export function prepareWiringManifest(input) {
-    const { spec, deps, internals, resume, sessionId, runId, hostTaskId, taskScope, modBus, checkpointScope, policyLayers, effectivePolicy, handsEnabled, taskRootFinal, legWriteGuard, mcp, irreversibleTools, egressTools, toolEffects, ownedEnv, executionEnv, offloadStore, onceLedger, usageWindows, envLifetimeSuspendAt, runtimeCaps, resolvedInteractionPosture, durableQuestionFace, liveQuestionFace, checkpointStore, sessions, modelGateManifest, autoModeArmReason, permissionMode, lockedPreflight, peerLaneRefs, frameSettlement, sessionBox, harness, pausedRef, askSeat, liveInheritedGate, delegation, toolRoster, readDenyBuiltinTiersActive, lspManagerWired, shellReadStationArmed, crossBoundaryStationEngaged, lspDiagnosticsLive, fileHistoryFact, memoryPollution } = input;
+    const { spec, deps, internals, resume, sessionId, runId, hostTaskId, taskScope, modBus, checkpointScope, policyLayers, effectivePolicy, handsEnabled, taskRootFinal, legWriteGuard, mcp, irreversibleTools, egressTools, toolEffects, ownedEnv, executionEnv, offloadStore, onceLedger, usageWindows, envLifetimeSuspendAt, runtimeCaps, resolvedInteractionPosture, durableQuestionFace, liveQuestionFace, checkpointStore, sessions, modelGateManifest, autoModeArmReason, permissionMode, lockedPreflight, peerLaneRefs, frameSettlement, sessionBox, harness, pausedRef, askSeat, liveInheritedGate, delegation, toolRoster, readDenyBuiltinTiersActive, lspManagerWired, shellReadStationArmed, crossBoundaryStationEngaged, lspDiagnosticsLive, fileHistoryFact, projectMemoryFact, sessionRulesChildrenReadLive, memoryPollution, advisorFact } = input;
     const onAsk = askSeat.value;
     const handWriteTools = toolRoster.entries.filter((e) => e.mountedBy === "hands" && (e.effect === "write" || e.effect === "idempotent")).map((e) => e.name);
     const hasEffectAwareGate = policyLayers.length > 0 || chainJudges(modBus);
@@ -223,7 +223,7 @@ export function prepareWiringManifest(input) {
         mods: modBus.records,
         ...(lspManagerWired ? { lsp: deriveLspSeam(toolRoster.entries.some((e) => e.contract.contractId === LSP_CONTRACT_ID), lspDiagnosticsLive) } : {}),
         hands: deriveHandsSeam(handsEnabled),
-        fileHistory: fileHistoryFact,
+        fileHistory: fileHistoryFact, projectMemory: projectMemoryFact, sessionRulesChildrenReadLive, ...(advisorFact !== undefined ? { advisor: advisorFact } : {}),
     });
     peerLaneRefs.askEffective = askSeatEffective(wiringManifest);
     peerLaneRefs.permissionMode = () => permissionMode.current;

package/dist/core/runner/resume-policy-outcome.js

@@ -45,7 +45,7 @@ export function resumePolicyOutcome(input) {
         const reason = decide.reason;
         assertOutcomeText(reason, "reason");
         const feedback = decide.feedback;
-        assertOutcomeText(feedback, "feedback");
+        assertOutcomeText(feedback, "feedback", { field: "feedback" });
         plainPolicyOutcome = {
             gate: "policy_ask",
             boundCallId: decide.boundCallId,

package/dist/core/runner/retired-runner-deps.js

@@ -7,7 +7,7 @@ const RETIRED_RUNNER_DEPS_KEYS = {
     graderEnvFactory: "the grader env reaches the repair loop as `RepairLoopConfig.graderEnv`, minted by the trusted control plane (`assertOracleIsolation` / `GraderEnv` unchanged)",
     "hands.readCyberReminder": "a Read result carries only the reminders about that read (an empty file, an offset past the end, a file already in context) — no standing content-safety tail, so there is nothing to switch; a deployment that wants that sentence states it in its own `appendSystemPrompt`",
     promptProvider: "a deployment changes prompt text through overlays: register a `prompt.compose` handler on `RunnerDeps.mods` answering `{ overlays }` (role base `replace`, a brand line `add` to the role band, a behavior or scenario `add`, a core-behavior `replace` / `append` / `drop`), choose the role base per task with `TaskSpec.promptRole`, and dispose of an MCP server's instructions with a `prompt.section` registration answering `{ text }` / `{ text: null }`",
-    memorySessionIncarnation: "the occupant behind a session id is a cell of the session row now — `SessionMetadata.incarnation` on the metadata `Session.getMetadata()` returns (forks also `forkedFromIncarnation`), with `SessionStore.incarnationOf` for by-id readers; put the token the old seat answered on your sessions instead. A deployment that drops the seat without surfacing the cell loses the axis: records bind by session id alone",
+    memorySessionIncarnation: "the occupant behind a session id is a cell of the session row now — `SessionMetadata.incarnation` on the metadata `Session.getMetadata()` returns (forks also `forkedFromIncarnation`), with `SessionStore.headOf` (its `incarnation`) for by-id readers; put the token the old seat answered on your sessions instead. A deployment that drops the seat without surfacing the cell loses the axis: records bind by session id alone",
 };
 export function assertNoRetiredRunnerDeps(deps) {
     assertNoRetiredKeys(deps, RETIRED_RUNNER_DEPS_KEYS, "RunnerDeps");

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

@@ -27,7 +27,6 @@ export async function runAttachmentSeats(input) {
             ? { announcedGuideline: prepared.workflowSizeGuideline.legGuideline, current: prepared.workflowSizeGuideline.current }
             : undefined;
     rs.counters.cadenceTurns = 0;
-    rs.turn.lastTurnHadToolCalls = false;
     if (rs.attach.attachState !== undefined && (rs.attach.attachmentsCfg?.backgroundTasks ?? eventDefaultOn("background_tasks")) === true) {
         try {
             const branch = await prepared.session.getBranch();

package/dist/core/runner/run-compaction-machinery.d.ts

@@ -24,7 +24,7 @@ export interface RunCompactionMachineryInput {
     runner: RunnerDepsSeat;
 }
 export interface RunCompactionMachineryResult {
-    /** The accounted compaction brain — `complete` always provided, usage recorded inline. */
+    /** The accounted compaction brain ({@link derivedLegBrain} on the `compaction` lane). */
     compactionBrain: Brain;
     /** Whether ROUTINE turn-boundary compaction runs for this task, asked AT THE BOUNDARY. The request's own
      *  `compaction` is fixed for the leg, but the deployment's per-model overlay is a live seat — an operator

package/dist/core/runner/run-compaction-machinery.js

@@ -4,22 +4,12 @@ import { compactionEnabled, contextOverlayFor } from "../context-settings.js";
 import { sanitizeCompactionSettings } from "../auto-compaction.js";
 import { modelCostToPricing } from "../pricing.js";
 import { emitTrace } from "../trace.js";
-import { runWithReasoningWireFacts, runWithStatusSink } from "../../brain/status-sink.js";
-import { sideCallBookOf } from "./side-call-account.js";
+import { derivedLegBrain, sideCallBookOf } from "./side-call-account.js";
 export function runCompactionMachinery(input) {
     const { spec, prepared, rs, stats, noteUnevaluablePriceTable, modelCatalog, runner } = input;
     const bookSideCall = sideCallBookOf(stats, { telemetry: rs.telemetry, pricing: () => runner.deps.pricing, noteUnevaluablePriceTable, catalog: modelCatalog });
     prepared.sideCallBookRef.book = bookSideCall;
-    const compactionBrain = {
-        stream: runner.deps.brain.stream,
-        complete: async (m, c, o) => {
-            const msg = await runWithStatusSink(() => { }, async () => await runWithReasoningWireFacts(() => { }, async () => runner.deps.brain.complete
-                ? await runner.deps.brain.complete(m, c, o)
-                : await (await Promise.resolve(runner.deps.brain.stream(m, c, o))).result()));
-            bookSideCall("compaction", m, msg);
-            return msg;
-        },
-    };
+    const compactionBrain = derivedLegBrain(() => runner.deps.brain, "compaction", bookSideCall);
     const legOverlay = () => contextOverlayFor(runner.deps.contextSettings, prepared.harness.getModelRef(), runner.deps);
     const withinTaskCompaction = () => compactionEnabled(spec.compaction?.enabled, legOverlay()) && (spec.compaction?.withinTask ?? true);
     const compactionBreaker = { failures: 0 };

package/dist/core/runner/run-git-lane.d.ts

@@ -47,6 +47,7 @@ export interface RunGitLaneInput {
      *  so a pending announcement is re-asserted into the session ahead of the boundary's own context work. */
     onTurnBoundary: (event: {
         model: Model;
+        continues: boolean;
     }) => Promise<undefined>;
     /** borrowed-readonly — the Runner's deployment deps, read LIVE inside the closures (`onError`). */
     runner: RunnerDepsSeat;

package/dist/core/runner/run-harness-handlers.js

@@ -5,7 +5,7 @@ import { emitTrace } from "../trace.js";
 import { primaryActivityArg } from "../arg-summary.js";
 import { egressText } from "../untrusted-egress.js";
 import { readDegradation } from "../../brain/degrading.js";
-import { OUTPUT_TOOL_NAME } from "./synthetic-tools.js";
+import { OUTPUT_TOOL_NAME } from "../tool-catalog-entries.js";
 import { usageCostMicroUsd } from "./usage-accounting.js";
 import { advanceCadenceClock, reduceToolEnd } from "./turn-attachments.js";
 import { gatedCallIdOf } from "./park-commit.js";
@@ -15,7 +15,7 @@ import { stampRowNotExecuted } from "./tool-not-executed.js";
 import { createResponseModelSeat } from "./response-model-seat.js";
 import { createToolCallIdFoldSeat } from "./tool-call-id-fold-seat.js";
 import { createFinishReasonSeat } from "./finish-reason-seat.js";
-import { createToolTurnIncompleteSeat, turnCarriesToolCall } from "./tool-turn-repair-seat.js";
+import { createToolTurnIncompleteSeat } from "./tool-turn-repair-seat.js";
 import { wireOf } from "../tool-name-readings.js";
 import { rosterToolName } from "../tool-roster.js";
 export function createHarnessHandlers(input) {
@@ -201,7 +201,6 @@ export function createHarnessHandlers(input) {
             const content = m.content;
             if (rs.attach.attachState !== undefined)
                 rs.counters.cadenceTurns = advanceCadenceClock(rs.attach.attachState, rs.counters.cadenceTurns, content, writeFamilyOf);
-            rs.turn.lastTurnHadToolCalls = turnCarriesToolCall(content);
         }
         rs.turn.callStartAt = undefined;
         rs.turn.firstTokenAt = undefined;

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

@@ -28,6 +28,7 @@ import { errorCodeOf } from "./terminal-account.js";
 import { DEFAULT_PRECALL_OUTPUT_TOKENS, platformLimitTerminal } from "./clock-and-limits.js";
 import { legContextOverlayOption } from "./compaction-call-options.js";
 import { mintOutputStyleReminder, owedPostureText } from "./compaction-restate.js";
+import { advisorFrameText, registerAdvisorReceipt } from "./advisor-instructions.js";
 import { deepJsonEqual, resumeContinuation } from "./decide-continuation.js";
 import { approvalWordsOf, owedApprovalWords, withApprovalWords } from "./approval-feedback.js";
 import { chainCannotJudge } from "./call-hook-stations.js";
@@ -163,6 +164,9 @@ export async function runLeg(input) {
                 const outputStyleWrapped = mintOutputStyleReminder(prepared);
                 if (outputStyleWrapped !== undefined)
                     continuation += "\n\n" + outputStyleWrapped;
+                const advisorResumeFrame = advisorFrameText(prepared);
+                if (advisorResumeFrame !== undefined)
+                    continuation += "\n\n" + advisorResumeFrame;
                 const engineSegments = continuation.length > 0 ? [{ start: 0, end: continuation.length }] : [];
                 const parkedSteers = readPendingSteerQueue(resume.cp.state);
                 const resumeFrames = [
@@ -254,6 +258,7 @@ export async function runLeg(input) {
                 if (!prepared.abortController.signal.aborted) {
                     if (resume !== undefined)
                         resume.decisionDelivered = true;
+                    registerAdvisorReceipt(prepared, continuation);
                     if (gitResumeDelivered !== undefined) {
                         const delivered = gitResumeDelivered;
                         prepared.gitStatusRef.protectedText = delivered.wrapped;
@@ -272,6 +277,8 @@ export async function runLeg(input) {
                         const preview = redactThenCut(prepared.outputStyleFrame, 220);
                         prepared.frameReceipts.pending.push({ source: "output_style", text: continuation, commit: () => void (queue.push({ type: "steering_injected", source: "output_style", preview, ...ident() }), (rs.attach.attachmentsInjected += 1)) });
                     }
+                    if (postureText !== undefined)
+                        prepared.frameReceipts.pending.push({ source: "posture", text: continuation, commit: () => undefined });
                     if (approvalFrames.length > 0) {
                         prepared.frameReceipts.pending.push({
                             source: "approval_feedback",
@@ -396,6 +403,9 @@ export async function runLeg(input) {
             if (firstFrames.length > 0) {
                 effectiveObjective = `${firstFrames.map((f) => mintSystemReminder(sanitizeUntrustedText(f.body, attachmentEnvelopeTags(f.source)), prepared.reminderMark)).join("\n")}\n${effectiveObjective}`;
             }
+            const advisorFrame = advisorFrameText(prepared);
+            if (advisorFrame !== undefined)
+                effectiveObjective = `${advisorFrame}\n${effectiveObjective}`;
             const postureText = await owedPostureText(prepared, "always");
             if (postureText !== undefined)
                 effectiveObjective = `${postureText}\n${effectiveObjective}`;
@@ -470,6 +480,9 @@ export async function runLeg(input) {
                         },
                     });
                 }
+                if (postureText !== undefined)
+                    prepared.frameReceipts.pending.push({ source: "posture", text: effectiveObjective, commit: () => undefined });
+                registerAdvisorReceipt(prepared, effectiveObjective);
                 const enginePrefixChars = effectiveObjective.length - projectedObjective.length;
                 if (!prepared.abortController.signal.aborted) {
                     prepared.attachmentDelivery.stage(objectiveInputId, attachmentFrames);

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

@@ -21,7 +21,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 { owedDateAnchor } from "./conversation-segment.js";
 import { autoRunConsolidationFromRecommendation, autoRunOnRecommendationEffective, scopeHasUnconsumedRecommendation } from "./memory-consolidation-driver.js";
 import { amendTerminal, terminalProjection } from "./terminal-projection.js";
 import { mintCompactedEvent } from "../auto-compaction.js";