@sema-agent/core 7.52.0 → 7.54.0

package/dist/prompt-assembly/artifact-store.d.ts

@@ -1,13 +1,35 @@
+import type { RunnerDeps } from "../core/runner-deps.js";
 import { type ArtifactVerifyCode, type PromptArtifact, type PublishedPromptArtifact } from "./artifact.js";
+/** Why a copy a store holds could not be used: the verifier refused it (its code and reason — a retired schema's reason
+ *  names the republish rewrite), or the store could not read it back (`unreadable`, the reason naming the read error). */
+export interface StoredArtifactRefusal {
+    readonly code: ArtifactVerifyCode | "unreadable";
+    readonly reason: string;
+}
+/** What a read tells its caller when a copy was there and could not be used. */
+export type OnArtifactRefused = (refusal: StoredArtifactRefusal) => void;
+/** The clause every reader says of a copy that could not be used, by its cause — one wording, wherever it is said. */
+export declare function refusalClause(refusal: StoredArtifactRefusal): string;
+/**
+ * The operator line for a stored center artifact that could not be read back: which copy, why — refused or unreadable
+ * (the clause above), or no copy at all — and what follows from it. The one sentence a boot restore and a pinned resume
+ * say.
+ */
+export declare function storedArtifactLine(artifactDigest: string, refusal: StoredArtifactRefusal | undefined, consequence: string): string;
 export interface PromptArtifactStore {
-    /** Verified read by digest — undefined on a miss OR on any verification failure of the stored bytes. */
-    get(artifactDigest: string): Promise<PublishedPromptArtifact | undefined>;
+    /**
+     * Verified read by digest — undefined on a miss OR on a copy that cannot be used. When a copy was there and could not
+     * be used — the verifier refused its bytes, or the store could not read them — `onRefused` is told once before the
+     * read answers undefined, so a caller can tell a refused or unreadable copy (a retired schema, a corrupt file, a file
+     * the process may not read) from a missing one. A store that holds a copy it cannot use calls it.
+     */
+    get(artifactDigest: string, onRefused?: OnArtifactRefused): Promise<PublishedPromptArtifact | undefined>;
     /** Write by digest (the caller verified before putting). */
     put(artifact: PublishedPromptArtifact): Promise<void>;
 }
 export declare class MemoryPromptArtifactStore implements PromptArtifactStore {
     private readonly byDigest;
-    get(artifactDigest: string): Promise<PublishedPromptArtifact | undefined>;
+    get(artifactDigest: string, onRefused?: OnArtifactRefused): Promise<PublishedPromptArtifact | undefined>;
     put(artifact: PublishedPromptArtifact): Promise<void>;
 }
 /** `artifacts/<hex>.json` under a caller-owned directory; atomic tmp+rename writes. */
