@sema-agent/core 7.54.1 → 7.56.0

package/dist/orchestration/workflow.js

@@ -1,4 +1,4 @@
-import { resolveModelDisplayLabel } from "../core/roles.js";
+import { presetRoleBaseOf, resolveModelDisplayLabel } from "../core/roles.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { createHash, randomUUID } from "node:crypto";
 import { availableParallelism } from "node:os";
@@ -9,18 +9,20 @@ import { terminalProjection } from "../core/runner/terminal-projection.js";
 import { steeringError } from "../core/runner/steer-admission.js";
 import { builtinAgentDefinitions } from "../agents/builtin-agents.js";
 import { GENERAL_PURPOSE_SUBAGENT_TYPE, markerFragment } from "../agents/subagent.js";
-import { deploymentSubagentSystemPrompt, runnerRoleMap } from "../agents/child-model-seat.js";
+import { runnerRoleMap } from "../agents/child-model-seat.js";
+import { namesRoleBase } from "../prompt-assembly/role-base.js";
 import { combinePolicies, createAllowDenyPolicy } from "../core/tool-policy.js";
 import { createSafeNotifier } from "../core/safe-notify.js";
-import { callKeyOrdinal, oversizeJournalResult, journalOversizeTombstone, JOURNAL_OVERSIZE_ERROR_CODE, MAX_JOURNAL_RESULT_BYTES } from "../core/workflow-journal-store.js";
+import { callKeyOrdinal, clampRunIdText, oversizeJournalResult, journalOversizeTombstone, readWorkflowJournalEntry, JOURNAL_OVERSIZE_ERROR_CODE, MAX_JOURNAL_RESULT_BYTES, WorkflowJournalIncompatibleError, } from "../core/workflow-journal-store.js";
 import { isWorkflowRunActive, closeWorkflowChannel, markWorkflowActive, publishWorkflowEvent } from "./workflow-observe.js";
 import { isDurablePause } from "../agents/suspend-guard.js";
 import { RUNNING_AGENT_OBSERVE_EVERY_BEATS } from "../config/defaults.js";
 import { boundInputHashOf } from "../core/canonical-json.js";
 import { boundedRedactedSummary, egressThrownText } from "../core/untrusted-egress.js";
 import { delimitUntrusted } from "../core/untrusted-text.js";
-import { OUTPUT_TOOL_NAME } from "../core/runner/synthetic-tools.js";
+import { OUTPUT_TOOL_NAME } from "../core/tool-catalog-entries.js";
 import { deniedToolNamesOf, judgeHostToolCeiling } from "../core/runner/sub-agent-deny-lists.js";
+import { namesEveryTool } from "../agents/tool-filter.js";
 import { compileOutputSchema } from "../core/runner/strict-output-schema.js";
 import { WorkflowBudgetExceededError, WorkflowNestingError, WorkflowAgentBlockedError, WorkflowAgentParkedError, WorkflowAgentSchemaError, WorkflowAgentStalledError, WorkflowMaxAgentsError, WORKFLOW_SPAWN_BLOCKED_ERROR_CODE } from "./workflow-types.js";
 import { WorkflowScriptError } from "./workflow-meta.js";
@@ -104,7 +106,7 @@ export function applyWorkflowAgentType(spec, agentType, registry) {
         throw new Error(`agent(): unknown agentType "${agentType}". Known types: ${known}. Pass a registered agent type, or omit agentType for the default workflow subagent.`);
     }
     const out = { ...spec };
-    if (out.systemPrompt === undefined && def.systemPrompt !== undefined)
+    if (!namesRoleBase(out) && def.systemPrompt !== undefined)
         out.systemPrompt = def.systemPrompt;
     if (out.model === undefined && def.model !== undefined)
         out.model = def.model;
