@sema-agent/core 7.51.1 → 7.52.0

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

@@ -1,101 +1,137 @@
 import { createHash } from "node:crypto";
 import { SEND_MESSAGE_TOOL_NAME } from "../../agents/send-message-tool.js";
 import { assemblePrompt } from "../../prompt-assembly/assemble.js";
-import { artifactDeclarations } from "../../prompt-assembly/artifact.js";
-import { resolveEpochAgainstBundled } from "../../prompt-assembly/epoch.js";
-import { SEMA_DEFAULT_PACK } from "../../prompt-assembly/packs/sema-default.js";
+import { adoptCenter, centerOverlaysOf } from "../../prompt-assembly/artifact.js";
+import { catalogDigestOf, digestOf, prepareEpochRecord } from "../../prompt-assembly/epoch.js";
+import { rendererVector } from "../../prompt-assembly/renderers.js";
+import { SEMA_DEFAULT_CATALOG } from "../../prompt-assembly/catalog/index.js";
+import { describeCatalog } from "../../prompt-assembly/explain.js";
+import { selectorsOf } from "../../prompt-assembly/select.js";
 import { auditToolCollisions, projectToolManifest } from "../../prompt-assembly/tool-catalog.js";
-import { buildEnvironmentContext, defaultPromptProvider } from "../../prompts/default.js";
+import { buildEnvironmentContext } from "../../prompts/default.js";
+import { raisePromptCompose } from "../mods/stations.js";
 import { protocolOf } from "../protocol-table.js";
