@yeaft/webchat-agent 0.1.597 → 0.1.599

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.597",
+  "version": "0.1.599",
   "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,19 @@
  */
 
 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';
+import { resolveThinking } from './router/thinking.js';
 
 /**
  * task-324 — Turn cap removed.
@@ -288,16 +291,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 +352,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 +361,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 +566,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 +617,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 +635,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 +674,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 = [
@@ -682,13 +744,40 @@ export class Engine {
       try {
         // task-327b: resolve effort per-turn so the long-loop auto-bump
         // kicks in once toolLoopTurns crosses the threshold.
-        const resolvedEffort = pickEffort({ scenario, toolLoopTurns, userEffort });
+        let resolvedEffort = pickEffort({ scenario, toolLoopTurns, userEffort });
+
+        // DESIGN.md §9.16: thinking-mode precedence chain. When a VP
+        // persona is active, the router/continuity bookkeeping has more
+        // signal than the raw scenario tag — the prior assistant turn's
+        // routerPlan, the VP's role default, and the global config all
+        // outrank the scenario picker for `'high'|'max'`. UI/userEffort
+        // is already honoured by pickEffort (highest precedence).
+        if (vpPersona && vpPersona.vpId) {
+          const priorPlan = extractPriorPlan(conversationMessages, vpPersona.vpId);
+          const thinkingCfg = (this.#config && this.#config.thinking) || {};
+          const resolved = resolveThinking({
+            uiOverride: (userEffort === 'max' || userEffort === 'high') ? userEffort : null,
+            routerPlan: null, // PR-C scope: priorPlan continuity only;
+                              // live router-plan thinking is a follow-up.
+            priorPlan: priorPlan && priorPlan.thinking ? priorPlan.thinking : null,
+            vpDefault: typeof vpPersona.thinking === 'string' ? vpPersona.thinking : null,
+            globalDefault: typeof thinkingCfg.default === 'string' ? thinkingCfg.default : null,
+            allowRouterEscalate: thinkingCfg.allowRouterEscalate !== false,
+          });
+          // Only adopt the chain's choice when it strengthens the
+          // baseline. We never weaken below pickEffort (e.g. consolidate
+          // = 'max' must not be downgraded to 'high' just because the VP
+          // default is 'high').
+          if (resolved.value === 'max' || (resolved.value === 'high' && resolvedEffort === 'low')) {
+            resolvedEffort = resolved.value;
+          }
+        }
 
         // Stream from adapter
         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 +926,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/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',