@sema-agent/core 7.52.0 → 7.53.0

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

@@ -69,15 +69,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/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;

package/dist/prompt-assembly/overlay.js

@@ -5,6 +5,7 @@ import { bandOf, isBandId } from "./bands.js";
 import { SEMA_DEFAULT_CATALOG, catalogMessage } from "./catalog/index.js";
 import { HOST_FORMS, HOST_ROLES, OVERLAY_OPS, PROMPT_FACT_NAMES, PROMPT_TRAITS, isWordOf, } from "./catalog/schema.js";
 import { RENDERERS } from "./renderers.js";
+import { canonicalWhen } from "./select.js";
 export const OVERLAY_SOURCE_ORDER = Object.freeze(["bundled", "task", "center", "deploy"]);
 export const ABSENT_THIS_RUN = "(absent this run)";
 const SECTION_BY_ID = new Map(SEMA_DEFAULT_CATALOG.sections.map((s) => [s.id, s]));
@@ -40,16 +41,49 @@ export function assembledRoleRefused(field, hits) {
     return Object.assign(new Error(`prompt.assembled_role_refused: ${field} contains, verbatim, the locked text of ${named.slice(0, 4).join(", ")}${named.length > 4 ? ` and ${named.length - 4} more` : ""} — the engine composes the locked sections itself; supply only the role layer (an already-assembled prompt is refused, never passed through)`), { code: "prompt.assembled_role_refused" });
 }
 const ID_GRAMMAR = /^[a-z0-9][a-z0-9/._-]*$/;
-const OVERLAY_KEYS = new Set(["id", "op", "target", "text", "message", "scope", "when"]);
+const OVERLAY_KEYS = new Set(["id", "op", "target", "text", "message", "when"]);
 const OPS = new Set(OVERLAY_OPS);
 const PROMPT_DATA = Object.freeze({ accessors: "refuse", depth: 4, others: "refuse", freeze: true, isProxy: (v) => types.isProxy(v) });
 export function receivePromptData(raw) {
     const r = receive(raw, PROMPT_DATA);
     return r.ok ? { value: r.value } : { notData: describeFault(r.fault) };
 }
