@yeaft/webchat-agent 0.1.1004 → 0.1.1006

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.1004",
+  "version": "0.1.1006",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/yeaft/config.js

@@ -22,7 +22,7 @@
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { DEFAULT_YEAFT_DIR } from './init.js';
-import { getModelEffortOptions, modelSupportsEffort, resolveModel, parseModelRef, normalizeProviderModels, resolveContextWindow, resolveMaxOutputTokens } from './models.js';
+import { getModelEffortOptions, getThinkingCapability, modelSupportsEffort, resolveModel, parseModelRef, normalizeProviderModels, resolveContextWindow, resolveMaxOutputTokens } from './models.js';
 import { normalizeKnownProviderForRuntime } from './llm/known-providers.js';
 
 /** Default configuration values. */
@@ -402,8 +402,10 @@ export function loadConfig(overrides = {}) {
           if (m.maxOutput !== undefined) entry.maxOutput = m.maxOutput;
           const effortOptions = getModelEffortOptions(m.id);
           if (effortOptions.length > 0) {
+            const cap = getThinkingCapability(m.id);
             entry.supportsEffort = modelSupportsEffort(m.id);
             entry.effortOptions = effortOptions;
+            entry.effortProtocol = cap.thinkingProtocol;
           }
           config.availableModels.push(entry);
         }

package/yeaft/effort.js

