@sema-agent/core 7.51.2 → 7.53.0

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

@@ -1,37 +1,42 @@
 import type { AgentTool } from "../../internal/harness.js";
 import type { Model } from "../../internal/llm.js";
 import { assemblePrompt, type AssembledPrompt } from "../../prompt-assembly/assemble.js";
-import { type PromptEpochArtifact } from "../../prompt-assembly/artifact.js";
-import { type EpochDeclaredSections } from "../../prompt-assembly/epoch.js";
-import { type EnvironmentFacts, type PromptProvider, type PromptTextDeclaration } from "../../prompts/default.js";
+import { type CenterAdoption } from "../../prompt-assembly/artifact.js";
+import { type RunPromptIdentity } from "../../prompt-assembly/epoch.js";
+import type { HostForm, HostRole } from "../../prompt-assembly/catalog/schema.js";
+import type { SourcedOverlay } from "../../prompt-assembly/overlay.js";
+import { type EnvironmentFacts } from "../../prompts/default.js";
+import { type LegModBus } from "../mods/stations.js";
 import { type StoredSession } from "../session.js";
 import type { RunnerDeps } from "../types.js";
 import type { AnnounceOnceSink, Prepared, PrepareResume, PromptFeatureFlags, RunInternals } from "./contracts.js";