@@ -120,7 +122,8 @@ export function applyWorkflowAgentType(spec, agentType, registry) {
     if (out.memoryPersistenceCapable === undefined && def.memoryPersistenceCapable !== undefined)
         out.memoryPersistenceCapable = def.memoryPersistenceCapable;
     if (def.allowTools !== undefined || def.denyTools !== undefined) {
-        const perType = createAllowDenyPolicy({ ...(def.allowTools ? { allow: def.allowTools } : {}), ...(def.denyTools ? { deny: deniedToolNamesOf(`workflow agentType "${def.name}"`, def.denyTools) } : {}) });
+        const allow = def.allowTools !== undefined && !def.allowTools.some(namesEveryTool) ? def.allowTools : undefined;
+        const perType = createAllowDenyPolicy({ ...(allow ? { allow } : {}), ...(def.denyTools ? { deny: deniedToolNamesOf(`workflow agentType "${def.name}"`, def.denyTools) } : {}) });
         out.toolPolicy = out.toolPolicy ? combinePolicies(out.toolPolicy, perType) : perType;
     }
     return out;
@@ -132,21 +135,29 @@ export function workflowAgentRegistry(opts) {
     return [...deployment, ...builtins];
 }
 function withWorkflowChildPersona(spec, schema) {
-    if (spec.systemPrompt === undefined) {
+    if (!namesRoleBase(spec)) {
         return { ...spec, systemPrompt: schema ? WORKFLOW_SUBAGENT_PROMPT_SCHEMA : WORKFLOW_SUBAGENT_PROMPT };
     }
     const note = schema ? WORKFLOW_SUBAGENT_APPEND_SCHEMA : WORKFLOW_SUBAGENT_APPEND;
     return { ...spec, appendSystemPrompt: spec.appendSystemPrompt ? `${spec.appendSystemPrompt}\n\n${note}` : note };
 }
 function withWorkflowChildSeats(typed, inheritedModelSnap, inheritedThinkingSnap, roles) {
-    const statedPersona = deploymentSubagentSystemPrompt(roles);
-    return {
+    const seated = {
         ...typed,
-        modelRole: typed.modelRole ?? "subagent",
+        modelRole: typed.modelRole === undefined ? "subagent" : typed.modelRole,
         ...(typed.model === undefined && inheritedModelSnap !== undefined ? { model: inheritedModelSnap } : {}),
         ...(typed.thinking === undefined && inheritedThinkingSnap !== undefined ? { thinking: inheritedThinkingSnap } : {}),
-        ...(typed.systemPrompt === undefined && statedPersona !== undefined ? { systemPrompt: statedPersona } : {}),
     };
+    if (namesRoleBase(seated))
+        return seated;
+    let preset;
+    try {
+        preset = presetRoleBaseOf(seated, { roles });
+    }
+    catch {
+        preset = undefined;
+    }
+    return { ...seated, ...preset };
 }
 export function workflowAgentCallKey(ordinal, spec, opts) {
     const identity = {
@@ -229,17 +240,14 @@ export class WorkflowResultTooLargeError extends Error {
         this.name = "WorkflowResultTooLargeError";
     }
 }
-export class WorkflowJournalIncompatibleError extends Error {
-    fromRunId;
-    ordinal;
-    code = "workflow.journal_incompatible";
-    constructor(fromRunId, ordinal) {
-        super(`startWorkflow: resume from "${fromRunId}" was REFUSED — journal entry #${ordinal} carries no terminal cause (a journal written before TaskResult.terminal, or a malformed entry). ` +
-            "Completed work must not run again; start a fresh run instead of resuming this journal.");
-        this.fromRunId = fromRunId;
-        this.ordinal = ordinal;
-        this.name = "WorkflowJournalIncompatibleError";
-    }
+function judgedJournal(runId, rows) {
+    return rows.map((raw) => {
+        const read = readWorkflowJournalEntry(raw);
+        if (!("corrupt" in read))
+            return read.entry;
+        const callKey = raw?.callKey;
+        throw new WorkflowJournalIncompatibleError(runId, typeof callKey === "string" ? callKeyOrdinal(callKey) : -1, raw);
+    });
 }
 export class WorkflowJournalAppendTimeoutError extends Error {
     runId;
@@ -475,9 +483,6 @@ function createSemaphore(max) {
         }),
     };
 }
-function clampRunIdText(raw) {
-    return raw.replace(/[^A-Za-z0-9_.:-]/g, "").slice(0, 64);
-}
 const fallbackResumeClaimTables = new WeakMap();
 function fallbackResumeClaimKey(scope, sourceRunId) {
     return JSON.stringify([scope, sourceRunId]);
@@ -531,6 +536,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
     }
     const now = opts.now ?? (() => Date.now());
     const scope = opts.scope ?? "default";
+    const parkedResume = opts.parkedResume, claimHolder = opts.holder;
     const runId = opts.runId ?? randomUUID();
     if (opts.runId !== undefined && isWorkflowRunActive(opts.runId)) {
         throw new Error(`startWorkflow: runId "${opts.runId}" is already an active workflow run in this process`);
@@ -876,7 +882,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
         const p = parkedLeg;
         return new WorkflowAgentParkedError(p.label, p.paused.terminal.gate.kind, p.paused.terminal.checkpointId);
     };
-    const parkedResumeFor = (token) => opts.parkedResume?.find((d) => d.token === token);
+    const parkedResumeFor = (token) => parkedResume?.find((d) => d.token === token);
     const parkedCallChangedError = (ordinal) => Object.assign(new Error(`workflow resume: ordinal ${ordinal} is PARKED on an approval checkpoint, but the call at that ordinal changed (its call key differs from the journaled one) ` +
         (divergence === undefined
             ? "while no earlier call diverged from the record — the difference is in this call's own inputs (the script, its args, or a host input folded into the call identity). "
@@ -933,7 +939,9 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
         if (key.originRunId === opts.resumeFromRunId)
             entry = replayByOrdinal[ordinal];
         else if (journalStore) {
-            const loaded = await finalizeWithin(timers, new Promise((resolve) => resolve(journalStore.load(key.originRunId, scope))).then((entries) => ({ entries }), (err) => ({ err })), "timeout");
+            const loaded = await finalizeWithin(timers, new Promise((resolve) => resolve(journalStore.load(key.originRunId, scope)))
+                .then((rows) => ({ entries: judgedJournal(key.originRunId, rows) }))
+                .catch((err) => ({ err })), "timeout");
             if (loaded === "timeout" || "err" in loaded) {
                 emitRunLog(`resume: the journal of run "${clampRunIdText(key.originRunId)}" (the origin of the park at ordinal ${ordinal}) could not be read (${loaded === "timeout" ? `the load did not settle within ${WORKFLOW_RESUME_CLAIM_FINALIZE_TIMEOUT_MS}ms` : withoutToken(errText(loaded.err), key.token)}).`);
             }
@@ -953,6 +961,11 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
         stats: { turns: 0, tokens: 0, costMicroUsd: 0, usageMissing: true },
         terminal: { kind: "paused", gate: cp.gate, token: cp.token, ...(cp.checkpointId !== undefined ? { checkpointId: cp.checkpointId } : {}) },
     });
+    const driveInternals = (base, drive) => ({ ...base, ...(drive.inheritedGate !== undefined ? { inheritedGate: drive.inheritedGate } : {}), ...(claimHolder !== undefined ? { holder: claimHolder } : {}) });
+    const driveRefusalText = (err, drive) => {
+        const text = withoutToken(errText(err), drive.token);
+        return claimHolder === undefined || claimHolder === "" ? text : text.split(claimHolder).join("<holder>");
+    };
     const disposeParkedOrdinal = (truth, ordinal, callKey) => {
         if (truth.key.callKey !== callKey)
             throw parkedCallChangedError(ordinal);
@@ -969,7 +982,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                     code: "workflow.park_not_pending",
                     message: `the approval checkpoint this call was parked on is ${truth.status}${truth.checkpointId !== undefined ? ` (checkpoint ${truth.checkpointId})` : ""} — decided, expired or reaped outside this workflow; settled as failed on the resume's acknowledgement. The call did not run.`,
                 },
-                result: "",
+                result: "", resultEntryIds: [],
                 stats: { turns: 0, tokens: 0, costMicroUsd: 0, usageMissing: true },
             };
             return { kind: "settle", result };
@@ -1437,6 +1450,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                     objective,
                     tools: toolNames,
                     ...(systemPrompt !== undefined ? { systemPrompt } : {}),
+                    ...(runSpec.promptRole !== undefined ? { promptRole: runSpec.promptRole } : {}),
                     ...(schemaText !== undefined ? { outputSchema: schemaText } : {}),
                     ...(imageCount > 0 ? { uninspectedImageAttachments: imageCount } : {}),
                     ...(remoteSources.length > 0 ? { externalCapabilitySources: shownSources } : {}),
@@ -1753,7 +1767,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                                 ? runner.runTaskStream(attemptSpec, undefined, attemptInternals)
                                 : await (() => {
                                     const { objective: _o, sessionId: _s, ...resumeConfig } = attemptSpec;
-                                    return runner.resumeStream(drive.token, drive.outcome, resumeConfig, { ...attemptInternals, ...(drive.inheritedGate !== undefined ? { inheritedGate: drive.inheritedGate } : {}) });
+                                    return runner.resumeStream(drive.token, drive.outcome, resumeConfig, driveInternals(attemptInternals, drive));
                                 })();
                             for await (const ev of stream) {
                                 if (ev.type === "text_delta" || ev.type === "reasoning_delta")
@@ -1853,7 +1867,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
             }
             catch (err) {
                 if (drive !== undefined && !finalized && !thrownIs(err, WorkflowAgentParkedError)) {
-                    emitRunLog(`[park] the parked leg "${label}" could not be driven — the resume was refused before the checkpoint was consumed (${withoutToken(errText(err), drive.token)}); the park stands.`);
+                    emitRunLog(`[park] the parked leg "${label}" could not be driven — the resume was refused before this run consumed the checkpoint (${driveRefusalText(err, drive)}); the park stands on this run's record.`);
                     release();
                     return await parkAgentLeg(rec, drive.paused, activityTail, false);
                 }
@@ -1897,7 +1911,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                     const journaled = journalAppend(callKey, salvaged ?? {
                         taskId: callKey,
                         sessionId: "",
-                        result: boundedRedactedSummary(thrownText(err), 500),
+                        result: boundedRedactedSummary(thrownText(err), 500), resultEntryIds: [],
                         terminal: {
                             kind: "failed",
                             ...(thrownIs(err, WorkflowAgentBlockedError) ? { code: WORKFLOW_SPAWN_BLOCKED_ERROR_CODE } : thrownIs(err, WorkflowBudgetExceededError) ? { code: err.code } : {}),
@@ -1997,7 +2011,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                     taskId: callKey,
                     sessionId: "",
                     terminal: { kind: "failed", code: refusal.code, message: boundedRedactedSummary(refusal.message, 500) },
-                    result: boundedRedactedSummary(refusal.message, 500),
+                    result: boundedRedactedSummary(refusal.message, 500), resultEntryIds: [],
                     stats: { turns: 0, tokens: 0, costMicroUsd: 0, usageMissing: true },
                 }).catch(() => undefined);
                 throw refusal;
@@ -2056,12 +2070,12 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                     : await workflowDepthStore.run({ depth: depth + 1 }, () => {
                         const d = drive;
                         const { objective: _o, sessionId: _s, ...resumeConfig } = runSpec;
-                        return runner.resumeStream(d.token, d.outcome, resumeConfig, { ...runInternals, ...(d.inheritedGate !== undefined ? { inheritedGate: d.inheritedGate } : {}) });
+                        return runner.resumeStream(d.token, d.outcome, resumeConfig, driveInternals(runInternals, d));
                     });
             }
             catch (err) {
                 if (drive !== undefined && !finalized) {
-                    emitRunLog(`[park] the parked leg "${label}" could not be driven — the resume was refused before the checkpoint was consumed (${withoutToken(errText(err), drive.token)}); the park stands.`);
+                    emitRunLog(`[park] the parked leg "${label}" could not be driven — the resume was refused before this run consumed the checkpoint (${driveRefusalText(err, drive)}); the park stands on this run's record.`);
                     releaseLeg();
                     return await parkAgentLeg(rec, drive.paused, [], false);
                 }
@@ -2080,7 +2094,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                         taskId: callKey,
                         sessionId: "",
                         terminal: { kind: "failed", code: WORKFLOW_SPAWN_BLOCKED_ERROR_CODE, message: boundedRedactedSummary(refusal.message, 500) },
-                        result: boundedRedactedSummary(refusal.message, 500),
+                        result: boundedRedactedSummary(refusal.message, 500), resultEntryIds: [],
                         stats: { turns: 0, tokens: 0, costMicroUsd: 0, usageMissing: true },
                     }).catch(() => undefined);
                 }
@@ -2128,7 +2142,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                         taskId: callKey,
                         sessionId: "",
                         terminal: { kind: "failed", message: boundedRedactedSummary(thrownText(err), 500) },
-                        result: boundedRedactedSummary(thrownText(err), 500),
+                        result: boundedRedactedSummary(thrownText(err), 500), resultEntryIds: [],
                         stats: { turns: partialSpend?.turns ?? 0, tokens: partialSpend?.tokens ?? 0, costMicroUsd: partialSpend?.costMicroUsd ?? 0 },
                     }).catch(() => undefined);
                     bceTerminal(callKey, "failed", thrownText(err), undefined, rec.stats);
@@ -2299,22 +2313,16 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                             "re-run the whole suffix live, duplicating every side effect. Wait for the holder to reach a terminal " +
                             "state (or stop it) and resume again.");
                     }