-import { reminderMarkDeclaration } from "../reminder-mint.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) {
+    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.message !== undefined ? { message: o.message } : {}),
+        ...(o.when !== undefined ? { when: o.when } : {}),
+    }));
+}
 export async function preparePromptAssembly(input) {
-    const { session, deps, internals, resume, provider, userSystemPrompt, userAppendSystemPrompt, featureFlags, mcpInstructionsBlock, memoryBlock, envFacts, promptProfile, fableMitigations, tools, model, sessionId, reminderMark, onceLedger } = input;
+    const { session, deps, internals, resume, sugar, host, binding, modBus, featureFlags, mcpInstructionsBlock, memoryBlock, envFacts, promptProfile, fableMitigations, tools, model, sessionId, onceLedger } = input;
+    const topLevel = internals?.parentTaskId === undefined && internals?.parentSessionId === undefined && internals?.parentCenterArtifactDigest === undefined;
+    const stored = await session.getPromptEpoch();
     let centerAdoption;
-    let centerAdoptionFresh = false;
     {
-        const failUnavailable = (digest, via) => {
-            const e = new Error(`prompt snapshot unavailable: ${via} center prompt artifact ${digest.slice(0, 23)}… has no verified resolvable copy (artifact store miss/corrupt${deps.promptSource === undefined ? "; RunnerDeps.promptSource is not configured" : ""}) — refusing to recompose a hybrid prompt (protocol §9.2)`);
-            e.code = "prompt.snapshot_unavailable";
-            throw e;
+        const failUnavailable = (what) => {
+            throw Object.assign(new Error(`prompt snapshot unavailable: ${what} (artifact source miss / not verifiable here${deps.promptSource === undefined ? "; RunnerDeps.promptSource is not configured" : ""}) — refusing to recompose a hybrid prompt`), { code: "prompt.snapshot_unavailable" });
+        };
+        const resolvePinned = async (digest, sourceRevision, via) => {
+            const art = await deps.promptSource?.get(digest);
+            const adopted = art !== undefined ? adoptCenter(art, sourceRevision) : undefined;
+            return adopted ?? failUnavailable(`${via} center prompt artifact ${digest.slice(0, 23)}… has no verified resolvable copy`);
         };
-        const pinnedEarly = await session.getPromptEpoch();
-        if (pinnedEarly?.centerArtifactDigest !== undefined) {
-            const art = await deps.promptSource?.get(pinnedEarly.centerArtifactDigest);
-            if (art === undefined)
-                failUnavailable(pinnedEarly.centerArtifactDigest, "this session is pinned to");
-            centerAdoption = { artifact: art, ...(pinnedEarly.sourceRevision !== undefined ? { sourceRevision: pinnedEarly.sourceRevision } : {}) };
+        const pinned = stored?.kind === "pin" ? stored.descriptor : undefined;
+        const retiredCenterPin = stored?.kind === "legacy" && stored.centerPinned;
+        if (pinned?.layers.center !== undefined) {
+            centerAdoption = await resolvePinned(pinned.layers.center, pinned.sourceRevision, "this session is pinned to");
         }
-        else if (pinnedEarly === undefined) {
+        else if (retiredCenterPin && topLevel) {
+            const state = deps.promptSource?.sourceState() ?? "unavailable";
+            if (state === "unavailable")
+                failUnavailable("this session's center pin is of a retired shape and the center source has no verified state; the pin is kept");
+            if (state === "active") {
+                const cand = deps.promptSource.current();
+                centerAdoption = (cand !== undefined ? adoptCenter(cand, cand.sourceRevision) : undefined) ?? failUnavailable("this session's center pin is of a retired shape and the current candidate");
+            }
+        }
+        else if (stored === undefined || retiredCenterPin) {
             if (internals?.parentCenterArtifactDigest !== undefined) {
-                const art = await deps.promptSource?.get(internals.parentCenterArtifactDigest);
-                if (art === undefined)
-                    failUnavailable(internals.parentCenterArtifactDigest, "the spawning parent adopted");
-                centerAdoption = {
-                    artifact: art,
-                    ...(internals.parentCenterSourceRevision !== undefined ? { sourceRevision: internals.parentCenterSourceRevision } : {}),
-                };
+                centerAdoption = await resolvePinned(internals.parentCenterArtifactDigest, internals.parentCenterSourceRevision, "the spawning parent adopted");
             }
-            else if (resume === undefined && internals?.parentTaskId === undefined && internals?.parentSessionId === undefined) {
-                const candidate = deps.promptSource?.current();
-                if (candidate !== undefined && !hasConversationContent(await session.getBranch())) {
-                    centerAdoption = { artifact: candidate.artifact, sourceRevision: candidate.sourceRevision };
-                    centerAdoptionFresh = true;
+            else if (stored === undefined && topLevel && resume === undefined) {
+                const cand = deps.promptSource?.current();
+                if (cand !== undefined && !hasConversationContent(await session.getBranch())) {
+                    centerAdoption = adoptCenter(cand, cand.sourceRevision);
+                    if (centerAdoption === undefined)
+                        deps.onError?.(new Error(`center prompt candidate ${cand.artifactDigest.slice(0, 23)}… does not verify on this engine; the session starts with no center layer`), { phase: "prompt-constitution", sessionId });
                 }
             }
         }
     }
-    const buildAssembleInputs = (centerDecls) => ({
-        provider,
-        isDefaultProvider: provider === defaultPromptProvider,
-        userSystemPrompt,
-        userAppendSystemPrompt,
-        tools: tools.map((t) => (t.aliases === undefined ? { ...t } : { ...t, aliases: [...t.aliases] })),
-        facts: {
-            supervisorEnabled: false,
-            teammateEnabled: internals?.explicitAgentName !== undefined && tools.some((t) => t.name === SEND_MESSAGE_TOOL_NAME),
-            ...featureFlags,
-            orchestrationEnabled: featureFlags.orchestrationEnabled && tools.some((t) => t.name === "Workflow"),
-            orchestrationDeferred: featureFlags.orchestrationDeferred && tools.some((t) => t.name === "Workflow"),
-            promptProfile,
-            fableMitigations,
-        },
+    const facts = {
+        supervisorEnabled: false,
+        teammateEnabled: internals?.explicitAgentName !== undefined && tools.some((t) => t.name === SEND_MESSAGE_TOOL_NAME),
+        ...featureFlags,
+        orchestrationEnabled: featureFlags.orchestrationEnabled && tools.some((t) => t.name === "Workflow"),
+        orchestrationDeferred: featureFlags.orchestrationDeferred && tools.some((t) => t.name === "Workflow"),
+        promptProfile,
+        fableMitigations,
+    };
+    const selectors = selectorsOf(facts, host);
+    const selectorRecord = {
+        ...(binding !== undefined ? { binding } : {}),
+        traits: [...selectors.traits].sort(),
+        host: { role: selectors.host.role, form: selectors.host.form },
+        facts: { ...selectors.facts },
+    };
+    const centerOverlays = centerOverlaysOf(centerAdoption, binding);
+    const lowerAdds = new Map();
+    for (const { overlay } of [...sugar, ...centerOverlays])
+        if (overlay.op === "add")
+            lowerAdds.set(overlay.id, overlay.target);
+    const composed = await raisePromptCompose(modBus, {
+        model: model.id,
+        catalog: describeCatalog().sections,
+        selectors: { traits: [...selectors.traits], host: selectors.host, facts: selectors.facts },
+    }, { lowerAdds, ...(input.signal !== undefined ? { signal: input.signal } : {}) });
+    for (const w of composed.warnings)
+        deps.onError?.(new Error(w), { phase: "prompt-constitution", sessionId });
+    const taskOverlays = [...sugar, ...composed.task];
+    const buildAssembleInputs = (center) => ({
+        taskOverlays,
+        centerOverlays: centerOverlaysOf(center, binding),
+        deployOverlays: composed.deploy,
+        host,
+        tools,
+        facts,
+        ...(envFacts.cwd !== undefined ? { workspaceFolder: envFacts.cwd } : {}),
         mcpInstructionsBlock,
         memoryBlock,
         buildEnvBlock: (date) => buildEnvironmentContext({ ...envFacts, date }) || undefined,
         date: envFacts.date,
-        envFacts,
         ...(model.promptGuidance && model.promptGuidance.length > 0 ? { modelGuidance: model.promptGuidance.join("\n\n") } : {}),
         onWarn: (message, phase) => deps.onError?.(new Error(message), { phase, sessionId }),
-        ...(centerDecls !== undefined ? { centerDeclarations: centerDecls } : {}),
     });
-    const assembled = assemblePrompt(buildAssembleInputs(centerAdoption !== undefined ? artifactDeclarations(centerAdoption.artifact) : undefined));
-    if (centerAdoption !== undefined && assembled.centerMounted !== true) {
-        const ownsWholePrompt = assembled.constitution === "provider-assembled";
-        const digest = centerAdoption.artifact.artifactDigest.slice(0, 23);
-        if (ownsWholePrompt) {
-            const e = new Error(`center prompt artifact ${digest}… cannot mount: this PromptProvider owns the whole prompt (assembled-identity pass-through) — upgrade the provider to stableBlocks/stableSystem or remove RunnerDeps.promptSource for this deployment`);
-            e.code = "prompt.center_unmountable";
-            throw e;
-        }
-        deps.onError?.(new Error(centerAdoptionFresh
-            ? `prompt-constitution: center prompt artifact ${digest}… contributed NO section to this prompt — every section it declares collides with a PromptProvider stableBlocks declaration of the same id, and the deployment-local declaration wins. This session runs on the bundled prompt and is deliberately NOT pinned to the artifact (a pin claiming content the model never received would be durable and wrong). Rename the colliding section ids on either side to adopt it; the per-section collisions are reported individually on this channel.`
-            : `prompt-constitution: this session is pinned to center prompt artifact ${digest}…, but under the CURRENT PromptProvider every section that artifact declares collides with a stableBlocks declaration of the same id, so none of them compiled into this prompt. The session keeps its pin and continues on the bundled prompt — its epoch's declaredSections record what actually compiled. Rename the colliding section ids on either side to restore the artifact's content.`), { phase: "prompt-constitution", sessionId });
-        if (centerAdoptionFresh)
-            centerAdoption = undefined;
-    }
+    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 bindingLayer = digestOf(selectorRecord);
+    const renderers = rendererVector();
+    const identityFor = (center) => ({
+        layers: {
+            catalog: CATALOG_DIGEST,
+            renderers,
+            ...(center !== undefined ? { center: center.artifact.artifactDigest } : {}),
+            ...(deployLayer !== undefined ? { deploy: deployLayer } : {}),
+            ...(taskLayer !== undefined ? { task: taskLayer } : {}),
+            binding: bindingLayer,
+        },
+        ...(center?.sourceRevision !== undefined ? { sourceRevision: center.sourceRevision } : {}),
+    });
+    const assembled = assemblePrompt(buildAssembleInputs(centerAdoption));
     let systemPrompt = assembled.systemPrompt;
-    if (!systemPrompt.includes(reminderMarkDeclaration(reminderMark))) {
-        deps.onError?.(new Error("reminder-mark declaration missing from the assembled system prompt: this run's PromptProvider owns the prompt and did not render the mark declaration, so engine <system-reminder> tags carry a mark the model is never told about (the impersonation defense is inactive for this deployment). Render `reminderMarkDeclaration(ctx.reminderMark)` (exported; the value rides StablePromptContext.reminderMark) in the provider, or accept the disclosure."), { phase: "config", sessionId });
-    }
-    const renderWithDate = assembled.renderWithDate
-        ? (date) => {
-            systemPrompt = assembled.renderWithDate(date);
-            return systemPrompt;
-        }
-        : undefined;
-    const promptConstitution = assembled.constitution;
+    const renderWithDate = (date) => {
+        systemPrompt = assembled.renderWithDate(date);
+        return systemPrompt;
+    };
     const promptBlocks = assembled.blocks;
     const collisionAudit = auditToolCollisions(tools);
     for (const y of collisionAudit.yields) {
@@ -104,38 +140,34 @@ export async function preparePromptAssembly(input) {
     for (const c of collisionAudit.aliasCollisions) {
         onceLedger.onError(new Error(`tool mount: alias "${c.alias}" is claimed by both "${c.owners[0]}" and "${c.owners[1]}" (design/141 warn face — name resolution serves the later mount)`), { phase: "config", sessionId });
     }
+    const promptIdentity = identityFor(centerAdoption);
+    const priorConversation = stored === undefined ? hasConversationContent(await session.getBranch()) : true;
+    const record = prepareEpochRecord(stored, promptIdentity.layers, { priorConversation, ...(promptIdentity.sourceRevision !== undefined ? { sourceRevision: promptIdentity.sourceRevision } : {}) });
+    if (record !== undefined)
+        await session.appendPromptEpoch(record);
+    const current = record ?? (stored?.kind === "pin" ? stored.descriptor : undefined);
     const saltedHash = (text) => createHash("sha256").update(PROMPT_HASH_SALT).update(text).digest("hex").slice(0, 12);
+    const contentHashOf = (s) => s.renderer !== undefined || s.chain.some((l) => l.source === "task")
+        ? `salted:${createHash("sha256").update(PROMPT_HASH_SALT).update(s.text).digest("hex")}`
+        : `sha256:${createHash("sha256").update(s.text).digest("hex")}`;
     const promptManifest = {
-        constitution: promptConstitution,
+        identity: { artifact: current.identity, layers: current.layers, epoch: current.epoch, activatedBy: current.activatedBy },
+        selectors: selectorRecord,
         blocks: promptBlocks.map((b) => ({ id: b.id, chars: b.text.length, hash: saltedHash(b.text) })),
-        ...(assembled.sections
-            ? { sections: assembled.sections.map((s) => ({ id: s.id, slot: s.slot, carrier: s.carrier, cadence: s.cadence, cacheClass: s.cacheClass, chars: s.text.length, hash: saltedHash(s.text), ...(s.declaredContentHash !== undefined ? { contentHash: s.declaredContentHash } : {}) })) }
-            : {}),
+        sections: assembled.sections.map((s) => ({
+            id: s.id,
+            band: s.band,
+            rank: s.rank,
+            ...(s.variant !== undefined ? { variant: s.variant } : {}),
+            ...(s.renderer !== undefined ? { renderer: { ...s.renderer } } : {}),
+            chars: s.text.length,
+            locale: s.chain.some((l) => l.source !== "bundled" && l.superseded !== true) ? "overlay" : "canonical",
+            contentHash: contentHashOf(s),
+            chain: s.chain.map((l) => ({ ...l })),
+        })),
+        ...(assembled.superseded.length > 0 ? { superseded: assembled.superseded.map((s) => ({ ...s })) } : {}),
         tools: projectToolManifest(tools, (t) => protocolOf(t.name)?.id ?? "caller"),
     };
-    const epochDeclaredSections = (assembled.sections ?? [])
-        .filter((s) => s.origin === "provider")
-        .map((s) => ({ id: s.id, slot: s.slot, chars: s.text.length, ...(s.declaredContentHash !== undefined ? { contentHash: s.declaredContentHash } : {}) }));
-    let epochArtifactDigestForSnapshot = "";
-    {
-        const pinned = await session.getPromptEpoch();
-        const resolved = resolveEpochAgainstBundled(pinned, SEMA_DEFAULT_PACK, epochDeclaredSections);
-        epochArtifactDigestForSnapshot = resolved.descriptor.artifactDigest;
-        if (resolved.migrated) {
-            const priorConversation = pinned === undefined ? hasConversationContent(await session.getBranch()) : true;
-            const activatedBy = pinned === undefined && !priorConversation ? "session_start" : "legacy_migration";
-            await session.appendPromptEpoch({
-                ...resolved.descriptor,
-                activatedBy,
-                ...(centerAdoption !== undefined
-                    ? {
-                        centerArtifactDigest: centerAdoption.artifact.artifactDigest,
-                        ...(centerAdoption.sourceRevision !== undefined ? { sourceRevision: centerAdoption.sourceRevision } : {}),
-                    }
-                    : {}),
-            });
-        }
-    }
     return {
         systemPromptSeat: {
             get current() {
@@ -148,9 +180,10 @@ export async function preparePromptAssembly(input) {
         renderWithDate,
         systemBlocks: assembled.systemBlocks,
         promptManifest,
-        epochDeclaredSections,
-        epochArtifactDigestForSnapshot,
+        promptIdentity,
         buildAssembleInputs,
+        identityFor,
+        adoptsCandidates: topLevel,
         centerAdoptionRef: {
             get current() {
                 return centerAdoption;

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

@@ -1,7 +1,7 @@
 /**
- * PrepareTask's PROMPT-INPUTS phase: the prompt provider selection, the runtime
- * feature flags the harness-context block gates on (so it never claims a mechanism the task lacks),
- * the three-source user system prompt + the caller's append block, the fenced MCP server-instructions
+ * PrepareTask's PROMPT-INPUTS phase: the runtime feature flags the harness-context block gates on (so it never
+ * claims a mechanism the task lacks), the request-body sugar's overlays (the task's role text and appended block),
+ * the fenced MCP server-instructions
  * block, the environment facts (client zone + date basis, knowledge cutoff, the deployment's sandbox
  * axes, resume-continuity facts on a durable-resume leg only, the hands facts + the one batched env
  * probe with its cwd/pwd alignment guard) and the git-status lane probe. The body is moved verbatim
@@ -19,9 +19,11 @@
  * Nothing here throws on its own: the env probe and the alignment guard are best-effort (a stub/odd env
  * just omits the shell-derived facts), and the git lane degrades through `onDegrade` → `deps.onError`.
  */
+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, type PromptProvider } from "../../prompts/default.js";
+import { type EnvironmentFacts } from "../../prompts/default.js";
+import type { SourcedOverlay } from "../../prompt-assembly/overlay.js";
 import type { ContainmentFace } from "../../tools/fs/index.js";
 import type { LockedPreflight } from "../locked-config.js";
 import type { MaterializedMcp } from "../mcp.js";
@@ -33,14 +35,15 @@ import type { AdvertisedWritableDirs } from "./advertised-writable-dirs.js";
 import { type GitStatusLaneRef } from "./git-status-frame.js";
 import { type ContextWindowOverlay } from "../context-settings.js";
 export interface PreparePromptInputsInput {
-    /** borrowed-readonly — the REBOUND spec (`spec′`). Read: `promptProvider`, `hooks` (flag), `systemPrompt`
-     *  / `appendSystemPrompt` (the user prompt sources), `clientContext` (zone, email), `envFacts` (the
-     *  deployment's sandbox + resume facts), `compaction` (the within-task flag). Never mutated. */
-    spec: Pick<TaskSpec, "promptProvider" | "hooks" | "systemPrompt" | "appendSystemPrompt" | "clientContext" | "envFacts" | "compaction">;
-    /** borrowed-readonly — deployment deps: `promptProvider` (fallback), `hooks` (flag), `onError` (the
-     *  operator lane: fail-closed advisory, cwd misalignment, git-lane degrade), `modelKnowledgeCutoffs`.
-     *  Receiver preserved (`deps.onError?.(…)`). */
-    deps: Pick<RunnerDeps, "promptProvider" | "hooks" | "onError" | "modelKnowledgeCutoffs">;
+    /** borrowed-readonly — the REBOUND spec (`spec′`). Read: `systemPrompt` / `appendSystemPrompt` (handed whole to the
+     *  request-body sugar), `clientContext` (zone, email), `envFacts` (the deployment's sandbox + resume facts),
+     *  `compaction` (the within-task flag). Never mutated. */
+    spec: Pick<TaskSpec, "systemPrompt" | "appendSystemPrompt" | "clientContext" | "envFacts" | "compaction">;
+    /** borrowed-readonly — deployment deps: `onError` (the operator lane: fail-closed advisory, cwd misalignment,
+     *  git-lane degrade), `modelKnowledgeCutoffs`. Receiver preserved (`deps.onError?.(…)`). */
+    deps: Pick<RunnerDeps, "onError" | "modelKnowledgeCutoffs">;
+    /** borrowed-readonly — the leg's mods bus (the harness-context block's "hooks may intercept" claim reads it). */
+    modBus: LegModBus;
     /** borrowed-readonly — the self-orchestration fail-closed advisory (null = nothing to announce),
      *  evaluated by the DRIVER against the whole spec/deps (see the module header). */
     failClosedReason: string | null;
@@ -65,7 +68,7 @@ export interface PreparePromptInputsInput {
     /** 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 third prompt source). `undefined` on a standalone prepare. */
+     *  `defaultSystemPrompt` (the sugar's third source). `undefined` on a standalone prepare. */
     internals: Pick<RunInternals, "goalMode" | "isolation" | "defaultSystemPrompt"> | undefined;
     /** borrowed-readonly — the resolved, role-folded reasoning tier (the awareness flag's input). */
     thinking: ThinkingLevel | undefined;
@@ -111,14 +114,10 @@ export interface PreparePromptInputsInput {
     contextOverlay?: ContextWindowOverlay;
 }
 export interface PreparePromptInputsResult {
-    /** owned — the prompt provider in force (`spec` ?? `deps` ?? the default). */
-    provider: PromptProvider;
     /** owned — the runtime feature flags (see {@link PromptFeatureFlags}). */
     featureFlags: PromptFeatureFlags;
-    /** owned — the user system prompt: `spec.systemPrompt ?? resolvedRole.systemPrompt ?? internals.defaultSystemPrompt`. */
-    userSystemPrompt: string | undefined;
-    /** owned — the caller's append block (`spec.appendSystemPrompt`). */
-    userAppendSystemPrompt: string | undefined;
+    /** owned — the request-body sugar's overlays (the task class's first contributions), in application order. */
+    sugar: readonly SourcedOverlay[];
     /** 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,4 +1,5 @@
-import { formatLocalDate, isValidTimeZone, promptProviderInForce } from "../../prompts/default.js";
+import { formatLocalDate, isValidTimeZone } from "../../prompts/default.js";
+import { sugarOverlays } from "../../prompt-assembly/sugar.js";
 import { isIsolated } from "../remote-env.js";
 import { readDateAnchor } from "./announce-once-ledger.js";
 import { probeGitStatusLane } from "./git-status-frame.js";
@@ -7,10 +8,8 @@ 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 provider = promptProviderInForce(spec.promptProvider, deps.promptProvider);
     const promptPolicyEnabled = Boolean(lockedPreflight.toolPolicy);
-    const promptHooks = spec.hooks ?? deps.hooks;
-    const promptHooksEnabled = Boolean(promptHooks?.preToolUse || promptHooks?.postToolUse);
+    const promptHooksEnabled = input.modBus.hasHandlers("classic.PreToolUse") || input.modBus.hasHandlers("classic.PostToolUse");
     if (failClosedReason) {
         deps.onError?.(new Error(failClosedReason), { phase: "config", sessionId });
     }
@@ -31,8 +30,7 @@ export async function preparePromptInputs(input) {
         withinTaskCompactionEnabled: compactionEnabled(spec.compaction?.enabled, input.contextOverlay) && (spec.compaction?.withinTask ?? true),
         isSubagent: delegation.isNonForkChild,
     };
-    const userSystemPrompt = spec.systemPrompt ?? resolvedRole.systemPrompt ?? internals?.defaultSystemPrompt;
-    const userAppendSystemPrompt = spec.appendSystemPrompt;
+    const sugar = sugarOverlays({ spec, resolvedRole, ...(internals !== undefined ? { internals } : {}) });
     const mcpInstructionsBlock = mcp.serverInstructions.length
         ? `# MCP Server Instructions\n${mcp.serverInstructions.map(renderMcpInstructionsEntry).join("\n\n")}`
         : undefined;
@@ -143,5 +141,5 @@ export async function preparePromptInputs(input) {
         taskRoot: taskRootFinal,
         onDegrade: (reason) => deps.onError?.(new Error(`env git snapshot degraded — ${reason}`), { phase: "degraded", sessionId, classification: "env-git-snapshot" }),
     });
-    return { provider, featureFlags, userSystemPrompt, userAppendSystemPrompt, mcpInstructionsBlock, envFacts, tzValid, userTz, dateAnchor, gitStatusRef };
+    return { featureFlags, sugar, mcpInstructionsBlock, envFacts, tzValid, userTz, dateAnchor, gitStatusRef };
 }

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

@@ -30,18 +30,20 @@ import type { LockedPreflight } from "../locked-config.js";
 import type { RunnerDeps, TaskSpec, ToolEffect } from "../types.js";
 import type { AnnounceOnceSink, IrreversibilityTier, Prepared, RollbackStack, ToolFaceSnapshot } from "./contracts.js";
 import { RosterBuilder, type ToolRosterDeltaSeat } from "../tool-roster.js";
+import type { LegModBus } from "../mods/stations.js";
 export interface PrepareProtocolToolsInput {
     /** borrowed-readonly — the frozen preflight; only `mcp` (the declared server entries) is read: the
      *  materialize input, the RefreshMcpTools mount predicate, and whether a real client was acquired. */
     lockedPreflight: Pick<LockedPreflight, "mcp">;
     /** borrowed-readonly — the REBOUND spec. Read: `principal` (the MCP header / the A2A identity), `tools`
-     *  (the caller names both reserved-name guards check against), `a2a` (the peer entries), `promptProvider` (with
-     *  `deps.promptProvider`: the provider in force, whose section seat disposes of each server's instructions). */
-    spec: Pick<TaskSpec, "principal" | "tools" | "a2a" | "promptProvider">;
+     *  (the caller names both reserved-name guards check against), `a2a` (the peer entries). */
+    spec: Pick<TaskSpec, "principal" | "tools" | "a2a">;
     /** 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. */
-    deps: Pick<RunnerDeps, "onElicit" | "mcpImageResizer" | "onError" | "mcpRevocations" | "onNotice" | "promptProvider">;
+    deps: Pick<RunnerDeps, "onElicit" | "mcpImageResizer" | "onError" | "mcpRevocations" | "onNotice">;
+    /** borrowed-readonly — the leg's mods bus: its `prompt.section` station disposes of each server's instructions at the dial. */
+    modBus: LegModBus;
     /** borrowed-readonly — the run tree's MCP connection pool (the leg leases its connections from it) and whether THIS leg created it
      *  (then this leg's dispose also closes it). Absent for a leg that declares no server. */
     mcpPool?: {

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

@@ -9,7 +9,7 @@ import { REFRESH_MCP_TOOLS_TOOL_NAME, toolFace } from "../tool-catalog-entries.j
 import { MCP_NAMESPACE, A2A_NAMESPACE } from "../protocol-table.js";
 import { mintNamespacePrefix } from "../protocol-naming.js";
 import { applyMcpToolFaces } from "./tool-face-overlay.js";
-import { promptProviderInForce } from "../../prompts/default.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;
@@ -25,7 +25,7 @@ export async function prepareProtocolTools(input) {
         throw Object.assign(new Error(`MCP server name ${JSON.stringify(overPeer.name.slice(0, 40) + "…")} is ${overPeer.name.length} characters; a peer rides every roster row of its tools and the roster's bound on a name is ${TOOL_WIRE_NAME_MAX_CHARS}.`), { code: "config.tool_name_too_long" });
     }
     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 }, promptProviderInForce(spec.promptProvider, deps.promptProvider))
+        ? 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))
         :
             { 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)

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

@@ -1,4 +1,4 @@
-import { NAMESPACED_NAME_SHAPES, carriesNamespaceSeparator } from "../protocol-table.js";
+import { callerToolNameProblem } from "../caller-tool-name.js";
 import { engineCardTypes, handBandEffects } from "../tool-registry.js";
 import { callerCardIdOf, offendingResultCard, rosterMemberBoundProblem, schemaKeyBoundProblem, survivorsByName } from "../tool-roster.js";
 import { toolFaceProblem } from "./tool-face-overlay.js";
@@ -65,18 +65,14 @@ export function prepareSafetyScan(input) {
                 throw e;
             }
         }
-        if (carriesNamespaceSeparator(t.name)) {
-            const e = new Error(`Tool name "${t.name}" is invalid: "__" is reserved for the engine's protocol tool namespaces (${NAMESPACED_NAME_SHAPES}) and must not appear in a caller tool name.`);
+        for (const [what, n] of [["name", t.name], ...(t.aliases ?? []).map((a) => ["alias", a])]) {
+            const problem = callerToolNameProblem(n);
+            if (problem === undefined)
+                continue;
+            const e = new Error(`Tool ${what} ${JSON.stringify(n)}${what === "alias" ? ` (of ${JSON.stringify(t.name)})` : ""} is invalid: ${problem}.`);
             e.code = "config.tool_name_invalid";
             throw e;
         }
-        for (const alias of t.aliases ?? []) {
-            if (carriesNamespaceSeparator(alias)) {
-                const e = new Error(`Tool alias "${alias}" (of "${t.name}") is invalid: "__" is reserved for the engine's protocol tool namespaces (${NAMESPACED_NAME_SHAPES}) and must not appear in a caller tool alias.`);
-                e.code = "config.tool_name_invalid";
-                throw e;
-            }
-        }
         if (t.effect && survivors.get(t.name) === t) {
             toolEffects.set(t.name, t.effect);
         }

package/dist/core/runner/prepare-suspend-saga.d.ts

@@ -171,6 +171,12 @@ export interface PrepareSuspendSagaInput {
     toolCeiling: readonly import("../tool-face.js").ToolSelectorLayer[] | undefined;
     /** borrowed-readonly — the spawning run's judgment of this leg's own lists, while it is bound to them (`boundToolListsJudgment`), the row's `toolListsJudged` stamp. */
     toolListsJudged: string | undefined;
+    /** borrowed-readonly — whose lists this leg's own are (the live seat, else the resumed row's), the row's `ownToolLists` stamp. */
+    ownToolLists: {
+        readonly toolName: string;
+        readonly definition?: string;
+        readonly lists: string;
+    } | undefined;
     /** borrowed-readonly — the external-content-target fold (the row's monotonic bit). */
     externalContentTargetActive: boolean;
     /** borrowed-mutable — the run-scoped remote-lifecycle failure log (`Prepared.remoteEnvFailures`). Writer here: the

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

@@ -3,6 +3,7 @@ import { isRemoteExecutionEnv, isSuspendable, RemoteExecutionError } from "../re
 import { resolveDeclaredFidelity } from "../checkpoint-store.js";
 import { judgeAsStored, stampCheckpointRequirements } from "../checkpoint-requirements.js";
 import { constraintChainDigest, constraintChainEntryOfLayer } from "../tool-policy.js";
+import { persistedToolNameList } from "../../agents/tool-filter.js";
 import { raceSettlementAgainstSignal } from "./abort-race.js";
 import { placementValueOrAbsent } from "./checkpoint-scope.js";
 import { serializeAnnouncedListings } from "./announce-once-ledger.js";
@@ -81,7 +82,7 @@ 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, externalContentTargetActive, 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, 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, remoteEnvFailures, memoryEngineSession, suspendLoopRef, ownedEnv, incompleteSuspendAdapter } = input;
     if (!gateMachineryActive)
         return { saga: undefined };
     const inFlightSpendMicroUsd = () => {
@@ -178,8 +179,9 @@ export function prepareSuspendSaga(input) {
         placementRootSessionId: stampPlacementRootSessionId(placementRootResolved),
         externalContentTarget: externalContentTargetActive ? true : undefined,
         legScope: checkpointScope,
-        toolCeiling: toolCeiling !== undefined ? toolCeiling.map((l) => ({ ...(l.allow !== undefined ? { allow: [...l.allow] } : {}), deny: [...l.deny] })) : undefined,
+        toolCeiling: toolCeiling !== undefined ? toolCeiling.map((l) => ({ ...(l.allow !== undefined ? { allow: persistedToolNameList(l.allow, "allowed") } : {}), deny: persistedToolNameList(l.deny, "denied") })) : undefined,
         toolListsJudged,
+        ownToolLists: ownToolLists !== undefined ? { toolName: ownToolLists.toolName, ...(ownToolLists.definition !== undefined ? { definition: ownToolLists.definition } : {}), lists: ownToolLists.lists } : undefined,
     });
     const compensatePausedVM = (remoteEnv, snapshotId) => compensateUnparkedPause(remoteEnv, snapshotId, {
         boundMs: PARK_COMPENSATION_TIMEOUT_MS,
@@ -212,15 +214,15 @@ export function prepareSuspendSaga(input) {
             const committedCount = cp.state.inheritedGate?.parentConstraintCount;
             if (cp.state.inheritedGate?.requiresParentConstraint === true &&
                 !screeningParkDisclosedRef.done &&
-                (inheritedParentConstraints ?? []).some((pc) => pc.preToolUse !== undefined)) {
+                (inheritedParentConstraints ?? []).some((pc) => pc.mods !== undefined)) {
                 screeningParkDisclosedRef.done = true;
                 try {
                     deps.onError?.(new Error(`durable park under an inherited PreToolUse SCREENING constraint: this checkpoint records ` +
                         `requiresParentConstraint with parentConstraintCount=${committedCount ?? "(unrecorded)"}, and the live ` +
                         `closures cannot be persisted. A resume on THIS Runner re-supplies them automatically; a resume on a fresh ` +
                         `Runner (restart / another replica) must hand back the whole chain via resumeStream(..., internals), ` +
-                        `rebuilding the screening entry with createPreToolUseConstraintPolicy(hook, env) — otherwise the row stays ` +
-                        `pending. If the face only observes, declare Hooks.preToolUseObservational and it stops entering the chain.`), { phase: "degraded", sessionId, classification: "screening-constraint-in-durable-chain" });
+                        `rebuilding the screening entry with createPreToolUseConstraintPolicy(chain, env) over the same registrations — ` +
+                        `otherwise the row stays pending. A handler declared { observe: true } never enters the chain.`), { phase: "degraded", sessionId, classification: "screening-constraint-in-durable-chain" });
                 }
                 catch {
                 }