-/** The center adoption a run composes under: the artifact and, when the source stamped one, its revision. */
-export type CenterAdoption = {
-    artifact: PromptEpochArtifact;
-    sourceRevision?: string;
-};
 export interface PreparePromptAssemblyInput {
-    /** borrowed-mutable — the acquired session. Read: `getPromptEpoch` (the pin, twice — the center arm and the epoch
-     *  resolution), `getBranch` (the freshness discriminator on the pinless arms). Writer here: `appendPromptEpoch`, the
-     *  ONE pin write of this leg (only when the resolution migrated). The acquire phase and the run loop write it elsewhere. */
+    /** borrowed-mutable — the acquired session. Read: `getPromptEpoch` (the stored record), `getBranch` (the freshness
+     *  discriminator on the record-less arms). Writer here: `appendPromptEpoch`, the ONE record write of this leg (only
+     *  when the run's identity differs from the stored record's). The acquire phase and the run loop write it elsewhere. */
     session: Pick<StoredSession, "getPromptEpoch" | "getBranch" | "appendPromptEpoch">;
-    /** borrowed-readonly — the deployment seats: `promptSource` (the center artifact store and its live candidate), `onError`
-     *  (the assembly's warn channel, the prompt-constitution line, the missing-declaration disclosure). Receiver preserved. */
+    /** borrowed-readonly — the deployment seats: `promptSource` (the center artifact source, its candidate and its
+     *  tri-state), `onError` (the assembly's warn channel). Receiver preserved. */
     deps: Pick<RunnerDeps, "promptSource" | "onError">;
-    /** borrowed-readonly — the trusted spawn-side channel: the parent's center closure (`parentCenterArtifactDigest`,
+    /** borrowed-readonly — the trusted spawn-side channel: the parent's center layer (`parentCenterArtifactDigest`,
      *  `parentCenterSourceRevision`), the top-level freshness facts (`parentTaskId`, `parentSessionId`) and the named-child
      *  fact the teammate flag reads (`explicitAgentName`). */
     internals: Pick<RunInternals, "parentCenterArtifactDigest" | "parentCenterSourceRevision" | "parentTaskId" | "parentSessionId" | "explicitAgentName"> | undefined;
     /** borrowed-readonly — the resume leg, or undefined; PRESENCE only (a resumed leg is never truly fresh). */
     resume: Pick<PrepareResume, "seed"> | undefined;
-    /** borrowed-readonly — the resolved prompt provider (compared against the default for `isDefaultProvider`). */
-    provider: PromptProvider;
-    /** borrowed-readonly — the caller's role-layer prompt, or undefined. */
-    userSystemPrompt: string | undefined;
-    /** borrowed-readonly — the caller's appended prompt, or undefined. */
-    userAppendSystemPrompt: string | undefined;
+    /** borrowed-readonly — the request-body sugar's overlays (the task class's first contributions). */
+    sugar: readonly SourcedOverlay[];
+    /** borrowed-readonly — the host selector values (`promptRole` / `promptForm`). */
+    host: {
+        readonly role?: HostRole;
+        readonly form?: HostForm;
+    };
+    /** borrowed-readonly — the run's binding (`TaskSpec.promptBinding`, validated), or undefined: a selector value. */
+    binding: string | undefined;
+    /** borrowed-readonly — the leg's mods bus: `prompt.compose` collects the deploy and task seats' overlays. */
+    modBus: LegModBus;
+    /** borrowed-readonly — the run's abort signal (the compose raise ends with it). */
+    signal?: AbortSignal;
     /** borrowed-readonly — the harness-context flags; the two orchestration flags are re-derived against the post-exclusion
      *  roster at assembly. */
     featureFlags: PromptFeatureFlags;
@@ -49,47 +54,47 @@ export interface PreparePromptAssemblyInput {
     /** borrowed-readonly — the run's ONE tool roster, read only: the assembly receives DETACHED copies, the audit and the
      *  manifest read it in place. Never mutated here. */
     tools: readonly AgentTool[];
-    /** borrowed-readonly — the task model; only `promptGuidance` (the model-guidance section). */
-    model: Pick<Model, "promptGuidance">;
+    /** borrowed-readonly — the task model: `promptGuidance` (the model-guidance section) and `id` (the compose event's `model`). */
+    model: Pick<Model, "id" | "promptGuidance">;
     /** borrowed-readonly — the acquired session id (every operator line's attribution). */
     sessionId: string;
-    /** borrowed-readonly — the session's reminder provenance mark (the declaration the assembled prompt must render). */
-    reminderMark: string;
     /** borrowed-readonly — the once-per-session ledger's operator sink (the collision audit's two lines). */
     onceLedger: Pick<AnnounceOnceSink, "onError">;
 }
 export interface PreparePromptAssemblyResult {
     /** borrowed-mutable — the LIVE system prompt (an accessor cell over this phase's closure variable). Writers: this
      *  phase's `renderWithDate` (the date re-render, called by the listings phase's date_change seam); the turn-wiring
-     *  phase's center candidate `apply` (the compaction-boundary swap). Readers: the harness construction, the cache
+     *  phase's center candidate `apply` (the compaction-boundary change). Readers: the harness construction, the cache
      *  fingerprint, the turn snapshot's stable text, the prompt-overhead term. */
     systemPromptSeat: {
         current: string;
     };
-    /** owned — the date re-render, or undefined for a provider whose assembly cannot re-render. Returns the new prompt and
-     *  writes it into `systemPromptSeat`. */
+    /** owned — the date re-render. Returns the new prompt and writes it into `systemPromptSeat`. */
     renderWithDate: ((date: string) => string) | undefined;
-    /** owned — the physical block face of the assembled prompt, or undefined (the harness's systemBlocks and the turn
-     *  snapshot's layout groups). */
+    /** owned — the physical block face of the assembled prompt (the harness's systemBlocks and the turn snapshot's
+     *  layout groups). */
     systemBlocks: AssembledPrompt["systemBlocks"];
     /** borrowed-mutable — the composition manifest (`Prepared.promptManifest`). Writers after this phase: the tool-disclosure
      *  phase writes `toolDisclosure` (when deferred tools exist); the turn-wiring phase backfills `snapshot` and `lowering`
      *  once the final wire tool list exists. */
     promptManifest: Prepared["promptManifest"];
-    /** owned — the provider-declared sections in the epoch shape (id, slot, chars, opt-in contentHash; never text). */
-    epochDeclaredSections: EpochDeclaredSections;
-    /** owned — the resolved epoch's artifact digest, the turn snapshot's identity element. */
-    epochArtifactDigestForSnapshot: string;
-    /** owned — the re-invokable assemble-inputs BUILDER: the compaction-boundary candidate re-assembles with a new
-     *  artifact's declarations through it (facts and tails identical; only the center closure differs). */
-    buildAssembleInputs: (centerDecls?: PromptTextDeclaration[]) => Parameters<typeof assemblePrompt>[0];
+    /** owned — the run's identity inputs and the pinned center layer's provenance (`Prepared.promptIdentity`; the
+     *  compaction-boundary candidate replaces it after a committed center change). */
+    promptIdentity: RunPromptIdentity;
+    /** owned — the re-invokable assemble-inputs BUILDER: the compaction-boundary candidate re-assembles with a new center
+     *  layer through it (facts, tails and the run-frozen mods overlays identical; only the center class differs). */
+    buildAssembleInputs: (center: CenterAdoption | undefined) => Parameters<typeof assemblePrompt>[0];
+    /** owned — the identity inputs under another center layer (the compaction-boundary candidate's record). */
+    identityFor: (center: CenterAdoption | undefined) => RunPromptIdentity;
+    /** owned — whether this run adopts center candidates at its boundaries: a top-level run does; a child composes its
+     *  parent's layer and never adopts one of its own. */
+    adoptsCandidates: boolean;
     /** borrowed-mutable — the LIVE center adoption (an accessor cell over this phase's closure variable), or undefined.
-     *  Writers: this phase (the three arms; the all-shadowed drop on the fresh arm); the turn-wiring phase's center
-     *  candidate `apply` (the boundary swap / the explicit-disable rollback). Readers: the two late-bound ctx getters
-     *  (inherited-gate, caps-and-workflow), the pin write, the candidate's same-artifact test. */
+     *  Writers: this phase (the resolution arms); the turn-wiring phase's center candidate `apply` (the boundary change).
+     *  Readers: the two late-bound ctx getters (inherited-gate, caps-and-workflow), the candidate's same-artifact test. */
     centerAdoptionRef: {
         current: CenterAdoption | undefined;
     };
 }
-/** The M13 phase body — prepareTask's prompt-assembly stretch, verbatim (see the module header). */
+/** The M13 phase body — prepareTask's prompt-assembly stretch (see the module header). */
 export declare function preparePromptAssembly(input: PreparePromptAssemblyInput): Promise<PreparePromptAssemblyResult>;

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

@@ -1,101 +1,141 @@
 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, verifyPromptArtifactBody } from "../../prompt-assembly/artifact.js";
