@yeaft/webchat-agent 0.1.596 → 0.1.598

package/package.json

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

package/unify/engine.js

@@ -18,16 +18,18 @@
  */
 
 import { randomUUID } from 'crypto';
-import { buildSystemPrompt } from './prompts.js';
+import { buildSystemPrompt, buildWorkerPrompt } from './prompts.js';
 import { LLMContextError, LLMAbortError } from './llm/adapter.js';
 import { recallR6, formatForInjection } from './memory/recall-r6.js';
 import { shouldConsolidate, consolidate } from './memory/consolidate.js';
 import { buildMemoryInjection } from './memory/layout.js';
 import { buildUserProfile } from './memory/user-memory-store.js';
+import { readSummary as readScopeSummary } from './memory/scope-tree.js';
 import { runStopHooks } from './stop-hooks.js';
 import { getThreadStore, MAIN_THREAD_ID } from './threads/store.js';
 import { pickEffort, parseEffortPrefix } from './effort.js';
 import { normalizeEffort } from './models.js';
+import { attachRouterPlan, extractPriorPlan, stripMetaForWire } from './router/continuity.js';
 
 /**
  * task-324 — Turn cap removed.
@@ -288,16 +290,56 @@ export class Engine {
   }
 
   /**
-   * Build the system prompt with memory, compact summary, and skill content.
+   * Load Layer A scope summaries from `<memoryRoot>/<scope>/summary.md`.
+   *
+   * Scopes:
+   *   - user           → `user/summary.md`            (always attempted)
+   *   - group <gid>    → `groups/<gid>/summary.md`    (if groupId)
+   *   - vp <vpId>      → `vp/<vpId>/summary.md`       (if vpId)
+   *
+   * Each fetch is best-effort — missing files / read errors return ''. The
+   * dream tick (Phase 6) is what populates these; on a fresh install they
+   * all return ''.
+   *
+   * @param {{groupId?: string, vpId?: string}} ctx
+   * @returns {Promise<{user:string, group:string, vp:string}>}
+   */
+  async #loadLayerASummaries({ groupId, vpId } = {}) {
+    if (!this.#yeaftDir) return { user: '', group: '', vp: '' };
+    const memoryRoot = `${this.#yeaftDir}/memory`;
+    const tasks = [
+      readScopeSummary({ kind: 'user' }, { root: memoryRoot }).catch(() => ''),
+      groupId
+        ? readScopeSummary({ kind: 'group', id: groupId }, { root: memoryRoot }).catch(() => '')
+        : Promise.resolve(''),
+      vpId
+        ? readScopeSummary({ kind: 'vp', id: vpId }, { root: memoryRoot }).catch(() => '')
+        : Promise.resolve(''),
+    ];
+    const [user, group, vp] = await Promise.all(tasks);
+    return { user: user || '', group: group || '', vp: vp || '' };
+  }
+
+  /**
+   * Build the system prompt with memory, compact summary, skill content,
+   * and (Phase 8 wire-up) Layer-A scope summaries.
+   *
+   * Routes through `buildWorkerPrompt`, which:
+   *   - Lays in the persona-as-identity block (or Yeaft identity fallback)
+   *   - Concatenates Layer A summaries (`user/group/vp/summary.md`)
+   *   - Reserves Layer B / C / D placeholders for future wiring (router
+   *     preselected memory, task scope, turn scope)
    *
    * @param {{ profile?: string, entries?: object[] }} [memory]
    * @param {string} [compactSummary]
    * @param {string} [prompt] — user prompt (for skill relevance matching)
-   * @param {string} [memoryInjection] — task-287: prebuilt memory block (index + prefs + project)
+   * @param {string} [memoryInjection] — task-287: prebuilt memory block
    * @param {string} [userProfile] — user profile from user-memory shard store
+   * @param {object} [vpPersona]
+   * @param {{user?:string, group?:string, vp?:string}} [summaries]
    * @returns {string}
    */