-                    const entries = await journalStore.load(opts.resumeFromRunId, scope);
+                    const entries = judgedJournal(opts.resumeFromRunId, await journalStore.load(opts.resumeFromRunId, scope));
                     for (const e of entries) {
-                        const parked = e.parked;
-                        if (parked !== undefined) {
-                            const pt = parked?.terminal;
-                            if (pt === null || typeof pt !== "object" || pt.kind !== "paused" || typeof pt.token !== "string" || pt.token.length === 0) {
-                                throw new WorkflowJournalIncompatibleError(clampRunIdText(opts.resumeFromRunId), callKeyOrdinal(e.callKey));
+                        const ordinal = callKeyOrdinal(e.callKey);
+                        if (e.parked === undefined) {
+                            const t = e.result.terminal;
+                            if (t === null || typeof t !== "object" || !isTerminalCauseKind(t.kind)) {
+                                throw new WorkflowJournalIncompatibleError(opts.resumeFromRunId, ordinal);
                             }
-                            replayByOrdinal[callKeyOrdinal(e.callKey)] = e;
-                            continue;
-                        }
-                        const t = e.result?.terminal;
-                        if (t === null || typeof t !== "object" || !isTerminalCauseKind(t.kind)) {
-                            throw new WorkflowJournalIncompatibleError(clampRunIdText(opts.resumeFromRunId), callKeyOrdinal(e.callKey));
                         }
-                        replayByOrdinal[callKeyOrdinal(e.callKey)] = e;
+                        replayByOrdinal[ordinal] = e;
                     }
                     const fromRunId = clampRunIdText(opts.resumeFromRunId);
                     let prior = null;

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

@@ -1,4 +1,4 @@
-import { type OverlayOp, type PromptTrait } from "./catalog/schema.js";
+import { type OverlayOp, type PromptTraitName } 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 they name. */
@@ -8,7 +8,7 @@ export interface PromptArtifactRequires {
         readonly kind: "message" | "section" | "band";
     }[];
     readonly ops: readonly OverlayOp[];
-    readonly traits: readonly PromptTrait[];
+    readonly traits: readonly PromptTraitName[];
     readonly bindings: readonly string[];
 }
 /** Why the artifact exists: an intent sentence (required) and references to the evaluations or goldens behind it. */

package/dist/prompt-assembly/artifact.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { isBandId } from "./bands.js";
 import { SEMA_DEFAULT_CATALOG } from "./catalog/index.js";
-import { OVERLAY_OPS, PROMPT_TRAITS, isWordOf } from "./catalog/schema.js";
+import { OVERLAY_OPS, PROMPT_TRAIT_BUNDLES, PROMPT_TRAITS, isPromptTraitName, isWordOf } from "./catalog/schema.js";
 import { canonical } from "./epoch.js";
 import { codePointsOver, sectionOfMessage, validateOverlay } from "./overlay.js";
 export const ARTIFACT_LIMITS = Object.freeze({
@@ -41,10 +41,12 @@ export function requiresOf(overlays) {
             bindings.add(b);
     }
     const byText = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+    const vocabulary = [...PROMPT_TRAITS, ...Object.keys(PROMPT_TRAIT_BUNDLES)];
+    const rank = (t) => (vocabulary.includes(t) ? vocabulary.indexOf(t) : vocabulary.length);
     return {
         targets: [...targets.values()].sort((a, b) => byText(`${a.kind}:${a.id}`, `${b.kind}:${b.id}`)),
         ops: OVERLAY_OPS.filter((op) => ops.has(op)),
-        traits: PROMPT_TRAITS.filter((t) => traits.has(t)),
+        traits: [...traits].sort((a, b) => rank(a) - rank(b) || byText(a, b)),
         bindings: [...bindings].sort(byText),
     };
 }
@@ -59,7 +61,7 @@ export function unmetRequirements(requires) {
         if (!isWordOf(OVERLAY_OPS, op))
             unmet.push(`op "${String(op)}"`);
     for (const tr of requires.traits)
-        if (!isWordOf(PROMPT_TRAITS, tr))
+        if (!isPromptTraitName(tr))
             unmet.push(`trait "${String(tr)}"`);
     return unmet;
 }

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

@@ -9,7 +9,7 @@
  * skipped).
  */
 import type { AgentTool } from "../internal/harness-types.js";
-import type { HostForm, HostRole } from "./catalog/schema.js";
+import type { HostForm, HostRole, PromptTraitName } from "./catalog/schema.js";
 import { type SourcedOverlay, type SupersededOverlay } from "./overlay.js";
 import type { CompiledSection, CompiledSystemBlock, PromptRuntimeFacts } from "./types.js";
 export interface AssembleInputs {
@@ -26,6 +26,8 @@ export interface AssembleInputs {
     };
     /** The run's binding (`TaskSpec.promptBinding`), read by every overlay's `when.binding`. */
     binding?: string;
+    /** The run's effective traits (the model's declared set, the task's `promptLean`, bundles expanded). */
+    traits: ReadonlySet<PromptTraitName>;
     tools: readonly AgentTool[];
     facts: PromptRuntimeFacts;
     /** The task's working directory (the Cowork role base's `{{workspaceFolder}}`). */
@@ -36,7 +38,6 @@ export interface AssembleInputs {
     buildEnvBlock: (date: string) => string | undefined;
     /** The leg's frozen date — the initial render input. */
     date: string;
-    modelGuidance?: string;
     /** Structured warning channel (maps to deps.onError with a phase). */
     onWarn?: (message: string, phase: "prompt-constitution") => void;
 }

package/dist/prompt-assembly/assemble.js

@@ -18,6 +18,7 @@ export function assemblePrompt(inputs) {
         catalog: SEMA_DEFAULT_CATALOG,
         ...(inputs.host !== undefined ? { host: inputs.host } : {}),
         ...(inputs.binding !== undefined ? { binding: inputs.binding } : {}),
+        traits: inputs.traits,
         overlays: [...inputs.taskOverlays, ...inputs.centerOverlays, ...inputs.deployOverlays],
     };
     const toolNames = inputs.tools.map((t) => t.name);
@@ -28,7 +29,6 @@ export function assemblePrompt(inputs) {
         mcpInstructionsBlock: inputs.mcpInstructionsBlock,
         environmentBlock: inputs.buildEnvBlock(date),
         memoryBlock: inputs.memoryBlock,
-        modelGuidance: inputs.modelGuidance,
     });
     let last = composeCatalog(plan, renderInputs(inputs.date));
     const named = new Set();

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

@@ -45,13 +45,39 @@ export interface HostCondition {
     readonly form?: HostForm;
 }
 /**
- * The model-capability traits a variant may be selected on — the reference's capability names, spelled
- * as the reference spells them, so an anchor upgrade can be diffed mechanically. The producer
- * ({@link import("../select.js").promptTraitsOf}) yields exactly these two today; a name joins this set when a
- * producer can yield it, never before.
+ * The model-capability traits a variant may be selected on: the reference's capability names that gate
+ * model-visible text, spelled as the reference spells them so an anchor upgrade diffs mechanically
+ * (cli296.js B[7451052,7451700) `fvo` is the reference's whole capability list; its members that gate no text —
+ * effort, thinking, context-management, fast-mode, refusal-fallback and org-lock bits — are not prompt traits).
+ * A model declares the traits it would light in the reference (`Model.promptTraits`); the engine never derives
+ * them from a model id. Order is meaning only for the artifact requirement list (`requiresOf`), which lists the
+ * names it needs in this order, so a name is appended here, never inserted.
  */
-export declare const PROMPT_TRAITS: readonly ["lean_prompt", "fable_5_mitigations"];
+export declare const PROMPT_TRAITS: readonly ["lean_prompt", "fable_5_mitigations", "thrifty_sonic", "turn_updates", "bash_output_audience_note", "silent_turn_reminder", "thinking_display_updates", "quizzical_shore", "lucky_cerf", "amber_astrolabe", "bison_cairn", "larch_cistern", "haiku_5_5_early_stopping_guidance", "elapsed_time_reminder"];
 export type PromptTrait = (typeof PROMPT_TRAITS)[number];
+/**
+ * The reference's bundle capabilities and the traits each lights (cli296.js B[10825000,10826100) `t$` — its three
+ * member sets). A model may declare a bundle by name; its effective trait set holds the bundle name and every member.
+ * No remote switch turns a member off here: a deployment that wants one member off declares the members it wants.
+ */
+export declare const PROMPT_TRAIT_BUNDLES: Readonly<Record<"fable_5_1_prompt_bundle" | "opus_5_prompt_bundle" | "opus_5_5_prompt_bundle", readonly PromptTrait[]>>;
+export type PromptTraitBundle = keyof typeof PROMPT_TRAIT_BUNDLES;
+/** A deployment's own trait: `x-<namespace>-<name>`. The engine checks the spelling and gives it no meaning — an
+ *  overlay whose `when.traits` names it is what makes it select anything. */
+export type DeploymentPromptTrait = `x-${string}-${string}`;
+/** Every name a model may declare and an overlay's `when.traits` may name. */
+export type PromptTraitName = PromptTrait | PromptTraitBundle | DeploymentPromptTrait;
+/** The names a bundled catalog variant may select on: the reference's (a deployment's own trait has no meaning in
+ *  the engine's text). */
+export type CatalogPromptTrait = PromptTrait | PromptTraitBundle;
+/** The longest trait name the engine accepts. */
+export declare const PROMPT_TRAIT_NAME_MAX = 64;
+/** Whether a value is a trait name — the one reading the model door (`Model.promptTraits`), the overlay grammar
+ *  (`when.traits`) and the artifact requirement check share: a reference trait, a bundle, or a deployment's own
+ *  `x-<namespace>-<name>` of at most {@link PROMPT_TRAIT_NAME_MAX} characters. */
+export declare function isPromptTraitName(v: unknown): v is PromptTraitName;
+/** The members a trait name lights besides itself (a bundle's members; none for any other name). */
+export declare function bundleMembersOf(name: PromptTraitName): readonly PromptTrait[];
 /** The boolean facts a section admit or a variant `when` may test. All but the last are runtime facts the
  *  prepare phase produces; `executionEnvironmentDeclared` is derived once from two of them, so no `when`
  *  ever needs a disjunction. An optional fact that is absent reads as `false`. */
@@ -60,8 +86,8 @@ export type PromptFactName = (typeof PROMPT_FACT_NAMES)[number];
 /** A conjunction of fact equalities — the whole predicate language. No disjunction, no expressions. */
 export type FactConjunction = Readonly<Partial<Record<PromptFactName, boolean>>>;
 export interface TraitCondition {
-    readonly allOf?: readonly PromptTrait[];
-    readonly noneOf?: readonly PromptTrait[];
+    readonly allOf?: readonly PromptTraitName[];
+    readonly noneOf?: readonly PromptTraitName[];
 }
 /** How a text relates to the reference. `cc` entries use the byte-span locator grammar the anchor gate resolves
  *  (scripts/verify-anchor-claims.mjs): corpus file, byte span, and a backticked identifier that occurs in it. */
@@ -91,10 +117,15 @@ export interface VariantWhen {
     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">;
+/** The condition a BUNDLED catalog variant is chosen on: a {@link VariantWhen} without the binding, its traits the
+ *  reference's. A binding and an `x-` trait are a deployment's own vocabulary (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" | "traits"> & {
+    readonly traits?: {
+        readonly allOf?: readonly CatalogPromptTrait[];
+        readonly noneOf?: readonly CatalogPromptTrait[];
+    };
+};
 export interface CatalogMessage {
     /** `core/<area>.<name>`. */
     readonly id: string;
@@ -104,7 +135,7 @@ export interface CatalogMessage {
 }
 /** The renderers the catalog may place by id — data here, so the catalog checks its sections without loading the
  *  renderer code; renderers.ts holds the code and the version table, one row per id (its record type is total). */
-export declare const RENDERER_IDS: readonly ["role-base", "model-guidance", "mcp-instructions", "reminder-mark", "environment", "memory"];
+export declare const RENDERER_IDS: readonly ["role-base", "mcp-instructions", "reminder-mark", "environment", "memory"];
 export type RendererId = (typeof RENDERER_IDS)[number];
 export type SectionBody = {
     readonly message: string;

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

@@ -7,7 +7,39 @@ 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_TRAITS = Object.freeze([
+    "lean_prompt",
+    "fable_5_mitigations",
+    "thrifty_sonic",
+    "turn_updates",
+    "bash_output_audience_note",
+    "silent_turn_reminder",
+    "thinking_display_updates",
+    "quizzical_shore",
+    "lucky_cerf",
+    "amber_astrolabe",
+    "bison_cairn",
+    "larch_cistern",
+    "haiku_5_5_early_stopping_guidance",
+    "elapsed_time_reminder",
+]);
+export const PROMPT_TRAIT_BUNDLES = Object.freeze({
+    fable_5_1_prompt_bundle: Object.freeze(["turn_updates", "bash_output_audience_note", "silent_turn_reminder", "thinking_display_updates"]),
+    opus_5_prompt_bundle: Object.freeze(["bison_cairn", "larch_cistern"]),
+    opus_5_5_prompt_bundle: Object.freeze(["silent_turn_reminder", "quizzical_shore"]),
+});
+const DEPLOYMENT_TRAIT = /^x-[a-z0-9]+-[a-z0-9][a-z0-9._-]*$/;
+export const PROMPT_TRAIT_NAME_MAX = 64;
+export function isPromptTraitName(v) {
+    if (typeof v !== "string")
+        return false;
+    if (isWordOf(PROMPT_TRAITS, v) || Object.prototype.hasOwnProperty.call(PROMPT_TRAIT_BUNDLES, v))
+        return true;
+    return v.length <= PROMPT_TRAIT_NAME_MAX && DEPLOYMENT_TRAIT.test(v);
+}
+export function bundleMembersOf(name) {
+    return Object.prototype.hasOwnProperty.call(PROMPT_TRAIT_BUNDLES, name) ? PROMPT_TRAIT_BUNDLES[name] : [];
+}
 export const PROMPT_FACT_NAMES = Object.freeze([
     "policyEnabled",
     "hooksEnabled",
@@ -25,4 +57,4 @@ export const PROMPT_FACT_NAMES = Object.freeze([
     "isSubagent",
     "executionEnvironmentDeclared",
 ]);
-export const RENDERER_IDS = Object.freeze(["role-base", "model-guidance", "mcp-instructions", "reminder-mark", "environment", "memory"]);
+export const RENDERER_IDS = Object.freeze(["role-base", "mcp-instructions", "reminder-mark", "environment", "memory"]);

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

@@ -90,7 +90,6 @@ export const SECTIONS = [
             ],
         },
     },
-    { id: "core/behavior.model-guidance", band: "behavior", rank: 450, block: { id: "model.guidance" }, body: { renderer: "model-guidance" } },
     { id: "core/discovery.mcp-instructions", band: "discovery", rank: 500, block: { id: "mcp.instructions" }, body: { renderer: "mcp-instructions" } },
     { id: "core/harness.reminder-mark", band: "constitution", rank: 590, block: { id: "harness.reminder-mark" }, body: { renderer: "reminder-mark" } },
     { id: "core/environment.context", band: "environment", rank: 600, block: { id: "env.context" }, body: { renderer: "environment" } },

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

@@ -1,4 +1,4 @@
-import type { HostForm, HostRole, PromptCatalog } from "./catalog/schema.js";
+import type { HostForm, HostRole, PromptCatalog, PromptTraitName } from "./catalog/schema.js";
 import { type SourcedOverlay, type SupersededOverlay } from "./overlay.js";
 import type { CompiledSystemBlock, ComposedPrompt, SectionRenderInputs, SystemLayout } from "./types.js";
 /** What one composition renders: the catalog, the host selector values, and the overlays in application order. */
@@ -11,6 +11,8 @@ export interface CompositionPlan {
     };
     /** The run's binding (`TaskSpec.promptBinding`; absent ⇒ none) — what every overlay's `when.binding` reads. */
     readonly binding?: string;
+    /** The run's effective traits (`effectiveTraitsOf`; absent ⇒ those of a model that declares none). */
+    readonly traits?: ReadonlySet<PromptTraitName>;
     /** 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, plan.binding);
+    const s = selectorsOf(inputs.facts, plan.host, plan.binding, plan.traits);
     const bases = basesOf(plan.catalog, inputs, s);
     const selectedText = selectedTextOf(plan.catalog, bases);
     const overlayText = (o) => {

package/dist/prompt-assembly/event-registry.js

@@ -11,6 +11,7 @@ export const EVENT_PROMPT_REGISTRY = new Map([
     { kind: "total_tokens_reminder", carrier: "message.user-prefix", trust: "operator", dedupe: "replace-by-key", defaultPolicy: "on", rendererRef: "turn-attachments.ts#renderTotalTokensReminder" },
     { kind: "background_tasks", carrier: "message.user-prefix", trust: "operator", dedupe: "replace-by-key", defaultPolicy: "on", rendererRef: "turn-attachments.ts#renderBackgroundTasks" },
     { kind: "tools_delta", carrier: "message.user-prefix", trust: "external", dedupe: "replace-by-key", defaultPolicy: "off", rendererRef: "turn-attachments.ts#renderToolsDelta" },
+    { kind: "mcp_unavailable", carrier: "message.user-prefix", trust: "external", dedupe: "replace-by-key", defaultPolicy: "on", rendererRef: "turn-attachments.ts#renderMcpUnavailable" },
     { kind: "agent_listing", carrier: "message.user-prefix", trust: "operator", dedupe: "replace-by-key", defaultPolicy: "on", rendererRef: "turn-attachments.ts#renderAgentListingDelta" },
     { kind: "skills_listing", carrier: "message.user-prefix", trust: "operator", dedupe: "replace-by-key", defaultPolicy: "on", rendererRef: "turn-attachments.ts#renderSkillsListingDelta" },
     { kind: "mcp_instructions", carrier: "message.user-prefix", trust: "external", dedupe: "replace-by-key", defaultPolicy: "off", rendererRef: "turn-attachments.ts#renderMcpInstructionsDelta" },
@@ -20,6 +21,7 @@ export const EVENT_PROMPT_REGISTRY = new Map([
     { kind: "limit_approach_converge", carrier: "message.user-prefix", trust: "operator", dedupe: "once-per-run", defaultPolicy: "always", rendererRef: "run-turn-boundary.ts#limitApproachFrames" },
     { kind: "limit_approach_deliver", carrier: "message.user-prefix", trust: "operator", dedupe: "once-per-run", defaultPolicy: "always", rendererRef: "run-turn-boundary.ts#limitApproachFrames" },
     { kind: "final_verification", carrier: "message.user-prefix", trust: "operator", dedupe: "once-per-run", defaultPolicy: "always", rendererRef: "runtask.ts#final-verification" },
+    { kind: "advisor_tool", carrier: "message.user-prefix", trust: "operator", dedupe: "replace-by-key", defaultPolicy: "always", rendererRef: "advisor-instructions.ts#advisorInstructionFrame" },
 ].map((e) => [e.kind, e]));
 export function eventDefaultOn(kind) {
     return EVENT_PROMPT_REGISTRY.get(kind)?.defaultPolicy === "on";

package/dist/prompt-assembly/overlay.js

@@ -3,7 +3,7 @@ import { describeFault, isPlainRecord, receive } from "../core/mods/kernel/recei
 import { egressText } from "../core/untrusted-egress.js";
 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, isHostRole, isWordOf, } from "./catalog/schema.js";
+import { HOST_FORMS, HOST_ROLES, OVERLAY_OPS, PROMPT_FACT_NAMES, PROMPT_TRAITS, PROMPT_TRAIT_BUNDLES, isHostRole, isPromptTraitName, 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"]);
@@ -116,8 +116,8 @@ function whenViolation(when) {
             if (!Array.isArray(list))
                 return `"when.traits.${k}" is not an array`;
             for (const name of list)
-                if (!isWordOf(PROMPT_TRAITS, name))
-                    return `"when.traits.${k}" names ${str(name)}, not a trait (${PROMPT_TRAITS.join(", ")})`;
+                if (!isPromptTraitName(name))
+                    return `"when.traits.${k}" names ${str(name)}, not a trait (${PROMPT_TRAITS.join(", ")}; a bundle: ${Object.keys(PROMPT_TRAIT_BUNDLES).join(", ")}; or a deployment's own "x-<namespace>-<name>")`;
         }
     }
     if (w["host"] !== undefined) {

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

@@ -5,7 +5,7 @@ export interface RendererSpec {
     readonly id: RendererId;
     readonly version: number;
     readonly stability: "static" | "session" | "leg";
-    readonly reads: "inputs" | "facts" | "env" | "memory" | "mcp" | "mark" | "selectors";
+    readonly reads: "facts" | "env" | "memory" | "mcp" | "mark" | "selectors";
     readonly external: boolean;
     /** The catalog messages this renderer's output is (an overlay targets them). */
     readonly messages?: readonly string[];

package/dist/prompt-assembly/renderers.js

@@ -4,7 +4,6 @@ import { catalogMessage } from "./catalog/index.js";
 import { selectVariant } from "./select.js";
 export const RENDERERS = {
     "role-base": { id: "role-base", version: 2, stability: "session", reads: "selectors", external: false, messages: ["core/role.base"] },
-    "model-guidance": { id: "model-guidance", version: 1, stability: "session", reads: "inputs", external: false },
     "mcp-instructions": { id: "mcp-instructions", version: 1, stability: "session", reads: "mcp", external: true },
     "reminder-mark": { id: "reminder-mark", version: 1, stability: "session", reads: "mark", external: false },
     environment: { id: "environment", version: 2, stability: "leg", reads: "env", external: false },
@@ -25,8 +24,6 @@ export function runRenderer(id, inputs, selectors) {
             const sections = renderCoworkBase({ tools: inputs.toolNames ?? [], workspaceFolder: inputs.workspaceFolder });
             return sections.length === 0 ? undefined : { text: sections.map((s) => s.text).join("\n\n"), variant: v.id };
         }
-        case "model-guidance":
-            return plain(inputs.modelGuidance);
         case "mcp-instructions":
             return plain(inputs.mcpInstructionsBlock);
         case "reminder-mark":

package/dist/prompt-assembly/role-base.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The role base's one decision rule (a leaf): of an ordered list of sources — the task, the requested model role's
+ * preset, an engine spawner's child persona — the first that names a role base decides it wholly (the sugar's header).
+ */
+import type { HostRole } from "./catalog/schema.js";
+/** A source's statement of the role base — its word (the host role; selects the `core/role.base` variant), its text
+ *  (replaces that base), or both. `TaskSpec`, a role preset and the delegation tool's options have this shape. */
+export interface RoleBaseDeclaration {
+    readonly promptRole?: HostRole;
+    readonly systemPrompt?: string;
+}
+/** Whether a source names a role base — the one reading of "this seat has spoken". */
+export declare function namesRoleBase(d: RoleBaseDeclaration | undefined): boolean;
+/** The first source that names a role base, whole; `undefined` ⇒ none did. */
+export declare function roleBaseOf(sources: readonly (RoleBaseDeclaration | undefined)[]): RoleBaseDeclaration | undefined;