@sema-agent/core 7.52.0 → 7.53.0

package/dist/index.js

@@ -91,7 +91,7 @@ export { RemoteExecutionError, hasDestroy, isRemoteExecutionEnv, isSuspendable,
 export { withRetry } from "./core/with-retry.js";
 export { addWorktree, pruneWorktrees, WORKTREE_PARENT } from "./core/git-worktree-env.js";
 export { runExecGate } from "./core/exec-gate.js";
-export { sanitizeUntrustedText, delimitUntrusted, inlineUntrusted } from "./core/untrusted-text.js";
+export { sanitizeUntrustedText, delimitUntrusted, inlineUntrusted, isMintableProbeReason } from "./core/untrusted-text.js";
 export { mintReminderMark, isValidReminderMark, openSystemReminder, mintSystemReminder, reminderMarkDeclaration } from "./core/reminder-mint.js";
 export { deriveInvariants, checkInvariants } from "./core/property-harness.js";
 export { bashReversibilityProbe, BASH_READONLY_DEFAULT_ALLOW, parseLeadingCommandName, classifyCompoundReadonly, MAX_EDIT_BYTES } from "./tools/fs/index.js";
@@ -219,9 +219,10 @@ export { runMemoryConsolidation, CONSOLIDATION_SYSTEM_PROMPT, DEFAULT_CONSOLIDAT
 export { consolidateScope, advanceCursorAfterInline, } from "./core/consolidate-scope.js";
 export { resolveMemoryConsolidationDriver, autoRunOnRecommendationEffective, } from "./core/runner/memory-consolidation-driver.js";
 export { DEFAULT_COMPACTION_INSTRUCTIONS } from "./core/auto-compaction.js";
-export { DEFAULT_SYSTEM_PROMPT, CODE_AGENT_PROMPT, SUBAGENT_PROMPT, CODE_SYSTEM_PROMPT, MEMORY_GUIDANCE, MEMORY_SAFETY, MEMORY_HYGIENE, NO_PERSISTENT_MEMORY_NOTICE, OUTPUT_EFFICIENCY, CYBER_RISK, HARNESS_SECTION_ANCHOR, URL_SAFETY, SUMMARIZE_TOOL_RESULTS, EXECUTION_ENVIRONMENT, EXECUTION_ENVIRONMENT_OPEN_READS, executionEnvironmentBlockFor, buildEnvironmentContext, buildGitSnapshot, buildScratchpadSection, GIT_STATUS_MAX_CHARS, formatLocalDate, } from "./prompts/default.js";
+export { DEFAULT_SYSTEM_PROMPT, CODE_AGENT_PROMPT, SUBAGENT_PROMPT, CODE_SYSTEM_PROMPT, MEMORY_GUIDANCE, MEMORY_SAFETY, MEMORY_HYGIENE, OUTPUT_EFFICIENCY, CYBER_RISK, HARNESS_SECTION_ANCHOR, URL_SAFETY, SUMMARIZE_TOOL_RESULTS, EXECUTION_ENVIRONMENT, EXECUTION_ENVIRONMENT_OPEN_READS, executionEnvironmentBlockFor, buildEnvironmentContext, buildGitSnapshot, buildScratchpadSection, GIT_STATUS_MAX_CHARS, formatLocalDate, } from "./prompts/default.js";
 export { SUPERVISOR_PROMPT, ORCHESTRATION_GUIDANCE, ORCHESTRATION_AWARENESS, GOAL_COMPLETION_GUIDANCE } from "./prompts/supervisor.js";
 export { OVERLAY_SOURCE_ORDER } from "./prompt-assembly/overlay.js";
+export { PROMPT_BINDING_LIST_MAX, PROMPT_BINDING_MAX_CHARS } from "./prompt-assembly/overlay.js";
 export { BANDS as PROMPT_BANDS } from "./prompt-assembly/bands.js";
 export { OVERLAY_OPS, HOST_ROLES, HOST_FORMS } from "./prompt-assembly/catalog/schema.js";
 export { SEMA_DEFAULT_CATALOG, catalogText } from "./prompt-assembly/catalog/index.js";
@@ -300,6 +301,11 @@ export { TEAM_ROLES, DIRECTION_RELATIONS, teamRoleOf, mayDirect } from "./agents
 export { createListAgentsTool, LIST_AGENTS_TOOL_NAME, LIST_AGENTS_TOOL_ALIAS, LIST_AGENTS_MAX_RESULT_CHARS, PEER_LISTING_FRESH_WINDOW_MS, isFreshPeerRow } from "./agents/list-agents-tool.js";
 export { CROSS_SESSION_CLASSIFIER_RULE } from "./agents/cross-session-envelope.js";
 export { PEER_SESSION_ID_UNGRAMMATICAL_CODE, PEER_RESUPPLY_CAP } from "./agents/peer-session-drain.js";
+export { ORG_DELIVERY_REFUSAL_CODES, isOrgDeliveryRefusalCode, mintCrossPrincipalRecord, isGateMintedRecord, PRINCIPAL_INBOX_TRIAGE_POLICIES, principalInboxTriagePolicy, principalInboxSideEffectKey, principalInboxConsumerOf, PRINCIPAL_INBOX_CONSUMER_INVALID_CODE, } from "./agents/org-delivery-gate.js";
+export { PRINCIPAL_INBOX_HANDLE } from "./agents/cross-session-ref.js";
+export { CROSS_PRINCIPAL_MESSAGE_NOTICE } from "./agents/cross-session-envelope.js";
+export { principalInboundLayers } from "./agents/cross-session-judge.js";
+export { PRINCIPAL_INBOX_UNMINTED_CAUSE } from "./agents/peer-session-drain.js";
 export { renderCrossSessionMessageFrame, renderCrossSessionNoticeLine } from "./core/task-notification.js";
 export { PEER_HELD_QUEUE_CAP, PEER_IDLE_SUBSCRIPTION_TTL_MS, PEER_IDLE_SUBSCRIBER_TABLE_CAP, PEER_IDLE_OUTSTANDING_CAP, PEER_IDLE_PRIORS_KEPT, PEER_IDLE_FIRE_DEBOUNCE_MS, PEER_IDLE_HELD_BACKOFF_MS, PEER_IDLE_LABEL_MAX, CROSS_SESSION_DIALOG_EXPIRY_VALUES, CROSS_SESSION_DIALOG_EXPIRY_DEFAULT, resolveCrossSessionDialogExpiry, PEER_HELD_REVIEW_CAUSES, PEER_DELIVERY_RECEIPT_STATES, isPeerDeliveryReceiptState, PEER_DROP_REASONS, peerRecipientSuffix, renderCrossSessionDeliveryNotice, describePeerDropReasons, renderCrossSessionDroppedNotice, PEER_IDLE_NOTICE_KINDS, isPeerIdleNoticeKind, PEER_IDLE_UNAVAILABLE_CAUSES, peerIdleNoticeLabel, formatPeerNoticeClock, renderCrossSessionIdleNotice, describePeerIdleSubscription, } from "./agents/peer-notices.js";
 export { createPeerHeldQueue, peerHeldQueueFor, peerHeldQueueIfAny, peerHeldQueueKey, realPeerClock, } from "./agents/peer-held-queue.js";
@@ -312,17 +318,17 @@ export { builtinAgentDefinitions, BUILTIN_READONLY_DENY_TOOLS, EXPLORE_WHEN_TO_U
 export { createTaskServer, } from "./server/http.js";
 export { clearStaleToolResults, editBudget, } from "./core/context-edit.js";
 export { createOpenAIBrain } from "./brain/openai.js";
-export { createAnthropicBrain } from "./brain/anthropic.js";
+export { createAnthropicBrain, ANTHROPIC_DEFAULT_BASE_URL } from "./brain/anthropic.js";
 export { createOpenResponsesBrain } from "./brain/open-responses.js";
 export { FABLE_5_COMPAT, fable5Model } from "./brain/model-presets.js";
 export { createFailoverBrain } from "./brain/failover.js";
-export { createRoutingBrain } from "./brain/routing.js";
+export { createRoutingBrain, brainLaneOf } from "./brain/routing.js";
 export { repairTextToolCalls } from "./brain/tool-call-repair.js";
 export { createCircuitBreakerBrain, CIRCUIT_OPEN_MARKER, } from "./brain/circuit-breaker.js";
 export { createDegradingBrain, readDegradation, DEGRADED_DIAGNOSTIC_TYPE, } from "./brain/degrading.js";
 export { retryBackoffMs, parseRetryAfter } from "./brain/retry.js";
 export { WAITING_FIRST_TOKEN_AFTER_MS, WAITING_FIRST_TOKEN_EVERY_MS } from "./brain/stream-engine.js";
-export { adjudicateModelRoute, resolveRouteCredential, routeRefusalText, routePairingStatus, routeKeyOf, displayUrlOf, resolveRequestRoot, resolveRequestRootOf, joinRequestUrl, hasAuthCarrier, __resetCredentialOriginBindings, } from "./brain/route-adjudicator.js";
+export { adjudicateModelRoute, resolveRouteCredential, admitRouteRequest, routeRefusalText, routePairingStatus, routeKeyOf, displayUrlOf, resolveRequestRoot, resolveRequestRootOf, joinRequestUrl, hasAuthCarrier, __resetCredentialOriginBindings, } from "./brain/route-adjudicator.js";
 export { ROUTE_CREDENTIAL_SOURCES, ROUTE_CARRIERS, ROUTE_CARRIER_BAGS, REQUEST_ROOT_ORIGINS, ROUTE_CREDENTIAL_PAIRING, requestRouteOf, routePairingRowOf, } from "./brain/request-route.js";
 export { ROUTE_ADJUDICATION_CONFORMANCE_CORPUS } from "./brain/route-conformance.js";
 export {} from "./brain/timeout.js";
@@ -334,4 +340,4 @@ export { SHADOW_REASON, allowRuleShadowSentence, cardDisclosureOf } from "./core
 export { RULE_OFFERS_ABSENCES } from "./core/ask-origin.js";
 export { BOUND_GRANT_ABSENCES } from "./core/skill-grant-binding.js";
 export { DISPOSABLE_PROMPT_SECTIONS } from "./core/prompt-section-seat.js";
-export { readMcpToolAxes } from "./core/mcp-server-spec.js";
+export { readToolAxes, readMcpToolAxes } from "./core/mcp-server-spec.js";

package/dist/internal/harness.d.ts

@@ -23,6 +23,7 @@ export { BaseSessionStorage, leafIdAfterEntry } from "../engine/session/storage-
 export { InMemorySessionStorage } from "../engine/session/memory-storage.js";
 export { InMemorySessionRepo } from "../engine/session/memory-repo.js";
 export { uuidv7 } from "../engine/session/uuid.js";
+export { readToolCallArguments } from "../engine/loop/agent-loop.js";
 export { SessionError } from "../engine/harness/types.js";
 export type { AnnouncedListingSnapshot, AnnouncedListingSnapshotInput, AnnouncedMcpFailure } from "../engine/harness/types.js";
 export { normalizeGitAnnouncement } from "../engine/harness/types.js";

package/dist/internal/harness.js

@@ -11,6 +11,7 @@ export { BaseSessionStorage, leafIdAfterEntry } from "../engine/session/storage-
 export { InMemorySessionStorage } from "../engine/session/memory-storage.js";
 export { InMemorySessionRepo } from "../engine/session/memory-repo.js";
 export { uuidv7 } from "../engine/session/uuid.js";
+export { readToolCallArguments } from "../engine/loop/agent-loop.js";
 export { SessionError } from "../engine/harness/types.js";
 export { normalizeGitAnnouncement } from "../engine/harness/types.js";
 export { gitFrameContextVisible } from "../engine/session/session.js";

package/dist/orchestration/goal.d.ts

@@ -13,7 +13,8 @@
  */
 import type { RunnerSelfSeat } from "../core/runner/contracts.js";
 import type { CheckpointToken } from "../core/checkpoint-store.js";
-import type { TaskResult, TaskSpec } from "../core/types.js";
+import type { GateKind, PAUSE_REGISTRY } from "../core/pause-registry.js";
+import type { PausedCause, TaskResult, TaskSpec } from "../core/types.js";
 /** Read-only snapshot a `doneCheck` sees after one iteration. */
 export interface GoalTurnState {
     /** This iteration's full {@link TaskResult}. */
@@ -73,6 +74,18 @@ export type GoalStatus = "achieved" | "max_iterations" | "budget" | "blocked" |
  * objective / raise `budgetTokens`), `"walltime"` = `totalTimeoutMs` elapsed (give it more time).
  */
 export type GoalBudgetCause = "tokens" | "walltime";
+/**
+ * The gates a pause can carry when the status word reads `suspended`: the pause registry's rows whose `taskStatus` column is `suspended` —
+ * the column {@link pauseFamily} projects the status word from. The type reads the same table the status word does, so a row added to the
+ * table moves both, and a gate that reaches the mint below with that word is always one of these. Of the four kinds, a run's own pause is
+ * `human`, `irreversible_ask` or `resource_limit`; `task_done` is the handle a deployment parks, which the engine mints in no run but which
+ * a custom runner seat may return as a paused terminal, and which the table reads `suspended` too. The review kinds are `needs_review`.
+ */
+type SuspendedGate = Extract<PausedCause["gate"], {
+    kind: {
+        [K in GateKind]: (typeof PAUSE_REGISTRY)[K]["taskStatus"] extends "suspended" ? K : never;
+    }[GateKind];
+}>;
 export interface GoalResult {
     readonly status: GoalStatus;
     /** Last iteration's result; absent on a preflight-terminate (a stop BEFORE iteration 1 ran). */
@@ -93,6 +106,15 @@ export interface GoalResult {
     /** #111 — present IFF `status === "budget"` (the KEY is absent otherwise, so presence alone reads
      *  as "stopped on a ceiling"). See {@link GoalBudgetCause}. */
     readonly budgetCause?: GoalBudgetCause;
+    /** Present IFF `status === "suspended"` — every suspended result carries it, no other carries the KEY: WHY the run is parked, as the
+     *  gate it parked at (the checkpoint's own gate, the same object as `result.terminal.gate`; its words are the closed sets of
+     *  {@link import("../core/checkpoint-store.js").CheckpointGate}, narrowed to the kinds whose status word is `suspended`: `human`,
+     *  `irreversible_ask`, `resource_limit` — and `task_done`, the handle a deployment parks, which a run of this engine never mints but a custom
+     *  runner seat may return). The cause is read from the gate alone, never from the caller's signal:
+     *  `{ kind: "resource_limit", reason: "usage_window" }` waits for quota (`resumeAfterMs`); `reason: "preempt"` is the host's own resumable
+     *  stop (`TaskSpec.preemptSignal`); `human` / `irreversible_ask` wait on an approval; another `resource_limit` reason waits on an
+     *  allowance. A caller's abort that ended the run is `status: "aborted"` (no checkpoint); a park that won the race with it is that park. */
+    readonly suspendGate?: SuspendedGate;
 }
 /** Reserved name of the goal-completion signal tool (injected by `runGoal` when there is no outputSchema). */
 export declare const DECLARE_DONE_TOOL_NAME = "DeclareDone";
@@ -104,3 +126,4 @@ export declare const DECLARE_DONE_TOOL_NAME = "DeclareDone";
  * cancel; a durable pause (suspended/needs_review) is a hard boundary that surfaces the checkpointToken.
  */
 export declare function runGoal(runner: RunnerSelfSeat, spec: GoalSpec): Promise<GoalResult>;
+export {};

package/dist/orchestration/goal.js

@@ -100,9 +100,10 @@ export async function runGoal(runner, spec) {
             verificationKind,
             accepted: false,
             cumulativeTokens,
-            checkpointToken: over?.checkpointToken,
+            checkpointToken: over?.paused?.token,
             errorCode: over?.errorCode,
             ...(status === "budget" && over?.budgetCause !== undefined ? { budgetCause: over.budgetCause } : {}),
+            ...(status === "suspended" && over?.paused !== undefined ? { suspendGate: over.paused.gate } : {}),
         };
         if (verificationKind === "mechanical" && status !== "suspended" && status !== "needs_review") {
             runner.emitTaskOutcome?.({
@@ -145,7 +146,7 @@ export async function runGoal(runner, spec) {
             spentCostMicroUsd += (result.stats.costMicroUsd ?? 0) + (result.stats.nested?.costMicroUsd ?? 0);
             spentTurns += (result.stats.turns ?? 0) + (result.stats.nested?.turns ?? 0);
             if (isDurablePause(result.terminal)) {
-                return mk(pauseFamily(result.terminal), iteration, { result, checkpointToken: result.terminal.token });
+                return mk(pauseFamily(result.terminal), iteration, { result, paused: result.terminal });
             }
             const midStop = classifyStop();
             if (midStop)

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[];