-  #buildSystemPrompt(memory, compactSummary, prompt, memoryInjection, userProfile, vpPersona) {
+  #buildSystemPrompt(memory, compactSummary, prompt, memoryInjection, userProfile, vpPersona, summaries) {
     // Get relevant skill content if SkillManager is wired
     let skillContent = '';
     if (this.#skillManager && prompt) {
@@ -309,7 +351,7 @@ export class Engine {
       ? this.#toolRegistry.getToolNames()
       : Array.from(this.#tools.keys());
 
-    return buildSystemPrompt({
+    return buildWorkerPrompt({
       language: this.#config.language || 'en',
       toolNames,
       memory,
@@ -318,6 +360,11 @@ export class Engine {
       skillContent,
       userProfile,
       vpPersona,
+      summaries,
+      // Worker-shape harness is descriptive metadata for human inspection;
+      // production prompts skip it to save tokens. Re-enable via env when
+      // diagnosing prompt structure issues.
+      includeShape: process.env.UNIFY_PROMPT_INCLUDE_SHAPE === '1',
       // task-334f: memory_trace tool is now registered (49 → 51 tools), so
       // unlock the core_memory meta-line behind 334e's feature flag.
       memoryTraceAvailable: true,
@@ -518,7 +565,7 @@ export class Engine {
    *   SCENARIO_EFFORT. Unknown values fall through to 'high'.
    * @yields {EngineEvent}
    */
-  async *query({ prompt, messages = [], signal, userEffort = null, scenario = 'chat', vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers } = {}) {
+  async *query({ prompt, messages = [], signal, userEffort = null, scenario = 'chat', vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, groupId } = {}) {
     if (!prompt || typeof prompt !== 'string' || !prompt.trim()) {
       yield {
         type: 'error',
@@ -569,7 +616,7 @@ export class Engine {
     const runSignal = abortCtrl.signal;
 
     try {
-      yield* this.#runQuery({ prompt: effectivePrompt, messages, signal: runSignal, userEffort: effectiveUserEffort, scenario, vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers });
+      yield* this.#runQuery({ prompt: effectivePrompt, messages, signal: runSignal, userEffort: effectiveUserEffort, scenario, vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, groupId });
     } finally {
       if (signal) {
         try { signal.removeEventListener('abort', onExternalAbort); } catch { /* ignore */ }
@@ -587,7 +634,7 @@ export class Engine {
    * in a try/finally without indenting the whole loop.
    * @private
    */
-  async *#runQuery({ prompt, messages, signal, userEffort = null, scenario = 'chat', vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers }) {
+  async *#runQuery({ prompt, messages, signal, userEffort = null, scenario = 'chat', vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, groupId }) {
 
     // ─── Pre-query: Memory Injection (task-287) + Compact Summary ──
     // Two-layer recall:
@@ -626,7 +673,21 @@ export class Engine {
 
     const compactSummary = this.#getCompactSummary();
     const userProfile = recallResult?.profile || '';
-    const systemPrompt = this.#buildSystemPrompt(undefined, compactSummary, prompt, memoryInjection, userProfile, vpPersona);
+
+    // Phase 8 wire-up — Layer A scope summaries
+    // Load `summary.md` for the user / addressed group / addressed VP from
+    // the scoped memory tree (DESIGN.md §2). This is the rolling synopsis a
+    // dream tick maintains; we surface it to the worker prompt so the LLM
+    // has cheap, persistent context without paying the recall cost on every
+    // turn. Failures are non-fatal (cold-start / no memory dir).
+    const summaries = await this.#loadLayerASummaries({
+      groupId,
+      vpId: vpPersona && typeof vpPersona === 'object' && typeof vpPersona.vpId === 'string'
+        ? vpPersona.vpId
+        : (typeof senderVpId === 'string' ? senderVpId : undefined),
+    });
+
+    const systemPrompt = this.#buildSystemPrompt(undefined, compactSummary, prompt, memoryInjection, userProfile, vpPersona, summaries);
 
     // Build conversation: existing messages + new user message
     const conversationMessages = [
@@ -688,7 +749,7 @@ export class Engine {
         for await (const event of this.#adapter.stream({
           model: currentModel,
           system: systemPrompt,
-          messages: [...conversationMessages],
+          messages: stripMetaForWire([...conversationMessages]),
           tools: toolDefs.length > 0 ? toolDefs : undefined,
           maxTokens: this.#config.maxOutputTokens || 16384,
           effort: resolvedEffort,
@@ -837,6 +898,18 @@ export class Engine {
           input: tc.input,
         }));
       }
+      // Phase 8 (DESIGN.md §9.15): carry the router plan back on the
+      // assistant message that produced it. Stripped at the wire by
+      // stripMetaForWire — pure bookkeeping for priorPlan continuity.
+      if (vpPersona && vpPersona.vpId) {
+        attachRouterPlan(assistantMsg, {
+          vpId: vpPersona.vpId,
+          forwardQuery: { userOriginal: prompt || '', intent: '' },
+          preselect: undefined,
+          thinking: null,
+          thinkingReason: '',
+        });
+      }
       conversationMessages.push(assistantMsg);
       fullResponseText += responseText;
 

package/unify/llm/adapter.js

@@ -1,9 +1,13 @@
 /**
  * adapter.js — LLM Adapter base class, unified types, and factory
  *
- * Design decision (2026-04-10): Only two adapters needed:
- *   1. AnthropicAdapter — Anthropic Messages API
- *   2. ChatCompletionsAdapter — OpenAI Chat Completions API (covers GPT, DeepSeek, CopilotProxy, etc.)
+ * Design decision (Phase 7, 2026-04-27): Only two adapters remain:
+ *   1. AnthropicAdapter        — Anthropic Messages API
+ *   2. OpenAIResponsesAdapter  — OpenAI Responses API (covers GPT, DeepSeek, CopilotProxy, etc.)
+ *
+ * The legacy ChatCompletionsAdapter (OpenAI Chat Completions API) was deleted in
+ * Phase 7. Configurations using protocol "openai" or alias "chat-completions"
+ * must migrate to "openai-responses" or "anthropic".
  *
  * The engine sees only unified types — it never knows which API is underneath.
  */
@@ -234,8 +238,7 @@ export async function createLLMAdapter(config) {
   }
 
   // ─── Legacy path: single adapter from env vars ────────
-  // Normalize adapter name — accept 'chat-completions' as alias for 'openai'
-  const adapter = config.adapter === 'chat-completions' ? 'openai' : config.adapter;
+  const adapter = config.adapter;
 
   if (adapter === 'anthropic' || (!adapter && config.apiKey)) {
     if (!config.apiKey) {
@@ -248,26 +251,24 @@ export async function createLLMAdapter(config) {
     });
   }
 
-  if (adapter === 'openai' || (!adapter && config.openaiApiKey)) {
-    if (!config.openaiApiKey && !config.apiKey) {
-      throw new Error('OpenAI adapter requires YEAFT_OPENAI_API_KEY (or YEAFT_API_KEY as fallback)');
-    }
-    const { ChatCompletionsAdapter } = await import('./chat-completions.js');
-    return new ChatCompletionsAdapter({
-      apiKey: config.openaiApiKey || config.apiKey,
-      baseUrl: config.baseUrl || 'https://api.openai.com/v1',
-    });
-  }
-
-  if (adapter === 'proxy' || (!adapter && config.proxyUrl)) {
-    const { ChatCompletionsAdapter } = await import('./chat-completions.js');
-    return new ChatCompletionsAdapter({
-      apiKey: 'proxy', // CopilotProxy handles auth
-      baseUrl: `${config.proxyUrl}/v1`,
-    });
+  if (
+    adapter === 'chat-completions' ||
+    adapter === 'openai' ||
+    adapter === 'proxy' ||
+    (!adapter && (config.openaiApiKey || config.proxyUrl))
+  ) {
+    throw new Error(
+      'The chat-completions adapter was removed in Phase 7. ' +
+      'Configure providers via ~/.yeaft/config.json with protocol: "anthropic" ' +
+      'or protocol: "openai-responses" instead of using the legacy ' +
+      '"openai"/"proxy"/"chat-completions" adapter env-var path.'
+    );
   }
 
   throw new Error(
-    'No LLM adapter configured. Set YEAFT_API_KEY (Anthropic), YEAFT_OPENAI_API_KEY (OpenAI), or YEAFT_PROXY_URL (CopilotProxy).',
+    'No LLM adapter configured. Set YEAFT_API_KEY (Anthropic) or configure ' +
+    'providers in ~/.yeaft/config.json. The chat-completions/openai/proxy ' +
+    'env-var paths were removed in Phase 7 — use protocol: "openai-responses" ' +
+    'in a provider entry instead.',
   );
 }

package/unify/llm/router.js

@@ -5,11 +5,14 @@
  *   [{ name, baseUrl, apiKey, protocol?, models[] }, ...]
  *
  * The router resolves model → provider, lazy-creates the right adapter
- * (AnthropicAdapter or ChatCompletionsAdapter based on protocol), caches it,
+ * (AnthropicAdapter or OpenAIResponsesAdapter based on protocol), caches it,
  * and forwards stream()/call() to the resolved adapter.
  *
- * protocol defaults to "openai" (Chat Completions API).
- * Set protocol: "anthropic" only for direct Anthropic API connections.
+ * protocol must be one of:
+ *   - "anthropic"        — Anthropic Messages API (required for claude-* models)
+ *   - "openai-responses" — OpenAI Responses API (default for everything else)
+ *
+ * Phase 7 removed the legacy "openai" (Chat Completions) protocol entirely.
  */
 
 import { LLMAdapter } from './adapter.js';
@@ -93,23 +96,25 @@ export class AdapterRouter extends LLMAdapter {
   /**
    * Resolve the effective wire protocol for a (provider, model) pair.
    *
-   * The provider's declared protocol is the default, but Anthropic-style
-   * model IDs (e.g. "claude-opus-4.7") cannot be served by the OpenAI
-   * Responses API even when the provider sits in front of both. Detect
-   * that mismatch and downgrade to chat-completions, which proxies like
-   * GitHub Copilot DO support for Claude models.
+   * Phase 7: only "anthropic" and "openai-responses" are supported. Claude
+   * model IDs require provider.protocol === "anthropic" — there is no
+   * chat-completions fallback any more.
    *
    * @param {object} provider — Provider config
    * @param {string} modelId
-   * @returns {'anthropic' | 'openai-responses' | 'openai'}
+   * @returns {'anthropic' | 'openai-responses'}
    */
   #effectiveProtocol(provider, modelId) {
-    const declared = provider.protocol || 'openai';
-    // Anthropic models — only 'anthropic' or 'openai' (chat-completions) make sense.
-    // Responses API does not support Claude → fall back to chat-completions.
+    const declared = provider.protocol || 'openai-responses';
     if (typeof modelId === 'string' && modelId.startsWith('claude-')) {
-      if (declared === 'openai-responses') return 'openai';
-      return declared; // anthropic / openai both fine
+      if (declared !== 'anthropic') {
+        throw new Error(
+          `Claude models require provider.protocol="anthropic"; ` +
+          `chat-completions fallback removed in Phase 7. ` +
+          `Provider "${provider.name}" declares protocol="${declared}" for model "${modelId}".`
+        );
+      }
+      return 'anthropic';
     }
     return declared;
   }
@@ -131,8 +136,8 @@ export class AdapterRouter extends LLMAdapter {
     }
 
     // Compute the effective protocol per model — a single provider may need
-    // two adapters (e.g. copilot proxy: openai-responses for gpt-5*,
-    // chat-completions for claude-*). Cache key includes the protocol.
+    // two adapters (e.g. mixed config: openai-responses for gpt-5*, anthropic
+    // for claude-*). Cache key includes the protocol.
     const protocol = this.#effectiveProtocol(provider, modelId);
     const cacheKey = `${provider.name}::${protocol}`;
     const cached = this.#adapterCache.get(cacheKey);
@@ -147,19 +152,18 @@ export class AdapterRouter extends LLMAdapter {
         baseUrl: provider.baseUrl,
       });
     } else if (protocol === 'openai-responses') {
-      // OpenAI Responses API (/v1/responses) — next-gen, recommended for GPT-5+
+      // OpenAI Responses API (/v1/responses) — canonical OpenAI-compatible path.
       const { OpenAIResponsesAdapter } = await import('./openai-responses.js');
       adapter = new OpenAIResponsesAdapter({
         apiKey: provider.apiKey,
         baseUrl: provider.baseUrl,
       });
     } else {
-      // Default: openai (Chat Completions API) — covers proxy, OpenAI, DeepSeek, Gemini, etc.
-      const { ChatCompletionsAdapter } = await import('./chat-completions.js');
-      adapter = new ChatCompletionsAdapter({
-        apiKey: provider.apiKey,
-        baseUrl: provider.baseUrl,
-      });
+      throw new Error(
+        `Unsupported protocol "${protocol}" for provider "${provider.name}". ` +
+        `Use protocol: "anthropic" or "openai-responses". ` +
+        `The chat-completions adapter was removed in Phase 7.`
+      );
     }
 
     this.#adapterCache.set(cacheKey, adapter);

package/unify/models.js

@@ -76,7 +76,7 @@ export const MODEL_REGISTRY = new Map([
   // ── OpenAI ─────────────────────────────────────────────────────
   ['gpt-5', {
     provider: 'openai',
-    adapter: 'chat-completions',
+    adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
     contextWindow: 256000,
     maxOutputTokens: 16384,
@@ -91,25 +91,25 @@ export const MODEL_REGISTRY = new Map([
   // should come from provider config (user-supplied) instead of guesses.
   ['gpt-5-mini', {
     provider: 'openai',
-    adapter: 'chat-completions',
+    adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
     displayName: 'GPT-5 Mini',
   }],
   ['gpt-5-nano', {
     provider: 'openai',
-    adapter: 'chat-completions',
+    adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
     displayName: 'GPT-5 Nano',
   }],
   ['gpt-5-pro', {
     provider: 'openai',
-    adapter: 'chat-completions',
+    adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
     displayName: 'GPT-5 Pro',
   }],
   ['gpt-5.4', {
     provider: 'openai',
-    adapter: 'chat-completions',
+    adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
     contextWindow: 272000,
     maxOutputTokens: 16384,
@@ -117,7 +117,7 @@ export const MODEL_REGISTRY = new Map([
   }],
   ['gpt-4.1', {
     provider: 'openai',
-    adapter: 'chat-completions',
+    adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
     contextWindow: 1047576,
     maxOutputTokens: 32768,
@@ -125,7 +125,7 @@ export const MODEL_REGISTRY = new Map([
   }],
   ['gpt-4.1-mini', {
     provider: 'openai',
-    adapter: 'chat-completions',
+    adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
     contextWindow: 1047576,
     maxOutputTokens: 16384,
@@ -133,7 +133,7 @@ export const MODEL_REGISTRY = new Map([
   }],
   ['gpt-4.1-nano', {
     provider: 'openai',
-    adapter: 'chat-completions',
+    adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
     contextWindow: 1047576,
     maxOutputTokens: 16384,
@@ -141,7 +141,7 @@ export const MODEL_REGISTRY = new Map([
   }],
   ['o3', {
     provider: 'openai',
-    adapter: 'chat-completions',
+    adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
     contextWindow: 200000,
     maxOutputTokens: 100000,
@@ -153,7 +153,7 @@ export const MODEL_REGISTRY = new Map([
   }],
   ['o4-mini', {
     provider: 'openai',
-    adapter: 'chat-completions',
+    adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
     contextWindow: 200000,
     maxOutputTokens: 100000,
@@ -166,7 +166,7 @@ export const MODEL_REGISTRY = new Map([
   // ── DeepSeek ───────────────────────────────────────────────────
   ['deepseek-chat', {
     provider: 'deepseek',
-    adapter: 'chat-completions',
+    adapter: 'openai-responses',
     baseUrl: 'https://api.deepseek.com',
     contextWindow: 131072,
     maxOutputTokens: 8192,
@@ -174,7 +174,7 @@ export const MODEL_REGISTRY = new Map([
   }],
   ['deepseek-reasoner', {
     provider: 'deepseek',
-    adapter: 'chat-completions',
+    adapter: 'openai-responses',
     baseUrl: 'https://api.deepseek.com',
     contextWindow: 131072,
     maxOutputTokens: 8192,
@@ -184,7 +184,7 @@ export const MODEL_REGISTRY = new Map([
   // ── Google (via OpenAI-compatible API) ─────────────────────────
   ['gemini-2.5-pro', {
     provider: 'google',
-    adapter: 'chat-completions',
+    adapter: 'openai-responses',
     baseUrl: 'https://generativelanguage.googleapis.com/v1beta/openai',
     contextWindow: 1048576,
     maxOutputTokens: 65536,
@@ -192,7 +192,7 @@ export const MODEL_REGISTRY = new Map([
   }],
   ['gemini-2.5-flash', {
     provider: 'google',
-    adapter: 'chat-completions',
+    adapter: 'openai-responses',
     baseUrl: 'https://generativelanguage.googleapis.com/v1beta/openai',
     contextWindow: 1048576,
     maxOutputTokens: 65536,

package/unify/prompts.js

@@ -155,6 +155,14 @@ function extractLangSection(content, language) {
 /** Loaded templates — read once at module load time. */
 const RAW_TEMPLATES = {
   base: readTemplate('base.md'),
+  // Phase 8 wire-up: split-out fragments for the persona-as-identity path.
+  // `identityYeaft` ships only when NO VP persona is active. `commonRules`
+  // ships every turn (with persona OR with Yeaft identity) — it carries
+  // output-format, code-editing, search, and frontend rules that are
+  // identity-independent. base.md remains as a back-compat bundle so any
+  // external snapshotter / test that reads the file directly keeps working.
+  identityYeaft: readTemplate('identity-yeaft.md', { required: false }),
+  commonRules: readTemplate('common-rules.md', { required: false }),
   modeUnified: readTemplate('mode-unified.md'),
   modeDream: readTemplate('mode-dream.md'),
   toolGuidance: readTemplate('tool-guidance.md'),
@@ -201,7 +209,7 @@ const PROMPTS = {
     coreMemoryMeta: 'To open the original message behind any entry above, call `memory_trace`.',
     vpPersonaHeader: '## active_persona',
     vpPersonaIntro: (name, role) =>
-      `For this turn you are speaking as **${name}**${role ? ` (${role})` : ''}. Stay in character; the persona below overrides the generic Yeaft identity for tone, expertise, and decision style.`,
+      `You ARE **${name}**${role ? ` (${role})` : ''}. Speak in the first person as ${name}; do not refer to yourself as "Yeaft" or as a generic AI assistant. The text below is your identity, expertise, and decision style.`,
   },
   zh: {
     identity: '你是 Yeaft，一个有用的 AI 助手。',
@@ -222,7 +230,7 @@ const PROMPTS = {
     coreMemoryMeta: '如需原始 message，调 `memory_trace`。',
     vpPersonaHeader: '## active_persona',
     vpPersonaIntro: (name, role) =>
-      `本轮你以 **${name}**${role ? `（${role}）` : ''} 的身份说话。请保持人设：以下 persona 在语气、专业方向与判断风格上覆盖默认的 Yeaft 身份。`,
+      `你就是 **${name}**${role ? `（${role}）` : ''}。请以 ${name} 的第一人称发言；不要自称 "Yeaft" 或泛指的 AI 助手。下面的文字是你的身份、专业方向与判断风格。`,
   },
 };
 
@@ -311,25 +319,28 @@ export function buildSystemPrompt({
   const parts = [];
 
   // ─── 1. Core Identity ──────────────────────────────────
-  // Use template if available, otherwise fallback to hardcoded one-liner
-  const baseTemplate = getTemplate('base', effectiveLang);
-  if (baseTemplate) {
-    parts.push(baseTemplate);
+  // Phase 8 wire-up: when a VP persona is active, the persona body REPLACES
+  // the Yeaft identity block (the LLM is that VP, not Yeaft pretending). When
+  // there is no persona, fall back to the legacy Yeaft identity bundle.
+  const personaBlock = renderVpPersona(vpPersona, lang);
+  if (personaBlock) {
+    parts.push(personaBlock);
+    // Common rules (output format, code editing, search, frontend) still
+    // apply to every turn, regardless of which VP is speaking.
+    const commonRules = getTemplate('commonRules', effectiveLang);
+    if (commonRules) parts.push(commonRules);
   } else {
-    parts.push(lang.identity);
+    const baseTemplate = getTemplate('base', effectiveLang);
+    if (baseTemplate) {
+      parts.push(baseTemplate);
+    } else {
+      parts.push(lang.identity);
+    }
   }
 
   // ─── 2. Date Metadata ──────────────────────────────────
   parts.push(lang.date(new Date().toISOString().split('T')[0]));
 
-  // ─── 2.5 VP Persona Override (Bug 3 fix) ───────────────
-  // When the caller (web-bridge / dispatcher) addressed a specific VP via
-  // @-mention, inject that VP's persona body so the LLM stops speaking as
-  // generic Yeaft and adopts the VP's voice. Placed AFTER base identity so
-  // the persona section's directive ("override generic Yeaft") wins.
-  const vpBlock = renderVpPersona(vpPersona, lang);
-  if (vpBlock) parts.push(vpBlock);
-
   // ─── 3. Mode-Specific Instructions ─────────────────────
   // task-297: single unified mode for all normal operation.
   // `dream` is retained for background memory maintenance.
@@ -426,10 +437,14 @@ function renderVpPersona(vpPersona, lang) {
   if (!name) return '';
   const role = typeof vpPersona.role === 'string' ? vpPersona.role.trim() : '';
   const body = typeof vpPersona.persona === 'string' ? vpPersona.persona.trim() : '';
-  const lines = [
-    lang.vpPersonaHeader,
-    lang.vpPersonaIntro(name, role),
-  ];
+
+  // Phase 8 wire-up: persona is now the IDENTITY layer (not an overlay).
+  // Emit a `# <name> — <role>` H1 so the prompt opens with the VP's name,
+  // matching the legacy Yeaft identity shape but speaking as the VP. The
+  // first-person imperative ("you ARE X") replaces the old soft overlay
+  // language so the LLM does not slip back into Yeaft voice mid-turn.
+  const heading = role ? `# ${name} — ${role}` : `# ${name}`;
+  const lines = [heading, '', lang.vpPersonaIntro(name, role)];
   if (body) lines.push('', body);
   return lines.join('\n');
 }

package/unify/templates/common-rules.md

@@ -0,0 +1,87 @@
+<!-- lang:en -->
+
+## Core Principles
+
+- You are a thoughtful collaborator, not just a command executor
+- Admit uncertainty honestly — say "I'm not sure" rather than guessing
+- Cite evidence when making claims about code, behavior, or facts
+- Be concise: prefer short, direct answers over verbose explanations
+- Never add emoji unless the user uses them first
+- Never start responses with excessive flattery ("Great question!")
+
+## Output Format
+
+- Use GitHub-flavored Markdown
+- Code blocks must include language identifiers: ```js, ```python, etc.
+- Reference files with inline code: `src/app.ts:42`
+- Avoid deeply nested bullet lists — prefer flat structure or numbered steps
+- For terminal commands, use single-line code blocks
+- For multi-step instructions, use numbered lists
+
+## Code Editing Rules
+
+- Always read a file before editing it
+- Never revert changes you did not make
+- Never amend commits unless the user explicitly asks
+- Never use `git reset --hard` or `git clean -f` without user approval
+- Prefer non-interactive git commands (no `git rebase -i`, no `git add -i`)
+- Default to ASCII — avoid Unicode decorations in code
+- Follow existing code style: indentation, naming conventions, patterns
+- When adding code, match the surrounding context
+
+## Search and Navigation
+
+- Prefer `rg` (ripgrep) over `grep` for speed and regex support
+- Use `glob` patterns for file discovery
+- Read files with offset/limit for large files instead of loading everything
+
+## Frontend Design (when applicable)
+
+- Avoid "AI slop": no gratuitous purple gradients, no hero sections with vague taglines
+- Do not default to dark theme — follow project conventions
+- Match existing design system; do not introduce new component libraries without asking
+- Prefer semantic HTML and progressive enhancement
+
+<!-- lang:zh -->
+
+## 核心原则
+
+- 你是一个深思熟虑的协作者，而非单纯的命令执行器
+- 诚实地承认不确定性 — 说"我不确定"而不是猜测
+- 在对代码、行为或事实做出断言时引用证据
+- 简洁：优先使用简短直接的回答，而非冗长的解释
+- 除非用户先使用 emoji，否则不要添加
+- 不要以过度的奉承开头（"好问题！"）
+
+## 输出格式
+
+- 使用 GitHub 风格的 Markdown
+- 代码块必须包含语言标识：```js、```python 等
+- 使用内联代码引用文件：`src/app.ts:42`
+- 避免深层嵌套的项目列表 — 优先使用扁平结构或编号步骤
+- 终端命令使用单行代码块
+- 多步骤指令使用编号列表
+
+## 代码编辑规则
+
+- 编辑文件前必须先读取
+- 不要回退你未做的修改
+- 除非用户明确要求，否则不要 amend commit
+- 未经用户同意不使用 `git reset --hard` 或 `git clean -f`
+- 优先使用非交互式 git 命令（不用 `git rebase -i`、不用 `git add -i`）
+- 默认使用 ASCII — 避免在代码中使用 Unicode 装饰
+- 遵循已有的代码风格：缩进、命名约定、模式
+- 添加代码时匹配周围的上下文
+
+## 搜索与导航
+
+- 优先使用 `rg`（ripgrep）而非 `grep`，速度更快且支持正则
+- 使用 `glob` 模式发现文件
+- 对大文件使用 offset/limit 读取，而非加载全部内容
+
+## 前端设计（适用时）
+
+- 避免 "AI 泛滥风格"：不要无端使用紫色渐变、不要带模糊标语的 hero 区域
+- 不要默认使用暗色主题 — 遵循项目约定
+- 匹配现有设计系统；不要在未询问的情况下引入新的组件库
+- 优先使用语义化 HTML 和渐进增强

package/unify/templates/identity-yeaft.md

@@ -0,0 +1,11 @@
+<!-- lang:en -->
+
+# Yeaft — AI Companion
+
+You are Yeaft, an AI companion that maintains a single continuous conversation with the user. You remember context across sessions through your memory system. Every interaction builds on what came before.
+
+<!-- lang:zh -->
+
+# Yeaft — AI 伙伴
+
+你是 Yeaft，一个与用户保持单一持续对话的 AI 伙伴。你通过记忆系统在会话间记住上下文。每次交互都建立在之前的基础上。

package/unify/threads/engine-instance.js

@@ -97,7 +97,7 @@ export class EngineInstance {
    * @param {AbortSignal} [params.signal]
    * @yields {object} EngineEvent with { ...event, threadId }
    */
-  async *query({ prompt, mode, signal, vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers } = {}) {
+  async *query({ prompt, mode, signal, vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, groupId } = {}) {
     if (this.#terminated) {
       yield {
         type: 'error',
@@ -173,7 +173,7 @@ export class EngineInstance {
       curToolResults = [];
     }
 
-    for await (const event of this.#engine.query({ prompt, mode, messages: snapshot, signal, vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers })) {
+    for await (const event of this.#engine.query({ prompt, mode, messages: snapshot, signal, vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, groupId })) {
       // Re-tag every event with the bound threadId. Non-object events
       // (shouldn't happen — all engine events are objects) are passed
       // through untouched.

package/unify/web-bridge.js

@@ -1256,13 +1256,17 @@ export async function handleUnifyGroupChat(msg) {
  * Returns `undefined` when we have nothing to inject — keeps the legacy
  * single-agent path identical to before.
  */
-function buildVpQueryOpts({ vpId, groupCoordinator }) {
+function buildVpQueryOpts({ vpId, groupCoordinator, groupId }) {
   if (!vpId) return undefined;
   const out = { senderVpId: vpId };
+  if (typeof groupId === 'string' && groupId.trim()) {
+    out.groupId = groupId.trim();
+  }
   try {
     const vp = readVp(vpId);
     if (vp) {
       out.vpPersona = {
+        vpId,
         displayName: vp.displayName || vpId,
         role: vp.role || '',
         persona: vp.persona || '',
@@ -1411,7 +1415,7 @@ export async function handleUnifyChat(msg) {
     const { entry } = session.dispatcher.submit(cleanedPrompt, {
       messageId: msg.messageId,
       override: override || undefined,
-      queryOpts: buildVpQueryOpts({ vpId, groupCoordinator }),
+      queryOpts: buildVpQueryOpts({ vpId, groupCoordinator, groupId }),
     });
     sendUnifyEvent({
       type: 'input_queue_updated',

package/unify/llm/chat-completions.js

@@ -1,501 +0,0 @@
-/**
- * chat-completions.js — OpenAI Chat Completions API adapter
- *
- * Covers ALL OpenAI-compatible backends via baseUrl:
- *   - https://api.openai.com/v1           → OpenAI direct
- *   - https://api.deepseek.com            → DeepSeek
- *   - http://localhost:6628/v1            → CopilotProxy
- *   - Azure, Ollama, LMStudio, etc.
- *
- * Key translation responsibilities:
- *   Request:  UnifiedToolDef → { type: "function", function: { name, description, parameters } }
- *   Response: delta.tool_calls[i].function.arguments (JSON string) → accumulate → JSON.parse → UnifiedToolCall
- *   Result:   UnifiedToolResult → { role: "tool", tool_call_id, content }
- *   Finish:   "tool_calls" → "tool_use", "stop" → "end_turn", "length" → "max_tokens"
- *
- * max_tokens strategy (based on model ID):
- *   OpenAI models (gpt-*, o1*, o3*, o4*) use "max_completion_tokens" (new standard).
- *   All other models (DeepSeek, Gemini, etc.) use "max_tokens" (legacy/compat).
- *   CopilotProxy transparently forwards whatever the client sends.
- *   Callers can override via extraBody to pass any parameter directly.
- */
-
-import {
-  LLMAdapter,
-  LLMRateLimitError,
-  LLMAuthError,
-  LLMContextError,
-  LLMServerError,
-  LLMAbortError,
-  redactRawRequest,
-  capRawRequest,
-  capRawString,
-  RAW_PAYLOAD_CAP_BYTES,
-} from './adapter.js';
-import {
-  normalizeEffort,
-  mapEffortToOpenAIReasoning,
-  getThinkingCapability,
-} from '../models.js';
-
-/**
- * task-327a: feature-flag accessor. Read lazily so tests can flip.
- */
-function thinkingV1Enabled() {
-  return process.env.UNIFY_THINKING_V1 === '1';
-}
-
-/**
- * task-DESIGN-v4: Chat Completions adapter is deprecated in favour of
- * `openai-responses.js` (Responses API) for OpenAI-protocol providers and
- * `anthropic.js` for Anthropic. This warning fires once per process the
- * first time the adapter is instantiated, unless UNIFY_SUPPRESS_DEPRECATION=1.
- * Removal is scheduled for Phase 7 of the multi-VP redesign — see
- * `agent/unify/DESIGN.md` § "Migration Plan".
- */
-let _chatCompletionsDeprecationWarned = false;
-function warnChatCompletionsDeprecated() {
-  if (_chatCompletionsDeprecationWarned) return;
-  if (process.env.UNIFY_SUPPRESS_DEPRECATION === '1') {
-    _chatCompletionsDeprecationWarned = true;
-    return;
-  }
-  _chatCompletionsDeprecationWarned = true;
-  // eslint-disable-next-line no-console
-  console.warn(
-    '[unify] ChatCompletionsAdapter is deprecated. Migrate OpenAI-protocol '
-    + 'providers to the Responses API (set provider.protocol="openai-responses"). '
-    + 'This adapter will be removed in a future release. Set '
-    + 'UNIFY_SUPPRESS_DEPRECATION=1 to silence this warning.'
-  );
-}
-
-/**
- * Check if a model ID is an OpenAI model that supports max_completion_tokens.
- * OpenAI introduced max_completion_tokens with o1 and made it standard for
- * GPT-4.1+, o-series, and GPT-5+. Other OpenAI-compatible APIs (DeepSeek,
- * Gemini, Ollama) still only understand max_tokens.
- *
- * @param {string} model — The model ID (e.g. "gpt-5", "deepseek-chat", "o3")
- * @returns {boolean} true = use max_completion_tokens
- */
-export function useNewMaxTokensParam(model) {
-  if (!model) return false;
-  const m = model.toLowerCase();
-  // GPT-4.1+ and GPT-5+
-  if (m.startsWith('gpt-')) return true;
-  // o-series reasoning models (o1, o3, o4-mini, etc.)
-  if (/^o\d/.test(m)) return true;
-  // Everything else (deepseek-*, gemini-*, claude-*, custom models): legacy
-  return false;
-}
-
-/**
- * ChatCompletionsAdapter — Talks to OpenAI Chat Completions API and compatibles.
- */
-export class ChatCompletionsAdapter extends LLMAdapter {
-  #apiKey;
-  #baseUrl;
-
-  /**
-   * @param {{ apiKey: string, baseUrl: string }} config
-   */
-  constructor({ apiKey, baseUrl }) {
-    super({ apiKey, baseUrl });
-    this.#apiKey = apiKey;
-    this.#baseUrl = baseUrl.replace(/\/+$/, ''); // strip trailing slash
-    warnChatCompletionsDeprecated();
-  }
-
-  /** Expose baseUrl for testing. */
-  get baseUrl() { return this.#baseUrl; }
-
-  /**
-   * Build the max-tokens portion of the request body.
-   * Uses max_completion_tokens for OpenAI models, max_tokens for others.
-   *
-   * @param {string} model
-   * @param {number} maxTokens
-   * @returns {object}
-   */
-  #maxTokensBody(model, maxTokens) {
-    if (useNewMaxTokensParam(model)) {
-      return { max_completion_tokens: maxTokens };
-    }
-    return { max_tokens: maxTokens };
-  }
-
-  /**
-   * Translate UnifiedToolDef[] → Chat Completions tool format.
-   * @param {import('./adapter.js').UnifiedToolDef[]} tools
-   * @returns {object[]|undefined}
-   */
-  #translateTools(tools) {
-    if (!tools || tools.length === 0) return undefined;
-    return tools.map(t => ({
-      type: 'function',
-      function: {
-        name: t.name,
-        description: t.description,
-        parameters: t.parameters,
-      },
-    }));
-  }
-
-  /**
-   * Translate UnifiedMessage[] → Chat Completions message format.
-   * @param {string} system — System prompt
-   * @param {import('./adapter.js').UnifiedMessage[]} messages
-   * @returns {object[]}
-   */
-  #translateMessages(system, messages) {
-    const result = [];
-
-    // System message first
-    if (system) {
-      result.push({ role: 'system', content: system });
-    }
-
-    for (const msg of messages) {
-      if (msg.role === 'system') {
-        result.push({ role: 'system', content: msg.content });
-      } else if (msg.role === 'user') {
-        result.push({ role: 'user', content: msg.content });
-      } else if (msg.role === 'assistant') {
-        const entry = { role: 'assistant' };
-        // Some OpenAI-compatible APIs require `content: null` when tool_calls are present
-        entry.content = msg.content || null;
-        if (msg.toolCalls && msg.toolCalls.length > 0) {
-          entry.tool_calls = msg.toolCalls.map(tc => ({
-            id: tc.id,
-            type: 'function',
-            function: {
-              name: tc.name,
-              arguments: JSON.stringify(tc.input),
-            },
-          }));
-        }
-        result.push(entry);
-      } else if (msg.role === 'tool') {
-        result.push({
-          role: 'tool',
-          tool_call_id: msg.toolCallId,
-          content: msg.content,
-        });
-      }
-    }
-    return result;
-  }
-
-  /**
-   * Classify HTTP errors.
-   * @param {number} status
-   * @param {string} body
-   */
-  #classifyError(status, body) {
-    if (status === 401 || status === 403) {
-      return new LLMAuthError(`Auth error: ${body}`, status);
-    }
-    if (status === 429) {
-      return new LLMRateLimitError(`Rate limit: ${body}`, status);
-    }
-    if (status === 529) {
-      return new LLMRateLimitError(`Overloaded: ${body}`, status);
-    }
-    if (status === 413 || body.includes('context_length_exceeded') || body.includes('maximum context length')) {
-      return new LLMContextError(`Context too long: ${body}`);
-    }
-    if (status >= 500) {
-      return new LLMServerError(`Server error: ${body}`, status);
-    }
-    return new Error(`API error ${status}: ${body}`);
-  }
-
-  /**
-   * Map Chat Completions finish_reason → unified stop reason.
-   * @param {string|null} reason
-   * @returns {'end_turn' | 'tool_use' | 'max_tokens'}
-   */
-  #mapFinishReason(reason) {
-    switch (reason) {
-      case 'tool_calls': return 'tool_use';
-      case 'stop': return 'end_turn';
-      case 'length': return 'max_tokens';
-      default: return 'end_turn';
-    }
-  }
-
-  /**
-   * @param {{ model: string, system: string, messages: import('./adapter.js').UnifiedMessage[], tools?: import('./adapter.js').UnifiedToolDef[], maxTokens?: number, effort?: 'low'|'medium'|'high'|'max', extraBody?: object, signal?: AbortSignal }} params
-   * @returns {AsyncGenerator<import('./adapter.js').StreamEvent>}
-   */
-  async *stream({ model, system, messages, tools, maxTokens = 16384, effort, extraBody, signal, onRawExchange }) {
-    if (signal?.aborted) throw new LLMAbortError();
-
-    const body = {
-      model,
-      messages: this.#translateMessages(system, messages),
-      ...this.#maxTokensBody(model, maxTokens),
-      stream: true,
-      stream_options: { include_usage: true },
-    };
-
-    // task-327a: inject OpenAI reasoning.effort when feature flag on, effort is
-    // valid, and model's registry entry flags openai-reasoning protocol.
-    // 'max' downgrades to 'high' (OpenAI has no 'max' enum). Unknown / unsupported
-    // models silently drop the parameter.
-    const normEffort = normalizeEffort(effort);
-    if (thinkingV1Enabled() && normEffort) {
-      const cap = getThinkingCapability(model);
-      if (cap.supportsThinking && cap.thinkingProtocol === 'openai-reasoning') {
-        const reasoningEffort = mapEffortToOpenAIReasoning(normEffort);
-        if (reasoningEffort) {
-          body.reasoning = { effort: reasoningEffort };
-        }
-      }
-    }
-
-    const translatedTools = this.#translateTools(tools);
-    if (translatedTools) body.tools = translatedTools;
-
-    // extraBody allows callers to pass through any additional/override parameters
-    if (extraBody) Object.assign(body, extraBody);
-
-    const url = `${this.#baseUrl}/chat/completions`;
-    const headers = {
-      'Content-Type': 'application/json',
-      'Authorization': `Bearer ${this.#apiKey}`,
-    };
-
-    // task-344: expose raw request (redacted) for debug panel.
-    // task-344 follow-up (N2): cap body size.
-    const rawRequest = capRawRequest(redactRawRequest({ url, method: 'POST', headers, body }));
-
-    const response = await fetch(url, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify(body),
-      signal,
-    });
-
-    if (!response.ok) {
-      const errorBody = await response.text();
-      if (onRawExchange) {
-        try {
-          onRawExchange({
-            rawRequest,
-            rawResponse: {
-              status: response.status,
-              headers: response.headers && typeof response.headers.entries === 'function'
-                ? Object.fromEntries(response.headers.entries())
-                : {},
-              // task-344 follow-up (N2): cap error body.
-              body: capRawString(errorBody),
-            },
-          });
-        } catch { /* ignore */ }
-      }
-      throw this.#classifyError(response.status, errorBody);
-    }
-
-    // Parse SSE stream
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = '';
-    // task-344: accumulate raw SSE body + headers/status for debug exposure.
-    // task-344 follow-up (N2): cap growth at RAW_PAYLOAD_CAP_BYTES.
-    let rawSseBody = '';
-    let rawSseTotalBytes = 0;
-    let rawSseCapped = false;
-    const responseHeaders = response.headers && typeof response.headers.entries === 'function'
-      ? Object.fromEntries(response.headers.entries())
-      : {};
-    const responseStatus = response.status;
-
-    // Tool call accumulation — Chat Completions sends tool args as fragments
-    // keyed by index within the delta.tool_calls array
-    /** @type {Map<number, { id: string, name: string, arguments: string }>} */
-    const toolCallAccum = new Map();
-
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-
-        const chunkText = decoder.decode(value, { stream: true });
-        buffer += chunkText;
-        // task-344 follow-up (N2): size-capped capture.
-        rawSseTotalBytes += value.byteLength;
-        if (!rawSseCapped) {
-          if (rawSseTotalBytes <= RAW_PAYLOAD_CAP_BYTES) {
-            rawSseBody += chunkText;
-          } else {
-            const remaining = RAW_PAYLOAD_CAP_BYTES - (rawSseTotalBytes - value.byteLength);
-            if (remaining > 0) {
-              rawSseBody += chunkText.slice(0, remaining);
-            }
-            rawSseCapped = true;
-          }
-        }
-        const lines = buffer.split('\n');
-        buffer = lines.pop() || '';
-
-        for (const line of lines) {
-          if (!line.startsWith('data: ')) continue;
-          const data = line.slice(6).trim();
-          if (data === '[DONE]') continue;
-
-          let chunk;
-          try {
-            chunk = JSON.parse(data);
-          } catch {
-            continue;
-          }
-
-          // Usage (from stream_options: include_usage)
-          if (chunk.usage) {
-            yield {
-              type: 'usage',
-              inputTokens: chunk.usage.prompt_tokens || 0,
-              outputTokens: chunk.usage.completion_tokens || 0,
-              cacheReadTokens: chunk.usage.prompt_tokens_details?.cached_tokens || 0,
-              cacheWriteTokens: 0,
-            };
-          }
-
-          const choice = chunk.choices?.[0];
-          if (!choice) continue;
-
-          const delta = choice.delta;
-          if (!delta) continue;
-
-          // Text content
-          if (delta.content) {
-            yield { type: 'text_delta', text: delta.content };
-          }
-
-          // Tool calls (streamed as fragments)
-          if (delta.tool_calls) {
-            for (const tc of delta.tool_calls) {
-              const idx = tc.index;
-              if (!toolCallAccum.has(idx)) {
-                toolCallAccum.set(idx, {
-                  id: tc.id || '',
-                  name: tc.function?.name || '',
-                  arguments: '',
-                });
-              }
-              const accum = toolCallAccum.get(idx);
-              if (tc.id) accum.id = tc.id;
-              if (tc.function?.name) accum.name = tc.function.name;
-              if (tc.function?.arguments) accum.arguments += tc.function.arguments;
-            }
-          }
-
-          // Finish reason
-          if (choice.finish_reason) {
-            // Emit accumulated tool calls before stop
-            for (const [, accum] of toolCallAccum) {
-              let parsedInput = {};
-              try {
-                parsedInput = accum.arguments ? JSON.parse(accum.arguments) : {};
-              } catch {
-                parsedInput = {};
-              }
-              yield {
-                type: 'tool_call',
-                id: accum.id,
-                name: accum.name,
-                input: parsedInput,
-              };
-            }
-            toolCallAccum.clear();
-
-            yield {
-              type: 'stop',
-              stopReason: this.#mapFinishReason(choice.finish_reason),
-            };
-          }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-      // task-344: emit raw exchange after stream completes.
-      if (onRawExchange) {
-        try {
-          // task-344 follow-up (N2): append truncation marker when capped.
-          const finalBody = rawSseCapped
-            ? `${rawSseBody}…[truncated, original ${rawSseTotalBytes} bytes]`
-            : rawSseBody;
-          onRawExchange({
-            rawRequest,
-            rawResponse: {
-              status: responseStatus,
-              headers: responseHeaders,
-              body: finalBody,
-              format: 'sse',
-            },
-          });
-        } catch { /* ignore */ }
-      }
-    }
-  }
-
-  /**
-   * Non-streaming call for side queries.
-   *
-   * task-327c: accepts `effort` for internal scenario-tagged calls
-   * (consolidate/dream/recall/light). Feature-flag + capability guards
-   * mirror stream() exactly; unsupported models silently drop the param.
-   */
-  async call({ model, system, messages, maxTokens = 4096, effort, extraBody, signal }) {
-    if (signal?.aborted) throw new LLMAbortError();
-
-    const body = {
-      model,
-      messages: this.#translateMessages(system, messages),
-      ...this.#maxTokensBody(model, maxTokens),
-    };
-
-    // task-327c: mirror stream()'s reasoning.effort injection for side queries.
-    const normEffort = normalizeEffort(effort);
-    if (thinkingV1Enabled() && normEffort) {
-      const cap = getThinkingCapability(model);
-      if (cap.supportsThinking && cap.thinkingProtocol === 'openai-reasoning') {
-        const reasoningEffort = mapEffortToOpenAIReasoning(normEffort);
-        if (reasoningEffort) {
-          body.reasoning = { effort: reasoningEffort };
-        }
-      }
-    }
-
-    // extraBody allows callers to pass through any additional/override parameters
-    if (extraBody) Object.assign(body, extraBody);
-
-    const response = await fetch(`${this.#baseUrl}/chat/completions`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${this.#apiKey}`,
-      },
-      body: JSON.stringify(body),
-      signal,
-    });
-
-    if (!response.ok) {
-      const errorBody = await response.text();
-      throw this.#classifyError(response.status, errorBody);
-    }
-
-    const result = await response.json();
-    const text = result.choices?.[0]?.message?.content || '';
-
-    return {
-      text,
-      usage: {
-        inputTokens: result.usage?.prompt_tokens || 0,
-        outputTokens: result.usage?.completion_tokens || 0,
-      },
-    };
-  }
-}