@@ -61,7 +61,7 @@ export const SCENARIO_EFFORT = Object.freeze({
  * Pick the effort level for a given query context.
  *
  * Decision order:
- *   1. If userEffort is a valid Effort ('minimal'|'low'|'medium'|'high'|'max'),
+ *   1. If userEffort is a valid Effort ('minimal'|'low'|'medium'|'high'|'xhigh'|'max'),
  *      return it unchanged. This is the explicit override path —
  *      `/max` prefix, Settings slider, or API caller.
  *   2. If toolLoopTurns >= LONG_LOOP_TURN_THRESHOLD, upgrade the
@@ -74,7 +74,7 @@ export const SCENARIO_EFFORT = Object.freeze({
  *   already consumed in the current `query()` call.
  * @param {unknown} [ctx.userEffort=null] — User-supplied override.
  *   Invalid values are ignored (fall through to scenario path).
- * @returns {'minimal'|'low'|'medium'|'high'|'max'} Resolved effort. Never null —
+ * @returns {'minimal'|'low'|'medium'|'high'|'xhigh'|'max'} Resolved effort. Never null —
  *   the adapter/router is responsible for dropping it when the
  *   feature flag is off or the model doesn't support thinking.
  */
@@ -97,7 +97,7 @@ export function pickEffort({ scenario = 'chat', toolLoopTurns = 0, userEffort =
 }
 
 /**
- * Parse a user prompt for `/max`, `/high`, `/medium`, `/low` prefix
+ * Parse a user prompt for `/max`, `/xhigh`, `/high`, `/medium`, `/low` prefix
  * commands. Returns `{ effort, cleanedPrompt }` where cleanedPrompt has
  * the prefix (plus one trailing space) stripped.
  *
@@ -108,11 +108,11 @@ export function pickEffort({ scenario = 'chat', toolLoopTurns = 0, userEffort =
  * via `!` or `/skill:` instead to avoid collision.
  *
  * @param {string} prompt
- * @returns {{ effort: 'low'|'medium'|'high'|'max'|null, cleanedPrompt: string }}
+ * @returns {{ effort: 'low'|'medium'|'high'|'xhigh'|'max'|null, cleanedPrompt: string }}
  */
 export function parseEffortPrefix(prompt) {
   if (typeof prompt !== 'string') return { effort: null, cleanedPrompt: prompt };
-  const m = prompt.match(/^\/(max|high|medium|low)(\s+|$)/);
+  const m = prompt.match(/^\/(max|xhigh|high|medium|low)(\s+|$)/);
   if (!m) return { effort: null, cleanedPrompt: prompt };
   const effort = m[1];
   const cleanedPrompt = prompt.slice(m[0].length);

package/yeaft/llm/anthropic.js

@@ -20,6 +20,7 @@ import {
   normalizeEffort,
   thinkingBudgetForEffort,
   getThinkingCapability,
+  getModelEffortOptions,
 } from '../models.js';
 
 /**
@@ -30,6 +31,28 @@ function thinkingV1Enabled() {
   return process.env.YEAFT_THINKING_V1 === '1';
 }
 
+function applyAnthropicThinking(body, model, effort) {
+  const cap = getThinkingCapability(model);
+  if (!cap.supportsThinking) return;
+  if (!getModelEffortOptions(model).includes(effort)) return;
+
+  if (cap.thinkingProtocol === 'anthropic-adaptive') {
+    body.thinking = { type: 'adaptive' };
+    body.output_config = { ...(body.output_config || {}), effort };
+    return;
+  }
+
+  if (cap.thinkingProtocol === 'anthropic') {
+    const budget = thinkingBudgetForEffort(model, effort);
+    if (budget && budget > 0) {
+      // Anthropic manual thinking requires max_tokens > budget_tokens.
+      const minMax = budget + 1024;
+      if (body.max_tokens < minMax) body.max_tokens = minMax;
+      body.thinking = { type: 'enabled', budget_tokens: budget };
+    }
+  }
+}
+
 const DEFAULT_BASE_URL = 'https://api.anthropic.com';
 const API_VERSION = '2023-06-01';
 
@@ -156,7 +179,7 @@ export class AnthropicAdapter extends LLMAdapter {
   }
 
   /**
-   * @param {{ model: string, system: string, messages: import('./adapter.js').UnifiedMessage[], tools?: import('./adapter.js').UnifiedToolDef[], maxTokens?: number, effort?: 'low'|'medium'|'high'|'max', effortSource?: 'user'|'auto', signal?: AbortSignal }} params
+   * @param {{ model: string, system: string, messages: import('./adapter.js').UnifiedMessage[], tools?: import('./adapter.js').UnifiedToolDef[], maxTokens?: number, effort?: 'low'|'medium'|'high'|'xhigh'|'max', effortSource?: 'user'|'auto', signal?: AbortSignal }} params
    * @returns {AsyncGenerator<import('./adapter.js').StreamEvent>}
    */
   async *stream({ model, system, messages, tools, maxTokens = 16384, effort, effortSource, signal, onRawExchange }) {
@@ -170,24 +193,12 @@ export class AnthropicAdapter extends LLMAdapter {
       stream: true,
     };
 
-    // task-327a: inject extended-thinking only when feature flag on, effort is
-    // a valid value, and the model's registry entry says it supports the
-    // 'anthropic' thinking protocol. Unknown models or non-thinking models
-    // silently drop the parameter — red line: never error on unsupported.
+    // Inject Anthropic thinking only for model-supported effort values.
+    // Adaptive Claude 4.7/4.8 uses output_config.effort; older manual-thinking
+    // models use budget_tokens. Unsupported combinations silently drop effort.
     const normEffort = normalizeEffort(effort);
     if ((thinkingV1Enabled() || effortSource === 'user') && normEffort) {
-      const cap = getThinkingCapability(model);
-      if (cap.supportsThinking && cap.thinkingProtocol === 'anthropic') {
-        const budget = thinkingBudgetForEffort(model, normEffort);
-        if (budget && budget > 0) {
-          // Anthropic requires max_tokens > budget_tokens. Widen max_tokens
-          // if the caller's value is too small to fit the thinking budget
-          // plus a sane reply margin (1024 tokens).
-          const minMax = budget + 1024;
-          if (body.max_tokens < minMax) body.max_tokens = minMax;
-          body.thinking = { type: 'enabled', budget_tokens: budget };
-        }
-      }
+      applyAnthropicThinking(body, model, normEffort);
     }
 
     const translatedTools = this.#translateTools(tools);
@@ -440,15 +451,7 @@ export class AnthropicAdapter extends LLMAdapter {
     // task-327c: mirror stream()'s thinking injection for side queries.
     const normEffort = normalizeEffort(effort);
     if ((thinkingV1Enabled() || effortSource === 'user') && normEffort) {
-      const cap = getThinkingCapability(model);
-      if (cap.supportsThinking && cap.thinkingProtocol === 'anthropic') {
-        const budget = thinkingBudgetForEffort(model, normEffort);
-        if (budget && budget > 0) {
-          const minMax = budget + 1024;
-          if (body.max_tokens < minMax) body.max_tokens = minMax;
-          body.thinking = { type: 'enabled', budget_tokens: budget };
-        }
-      }
+      applyAnthropicThinking(body, model, normEffort);
     }
 
     const response = await fetch(`${this.#baseUrl}/v1/messages`, {

package/yeaft/llm/openai-responses.js

@@ -38,6 +38,7 @@ import {
 import {
   normalizeEffort,
   getThinkingCapability,
+  mapEffortToOpenAIReasoning,
 } from '../models.js';
 
 const DEFAULT_BASE_URL = 'https://api.openai.com/v1';
@@ -52,15 +53,13 @@ function thinkingV1Enabled() {
 }
 
 /**
- * Translate a normalised effort ('minimal'|'low'|'medium'|'high'|'max') into the value
+ * Translate a normalised effort ('minimal'|'low'|'medium'|'high'|'xhigh'|'max') into the value
  * accepted by the OpenAI Responses `reasoning.effort` field. Responses today
- * accepts 'minimal'|'low'|'medium'|'high' — 'max' degrades to 'high' to match the
- * registry's normaliseEffort downgrade rule.
+ * accepts 'minimal'|'low'|'medium'|'high'. Unsupported Anthropic-only
+ * adaptive efforts must be dropped, not downgraded.
  */
 function effortForResponses(effort) {
-  if (!effort) return null;
-  if (effort === 'max') return 'high';
-  return effort;
+  return mapEffortToOpenAIReasoning(effort);
 }
 
 export class OpenAIResponsesAdapter extends LLMAdapter {
@@ -230,7 +229,7 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
   // ─── Streaming ──────────────────────────────────────────
 
   /**
-   * @param {{ model: string, system: string, messages: import('./adapter.js').UnifiedMessage[], tools?: import('./adapter.js').UnifiedToolDef[], maxTokens?: number, effort?: 'low'|'medium'|'high'|'max', effortSource?: 'user'|'auto', extraBody?: object, signal?: AbortSignal, onRawExchange?: ({rawRequest, rawResponse}) => void }} params
+   * @param {{ model: string, system: string, messages: import('./adapter.js').UnifiedMessage[], tools?: import('./adapter.js').UnifiedToolDef[], maxTokens?: number, effort?: 'minimal'|'low'|'medium'|'high'|'xhigh'|'max', effortSource?: 'user'|'auto', extraBody?: object, signal?: AbortSignal, onRawExchange?: ({rawRequest, rawResponse}) => void }} params
    *
    * NOTE on `extraBody`: any keys you spread here are merged verbatim into
    * the wire body and — because the verbatim debug feature is intentionally

package/yeaft/llm/router.js

@@ -115,7 +115,7 @@ export function filterEffortForModel(params) {
     const { effort: _drop, effortSource: _source, ...rest } = params;
     return rest;
   }
-  if (norm === 'minimal' && !getModelEffortOptions(modelId).includes('minimal')) {
+  if (!getModelEffortOptions(modelId).includes(norm)) {
     const { effort: _drop, effortSource: _source, ...rest } = params;
     return rest;
   }

package/yeaft/models.js

@@ -31,9 +31,10 @@ import { lookupModelLimitSync } from './llm/models-dev.js';
  * @property {string} baseUrl — Official API endpoint base URL
  * @property {string} displayName — Human-readable model name
  * @property {boolean} [supportsThinking] — task-327a: model supports thinking/reasoning effort.
- * @property {'anthropic' | 'openai-reasoning' | 'none'} [thinkingProtocol] — task-327a:
+ * @property {'anthropic' | 'anthropic-adaptive' | 'openai-reasoning' | 'none'} [thinkingProtocol] — task-327a:
  *   'anthropic' → thinking:{type:'enabled', budget_tokens:N}
- *   'openai-reasoning' → reasoning:{effort:'low'|'medium'|'high'}
+ *   'anthropic-adaptive' → thinking:{type:'adaptive'} + output_config:{effort}
+ *   'openai-reasoning' → reasoning:{effort:'minimal'|'low'|'medium'|'high'}
  *   'none' (default) → parameter silently dropped by router
  * @property {'low' | 'medium' | 'high' | 'max' | null} [defaultEffort] — task-327a: adapter-level default
  *   when caller doesn't specify effort (null = no default / decision-tree decides).
@@ -73,8 +74,9 @@ export const MODEL_REGISTRY = new Map([
     baseUrl: 'https://api.anthropic.com',
     displayName: 'Claude Opus 4.8',
     supportsThinking: true,
-    thinkingProtocol: 'anthropic',
-    defaultEffort: null,
+    thinkingProtocol: 'anthropic-adaptive',
+    defaultEffort: 'high',
+    effortOptions: ['low', 'medium', 'high', 'xhigh', 'max'],
     maxBudgetTokens: 64000,
   }],
   ['claude-opus-4.8', {
@@ -83,8 +85,9 @@ export const MODEL_REGISTRY = new Map([
     baseUrl: 'https://api.anthropic.com',
     displayName: 'Claude Opus 4.8',
     supportsThinking: true,
-    thinkingProtocol: 'anthropic',
-    defaultEffort: null,
+    thinkingProtocol: 'anthropic-adaptive',
+    defaultEffort: 'high',
+    effortOptions: ['low', 'medium', 'high', 'xhigh', 'max'],
     maxBudgetTokens: 64000,
   }],
   ['claude-haiku-3-20250414', {
@@ -383,7 +386,7 @@ export function parseModelRef(ref) {
 
 /**
  * Valid effort levels accepted by Yeaft adapters.
- * @typedef {'minimal' | 'low' | 'medium' | 'high' | 'max'} Effort
+ * @typedef {'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max'} Effort
  */
 
 /**
@@ -417,15 +420,14 @@ export function mapEffortToOpenAIReasoning(effort) {
     case 'low': return 'low';
     case 'medium': return 'medium';
     case 'high': return 'high';
-    // OpenAI doesn't support 'max'; degrade to 'high'. Engine may emit a
-    // debug line noting the downgrade — adapter level stays silent.
-    case 'max': return 'high';
     default: return null;
   }
 }
 
 export const OPENAI_REASONING_EFFORT_OPTIONS = ['minimal', 'low', 'medium', 'high'];
-export const ANTHROPIC_EFFORT_OPTIONS = ['low', 'medium', 'high'];
+export const ANTHROPIC_MANUAL_EFFORT_OPTIONS = ['low', 'medium', 'high'];
+export const ANTHROPIC_ADAPTIVE_EFFORT_OPTIONS = ['low', 'medium', 'high', 'xhigh', 'max'];
+export const ANTHROPIC_ADAPTIVE_MAX_EFFORT_OPTIONS = ['low', 'medium', 'high', 'max'];
 
 function inferThinkingCapability(model) {
   const id = parseModelRef(model).modelId.toLowerCase();
@@ -435,9 +437,32 @@ function inferThinkingCapability(model) {
     return { supportsThinking: true, thinkingProtocol: 'openai-reasoning', defaultEffort: null, maxBudgetTokens: null };
   }
 
+  // Claude Opus 4.7/4.8 expose the full adaptive effort set, including xhigh.
+  if (/^claude-opus-4[-.]?(7|8)($|-|\.)/.test(id)) {
+    return {
+      supportsThinking: true,
+      thinkingProtocol: 'anthropic-adaptive',
+      defaultEffort: 'high',
+      maxBudgetTokens: null,
+      effortOptions: ANTHROPIC_ADAPTIVE_EFFORT_OPTIONS,
+    };
+  }
+
+  // Claude Opus 4.6 and Sonnet 4.6 use adaptive effort too, but official
+  // Anthropic docs do not list xhigh for them. Keep max, reject xhigh.
+  if (/^claude-(opus|sonnet)-4[-.]?6($|-|\.)/.test(id)) {
+    return {
+      supportsThinking: true,
+      thinkingProtocol: 'anthropic-adaptive',
+      defaultEffort: 'high',
+      maxBudgetTokens: null,
+      effortOptions: ANTHROPIC_ADAPTIVE_MAX_EFFORT_OPTIONS,
+    };
+  }
+
   // Anthropic extended thinking is available on Claude 3.7+ and Claude 4.x.
   // Be conservative: older Claude 3/3.5/Haiku entries stay unsupported unless
-  // explicitly listed in the registry.
+  // explicitly listed in the registry. Older Claude 4.x entries keep manual budgets.
   if (/^claude-/.test(id) && (/(^|-)3-7($|-|\.)/.test(id) || /(^|-)4($|-|\.)/.test(id))) {
     const maxBudgetTokens = id.includes('opus') ? 64000 : 32000;
     return { supportsThinking: true, thinkingProtocol: 'anthropic', defaultEffort: null, maxBudgetTokens };
@@ -474,7 +499,7 @@ export function thinkingBudgetForEffort(model, effort) {
  * models (red line: never error on unsupported).
  *
  * @param {string} model
- * @returns {{ supportsThinking: boolean, thinkingProtocol: 'anthropic' | 'openai-reasoning' | 'none', defaultEffort: Effort | null, maxBudgetTokens: number | null }}
+ * @returns {{ supportsThinking: boolean, thinkingProtocol: 'anthropic' | 'anthropic-adaptive' | 'openai-reasoning' | 'none', defaultEffort: Effort | null, maxBudgetTokens: number | null, effortOptions: Effort[] }}
  */
 export function getThinkingCapability(model) {
   const info = MODEL_REGISTRY.get(model);
@@ -486,6 +511,7 @@ export function getThinkingCapability(model) {
       thinkingProtocol: 'none',
       defaultEffort: null,
       maxBudgetTokens: null,
+      effortOptions: [],
     };
   }
   return {
@@ -493,14 +519,17 @@ export function getThinkingCapability(model) {
     thinkingProtocol: info?.thinkingProtocol || inferred?.thinkingProtocol || 'none',
     defaultEffort: info?.defaultEffort ?? inferred?.defaultEffort ?? null,
     maxBudgetTokens: info?.maxBudgetTokens ?? inferred?.maxBudgetTokens ?? null,
+    effortOptions: (info?.effortOptions || inferred?.effortOptions || null),
   };
 }
 
 export function getModelEffortOptions(model) {
   const cap = getThinkingCapability(model);
   if (!cap.supportsThinking || cap.thinkingProtocol === 'none') return [];
+  if (Array.isArray(cap.effortOptions)) return cap.effortOptions.slice();
   if (cap.thinkingProtocol === 'openai-reasoning') return OPENAI_REASONING_EFFORT_OPTIONS.slice();
-  if (cap.thinkingProtocol === 'anthropic') return ANTHROPIC_EFFORT_OPTIONS.slice();
+  if (cap.thinkingProtocol === 'anthropic-adaptive') return ANTHROPIC_ADAPTIVE_EFFORT_OPTIONS.slice();
+  if (cap.thinkingProtocol === 'anthropic') return ANTHROPIC_MANUAL_EFFORT_OPTIONS.slice();
   return [];
 }
 
@@ -515,7 +544,7 @@ export function modelSupportsEffort(model) {
  * @returns {Effort | null}
  */
 export function normalizeEffort(effort) {
-  if (effort === 'minimal' || effort === 'low' || effort === 'medium' || effort === 'high' || effort === 'max') {
+  if (effort === 'minimal' || effort === 'low' || effort === 'medium' || effort === 'high' || effort === 'xhigh' || effort === 'max') {
     return effort;
   }
   return null;

package/yeaft/prompts.js

@@ -197,6 +197,7 @@ const PROMPTS = {
     tools: (names) => `Available tools: ${names}`,
     // DESIGN-PROMPT §3 ④ — Active Scope header
     activeScopeHeader: '## active_scope',
+    multiVpRoutingHeader: '## multi_vp_routing',
     sessionAnnouncementHeader: '[Session Announcement]',
     // Project-doc (CLAUDE.md / AGENTS.md) header + one-liner intro. Both
     // filenames are recognized: CLAUDE.md is this project's convention,
@@ -212,6 +213,7 @@ const PROMPTS = {
     tools: (names) => `可用工具：${names}`,
     // DESIGN-PROMPT §3 ④ — Active Scope header
     activeScopeHeader: '## active_scope',
+    multiVpRoutingHeader: '## multi_vp_routing',
     sessionAnnouncementHeader: '[会话公告]',
     // 项目文档块：CLAUDE.md / AGENTS.md（与 Codex 通用命名兼容）。
     projectDocHeader: '[项目文档]',
@@ -393,6 +395,9 @@ export function buildSystemPrompt({
   const activeScopeBlock = renderActiveScope(activeScope, lang);
   if (activeScopeBlock) parts.push(activeScopeBlock);
 
+  const multiVpRoutingBlock = renderMultiVpRouting(activeScope, lang);
+  if (multiVpRoutingBlock) parts.push(multiVpRoutingBlock);
+
   return parts.join('\n\n');
 }
 
@@ -490,7 +495,11 @@ function firstNonEmptyString(...values) {
 }
 
 function renderSessionMembersLine(members) {
-  if (!Array.isArray(members)) return '';
+  return normalizeSessionMemberIds(members).join(', ');
+}
+
+function normalizeSessionMemberIds(members) {
+  if (!Array.isArray(members)) return [];
   const clean = [];
   const seen = new Set();
   for (const member of members) {
@@ -500,7 +509,38 @@ function renderSessionMembersLine(members) {
     seen.add(id);
     clean.push(id);
   }
-  return clean.join(', ');
+  return clean;
+}
+
+function renderMultiVpRouting(activeScope, lang) {
+  if (!activeScope || typeof activeScope !== 'object') return '';
+  const ownId = firstNonEmptyString(activeScope.sessionMember, activeScope.vpId);
+  const members = normalizeSessionMemberIds(activeScope.sessionMembers || activeScope.members);
+  const peers = ownId ? members.filter((member) => member !== ownId) : members;
+  if (peers.length === 0) return '';
+
+  const header = lang.multiVpRoutingHeader || '## multi_vp_routing';
+  if (lang === PROMPTS.zh) {
+    return [
+      header,
+      `当前 VP: ${ownId || 'unknown'}`,
+      `可转发 VP: ${peers.join(', ')}`,
+      '- 多 VP session 中，先主动感知这些 VP 的职责；不要假装只有你一个人在场。',
+      '- 当用户点名其他 VP、任务明显属于其他 VP、需要并行协作，或你需要另一个 VP 继续处理时，必须调用 `route_forward`。',
+      '- VP 自己写 @mention 不会触发路由；只有 `route_forward` 工具会真正把任务交给目标 VP。',
+      '- 如果要多人一起处理，调用 `route_forward`，`to` 可填目标 vpId 或 `all`；`text` 要包含明确任务和必要上下文。',
+    ].join('\n');
+  }
+
+  return [
+    header,
+    `Current VP: ${ownId || 'unknown'}`,
+    `Forwardable VPs: ${peers.join(', ')}`,
+    '- In a multi-VP session, actively notice these peers and their likely responsibilities; do not behave as if you are alone.',
+    '- When the user names another VP, the task clearly belongs to another VP, parallel collaboration is needed, or another VP should continue the work, you MUST call `route_forward`.',
+    '- VP-written @mentions do not route anything; only the `route_forward` tool performs a real hand-off.',
+    '- For multi-person work, call `route_forward` with a target vpId or `all`; include the concrete task and required context in `text`.',
+  ].join('\n');
 }
 
 /**

package/yeaft/sessions/session-config.js

@@ -28,7 +28,7 @@ const CONFIG_FILE = 'config.json';
 
 /** Whitelist of persisted session model-override fields. Reject everything else. */
 const ALLOWED_KEYS = new Set(['model', 'modelEffort']);
-const ALLOWED_EFFORTS = new Set(['minimal', 'low', 'medium', 'high']);
+const ALLOWED_EFFORTS = new Set(['minimal', 'low', 'medium', 'high', 'xhigh', 'max']);
 
 export class SessionConfigError extends Error {
   constructor(code, message) {
@@ -101,7 +101,7 @@ export function validateSessionConfig(cfg) {
   }
   if ('modelEffort' in cfg && cfg.modelEffort !== null && cfg.modelEffort !== undefined && cfg.modelEffort !== '') {
     if (typeof cfg.modelEffort !== 'string' || !ALLOWED_EFFORTS.has(cfg.modelEffort.trim())) {
-      throw new SessionConfigError('invalid_model_effort', 'modelEffort must be minimal, low, medium, or high');
+      throw new SessionConfigError('invalid_model_effort', 'modelEffort must be minimal, low, medium, high, xhigh, or max');
     }
   }
 }

package/yeaft/tools/route-forward.js

@@ -27,16 +27,21 @@ import { defineTool } from './types.js';
 
 export default defineTool({
   name: 'RouteForward',
-  description: `Hand this turn off to another VP in the same group.
+  description: `Hand this turn off to another VP in the same session.
 
 Use this tool — NOT free-text @mentions — to route a question or task to
 another VP. VP-authored @mentions in chat text are NOT automatically routed
-(the group coordinator only text-routes for user messages); you must call
-RouteForward for the hand-off to take effect.
+(the coordinator only text-routes user messages); you must call RouteForward
+for the hand-off to take effect.
+
+In a multi-VP session, treat RouteForward as the required hand-off mechanism:
+- If the user names another VP, call RouteForward to that vpId.
+- If another VP clearly owns the domain or should continue the work, call RouteForward instead of only mentioning them.
+- If the task needs parallel collaboration, call RouteForward with a target vpId or "all".
 
 Arguments:
   - to (string): target vpId, or the literal "all" to broadcast to every
-    other member of the group (subject to the per-group fan-out cap).
+    other member of the session (subject to the session fan-out cap).
   - text (string): the message body to send on your behalf.
   - reason (string, optional): short rationale for the forward, recorded on
     the message meta for audit / UI display.
@@ -47,7 +52,7 @@ Rules:
   - Forwards carry a causedBy chain; chains deeper than 10 hops are blocked
     (chain_depth_exceeded).
   - A single target may be forwarded to at most 8 times per 5-second window
-    per group (throttled).
+    per session (throttled).
 
 Returns JSON: { ok, dispatched?, error?, detail? }.`,
   parameters: {