@sema-agent/core 7.5.0 → 7.5.2

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

@@ -0,0 +1,119 @@
+/**
+ * design/390 M9 — prepareTask's PROJECT-CONTEXT phase: the deployment's project memory snapshot (the
+ * `loadProjectMemory` seam: phase derivation, instruction sources, the framed + fenced project layer
+ * appended to the memory block), the skills roster (declaration rank, normalization, the 1MB load gate,
+ * the manifest-scope door, the `skill` tool mount), the two built-in memory pairs' mount-or-yield
+ * (shared-memory pair, engine-memory pair), and the skills-listing projection the run loop announces.
+ * The body is the driver's stretch moved verbatim; the interface below is the dependency list it had
+ * implicitly (design/238 R-1: a new read is an Input field, i.e. a review event).
+ *
+ * ASYNC BY CONTENT: the stretch awaits the session branch read, the seam itself and the read-state
+ * seeding (all inside the `loadProjectMemory` arm). It already sits past prepareTask's first await, so
+ * the one extra microtask the driver's `await` adds on the seam-less path opens no window any caller
+ * could reach (design/390 §1.5 S1 synchronicity rule: only pre-first-await stretches must stay sync).
+ *
+ * Throws pass through unchanged: `config.reserved_tool_name` (a caller tool named like the skill tool
+ * while skills are present) is the only refusal here; the seam's own throw and the seeding's are
+ * caught and forwarded to `deps.onError` (best-effort, never block the task).
+ */
+import type { AgentTool } from "../../internal/harness.js";
+import { type StoredSession } from "../session.js";
+import type { RunnerDeps, TaskSpec, ToolSpec } from "../types.js";
+import type { ActiveSkillScope } from "./active-skill-scope.js";
+import type { AnnounceOnceSink, Prepared, PrepareResume, RunInternals, ToolFaceSnapshot } from "./contracts.js";
+import { normalizeSkills } from "./synthetic-tools.js";
+export interface PrepareProjectContextInput {
+    /** borrowed-readonly — the deployment seams this phase reads: `loadProjectMemory` (the snapshot),
+     *  `onError` (the operator lane for a throwing seam / seeding / oversize skill), `sharedMemoryStores`
+     *  (the shared-memory pair's switch: wired ⇒ mount). Receiver preserved (`deps.onError?.(…)`). */
+    deps: Pick<RunnerDeps, "loadProjectMemory" | "onError" | "sharedMemoryStores">;
+    /** borrowed-readonly — the REBOUND spec (`spec′`). Read: `sessionId` (phase derivation + the
+     *  continuation projections), `skills` (the roster), `principal` (the shared-memory tools' trusted
+     *  identity). Never mutated. */
+    spec: Pick<TaskSpec, "sessionId" | "skills" | "principal">;
+    /** borrowed-readonly — trusted internals: `agentName` (seam ctx), `inheritedManifestScope` (the
+     *  parent's active skill frames, seeded as the base of the LIFO). `undefined` on a standalone prepare. */
+    internals: Pick<RunInternals, "agentName" | "inheritedManifestScope"> | undefined;
+    /** borrowed-readonly — the acquired session; only `getBranch()` is read (phase derivation walk).
+     *  The read is best-effort: a throw keeps the provisional phase. */
+    session: Pick<StoredSession, "getBranch">;
+    /** borrowed-readonly — the acquired session's id (seam ctx cache key; operator-line context). */
+    sessionId: string;
+    /** borrowed-readonly — `spec.taskId ?? sessionId`: the shared-memory tools' trusted task identity. */
+    hostTaskId: string;
+    /** borrowed-readonly — the FINAL task root (post-restore): the seam's `cwd`. */
+    taskRootFinal: string;
+    /** borrowed-readonly — whether a real execution env is mounted (seam ctx flag). */
+    handsEnabled: boolean;
+    /** borrowed-readonly — the leg's effective-delegation facts; only `isNonForkChild` is read (the
+     *  seam's `isSubagent` — one derivation shared with the prompt fact, never re-derived here). */
+    delegation: {
+        readonly isNonForkChild: boolean;
+    };
+    /** borrowed-readonly — the hands phase's read-state seeding closure (CREATED there, CALLED here for
+     *  the snapshot's declared `seededFiles`); `undefined` on a hands-less task = nothing to seed. */
+    seedContextFiles: ((files: ReadonlyArray<{
+        path: string;
+        content: string;
+    }>) => Promise<void>) | undefined;
+    /** borrowed-readonly — the memory phase's composed block, as returned (recall discipline + engine
+     *  files). This phase APPENDS the project layer and hands the result back as
+     *  {@link PrepareProjectContextResult.memoryBlock}; the input value itself is never mutated. */
+    memoryBlockFromEngine: string | undefined;
+    /** borrowed-mutable — the run's LIFO skill-scope stack (identity is the contract: the scope policy
+     *  and the `skill` tool alias this exact object). Mutated here: `push` of every inherited parent
+     *  frame; after this phase only the `skill` tool's execute pushes/pops. */
+    skillScope: ActiveSkillScope;
+    /** borrowed-mutable — the shared mount array (later refs alias it; in-place contract). Mutated
+     *  here: `push` of the `skill` tool, the shared-memory pair and the engine-memory pair. Occupancy
+     *  is judged on this ALREADY-MOUNTED roster (names + aliases). */
+    tools: AgentTool[];
+    /** borrowed-readonly — the frozen task-start tool face; only `exclude` is read (pair yield ①). */
+    toolFaceSnapshot: Pick<ToolFaceSnapshot, "exclude">;
+    /** borrowed-readonly — the once-per-session announcement ledger; only its deduplicated `onError`
+     *  sink is invoked (a pair's mount shape is a session-level fact, announced once). */
+    onceLedger: AnnounceOnceSink;
+    /** borrowed-readonly — the memory phase's engine-pair ToolSpecs (present iff the pair may mount). */
+    memoryTools: ToolSpec[] | undefined;
+    /** borrowed-readonly — the memory phase's session seat; only `!== undefined` is read (the
+     *  blocked-mount disclosure fires only when a session mounted). */
+    memoryEngineSession: Prepared["memoryEngineSession"];
+    /** borrowed-readonly — the engine pair's early conjuncts (computed before the memory phase). */
+    memorySearchToolsPlanned: boolean;
+    /** borrowed-readonly — the engine-pair name the exclusion valve removed, if any (disclosure text). */
+    memoryPairExcludedName: string | undefined;
+    /** borrowed-readonly — the engine-pair name a declared tool already occupies, if any (disclosure text). */
+    memoryPairOccupiedName: string | undefined;
+    /** borrowed-readonly — the durable-resume carrier; read for `!== undefined` (seedAnnounced) and
+     *  `seed.announcedListings.skills` (the removal-to-zero projection's gate). */
+    resume: Pick<PrepareResume, "seed"> | undefined;
+}
+export interface PrepareProjectContextResult {
+    /** owned — the memory block with the project layer appended at the tail (unchanged when the seam is
+     *  unwired or returns null/blank). The driver binds it under a NEW name; the defer-classification
+     *  stretch may still strip the recall-discipline segment from it. */
+    memoryBlock: string | undefined;
+    /** owned — the snapshot's declared instruction sources (non-empty only), for the run loop's
+     *  instructions_change lane (`Prepared.instructionSources`). */
+    instructionSources: ReadonlyArray<{
+        path: string;
+        contentHash: string | null;
+    }> | undefined;
+    /** owned — the RAW snapshot text (pre-compose) for the compaction lanes' instruction-file seat
+     *  (`Prepared.projectInstructionContent`). */
+    projectInstructionContent: string | undefined;
+    /** owned — the normalized, load-gated skills (first-wins dedupe, name-sorted). Consumed inside this
+     *  phase (tool + listing); exposed as the phase's own product. */
+    skillSpecs: ReturnType<typeof normalizeSkills>;
+    /** owned — whether THIS task carries a manifested skill or inherits a parent frame (the skill-scope
+     *  policy's activation predicate). */
+    hasSkillManifest: boolean;
+    /** owned — the skills-listing projection the run loop's announce lane consumes (`Prepared.skillsListing`). */
+    skillsListing: Prepared["skillsListing"];
+    /** owned — whether the shared-memory pair mounted here (the support-name pre-check reads it). */
+    sharedMemoryPairMounted: boolean;
+    /** owned — whether the engine-memory pair mounted here (the support-name pre-check reads it). */
+    memoryEnginePairMounted: boolean;
+}
+/** The M9 phase body — prepareTask's project-context stretch, verbatim (see the module header). */
+export declare function prepareProjectContext(input: PrepareProjectContextInput): Promise<PrepareProjectContextResult>;

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