-const BINDING_MAX = 128;
+export const PROMPT_BINDING_MAX_CHARS = 128;
+export const PROMPT_BINDING_LIST_MAX = 64;
+export function codePointsOver(s, max) {
+    if (s.length <= max)
+        return false;
+    if (s.length > 2 * max)
+        return true;
+    let n = 0;
+    for (const _ of s)
+        if (++n > max)
+            return true;
+    return false;
+}
 function bindingProblem(v) {
-    return typeof v !== "string" || v.trim() === "" || v.length > BINDING_MAX ? `${str(v)} is not a non-blank string of at most ${BINDING_MAX} characters` : undefined;
+    return typeof v !== "string" || v.trim() === "" || codePointsOver(v, PROMPT_BINDING_MAX_CHARS) ? `${str(v)} is not a non-blank string of at most ${PROMPT_BINDING_MAX_CHARS} characters (code points)` : undefined;
+}
+function bindingConditionProblem(b) {
+    if (!isPlainRecord(b))
+        return `"when.binding" is ${Array.isArray(b) ? "an array" : str(b)}, not { anyOf: [...] } or { noneOf: [...] }`;
+    const keys = Object.keys(b);
+    const k = keys[0];
+    if (keys.length !== 1 || (k !== "anyOf" && k !== "noneOf"))
+        return `"when.binding" carries ${keys.length === 0 ? "no list" : keys.map((x) => str(x)).join(", ")} (exactly one of anyOf, noneOf)`;
+    const list = b[k];
+    if (!Array.isArray(list) || list.length === 0)
+        return `"when.binding.${k}" is ${Array.isArray(list) ? "empty" : str(list)}, not a list naming at least one binding`;
+    if (list.length > PROMPT_BINDING_LIST_MAX)
+        return `"when.binding.${k}" names ${list.length} bindings (at most ${PROMPT_BINDING_LIST_MAX})`;
+    for (const name of list) {
+        const why = bindingProblem(name);
+        if (why !== undefined)
+            return `"when.binding.${k}": ${why}`;
+    }
+    if (new Set(list).size !== list.length)
+        return `"when.binding.${k}" names a binding twice`;
+    return undefined;
 }
 export function resolvePromptBinding(task) {
     if (task.promptBinding === undefined)
@@ -69,8 +103,8 @@ function whenViolation(when) {
     if (typeof when !== "object" || when === null || Array.isArray(when))
         return `"when" is ${str(when)}, not an object`;
     for (const k of Object.keys(when))
-        if (k !== "traits" && k !== "host" && k !== "facts")
-            return `"when" carries ${str(k)} (traits, host, facts only)`;
+        if (k !== "traits" && k !== "host" && k !== "facts" && k !== "binding")
+            return `"when" carries ${str(k)} (traits, host, facts, binding only)`;
     const w = when;
     if (w["traits"] !== undefined) {
         const t = w["traits"];
@@ -107,6 +141,8 @@ function whenViolation(when) {
                 return `"when.facts.${k}" is ${str(v)}, not a boolean`;
         }
     }
+    if (w["binding"] !== undefined)
+        return bindingConditionProblem(w["binding"]);
     return undefined;
 }
 function textsOf(o) {
@@ -124,11 +160,14 @@ export function validateOverlay(raw, ctx) {
     const r = received.value;
     if (!isPlainRecord(r))
         return fail(`an overlay is an object, got ${Array.isArray(r) ? "an array" : str(r)}`);
-    for (const k of Object.keys(r))
-        if (!OVERLAY_KEYS.has(k))
-            return fail(`an overlay carries ${str(k)} (id, op, target, text, message, scope, when only)`);
-    const { id, op, target, text, message, scope, when } = r;
-    if (typeof id !== "string" || id.length === 0 || id.length > 128 || !ID_GRAMMAR.test(id))
+    for (const k of Object.keys(r)) {
+        if (OVERLAY_KEYS.has(k))
+            continue;
+        const rewrite = k === "scope" ? `; an overlay names its binding as "when": { "binding": { "anyOf": [<binding>] } }` : "";
+        return fail(`an overlay carries ${str(k)} (id, op, target, text, message, when only)${rewrite}`);
+    }
+    const { id, op, target, text, message, when } = r;
+    if (typeof id !== "string" || id.length === 0 || codePointsOver(id, 128) || !ID_GRAMMAR.test(id))
         return fail(`overlay id ${str(id)} is not ^[a-z0-9][a-z0-9/._-]*$ of at most 128 characters`);
     if (id.startsWith("core/") && ctx.sugar !== true)
         return fail(`overlay id ${str(id)}: the core/ namespace is the engine's own`);
@@ -150,11 +189,6 @@ export function validateOverlay(raw, ctx) {
         if (why !== undefined)
             return fail(`overlay "${id}": ${why}`);
     }
-    if (scope !== undefined && ctx.source !== "center")
-        return fail(`overlay "${id}": "scope" selects among a center artifact's overlays; a ${ctx.source} overlay answers for this run`);
-    if (scope !== undefined && (!isPlainRecord(scope) || Object.entries(scope).some(([k, v]) => k !== "binding" || bindingProblem(v) !== undefined))) {
-        return fail(`overlay "${id}": "scope" is { binding?: a non-blank string of at most ${BINDING_MAX} characters }`);
-    }
     let band;
     let where;
     if (op === "add") {
@@ -191,14 +225,14 @@ export function validateOverlay(raw, ctx) {
     }
     if (ctx.event !== undefined && row.modsEvent !== ctx.event)
         return fail(`overlay "${id}": ${where} is written through ${row.modsEvent ?? "no mods event"}, not ${ctx.event}`);
+    const normalWhen = canonicalWhen(when);
     const overlay = Object.freeze({
         id,
         op: op,
         target,
         ...(text !== undefined ? { text: text } : {}),
         ...(message !== undefined ? { message: message } : {}),
-        ...(scope !== undefined ? { scope: scope } : {}),
-        ...(when !== undefined ? { when: when } : {}),
+        ...(normalWhen !== undefined ? { when: normalWhen } : {}),
     });
     for (const t of textsOf(overlay)) {
         const hits = lockedTextIn(t);
@@ -255,6 +289,10 @@ export function foldOverlays(ordered, selectedText, applies, overlayText) {
                 addedBy.delete(o.target);
                 continue;
             }
+            if (!SECTION_BY_ID.has(o.target)) {
+                supersede(me, o.target, ABSENT_THIS_RUN);
+                continue;
+            }
             for (const m of sectionMessages(o.target)) {
                 for (const w of writers.get(m) ?? [])
                     supersede(w, m, o.id);

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

@@ -1,7 +1,7 @@
 /**
  * The selector: the one reading that picks, for a catalog message, the variant a run receives — and decides
- * whether an overlay's `when` applies to this run. Three dimensions, each with exactly one writer, so no value
- * ever needs a precedence order:
+ * whether an overlay's `when` applies to this run (every source class alike). Four dimensions, each with exactly one
+ * writer, so no value ever needs a precedence order:
  *
  * - `traits` — derived from the run's two prompt-shape axes by {@link promptTraitsOf} (the prompt profile and the
  *   fable-family model); catalog data reads traits, never the axes.
@@ -9,10 +9,12 @@
  *   `form` (`TaskSpec.promptForm`, which every engine-built child receives through the parent spec seat; absent ⇒
  *   `standard`).
  * - `facts` — the runtime facts prepare produces (one derived: `executionEnvironmentDeclared`).
+ * - `binding` — the deployment's scenario name (`TaskSpec.promptBinding`, an open vocabulary; absent ⇒ none).
  *
- * A variant's `when` is a conjunction: every listed trait present, every `noneOf` trait absent, every host key
- * equal, every fact equal. No disjunction, no expressions.
+ * A `when` is a conjunction: every listed trait present, every `noneOf` trait absent, every host key equal, every
+ * fact equal, the binding inside its `anyOf` (or outside its `noneOf`). No disjunction across dimensions.
  */
+import type { PromptManifestSelectors } from "../core/trace.js";
 import { type CatalogMessage, type FactConjunction, type HostForm, type HostRole, type PromptFactName, type PromptTrait, type Variant, type VariantWhen } from "./catalog/schema.js";
 import type { PromptRuntimeFacts } from "./types.js";
 /** The run's selector values, resolved once per assembly. */
@@ -23,6 +25,7 @@ export interface PromptSelectors {
         readonly form: HostForm;
     };
     readonly facts: Readonly<Record<PromptFactName, boolean>>;
+    readonly binding?: string;
 }
 /**
  * The run's prompt traits, derived from the two prompt-shape axes the engine resolves today: the simple
@@ -44,13 +47,25 @@ export declare function resolveHost(task: {
     readonly role?: HostRole;
     readonly form?: HostForm;
 };
-/** The run's selectors: traits and facts from the runtime facts, the host from its two writers' values. */
+/** The run's selectors — their one mint: traits and facts from the runtime facts, the host from its two writers' values,
+ *  the binding as the task's door validated it. */
 export declare function selectorsOf(facts: PromptRuntimeFacts, host?: {
     readonly role?: HostRole;
     readonly form?: HostForm;
-}): PromptSelectors;
+}, binding?: string): PromptSelectors;
+/** The selectors' plain form (traits sorted): what the manifest shows, the identity's `binding` element digests and the
+ *  `prompt.compose` event carries — one record. */
+export declare function selectorRecordOf(s: PromptSelectors): PromptManifestSelectors;
 export declare function factsHold(conj: FactConjunction | undefined, facts: Readonly<Record<PromptFactName, boolean>>): boolean;
 /** Whether a `when` holds under the run's selectors. */
 export declare function whenHolds(when: VariantWhen | undefined, s: PromptSelectors): boolean;
+/**
+ * A `when` in its normal form — the one spelling of what it asks: every list sorted and without repeats, a conjunct that
+ * asks nothing (an empty `traits`, `host` or `facts`, an empty list) left out, and a condition left with no conjunct
+ * (`{}`) is no condition at all (`undefined`). Two conditions that hold in the same runs by construction are equal as
+ * values here, so the overlay door (`validateOverlay`) hands every reader — the artifact digest, the publish-side
+ * conflict check — the same condition. Idempotent; it never changes which runs a condition holds for.
+ */
+export declare function canonicalWhen(when: VariantWhen | undefined): VariantWhen | undefined;
 /** The variant this run receives, or undefined when no variant's `when` holds (the message is absent). */
 export declare function selectVariant(message: CatalogMessage, s: PromptSelectors): Variant | undefined;

package/dist/prompt-assembly/select.js

@@ -36,13 +36,22 @@ export function resolveHost(task) {
     const form = task.promptForm === undefined ? undefined : task.promptForm === "minimal" ? "minimal" : refuse("promptForm", task.promptForm, ["minimal"]);
     return Object.freeze({ ...(role !== undefined ? { role } : {}), ...(form !== undefined ? { form } : {}) });
 }
-export function selectorsOf(facts, host = {}) {
+export function selectorsOf(facts, host = {}, binding) {
     return Object.freeze({
         traits: promptTraitsOf(facts),
         host: Object.freeze({ role: host.role ?? "general", form: host.form ?? "standard" }),
         facts: Object.freeze(catalogFactsOf(facts)),
+        ...(binding !== undefined ? { binding } : {}),
     });
 }
+export function selectorRecordOf(s) {
+    return {
+        ...(s.binding !== undefined ? { binding: s.binding } : {}),
+        traits: [...s.traits].sort(),
+        host: { role: s.host.role, form: s.host.form },
+        facts: { ...s.facts },
+    };
+}
 export function factsHold(conj, facts) {
     if (conj === undefined)
         return true;
@@ -61,8 +70,36 @@ function hostHolds(cond, host) {
         return true;
     return (cond.role === undefined || cond.role === host.role) && (cond.form === undefined || cond.form === host.form);
 }
+function bindingHolds(cond, binding) {
+    if (cond === undefined)
+        return true;
+    if (cond.anyOf !== undefined)
+        return binding !== undefined && cond.anyOf.includes(binding);
+    return binding === undefined || !cond.noneOf.includes(binding);
+}
 export function whenHolds(when, s) {
-    return when === undefined || (traitsHold(when.traits, s.traits) && hostHolds(when.host, s.host) && factsHold(when.facts, s.facts));
+    return when === undefined || (traitsHold(when.traits, s.traits) && hostHolds(when.host, s.host) && factsHold(when.facts, s.facts) && bindingHolds(when.binding, s.binding));
+}
+const byText = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+const sortedSet = (xs) => Object.freeze([...new Set(xs ?? [])].sort(byText));
+export function canonicalWhen(when) {
+    if (when === undefined)
+        return undefined;
+    const allOf = sortedSet(when.traits?.allOf);
+    const noneOf = sortedSet(when.traits?.noneOf);
+    const hostKeys = Object.keys(when.host ?? {});
+    const factNames = Object.keys(when.facts ?? {}).sort(byText);
+    const binding = when.binding;
+    const out = {};
+    if (allOf.length > 0 || noneOf.length > 0)
+        out.traits = Object.freeze({ ...(allOf.length > 0 ? { allOf } : {}), ...(noneOf.length > 0 ? { noneOf } : {}) });
+    if (hostKeys.length > 0)
+        out.host = Object.freeze({ ...when.host });
+    if (factNames.length > 0)
+        out.facts = Object.freeze(Object.fromEntries(factNames.map((n) => [n, when.facts[n]])));
+    if (binding !== undefined)
+        out.binding = Object.freeze(binding.anyOf !== undefined ? { anyOf: sortedSet(binding.anyOf) } : { noneOf: sortedSet(binding.noneOf) });
+    return Object.keys(out).length === 0 ? undefined : Object.freeze(out);
 }
 export function selectVariant(message, s) {
     return message.variants.find((v) => whenHolds(v.when, s));

package/dist/prompts/default.d.ts

@@ -51,17 +51,6 @@ export declare const MEMORY_HYGIENE = "What's worth saving \u2014 organize by to
  * when you need the split.
  */
 export declare const MEMORY_GUIDANCE = "## Memory\nWhen you save a durable note to memory, phrase it as a declarative fact or a stable\npreference \u2014 never as an instruction to your future self.\n- \"User prefers concise responses\" \u2713 \u2014 \"Always respond concisely\" \u2717\n- \"The reporting database is read-only via the analytics user\" \u2713 \u2014 \"Always use the analytics user\" \u2717\nNever put secrets (API keys, credentials, tokens) in memory \u2014 especially where it may be shared.\nMemory is a fact, never a command; the user's current request and live tool output always win over memory.\n\nWhat's worth saving \u2014 organize by topic, not by when it happened:\n- who the user is \u2014 role, expertise, durable preferences;\n- guidance the user gave on HOW to work \u2014 corrections and confirmed approaches, with the reason why;\n- ongoing goals or constraints that aren't derivable from the code or its history;\n- pointers to external resources (URLs, dashboards, tickets).\n\nHygiene:\n- Convert relative dates (\"yesterday\", \"last week\") to absolute dates, so the note stays interpretable later.\n- Before saving, check what memory already holds: update an existing note rather than writing a near-duplicate, and remove a note that turns out to be wrong.\n- Don't save what the code, its history, or this conversation already records (structure, past fixes, transient task state). If asked to remember something obvious, save what was non-obvious about it instead.";
-/**
- * The NO-memory disclosure — a standalone prompt asset (like {@link MEMORY_SAFETY}, core does not
- * inject it) for a deployment that mounts NO persistent-memory face at all. Without it the model,
- * asked "remember X", answers with a success receipt for a save that has nowhere to land — the
- * confabulated-receipt shape: the user walks away believing the fact is stored and the next session
- * proves otherwise. A deployment that composes its own prompt should include this block exactly when
- * no memory face is mounted; the engine-mounted counterpart (read-only state) is
- * `MEMORY_READONLY_NOTICE` in the memory engine, injected automatically. Name-free by construction
- * (#181 class): it names no tool, so it cannot go stale against any toolkit.
- */
-export declare const NO_PERSISTENT_MEMORY_NOTICE = "# Memory\n\nYou 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 \u2014 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).";
 /** The refuse-harmful-use security boundary (composed on every shape; safety text is never gated). */
 export declare const CYBER_RISK: string;
 /** The never-guess-URLs rule (composed on every shape). */

package/dist/prompts/default.js

@@ -24,9 +24,6 @@ Hygiene:
 - Before saving, check what memory already holds: update an existing note rather than writing a near-duplicate, and remove a note that turns out to be wrong.
 - Don't save what the code, its history, or this conversation already records (structure, past fixes, transient task state). If asked to remember something obvious, save what was non-obvious about it instead.`;
 export const MEMORY_GUIDANCE = `${MEMORY_SAFETY}\n\n${MEMORY_HYGIENE}`;
-export const NO_PERSISTENT_MEMORY_NOTICE = `# 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 CYBER_RISK = catalogText("core/security.cyber-risk");
 export const URL_SAFETY = catalogText("core/security.url-safety");
 export const SUMMARIZE_TOOL_RESULTS = catalogText("core/harness.tool-result-retention");

package/dist/stores/file/permission-rule-store.d.ts

@@ -52,7 +52,7 @@
 import type { PersistedRule, RuleTombstone } from "../../core/permission-rule-model.js";
 import type { DurableRulePartition, DurableRulePartitionProvider, PermissionRuleWriter, QuarantinedRuleAdd, RuleOwner, RuleSyncFrontier, StoredRules, WritableDurableRulePartition } from "../../core/permission-rule-store.js";
 import { PERMISSION_RULE_WRITER } from "../../core/permission-rule-store.js";
-import type { OrgRuleStatePersistence, PersistedOrgRuleState } from "../../core/permission-rule-org.js";
+import { type OrgRuleStatePersistence, type PersistedOrgRuleState } from "../../core/permission-rule-org.js";
 import type { StoreDurability, StoreFidelity } from "../../core/checkpoint-store.js";
 /**
  * The on-disk shape of one bucket. `schemaVersion` is the only field a future reader may rely on before

package/dist/stores/file/permission-rule-store.js

@@ -4,6 +4,7 @@ import { createHash, randomBytes } from "node:crypto";
 import { isRuleBehavior } from "../../core/permission-rule-model.js";
 import { posixModeBitsMeaningful } from "../../core/posix-mode-face.js";
 import { PERMISSION_RULE_WRITER, applySyncJoin, applyTombstones, assertDeleteDeltaCarriesNoAdd, assertRedemptionNotQuarantined, assertWriteDeltaScopeDurable, foldDelta, unknownRuleWriteDeltaError, } from "../../core/permission-rule-store.js";
+import { sameOrgPolicyContent } from "../../core/permission-rule-org.js";
 import { canonicalize } from "../../core/canonical-json.js";
 import { BootLock, FileStoreLockError } from "./fs-atomic.js";
 import { assertAdoptionBootGate } from "./adoption/marker.js";
@@ -549,7 +550,7 @@ class FileOrgRuleStatePersistence {
         if (cur !== undefined && state.revisionHighWater < cur.revisionHighWater) {
             throw new OrgRevisionRefusal(`refusing to lower the org revision high-water mark (${cur.revisionHighWater} → ${state.revisionHighWater}) — an interleaved install must re-read and re-compare`);
         }
-        if (cur !== undefined && state.snapshot.revision === cur.snapshot.revision && canonicalize(state.snapshot.rules) !== canonicalize(cur.snapshot.rules)) {
+        if (cur !== undefined && state.snapshot.revision === cur.snapshot.revision && !sameOrgPolicyContent(state.snapshot, cur.snapshot)) {
             throw new OrgRevisionRefusal(`refusing to replace org revision ${state.snapshot.revision} with DIFFERENT policy content under the same revision — content changes must bump the revision`);
         }
         if (cur !== undefined && state.snapshot.revision === cur.snapshot.revision && state.snapshot.fetchedAtMs <= cur.snapshot.fetchedAtMs)

package/dist/tools/artifact/artifact-tool.js

@@ -64,6 +64,7 @@ function renderFile(f) {
     return isTextMedia(f.mediaType) ? `${head}\n${Buffer.from(f.content).toString("utf8")}` : `${head}\n[binary content, not shown]`;
 }
 const isRecord = (x) => x !== null && typeof x === "object";
+const withDefaultAction = (args) => (isRecord(args) && args["action"] === undefined ? { ...args, action: "publish" } : args);
 const everyItem = (x, pred) => Array.isArray(x) && x.every(pred);
 const optString = (v) => v === undefined || typeof v === "string";
 const isRef = (x) => isRecord(x) && typeof x["url"] === "string" && typeof x["slug"] === "string" && typeof x["version"] === "string" && optString(x["title"]);
@@ -445,11 +446,11 @@ export function createArtifactTool(opts) {
         contentOrigin: ARTIFACT_PLANE_CONTENT_ORIGIN[caps.plane],
         description: artifactDescription(caps.plane, caps.actions),
         parameters: buildSchema(caps),
-        prepareArguments: (args) => (isRecord(args) && args["action"] === undefined ? { ...args, action: "publish" } : args),
+        prepareArguments: withDefaultAction,
         isConcurrencySafe: (args) => isRecord(args) && typeof args["action"] === "string" && ARTIFACT_ACTION_CONCURRENCY_SAFE[args["action"]] === true,
         execute: async (args, ctx) => {
-            const a = args;
-            const action = a.action ?? "publish";
+            const a = withDefaultAction(args);
+            const action = a.action;
             const target = typeof a.url === "string" ? a.url : undefined;
             if (target !== undefined)
                 activeTargets.set(target, (activeTargets.get(target) ?? 0) + 1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/core",
-  "version": "7.52.0",
+  "version": "7.53.0",
   "description": "Stateless, task-oriented AI agent core",
   "type": "module",
   "license": "BUSL-1.1",