@sema-agent/core 7.54.1 → 7.56.0

package/dist/agents/subagent.js

@@ -2,14 +2,17 @@ import { Type } from "typebox";
 import { isAbsolute } from "node:path";
 import { backgroundChildTerminal } from "../core/delegation-frames.js";
 import { bindDelegationName } from "../core/delegation-name.js";
+import { principalNameOf } from "../core/principal-name.js";
 import { resumeRefusalDetailOf, resumeStartupCauseOf } from "../core/resume-startup-cause.js";
 import { errorCodeOf, thrownFailureOf } from "../core/runner/terminal-account.js";
 import { applyParentSpecSeat, parentSpecSeatOfCtx } from "../core/parent-spec-seat.js";
+import { ADVISOR_FORK_SENTENCE, ADVISOR_TOOL_NAME } from "../core/advisor-verdict.js";
 import { applyClampSeats, assertClampRecord, childClampSeats, clampSeatsOf, clampSourceOf, engineHeadlessLegSeats, foldClampSources, postureUnderClamps } from "../core/child-clamp-seats.js";
 import { assertNoRetiredKeys } from "../core/retired-keys.js";
 import { stripSpawnTurnQuestionFace } from "../core/ask-question.js";
 import { withDelegationProvenance } from "../core/tool-policy.js";
 import { errorResult } from "../core/tools.js";
+import { notStartedResult } from "../core/delegation-not-started.js";
 import { isHighSurrogate, isLowSurrogate } from "../core/surrogate-safe-slice.js";
 import { newDelegationProvenanceAggregate, reduceDelegationAttestation } from "../core/memory-engine/delegation-provenance.js";
 import { registerDelegationLaunch, replayExternalSettlementEffects, settleDelegation } from "../core/memory-engine/delegation-settlement.js";
@@ -17,15 +20,17 @@ import { enqueueMemoryAnnouncement } from "../core/memory-engine/layout.js";
 import { resolveModel, resolveModelDisplayLabel } from "../core/roles.js";
 import { childModelSeat, childThinkingSeat, deploymentStatesSubagentModel, deploymentSubagentThinking, forkModelSeat, inheritedParentModel, runnerRoleMap } from "./child-model-seat.js";
 export { childThinkingSeat, deploymentSubagentThinking, deploymentSubagentTierModel } from "./child-model-seat.js";
-import { OUTPUT_TOOL_NAME, REPORT_BLOCKED_TOOL_NAME } from "../core/runner/synthetic-tools.js";
+import { REPORT_BLOCKED_TOOL_NAME } from "../core/runner/synthetic-tools.js";
 import { TOOL_SEARCH_NAME } from "../core/runner/tool-disclosure.js";
 import { OFFLOAD_TOOL_NAME } from "../core/tool-result-store.js";
-import { compileToolSelector, delegationListWhere, snapshotDefinitionLists, toolListsDigest, toolNameAllowed, toolNameListFlaw } from "./tool-filter.js";
+import { compileToolSelector, delegationListWhere, namesEveryTool, snapshotDefinitionLists, toolListsDigest, toolNameAllowed, toolNameListFlaw } from "./tool-filter.js";
 import { readToolNameList, snapshotToolNameList } from "../core/tool-name-list.js";
 import { EXTRA_TOOL_NAMES_CODE, delegationPoolFace, extraToolNamesError, firstUndeclaredExtraTool, readExtraToolNames } from "./extra-tool-names.js";
 import { builtinAgentDefinitions } from "./builtin-agents.js";
 import { normalizePeerName, reservedPeerNameReason } from "./cross-session-ref.js";
 import { SUBAGENT_PROMPT } from "../prompts/default.js";
+import { roleBaseOf } from "../prompt-assembly/role-base.js";
+import { readPromptRole } from "../prompt-assembly/select.js";
 import { hasSessionFork } from "../core/session.js";
 import { isDurablePause, pauseFamily } from "./suspend-guard.js";
 import { childRejection, childTerminalFace, childThrownText } from "./child-failure.js";
@@ -73,7 +78,8 @@ import { recordRosterSpawn } from "./roster-store.js";
 import { LAUNCH_RECEIPT_OWN_WORDS_CLAUSE, launchReceiptNoQuoteClause } from "./launch-receipt-contract.js";
 import { ObserverDigestTap, ObserverPairing, createObserverReportToolSpec, markObserverTaskId, unmarkObserverTaskId, isObserverTaskId, ObserverResumeStateError, ObserverStoppedByUserError, observerFramingPrompt, observerSlug, resolveObserverDeclaration, } from "./observer.js";
 import { SubagentStepRecorder } from "./subagent-steps.js";
-import { toolFace } from "../core/tool-catalog-entries.js";
+import { OUTPUT_TOOL_NAME, mountRuleFace, toolFace } from "../core/tool-catalog-entries.js";
+import { canonicalNameValue } from "../core/permission-rule-model.js";
 import { inheritedChildPool, inheritedMcpDeclarations } from "./inherited-tool-pool.js";
 import { readMember, thrownText } from "../core/thrown-value.js";
 const BG_AGENT_RESULT_MAX = 4_000;
@@ -278,19 +284,6 @@ const WORKTREE_UNAVAILABLE = {
     seatSilent: worktreeUnavailableSentence("the runner this tool runs children on does not declare whether it can place a child in a tree other than the caller's (its seat has no canRerootChild), and an undeclared answer is read as no; use a Runner, or add that method to the seat"),
 };
 const placementRefused = (terminal) => terminal?.kind === "failed" && terminal.code === "isolation.unavailable";
