@sema-agent/core 7.51.2 → 7.53.0

package/dist/prompt-assembly/epoch.js

@@ -7,140 +7,55 @@ export function canonical(node) {
     const keys = Object.keys(node).sort();
     return `{${keys.map((k) => `${JSON.stringify(k)}:${canonical(node[k])}`).join(",")}}`;
 }
-const PROBE_FACTS_OFF = {
-    policyEnabled: false,
-    hooksEnabled: false,
-    isolationEnabled: false,
-    withinTaskCompactionEnabled: false,
-    supervisorEnabled: false,
-    orchestrationEnabled: false,
-    awarenessEnabled: false,
-    goalEnabled: false,
-    worktreeIsolated: false,
-    teammateEnabled: false,
-    orchestrationDeferred: false,
-    isSubagent: false,
-    promptProfile: "simple",
-    fableMitigations: false,
-    readFaceOpen: false,
-    writeFaceOpen: false,
-    reminderMark: undefined,
-};
-const PROBE_FACTS_ON = {
-    policyEnabled: true,
-    hooksEnabled: true,
-    isolationEnabled: true,
-    withinTaskCompactionEnabled: true,
-    supervisorEnabled: true,
-    orchestrationEnabled: true,
-    awarenessEnabled: true,
-    goalEnabled: true,
-    worktreeIsolated: true,
-    teammateEnabled: true,
-    orchestrationDeferred: true,
-    isSubagent: true,
-    promptProfile: "classic",
-    fableMitigations: true,
-    readFaceOpen: true,
-    writeFaceOpen: true,
-    reminderMark: "PROBE-FIXED-MARK-AXIS0",
-};
-const PROBE_VECTORS = [
-    PROBE_FACTS_OFF,
-    PROBE_FACTS_ON,
-    ...Object.keys(PROBE_FACTS_OFF).map((k) => ({ ...PROBE_FACTS_OFF, [k]: PROBE_FACTS_ON[k] })),
-];
-const PROBE_INPUTS_BASE = {
-    roleBase: "\u0000probe-role\u0000",
-    roleAppend: "\u0000probe-append\u0000",
-    mcpInstructionsBlock: "\u0000probe-mcp\u0000",
-    environmentBlock: "\u0000probe-env@2\u0000",
-    memoryBlock: "\u0000probe-memory\u0000",
-    modelGuidance: "\u0000probe-guidance\u0000",
-};
-export function computeBundledArtifactDigest(pack, declared) {
-    const probeSection = (s) => PROBE_VECTORS.map((facts) => {
-        const inputs = { ...PROBE_INPUTS_BASE, facts };
-        try {
-            if (s.admit && !s.admit(inputs))
-                return null;
-            return s.content(inputs) ?? null;
-        }
-        catch {
-            return " probe-threw ";
-        }
-    });
-    const payload = {
-        packId: pack.packId,
-        assemblyApi: pack.assemblyApi,
-        ...(declared !== undefined && declared.length > 0
-            ? { declaredSections: declared.map((d) => ({ id: d.id, slot: d.slot, chars: d.chars, ...(d.contentHash !== undefined ? { contentHash: d.contentHash } : {}) })) }
-            : {}),
-        sections: [...pack.sections].sort((a, b) => a.rank - b.rank).map((s) => ({
-            id: s.id,
-            slot: s.slot,
-            rank: s.rank,
-            owner: s.owner,
-            trust: s.trust,
-            mutability: s.mutability,
-            cadence: s.cadence,
-            cacheClass: s.cacheClass,
-            carrier: s.carrier,
-            legacyBlockId: s.blockId,
-            probes: probeSection(s),
-        })),
-    };
-    return `sha256:${createHash("sha256").update(canonical(payload)).digest("hex")}`;
+export function digestOf(node) {
+    return `sha256:${createHash("sha256").update(canonical(node)).digest("hex")}`;
 }
-export function mintSessionStartEpoch(pack, declared) {
-    return {
-        epoch: 1,
-        artifactDigest: computeBundledArtifactDigest(pack, declared),
-        packId: pack.packId,
-        assemblyApi: pack.assemblyApi,
-        activatedBy: "session_start",
-    };
+export function catalogDigestOf(catalog) {
+    return digestOf({
+        ...catalog,
+        bands: [...catalog.bands].sort((a, b) => a.id.localeCompare(b.id)),
+        messages: [...catalog.messages].sort((a, b) => a.id.localeCompare(b.id)),
+        sections: [...catalog.sections].sort((a, b) => a.rank - b.rank),
+    });
 }
-export function selectCompactionEpoch(current, pack, declared, centerAdoption) {
-    const digest = computeBundledArtifactDigest(pack, declared);
-    if (centerAdoption === undefined && current && current.artifactDigest === digest) {
-        return { ...current, activatedBy: "compaction" };
-    }
-    return {
-        epoch: (current?.epoch ?? 0) + 1,
-        artifactDigest: digest,
-        packId: pack.packId,
-        assemblyApi: pack.assemblyApi,
-        activatedBy: "compaction",
-        ...(centerAdoption !== undefined
-            ? "clear" in centerAdoption
-                ? {}
-                : {
-                    centerArtifactDigest: centerAdoption.centerArtifactDigest,
-                    ...(centerAdoption.sourceRevision !== undefined ? { sourceRevision: centerAdoption.sourceRevision } : {}),
-                }
-            : current?.centerArtifactDigest !== undefined
-                ? {
-                    centerArtifactDigest: current.centerArtifactDigest,
-                    ...(current.sourceRevision !== undefined ? { sourceRevision: current.sourceRevision } : {}),
-                }
-                : {}),
-    };
+export function promptIdentityOf(layers) {
+    return digestOf({
+        catalog: layers.catalog,
+        renderers: layers.renderers,
+        overlays: digestOf({ center: layers.center ?? null, deploy: layers.deploy ?? null, task: layers.task ?? null }),
+        binding: layers.binding,
+    });
 }
-export function resolveEpochAgainstBundled(pinned, pack, declared) {
-    const digest = computeBundledArtifactDigest(pack, declared);
-    if (pinned && pinned.artifactDigest === digest && pinned.packId === pack.packId && pinned.assemblyApi === pack.assemblyApi) {
-        return { descriptor: pinned, migrated: false };
-    }
+export const PROMPT_EPOCH_ACTIVATIONS = Object.freeze(["session_start", "compaction", "code_change", "selection_change"]);
+export const PROMPT_EPOCH_CHANGES = Object.freeze(["catalog", "renderers", "deploy", "task", "published_schema"]);
+const DIGEST = /^sha256:[0-9a-f]{64}$/;
+const isDigest = (v) => typeof v === "string" && DIGEST.test(v);
+const RETIRED_DESCRIPTOR_FIELDS = Object.freeze(["artifactDigest", "packId", "assemblyApi", "centerArtifactDigest"]);
+function normalizeLayers(raw) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+        return undefined;
+    const r = raw;
+    for (const k of Object.keys(r))
+        if (!["catalog", "renderers", "center", "deploy", "task", "binding"].includes(k))
+            return undefined;
+    if (!isDigest(r.catalog) || !isDigest(r.binding))
+        return undefined;
+    for (const k of ["center", "deploy", "task"])
+        if (r[k] !== undefined && !isDigest(r[k]))
+            return undefined;
+    const rv = r.renderers;
+    if (rv === null || typeof rv !== "object" || Array.isArray(rv))
+        return undefined;
+    const entries = Object.entries(rv);
+    if (entries.length > 64 || entries.some(([k, v]) => k.length === 0 || k.length > 64 || typeof v !== "number" || !Number.isInteger(v) || v < 1 || v > 1_000_000))
+        return undefined;
     return {
-        descriptor: {
-            epoch: (pinned?.epoch ?? 0) + 1,
-            artifactDigest: digest,
-            packId: pack.packId,
-            assemblyApi: pack.assemblyApi,
-            activatedBy: "legacy_migration",
-        },
-        migrated: true,
+        catalog: r.catalog,
+        renderers: Object.fromEntries(entries),
+        ...(r.center !== undefined ? { center: r.center } : {}),
+        ...(r.deploy !== undefined ? { deploy: r.deploy } : {}),
+        ...(r.task !== undefined ? { task: r.task } : {}),
+        binding: r.binding,
     };
 }
 export function normalizePromptEpoch(raw) {
@@ -149,23 +64,81 @@ export function normalizePromptEpoch(raw) {
     const r = raw;
     if (typeof r.epoch !== "number" || !Number.isInteger(r.epoch) || r.epoch < 1 || r.epoch > 1_000_000_000)
         return undefined;
-    if (typeof r.artifactDigest !== "string" || !/^sha256:[0-9a-f]{64}$/.test(r.artifactDigest))
+    if (!isDigest(r.identity))
         return undefined;
-    if (typeof r.packId !== "string" || !r.packId.trim() || r.packId.length > 200)
+    const layers = normalizeLayers(r.layers);
+    if (layers === undefined || promptIdentityOf(layers) !== r.identity)
         return undefined;
-    if (r.assemblyApi !== 1)
+    if (!PROMPT_EPOCH_ACTIVATIONS.some((a) => a === r.activatedBy))
         return undefined;
-    if (r.activatedBy !== "session_start" && r.activatedBy !== "compaction" && r.activatedBy !== "legacy_migration")
+    const activatedBy = r.activatedBy;
+    let changed;
+    if (r.changed !== undefined) {
+        if (activatedBy !== "code_change" || !Array.isArray(r.changed) || r.changed.length === 0)
+            return undefined;
+        if (r.changed.some((c) => !PROMPT_EPOCH_CHANGES.some((w) => w === c)) || new Set(r.changed).size !== r.changed.length)
+            return undefined;
+        changed = [...r.changed];
+    }
+    if (r.sourceRevision !== undefined && (layers.center === undefined || typeof r.sourceRevision !== "string" || r.sourceRevision.length === 0 || r.sourceRevision.length > 500))
         return undefined;
-    const centerArtifactDigest = typeof r.centerArtifactDigest === "string" && /^sha256:[0-9a-f]{64}$/.test(r.centerArtifactDigest) ? r.centerArtifactDigest : undefined;
-    const sourceRevision = typeof r.sourceRevision === "string" && r.sourceRevision.length > 0 && r.sourceRevision.length <= 500 ? r.sourceRevision : undefined;
     return {
         epoch: r.epoch,
-        artifactDigest: r.artifactDigest,
-        packId: r.packId,
-        assemblyApi: 1,
-        activatedBy: r.activatedBy,
-        ...(centerArtifactDigest !== undefined ? { centerArtifactDigest } : {}),
-        ...(centerArtifactDigest !== undefined && sourceRevision !== undefined ? { sourceRevision } : {}),
+        identity: r.identity,
+        layers,
+        activatedBy,
+        ...(changed !== undefined ? { changed } : {}),
+        ...(r.sourceRevision !== undefined ? { sourceRevision: r.sourceRevision } : {}),
+    };
+}
+export function readStoredPromptEpoch(raw) {
+    const descriptor = normalizePromptEpoch(raw);
+    if (descriptor !== undefined)
+        return { kind: "pin", descriptor };
+    if (raw === null || typeof raw !== "object")
+        return undefined;
+    const r = raw;
+    if (!RETIRED_DESCRIPTOR_FIELDS.some((f) => f in r))
+        return undefined;
+    return { kind: "legacy", centerPinned: isDigest(r.centerArtifactDigest) };
+}
+function changedLayers(a, b) {
+    const out = [];
+    if (a.catalog !== b.catalog)
+        out.push("catalog");
+    if (canonical(a.renderers) !== canonical(b.renderers))
+        out.push("renderers");
+    if (a.deploy !== b.deploy)
+        out.push("deploy");
+    if (a.task !== b.task)
+        out.push("task");
+    return out;
+}
+function descriptorOf(epoch, layers, activatedBy, extra) {
+    return {
+        epoch,
+        identity: promptIdentityOf(layers),
+        layers,
+        activatedBy,
+        ...(extra.changed !== undefined && extra.changed.length > 0 ? { changed: [...extra.changed] } : {}),
+        ...(layers.center !== undefined && extra.sourceRevision !== undefined ? { sourceRevision: extra.sourceRevision } : {}),
     };
 }
+export function prepareEpochRecord(stored, layers, ctx) {
+    if (stored === undefined)
+        return descriptorOf(1, layers, ctx.priorConversation ? "code_change" : "session_start", ctx);
+    if (stored.kind === "legacy")
+        return descriptorOf(1, layers, "code_change", { ...ctx, ...(stored.centerPinned ? { changed: ["published_schema"] } : {}) });
+    const pinned = stored.descriptor;
+    if (pinned.identity === promptIdentityOf(layers))
+        return undefined;
+    const changed = changedLayers(pinned.layers, layers);
+    return descriptorOf(pinned.epoch + 1, layers, changed.length > 0 ? "code_change" : "selection_change", { ...ctx, changed });
+}
+export function selectCompactionEpoch(current, layers, sourceRevision) {
+    if (current !== undefined && current.identity === promptIdentityOf(layers)) {
+        const { changed: _recordOnly, ...restated } = current;
+        return { ...restated, activatedBy: "compaction" };
+    }
+    return descriptorOf((current?.epoch ?? 0) + 1, layers, "compaction", sourceRevision !== undefined ? { sourceRevision } : {});
+}

package/dist/prompt-assembly/explain.d.ts

@@ -1,57 +1,81 @@
+import type { BandId, OverlayOp } from "./catalog/schema.js";
+/** A `prompt.assembled` manifest (v3) as explain reads it: the frame's own members. */
 export interface ExplainInput {
-    constitution: "core" | "replaced" | "provider-assembled";
-    blocks: Array<{
+    identity: {
+        artifact: string;
+        layers: {
+            center?: string;
+            deploy?: string;
+            task?: string;
+        };
+        epoch: number;
+        activatedBy: string;
+    };
+    selectors: {
+        binding?: string;
+        traits: readonly string[];
+        host: {
+            role: string;
+            form: string;
+        };
+    };
+    blocks: ReadonlyArray<{
         id: string;
         chars: number;
         hash: string;
     }>;
-    sections?: Array<{
+    sections: ReadonlyArray<{
         id: string;
-        slot: string;
-        carrier: string;
-        cadence: string;
-        cacheClass: string;
+        band: string;
+        variant?: string;
         chars: number;
-        hash: string;
-        contentHash?: string;
+        locale: string;
+        contentHash: string;
+        chain: ReadonlyArray<{
+            source: string;
+            overlay?: string;
+            op?: string;
+            superseded?: true;
+        }>;
     }>;
-    tools?: Array<{
+    superseded?: ReadonlyArray<{
+        id: string;
+        source: string;
+        by: string;
+        target: string;
+        supersededBy: string;
+    }>;
+    tools?: ReadonlyArray<{
         wireName: string;
         contractId: string;
         cardId: string;
         shapeDigest: string;
     }>;
-    epoch?: {
-        epoch: number;
-        artifactDigest: string;
-        packId: string;
-        activatedBy: string;
-    };
 }
-/** Render a `prompt.assembled` manifest (+ optional epoch pin) as a readable report. */
+/** Render a `prompt.assembled` manifest as a readable report: which prompt (identity, its layers, the selector values),
+ *  what composed it, and where each section's text came from. */
 export declare function explainPromptAssembly(input: ExplainInput): string;
 /**
- * the CENTER-facing read-only description of the default pack: section
- * metadata (id/slot/rank/ownership/locked) plus the default role-base TEXT (the append-mode
- * compile skeleton the web UI prepends to a user's "Role details"). Deliberately NO other section
- * texts (the no-prompt-bodies observability line — structure yes, prose no; the role base is
- * the one deliberate exception: it is the public compile input of the append mode, and its text is
- * this open repo's DEFAULT_SYSTEM_PROMPT). Programmatic — a static copy in the web tier would
- * silently drift the moment core's default prompt changes (no static copies).
+ * The CENTER-facing read-only description of the bundled catalog: each section's id, band, rank and what each overlay
+ * source class may do to it (the band's three op columns — a center editor reads `ops.center`; an empty column for
+ * every class is a platform-managed section), plus the default role-base TEXT (the append-mode compile skeleton the web
+ * UI prepends to a user's "Role details"). No other section texts. Programmatic — a static copy in the web tier would
+ * drift the moment the catalog changes.
  */
-export interface DefaultPackDescription {
-    packId: string;
-    /** The pack-default role base (append-mode skeleton). */
+export interface CatalogDescription {
+    catalogId: string;
+    /** The catalog-default role base (append-mode skeleton). */
     roleBaseText: string;
     sections: Array<{
         id: string;
-        slot: string;
+        band: BandId;
         rank: number;
-        owner: string;
-        trust: string;
-        mutability: string;
-        /** True ⇒ not deployment-writable (the UI shows the platform-managed indicator, never an editor). */
-        locked: boolean;
+        /** The band's op columns: what a center artifact, a deployment's mods and a task may do to this section. */
+        ops: {
+            center: readonly OverlayOp[];
+            deploy: readonly OverlayOp[];
+            task: readonly OverlayOp[];
+        };
     }>;
 }
-export declare function describeDefaultPack(): DefaultPackDescription;
+export declare function describeCatalog(): CatalogDescription;

package/dist/prompt-assembly/explain.js

@@ -1,23 +1,28 @@
 import { EVENT_PROMPT_REGISTRY } from "./event-registry.js";
-import { SEMA_DEFAULT_PACK } from "./packs/sema-default.js";
-import { DEFAULT_SYSTEM_PROMPT } from "../prompts/default.js";
+import { bandOf } from "./bands.js";
+import { SEMA_DEFAULT_CATALOG, catalogText } from "./catalog/index.js";
 function safeId(raw) {
-    const cleaned = raw.replace(/[\u0000-\u001f\u007f]/g, "\u2400");
+    const cleaned = raw.replace(/[\u0000-\u001f\u007f]/g, "␀");
     return cleaned.length > 120 ? `${cleaned.slice(0, 117)}...` : cleaned;
 }
 export function explainPromptAssembly(input) {
     const lines = [];
-    lines.push(`constitution: ${safeId(input.constitution)}${input.constitution === "core" ? "" : " (non-default — see PromptProvider tier docs)"}`);
-    if (input.epoch) {
-        lines.push(`epoch: #${input.epoch.epoch} on ${safeId(input.epoch.packId)} (${safeId(input.epoch.artifactDigest).slice(0, 23)}…) via ${safeId(input.epoch.activatedBy)}`);
-    }
-    lines.push(`system blocks (v1 view): ${input.blocks.map((b) => `${safeId(b.id)}[${b.chars}ch]`).join(" → ")}`);
-    if (input.sections?.length) {
-        lines.push("sections (compiled IR):");
-        for (const s of input.sections) {
-            lines.push(`  ${safeId(s.id)}  slot=${safeId(s.slot)} carrier=${safeId(s.carrier)} cadence=${safeId(s.cadence)} cache=${safeId(s.cacheClass)} ${s.chars}ch #${safeId(s.hash)}${s.contentHash !== undefined ? ` content=${safeId(s.contentHash)}` : ""}`);
+    const short = (d) => (d === undefined ? "none" : `${safeId(d).slice(0, 23)}…`);
+    lines.push(`identity: ${short(input.identity.artifact)} (record #${input.identity.epoch} via ${safeId(input.identity.activatedBy)})`);
+    lines.push(`  layers: center=${short(input.identity.layers.center)} deploy=${short(input.identity.layers.deploy)} task=${short(input.identity.layers.task)}`);
+    const s = input.selectors;
+    lines.push(`  selectors: role=${safeId(s.host.role)} form=${safeId(s.host.form)} traits=[${s.traits.map(safeId).join(", ")}]${s.binding !== undefined ? ` binding=${safeId(s.binding)}` : ""}`);
+    lines.push(`system blocks: ${input.blocks.map((b) => `${safeId(b.id)}[${b.chars}ch]`).join(" → ")}`);
+    if (input.sections.length > 0) {
+        lines.push("sections:");
+        for (const sec of input.sections) {
+            const chain = sec.chain.map((l) => (l.source === "bundled" ? "bundled" : `${safeId(l.source)}:${l.op ?? "?"} ${safeId(l.overlay ?? "?")}${l.superseded === true ? " (superseded)" : ""}`)).join(" > ");
+            lines.push(`  ${safeId(sec.id)}  band=${safeId(sec.band)}${sec.variant !== undefined ? ` variant=${safeId(sec.variant)}` : ""} ${sec.chars}ch ${safeId(sec.locale)} ${safeId(sec.contentHash).slice(0, 19)}…  ${chain}`);
         }
     }
+    if (input.superseded?.length) {
+        lines.push(`superseded: ${input.superseded.map((o) => `${safeId(o.id)} (${safeId(o.source)}) on ${safeId(o.target)} by ${safeId(o.supersededBy)}`).join("; ")}`);
+    }
     if (input.tools?.length) {
         const legacy = input.tools.filter((t) => t.contractId.startsWith("legacy:"));
         lines.push(`tools: ${input.tools.length} mounted (${input.tools.length - legacy.length} contract-declared, ${legacy.length} legacy/external)`);
@@ -26,18 +31,10 @@ export function explainPromptAssembly(input) {
     lines.push(`event kinds registered: ${kinds.length} (default-on: ${kinds.filter((k) => k.defaultPolicy === "on").map((k) => k.kind).join(", ")})`);
     return lines.join("\n");
 }
-export function describeDefaultPack() {
+export function describeCatalog() {
     return {
-        packId: SEMA_DEFAULT_PACK.packId,
-        roleBaseText: DEFAULT_SYSTEM_PROMPT,
-        sections: [...SEMA_DEFAULT_PACK.sections].sort((a, b) => a.rank - b.rank).map((s) => ({
-            id: s.id,
-            slot: s.slot,
-            rank: s.rank,
-            owner: s.owner,
-            trust: s.trust,
-            mutability: s.mutability,
-            locked: s.mutability === "locked",
-        })),
+        catalogId: SEMA_DEFAULT_CATALOG.id,
+        roleBaseText: catalogText("core/role.base", "default"),
+        sections: [...SEMA_DEFAULT_CATALOG.sections].sort((a, b) => a.rank - b.rank).map((s) => ({ id: s.id, band: s.band, rank: s.rank, ops: bandOf(s.band).ops })),
     };
 }

package/dist/prompt-assembly/overlay.d.ts

@@ -0,0 +1,137 @@
+import { type BandId, type CatalogSection, type OverlayOp, type OverlaySource, type VariantWhen } from "./catalog/schema.js";
+/** One overlay: an operation on a target, carrying text (or a catalog message reference). */
+export interface PromptOverlay {
+    /** `<namespace>/<name>`; the `core/` namespace is the task sugar's alone. Names an added entry. */
+    readonly id: string;
+    readonly op: OverlayOp;
+    /** A message id (`replace` / `append`), a band id (`add`), or a section / added-entry id (`drop`). */
+    readonly target: string;
+    /** The overlay's text (`replace` / `append` / `add`); exclusive with `message`. */
+    readonly text?: string;
+    /** A catalog message whose selected variant is the overlay's text; exclusive with `text`. */
+    readonly message?: string;
+    /** The overlay applies to this run only when this holds (the variant selector's own vocabulary, the binding
+     *  included) — the one applicability condition of every source class. */
+    readonly when?: VariantWhen;
+}
+/** The source classes in application order (later wins). `bundled` is the catalog itself and writes no overlay. */
+export declare const OVERLAY_SOURCE_ORDER: readonly ["bundled", "task", "center", "deploy"];
+/** Who contributed an overlay: its source class and, within it, the contributor (`sugar`, a mods registration, the center). */
+export interface OverlayOrigin {
+    readonly source: OverlaySource;
+    readonly by: string;
+}
+export interface SourcedOverlay {
+    readonly overlay: PromptOverlay;
+    readonly origin: OverlayOrigin;
+}
+/** An overlay a later one on the same target overrode (or a drop removed), or one that changed nothing this run. */
+export interface SupersededOverlay {
+    readonly id: string;
+    readonly source: OverlaySource;
+    readonly by: string;
+    readonly target: string;
+    /** The overlay id that won, or {@link ABSENT_THIS_RUN}. */
+    readonly supersededBy: string;
+}
+/** `supersededBy` of an overlay that changed nothing this run: the selector chose no variant of its target, or of
+ *  the catalog message it takes its text from. */
+export declare const ABSENT_THIS_RUN = "(absent this run)";
+/** The section a message id is placed by, when the catalog places it. */
+export declare function sectionOfMessage(id: string): CatalogSection | undefined;
+export interface LockedEntry {
+    readonly message: string;
+    readonly variant: string;
+    readonly text: string;
+}
+/** Every constitution entry the guard compares: each message a constitution section places, every variant, whole. */
+export declare function lockedEntries(): readonly LockedEntry[];
+/** The constitution entries (`message#variant`) whose canonical text `text` contains verbatim. */
+export declare function lockedTextIn(text: string): string[];
+/** The task sugar's one violation: a role-layer text that carries locked text (an already-assembled prompt). */
+export declare function assembledRoleRefused(field: string, hits: readonly string[]): Error;
+/** Receive a source's prompt data ({@link PROMPT_DATA}): its frozen copy, or the clause naming what in it is not data. */
+export declare function receivePromptData(raw: unknown): {
+    readonly value: unknown;
+} | {
+    readonly notData: string;
+};
+/** The longest binding a task may name (`TaskSpec.promptBinding`), counted in Unicode code points (`[...s].length`) — not
+ *  in UTF-16 code units; every binding a `when.binding` list names is held to the same bound. Exported so a host screens
+ *  with the engine's number and the engine's unit. Code points are the one unit of every character bound of the prompt
+ *  artifact verifier ({@link codePointsOver}: a binding, an overlay id, `sourceRevision`, `evidence.intent`, a
+ *  reference), so a character outside the BMP (an emoji, a rare CJK ideograph) counts one, not two; the overlay text
+ *  budgets are UTF-8 bytes and are named so. */
+export declare const PROMPT_BINDING_MAX_CHARS = 128;
+/** The most bindings one `when.binding` list names — it bounds what a publisher can make the conflict check walk. */
+export declare const PROMPT_BINDING_LIST_MAX = 64;
+/** Whether `s` holds more than `max` Unicode code points — the one length unit of the prompt artifact verifier's
+ *  character bounds. A string of at most `max` code units fits (a code point is one or two of them); one of more than
+ *  twice `max` does not; only a string in between is counted — counted, never copied whole. */
+export declare function codePointsOver(s: string, max: number): boolean;
+/**
+ * The run's binding (`TaskSpec.promptBinding`): the scenario a `when.binding` condition reads, on an overlay of any
+ * source class. Its one writer is the task (a deployment names its scenario); absent ⇒ undefined. A value outside the
+ * grammar is refused by name (`config.prompt_selector_invalid`), never read as absent.
+ */
+export declare function resolvePromptBinding(task: {
+    readonly promptBinding?: unknown;
+}): string | undefined;
+/** What a validation needs besides the overlay: its source class, which mods event (if any) carries it, and the
+ *  entries lower classes added (the only entries a `drop` may name besides a built-in section). */
+export interface OverlayValidationContext {
+    readonly source: OverlaySource;
+    /** The mods event the overlay arrived on; absent for the sugar and the center. */
+    readonly event?: "prompt.compose";
+    /** The request-body sugar may use the `core/` namespace; nothing else may. */
+    readonly sugar?: boolean;
+    /** Ids of entries lower source classes added (`add`) and the band each landed in. */
+    readonly lowerAdds?: ReadonlyMap<string, BandId>;
+}
+/**
+ * Validate one overlay for one source class. Returns the overlay (a frozen copy of its known members, its `when` in
+ * normal form — {@link canonicalWhen}) or why it is a violation: shape, namespace, op, text/message, `when`, target existence, band authorization (and the band's mods
+ * write port), and the locked-text guard.
+ */
+export declare function validateOverlay(raw: unknown, ctx: OverlayValidationContext): {
+    readonly overlay: PromptOverlay;
+} | {
+    readonly violation: string;
+};
+/** One added entry as the fold leaves it. */
+export interface AddedEntry {
+    readonly id: string;
+    readonly band: BandId;
+    readonly rank: number;
+    readonly text: string;
+    readonly origin: OverlayOrigin;
+}
+/** One overlay in a section's history, in application order; `superseded` once a later one overrode it. The
+ *  composition puts the catalog's own text (`bundled`) first for a catalog section. */
+export interface ChainLink {
+    readonly source: "bundled" | OverlaySource;
+    readonly overlay?: string;
+    readonly op?: OverlayOp;
+    readonly superseded?: true;
+}
+/** The fold's result: per-message text the overlays set, dropped sections, added entries, superseded overlays. */
+export interface OverlayFold {
+    /** Message id → its text after the overlays (absent ⇒ the selected variant's text stands). */
+    readonly messageText: ReadonlyMap<string, {
+        readonly text: string;
+        readonly origin: OverlayOrigin;
+        readonly replaced: boolean;
+    }>;
+    /** Built-in section ids a drop removed. */
+    readonly dropped: ReadonlySet<string>;
+    readonly added: readonly AddedEntry[];
+    readonly superseded: readonly SupersededOverlay[];
+    /** Section id (or added-entry id) → the overlays applied to it, in order, superseded ones marked. */
+    readonly chains: ReadonlyMap<string, readonly ChainLink[]>;
+}
+/**
+ * Apply sourced overlays, already validated and already in application order, over the selected texts.
+ * `selectedText(messageId)` answers the text the selector chose (undefined ⇒ the message is absent this run);
+ * `applies(overlay)` answers its `when`.
+ */
+export declare function foldOverlays(ordered: readonly SourcedOverlay[], selectedText: (messageId: string) => string | undefined, applies: (o: PromptOverlay) => boolean, overlayText: (o: PromptOverlay) => string | undefined): OverlayFold;