@@ -0,0 +1,148 @@
+import { PROJECT_CONTEXT_FRAMING } from "../../prompts/default.js";
+import { MEMORY_ENGINE_TOOL_NAMES } from "../memory-engine/tools.js";
+import { composeMemoryBlock } from "../memory.js";
+import { hasConversationContent } from "../session.js";
+import { createSharedMemoryTools } from "../shared-memory/tools.js";
+import { SHARED_MEMORY_TOOL_NAMES } from "../shared-memory/types.js";
+import { defineTool } from "../tools.js";
+import { SKILL_CONTENT_MAX_CHARS, SKILL_TOOL_NAME, createSkillTool, normalizeSkills } from "./synthetic-tools.js";
+export async function prepareProjectContext(input) {
+    const { deps, spec, internals, session, sessionId, hostTaskId, taskRootFinal, handsEnabled, delegation, seedContextFiles, memoryBlockFromEngine, skillScope, tools, toolFaceSnapshot, onceLedger, memoryTools, memoryEngineSession, memorySearchToolsPlanned, memoryPairExcludedName, memoryPairOccupiedName, resume } = input;
+    let memoryBlock = memoryBlockFromEngine;
+    let instructionSources;
+    let projectInstructionContent;
+    if (deps.loadProjectMemory) {
+        let projectMemoryPhase = spec.sessionId ? "resume" : "fresh";
+        if (spec.sessionId) {
+            try {
+                const branch = await session.getBranch();
+                const hasConversation = hasConversationContent(branch);
+                if (!hasConversation)
+                    projectMemoryPhase = "fresh";
+                else {
+                    for (let i = branch.length - 1; i >= 0; i--) {
+                        const e = branch[i];
+                        if (e.type === "compaction") {
+                            projectMemoryPhase = "post-compact";
+                            break;
+                        }
+                        if (e.type === "message" && e.message.role === "user")
+                            break;
+                    }
+                }
+            }
+            catch {
+            }
+        }
+        let loaded = null;
+        try {
+            loaded = await Promise.resolve(deps.loadProjectMemory({
+                cwd: taskRootFinal,
+                handsEnabled,
+                isSubagent: delegation.isNonForkChild,
+                ...(internals?.agentName ? { agentName: internals.agentName } : {}),
+                sessionId,
+                phase: projectMemoryPhase,
+            }));
+        }
+        catch (err) {
+            deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "config", sessionId });
+        }
+        const projectMem = loaded !== null && typeof loaded === "object" ? loaded.content : loaded;
+        const seededFiles = loaded !== null && typeof loaded === "object" ? loaded.seededFiles : undefined;
+        const declaredSources = loaded !== null && typeof loaded === "object" ? loaded.instructionSources : undefined;
+        if (declaredSources !== undefined && declaredSources.length > 0)
+            instructionSources = declaredSources;
+        if (seededFiles?.length && seedContextFiles) {
+            try {
+                await seedContextFiles(seededFiles);
+            }
+            catch (err) {
+                deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "config", sessionId });
+            }
+        }
+        if (projectMem != null && projectMem.trim()) {
+            projectInstructionContent = projectMem;
+            const projectBlock = `${PROJECT_CONTEXT_FRAMING}\n\n${composeMemoryBlock(projectMem, "project")}`;
+            memoryBlock = memoryBlock ? `${memoryBlock}\n\n${projectBlock}` : projectBlock;
+        }
+    }
+    const declaredSkillRank = new Map();
+    for (const s of spec.skills ?? [])
+        if (!declaredSkillRank.has(s.name))
+            declaredSkillRank.set(s.name, declaredSkillRank.size);
+    const skillSpecs = normalizeSkills(spec.skills ?? []).filter((s) => {
+        if (s.content.length <= SKILL_CONTENT_MAX_CHARS)
+            return true;
+        deps.onError?.(new Error(`Skill "${s.name}" content is ${s.content.length} chars, over the ${SKILL_CONTENT_MAX_CHARS}-char load limit — skill not loaded (skills are never truncated; shrink the body or move material to attachments/files).`), { phase: "config", sessionId });
+        return false;
+    });
+    const inheritedFrames = internals?.inheritedManifestScope ?? [];
+    for (const frame of inheritedFrames) {
+        skillScope.push(frame);
+    }
+    const hasSkillManifest = skillSpecs.some((s) => s.manifest !== undefined) || inheritedFrames.length > 0;
+    if (skillSpecs.length > 0) {
+        if (tools.some((t) => t.name === SKILL_TOOL_NAME)) {
+            const e = new Error(`Tool name "${SKILL_TOOL_NAME}" is reserved when spec.skills is present.`);
+            e.code = "config.reserved_tool_name";
+            throw e;
+        }
+        tools.push(createSkillTool(skillSpecs, skillScope));
+    }
+    const sharedMemoryProvider = deps.sharedMemoryStores;
+    let sharedMemoryPairMounted = false;
+    if (sharedMemoryProvider !== undefined) {
+        const excluded = new Set(toolFaceSnapshot.exclude ?? []);
+        const mountedNameDomain = new Set();
+        for (const t of tools) {
+            mountedNameDomain.add(t.name);
+            for (const alias of t.aliases ?? [])
+                mountedNameDomain.add(alias);
+        }
+        const excludedName = SHARED_MEMORY_TOOL_NAMES.find((n) => excluded.has(n));
+        const occupiedName = SHARED_MEMORY_TOOL_NAMES.find((n) => mountedNameDomain.has(n));
+        if (excludedName !== undefined || occupiedName !== undefined) {
+            onceLedger.onError(new Error(`Shared memory tools ${SHARED_MEMORY_TOOL_NAMES.join("/")} were NOT mounted: ` +
+                (excludedName !== undefined
+                    ? `excludeTools removes "${excludedName}"`
+                    : `this task already declares a tool named "${occupiedName}" (the built-in yields to it)`) +
+                " — the pair mounts together or not at all."), { phase: "config", sessionId, classification: "shared-memory-not-mounted" });
+        }
+        else {
+            tools.push(...createSharedMemoryTools({
+                provider: sharedMemoryProvider,
+                context: { sessionId, taskId: hostTaskId, ...(spec.principal !== undefined ? { principal: spec.principal } : {}) },
+            }).map((s) => defineTool(s)));
+            sharedMemoryPairMounted = true;
+        }
+    }
+    let memoryEnginePairMounted = false;
+    if (memoryTools !== undefined && memoryTools.length > 0) {
+        tools.push(...memoryTools.map((s) => defineTool(s)));
+        memoryEnginePairMounted = true;
+    }
+    else if (memoryEngineSession !== undefined && !memorySearchToolsPlanned) {
+        onceLedger.onError(new Error(`Memory tools ${MEMORY_ENGINE_TOOL_NAMES.join("/")} were NOT mounted: ` +
+            (memoryPairExcludedName !== undefined
+                ? `excludeTools removes "${memoryPairExcludedName}"`
+                : `this task already declares a tool named "${memoryPairOccupiedName}" (the built-in yields to it)`) +
+            " — these tools mount together or not at all."), { phase: "config", sessionId, classification: "memory-tools-not-mounted" });
+    }
+    const skillsListing = skillSpecs.length > 0
+        ? {
+            entries: skillSpecs.map((s) => ({
+                name: s.name,
+                description: s.description,
+                ...(s.files !== undefined ? { files: s.files.map((f) => ({ path: f.path })) } : {}),
+                ...(declaredSkillRank.get(s.name) !== undefined ? { declaredRank: declaredSkillRank.get(s.name) } : {}),
+            })),
+            seedAnnounced: resume !== undefined || spec.sessionId !== undefined,
+        }
+        :
+            (resume?.seed.announcedListings?.skills?.length ?? 0) > 0 || spec.sessionId !== undefined
+                ?
+                    { entries: [], seedAnnounced: true }
+                : undefined;
+    return { memoryBlock, instructionSources, projectInstructionContent, skillSpecs, hasSkillManifest, skillsListing, sharedMemoryPairMounted, memoryEnginePairMounted };
+}

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