@@ -15,7 +37,9 @@ export declare class FilePromptArtifactStore implements PromptArtifactStore {
     private readonly dir;
     constructor(dir: string);
     private fileFor;
-    get(artifactDigest: string): Promise<PublishedPromptArtifact | undefined>;
+    /** A file that is not there is a miss; one that is there and cannot be read (a directory in its place, a file the
+     *  process may not open, too many open files) is told to `onRefused` as `unreadable`, by its error code. */
+    get(artifactDigest: string, onRefused?: OnArtifactRefused): Promise<PublishedPromptArtifact | undefined>;
     put(artifact: PublishedPromptArtifact): Promise<void>;
 }
 export type PromptSourceState = {
@@ -47,8 +71,10 @@ export declare class FilePromptSourceStateStore implements PromptSourceStateStor
 export interface PromptArtifactSource {
     /** The current verified candidate new sessions (and every top-level session at a compaction) adopt; undefined = none. */
     current(): PublishedPromptArtifact | undefined;
-    /** Resolve a PINNED digest (the resume path). Undefined = unavailable — the caller fails loud. */
-    get(artifactDigest: string): Promise<PromptArtifact | undefined>;
+    /** Resolve a PINNED digest (the resume path). Undefined = unavailable — the caller fails loud. `onRefused` is the
+     *  store's (see {@link PromptArtifactStore.get}): told when a copy was there and could not be used, so the caller says
+     *  why. */
+    get(artifactDigest: string, onRefused?: OnArtifactRefused): Promise<PromptArtifact | undefined>;
     /** The tri-state every adoption decision keys on: `"active"` = a verified candidate is live; `"disabled"` = an
      *  EXPLICIT verified revocation (`applyDisabled`) — the one state that empties a pinned center layer;
      *  `"unavailable"` = no verified state (never configured, or a store miss at boot) — an outage never strips policy,
@@ -61,12 +87,16 @@ export interface PromptArtifactSource {
  *     in-memory swap. Any verification failure leaves EVERYTHING unchanged.
  *   - `applyDisabled(sourceRevision)` — an explicit, successful disable/delete response: persist disabled state +
  *     drop the candidate. (Network failure/304 = simply don't call anything.)
- *   - `restore()` — boot: re-resolve the persisted active state through the verified store; a miss or verify failure
- *     boots stateless (no candidate) without touching the persisted record.
+ *   - `restore()` — boot: re-resolve the persisted active state through the verified store; a miss, an unreadable copy
+ *     or a verify failure boots stateless (no candidate) without touching the persisted record, and says which on
+ *     `onError` (a refused copy — a retired schema's reason names the republish rewrite — and an unreadable one are told
+ *     apart from no copy at all).
  */
 export declare class CenterPromptSource implements PromptArtifactSource {
     private readonly store;
     private readonly stateStore;
+    private readonly onError;
+    private readonly notifier;
     private candidate;
     private state;
     /** Serialization tail for the three STATE-MUTATING entry points. Each is a multi-await sequence ending in a
@@ -78,12 +108,17 @@ export declare class CenterPromptSource implements PromptArtifactSource {
     private tail;
     /** Run `fn` after every previously-queued mutation settles (success OR failure — a failed apply must not wedge the queue). */
     private exclusive;
+    /** `onError` is the operator channel of the source's own acts (a boot restore that finds its persisted artifact
+     *  refused, unreadable or gone) — the Runner's sink, in its shape (`RunnerDeps.onError`): pass the Runner's. A boot
+     *  restore belongs to no session: its context is `{ phase: "prompt-constitution", sessionId: "", classification:
+     *  "center-source-restore" }`. Omitted = those acts are silent. */
     constructor(opts: {
         store: PromptArtifactStore;
         stateStore?: PromptSourceStateStore;
+        onError?: RunnerDeps["onError"];
     });
     current(): PublishedPromptArtifact | undefined;
-    get(artifactDigest: string): Promise<PromptArtifact | undefined>;
+    get(artifactDigest: string, onRefused?: OnArtifactRefused): Promise<PromptArtifact | undefined>;
     restore(): Promise<void>;
     sourceState(): "active" | "disabled" | "unavailable";
     applySnapshot(raw: unknown): Promise<{

package/dist/prompt-assembly/artifact-store.js

@@ -1,22 +1,37 @@
 import { mkdirSync, promises as fs } from "node:fs";
 import path from "node:path";
+import { createSafeNotifier, observeThenableRejection } from "../core/safe-notify.js";
 import { verifyPromptArtifact } from "./artifact.js";
-function verifiedRead(bytes, artifactDigest) {
+export function refusalClause(refusal) {
+    return refusal.code === "unreadable" ? `unreadable (${refusal.reason})` : `refused by this engine (${refusal.code}: ${refusal.reason})`;
+}
+export function storedArtifactLine(artifactDigest, refusal, consequence) {
+    return `center prompt artifact ${artifactDigest.slice(0, 23)}… ${refusal !== undefined ? `is ${refusalClause(refusal)}` : "has no stored copy"} — ${consequence}`;
+}
+function tellRefused(onRefused, refusal) {
+    const notifier = createSafeNotifier();
+    notifier.notify(() => observeThenableRejection(onRefused?.(refusal), notifier, "artifact-store.onRefused"), "artifact-store.onRefused");
+    return undefined;
+}
+function verifiedRead(bytes, artifactDigest, onRefused) {
+    const refuse = (refusal) => tellRefused(onRefused, refusal);
     let parsed;
     try {
         parsed = JSON.parse(bytes);
     }
     catch {
-        return undefined;
+        return refuse({ code: "shape", reason: "the stored bytes are not JSON" });
     }
     const v = verifyPromptArtifact(parsed);
-    return v.ok && v.artifact.artifactDigest === artifactDigest ? v.artifact : undefined;
+    if (!v.ok)
+        return refuse({ code: v.code, reason: v.reason });
+    return v.artifact.artifactDigest === artifactDigest ? v.artifact : refuse({ code: "digest", reason: "the stored artifact is not the one its digest names" });
 }
 export class MemoryPromptArtifactStore {
     byDigest = new Map();
-    async get(artifactDigest) {
+    async get(artifactDigest, onRefused) {
         const bytes = this.byDigest.get(artifactDigest);
-        return bytes === undefined ? undefined : verifiedRead(bytes, artifactDigest);
+        return bytes === undefined ? undefined : verifiedRead(bytes, artifactDigest, onRefused);
     }
     async put(artifact) {
         this.byDigest.set(artifact.artifactDigest, JSON.stringify(artifact));
@@ -32,7 +47,7 @@ export class FilePromptArtifactStore {
         const m = /^sha256:([0-9a-f]{64})$/.exec(artifactDigest);
         return m ? path.join(this.dir, "artifacts", `${m[1]}.json`) : undefined;
     }
-    async get(artifactDigest) {
+    async get(artifactDigest, onRefused) {
         const file = this.fileFor(artifactDigest);
         if (file === undefined)
             return undefined;
@@ -40,10 +55,13 @@ export class FilePromptArtifactStore {
         try {
             bytes = await fs.readFile(file, "utf8");
         }
-        catch {
-            return undefined;
+        catch (err) {
+            const code = typeof err === "object" && err !== null ? err.code : undefined;
+            if (code === "ENOENT")
+                return undefined;
+            return tellRefused(onRefused, { code: "unreadable", reason: `the store could not read its file: ${typeof code === "string" ? code : "an error with no code"}` });
         }
-        return verifiedRead(bytes, artifactDigest);
+        return verifiedRead(bytes, artifactDigest, onRefused);
     }
     async put(artifact) {
         const file = this.fileFor(artifact.artifactDigest);
@@ -99,6 +117,8 @@ export class FilePromptSourceStateStore {
 export class CenterPromptSource {
     store;
     stateStore;
+    onError;
+    notifier = createSafeNotifier();
     candidate;
     state = "unavailable";
     tail = Promise.resolve();
@@ -110,14 +130,15 @@ export class CenterPromptSource {
     constructor(opts) {
         this.store = opts.store;
         this.stateStore = opts.stateStore ?? new MemoryPromptSourceStateStore();
+        this.onError = opts.onError;
     }
     current() {
         return this.candidate;
     }
-    async get(artifactDigest) {
+    async get(artifactDigest, onRefused) {
         if (this.candidate?.artifactDigest === artifactDigest)
             return this.candidate;
-        return this.store.get(artifactDigest);
+        return this.store.get(artifactDigest, onRefused);
     }
     async restore() {
         return this.exclusive(async () => {
@@ -132,9 +153,14 @@ export class CenterPromptSource {
                 this.state = "unavailable";
                 return;
             }
-            const stored = await this.store.get(state.artifactDigest);
+            const refused = {};
+            const stored = await this.store.get(state.artifactDigest, (r) => void (refused.current = r));
             this.candidate = stored !== undefined ? { ...stored, sourceRevision: state.sourceRevision } : undefined;
             this.state = stored !== undefined ? "active" : "unavailable";
+            if (stored === undefined) {
+                const line = new Error(storedArtifactLine(state.artifactDigest, refused.current, "the source boots unavailable: a new session has no center layer until a verified artifact is applied"));
+                this.notifier.notify(() => observeThenableRejection(this.onError?.(line, { phase: "prompt-constitution", sessionId: "", classification: "center-source-restore" }), this.notifier, "center-source.onError"), "center-source.onError");
+            }
         });
     }
     sourceState() {

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

@@ -1,7 +1,7 @@
 import { type OverlayOp, type PromptTrait } from "./catalog/schema.js";
 import { type PromptOverlay, type SourcedOverlay } from "./overlay.js";
 /** What an artifact needs from the engine that composes it: the targets it names (each with what kind of target it
- *  is), the operations it uses, the traits its `when` conditions read, and the bindings its overlays are scoped to. */
+ *  is), the operations it uses, the traits its `when` conditions read, and the bindings they name. */
 export interface PromptArtifactRequires {
     readonly targets: readonly {
         readonly id: string;
@@ -18,9 +18,9 @@ export interface PromptArtifactEvidence {
 }
 /** The digested part of an artifact. */
 export interface PromptArtifactPayload {
-    readonly schemaVersion: 2;
+    readonly schemaVersion: 3;
     readonly requires: PromptArtifactRequires;
-    /** Every overlay is of the `center` class; `scope.binding` absent ⇒ applies under every binding. */
+    /** Every overlay is of the `center` class; one with no `when.binding` applies under every binding. */
     readonly overlays: readonly PromptOverlay[];
     readonly evidence: PromptArtifactEvidence;
 }
@@ -33,7 +33,8 @@ export interface PromptArtifact {
 export interface PublishedPromptArtifact extends PromptArtifact {
     readonly sourceRevision: string;
 }
-/** Validator bounds: they bound abuse and runaway publishes, not legitimate artifacts. */
+/** Validator bounds: they bound abuse and runaway publishes, not legitimate artifacts. A `…Chars` bound counts Unicode
+ *  code points (`codePointsOver`, the verifier's one character unit); a `…Bytes` bound counts UTF-8 bytes. */
 export declare const ARTIFACT_LIMITS: Readonly<{
     maxOverlays: 64;
     maxOverlayTextBytes: 32000;
@@ -85,17 +86,17 @@ export type CenterAdoption = {
     artifact: PromptArtifact;
     sourceRevision?: string;
 };
-/**
- * The center class's overlays for an adopted artifact under a binding: every overlay with no `scope.binding`, and
- * every one whose `scope.binding` equals the run's binding, in the artifact's order.
- */
-export declare function centerOverlaysOf(adoption: CenterAdoption | undefined, binding: string | undefined): readonly SourcedOverlay[];
+/** The center class's overlays for an adopted artifact, in the artifact's order. Which of them apply to a run is their
+ *  `when` (the binding included), read where every class's is — at the composition. */
+export declare function centerOverlaysOf(adoption: CenterAdoption | undefined): readonly SourcedOverlay[];
 /** An artifact a source handed a run, re-checked by this engine before the run adopts it; undefined when it fails. */
 export declare function adoptCenter(artifact: PromptArtifact, sourceRevision: string | undefined): CenterAdoption | undefined;
 /**
  * Build a published artifact from overlays and evidence — the one builder (a center's publish pipeline calls it):
- * `requires` is derived, the digest computed over the payload's JSON form (what travels), and the result goes
- * through the verifier, so the caller holds either a valid artifact or the reason it is not one.
+ * `requires` is derived, the digest computed over the payload's JSON form (what travels) with each overlay as the
+ * overlay door leaves it (its `when` in normal form, so one meaning is one digest), and the result goes through the
+ * verifier, so the caller holds either a valid artifact or the reason it is not one. An overlay the door refuses goes on
+ * as it was given: the verifier names it, in its own order of checks.
  */
 export declare function buildPromptArtifact(opts: {
     overlays: readonly PromptOverlay[];

package/dist/prompt-assembly/artifact.js

@@ -3,7 +3,7 @@ import { isBandId } from "./bands.js";
 import { SEMA_DEFAULT_CATALOG } from "./catalog/index.js";
 import { OVERLAY_OPS, PROMPT_TRAITS, isWordOf } from "./catalog/schema.js";
 import { canonical } from "./epoch.js";
-import { sectionOfMessage, validateOverlay } from "./overlay.js";
+import { codePointsOver, sectionOfMessage, validateOverlay } from "./overlay.js";
 export const ARTIFACT_LIMITS = Object.freeze({
     maxOverlays: 64,
     maxOverlayTextBytes: 32_000,
@@ -37,8 +37,8 @@ export function requiresOf(overlays) {
             need(o.message, "message");
         for (const t of [...(o.when?.traits?.allOf ?? []), ...(o.when?.traits?.noneOf ?? [])])
             traits.add(t);
-        if (o.scope?.binding !== undefined)
-            bindings.add(o.scope.binding);
+        for (const b of [...(o.when?.binding?.anyOf ?? []), ...(o.when?.binding?.noneOf ?? [])])
+            bindings.add(b);
     }
     const byText = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
     return {
@@ -77,24 +77,49 @@ function requiresShaped(v) {
         strings(v.traits) &&
         strings(v.bindings));
 }
+const bindingListOf = (b) => {
+    if (b === undefined)
+        return undefined;
+    const names = b.anyOf !== undefined ? b.anyOf : b.noneOf;
+    return { anyOf: b.anyOf !== undefined, names, set: new Set(names) };
+};
+function bindingsMeet(a, b) {
+    if (a === undefined || b === undefined)
+        return true;
+    if (a.anyOf && b.anyOf)
+        return a.names.some((x) => b.set.has(x));
+    if (a.anyOf)
+        return a.names.some((x) => !b.set.has(x));
+    if (b.anyOf)
+        return b.names.some((x) => !a.set.has(x));
+    return true;
+}
 function replaceConflict(overlays) {
-    const seen = new Map();
+    const groups = new Map();
     for (const o of overlays) {
         if (o.op !== "replace")
             continue;
-        const key = canonical({ target: o.target, binding: o.scope?.binding ?? null, when: o.when ?? null });
-        const prior = seen.get(key);
-        if (prior !== undefined)
-            return `overlays "${prior}" and "${o.id}" both replace "${o.target}" under the same binding and condition`;
-        seen.set(key, o.id);
+        const { binding, ...rest } = o.when ?? {};
+        const key = canonical({ target: o.target, when: rest });
+        groups.set(key, [...(groups.get(key) ?? []), { o, list: bindingListOf(binding) }]);
+    }
+    for (const group of groups.values()) {
+        for (let i = 0; i < group.length; i++) {
+            for (let j = i + 1; j < group.length; j++) {
+                const [{ o: p, list: pl }, { o: q, list: ql }] = [group[i], group[j]];
+                if (bindingsMeet(pl, ql)) {
+                    return `overlays "${p.id}" and "${q.id}" both replace "${p.target}" under one condition that can hold in the same run (write exclusive binding conditions: "noneOf": [x] beside "anyOf": [x])`;
+                }
+            }
+        }
     }
     return undefined;
 }
 export function verifyPromptArtifact(raw) {
     if (!isRecord(raw))
         return { ok: false, code: "shape", reason: "the published artifact is not an object" };
-    if (typeof raw.sourceRevision !== "string" || raw.sourceRevision.length === 0 || raw.sourceRevision.length > ARTIFACT_LIMITS.maxSourceRevisionChars) {
-        return { ok: false, code: "shape", reason: "sourceRevision missing or oversized" };
+    if (typeof raw.sourceRevision !== "string" || raw.sourceRevision.length === 0 || codePointsOver(raw.sourceRevision, ARTIFACT_LIMITS.maxSourceRevisionChars)) {
+        return { ok: false, code: "shape", reason: `sourceRevision missing or over ${ARTIFACT_LIMITS.maxSourceRevisionChars} characters (code points)` };
     }
     const v = verifyPromptArtifactBody(raw);
     return v.ok ? { ok: true, artifact: { ...v.artifact, sourceRevision: raw.sourceRevision } } : v;
@@ -111,8 +136,10 @@ export function verifyPromptArtifactBody(raw) {
     const payload = raw.payload;
     if (!isRecord(payload))
         return fail("shape", "payload is not an object");
-    if (payload.schemaVersion !== 2)
-        return fail("schema", `unsupported schemaVersion ${JSON.stringify(payload.schemaVersion)?.slice(0, 40)} (this engine reads schemaVersion 2 only)`);
+    if (payload.schemaVersion !== 3) {
+        const republish = payload.schemaVersion === 2 ? `; republish under schemaVersion 3 — an overlay's "scope": { "binding": b } becomes "when": { "binding": { "anyOf": [b] } }` : "";
+        return fail("schema", `unsupported schemaVersion ${JSON.stringify(payload.schemaVersion)?.slice(0, 40)} (this engine reads schemaVersion 3 only${republish})`);
+    }
     for (const k of Object.keys(payload))
         if (k !== "schemaVersion" && k !== "requires" && k !== "overlays" && k !== "evidence")
             return fail("shape", `payload carries ${JSON.stringify(k).slice(0, 60)}`);
@@ -151,11 +178,11 @@ export function verifyPromptArtifactBody(raw) {
     if (conflict !== undefined)
         return fail("overlay", conflict);
     const evidence = payload.evidence;
-    if (!isRecord(evidence) || typeof evidence.intent !== "string" || evidence.intent.trim() === "" || evidence.intent.length > ARTIFACT_LIMITS.maxIntentChars) {
-        return fail("evidence", `evidence.intent is a non-blank string of at most ${ARTIFACT_LIMITS.maxIntentChars} characters`);
+    if (!isRecord(evidence) || typeof evidence.intent !== "string" || evidence.intent.trim() === "" || codePointsOver(evidence.intent, ARTIFACT_LIMITS.maxIntentChars)) {
+        return fail("evidence", `evidence.intent is a non-blank string of at most ${ARTIFACT_LIMITS.maxIntentChars} characters (code points)`);
     }
-    if (!Array.isArray(evidence.refs) || evidence.refs.length > ARTIFACT_LIMITS.maxRefs || evidence.refs.some((r) => typeof r !== "string" || r.trim() === "" || r.length > ARTIFACT_LIMITS.maxRefChars)) {
-        return fail("evidence", `evidence.refs is a list of at most ${ARTIFACT_LIMITS.maxRefs} non-blank references`);
+    if (!Array.isArray(evidence.refs) || evidence.refs.length > ARTIFACT_LIMITS.maxRefs || evidence.refs.some((r) => typeof r !== "string" || r.trim() === "" || codePointsOver(r, ARTIFACT_LIMITS.maxRefChars))) {
+        return fail("evidence", `evidence.refs is a list of at most ${ARTIFACT_LIMITS.maxRefs} non-blank references of at most ${ARTIFACT_LIMITS.maxRefChars} characters (code points) each`);
     }
     for (const k of Object.keys(evidence))
         if (k !== "intent" && k !== "refs")
@@ -165,7 +192,7 @@ export function verifyPromptArtifactBody(raw) {
         return fail("evidence", `overlay "${behaviorReplace.id}" replaces core-behavior text; evidence.refs names at least one evaluation or golden`);
     }
     const normalized = {
-        schemaVersion: 2,
+        schemaVersion: 3,
         requires: requiresOf(overlays),
         overlays,
         evidence: { intent: evidence.intent, refs: [...evidence.refs] },
@@ -175,16 +202,20 @@ export function verifyPromptArtifactBody(raw) {
     return { ok: true, artifact: { payload: normalized, artifactDigest: raw.artifactDigest } };
 }
 const CENTER_ORIGIN = Object.freeze({ source: "center", by: "center" });
-export function centerOverlaysOf(adoption, binding) {
+export function centerOverlaysOf(adoption) {
     if (adoption === undefined)
         return [];
-    return adoption.artifact.payload.overlays.filter((o) => o.scope?.binding === undefined || o.scope.binding === binding).map((overlay) => ({ overlay, origin: CENTER_ORIGIN }));
+    return adoption.artifact.payload.overlays.map((overlay) => ({ overlay, origin: CENTER_ORIGIN }));
 }
 export function adoptCenter(artifact, sourceRevision) {
     const v = verifyPromptArtifactBody(artifact);
     return v.ok ? { artifact: v.artifact, ...(sourceRevision !== undefined ? { sourceRevision } : {}) } : undefined;
 }
 export function buildPromptArtifact(opts) {
-    const payload = JSON.parse(JSON.stringify({ schemaVersion: 2, requires: requiresOf(opts.overlays), overlays: opts.overlays, evidence: opts.evidence }));
+    const overlays = opts.overlays.map((o) => {
+        const v = validateOverlay(o, { source: "center" });
+        return "overlay" in v ? v.overlay : o;
+    });
+    const payload = JSON.parse(JSON.stringify({ schemaVersion: 3, requires: requiresOf(overlays), overlays, evidence: opts.evidence }));
     return verifyPromptArtifact({ payload, artifactDigest: sha256Hex(canonical(payload)), sourceRevision: opts.sourceRevision });
 }

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

@@ -24,6 +24,8 @@ export interface AssembleInputs {
         role?: HostRole;
         form?: HostForm;
     };
+    /** The run's binding (`TaskSpec.promptBinding`), read by every overlay's `when.binding`. */
+    binding?: string;
     tools: readonly AgentTool[];
     facts: PromptRuntimeFacts;
     /** The task's working directory (the Cowork role base's `{{workspaceFolder}}`). */

package/dist/prompt-assembly/assemble.js

@@ -3,7 +3,7 @@ import { composeCatalog, layoutSystemBlocks } from "./composer.js";
 import { ABSENT_THIS_RUN } from "./overlay.js";
 function supersededLine(s) {
     return s.supersededBy === ABSENT_THIS_RUN
-        ? `prompt overlay "${s.id}" (${s.source}, ${s.by}) on "${s.target}" changed nothing: the selector left its target, or the catalog message it takes its text from, out of this run`
+        ? `prompt overlay "${s.id}" (${s.source}, ${s.by}) on "${s.target}" changed nothing: what it names is not in this run (the selector chose no variant of its target, or of the catalog message it takes its text from; or the lower entry it drops was never added — its own condition left it out, or the layer that added it is not in force)`
         : `prompt overlay "${s.id}" (${s.source}, ${s.by}) on "${s.target}" is superseded by "${s.supersededBy}", applied after it (source order task < center < deploy; within a source, declaration order)`;
 }
 export function assemblePrompt(inputs) {
@@ -17,6 +17,7 @@ export function assemblePrompt(inputs) {
     const plan = {
         catalog: SEMA_DEFAULT_CATALOG,
         ...(inputs.host !== undefined ? { host: inputs.host } : {}),
+        ...(inputs.binding !== undefined ? { binding: inputs.binding } : {}),
         overlays: [...inputs.taskOverlays, ...inputs.centerOverlays, ...inputs.deployOverlays],
     };
     const toolNames = inputs.tools.map((t) => t.name);

package/dist/prompt-assembly/catalog/index.js

@@ -1,5 +1,6 @@
 import { CONSTITUTION_MESSAGES } from "./constitution.js";
 import { CORE_BEHAVIOR_MESSAGES } from "./core-behavior.js";
+import { MEMORY_MESSAGES } from "./memory.js";
 import { MODE_MESSAGES } from "./modes.js";
 import { ROLE_MESSAGES } from "./role.js";
 import { SECTIONS } from "./sections.js";
@@ -9,7 +10,7 @@ import { RENDERER_IDS, isWordOf } from "./schema.js";
 export const SEMA_DEFAULT_CATALOG = {
     id: "sema-default@2",
     bands: BANDS,
-    messages: [...ROLE_MESSAGES, ...CONSTITUTION_MESSAGES, ...CORE_BEHAVIOR_MESSAGES, ...MODE_MESSAGES, ...TEAM_MESSAGES],
+    messages: [...ROLE_MESSAGES, ...CONSTITUTION_MESSAGES, ...CORE_BEHAVIOR_MESSAGES, ...MODE_MESSAGES, ...TEAM_MESSAGES, ...MEMORY_MESSAGES],
     sections: SECTIONS,
 };
 export function validateCatalog(catalog) {

package/dist/prompt-assembly/catalog/memory.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Catalog messages of the `memory` band. No section places them: the band's bytes are the memory renderer's
+ * input, which the memory phase composes (prepare-memory.ts `composeInjection`); these are the texts it reads.
+ *
+ * - `core/memory.no-persistent-store`: the run has no memory store configured and no channel to persist through
+ *   (the roster-wide persistence verdict is false). Without it the model, asked "remember X", answers with a
+ *   receipt for a save that has nowhere to land. A store that is configured but did not mount this run does not
+ *   get this sentence (it is categorical, and a mount can succeed next time): it gets the engine's
+ *   writes-unavailable-right-now notice, with the failed mount as its cause. Name-free: it names no tool, so no
+ *   toolkit can make it stale.
+ */
+import type { CatalogMessage } from "./schema.js";
+export declare const MEMORY_MESSAGES: readonly CatalogMessage[];

package/dist/prompt-assembly/catalog/memory.js

@@ -0,0 +1,6 @@
+const NO_PERSISTENT_STORE = `# Memory
+
+You have no persistent memory store: what is said in this conversation is not automatically retained for future sessions. If the user asks you to remember something for later, say plainly that you cannot store it — do not claim to have noted or saved it. If you have file tools, you may offer to write it into a project file instead (files persist; conversation memory does not).`;
+export const MEMORY_MESSAGES = [
+    { id: "core/memory.no-persistent-store", variants: [{ id: "default", when: {}, text: NO_PERSISTENT_STORE }], attribution: { form: "sema-owned" } },
+];

package/dist/prompt-assembly/catalog/schema.d.ts

@@ -33,6 +33,9 @@ export interface BandRow {
  *  task (`TaskSpec.promptRole`); absent ⇒ `general`. */
 export declare const HOST_ROLES: readonly ["general", "code", "coordinator", "cowork"];
 export type HostRole = (typeof HOST_ROLES)[number];
+/** Membership test for {@link HostRole} — the one reading of "is this a role base the engine selects": the task door
+ *  (`TaskSpec.promptRole`) and the overlay grammar (`when.host.role`) both ask it. */
+export declare function isHostRole(v: unknown): v is HostRole;
 /** The host form: `minimal` leaves the core-behavior band out (the locked bands stay). Written only by
  *  `TaskSpec.promptForm`; absent ⇒ `standard`. */
 export declare const HOST_FORMS: readonly ["standard", "minimal"];
@@ -69,15 +72,29 @@ export interface Attribution {
 export interface Variant {
     /** Reported in the manifest — one of the answers to "why this sentence". */
     readonly id: string;
-    readonly when: VariantWhen;
+    readonly when: CatalogVariantWhen;
     readonly text: string;
 }
-/** The selector condition a variant (or an overlay) is chosen on: a conjunction over traits, host and facts. */
+/** A condition on the run's binding (`TaskSpec.promptBinding`, a deployment's scenario name): exactly one list. A run
+ *  with no binding is outside every `anyOf` and inside every `noneOf`. */
+export type BindingCondition = {
+    readonly anyOf: readonly string[];
+    readonly noneOf?: never;
+} | {
+    readonly noneOf: readonly string[];
+    readonly anyOf?: never;
+};
+/** The selector condition a variant (or an overlay) is chosen on: a conjunction over traits, host, facts and binding. */
 export interface VariantWhen {
     readonly traits?: TraitCondition;
     readonly host?: HostCondition;
     readonly facts?: FactConjunction;
+    readonly binding?: BindingCondition;
 }
+/** The condition a BUNDLED catalog variant is chosen on: a {@link VariantWhen} without the binding. A binding is a
+ *  deployment's own vocabulary (scenario names the engine cannot know), so no catalog variant can name one — the type
+ *  refuses it where the catalog data is written. */
+export type CatalogVariantWhen = Omit<VariantWhen, "binding">;
 export interface CatalogMessage {
     /** `core/<area>.<name>`. */
     readonly id: string;

package/dist/prompt-assembly/catalog/schema.js

@@ -3,6 +3,9 @@ export function isWordOf(words, v) {
 }
 export const OVERLAY_OPS = Object.freeze(["replace", "append", "add", "drop"]);
 export const HOST_ROLES = Object.freeze(["general", "code", "coordinator", "cowork"]);
+export function isHostRole(v) {
+    return isWordOf(HOST_ROLES, v);
+}
 export const HOST_FORMS = Object.freeze(["standard", "minimal"]);
 export const PROMPT_TRAITS = Object.freeze(["lean_prompt", "fable_5_mitigations"]);
 export const PROMPT_FACT_NAMES = Object.freeze([

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

@@ -9,6 +9,8 @@ export interface CompositionPlan {
         readonly role?: HostRole;
         readonly form?: HostForm;
     };
+    /** The run's binding (`TaskSpec.promptBinding`; absent ⇒ none) — what every overlay's `when.binding` reads. */
+    readonly binding?: string;
     /** Validated overlays, already in application order (`bundled < task < center < deploy`, then declaration order). */
     readonly overlays?: readonly SourcedOverlay[];
 }

package/dist/prompt-assembly/composer.js

@@ -91,7 +91,7 @@ function renderAdded(e, fold) {
     };
 }
 export function composeCatalog(plan, inputs) {
-    const s = selectorsOf(inputs.facts, plan.host);
+    const s = selectorsOf(inputs.facts, plan.host, plan.binding);
     const bases = basesOf(plan.catalog, inputs, s);
     const selectedText = selectedTextOf(plan.catalog, bases);
     const overlayText = (o) => {

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

@@ -10,11 +10,8 @@ export interface PromptOverlay {
     readonly text?: string;
     /** A catalog message whose selected variant is the overlay's text; exclusive with `text`. */
     readonly message?: string;
-    /** Selects a center artifact's overlay by binding; carried by center artifacts only. */
-    readonly scope?: {
-        readonly binding?: string;
-    };
-    /** The overlay applies to this run only when this holds (the variant selector's own closed vocabulary). */
+    /** 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. */
@@ -59,10 +56,23 @@ export declare function receivePromptData(raw: 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 center binding (`TaskSpec.promptBinding`): the key a center artifact's scoped overlays are selected by.
- * 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.
+ * 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;
@@ -79,9 +89,9 @@ export interface OverlayValidationContext {
     readonly lowerAdds?: ReadonlyMap<string, BandId>;
 }
 /**
- * Validate one overlay for one source class. Returns the overlay (a frozen copy of its known members) or why it is
- * a violation: shape, namespace, op, text/message, `when`, `scope`, target existence, band authorization (and the
- * band's mods write port), and the locked-text guard.
+ * 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;