-const NOT_STARTED_RESULTS = new WeakSet();
-function notStartedResult(result) {
-    const details = result.details;
-    if (typeof details === "object" && details !== null)
-        NOT_STARTED_RESULTS.add(details);
-    return result;
-}
-export function isNotStartedDelegationResult(result) {
-    if (typeof result !== "object" || result === null)
-        return false;
-    const details = result.details;
-    return typeof details === "object" && details !== null && NOT_STARTED_RESULTS.has(details);
-}
 const isolationUnavailable = (content) => notStartedResult({
     isError: true,
     content,
@@ -350,6 +343,14 @@ const ccElapsedTag = (ms) => {
     return sec >= 60 ? ` \u00b7 ${Math.floor(sec / 60)}m${sec % 60}s` : ` \u00b7 ${sec}s`;
 };
 const ccCompletionText = (desc, settled, rawStatus, elapsedMs) => `Agent "${desc}" ${settled === "killed" ? "stopped" : settled === "completed" ? "finished" : rawStatus}${ccElapsedTag(elapsedMs)}`;
+const SYNC_ESCAPE_SENTENCE = "Pass `run_in_background: false` for a synchronous run when you need the result before continuing (a named agent always runs in the background).";
+function continuationSentence(toolName, durableRevival, forkOffered) {
+    return (`Where the SendMessage tool is mounted, use it with the agent's ID or name to message a RUNNING agent, or — when session retention${durableRevival ? " or durable named-agent revival" : ""} is enabled — ` +
+        `to continue a COMPLETED one with its context intact; a new ${toolName} call starts fresh${forkOffered ? ` (except subagent_type: "${FORK_SUBAGENT_TYPE}", which inherits your context)` : ""}.`);
+}
+function launchContinuationSentence(taskId) {
+    return `Where the SendMessage tool is mounted, use it with to: '${taskId}', summary: '<5-10 word recap>' to continue this agent.`;
+}
 function resumabilityClaim(f) {
     if (f.status === "killed" && f.stoppedBy === "user")
         return false;
@@ -1182,18 +1183,36 @@ function chargeDelegationEntryHandle(registry, key, store, handle) {
     armDelegationLedgerLifecycle(registry);
     sweepDelegationLedgerRound(registry, 3);
 }
-export function normalizeSubagentType(value) {
-    return value.normalize("NFKC").toLowerCase().replace(/[\p{White_Space}\p{Pd}_]+/gu, "");
-}
-function foldGeneralPurposeAlias(args, shadowed) {
-    if (shadowed)
+export { normalizeSubagentType } from "../core/permission-rule-model.js";
+function canonicalSubagentTypeArgs(args, accepted, generalPurposeShadowed) {
+    if (args === null || typeof args !== "object" || Array.isArray(args))
         return args;
     const raw = args;
-    if (raw !== null && typeof raw === "object" && raw.subagent_type === GENERAL_PURPOSE_SUBAGENT_TYPE) {
-        const { subagent_type: _dropped, ...rest } = raw;
-        return rest;
+    const requested = raw["subagent_type"];
+    if (requested === undefined || requested === "") {
+        if (!generalPurposeShadowed)
+            return { ...raw, subagent_type: GENERAL_PURPOSE_SUBAGENT_TYPE };
+        if (requested === undefined)
+            return args;
+        const { subagent_type: _empty, ...omitted } = raw;
+        return omitted;
     }
-    return args;
+    if (typeof requested !== "string")
+        return args;
+    const resolved = canonicalNameValue(requested, accepted);
+    return resolved.kind === "entry" && resolved.entry !== requested ? { ...raw, subagent_type: resolved.entry } : args;
+}
+function subagentTypeRefusal(requested, accepted) {
+    if (requested === undefined || requested === "")
+        return undefined;
+    if (typeof requested !== "string")
+        return { content: `Sub-agent not started: subagent_type must be a string. Available subagent_type values: ${accepted.join(", ")}.`, error: "unknown subagent_type" };
+    const resolved = canonicalNameValue(requested, accepted);
+    if (resolved.kind === "ambiguous")
+        return { content: `Sub-agent not started: subagent_type "${requested}" is ambiguous — it matches ${resolved.entries.join(", ")}. Use the exact name.`, error: "ambiguous subagent_type" };
+    if (resolved.kind === "unknown")
+        return { content: `Sub-agent not started: unknown subagent_type "${requested}". Available subagent_type values: ${accepted.join(", ")}.`, error: "unknown subagent_type" };
+    return undefined;
 }
 export const SUBAGENT_SYSTEM_NOTE = "You can delegate a self-contained subtask to an isolated sub-agent via the delegation tool. " +
     "The sub-agent runs in a clean context and returns a single report. Delegate slow, parallelizable, " +
@@ -1228,7 +1247,7 @@ export function asyncLaunchedReceipt(p) {
     const noteLines = (p.notes ?? []).filter((n) => n !== undefined && n !== "");
     const oneShotBlocked = p.notify && p.oneShot === true;
     return (`Async agent launched successfully. (${launchReceiptNoQuoteClause(", including the task_id below,")})\n` +
-        `task_id: ${p.taskId} (internal ID - do not mention to user. Use SendMessage with to: '${p.taskId}', summary: '<5-10 word recap>' to continue this agent.)\n` +
+        `task_id: ${p.taskId} (internal ID - do not mention to user. ${launchContinuationSentence(p.taskId)})\n` +
         (oneShotBlocked
             ? `${p.workingLine} This is a ONE-SHOT submission — there is no later turn for a background notification to land in, so do NOT end your turn expecting one. Actively wait instead: TaskOutput(task_id: "${p.taskId}", block: true). If it is still running after the wait, wait again (bounded) rather than ending the turn, or write out your best available answer now if you are near your own time budget.\n`
             : p.notify
@@ -1250,6 +1269,7 @@ function runnerModelCatalog(runner) {
     }
 }
 export function createSubagentTool(opts) {
+    readPromptRole("SubagentToolOptions.promptRole", opts.promptRole);
     const catalog = opts.runner.agentCatalog;
     if (opts.agents === undefined && catalog?.agents)
         opts = { ...opts, agents: catalog.agents };
@@ -1306,7 +1326,7 @@ export function createSubagentTool(opts) {
 export function agentToolsNote(def) {
     const allowRead = readToolNameList(def.allowTools);
     const allow = allowRead.kind === "entries" ? allowRead.entries.filter((entry) => typeof entry === "string") : [];
-    const hasAllow = allow.length > 0 && !allow.includes("*");
+    const hasAllow = allow.length > 0 && !allow.some(namesEveryTool);
     const denyRead = readToolNameList(def.denyTools);
     const deny = denyRead.kind === "entries" ? denyRead.entries.filter((entry) => typeof entry === "string") : [];
     const hasDeny = deny.length > 0;
@@ -1379,6 +1399,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
     return bindDelegationName(delegationToolName, {
         name: opts.name ?? DEFAULT_SUBAGENT_TOOL_NAME,
         ...toolFace("agent"),
+        ruleFace: { ...mountRuleFace("agent"), nameValues: acceptedSubagentTypes() },
         agentListing,
         agentToolFaces,
         ...(depth === 0 && opts.allowTools !== undefined ? { agentToolLevelAllowTools: opts.allowTools } : {}),
@@ -1406,41 +1427,41 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                 : `- Each agent type's model, thinking level, and tools come from its agent definition.\n`) +
             `- \`isolation: "worktree"\` gives the agent its own git worktree (auto-cleaned if unchanged).` +
             (opts.background
-                ? `\n- Subagents run in the background by default${opts.background.notify ? "; you'll be notified when one completes" : "; the receipt's task_id retrieves progress and results via the TaskOutput tool where mounted"}. Pass \`run_in_background: false\` for a synchronous run when you need the result before continuing. Never fabricate or predict a pending agent's results — ${opts.background.notify ? "the notification is never something you write yourself; " : ""}if the user asks before it arrives, say it's still running.\n` +
-                    `- Where the SendMessage tool is mounted, use it with the agent's ID or name to message a RUNNING agent, or — when session retention${opts.background.agentStore !== undefined ? " or durable named-agent revival" : ""} is enabled — to continue a COMPLETED one with its context intact; a new ${opts.name ?? DEFAULT_SUBAGENT_TOOL_NAME} call starts fresh${forkOffered ? ` (except subagent_type: "${FORK_SUBAGENT_TYPE}", which inherits your context)` : ""}.`
+                ? `\n- Subagents run in the background by default${opts.background.notify ? "; you'll be notified when one completes" : "; the receipt's task_id retrieves progress and results via the TaskOutput tool where mounted"}. ${SYNC_ESCAPE_SENTENCE} Never fabricate or predict a pending agent's results — ${opts.background.notify ? "the notification is never something you write yourself; " : ""}if the user asks before it arrives, say it's still running.\n` +
+                    `- ${continuationSentence(opts.name ?? DEFAULT_SUBAGENT_TOOL_NAME, opts.background.agentStore !== undefined, forkOffered)}`
                 : `\n- \`run_in_background\` is unavailable here — only synchronous subagents.`),
-        descriptionClassic: `Launch a new agent. Delegate a self-contained subtask to an isolated sub-agent and get back a single report. ` +
-            (opts.purpose ? `This sub-agent is for: ${opts.purpose}. ` : "") +
-            (hasAgents ? `Available agent types are listed in <system-reminder> messages in the conversation. If \`subagent_type\` is omitted, a general-purpose sub-agent is used.\n` : "") +
-            `The sub-agent starts with a clean context (it does NOT see this conversation), so put everything it needs in 'prompt'. ` +
-            `It returns status (completed/blocked/failed) and a result you must verify before deciding the overall task is done.\n\n` +
-            `When NOT to delegate (do it yourself — it's faster and you keep the understanding):\n` +
-            `- Reading a specific known file → use Read directly.\n` +
-            `- Finding a known symbol/class/definition, or searching within 2-3 known files → use Grep/Glob/Read.\n` +
-            `- A lookup where you already know what you want and roughly where it is → just do it. Delegate open-ended INVESTIGATIONS (you don't know where the answer is), not lookups.\n\n` +
-            `Writing the 'prompt' — brief the agent like a smart colleague who just walked into the room — it hasn't seen this conversation, doesn't know what you've tried, doesn't understand why this task matters:\n` +
-            `- Make it fully self-contained and highly detailed: the sub-agent does the whole task end-to-end in one shot — you can't course-correct mid-run.\n` +
-            `- State exactly what it must RETURN (e.g. "report the file:line of each call site", not "look into the call sites").\n` +
-            `- Say explicitly whether you want it to WRITE CODE or only RESEARCH/REPORT — otherwise it may guess wrong.\n` +
-            `- Never delegate understanding. Don't write "based on your findings, fix the bug" or "based on the research, implement it." Those phrases push synthesis onto the agent instead of doing it yourself. Write prompts that prove you understood: include file paths, line numbers, what specifically to change.\n\n` +
-            `Use it for self-contained, parallelizable subtasks (e.g. independent searches/investigations) — it protects your main context; don't overuse it for trivial steps you can do directly. ` +
-            `Once you delegate a piece of research, rely on the sub-agent's report rather than repeating that search yourself. ` +
-            `The agent's final message is returned to you as the tool result; it is not shown to the user — relay what matters.\n\n` +
-            `If the agent reports an action was refused because an approval could not be resolved, do not send the approval back as a message — messages never clear a permission gate. Surface the agent's report of the prepared action and its refusal text to your user. (An agent PARKED at an approval gate is not refused — it is waiting, and resumes when the pending approval is decided.)\n\n` +
-            `Orchestration: When you launch multiple agents for independent work, send them in a single message with multiple tool uses so they run concurrently. Keep anything that needs shared context single-threaded. Once you've delegated a piece of work, don't also do it yourself — wait for the report.` +
-            (forkOffered
-                ? `\n\nsubagent_type "${FORK_SUBAGENT_TYPE}" is built in: it spawns a child that INHERITS your full current context (this entire conversation — no re-explaining, shared prompt cache) and works on 'prompt' as its directive. The fork always runs on YOUR model (the 'model' parameter is ignored for forks) and is not available inside a forked agent.`
-                : `\n\nNote: this deployment defines its own "${FORK_SUBAGENT_TYPE}" agent type, which OVERRIDES the built-in context-inheriting fork routing — subagent_type "${FORK_SUBAGENT_TYPE}" delegates to that definition instead.`) +
-            `\n\nThe 'model' parameter optionally overrides the sub-agent's model. If omitted, the agent definition's model (or the inherited default) applies.` +
-            `\nSet isolation: "worktree" to give the agent its own detached git worktree (auto-removed if it made no changes; kept for you to inspect/merge when it did).` +
-            (opts.background
-                ?
-                    (opts.background.notify
-                        ? `\n\nAgents run in the background by default. When an agent runs in the background, you will be automatically notified when it completes — do NOT sleep, poll, or proactively check on its progress. Continue with other work or respond to the user instead. Pass \`run_in_background: false\` for a synchronous run when you need the result before continuing.`
-                        : `\n\nAgents run in the background by default. A background agent's result is not pushed automatically — the launch receipt's task_id retrieves progress and results via the TaskOutput tool where mounted. Pass \`run_in_background: false\` for a synchronous run when you need the result before continuing.`) +
-                        ` Use SendMessage with a completed agent's ID to continue it with its context intact; a new ${opts.name ?? DEFAULT_SUBAGENT_TOOL_NAME} call starts fresh.` +
-                        `\n\n**Don't race.** After launching, you know nothing about what the agent found. Never fabricate or predict agent results in any format — not as prose, summary, or structured output. ${opts.background.notify ? "The notification arrives as a user-role message in a later turn; it is never something you write yourself." : "The result exists only when you retrieve it; it is never something you write yourself."}`
-                : `\n\nThe run_in_background parameter is not available in this context. Only synchronous subagents are supported.`),
+        descriptionVariants: [{ id: "classic", traits: { noneOf: ["lean_prompt"] }, text: `Launch a new agent. Delegate a self-contained subtask to an isolated sub-agent and get back a single report. ` +
+                    (opts.purpose ? `This sub-agent is for: ${opts.purpose}. ` : "") +
+                    (hasAgents ? `Available agent types are listed in <system-reminder> messages in the conversation. If \`subagent_type\` is omitted, a general-purpose sub-agent is used.\n` : "") +
+                    `The sub-agent starts with a clean context (it does NOT see this conversation), so put everything it needs in 'prompt'. ` +
+                    `It returns status (completed/blocked/failed) and a result you must verify before deciding the overall task is done.\n\n` +
+                    `When NOT to delegate (do it yourself — it's faster and you keep the understanding):\n` +
+                    `- Reading a specific known file → use Read directly.\n` +
+                    `- Finding a known symbol/class/definition, or searching within 2-3 known files → use Grep/Glob/Read.\n` +
+                    `- A lookup where you already know what you want and roughly where it is → just do it. Delegate open-ended INVESTIGATIONS (you don't know where the answer is), not lookups.\n\n` +
+                    `Writing the 'prompt' — brief the agent like a smart colleague who just walked into the room — it hasn't seen this conversation, doesn't know what you've tried, doesn't understand why this task matters:\n` +
+                    `- Make it fully self-contained and highly detailed: the sub-agent does the whole task end-to-end in one shot — you can't course-correct mid-run.\n` +
+                    `- State exactly what it must RETURN (e.g. "report the file:line of each call site", not "look into the call sites").\n` +
+                    `- Say explicitly whether you want it to WRITE CODE or only RESEARCH/REPORT — otherwise it may guess wrong.\n` +
+                    `- Never delegate understanding. Don't write "based on your findings, fix the bug" or "based on the research, implement it." Those phrases push synthesis onto the agent instead of doing it yourself. Write prompts that prove you understood: include file paths, line numbers, what specifically to change.\n\n` +
+                    `Use it for self-contained, parallelizable subtasks (e.g. independent searches/investigations) — it protects your main context; don't overuse it for trivial steps you can do directly. ` +
+                    `Once you delegate a piece of research, rely on the sub-agent's report rather than repeating that search yourself. ` +
+                    `The agent's final message is returned to you as the tool result; it is not shown to the user — relay what matters.\n\n` +
+                    `If the agent reports an action was refused because an approval could not be resolved, do not send the approval back as a message — messages never clear a permission gate. Surface the agent's report of the prepared action and its refusal text to your user. (An agent PARKED at an approval gate is not refused — it is waiting, and resumes when the pending approval is decided.)\n\n` +
+                    `Orchestration: When you launch multiple agents for independent work, send them in a single message with multiple tool uses so they run concurrently. Keep anything that needs shared context single-threaded. Once you've delegated a piece of work, don't also do it yourself — wait for the report.` +
+                    (forkOffered
+                        ? `\n\nsubagent_type "${FORK_SUBAGENT_TYPE}" is built in: it spawns a child that INHERITS your full current context (this entire conversation — no re-explaining, shared prompt cache) and works on 'prompt' as its directive. The fork always runs on YOUR model (the 'model' parameter is ignored for forks) and is not available inside a forked agent.`
+                        : `\n\nNote: this deployment defines its own "${FORK_SUBAGENT_TYPE}" agent type, which OVERRIDES the built-in context-inheriting fork routing — subagent_type "${FORK_SUBAGENT_TYPE}" delegates to that definition instead.`) +
+                    `\n\nThe 'model' parameter optionally overrides the sub-agent's model. If omitted, the agent definition's model (or the inherited default) applies.` +
+                    `\nSet isolation: "worktree" to give the agent its own detached git worktree (auto-removed if it made no changes; kept for you to inspect/merge when it did).` +
+                    (opts.background
+                        ?
+                            (opts.background.notify
+                                ? `\n\nAgents run in the background by default. When an agent runs in the background, you will be automatically notified when it completes — do NOT sleep, poll, or proactively check on its progress. Continue with other work or respond to the user instead. ${SYNC_ESCAPE_SENTENCE}`
+                                : `\n\nAgents run in the background by default. A background agent's result is not pushed automatically — the launch receipt's task_id retrieves progress and results via the TaskOutput tool where mounted. ${SYNC_ESCAPE_SENTENCE}`) +
+                                ` ${continuationSentence(opts.name ?? DEFAULT_SUBAGENT_TOOL_NAME, opts.background.agentStore !== undefined, forkOffered)}` +
+                                `\n\n**Don't race.** After launching, you know nothing about what the agent found. Never fabricate or predict agent results in any format — not as prose, summary, or structured output. ${opts.background.notify ? "The notification arrives as a user-role message in a later turn; it is never something you write yourself." : "The result exists only when you retrieve it; it is never something you write yourself."}`
+                        : `\n\nThe run_in_background parameter is not available in this context. Only synchronous subagents are supported.`) }],
         parameters: Type.Object({
             subagent_type: Type.Optional(Type.String({ description: "The type of specialized agent to use for this task" })),
             description: Type.String({ description: "A short (3-5 word) description of the task." }),
@@ -1448,7 +1469,9 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
             name: Type.Optional(Type.String({
                 maxLength: 64,
                 pattern: "^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$",
-                description: 'Name for the spawned agent. Where the SendMessage tool is mounted, it makes a background agent addressable via SendMessage({to: name}). "main" is reserved.',
+                description: opts.background
+                    ? 'Name for the spawned agent. Where the SendMessage tool is mounted, the name makes the agent addressable via SendMessage({to: name}); either way a named agent always runs in the background (omit name to run one synchronously). "main" is reserved.'
+                    : 'Name for the spawned agent — a label only: agents on this mount run synchronously, so a name does not make one addressable. "main" is reserved.',
             })),
             cwd: Type.Optional(Type.String({
                 description: 'Absolute path to run the agent in. Overrides the working directory for all filesystem and shell operations within this agent. Mutually exclusive with isolation: "worktree".',
@@ -1465,15 +1488,19 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                 ? {
                     run_in_background: Type.Optional(Type.Boolean({
                         description: opts.background.notify
-                            ? "Agents run in the background by default; you will be notified when one completes. Set to false to run this agent synchronously when you need its result before continuing."
-                            : "Agents run in the background by default; the launch receipt's task_id retrieves progress and results via the TaskOutput tool where mounted. Set to false to run this agent synchronously when you need its result before continuing.",
+                            ? "Agents run in the background by default; you will be notified when one completes. Set to false to run this agent synchronously when you need its result before continuing (a named agent always runs in the background)."
+                            : "Agents run in the background by default; the launch receipt's task_id retrieves progress and results via the TaskOutput tool where mounted. Set to false to run this agent synchronously when you need its result before continuing (a named agent always runs in the background).",
                     })),
                 }
                 : {}),
         }),
-        prepareArguments: (args) => foldGeneralPurposeAlias(args, generalPurposeShadowed),
+        prepareArguments: (args) => canonicalSubagentTypeArgs(args, acceptedSubagentTypes(), generalPurposeShadowed),
+        validateInput: (args) => {
+            const refusal = subagentTypeRefusal(args.subagent_type, acceptedSubagentTypes());
+            return refusal === undefined ? { ok: true } : { ok: false, message: refusal.content, code: refusal.error };
+        },
         execute: async (args, ctx) => {
-            const a = foldGeneralPurposeAlias(args, generalPurposeShadowed);
+            const a = canonicalSubagentTypeArgs(args, acceptedSubagentTypes(), generalPurposeShadowed);
             const parentSpecSeat = parentSpecSeatOfCtx(ctx);
             const reviveClaim = ctx.reviveClaim;
             if (reviveClaim !== undefined && opts.background === undefined) {
@@ -1487,46 +1514,17 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
             if (!prompt) {
                 return notStartedResult({ isError: true, content: "Sub-agent not started: 'prompt' was empty.", details: { error: "empty prompt" } });
             }
-            if (a.subagent_type !== undefined && typeof a.subagent_type !== "string") {
-                return notStartedResult({
-                    isError: true,
-                    content: `Sub-agent not started: subagent_type must be a string. Available subagent_type values: ${acceptedSubagentTypes().join(", ")}.`,
-                    details: { error: "unknown subagent_type" },
-                });
-            }
-            const requestedType = a.subagent_type ?? "";
-            let rawType = requestedType;
-            if (requestedType !== "") {
-                const accepted = acceptedSubagentTypes();
-                if (!accepted.includes(requestedType)) {
-                    const wanted = normalizeSubagentType(requestedType);
-                    const hits = wanted === "" ? [] : accepted.filter((n) => normalizeSubagentType(n) === wanted);
-                    if (hits.length > 1) {
-                        return notStartedResult({
-                            isError: true,
-                            content: `Sub-agent not started: subagent_type "${requestedType}" is ambiguous — it matches ${hits.join(", ")}. Use the exact name.`,
-                            details: { error: "ambiguous subagent_type" },
-                        });
-                    }
-                    if (hits.length === 1)
-                        rawType = hits[0];
-                }
-            }
+            const typeRefusal = subagentTypeRefusal(a.subagent_type, acceptedSubagentTypes());
+            if (typeRefusal !== undefined)
+                return notStartedResult({ isError: true, content: typeRefusal.content, details: { error: typeRefusal.error } });
+            const rawType = typeof a.subagent_type === "string" ? a.subagent_type : "";
             const wantsFork = forkOffered && rawType === FORK_SUBAGENT_TYPE;
             if (reviveClaim !== undefined && wantsFork) {
                 return notStartedResult({ isError: true, content: `Sub-agent not revived: a "${FORK_SUBAGENT_TYPE}" agent cannot be revived — launch a new agent with the needed context instead.`, details: { error: "revive.fork_unsupported" } });
             }
             const omitted = rawType === "" || (!generalPurposeShadowed && rawType === GENERAL_PURPOSE_SUBAGENT_TYPE);
             const def = hasAgents && !wantsFork && !omitted ? agentMap.get(rawType) : undefined;
-            const wantsBackground = opts.background !== undefined && (a.run_in_background !== false || def?.background === true);
             const spawnAgentType = wantsFork ? FORK_SUBAGENT_TYPE : omitted ? GENERAL_PURPOSE_SUBAGENT_TYPE : rawType;
-            if (!def && !wantsFork && !omitted) {
-                return notStartedResult({
-                    isError: true,
-                    content: `Sub-agent not started: unknown subagent_type "${rawType}". Available subagent_type values: ${acceptedSubagentTypes().join(", ")}.`,
-                    details: { error: "unknown subagent_type" },
-                });
-            }
             const allowFlaw = toolNameListFlaw(delegationListWhere(toolName, def?.name), "allowed", def !== undefined ? def.allowTools : opts.allowTools);
             if (allowFlaw !== undefined)
                 return notStartedResult({ isError: true, content: `Sub-agent not started: ${inlineUntrusted(allowFlaw, 480)}`, details: { error: "config.agent.unknown_tool" } });
@@ -1556,6 +1554,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                     });
                 }
             }
+            const wantsBackground = opts.background !== undefined && (a.run_in_background !== false || def?.background === true || agentName !== undefined);
             if (a.cwd !== undefined && typeof a.cwd !== "string") {
                 return notStartedResult({ isError: true, content: "Sub-agent not started: cwd must be an absolute path string.", details: { error: "cwd.relative" } });
             }
@@ -1846,8 +1845,9 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
             const parentMcp = opts.tools === undefined && extraToolsNote === undefined ? ctx.mountedMcp?.() : undefined;
             const childMcp = parentMcp !== undefined ? inheritedMcpDeclarations(parentMcp, compileToolSelector([...childCeiling, childOwnLayer])) : undefined;
             const childTools = [...childPool];
-            const childSystemPrompt = def?.systemPrompt ?? opts.systemPrompt;
-            const childDefaultPersona = childSystemPrompt === undefined && !wantsFork ? SUBAGENT_PROMPT : undefined;
+            const childRoleBase = roleBaseOf([def !== undefined ? { systemPrompt: def.systemPrompt } : undefined, { promptRole: opts.promptRole, systemPrompt: opts.systemPrompt }]);
+            const childSystemPrompt = childRoleBase?.systemPrompt;
+            const childDefaultPersona = childRoleBase === undefined && !wantsFork ? SUBAGENT_PROMPT : undefined;
             const defMaxTurns = typeof def?.maxTurns === "number" && Number.isFinite(def.maxTurns) && def.maxTurns > 0 ? def.maxTurns : undefined;
             const childLimits = defMaxTurns !== undefined ? { ...opts.limits, maxTurns: defMaxTurns } : opts.limits;
             const nextExcluded = def ? new Set([...excluded, def.name]) : excluded;
@@ -1922,10 +1922,11 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                     ...(ctx.getApiKeyAndHeaders !== undefined ? { getApiKeyAndHeaders: ctx.getApiKeyAndHeaders } : {}),
                     ...(ctx.checkpointStoreForChildren !== undefined ? { checkpointStore: ctx.checkpointStoreForChildren } : {}),
                     tools: [reportTool],
+                    ...(parentSpecSeat?.advisorModel !== undefined ? { excludeTools: [ADVISOR_TOOL_NAME] } : {}),
                     ...(ctx.deferTools !== undefined ? { deferTools: [...ctx.deferTools] } : {}),
                     ...(ctx.alwaysLoadTools !== undefined ? { alwaysLoadTools: [...ctx.alwaysLoadTools] } : {}),
                     ...(ctx.restoreGatedTools !== undefined ? { restoreGatedTools: ctx.restoreGatedTools === true ? true : [...ctx.restoreGatedTools] } : {}),
-                    ...(ctx.promptProfile !== undefined ? { promptProfile: ctx.promptProfile } : {}),
+                    ...(ctx.promptLean !== undefined ? { promptLean: ctx.promptLean } : {}),
                     ...engineHeadlessLegSeats(),
                     ...childClampSeats(clampSourceOf(ctx)),
                     enableBlockedReport: false,
@@ -1942,6 +1943,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                     const observerGate = parentGate === undefined
                         ? undefined
                         : {
+                            ...(parentGate.ancestorRules !== undefined ? { ancestorRules: parentGate.ancestorRules } : {}),
                             ...(parentGate.permissionMode !== undefined ? { permissionMode: parentGate.permissionMode } : {}),
                             ...(parentGate.permissionModeCeiling !== undefined ? { permissionModeCeiling: parentGate.permissionModeCeiling } : {}),
                             ...(parentGate.shellGate !== undefined ? { shellGate: parentGate.shellGate } : {}),
@@ -2201,6 +2203,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                 tools: childTools,
                 ...(childMcp !== undefined && childMcp.length > 0 ? { mcp: childMcp } : {}),
                 systemPrompt: childSystemPrompt,
+                ...(childRoleBase?.promptRole !== undefined ? { promptRole: childRoleBase.promptRole } : {}),
                 ...(def?.memory ? { memory: def.memory } : {}),
                 ...(def?.skills?.length ? { skills: def.skills } : {}),
                 ...(def?.memoryPersistenceCapable !== undefined ? { memoryPersistenceCapable: def.memoryPersistenceCapable } : {}),
@@ -2212,7 +2215,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                 ...(ctx.deferTools !== undefined ? { deferTools: [...ctx.deferTools] } : {}),
                 ...(ctx.alwaysLoadTools !== undefined ? { alwaysLoadTools: [...ctx.alwaysLoadTools] } : {}),
                 ...(ctx.restoreGatedTools !== undefined ? { restoreGatedTools: ctx.restoreGatedTools === true ? true : [...ctx.restoreGatedTools] } : {}),
-                ...(ctx.promptProfile !== undefined ? { promptProfile: ctx.promptProfile } : {}),
+                ...(ctx.promptLean !== undefined ? { promptLean: ctx.promptLean } : {}),
                 ...(ctx.getApiKeyAndHeaders !== undefined ? { getApiKeyAndHeaders: ctx.getApiKeyAndHeaders } : {}),
                 enableBlockedReport: true,
                 limits: childLimits,
@@ -2377,6 +2380,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                             objective: objectiveSample.text,
                             tools: spawnToolNames,
                             systemPrompt: systemPromptSample?.text,
+                            ...(childRoleBase?.promptRole !== undefined ? { promptRole: childRoleBase.promptRole } : {}),
                             ...(spawnCoverage ? { reviewCoverage: spawnCoverage } : {}),
                         },
                         toolCallId: ctx.toolCallId,
@@ -2409,7 +2413,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                         releaseForked = forkHandle?.release;
                     }
                     else {
-                        forkedId = (await opts.runner.sessions.fork?.(ctx.sessionId, ctx.principal ?? null)) ?? null;
+                        forkedId = (await opts.runner.sessions.fork?.(ctx.sessionId, principalNameOf(ctx.principal) ?? null)) ?? null;
                     }
                 }
                 catch (e) {
@@ -2423,7 +2427,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                 const forkInternals = { ...childInternals, insideFork: true, ...(ctx.reminderMark !== undefined ? { reminderMark: ctx.reminderMark } : {}) };
                 stepRecorder.lockTo(forkedId);
                 const forkWorktreeNote = worktreeDir !== undefined ? forkWorktreeTranslationNote(ctx.parentCwd, worktreeDir) : undefined;
-                const forkObjective = `${FORK_DIRECTIVE_FRAME}${prompt}${forkWorktreeNote !== undefined ? `\n\n${forkWorktreeNote}` : ""}`;
+                const forkObjective = `${FORK_DIRECTIVE_FRAME}${prompt}${forkWorktreeNote !== undefined ? `\n\n${forkWorktreeNote}` : ""}${parentSpecSeat?.advisorModel !== undefined ? `\n\n${ADVISOR_FORK_SENTENCE}` : ""}`;
                 if (wantsBackground) {
                     const bg = opts.background;
                     const notify = ctx.onTaskNotification ?? bg.notify;
@@ -3835,7 +3839,6 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                         : "",
                 `stats: turns=${child.stats.turns} tokens=${child.stats.tokens}`,
                 !retainEntry && failureRetained ? `transcript_id: ${child.sessionId} (internal ID - do not mention to user; inspect via AgentTranscript where mounted)` : "",
-                retainEntry ? `resumable: true` : "",
                 failureRetained
                     ? `session_retained: this child's session is kept for a short time (~15 min) so its transcript stays inspectable via transcript_id; it is released automatically afterwards.`
                     : "",

package/dist/agents/tool-filter.d.ts

@@ -1,6 +1,5 @@
 import type { AgentDefinition, ToolSpec } from "../core/types.js";
 import { type ToolLegKind, type ToolSelector, type ToolSelectorLayer } from "../core/tool-face.js";
-import { type ProtocolId } from "../core/protocol-table.js";
 import { type ToolNameListReading } from "../core/tool-name-list.js";
 /**
  * The tool selector (design/38 1A, one operation since #1623): what tools a run may use, read once over the universe it can get
@@ -10,27 +9,23 @@ import { type ToolNameListReading } from "../core/tool-name-list.js";
  * run that spawned it), so there is no spawn-time filter and no complement anywhere.
  *
  *  - an allowed list absent, or holding `"*"` (any spelling the rule syntax reads as it: `*()`, `*(*)`), sets no allowlist on
- *    its layer; otherwise the layer keeps only what it names
- *    (`[]` keeps nothing — intentional, not a mistake);
+ *    its layer; otherwise the layer keeps only what it names (`[]` keeps nothing — intentional);
  *  - a denied list removes what it names from whatever remains (a denied tool always loses);
  *  - a layer above a run (its ceiling) bounds it: a child's `"*"` never widens what its parent could use.
  *
- * An entry is read by the rule syntax ({@link readDeniedEntry}: `Tool(content)` names `Tool`, the content is not read, the
- * whole tool is hidden; an entry the syntax cannot read names no tool); a protocol spelling (`mcp__srv`, `mcp__srv__*`, a glob over the tool segment) reaches the
- * tools of that peer, including ones it lists later; an entry no tool answers to is kept by name and reaches one mounted later.
- * Judged at the prepare that receives it: a spelling no tool name can have is refused, an unknown name told (`sub-agent-deny-lists.ts`).
+ * An entry is read by the rule syntax ({@link readDeniedEntry}); a protocol spelling (`mcp__srv`, `mcp__srv__*`, a glob over the
+ * tool segment) reaches the tools of that peer, including ones it lists later, and on a denied list any glob (`Re*d`, `*`) the
+ * names it matches; an entry no tool answers to is kept by name and reaches one mounted later. Judged at the prepare that receives it.
  *
- * `"*"` in an allowed list is the "allow all" sentinel and never a name: no tool is named `*` (the caller tool name
- * contract, `caller-tool-name.ts`, refuses it at the mount; engine and protocol-minted names never are).
+ * `"*"` in an allowed list is the "allow all" sentinel and never a name (`caller-tool-name.ts` refuses it at the mount).
  */
 /**
  * How ONE denied-tools entry is read — by the rule syntax's own test of a rule spelling (`ruleSpellingOf`, the one every entry
  * list's reader asks), exactly as written: `Tool(content)` names `Tool` (the content is not read here, so the whole tool is
  * hidden), `Tool()` and `Tool(*)` are the bare name. An entry the syntax cannot read — surrounding whitespace, a tool name
  * outside its spelling (a blank or an invisible character before the `(`, a leading `-`), a parenthesis that does not close
- * the entry — names no tool: `unreadable`, the entry as written. A value that is not a string (a list a host read from a file
- * can hold anything) names no tool either: it reads as `not_a_string` with a fixed label of its TYPE, and nothing about the
- * value is read, converted or printed — `typeof` and the array test only.
+ * the entry — names no tool: `unreadable`, the entry as written. A value that is not a string names no tool either: it reads as
+ * `not_a_string` with a fixed label of its TYPE, and nothing about the value is read, converted or printed.
  */
 export type DeniedEntryReading = {
     readonly kind: "name";
@@ -57,9 +52,9 @@ export declare function notAListSentence(where: string, side: ToolNameListSide,
 export declare function delegationListWhere(toolName: string, definitionName: string | undefined): string;
 /**
  * The digest of a run's own two tool lists as its selector reads them (an absent denied list reads as an empty one): sha256 over the
- * binding serializer's canonical form — the serializer the checkpoint row digest uses. It is the evidence that the spawning run judged
- * EXACTLY these lists (`RunInternals.toolListsJudged`, and the row's `CheckpointState.toolListsJudged` on a resume); `undefined` for
- * lists the serializer cannot encode, which therefore never match any evidence.
+ * binding serializer's canonical form. It is the evidence that the spawning run judged EXACTLY these lists
+ * (`RunInternals.toolListsJudged`, and the row's `CheckpointState.toolListsJudged` on a resume); `undefined` for lists the
+ * serializer cannot encode, which therefore never match any evidence.
  */
 export declare function toolListsDigest(allow: readonly unknown[] | undefined, deny: readonly unknown[] | undefined): string | undefined;
 /**
@@ -67,46 +62,38 @@ export declare function toolListsDigest(allow: readonly unknown[] | undefined, d
  * of strings. The one reading the judgment before the run and the spawn-time check of a tool that never went through prepare share.
  */
 export declare function toolNameListFlaw(where: string, side: ToolNameListSide, value: unknown): string | undefined;
-/** A definition with its two tool-name lists replaced by their one copy — the copy every later reader (the judgment before the
- *  run, the roster, the filter at each spawn) takes instead of the host's container. */
+/** A definition with its two tool-name lists replaced by their one copy — the copy every later reader takes instead of the host's container. */
 export declare function snapshotDefinitionLists(def: AgentDefinition): AgentDefinition;
 /**
- * What ONE tool-name list reaches — the single reading every consumer of an allowed or a denied list takes (the spawn-time
- * filter, the nested-delegation check, the memory content-origin face, the judgment before the run):
- *  - `names`: exact spellings; a tool answers to its wire name and to every alias it declares;
- *  - `covering`: the protocol spellings that cover a SET — a peer (`mcp__srv`), the same set written with the star
- *    (`mcp__srv__*`), a glob over the tool segment (`mcp__srv__get_*`) — matched by the allow layer's own covering matcher,
- *    peers compared exactly, both sides in the same namespace;
- *  - `wholeProtocols`: a denied list's `mcp__*` — every tool of that protocol. An allowed list reads it as nothing (the
- *    reference's allow resolution has no such form: it keeps no MCP tool by it).
+ * What ONE tool-name list reaches — the single reading every consumer of an allowed or a denied list takes: `names` are exact
+ * spellings (a tool answers to its wire name and every alias it declares); `covering` the spellings that cover a SET
+ * ({@link isCoveringRuleName}: `mcp__srv`, `mcp__srv__get_*`; on a denied list any glob, `Re*d`, `*`).
  */
 export interface ToolNameListReach {
     readonly names: ReadonlySet<string>;
     readonly covering: readonly string[];
-    readonly wholeProtocols: ReadonlySet<ProtocolId>;
 }
 /**
  * The tool ONE entry of a list on `side` reaches ({@link readDeniedEntry}) — the one per-entry reading every list reader takes:
- * `Tool()` / `Tool(*)` are the bare `Tool` (`*()` / `*(*)` the wildcard `*`); a denied `Tool(content)` hides the whole `Tool`;
- * an allowed one, an unreadable entry or a non-string reaches nothing (`undefined`).
+ * `Tool()` / `Tool(*)` are the bare `Tool`; a denied `Tool(content)` hides the whole `Tool`; an allowed one, an unreadable entry
+ * or a non-string reaches nothing (`undefined`).
  */
 export declare function toolNameOfEntry(entry: unknown, side: ToolNameListSide): string | undefined;
 /**
- * Is this entry a bare tool name as the rule syntax reads it, written as such (`Read`, `mcp__srv__*`, `*`; never `Read()`,
- * `Read(*)`, `Read(x)`, an unreadable spelling or a non-string)? The one form a checkpoint row records and is read back in.
- */
+ * Is this entry a bare tool name as the rule syntax reads it, written as such (`Read`, `mcp__srv__*`, `*`; never `Read()` or
+ * `Read(x)`)? The one form a checkpoint row records and is read back in. */
 export declare function isCanonicalToolName(entry: unknown): boolean;
 /**
- * A tool-name list as a checkpoint row records it: each entry as {@link toolNameOfEntry} reads it, in canonical spelling, an
- * allowed entry that admits nothing left out — the copy reaches what the list reached, in the spelling a reader accepts
- * ({@link isCanonicalToolName}). An unreadable entry stays as written: prepare refuses it before the park, the reader again.
+ * A tool-name list as a checkpoint row records it: each entry as {@link toolNameOfEntry} reads it, in canonical spelling
+ * ({@link isCanonicalToolName}), an allowed entry that admits nothing left out. An unreadable entry stays as written: prepare
+ * refuses it before the park, the reader again.
  */
 export declare function persistedToolNameList(entries: readonly string[], side: ToolNameListSide): string[];
+/** Is this allowed-tools entry the selector's wildcard (`*`, `*()`, `*(*)`) — no allowlist on its layer? The one test every reader asks. */
+export declare function namesEveryTool(entry: unknown): boolean;
 /**
- * What an allowed-tools value admits, or `undefined` when it names no allowlist: absent, `null`, or a list holding the
- * wildcard — an entry {@link toolNameOfEntry} reads as `*` (`*`, `*()`, `*(*)`). A list admits its string entries (an entry that
- * is not a string admits nothing); a value that is not a list admits NOTHING — the judge before the run refuses it, and a
- * reader that meets it first fails closed.
+ * What an allowed-tools value admits, or `undefined` when it names no allowlist: absent, `null`, or a list holding the wildcard
+ * ({@link namesEveryTool}). A value that is not a list admits NOTHING (refused before the run).
  */
 export declare function readAllowedToolList(allowTools: unknown): ToolNameListReach | undefined;
 /** What a denied value hides: its string entries read as {@link readDeniedEntry} reads them (an entry it reads as `unreadable` or not a string, or a value that is not a list, hides nothing here — the judgment before the run refuses each). */
@@ -132,17 +119,15 @@ export declare function isToolSelectorLayer(layer: unknown): layer is ToolSelect
 /**
  * Compile ONE run's tool selector from its layers (the ceiling it was spawned under, then its own lists — the LAST layer is its own)
  * and the kinds of leg it is. Each list is read by the one reading ({@link readAllowedToolList} / {@link readDeniedToolList}) and
- * matched by the one matcher ({@link listReaches}); a protocol tool of one of `legs` is admitted whatever the leg's own lists say —
- * and whatever the ceiling says too, unless a kind of its row shares its spawner's tool surface ({@link protocolRowUnderCeiling}):
- * the ceiling layers decide it. Whether a list may reach a protocol tool at all is judged at prepare. The layers are kept as handed —
- * the producer passes frozen copies of the lists it read.
+ * matched by the one matcher ({@link listReaches}); a protocol tool of one of `legs` is admitted whatever the leg's own lists say,
+ * and whatever the ceiling says unless a kind of its row shares its spawner's tool surface ({@link protocolRowUnderCeiling}), when
+ * the ceiling layers decide it. Whether a list may reach a protocol tool at all is judged at prepare.
  */
 export declare function compileToolSelector(layers: readonly ToolSelectorLayer[], legs?: readonly ToolLegKind[]): ToolSelector;
 /**
  * What a leg's tool valve leaves mounted — its one reading: nothing under the run's whole-face switch (`excludeAllTools`: every
  * tool unmounts, protocol tools included), else what the compiled selector admits. The valve unmounts by it, and every question
- * prepare asks about the post-valve roster before the valve runs (the full shell's reachability, the memory write channel, the
- * persistence verdict, the two memory pairs' planning) asks it too.
+ * prepare asks about the post-valve roster before the valve runs asks it too.
  */
 export declare function valveLeaves(spec: {
     readonly excludeAllTools?: true;
@@ -150,8 +135,8 @@ export declare function valveLeaves(spec: {
 /**
  * The valve's reading at the SERVER level — {@link valveLeaves} asked of a whole peer before any of its tools is known: can the valve
  * leave a tool of the peer `prefix` (`mcp__srv__`) at all? Nothing under the run's whole-face switch; else what the compiled selector's
- * lists can reach of the peer ({@link ToolSelector.admitsPeer} — read off the lists, never off what the server lists). A peer this
- * answers `false` for leaves no tool on the roster whatever it lists, so a run has no reason to dial it or to teach its instructions.
+ * lists can reach of the peer ({@link ToolSelector.admitsPeer}). A peer answered `false` leaves no tool on the roster, so a run has no
+ * reason to dial it or to teach its instructions.
  */
 export declare function valveLeavesPeer(spec: {
     readonly excludeAllTools?: true;