@sema-agent/core 7.54.1 → 7.56.0

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

@@ -15,19 +15,23 @@ import { protocolOf } from "../protocol-table.js";
 import { hasConversationContent } from "../session.js";
 import { PROMPT_HASH_SALT } from "./prompt-hash-salt.js";
 const CATALOG_DIGEST = catalogDigestOf(SEMA_DEFAULT_CATALOG);
-function taskLayerOf(task) {
+const TASK_TEXT_DIGEST_SCHEME = "sid-sha256:";
+function taskLayerDigestOf(sessionId, text) {
+    return `${TASK_TEXT_DIGEST_SCHEME}${createHash("sha256").update(sessionId).update("\u0000").update(text).digest("hex")}`;
+}
+function taskLayerOf(task, sessionId) {
     return task.map(({ overlay: o, origin }) => ({
         by: origin.by,
         id: o.id,
         op: o.op,
         target: o.target,
-        ...(o.text !== undefined ? { chars: o.text.length } : {}),
+        ...(o.text !== undefined ? { text: taskLayerDigestOf(sessionId, o.text) } : {}),
         ...(o.message !== undefined ? { message: o.message } : {}),
         ...(o.when !== undefined ? { when: o.when } : {}),
     }));
 }
 export async function preparePromptAssembly(input) {
-    const { session, deps, internals, resume, sugar, host, binding, modBus, featureFlags, mcpInstructionsBlock, memoryBlock, envFacts, promptProfile, fableMitigations, tools, model, sessionId, onceLedger } = input;
+    const { session, deps, internals, resume, sugar, host, binding, modBus, featureFlags, mcpInstructionsBlock, memoryBlock, envFacts, promptTraits, tools, model, sessionId, onceLedger } = input;
     const topLevel = internals?.parentTaskId === undefined && internals?.parentSessionId === undefined && internals?.parentCenterArtifactDigest === undefined;
     const stored = await session.getPromptEpoch();
     let centerAdoption;
@@ -82,10 +86,8 @@ export async function preparePromptAssembly(input) {
         ...featureFlags,
         orchestrationEnabled: featureFlags.orchestrationEnabled && tools.some((t) => t.name === "Workflow"),
         orchestrationDeferred: featureFlags.orchestrationDeferred && tools.some((t) => t.name === "Workflow"),
-        promptProfile,
-        fableMitigations,
     };
-    const selectorRecord = selectorRecordOf(selectorsOf(facts, host, binding));
+    const selectorRecord = selectorRecordOf(selectorsOf(facts, host, binding, promptTraits));
     const centerOverlays = centerOverlaysOf(centerAdoption);
     const lowerAdds = new Map();
     for (const { overlay } of [...sugar, ...centerOverlays])
@@ -105,6 +107,7 @@ export async function preparePromptAssembly(input) {
         deployOverlays: composed.deploy,
         host,
         ...(binding !== undefined ? { binding } : {}),
+        traits: promptTraits,
         tools,
         facts,
         ...(envFacts.cwd !== undefined ? { workspaceFolder: envFacts.cwd } : {}),
@@ -112,11 +115,10 @@ export async function preparePromptAssembly(input) {
         memoryBlock,
         buildEnvBlock: (date) => buildEnvironmentContext({ ...envFacts, date }) || undefined,
         date: envFacts.date,
-        ...(model.promptGuidance && model.promptGuidance.length > 0 ? { modelGuidance: model.promptGuidance.join("\n\n") } : {}),
         onWarn: (message, phase) => deps.onError?.(new Error(message), { phase, sessionId }),
     });
     const deployLayer = composed.deploy.length > 0 ? digestOf(composed.deploy.map(({ overlay, origin }) => ({ by: origin.by, overlay }))) : undefined;
-    const taskLayer = taskOverlays.length > 0 ? digestOf(taskLayerOf(taskOverlays)) : undefined;
+    const taskLayer = taskOverlays.length > 0 ? digestOf(taskLayerOf(taskOverlays, sessionId)) : undefined;
     const bindingLayer = digestOf(selectorRecord);
     const renderers = rendererVector();
     const identityFor = (center) => ({

package/dist/core/runner/prepare-prompt-inputs.d.ts

@@ -23,7 +23,8 @@ import type { LegModBus } from "../mods/stations.js";
 import type { ExecutionEnv, ThinkingLevel } from "../../internal/harness.js";
 import type { Model } from "../../internal/llm.js";
 import { type EnvironmentFacts } from "../../prompts/default.js";
-import type { SourcedOverlay } from "../../prompt-assembly/overlay.js";
+import type { HostRole } from "../../prompt-assembly/catalog/schema.js";
+import { type RequestBodySugar } from "../../prompt-assembly/sugar.js";
 import type { ContainmentFace } from "../../tools/fs/index.js";
 import type { LockedPreflight } from "../locked-config.js";
 import type { MaterializedMcp } from "../mcp.js";
@@ -65,10 +66,6 @@ export interface PreparePromptInputsInput {
     /** borrowed-readonly — the frozen tool face; `defer` (the Workflow short-pointer flag) and `selector` (with the spec's whole-face
      *  switch, the valve's reading that decides which servers' instructions are taught). */
     toolFaceSnapshot: Pick<ToolFaceSnapshot, "defer" | "selector">;
-    /** borrowed-readonly — the resolved prompt profile (rides the flags to the legacy ctx). */
-    promptProfile: "simple" | "classic";
-    /** borrowed-readonly — the fable-mitigations profile axis (rides the flags with the profile). */
-    fableMitigations: boolean;
     /** borrowed-readonly — trusted internals: `goalMode` (goal flag), `isolation` (worktree flag),
      *  `defaultSystemPrompt` (the sugar's third source). `undefined` on a standalone prepare. */
     internals: Pick<RunInternals, "goalMode" | "isolation" | "defaultSystemPrompt"> | undefined;
@@ -81,8 +78,12 @@ export interface PreparePromptInputsInput {
     delegation: {
         readonly isNonForkChild: boolean;
     };
-    /** borrowed-readonly — the resolved role; only its `systemPrompt` preset is read (second source). */
-    resolvedRole: Pick<ResolvedRole, "systemPrompt">;
+    /** borrowed-readonly — the resolved role; only its role-base statement (`promptRole` / `systemPrompt`) is read (the
+     *  role-base decision's second source). */
+    resolvedRole: Pick<ResolvedRole, "promptRole" | "systemPrompt">;
+    /** borrowed-readonly — the task seat's role word as its door judged it (`TaskSpec.promptRole`, `resolveHost`): the
+     *  role-base decision's first source, beside the spec's own text. */
+    taskRole: HostRole | undefined;
     /** borrowed-mutable — the materialized MCP roster; `serverInstructions` (the disposed entries) and `tools` (each server's listing: did it list
      *  any tool) are read, and the instructions lane's ledger is stated: the block is what the model is told at the run's start. */
     mcp: Pick<MaterializedMcp, "serverInstructions" | "tools" | "instructionsDelta">;
@@ -122,8 +123,9 @@ export interface PreparePromptInputsInput {
 export interface PreparePromptInputsResult {
     /** owned — the runtime feature flags (see {@link PromptFeatureFlags}). */
     featureFlags: PromptFeatureFlags;
-    /** owned — the request-body sugar's overlays (the task class's first contributions), in application order. */
-    sugar: readonly SourcedOverlay[];
+    /** owned — the request-body sugar: its overlays (the task class's first contributions, in application order) and the
+     *  run's host role, from the one role-base decision. */
+    sugar: RequestBodySugar;
     /** owned — the fenced MCP server-instructions block, or undefined when no server declared any. */
     mcpInstructionsBlock: string | undefined;
     /** owned — the environment facts the env tail renders from. Filled here; no later phase writes it

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

@@ -1,15 +1,15 @@
 import { formatLocalDate, isValidTimeZone } from "../../prompts/default.js";
-import { sugarOverlays } from "../../prompt-assembly/sugar.js";
+import { requestBodySugar } 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"]);
 import { compactionEnabled } from "../context-settings.js";
 export async function preparePromptInputs(input) {
-    const { spec, deps, failClosedReason, lockedPreflight, selfOrchestrationActive, executionEnv, reminderMark, resolvedReadFace, resolvedWriteFace, toolFaceSnapshot, promptProfile, fableMitigations, internals, thinking, ownedEnv, delegation, resolvedRole, mcp, model, externalContentTargetActive, resume, handsEnabled, taskRootFinal, additionalRootsCanonical, additionalReadRootsCanonical, sessionId, session, advertisedWritableDirs } = input;
+    const { spec, deps, failClosedReason, lockedPreflight, selfOrchestrationActive, executionEnv, reminderMark, resolvedReadFace, resolvedWriteFace, toolFaceSnapshot, internals, thinking, ownedEnv, delegation, resolvedRole, mcp, model, externalContentTargetActive, resume, handsEnabled, taskRootFinal, additionalRootsCanonical, additionalReadRootsCanonical, sessionId, session, advertisedWritableDirs } = input;
     const promptPolicyEnabled = Boolean(lockedPreflight.toolPolicy);
     const promptHooksEnabled = input.modBus.hasHandlers("classic.PreToolUse") || input.modBus.hasHandlers("classic.PostToolUse");
     if (failClosedReason) {
@@ -24,15 +24,13 @@ export async function preparePromptInputs(input) {
         writeFaceOpen: resolvedWriteFace === "open",
         orchestrationEnabled: selfOrchestrationActive,
         orchestrationDeferred: selfOrchestrationActive && (toolFaceSnapshot.defer?.includes("Workflow") ?? false),
-        promptProfile,
-        fableMitigations,
         goalEnabled: internals?.goalMode === true,
         awarenessEnabled: thinking !== undefined && ULTRA_REASONING_TIERS.has(thinking),
         worktreeIsolated: internals?.isolation === "worktree" && ownedEnv !== undefined,
         withinTaskCompactionEnabled: compactionEnabled(spec.compaction?.enabled, input.contextOverlay) && (spec.compaction?.withinTask ?? true),
         isSubagent: delegation.isNonForkChild,
     };
-    const sugar = sugarOverlays({ spec, resolvedRole, ...(internals !== undefined ? { internals } : {}) });
+    const sugar = requestBodySugar({ spec, resolvedRole, ...(input.taskRole !== undefined ? { taskRole: input.taskRole } : {}), ...(internals !== undefined ? { internals } : {}) });
     const valveLeft = valveLeaves(spec, toolFaceSnapshot.selector);
     const taught = mcp.serverInstructions.filter((entry) => instructionsTaught(valveLeft, entry.server, input.roster.tools, mcp.tools));
     toldAtStart(mcp.instructionsDelta, new Set(taught.map((entry) => entry.server)));

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

@@ -36,10 +36,12 @@ export interface PrepareProtocolToolsInput {
      *  mount predicate, and whether a real client was acquired) and `a2a` (the declared peers the door judged: the materialize
      *  input and whether a handle was acquired) are read. */
     lockedPreflight: Pick<LockedPreflight, "mcp" | "a2a">;
+    /** borrowed-readonly — the deployment's host floor as the config doors compiled it: each MCP http dial and every A2A request is judged by it. */
+    hostFloor: import("../host-floor.js").HostFloor | undefined;
     /** 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,14 +7,14 @@ 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";
 import { sectionDisposerOf } from "../prompt-section-seat.js";
 import { thrownText } from "../thrown-value.js";
 export async function prepareProtocolTools(input) {
-    const { lockedPreflight, spec, deps, mcpPool, reminderMark, reminderDisclosureCounts, runId, sessionId, onceLedger, roster, rosterSeat, remoteToolOffload, toolFaceSnapshot, toolEffects, axisExplicitNegatives, irreversibilityTier, irreversibleTools, egressTools, toolMarkSources, abortController, rollback } = input;
+    const { lockedPreflight, hostFloor, spec, deps, mcpPool, reminderMark, reminderDisclosureCounts, runId, sessionId, onceLedger, roster, rosterSeat, remoteToolOffload, toolFaceSnapshot, toolEffects, axisExplicitNegatives, irreversibilityTier, irreversibleTools, egressTools, toolMarkSources, abortController, rollback } = input;
     const markedBy = (name, source) => {
         const set = toolMarkSources.get(name);
         if (set !== undefined)
@@ -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] : [])]), hostFloor)
         :
             { 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.",
@@ -166,7 +167,7 @@ export async function prepareProtocolTools(input) {
     foldProtocolAxes(mcp.toolAxes, "MCP");
     const a2aDeclared = lockedPreflight.a2a;
     const a2a = a2aDeclared
-        ? await materializeA2aTools(a2aDeclared, spec.principal, abortController.signal)
+        ? await materializeA2aTools(a2aDeclared, spec.principal, abortController.signal, hostFloor)
         : { tools: [], toolAxes: [], warnings: [], statuses: [], refresh: async () => [], dispose: async () => { } };
     if (a2aDeclared)
         rollback.push(function a2aDispose() { return a2a.dispose(); });

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 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) {
@@ -114,9 +116,7 @@ export function prepareSafetyScan(input) {
         }
     }
     const candidates = engineCandidatesOf(spec, deps);
-    const engineNames = new Set(candidates.map(([n]) => n));
     for (const t of survivors.values()) {
-        const tier = tierOf(t);
         for (const alias of t.aliases ?? []) {
             if (alias === t.name || survivors.has(alias))
                 continue;
@@ -125,27 +125,12 @@ export function prepareSafetyScan(input) {
                 continue;
             claimedAliases.add(alias);
             if (t.effect)
-                toolEffects.set(alias, t.effect);
-            if (engineNames.has(alias))
-                continue;
-            if (tier !== undefined) {
-                irreversibilityTier.set(alias, tier);
-                if (tier === "always" || tier === "maybe") {
-                    irreversibleTools.add(alias);
-                    markedBy(alias, "deployment");
-                }
-            }
-            if (t.reversibilityProbe)
-                reversibilityProbes.set(alias, t.reversibilityProbe);
-            if (t.egress) {
-                egressTools.add(alias);
-                markedBy(alias, "deployment");
-            }
+                declared.set(alias, t.effect);
         }
     }
     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-suspend-saga.d.ts

@@ -114,6 +114,8 @@ export interface PrepareSuspendSagaInput {
     writeFaceCheckpointSection: () => SerializedCheckpointState["writeFace"];
     /** borrowed-readonly — the inherited-gate phase's SKILL-GRANT section builder (the row's `skillGrants`). */
     skillGrantCheckpointSection: () => SerializedCheckpointState["skillGrants"];
+    /** borrowed-readonly — the leg's skill scopes (the mods admission's record): the row's `skillScopes`, read at the park. */
+    skillScopesCheckpointSection: () => SerializedCheckpointState["skillScopes"];
     /** borrowed-readonly — the leg's reminder provenance mark (travels with the row). */
     reminderMark: string;
     /** borrowed-readonly — the hand's live tracked cwd, or undefined; `current` is read at mint time. Not written here. */

package/dist/core/runner/prepare-suspend-saga.js

@@ -82,9 +82,10 @@ function stampPlacementRootSessionId(placementRootResolved) {
     return placementValueOrAbsent(placementRootResolved);
 }
 export function prepareSuspendSaga(input) {
-    const { gateMachineryActive, abortController, harness, checkpointStore, deps, sessionId, hostTaskId, taskScope, liveSpendRef, resume, nestedStats, internals, activeTools, outputRef, readFileStateForCheckpoint, faceCheckpointSection, writeFaceCheckpointSection, skillGrantCheckpointSection, reminderMark, handsCwdRef, handsRoot, handsHome, worktreeSessionRef, undeliveredContinuationRef, inheritedParentConstraints, seedInheritedGate, ancestorRulesNow, inheritedShellGate, permissionMode, inheritedAdmittedOrgScopes, inheritedPathRuleAnchors, inheritedPathRuleInstallations, ownOrgVerdictRef, orgGovernedProvenance, announcedListingsRef, gitStatusRef, hookIdentity, placementRootResolved, checkpointScope, toolCeiling, toolListsJudged, ownToolLists, externalContentTargetActive, crossBoundary, remoteEnvFailures, memoryEngineSession, suspendLoopRef, ownedEnv, incompleteSuspendAdapter } = input;
+    const { gateMachineryActive, abortController, harness, checkpointStore, deps, sessionId, hostTaskId, taskScope, liveSpendRef, resume, nestedStats, internals, activeTools, outputRef, readFileStateForCheckpoint, faceCheckpointSection, writeFaceCheckpointSection, skillGrantCheckpointSection, skillScopesCheckpointSection, reminderMark, handsCwdRef, handsRoot, handsHome, worktreeSessionRef, undeliveredContinuationRef, inheritedParentConstraints, seedInheritedGate, ancestorRulesNow, inheritedShellGate, permissionMode, inheritedAdmittedOrgScopes, inheritedPathRuleAnchors, inheritedPathRuleInstallations, ownOrgVerdictRef, orgGovernedProvenance, announcedListingsRef, gitStatusRef, hookIdentity, placementRootResolved, checkpointScope, toolCeiling, toolListsJudged, ownToolLists, externalContentTargetActive, crossBoundary, remoteEnvFailures, memoryEngineSession, suspendLoopRef, ownedEnv, incompleteSuspendAdapter } = input;
     if (!gateMachineryActive)
         return { saga: undefined };
+    const taskAccess = { owner: hostTaskId, scope: taskScope, sessionId };
     const inFlightSpendMicroUsd = () => {
         const own = liveSpendRef.get?.().costMicroUsd ?? 0;
         const seededNested = resume?.seed.nestedStats.costMicroUsd;
@@ -114,6 +115,7 @@ export function prepareSuspendSaga(input) {
         readFace: faceCheckpointSection(),
         writeFace: writeFaceCheckpointSection(),
         skillGrants: skillGrantCheckpointSection(),
+        skillScopes: skillScopesCheckpointSection(),
         reminderMark,
         repairBundle: repairBundleForCheckpoint(parkedSpendMicroUsd),
         workspaceHandle,
@@ -122,10 +124,7 @@ export function prepareSuspendSaga(input) {
         handsHome,
         activeWorktree: worktreeSessionRef?.current ? { ...worktreeSessionRef.current } : undefined,
         runningBackgroundTasks: (() => {
-            const live = defaultTaskRegistry
-                .list({ owner: hostTaskId, scope: taskScope, sessionId })
-                .filter((t) => t.status === "pending" || t.status === "running")
-                .map((t) => ({ id: t.task_id, ...(t.description !== undefined ? { description: t.description } : {}) }));
+            const live = defaultTaskRegistry.liveTasks(taskAccess).filter((t) => t.status !== "parked").map((t) => ({ id: t.task_id, ...(t.description !== undefined ? { description: t.description } : {}) }));
             const owed = undeliveredContinuationRef.current.orphanTasks.filter((o) => !live.some((t) => t.id === o.id));
             const all = [...owed, ...live];
             return all.length > 0 ? all : undefined;
@@ -200,7 +199,7 @@ export function prepareSuspendSaga(input) {
             return { tag: "absent" };
         if (memoryEngineSession)
             await memoryEngineSession.harvest("checkpoint");
-        const recordUnwritten = await crossBoundary.owe(cp.leafId).then((entryId) => void (entryId !== undefined && (cp = { ...cp, leafId: entryId })), (err) => ({ err }));
+        const recordUnwritten = await crossBoundary.owe(cp.leafId, () => defaultTaskRegistry.owedDeliveries(taskAccess)).then((entryId) => void (entryId !== undefined && (cp = { ...cp, leafId: entryId })), (err) => ({ err }));
         if (cutSignal?.aborted) {
             if (remoteEnv !== undefined && remoteHandle?.snapshotId !== undefined) {
                 const back = await compensatePausedVM(remoteEnv, remoteHandle.snapshotId);

package/dist/core/runner/prepare-task.d.ts

@@ -62,7 +62,7 @@ export declare function resolveEnvLifetimeExpiry(env: ExecutionEnv, observedAt:
     unanchored: true;
 } | undefined;
 export { resolveCheckpointStore } from "../checkpoint-store.js";
-export { isFableFamilyModelId, resolveAttachmentsConfig, resolveModelPromptTraits, resolveTaskLimits } from "./prepare-config-doors.js";
+export { resolveAttachmentsConfig, resolvePromptTraits, resolveTaskLimits } from "./prepare-config-doors.js";
 export { rebaseWorkspacePath, rebaseWorkspacePathAcross } from "./workspace-path.js";
 /** Everything the run loop needs, built once by {@link prepareTask} (task setup, isolated from the loop). */
 /**