@@ -0,0 +1,95 @@
+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 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. */
+    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. */
+    deps: Pick<RunnerDeps, "promptSource" | "onError">;
+    /** borrowed-readonly — the trusted spawn-side channel: the parent's center closure (`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 harness-context flags; the two orchestration flags are re-derived against the post-exclusion
+     *  roster at assembly. */
+    featureFlags: PromptFeatureFlags;
+    /** borrowed-readonly — the MCP instructions block, or undefined. */
+    mcpInstructionsBlock: string | undefined;
+    /** borrowed-readonly — the memory block as the assembly reads it (the recall paragraph already stripped when a
+     *  retraction ran), or undefined. */
+    memoryBlock: string | undefined;
+    /** borrowed-readonly — the environment facts; `date` is the assembly's date, the block builder re-renders on a date change. */
+    envFacts: EnvironmentFacts;
+    /** borrowed-readonly — the resolved prompt profile (a runtime fact of the assembly). */
+    promptProfile: "simple" | "classic";
+    /** borrowed-readonly — the fable mitigations switch (a runtime fact of the assembly). */
+    fableMitigations: boolean;
+    /** 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: AgentTool[];
+    /** borrowed-readonly — the task model; only `promptGuidance` (the model-guidance section). */
+    model: Pick<Model, "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
+     *  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`. */
+    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). */
+    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];
+    /** 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. */
+    centerAdoptionRef: {
+        current: CenterAdoption | undefined;
+    };
+}
+/** The M13 phase body — prepareTask's prompt-assembly stretch, verbatim (see the module header). */
+export declare function preparePromptAssembly(input: PreparePromptAssemblyInput): Promise<PreparePromptAssemblyResult>;

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

@@ -0,0 +1,162 @@
+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 { auditToolCollisions, projectToolManifest } from "../../prompt-assembly/tool-catalog.js";
+import { buildEnvironmentContext, defaultPromptProvider } from "../../prompts/default.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";
+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;
+    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 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 } : {}) };
+        }
+        else if (pinnedEarly === undefined) {
+            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 } : {}),
+                };
+            }
+            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;
+                }
+            }
+        }
+    }
+    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,
+        },
+        mcpInstructionsBlock,
+        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 }),
+        ...(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;
+    }
+    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 promptBlocks = assembled.legacyBlocks;
+    const collisionAudit = auditToolCollisions(tools);
+    for (const y of collisionAudit.yields) {
+        onceLedger.onError(new Error(`tool mount: caller tool "${y.name}" shadows another tool with the same canonical name (deliberate last-write-wins yield — the later mount serves)`), { phase: "config", sessionId });
+    }
+    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 saltedHash = (text) => createHash("sha256").update(PROMPT_HASH_SALT).update(text).digest("hex").slice(0, 12);
+    const promptManifest = {
+        constitution: promptConstitution,
+        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 } : {}) })) }
+            : {}),
+        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() {
+                return systemPrompt;
+            },
+            set current(v) {
+                systemPrompt = v;
+            },
+        },
+        renderWithDate,
+        systemBlocks: assembled.systemBlocks,
+        promptManifest,
+        epochDeclaredSections,
+        epochArtifactDigestForSnapshot,
+        buildAssembleInputs,
+        centerAdoptionRef: {
+            get current() {
+                return centerAdoption;
+            },
+            set current(v) {
+                centerAdoption = v;
+            },
+        },
+    };
+}