@sema-agent/core 7.54.1 → 7.56.0

package/dist/core/runner/prepare-advisor.js

@@ -0,0 +1,77 @@
+import { valveLeaves } from "../../agents/tool-filter.js";
+import { ADVISOR_TOOL_NAME, advisorAttachVerdict, advisorHoldOf, advisorNotAttachedNotice, advisorReasonTold } from "../advisor-verdict.js";
+import { deliverEngineNotice } from "../types.js";
+import { advisorInstructionFrame } from "./advisor-instructions.js";
+import { createAdvisorTool } from "./advisor-tool.js";
+import { announceDigest } from "./announce-once-ledger.js";
+import { conversationSegmentOf } from "./conversation-segment.js";
+import { derivedRouteFallsBack } from "./derived-route-fallback.js";
+import { derivedLegBrain } from "./side-call-account.js";
+import { withBrainCallGuardrail } from "../../brain/timeout.js";
+export async function prepareAdvisor(input) {
+    const { spec, deps, model, onceLedger, sessionId, runId } = input;
+    const told = onceLedger.arms().advisor;
+    if (spec.advisorModel === undefined && told === undefined)
+        return { manifest: undefined, instruction: undefined };
+    const requested = spec.advisorModel === undefined || input.advisorTool === "disabled" ? undefined : typeof spec.advisorModel === "string" ? spec.advisorModel : spec.advisorModel.id;
+    const fact = (f) => ({ ...(requested !== undefined ? { requested } : {}), main: model.id, ...f });
+    const notAttached = (reason, extra = {}) => {
+        if (input.rootLeg && requested !== undefined && advisorReasonTold(reason)) {
+            onceLedger.oncePerSession(announceDigest("advisor.not_attached", `${reason}\n${requested}\n${model.id}`), () => deliverEngineNotice(deps.onNotice, advisorNotAttachedNotice({ reason, advisorModel: requested, mainModel: model.id, sessionId, ...(runId !== undefined ? { runId } : {}) })));
+        }
+        return fact({ state: "not_attached", reason, ...extra });
+    };
+    let branch;
+    const readBranch = async () => (branch ??= await input.session.getBranch().catch(() => undefined));
+    let mounted = false;
+    const mount = async (advisor) => {
+        if ((spec.tools ?? []).some((t) => t.name === ADVISOR_TOOL_NAME)) {
+            const e = new Error(`Tool name "${ADVISOR_TOOL_NAME}" is reserved when TaskSpec.advisorModel attaches the advisor tool.`);
+            e.code = "config.reserved_tool_name";
+            throw e;
+        }
+        if (!valveLeaves(spec, input.selector)({ name: ADVISOR_TOOL_NAME }))
+            return fact({ state: "not_attached", reason: "excluded" });
+        const entries = await readBranch();
+        if (entries === undefined)
+            return notAttached("hold_unknown");
+        const held = advisorHoldOf(entries);
+        if (held !== undefined)
+            return fact({ state: "held", model: advisor.id, hold: held });
+        const route = await derivedRouteFallsBack({ seat: "advisor", derived: advisor, primary: model, brain: deps.brain, getApiKeyAndHeaders: spec.getApiKeyAndHeaders, onNotice: deps.onNotice, sessionId, ...(runId !== undefined ? { runId } : {}), onBrokenPairing: "detach" });
+        if (route.action === "detach")
+            return notAttached("route_refused", { routeCode: route.cause });
+        input.roster.mount(createAdvisorTool(advisorSeat(input, advisor)), { source: "builtin", mountedBy: "optional" });
+        mounted = true;
+        return fact({ state: "on", model: advisor.id });
+    };
+    let manifest;
+    if (spec.advisorModel !== undefined) {
+        const verdict = advisorAttachVerdict({ deps: { ...deps, ...(input.advisorTool !== undefined ? { advisorTool: input.advisorTool } : {}) }, main: model, advisor: spec.advisorModel });
+        manifest = verdict.state === "on" ? await mount(verdict.model) : notAttached(verdict.reason);
+    }
+    const entries = told !== undefined || mounted ? await readBranch() : undefined;
+    if (entries === undefined)
+        return { manifest, instruction: undefined };
+    const segment = conversationSegmentOf(entries);
+    const owed = advisorInstructionFrame(told !== undefined && told.segment === segment ? told.state : undefined, mounted);
+    return { manifest, instruction: { ...(owed !== undefined ? { owed } : {}), segment, mounted } };
+}
+function advisorSeat(input, model) {
+    const book = (lane, m, reply) => {
+        const door = input.sideCallBookRef.book;
+        if (door === undefined)
+            throw new Error("the advisor was consulted before the run body bound the leg's usage account, which it does before any tool call");
+        door(lane, m, reply);
+    };
+    const ms = input.brainCallGuardrailMs;
+    const guarded = (b) => (ms === undefined ? b : { ...b, stream: withBrainCallGuardrail((m, c, o) => b.stream(m, c, o), ms, {}) });
+    return {
+        model,
+        brain: derivedLegBrain(() => guarded(input.deps.brain), "advisor", book),
+        lastSentRequest: input.lastSentRequest,
+        readBranch: () => input.session.getBranch(),
+        getApiKeyAndHeaders: input.spec.getApiKeyAndHeaders,
+        markUsageUnknown: () => book("advisor", model, undefined),
+    };
+}

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" });
@@ -223,7 +223,7 @@ export async function prepareCapsAndWorkflow(input) {
         const am = autoModeFace;
         const classifierSeat = classifierSeatModel({ deps, main: model });
         let classifierModel = classifierSeat.model;
-        if (await derivedRouteFallsBack({ seat: "auto-mode-classifier", derived: classifierModel, primary: model, brain: deps.brain, getApiKeyAndHeaders: spec.getApiKeyAndHeaders, onNotice: deps.onNotice, sessionId, runId, onBrokenPairing: autoModeClassifierFallbackOf(am.classifierFallback) === "none" ? "refuse" : "fall_back" })) {
+        if ((await derivedRouteFallsBack({ seat: "auto-mode-classifier", derived: classifierModel, primary: model, brain: deps.brain, getApiKeyAndHeaders: spec.getApiKeyAndHeaders, onNotice: deps.onNotice, sessionId, runId, onBrokenPairing: autoModeClassifierFallbackOf(am.classifierFallback) === "none" ? "refuse" : "fall_back" })).action === "fall_back") {
             classifierModel = model;
         }
         announceClassifierRoleDefaulted({ onNotice: deps.onNotice, seat: { ...classifierSeat, model: classifierModel }, ...(sessionId !== undefined ? { sessionId } : {}), ...(runId !== undefined ? { runId } : {}) });
@@ -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,18 @@ 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";
 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 +61,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 +96,13 @@ export declare function resolveTaskLimits(limits: TaskLimits | undefined): TaskL
  */
 export declare function resolveAttachmentsConfig(attachments: TaskSpec["attachments"]): TaskSpec["attachments"];
 /**
- * R2 双形轴(追加令 2026-07-18): CC 2.1.212's fable-variant prompt gate (b9e —
- * `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.
- */
-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. CC 2.1.220's counterpart is a model-registry `capabilities` array (one table drives
- * `lean_prompt` + `fable_5_mitigations` alike; anchors/2.1.220/CC-218-220-DIFF.md §2).
- *
- * 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).
+ * 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 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 +117,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 +129,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 +161,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);
@@ -213,6 +202,8 @@ export interface PrepareConfigDoorsResult {
     brainCallGuardrailMs: number | undefined;
     /** 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:
@@ -237,12 +228,13 @@ 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"> & {
+type ConfigValueDoorsResult = Pick<PrepareConfigDoorsResult, "toolFaceLists" | "promptHost" | "promptBinding" | "lockedPreflight" | "microCompactKnob" | "memoryDelegationEvidence" | "memoryProvenance" | "memoryCapturePolicy" | "usageWindows" | "brainCallGuardrailMs" | "crossBoundaryPosture" | "advisorTool" | "promptLean" | "hostFloor"> & {
     skillListingSeats: {
         fraction: unknown;
         maxDescChars: unknown;
     };
     skills: TaskSpec["skills"];
+    projectMemory: TaskSpec["projectMemory"];
 };
 /**
  * The phase's VALUE doors as ONE function with two callers — each judges a declared value against its own vocabulary, reading only the
@@ -257,6 +249,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
@@ -271,6 +264,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,20 +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 { applyToolModelGate, assertRestoreGatedToolsValue, modelIdTail } from "../tool-model-gate.js";
+import { assertAdvisorModelShape } from "../advisor-verdict.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,
@@ -53,6 +59,12 @@ export function limitConfigError(code, 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;
@@ -98,6 +110,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;
@@ -108,15 +121,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;
@@ -155,7 +162,7 @@ function resolveClearOnRejection(bag) {
     }
     return declared ?? true;
 }
-function deploymentWord(raw, seat, words, absent, code, why) {
+function closedWord(raw, seat, words, absent, code, why) {
     if (raw === undefined)
         return absent;
     const word = words.find((w) => w === raw);
@@ -163,7 +170,7 @@ function deploymentWord(raw, seat, words, absent, code, why) {
         return word;
     const got = typeof raw === "string" ? JSON.stringify(raw.length > 64 ? `${raw.slice(0, 64)}…` : raw) : raw === null ? "null" : Array.isArray(raw) ? "an array" : typeof raw;
     const spelled = words.map((w) => `"${w}"`);
-    throw limitConfigError(code, `RunnerDeps.${seat} must be ${spelled.slice(0, -1).join(", ")} or ${spelled.at(-1)} when present (got ${got}) — ${why}`);
+    throw limitConfigError(code, `${seat} must be ${spelled.length > 1 ? `${spelled.slice(0, -1).join(", ")} or ` : ""}${spelled.at(-1)} when present (got ${got}) — ${why}`);
 }
 export const checkpointStoreSeat = (spec) => (spec.checkpointStore !== undefined ? "taskConfig" : "deps");
 export function assertResumeConfigRecord(config) {
@@ -172,8 +179,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));
@@ -212,7 +220,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) {
@@ -231,10 +242,15 @@ export function configValueDoors(input, enter = ENTER_AS_IS) {
     enter("taskConfig", () => assertContainmentFaceValue(spec.writeFace, "write", "spec"));
     enter("deps", () => assertContainmentFaceValue(deps.writeFace, "write", "deps"));
     enter("taskConfig", () => assertAddOnlySeats(spec));
-    const memoryDelegationEvidence = enter("deps", () => deploymentWord(deps.memoryDelegationEvidence, "memoryDelegationEvidence", ["static-face", "attested-only"], "static-face", "config.memory_delegation_evidence", "an unevaluable evidence standard is refused loudly, never folded to either standard."));
-    const memoryProvenance = enter("deps", () => deploymentWord(deps.memoryProvenance, "memoryProvenance", ["off", "carry"], "carry", "config.memory_provenance", "an unevaluable provenance mode is refused loudly, never folded to either mode."));
-    const memoryCapturePolicy = enter("deps", () => deploymentWord(deps.memoryCapturePolicy, "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", () => deploymentWord(deps.crossBoundaryPosture, "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 memoryDelegationEvidence = enter("deps", () => closedWord(deps.memoryDelegationEvidence, "RunnerDeps.memoryDelegationEvidence", ["static-face", "attested-only"], "static-face", "config.memory_delegation_evidence", "an unevaluable evidence standard is refused loudly, never folded to either standard."));
+    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));
+    const projectMemory = enter("taskConfig", () => closedWord(spec.projectMemory, "TaskSpec.projectMemory", ["disabled"], undefined, "config.invalid_argument", "the switch has one word; omit the key to leave the deployment's project context in force."));
     enter("deps", () => assertAutoConsolidationWirable(deps));
     if (spec.resumeAtMode !== undefined)
         enter("taskConfig", () => {
@@ -305,6 +321,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({
@@ -317,9 +335,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, microCompactKnob, memoryDelegationEvidence, memoryProvenance, memoryCapturePolicy, usageWindows, brainCallGuardrailMs, crossBoundaryPosture };
+    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);
@@ -327,18 +345,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, microCompactKnob, memoryDelegationEvidence, memoryProvenance, memoryCapturePolicy, usageWindows, brainCallGuardrailMs, crossBoundaryPosture } = configValueDoors({ spec, deps, resumeLeg: resume !== undefined, sessions });
-    spec = Object.create(Object.getPrototypeOf(spec), { ...Object.getOwnPropertyDescriptors(spec), skills: { value: skills, enumerable: skills !== undefined, writable: false, configurable: false } });
-    const promptProfile = resolveModelPromptTraits({ id: "" }, spec, internals).promptProfile;
+    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 resolvedInteractionPosture = spec.interactionPosture ?? internals?.parentInteractionPosture ?? deps.interactionPosture;
     const askSeat = resolveAskSeat(spec, deps);
     {
@@ -404,7 +424,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);
             }),
         };
     }
@@ -441,7 +464,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,
@@ -459,13 +482,14 @@ export function prepareConfigDoors(input) {
         discardedEnvRaw: gateDecision.discardedEnvRaw,
     });
     const thinking = spec.thinking ?? resolvedRole.thinking ?? model.defaultThinking;
-    const compModel = spec.compactionModel
-        ? resolveModel(spec.compactionModel, deps.models)
+    const compModel = spec.compactionModel !== undefined
+        ? resolveModel(spec.compactionModel, deps.models, "TaskSpec.compactionModel")
         : roleModelIfSet("summarize", spec, deps);
     return {
         spec,
         toolFaceLists,
-        promptProfile,
+        promptLean,
+        promptTraits,
         promptHost,
         promptBinding,
         lockedPreflight,
@@ -476,12 +500,11 @@ export function prepareConfigDoors(input) {
         model,
         thinking,
         compModel,
-        fableMitigations,
         modelGate,
         memoryDelegationEvidence,
         skillListingBudget,
         memoryProvenance,
-        memoryCapturePolicy, crossBoundaryPosture,
+        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). */