@sema-agent/core 7.55.0 → 7.57.0

package/dist/core/runner/prepare-acquire-reconcile.js

@@ -6,6 +6,7 @@ import { lastAttachmentFrameOf } from "../user-attachment.js";
 import { reconcileInterruptedSession } from "../session-reconcile.js";
 import { detectConflicts, settleBranchWriteBack } from "./branch-writeback.js";
 import { settleTeardownLeg } from "./teardown-bounded.js";
+import { writesThroughLeg } from "./session-write-ledger.js";
 const RECONCILE_MAX_RETRIES = 3;
 export async function prepareAcquireReconcile(input) {
     const { sessions, spec, resume, wakeEffects } = input;
@@ -29,7 +30,7 @@ export async function prepareAcquireReconcile(input) {
         }
         conflictRef = { hit: false };
         const own = { ids: undefined };
-        session = new StoredSession(detectConflicts(acquired.session.getStorage(), conflictRef, own));
+        session = new StoredSession(detectConflicts(input.legWrites !== undefined ? writesThroughLeg(acquired.session.getStorage(), input.legWrites, acquired.sessionId) : acquired.session.getStorage(), conflictRef, own));
         if (!spec.sessionId) {
             break;
         }

package/dist/core/runner/prepare-ask-lane.d.ts

@@ -38,8 +38,8 @@ export interface PrepareAskLaneInput {
     advertisedWritableDirs: Pick<AdvertisedWritableDirs, "roots"> | undefined;
     /** borrowed-readonly — the leg's ONE exempt root, stamped on every request a policy judges (`ToolCallRequest.exemptRoots`). */
     exemptRoots: readonly string[];
-    /** borrowed-readonly — the shared mount roster; read at RUN time by the approval-preview projection (alias-aware
-     *  lookup over whatever the roster holds when the ask is minted). Never mutated here. */
+    /** borrowed-readonly — the shared mount roster; read at RUN time by the approval-preview projection (the dispatcher's
+     *  resolution over whatever the roster holds when the ask is minted). Never mutated here. */
     tools: readonly AgentTool[];
     /** borrowed-mutable — the inherited-unavailable marker set. Writer here: `resolveAskBound` consumes (`delete`) a
      *  marked call at its fail-closed intercept; the policy-chain phase records, the gate station sweeps. */

package/dist/core/runner/prepare-ask-lane.js

@@ -6,9 +6,11 @@ import { exactBoundInputHashOf } from "../canonical-json.js";
 import { composeCallSignal, raceSettlementAgainstSignal } from "./abort-race.js";
 import { failedJudgmentDeny, policyCheckAbortedDeny } from "./policy-throw.js";
 import { askMandateMember } from "../ask-origin.js";
-import { approvalCardMemberOf } from "../tool-roster.js";
+import { approvalCardMemberOf, survivorsByName } from "../tool-roster.js";
+import { toolNameIndex } from "../../internal/llm.js";
 import { gateAskCarry, lateAskSettlementObserver } from "./denial-limit-arms.js";
 import { consumeInheritedAskGrant } from "./inherited-ask-grants.js";
+import { requesterOf } from "../mods/extension-call.js";
 import { settleReadRootGrant } from "./read-root-grant.js";
 function createDenyObserverNotifier(bus, signal) {
     if (bus === undefined || !bus.hasHandlers("classic.PermissionDenied"))
@@ -32,7 +34,7 @@ const sanitizePreview = (node, depth = 0) => {
     return out;
 };
 function resolveApprovalPreview(tools, toolName, args) {
-    const t = tools.find((x) => x.name === toolName || (x.aliases?.includes(toolName) ?? false));
+    const t = toolNameIndex([...survivorsByName(tools).values()])(toolName);
     if (t?.approvalPreview === undefined)
         return {};
     try {
@@ -106,6 +108,7 @@ export function prepareAskLane(input) {
             ...askSourceIdentity(),
             ...riskAxesOf(req),
             ...approvalCardMemberOf(req),
+            ...requesterOf(modBus, req.toolCallId),
             ...(decision.action === "ask" && decision.requiresRealApproval === true ? { requiresRealApproval: true } : {}),
             ...(decision.action === "ask" ? askMandateMember(decision) : {}),
             ...(decision.action === "ask" ? gateAskCarry(decision, isLiveApproverSeat(onAsk), autoModeDenialTracking.current) : {}),

package/dist/core/runner/prepare-caps-and-workflow.d.ts

@@ -36,7 +36,7 @@ import type { AssertAllKeysHandled } from "../ask-origin.js";
 import { type ChildClampSource } from "../child-clamp-seats.js";
 import type { InheritedGate, Prepared, RunInternals, RunnerSelfSeat, ToolFaceSnapshot } from "./contracts.js";
 import { type BlockedRef } from "./synthetic-tools.js";
-import { RosterBuilder, type RosterAxisTables } from "../tool-roster.js";
+import { RosterBuilder } from "../tool-roster.js";
 import type { ParentSpecSeat } from "../parent-spec-seat.js";
 import { type RosterSpec } from "./caller-roster.js";
 export interface PrepareCapsAndWorkflowInput {
@@ -56,7 +56,7 @@ export interface PrepareCapsAndWorkflowInput {
     /** borrowed-readonly — the trusted spawn-side channel; the Workflow mount forwards `rootSessionId`, `placementRoot`,
      *  `onTaskNotification`, `workflowDepth`, the capture-floor getter reads `memoryCaptureAncestors`, and the arming reads
      *  the chain's auto-mode face (`inheritedGate.autoModeFace`). */
-    internals: Pick<RunInternals, "rootSessionId" | "placementRoot" | "onTaskNotification" | "workflowDepth" | "memoryCaptureAncestors" | "workflowParkedResume" | "questionFaceStripped" | "inheritedGate"> | undefined;
+    internals: Pick<RunInternals, "rootSessionId" | "placementRoot" | "onTaskNotification" | "workflowDepth" | "memoryCaptureAncestors" | "workflowParkedResume" | "holder" | "questionFaceStripped" | "inheritedGate"> | undefined;
     /** borrowed-readonly — the tree's cross-boundary token (inherited or minted), which the Workflow mount hands to its children. */ crossBoundaryTree: import("../cross-boundary-taint.js").CrossBoundaryTreeToken;
     /** borrowed-readonly — the acquired session; the classifier leg rebuilds its transcript window from `buildContext`. */
     session: Pick<StoredSession, "buildContext">;
@@ -78,12 +78,10 @@ export interface PrepareCapsAndWorkflowInput {
     lockedPreflight: Pick<LockedPreflight, "mcp">;
     /** borrowed-mutable — the effect collection (`Prepared.toolEffects`): the safety scan's caller entries, then the mounts' writes. */
     toolEffects: Prepared["toolEffects"];
-    /** borrowed-mutable — the scan's axis tables, so the builder moves an alias's axes with its member (a phase test may omit them). */
-    safetyAxes?: RosterAxisTables;
     /** borrowed-readonly — the frozen tool-face snapshot the Workflow mount forwards (exclude / defer / alwaysLoad / restoreGated). */
     toolFaceSnapshot: ToolFaceSnapshot;
-    /** borrowed-readonly — the resolved prompt profile (the Workflow mount's parentPromptProfile). */
-    promptProfile: ToolExecuteContext["promptProfile"];
+    /** borrowed-readonly — the task-level lean switch (the Workflow mount's parentPromptLean; absent ⇒ no key). */
+    promptLean: ToolExecuteContext["promptLean"];
     /** borrowed-readonly — the resolved interaction posture (the Workflow mount's parentInteractionPosture; absent ⇒ no key). */
     resolvedInteractionPosture: ToolExecuteContext["interactionPosture"];
     /** borrowed-readonly — the harness seat; the Workflow mount's parentModel / parentThinking getters read it call-time. */

package/dist/core/runner/prepare-caps-and-workflow.js

@@ -117,8 +117,8 @@ function autoModeArmReasonOf(intent, facePresent, caps, capsFaulted) {
     return { armed: true, reason: "armed" };
 }
 export async function prepareCapsAndWorkflow(input) {
-    const { spec, deps, parentSpecSeat, checkpointSeat, internals, session, sessionId, runId, hostTaskId, taskScope, taskRootFinal, model, thinking, lockedPreflight, toolEffects, safetyAxes, toolFaceSnapshot, promptProfile, resolvedInteractionPosture, harnessRef, askSeat, runClampSource, forwardEvent, inheritedGateForChildren, enrichSpecToolCtx, maybeOffload, requestReview, enterPlanMode, permissionMode, readDenyEntries, peerLaneActive, peerSendMessageBuiltIn, runnerSelf, delegated, sideCallBookRef } = input;
-    const roster = new RosterBuilder(toolEffects, safetyAxes);
+    const { spec, deps, parentSpecSeat, checkpointSeat, internals, session, sessionId, runId, hostTaskId, taskScope, taskRootFinal, model, thinking, lockedPreflight, toolEffects, toolFaceSnapshot, promptLean, resolvedInteractionPosture, harnessRef, askSeat, runClampSource, forwardEvent, inheritedGateForChildren, enrichSpecToolCtx, maybeOffload, requestReview, enterPlanMode, permissionMode, readDenyEntries, peerLaneActive, peerSendMessageBuiltIn, runnerSelf, delegated, sideCallBookRef } = input;
+    const roster = new RosterBuilder(toolEffects);
     for (const t of spec.tools ?? []) {
         const mounted = mountCallerTool(t);
         roster.mount(mounted, { source: callerMountSource(mounted), mountedBy: "scenario" });
@@ -317,7 +317,7 @@ export async function prepareCapsAndWorkflow(input) {
             parentDeferTools: toolFaceSnapshot.defer,
             parentAlwaysLoadTools: toolFaceSnapshot.alwaysLoad,
             ...(toolFaceSnapshot.restoreGated !== undefined ? { parentRestoreGatedTools: toolFaceSnapshot.restoreGated } : {}),
-            parentPromptProfile: promptProfile,
+            ...(promptLean !== undefined ? { parentPromptLean: promptLean } : {}),
             models: deps.models,
             agents: deps.agents,
             builtinAgents: deps.builtinAgents,
@@ -352,6 +352,7 @@ export async function prepareCapsAndWorkflow(input) {
                         return mine.length > 0 ? mine : undefined;
                     } }
                 : {}),
+            ...(internals?.holder !== undefined ? { holder: internals.holder } : {}),
             parentSpecSeat, ...(internals?.questionFaceStripped === true ? { parentQuestionFaceStripped: true } : {}),
             ...(resolvedInteractionPosture !== undefined ? { parentInteractionPosture: resolvedInteractionPosture } : {}),
             parentMemoryCaptureState: () => {

package/dist/core/runner/prepare-config-doors.d.ts

@@ -23,6 +23,7 @@ import type { Model } from "../../internal/llm.js";
 import type { ThinkingLevel } from "../../internal/harness.js";
 import { type MicroCompactMachine } from "../context-edit.js";
 import { type CrossBoundaryPosture } from "../cross-boundary-taint.js";
+import { type HostFloor } from "../host-floor.js";
 import { recordedModeSeed } from "../checkpoint-store.js";
 import { type ConfigDoorEntry, type LockedPreflight } from "../locked-config.js";
 import { type ResolvedRole } from "../roles.js";
@@ -33,10 +34,24 @@ import { type UsageWindow } from "../usage-window-store.js";
 import { type AskSeat } from "../wiring-manifest.js";
 import type { PrepareResume, RunInternals, ToolFaceLists } from "./contracts.js";
 import { resolveHost } from "../../prompt-assembly/select.js";
+import type { PromptTraitName } from "../../prompt-assembly/catalog/schema.js";
 import { type RosterSpec } from "./caller-roster.js";
+/**
+ * The model a compaction pass summarizes on: the explicit `compactionModel` wins (resolved at `seat`, the word a
+ * refusal names), else the `summarize` role when one is configured, else `undefined` — the pass then falls back to
+ * the main model inside `maybeCompact`. One reading for a run's prepare and the out-of-run `Runner.compactSession`.
+ */
+export declare function resolveCompactionModel(spec: Pick<TaskSpec, "compactionModel" | "roles">, deps: Pick<RunnerDeps, "models" | "roles">, seat: string): Model | undefined;
 export declare function limitConfigError(code: string, message: string): Error & {
     code?: string;
 };
+/**
+ * `TaskSpec.principal`: absent (omitted, or the empty string the engine has always read as no principal) or a principal name. A
+ * principal that was PROVIDED and is no name (white space, an invisible or control character, a non-string) is refused at the task, on
+ * every leg a resume's re-supplied config included — read as "no principal" it would reach the unauthenticated floor, or, on a
+ * deployment that declared local-owner rules, the machine owner's standing approvals.
+ */
+export declare function assertPrincipalValue(raw: unknown): void;
 /**
  * Validate `TaskSpec.limits` at the door and return it unchanged.
  *
@@ -52,8 +67,9 @@ export declare function limitConfigError(code: string, message: string): Error &
  */
 export declare function resolveTaskLimits(limits: TaskLimits | undefined): TaskLimits | undefined;
 /**
- * Validate the MODE-VALUED members of `TaskSpec.attachments` at the same door, and return the
- * config unchanged. Today that is exactly one member, `totalTokensReminderMode`.
+ * Validate the members of `TaskSpec.attachments` that refuse a value they cannot read at the same door, and return the
+ * config unchanged. Today that is two: the mode-valued `totalTokensReminderMode` and the boolean switch `mcpUnavailable`
+ * (read by its own reader, `mcpUnavailableOn`, which the leg asks as well).
  *
  * WHY A DOOR AT ALL (坏值响亮度律): a knob whose bad value silently folds to the default is a knob the
  * deployment believes is armed. `totalTokensReminderMode: "padded_countdown"` (underscore) or
@@ -86,36 +102,13 @@ export declare function resolveTaskLimits(limits: TaskLimits | undefined): TaskL
  */
 export declare function resolveAttachmentsConfig(attachments: TaskSpec["attachments"]): TaskSpec["attachments"];
 /**
- * R2 双形轴(追加令 2026-07-18): the reference's fable-variant prompt gate (
- * `fable_5_mitigations` capability / claude-mythos-5), ORTHOGONAL to the simple/classic profile.
- * sema is BYOM, so the id may carry provider prefixes ("anthropic/claude-fable-5",
- * "openrouter/anthropic/claude-fable-5"): BOUNDARY-AWARE family match on the last path segment
- * (raw substring classified "vendor/not-claude-fable-5" and "claude-mythos-50"
- * as fable), case-normalized. Recognition set = CC's _Nr (startsWith "claude-fable-") + b9e
- * (mythos-5). R3 system sections fork on the resulting fact.
+ * The run's prompt traits — the one place prepare forms them: the model's declared set (`Model.promptTraits`, read
+ * through the model door: a retired `promptGuidance` or a name that is no trait refuses the task by name) with the
+ * task's switch on `lean_prompt` (`promptLean`, as the spec writes it — an engine-built child's spec carries its
+ * parent's), bundles expanded ({@link effectiveTraitsOf}). The reference's counterpart is a model registry's capability list; sema is
+ * BYOM, so the model entry carries the list and no model id is read.
  */
-export declare function isFableFamilyModelId(id: string): boolean;
-/**
- * The SINGLE decision point for the two prompt-shape axes.
- * Both were resolved in separate places with different mechanisms — `promptProfile` off a TaskSpec field,
- * `fableMitigations` off a raw model-id prefix test — so "which shape does this task speak" had no one
- * place to read. The reference's counterpart is a model-registry `capabilities` array (one table drives
- * `lean_prompt` + `fable_5_mitigations` alike).
- *
- * sema stays BYOM: we cannot key off a capability table for arbitrary model ids, so the RESOLUTION RULES
- * are unchanged — profile: spec > inherited internals > "simple"; mitigations: model family. This is a
- * consolidation, not a behavior change (the axes stay ORTHOGONAL: neither rewrites the other).
- */
-export declare function resolveModelPromptTraits(model: {
-    id: string;
-}, spec: {
-    promptProfile?: "simple" | "classic";
-}, internals?: {
-    promptProfile?: "simple" | "classic";
-}): {
-    promptProfile: "simple" | "classic";
-    fableMitigations: boolean;
-};
+export declare function resolvePromptTraits(model: Model, promptLean: boolean | undefined): ReadonlySet<PromptTraitName>;
 export interface PrepareConfigDoorsInput {
     /** borrowed-readonly — the snapshot spec (its roster is faces). NEVER mutated here: the per-task agents rebind returns a
      *  SHALLOW COPY on {@link PrepareConfigDoorsResult.spec} (only `tools` replaced, each rebuilt entry through the snapshot). */
@@ -130,7 +123,7 @@ export interface PrepareConfigDoorsInput {
     /** borrowed-readonly — presence gates the resumeAt-conflict door and exempts the empty-objective
      *  door (a checkpoint resume passes `objective: ""` by design). */
     resume?: PrepareResume | undefined;
-    /** borrowed-readonly — trusted engine channel: prompt-profile inheritance, the spawning run's
+    /** borrowed-readonly — trusted engine channel: the spawning run's
      *  interaction posture, the engine question-strip flag. */
     internals?: RunInternals | undefined;
 }
@@ -142,8 +135,12 @@ export interface PrepareConfigDoorsResult {
     /** owned — the frozen task-start copies of the caller's tool-face control arrays; the driver compiles the leg's selector
      *  from them, and the selector (with the disclosure lists) is the ONLY thing later face reads consult. Frozen-immutable. */
     toolFaceLists: ToolFaceLists;
-    /** owned — the profile half of the single decision point (model-independent by contract). */
-    promptProfile: "simple" | "classic";
+    /** owned — the task-level switch on the lean shape (`TaskSpec.promptLean`, validated; an engine-built child's spec
+     *  carries its parent's): what the run hands its children and workflow agents, never its effective traits. */
+    promptLean: boolean | undefined;
+    /** owned, frozen-by-contract — the run's effective prompt traits ({@link resolvePromptTraits}): the catalog's
+     *  variants, every overlay's `when.traits` and each tool's description variants select on them. */
+    promptTraits: ReadonlySet<PromptTraitName>;
     /** owned — the host selector values (`TaskSpec.promptRole` / `TaskSpec.promptForm`, validated) the assembly selects on. */
     promptHost: ReturnType<typeof resolveHost>;
     /** owned — the run's binding (`TaskSpec.promptBinding`, validated): the selector value every overlay's `when.binding` reads. */
@@ -170,8 +167,6 @@ export interface PrepareConfigDoorsResult {
     /** owned — the compaction model: explicit wins, else the `summarize` role, else undefined (main
      *  model fallback inside maybeCompact). NOT derivable from {@link resolvedRole}. */
     compModel: Model | undefined;
-    /** owned — the mitigations half of the decision point (model-family fact). */
-    fableMitigations: boolean;
     /** owned, frozen — model-gate DISCLOSURE data (the application itself already
      *  happened on {@link spec}: its `tools` is the survivor rebind when anything was removed).
      *  prepareTask emits the notices from this after the doors return (the onNotice station);
@@ -214,6 +209,7 @@ export interface PrepareConfigDoorsResult {
     /** owned — the screened cross-boundary posture: the deps seat read ONCE, a bad value refused; absent stays `undefined` (undeclared is its own fact). */
     crossBoundaryPosture: CrossBoundaryPosture | undefined;
     advisorTool: "disabled" | undefined;
+    hostFloor: HostFloor | undefined;
 }
 /** The microCompact knob door (坏值响亮度默认律, the sibling knob doors' form:
  *  interactionPosture / toolModelGate / staleToolResultOffload). Placement is load-bearing:
@@ -238,7 +234,7 @@ export declare const checkpointStoreSeat: (spec: {
 export declare function assertResumeConfigRecord(config: unknown): void;
 /** The spec the value doors read: a prepare's (its roster is faces) or a resume's re-supplied config (no objective, no session id). */
 type ValueDoorSpec = Omit<TaskSpec, "tools" | "objective" | "sessionId" | "userAttachments"> & Partial<Pick<TaskSpec, "objective" | "sessionId">>;
-type ConfigValueDoorsResult = Pick<PrepareConfigDoorsResult, "toolFaceLists" | "promptHost" | "promptBinding" | "lockedPreflight" | "microCompactKnob" | "memoryDelegationEvidence" | "memoryProvenance" | "memoryCapturePolicy" | "usageWindows" | "brainCallGuardrailMs" | "crossBoundaryPosture" | "advisorTool"> & {
+type ConfigValueDoorsResult = Pick<PrepareConfigDoorsResult, "toolFaceLists" | "promptHost" | "promptBinding" | "lockedPreflight" | "microCompactKnob" | "memoryDelegationEvidence" | "memoryProvenance" | "memoryCapturePolicy" | "usageWindows" | "brainCallGuardrailMs" | "crossBoundaryPosture" | "advisorTool" | "promptLean" | "hostFloor"> & {
     skillListingSeats: {
         fraction: unknown;
         maxDescChars: unknown;
@@ -259,6 +255,7 @@ export declare function configValueDoors(input: {
     deps: RunnerDeps;
     resumeLeg: boolean;
     sessions: SessionStore;
+    holder?: string | undefined;
 }, enter?: ConfigDoorEntry): ConfigValueDoorsResult;
 /**
  * The doors a RESUMED leg's prepare refuses at, run as one screen BEFORE the claim — prepare's own functions, so a refusal carries
@@ -273,6 +270,6 @@ export declare function configValueDoors(input: {
  * corrected resume redeems the same token. A throw that is none of prepare's codes leaves as it was thrown. Returns the config the
  * leg is handed: the caller's, its MCP servers and A2A peers the frozen entries the lock layer judged (read once, dialed as judged).
  */
-export declare function refuseResumeDoors<C extends ValueDoorSpec & Pick<TaskSpec, "userAttachments">>(config: C, recordedGate: Parameters<typeof recordedModeSeed>[0], deps: RunnerDeps, sessions: SessionStore): C;
+export declare function refuseResumeDoors<C extends ValueDoorSpec & Pick<TaskSpec, "userAttachments">>(config: C, recordedGate: Parameters<typeof recordedModeSeed>[0], deps: RunnerDeps, sessions: SessionStore, holder?: string): C;
 export declare function prepareConfigDoors(input: PrepareConfigDoorsInput): PrepareConfigDoorsResult;
 export {};

package/dist/core/runner/prepare-config-doors.js

@@ -3,8 +3,10 @@ import { assertContainmentFaceValue } from "../../tools/fs/index.js";
 import { MICRO_COMPACT_MACHINES } from "../context-edit.js";
 import { assertAddOnlySeats } from "../child-clamp-seats.js";
 import { CROSS_BOUNDARY_POSTURES } from "../cross-boundary-taint.js";
+import { compileHostFloor } from "../host-floor.js";
 import { assertNoRetiredRunnerDeps } from "./retired-runner-deps.js";
 import { recordedModeSeed, resolveCheckpointStore } from "../checkpoint-store.js";
+import { assertCheckpointStoreJudgesHolder, assertHolderValue } from "../checkpoint-generation.js";
 import { asResumeConfigRefusal, refusePermissionModeDoors } from "../mode-policy.js";
 import { resolveOutputStyleFrame } from "../output-style.js";
 import { screenUserAttachments } from "../user-attachment.js";
@@ -15,21 +17,24 @@ import { assertAutoConsolidationWirable } from "./memory-consolidation-driver.js
 import { isModelPriced, malformedPricingField, modelCostToPricing } from "../pricing.js";
 import { ENTER_AS_IS, preflightLockedConfig } from "../locked-config.js";
 import { assertRetentionCapability } from "../retention.js";
-import { resolveModel, resolveTaskModel, roleModelIfSet } from "../roles.js";
+import { resolveModel, resolveTaskModel, roleModelIfSet, screenRoleMap } from "../roles.js";
 import { resolveSkillListingBudget } from "../skill-listing-budget.js";
 import { describeRejectedValue } from "../tool-search-setting.js";
 import { assertAdvisorModelShape } from "../advisor-verdict.js";
-import { applyToolModelGate, assertRestoreGatedToolsValue, modelIdTail } from "../tool-model-gate.js";
+import { applyToolModelGate, assertRestoreGatedToolsValue } from "../tool-model-gate.js";
 import { resolveUsageWindows } from "../usage-window-store.js";
 import { deriveAskEffective, resolveAskSeat, resolveQuestionSeam, screenApprovalReach } from "../wiring-manifest.js";
-import { resolveHost } from "../../prompt-assembly/select.js";
+import { effectiveTraitsOf, readModelPromptTraits, resolveHost, resolvePromptLean } from "../../prompt-assembly/select.js";
+import { assertNoRetiredKeys, RETIRED_MODEL_KEYS } from "../retired-keys.js";
 import { resolvePromptBinding } from "../../prompt-assembly/overlay.js";
 import { assertPeerPresenceValue } from "../../agents/peer-directory.js";
 import { snapshotDefinitionLists } from "../../agents/tool-filter.js";
-import { TOTAL_TOKENS_REMINDER_MODES } from "./turn-attachments.js";
-import { rosterFaceOf } from "./caller-roster.js";
+import { mcpUnavailableOn, TOTAL_TOKENS_REMINDER_MODES } from "./turn-attachments.js";
+import { refuseRetiredMember, rosterFaceOf } from "./caller-roster.js";
 import { assertToolBoundaryLegs } from "../tool-roster.js";
+import { assertToolCardDeclarations } from "../../prompt-assembly/tool-catalog.js";
 import { refuseRenamedDelegationMounts } from "./sub-agent-deny-lists.js";
+import { readPrincipal } from "../principal-name.js";
 const TASK_LIMIT_KEY_DICT = {
     maxTokens: true,
     maxCostUsd: true,
@@ -49,11 +54,20 @@ const RETIRED_TASK_LIMIT_KEYS = {
     callCapByDeadline: "(retired — no replacement)",
     gracefulFinalize: "(retired — the approach notice is the only end-of-budget prompt)",
 };
+export function resolveCompactionModel(spec, deps, seat) {
+    return spec.compactionModel !== undefined ? resolveModel(spec.compactionModel, deps.models, seat) : roleModelIfSet("summarize", spec, deps);
+}
 export function limitConfigError(code, message) {
     const e = new Error(message);
     e.code = code;
     return e;
 }
+export function assertPrincipalValue(raw) {
+    const reading = readPrincipal(raw);
+    if (reading.kind === "invalid") {
+        throw limitConfigError("config.invalid_argument", `TaskSpec.principal must be a principal name when present (got ${reading.fault}) — omit the key for a task with no principal; a provided value that names nobody is refused, never read as "no principal".`);
+    }
+}
 export function resolveTaskLimits(limits) {
     if (limits === undefined)
         return undefined;
@@ -99,6 +113,7 @@ export function resolveTaskLimits(limits) {
 export function resolveAttachmentsConfig(attachments) {
     if (attachments === null || (typeof attachments !== "object" && typeof attachments !== "function"))
         return attachments;
+    mcpUnavailableOn(attachments);
     const mode = attachments.totalTokensReminderMode;
     if (mode !== undefined) {
         const legal = TOTAL_TOKENS_REMINDER_MODES;
@@ -109,15 +124,9 @@ export function resolveAttachmentsConfig(attachments) {
     }
     return attachments;
 }
-export function isFableFamilyModelId(id) {
-    const tail = modelIdTail(id);
-    return /^claude-fable-\d/.test(tail) || /^claude-mythos-5(?!\d)/.test(tail);
-}
-export function resolveModelPromptTraits(model, spec, internals) {
-    return {
-        promptProfile: spec.promptProfile ?? internals?.promptProfile ?? "simple",
-        fableMitigations: isFableFamilyModelId(model.id),
-    };
+export function resolvePromptTraits(model, promptLean) {
+    assertNoRetiredKeys(model, RETIRED_MODEL_KEYS, "Model");
+    return effectiveTraitsOf(readModelPromptTraits(model), promptLean);
 }
 function microCompactConfigError(field, value, legal) {
     let shown;
@@ -173,8 +182,9 @@ export function assertResumeConfigRecord(config) {
     }
 }
 export function configValueDoors(input, enter = ENTER_AS_IS) {
-    const { spec, deps, resumeLeg, sessions } = input;
+    const { spec, deps, resumeLeg, sessions, holder } = input;
     enter("deps", () => assertNoRetiredRunnerDeps(deps));
+    enter("taskConfig", () => assertPrincipalValue(spec.principal));
     enter("taskConfig", () => assertPeerPresenceValue(spec.peerPresence));
     enter("taskConfig", () => assertRestoreGatedToolsValue(spec.restoreGatedTools));
     const microCompactKnob = enter("deps", () => resolveMicroCompactKnob(deps.microCompact));
@@ -213,7 +223,10 @@ export function configValueDoors(input, enter = ENTER_AS_IS) {
                 : undefined,
     };
     const promptHost = enter("taskConfig", () => resolveHost(spec));
+    enter("deps", () => screenRoleMap(deps.roles, "RunnerDeps.roles"));
+    enter("taskConfig", () => screenRoleMap(spec.roles, "TaskSpec.roles"));
     const promptBinding = enter("taskConfig", () => resolvePromptBinding(spec));
+    const promptLean = enter("taskConfig", () => resolvePromptLean(spec));
     if (spec.resumeAt !== undefined)
         enter("taskConfig", () => {
             if (resumeLeg) {
@@ -236,6 +249,7 @@ export function configValueDoors(input, enter = ENTER_AS_IS) {
     const memoryProvenance = enter("deps", () => closedWord(deps.memoryProvenance, "RunnerDeps.memoryProvenance", ["off", "carry"], "carry", "config.memory_provenance", "an unevaluable provenance mode is refused loudly, never folded to either mode."));
     const memoryCapturePolicy = enter("deps", () => closedWord(deps.memoryCapturePolicy, "RunnerDeps.memoryCapturePolicy", ["open", "governed", "capture-required"], "open", "config.memory_capture_policy", "an unevaluable capture posture is refused loudly, never folded to any posture (the fault arms differ per posture, so a guess would pick a polarity nobody configured)."));
     const crossBoundaryPosture = enter("deps", () => closedWord(deps.crossBoundaryPosture, "RunnerDeps.crossBoundaryPosture", CROSS_BOUNDARY_POSTURES, undefined, "config.cross_boundary_posture", "an unevaluable posture is refused loudly, never folded to either word (an absent seat is undeclared, which is its own fact)."));
+    const hostFloor = enter("deps", () => compileHostFloor(deps.hostFloor));
     const advisorTool = enter("deps", () => closedWord(deps.advisorTool, "RunnerDeps.advisorTool", ["disabled"], undefined, "config.advisor_tool_invalid", "the switch has one word; anything else is refused, never read as either state."));
     if (advisorTool === undefined)
         enter("taskConfig", () => assertAdvisorModelShape(spec.advisorModel));
@@ -310,6 +324,8 @@ export function configValueDoors(input, enter = ENTER_AS_IS) {
     const taskGuardrail = spec.limits?.brainCallGuardrailMs;
     const brainCallGuardrailMs = enter(taskGuardrail != null ? "taskConfig" : "deps", () => resolveBrainCallGuardrailMs(taskGuardrail ?? deps.brainCallGuardrailMs));
     const checkpointStore = enter(checkpointStoreSeat(spec), () => resolveCheckpointStore(spec, deps));
+    enter("deps", () => assertHolderValue(holder));
+    enter(checkpointStoreSeat(spec), () => assertCheckpointStoreJudgesHolder(checkpointStoreSeat(spec) === "taskConfig" ? "TaskSpec.checkpointStore" : "RunnerDeps.checkpointStore", checkpointStore, holder));
     const taskStore = checkpointStoreSeat(spec) === "taskConfig" ? checkpointStore : undefined;
     const retention = { policy: deps.retentionPolicy, locked: lockedPreflight.lockedKeys.has("retentionPolicy") };
     enter("deps", () => assertRetentionCapability({
@@ -322,9 +338,9 @@ export function configValueDoors(input, enter = ENTER_AS_IS) {
     }));
     if (taskStore !== undefined)
         enter("taskConfig", () => assertRetentionCapability({ ...retention, stores: [{ name: "checkpointStore", store: taskStore }] }));
-    return { toolFaceLists, promptHost, promptBinding, lockedPreflight, skillListingSeats, skills, projectMemory, microCompactKnob, memoryDelegationEvidence, memoryProvenance, memoryCapturePolicy, usageWindows, brainCallGuardrailMs, crossBoundaryPosture, advisorTool };
+    return { toolFaceLists, promptHost, promptBinding, promptLean, lockedPreflight, skillListingSeats, skills, projectMemory, microCompactKnob, memoryDelegationEvidence, memoryProvenance, memoryCapturePolicy, usageWindows, brainCallGuardrailMs, crossBoundaryPosture, advisorTool, hostFloor };
 }
-export function refuseResumeDoors(config, recordedGate, deps, sessions) {
+export function refuseResumeDoors(config, recordedGate, deps, sessions, holder) {
     asResumeConfigRefusal("taskConfig", () => {
         refusePermissionModeDoors(config);
         resolveOutputStyleFrame(config.outputStyle);
@@ -332,19 +348,20 @@ export function refuseResumeDoors(config, recordedGate, deps, sessions) {
         screenUserInvokedSkills(config);
         screenUserAttachments(config.userAttachments, { resumeLeg: true });
         assertToolBoundaryLegs(config.tools);
+        assertToolCardDeclarations(config.tools);
     });
-    const { lockedPreflight, skills } = configValueDoors({ spec: config, deps, resumeLeg: true, sessions }, asResumeConfigRefusal);
+    const { lockedPreflight, skills } = configValueDoors({ spec: config, deps, resumeLeg: true, sessions, holder }, asResumeConfigRefusal);
     asResumeConfigRefusal("inheritedGate", () => void recordedModeSeed(recordedGate));
     return { ...config, ...(config.mcp !== undefined ? { mcp: lockedPreflight.mcp ?? [] } : {}), ...(config.a2a !== undefined ? { a2a: lockedPreflight.a2a ?? [] } : {}), skills };
 }
 export function prepareConfigDoors(input) {
     const { deps, sessions, resume, internals } = input;
     assertToolBoundaryLegs(input.spec.tools);
+    assertToolCardDeclarations(input.spec.tools);
     let spec = input.spec;
-    const { toolFaceLists, promptHost, promptBinding, lockedPreflight, skillListingSeats, skills, projectMemory, microCompactKnob, memoryDelegationEvidence, memoryProvenance, memoryCapturePolicy, usageWindows, brainCallGuardrailMs, crossBoundaryPosture, advisorTool } = configValueDoors({ spec, deps, resumeLeg: resume !== undefined, sessions });
+    const { toolFaceLists, promptHost, promptBinding, promptLean, lockedPreflight, skillListingSeats, skills, projectMemory, microCompactKnob, memoryDelegationEvidence, memoryProvenance, memoryCapturePolicy, usageWindows, brainCallGuardrailMs, crossBoundaryPosture, advisorTool, hostFloor } = configValueDoors({ spec, deps, resumeLeg: resume !== undefined, sessions, holder: internals?.holder });
     const doorRead = (value) => ({ value, enumerable: value !== undefined, writable: false, configurable: false });
     spec = Object.create(Object.getPrototypeOf(spec), { ...Object.getOwnPropertyDescriptors(spec), skills: doorRead(skills), projectMemory: doorRead(projectMemory) });
-    const promptProfile = resolveModelPromptTraits({ id: "" }, spec, internals).promptProfile;
     const resolvedInteractionPosture = spec.interactionPosture ?? internals?.parentInteractionPosture ?? deps.interactionPosture;
     const askSeat = resolveAskSeat(spec, deps);
     {
@@ -410,7 +427,10 @@ export function prepareConfigDoors(input) {
                 if (typeof t.withAgents !== "function")
                     return t;
                 const rebuilt = t.withAgents(perTask);
-                return rosterFaceOf(t.modelGate !== undefined && rebuilt.modelGate === undefined ? { ...rebuilt, modelGate: t.modelGate } : rebuilt, index);
+                const restamp = t.modelGate !== undefined && rebuilt.modelGate === undefined;
+                if (restamp)
+                    refuseRetiredMember(rebuilt, index);
+                return rosterFaceOf(restamp ? { ...rebuilt, modelGate: t.modelGate } : rebuilt, index);
             }),
         };
     }
@@ -447,7 +467,7 @@ export function prepareConfigDoors(input) {
             throw limitConfigError("config.limit_invalid", `TaskSpec.${dollarCeiling} is a money ceiling, but the price table for model ${JSON.stringify(model.id)} declares an unevaluable ${bad} — every rate must be a finite, non-negative number of USD per 1M tokens. A table like this prices every turn at zero (or below), so the ceiling would never trip: refused rather than enforced in name only.`);
         }
     }
-    const fableMitigations = resolveModelPromptTraits(model, spec, internals).fableMitigations;
+    const promptTraits = resolvePromptTraits(model, promptLean);
     const gateDecision = applyToolModelGate({
         tools: spec.tools,
         modelId: model.id,
@@ -465,13 +485,12 @@ export function prepareConfigDoors(input) {
         discardedEnvRaw: gateDecision.discardedEnvRaw,
     });
     const thinking = spec.thinking ?? resolvedRole.thinking ?? model.defaultThinking;
-    const compModel = spec.compactionModel !== undefined
-        ? resolveModel(spec.compactionModel, deps.models, "TaskSpec.compactionModel")
-        : roleModelIfSet("summarize", spec, deps);
+    const compModel = resolveCompactionModel(spec, deps, "TaskSpec.compactionModel");
     return {
         spec,
         toolFaceLists,
-        promptProfile,
+        promptLean,
+        promptTraits,
         promptHost,
         promptBinding,
         lockedPreflight,
@@ -482,12 +501,11 @@ export function prepareConfigDoors(input) {
         model,
         thinking,
         compModel,
-        fableMitigations,
         modelGate,
         memoryDelegationEvidence,
         skillListingBudget,
         memoryProvenance,
-        memoryCapturePolicy, crossBoundaryPosture, advisorTool,
+        memoryCapturePolicy, crossBoundaryPosture, advisorTool, hostFloor,
         usageWindows,
         brainCallGuardrailRef,
         brainCallGuardrailMs,

package/dist/core/runner/prepare-defer-classify.d.ts

@@ -1,4 +1,5 @@
 import type { Model } from "../../internal/llm.js";
+import type { PromptTraitName } from "../../prompt-assembly/catalog/schema.js";
 import type { MaterializedA2a } from "../a2a.js";
 import type { MaterializedMcp } from "../mcp.js";
 import type { RunnerDeps, TaskSpec } from "../types.js";
@@ -11,7 +12,7 @@ export interface PrepareDeferClassifyInput {
     deps: Pick<RunnerDeps, "deferMode" | "toolSearch">;
     /** borrowed-mutable — the shared mount array (later refs alias it; in-place contract, never
      *  re-created). Mutated here, in order: `splice` of every excluded name; element REPLACEMENT with a
-     *  shallow copy for the classic-profile description swap (the caller's ToolSpec object is never
+     *  shallow copy for a description variant chosen by the run's traits (the caller's ToolSpec object is never
      *  mutated); `splice` of a retracted memory group. After this phase: the content-origin wrap
      *  (element replacement with the wrapped object), the disclosure mount, the MCP refresh re-splice. Since
      *  Every one of those writes is a builder verb (`unmountWhere` / `replaceAt`). */
@@ -22,8 +23,8 @@ export interface PrepareDeferClassifyInput {
     handsEnabled: boolean;
     /** borrowed-readonly — the spec-time precomputation the invariant checks the post-exclusion roster against: a mismatch is an engine bug, thrown. */
     fullShellReachable: boolean;
-    /** borrowed-readonly — the resolved prompt profile (`classic` swaps in `descriptionClassic`). */
-    promptProfile: "simple" | "classic";
+    /** borrowed-readonly — the run's effective prompt traits (each tool's description variants are chosen on them). */
+    promptTraits: ReadonlySet<PromptTraitName>;
     /** borrowed-readonly — the resolved model (the deferral gate's threshold reads its context window). */
     model: Model;
     /** borrowed-readonly — the materialized MCP roster; only `tools` is read (protocol names; `mcpAlwaysLoad` self-declarations lose to an operator defer). */

package/dist/core/runner/prepare-defer-classify.js

@@ -1,4 +1,4 @@
-import { getToolContract } from "../../prompt-assembly/tool-catalog.js";
+import { getToolContract, mountDescriptionVariant } from "../../prompt-assembly/tool-catalog.js";
 import { FULL_SHELL_CONTRACT_ID } from "../../tools/fs/index.js";
 import { ASK_USER_QUESTION_TOOL_NAME } from "../ask-question.js";
 import { MEMORY_ENGINE_TOOL_NAMES } from "../memory-engine/tools.js";
@@ -17,7 +17,7 @@ function memoryGroupRetractionSet(builtinDeferPairNames, engineTrioInPlay) {
     return new Set([...builtinDeferPairNames, ...(engineTrioInPlay ? MEMORY_ENGINE_TOOL_NAMES : [])]);
 }
 export function prepareDeferClassify(input) {
-    const { spec, deps, roster, toolFaceSnapshot, handsEnabled, fullShellReachable, promptProfile, model, mcp, a2a, sharedMemoryPairMounted, memoryEnginePairMounted, memoryRecallSegment, onceLedger, sessionId } = input;
+    const { spec, deps, roster, toolFaceSnapshot, handsEnabled, fullShellReachable, promptTraits, model, mcp, a2a, sharedMemoryPairMounted, memoryEnginePairMounted, memoryRecallSegment, onceLedger, sessionId } = input;
     const tools = roster.tools;
     let memoryBlock = input.memoryBlock;
     const leaves = valveLeaves(spec, toolFaceSnapshot.selector);
@@ -32,12 +32,11 @@ export function prepareDeferClassify(input) {
             throw e;
         }
     }
-    if (promptProfile === "classic") {
-        for (let i = 0; i < tools.length; i++) {
-            const t = tools[i];
-            if (t.descriptionClassic !== undefined)
-                roster.replaceAt(i, { ...t, description: t.descriptionClassic });
-        }
+    for (let i = 0; i < tools.length; i++) {
+        const t = tools[i];
+        const face = mountDescriptionVariant(t, promptTraits);
+        if (face !== t)
+            roster.replaceAt(i, face);
     }
     const protocolToolNames = [...mcp.tools, ...a2a.tools].filter((t) => protocolOf(t.name) !== undefined).map((t) => t.name);
     const mcpAlwaysLoadNames = mcp.tools