+import { refusalClause, storedArtifactLine } from "../../prompt-assembly/artifact-store.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 { selectorRecordOf, 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, refusal) => {
+            const why = refusal !== undefined ? `the source's copy is ${refusalClause(refusal)}` : `artifact source miss / not verifiable here${deps.promptSource === undefined ? "; RunnerDeps.promptSource is not configured" : ""}`;
+            throw Object.assign(new Error(`prompt snapshot unavailable: ${what} (${why}) — refusing to recompose a hybrid prompt`), { code: "prompt.snapshot_unavailable" });
+        };
+        const resolvePinned = async (digest, sourceRevision, via) => {
+            const told = {};
+            const art = await deps.promptSource?.get(digest, (r) => void (told.current = r));
+            const adopted = art !== undefined ? adoptCenter(art, sourceRevision) : undefined;
+            if (adopted !== undefined)
+                return adopted;
+            const checked = art !== undefined ? verifyPromptArtifactBody(art) : undefined;
+            const refusal = told.current ?? (checked !== undefined && !checked.ok ? { code: checked.code, reason: checked.reason } : undefined);
+            if (refusal !== undefined)
+                deps.onError?.(new Error(storedArtifactLine(digest, refusal, `the session fails prompt.snapshot_unavailable (a hybrid prompt is never recomposed)`)), { phase: "prompt-constitution", sessionId });
+            return failUnavailable(`${via} center prompt artifact ${digest.slice(0, 23)}… has no verified resolvable copy`, refusal);
         };
-        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 (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 (pinnedEarly === undefined) {
+        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 selectorRecord = selectorRecordOf(selectorsOf(facts, host, binding));
+    const centerOverlays = centerOverlaysOf(centerAdoption);
+    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: selectorRecord,
+    }, { 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),
+        deployOverlays: composed.deploy,
+        host,
+        ...(binding !== undefined ? { binding } : {}),
+        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 +144,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 +184,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,12 +19,15 @@
  * 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";
+import type { RosterBuilder } from "../tool-roster.js";
 import type { ResolvedRole } from "../roles.js";
 import type { RunnerDeps, TaskSpec } from "../types.js";
 import type { SessionTreeEntry } from "../../internal/harness-types.js";
@@ -33,14 +36,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), `excludeAllTools` (the valve's whole-face switch). Never mutated. */
+    spec: Pick<TaskSpec, "systemPrompt" | "appendSystemPrompt" | "clientContext" | "envFacts" | "compaction" | "excludeAllTools">;
+    /** 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;
@@ -58,14 +62,15 @@ export interface PreparePromptInputsInput {
     resolvedReadFace: ContainmentFace | undefined;
     /** borrowed-readonly — the resolved write face (the open-writes flag + the structured env fact). */
     resolvedWriteFace: ContainmentFace | undefined;
-    /** borrowed-readonly — the frozen tool face; only `defer` is read (the Workflow short-pointer flag). */
-    toolFaceSnapshot: Pick<ToolFaceSnapshot, "defer">;
+    /** 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 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;
@@ -78,8 +83,12 @@ export interface PreparePromptInputsInput {
     };
     /** borrowed-readonly — the resolved role; only its `systemPrompt` preset is read (second source). */
     resolvedRole: Pick<ResolvedRole, "systemPrompt">;
-    /** borrowed-readonly — the materialized MCP roster; only `serverInstructions` (the disposed entries) is read. */
-    mcp: Pick<MaterializedMcp, "serverInstructions">;
+    /** 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">;
+    /** borrowed-readonly — the run's roster as the protocol-tools phase mounted it (the deployment's overlay applied, the valve not yet):
+     *  the tools the teaching answer reads, with the valve's predicate. */
+    roster: Pick<RosterBuilder, "tools">;
     /** borrowed-readonly — the resolved model (id for the env line + the cutoff lookup). */
     model: Model;
     /** borrowed-readonly — the run's external-content-target fold (the single-source disclosure fact). */
@@ -111,14 +120,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,7 @@
-import { formatLocalDate, isValidTimeZone, promptProviderInForce } from "../../prompts/default.js";
+import { formatLocalDate, isValidTimeZone } from "../../prompts/default.js";
+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 { probeGitStatusLane } from "./git-status-frame.js";
@@ -7,10 +10,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,11 +32,11 @@ 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 mcpInstructionsBlock = mcp.serverInstructions.length
-        ? `# MCP Server Instructions\n${mcp.serverInstructions.map(renderMcpInstructionsEntry).join("\n\n")}`
-        : undefined;
+    const sugar = sugarOverlays({ spec, resolvedRole, ...(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)));
+    const mcpInstructionsBlock = taught.length ? `# MCP Server Instructions\n${taught.map(renderMcpInstructionsEntry).join("\n\n")}` : undefined;
     const userTz = spec.clientContext?.timeZone;
     const tzValid = userTz !== undefined && isValidTimeZone(userTz);
     const dateAnchor = await readDateAnchor(session);
@@ -143,5 +144,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 };
 }