@yeaft/webchat-agent 0.1.752 → 0.1.754

package/package.json

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

package/unify/compact/compactor.js

@@ -62,12 +62,17 @@ export class Compactor {
    *        treats that as a soft failure).
    * @param {() => number|undefined} [opts.getMaxContextTokens]
    *        Returns `config.maxContextTokens` for `shouldCompactHistory`.
+   * @param {() => string|undefined} [opts.getLanguage]
+   *        Returns the live `config.language`. Threaded into
+   *        `compactHistory` so the compactor's summary prompt + the
+   *        "session continued" wrapper render in the user's preferred
+   *        locale instead of always English.
    * @param {(groupId: string, result: CompactedResult) => void} [opts.onCompacted]
    *        Optional sink. Bridge wires this to send the
    *        `unify_history_compacted` WS event. Default: no-op. Can be
    *        replaced post-construction via `setOnCompacted`.
    */
-  constructor({ summarize, getMaxContextTokens, onCompacted } = {}) {
+  constructor({ summarize, getMaxContextTokens, getLanguage, onCompacted } = {}) {
     if (typeof summarize !== 'function') {
       throw new TypeError('Compactor: summarize is required');
     }
@@ -75,6 +80,9 @@ export class Compactor {
     this._getMaxContextTokens = typeof getMaxContextTokens === 'function'
       ? getMaxContextTokens
       : () => undefined;
+    this._getLanguage = typeof getLanguage === 'function'
+      ? getLanguage
+      : () => undefined;
     this._onCompacted = typeof onCompacted === 'function' ? onCompacted : () => {};
     /** @type {Map<string, { inFlight: Promise<void>|null, pending: boolean }>} */
     this._states = new Map();
@@ -186,7 +194,11 @@ export class Compactor {
       const summarize = ({ system, prompt }) =>
         this._summarize({ system, prompt, maxTokens: SUMMARIZER_MAX_TOKENS });
 
-      const result = await compactHistory(snapshot, { summarize, maxContextTokens });
+      const result = await compactHistory(snapshot, {
+        summarize,
+        maxContextTokens,
+        language: this._getLanguage(),
+      });
       if (!result || !result.compacted) {
         if (result && result.error) {
           console.warn(

package/unify/dream-v2/runner.js

@@ -44,7 +44,7 @@ import { listScopes, readSummary } from '../memory/store-v2.js';
 import {
   DEFAULT_LIMITS,
 } from './limits.js';
-import { readGroupState, writeGroupState } from './state.js';
+import { readGroupState, writeGroupState, writeDreamError } from './state.js';
 import { segmentDiff, truncateMessage, estimateMessagesTokens } from './segment.js';
 import { triageGroupSegments } from './triage.js';
 import { mergeByTarget } from './merge.js';
@@ -148,6 +148,14 @@ export async function runDream(opts) {
     } catch (err) {
       groupsReport.push({ groupId, new: newCount, status: 'error', error: err.message });
       onProgress({ phase: 'triage', groupId, status: 'error', error: err.message });
+      // Journal the failure on disk so operators can see WHY dream is
+      // not advancing without having to enable `config.debug`. Best-
+      // effort — `writeDreamError` swallows its own I/O errors.
+      await writeDreamError(opts.root, `group/${groupId}`, {
+        phase: 'triage',
+        message: err.message,
+        stack: err.stack,
+      });
       continue;
     }
 
@@ -191,6 +199,14 @@ export async function runDream(opts) {
         error: err.message,
       });
       onProgress({ phase: 'apply', target: merged.target, status: 'error', error: err.message });
+      // Journal apply-stage failures into the target scope's directory
+      // (`<root>/<merged.target>/.dream-last-error.json`). Same rationale
+      // as the triage catch above.
+      await writeDreamError(opts.root, merged.target, {
+        phase: 'apply',
+        message: err.message,
+        stack: err.stack,
+      });
     }
   }
 

package/unify/dream-v2/state.js

@@ -1,7 +1,7 @@
 /**
  * dream-v2/state.js.
  *
- * Two pieces of state, tracked separately:
+ * Three pieces of state, tracked separately:
  *
  *   1. Per-group control state (used to decide whether a group enters
  *      triage and how far to advance the cursor):
@@ -31,13 +31,25 @@
  *      control-flow decision. We update it by replacing the existing
  *      block (if any) or appending a new one to the end of the file.
  *
- * Both helpers are pure I/O; no LLM, no logic beyond parsing.
+ *   3. Per-scope dream-error sink (added v0.1.754):
+ *
+ *        ~/.yeaft/memory/<scope>/.dream-last-error.json
+ *
+ *      Most-recent-wins JSON written unconditionally on every triage
+ *      or apply failure (best-effort — never throws even when the I/O
+ *      itself fails). The runner used to swallow these exceptions and
+ *      the only sink was a `config.debug`-gated console.log; this file
+ *      gives operators on-disk evidence regardless of debug. See
+ *      `writeDreamError` / `readDreamError` below for the contract.
+ *
+ * All helpers are pure I/O; no LLM, no logic beyond parsing.
  */
 
 import { promises as fsp, existsSync } from 'fs';
 import { join, dirname } from 'path';
 
 const STATE_FILE = '.dream-state';
+const ERROR_FILE = '.dream-last-error.json';
 const DREAM_BLOCK_OPEN = '<!-- dream-state -->';
 const DREAM_BLOCK_CLOSE = '<!-- /dream-state -->';
 
@@ -101,6 +113,95 @@ function parseGroupState(raw) {
   return out;
 }
 
+// ─── per-scope dream error sink ────────────────────────────────
+//
+// Why: dream-v2 silently swallowed exceptions at the triage / apply
+// catch sites — the only sink was `trace.event('dream_progress', evt)`
+// and a `config.debug`-gated `console.log` in `session-wiring.js`. With
+// `debug=false` (the default), there was no on-disk evidence that a
+// dream pass had ever failed: no `.dream-state` (because we only write
+// it on success), no log file, nothing. The Resident layer's continued
+// regurgitation of the bootstrap seed was the only symptom.
+//
+// `writeDreamError` writes `<memoryRoot>/<scope>/.dream-last-error.json`
+// unconditionally on every catch (best-effort — write failures must not
+// shadow the original error). Operators can then `ls ~/.yeaft/memory/
+// group/<id>/` and see what blew up, without having to re-enable debug.
+
+/**
+ * Resolve a memoryRoot + scope-string to the scope directory.
+ * The scope string is the same shape dream-v2 already uses internally:
+ * `'user'`, `'vp/<vpId>'`, `'group/<groupId>'`, `'feature/<id>'`, etc.
+ *
+ * Pure path-join; does NOT create the directory. The writer creates it.
+ *
+ * @param {string} root
+ * @param {string} scope
+ * @returns {string}
+ */
+export function scopeDirFor(root, scope) {
+  // Defensive: trim leading/trailing slashes so callers can pass either
+  // `'group/grp_fun'` or `/group/grp_fun/` — both land on the same dir.
+  const clean = String(scope || '').replace(/^\/+|\/+$/g, '');
+  return join(root, clean);
+}
+
+/**
+ * Best-effort write of the dream-error sink. Never throws — a failed
+ * write is silently swallowed because the caller is already in an
+ * error-handling path and we must not mask the original failure.
+ *
+ * @param {string} root         — memory root, e.g. ~/.yeaft/memory
+ * @param {string} scope        — `'group/<id>'` for triage failures,
+ *                                `merged.target` for apply failures.
+ * @param {{ phase: string, message: string, stack?: string|null, at?: string }} info
+ * @returns {Promise<void>}
+ */
+export async function writeDreamError(root, scope, info) {
+  try {
+    const dir = scopeDirFor(root, scope);
+    await fsp.mkdir(dir, { recursive: true });
+    const abs = join(dir, ERROR_FILE);
+    const at = (info && info.at) || new Date().toISOString();
+    // Trim stack to the first 5 frames — enough for diagnosis, small
+    // enough that the artifact stays human-readable. Missing/empty
+    // stack collapses to `null` rather than `""` so the artifact is
+    // cleaner for operators.
+    const rawStack = info && typeof info.stack === 'string' ? info.stack : '';
+    const stackLines = rawStack ? rawStack.split('\n').slice(0, 5) : [];
+    const body = JSON.stringify({
+      at,
+      scope,
+      phase: String(info?.phase || 'unknown'),
+      message: String(info?.message || ''),
+      stack: stackLines.length > 0 ? stackLines.join('\n') : null,
+    }, null, 2) + '\n';
+    await atomicWrite(abs, body);
+  } catch {
+    // Best-effort: swallow. The caller is already handling the real
+    // error; an inability to journal it must not shadow that.
+  }
+}
+
+/**
+ * Read the last dream error JSON for a scope, or null if absent. Used
+ * by the debug panel and by tests. Tolerates a malformed file by
+ * returning `{ raw: <body>, parseError: <message> }` instead of
+ * throwing.
+ *
+ * @param {string} root
+ * @param {string} scope
+ * @returns {Promise<object|null>}
+ */
+export async function readDreamError(root, scope) {
+  const abs = join(scopeDirFor(root, scope), ERROR_FILE);
+  let raw;
+  try { raw = await fsp.readFile(abs, 'utf8'); }
+  catch (err) { if (err && err.code === 'ENOENT') return null; throw err; }
+  try { return JSON.parse(raw); }
+  catch (e) { return { raw, parseError: e.message }; }
+}
+
 // ─── per-scope marker (memory.md tail block) ───────────────────
 
 /**

package/unify/engine.js

@@ -975,13 +975,23 @@ export class Engine {
 
     const archiveIds = [];
 
+    // Language-aware summarizer prompts. The orchestrator-track summary
+    // ends up in the system prompt as a "previous conversation summary"
+    // block, so it needs to match the user's preferred language to avoid
+    // a jarring locale flip mid-context.
+    const isZh = String(this.#config.language || '').toLowerCase().startsWith('zh');
+    const summariserSystem = isZh
+      ? '你是对话摘要器。请用中文写出 2–3 段简明摘要，保留决策、事实与上下文。'
+      : 'You are a conversation summarizer. Summarize concisely in 2–3 paragraphs, preserving decisions, facts, and context.';
+    const summariserPromptPrefix = isZh ? '请概括：\n\n' : 'Summarize:\n\n';
+
     const hooks = {
       summarise: async () => {
         try {
           const result = await adapter.call({
             model: fastConfig.model,
-            system: 'You are a conversation summarizer. Summarize concisely in 2–3 paragraphs, preserving decisions, facts, and context.',
-            messages: [{ role: 'user', content: `Summarize:\n\n${toArchive.map(m => `[${m.role}] ${(m.content || '').slice(0, 500)}`).join('\n\n')}` }],
+            system: summariserSystem,
+            messages: [{ role: 'user', content: `${summariserPromptPrefix}${toArchive.map(m => `[${m.role}] ${(m.content || '').slice(0, 500)}`).join('\n\n')}` }],
             maxTokens: 1024,
           });
           return (result.text || '').trim();

package/unify/history-compact.js

@@ -328,16 +328,22 @@ export function findCutIndex(messages, keepRecent) {
  * `server/db/message-db.js`) recognise it.
  *
  * @param {string} summary
+ * @param {{ language?: string }} [opts]
  * @returns {{role:'user', content:string, _compactSummary: true}}
  */
-export function wrapSummaryAsUserMessage(summary) {
+export function wrapSummaryAsUserMessage(summary, opts = {}) {
   const body = (summary || '').trim() || '(no summary produced)';
-  const content =
-    'This session is being continued from a previous conversation. ' +
-    'The earlier context has been summarized for efficiency.\n\n' +
-    'Summary of conversation so far:\n' +
-    body +
-    '\n\nContinue the conversation from where it left off without asking the user any further questions.';
+  const isZh = String(opts.language || '').toLowerCase().startsWith('zh');
+  const content = isZh
+    ? '本会话延续自之前的对话。早期上下文已经被概括以节省空间。\n\n' +
+      '至此为止的对话摘要：\n' +
+      body +
+      '\n\n请从中断处继续对话，不要再向用户重复确认。'
+    : 'This session is being continued from a previous conversation. ' +
+      'The earlier context has been summarized for efficiency.\n\n' +
+      'Summary of conversation so far:\n' +
+      body +
+      '\n\nContinue the conversation from where it left off without asking the user any further questions.';
   return {
     role: 'user',
     content,
@@ -349,24 +355,36 @@ export function wrapSummaryAsUserMessage(summary) {
  * Build the prompt fed to the fast-model summarizer. Kept in code (not in
  * a template file) because it's small and lives alongside the call site.
  *
+ * The summarizer prompt itself is language-aware: callers pass the live
+ * `config.language` so the produced summary is written in the user's
+ * preferred language. JSON-style structural cues stay English so the
+ * summary remains easy to splice into the next turn regardless of locale.
+ *
  * @param {Array<{role:string, content:string}>} cleanedMessages
+ * @param {{ language?: string }} [opts]
  * @returns {{system: string, prompt: string}}
  */
-export function buildSummaryPrompt(cleanedMessages) {
+export function buildSummaryPrompt(cleanedMessages, opts = {}) {
   const transcript = cleanedMessages
     .map(m => `[${m.role}]\n${m.content}`)
     .join('\n\n---\n\n');
-  const system =
-    'You are a conversation summarizer for a multi-agent group chat. ' +
-    'Produce a concise (4–8 short bullet points) summary of the conversation ' +
-    'so far. Preserve: (1) decisions made, (2) facts learned, (3) the user\'s ' +
-    'current goal, (4) any open questions or pending actions, (5) which VPs ' +
-    'are participating and what each contributed. Do NOT include raw tool ' +
-    'output. Do NOT speculate. Be specific.';
-  const prompt =
-    'Summarize the following conversation. Output ONLY the summary, no ' +
-    'preamble.\n\n' +
-    transcript;
+  const isZh = String(opts.language || '').toLowerCase().startsWith('zh');
+  const system = isZh
+    ? '你是多 agent 群聊的对话摘要器。请用中文写出 4–8 条简明 bullet 摘要。' +
+      '保留：(1) 已做的决策，(2) 已学到的事实，(3) 用户当前目标，' +
+      '(4) 任何未解决的问题或待办事项，(5) 哪些 VP 参与了对话以及各自贡献。' +
+      '不要包含原始工具输出。不要臆测。要具体。'
+    : 'You are a conversation summarizer for a multi-agent group chat. ' +
+      'Produce a concise (4–8 short bullet points) summary of the conversation ' +
+      'so far. Preserve: (1) decisions made, (2) facts learned, (3) the user\'s ' +
+      'current goal, (4) any open questions or pending actions, (5) which VPs ' +
+      'are participating and what each contributed. Do NOT include raw tool ' +
+      'output. Do NOT speculate. Be specific.';
+  const prompt = isZh
+    ? '请概括下面的对话。只输出摘要正文，不要前言。\n\n' + transcript
+    : 'Summarize the following conversation. Output ONLY the summary, no ' +
+      'preamble.\n\n' +
+      transcript;
   return { system, prompt };
 }
 
@@ -384,6 +402,7 @@ export function buildSummaryPrompt(cleanedMessages) {
  *   maxContextTokens?: number,
  *   tokenFraction?: number,
  *   hardTokenCeiling?: number,
+ *   language?: string,
  * }} options
  * @returns {Promise<{
  *   messages: Array<object>,
@@ -407,6 +426,7 @@ export async function compactHistory(messages, options) {
     maxContextTokens,
     tokenFraction,
     hardTokenCeiling,
+    language,
   } = options || {};
 
   if (typeof summarize !== 'function') {
@@ -460,7 +480,7 @@ export async function compactHistory(messages, options) {
 
   let summaryText = '';
   if (cleaned.length > 0) {
-    const { system, prompt } = buildSummaryPrompt(cleaned);
+    const { system, prompt } = buildSummaryPrompt(cleaned, { language });
     try {
       summaryText = (await summarize({ system, prompt })) || '';
     } catch (err) {
@@ -498,7 +518,7 @@ export async function compactHistory(messages, options) {
     }
   }
 
-  const summaryMsg = wrapSummaryAsUserMessage(summaryText);
+  const summaryMsg = wrapSummaryAsUserMessage(summaryText, { language });
 
   // Defensive pair-sanitize: the cut at `cutIdx` lands at a user-message
   // boundary so an `[assistant(toolCalls), tool…]` arc is not split, but

package/unify/session.js

@@ -315,6 +315,13 @@ export async function loadSession(options = {}) {
       engine.summarizeForCompact({ system, prompt, maxTokens }),
     getMaxContextTokens: () =>
       typeof config.maxContextTokens === 'number' ? config.maxContextTokens : undefined,
+    // Live-read: `config.language` is mutated in place by
+    // `engine.setLanguage()` (which broadcastLanguageChange fans out to
+    // every per-VP engine). The compactor must see the post-broadcast
+    // value, not a boot-time snapshot, so the summary prompt + the
+    // "session continued" wrapper render in the user's current locale.
+    getLanguage: () =>
+      typeof config.language === 'string' ? config.language : undefined,
   });
 
   // ─── 9a. Create dream scheduler ────────────

package/unify/tools/registry.js

@@ -61,16 +61,44 @@ function localizeVisibleText(value, language, toolName) {
   ].join('\n');
 }
 
+/**
+ * Walk a JSON Schema `parameters` object and localize the human-readable
+ * `description` strings to the requested language. All other schema bits
+ * (`type`, `enum`, `required`, `items`, nested `properties`, etc.) are
+ * preserved by value.
+ *
+ * Critical correctness rule: a JSON Schema can have a *property named*
+ * `description` whose value is itself a sub-schema (e.g.
+ * `properties: { description: { type: 'string', description: 'Detailed...' }}`).
+ * In that case the OUTER `description` key holds the sub-schema and must
+ * be recursed into; only the INNER `description: 'Detailed...'` value
+ * (which is a string) should be localized.
+ *
+ * Previous bug: this walker localized ANY value under a `description`
+ * key, including sub-schema objects. `localizeVisibleText` then ran
+ * `String(value)` on the object, producing the literal string
+ * `'[object Object]'`. GPT-5's strict schema validator rejected the
+ * resulting `{ description: '[object Object]' }` with
+ * `"'[object Object]' is not of type 'object', 'boolean'"`. This made
+ * FeatureCreate (and any tool whose schema contains a property named
+ * `description`) unusable in zh locale on strict providers.
+ *
+ * The fix: only treat a `description` value as localizable text when it
+ * is actually a string. Object/array values under a `description` key
+ * are sub-schemas and must be recursed into normally.
+ */
 function localizeParameters(parameters, language, toolName) {
   const lang = normalizeLanguage(language);
   if (lang !== 'zh' || !parameters || typeof parameters !== 'object') return parameters;
   if (Array.isArray(parameters)) return parameters.map(v => localizeParameters(v, lang, toolName));
   const out = {};
   for (const [key, value] of Object.entries(parameters)) {
-    if (key === 'description') {
+    if (key === 'description' && typeof value === 'string') {
       out[key] = localizeVisibleText(value, lang, toolName);
-    } else {
+    } else if (value && typeof value === 'object') {
       out[key] = localizeParameters(value, lang, toolName);
+    } else {
+      out[key] = value;
     }
   }
   return out;

package/unify/web-bridge.js

@@ -2418,28 +2418,55 @@ export function __testGetRegisteredThreadIds() {
 export const __testRaceWithEscalation = raceWithEscalation;
 
 /**
- * Manual dream trigger from VP detail page.
+ * Manual dream trigger.
+ *
+ * Two call shapes, both routed through this single handler:
+ *
+ *   { type: 'unify_dream_trigger', vpId }     — per-VP trigger (legacy
+ *     VP-detail page button). Fires an unscoped dream pass; the result
+ *     event is tagged with `vpId` so the per-VP store row updates.
+ *
+ *   { type: 'unify_dream_trigger', groupId }  — per-GROUP trigger (new
+ *     in v0.1.754 — added so users can manually kick dream for a group
+ *     after seeing the Resident layer stuck on the bootstrap seed).
+ *     Fires a scope-filtered pass via `triggerDreamForScopes(['group/X'])`
+ *     so unrelated groups don't get processed; the result event is
+ *     tagged with `groupId` for the per-group UI row.
+ *
+ * Backwards-compat: when neither field is set, defaults to `vpId='default'`
+ * which matches the pre-v0.1.754 behavior.
  */
 export async function handleUnifyDreamTrigger(msg = {}) {
+  // Resolve tag up-front so EVERY outbound envelope (including the
+  // scheduler-uninitialised early-return below) carries `groupId` /
+  // `vpId`. Without this the frontend's `applyDreamResult` couldn't
+  // route the error event back to the right row and the per-group
+  // "Run dream now" button would stay stuck on "Running…" forever
+  // (review feedback from PR #757).
+  const groupId = typeof msg.groupId === 'string' && msg.groupId ? msg.groupId : null;
+  const vpId = !groupId ? (msg.vpId || 'default') : null;
+  const tag = groupId ? { groupId } : { vpId };
+
   if (!session?.dreamScheduler) {
     sendToServer({
       type: 'unify_dream_result',
+      ...tag,
       success: false,
       error: 'Dream scheduler not initialized — session not loaded.',
     });
     return;
   }
 
-  const vpId = msg.vpId || 'default';
-
   try {
     sendToServer({
       type: 'unify_dream_status',
-      vpId,
+      ...tag,
       status: 'running',
     });
 
-    const result = await session.dreamScheduler.triggerDreamNow();
+    const result = groupId
+      ? await session.dreamScheduler.triggerDreamForScopes([`group/${groupId}`])
+      : await session.dreamScheduler.triggerDreamNow();
 
     // fix/dream-cadence-and-ui-trigger: derive a single "entries
     // created" count for the UI bubble. The runner returns a richer
@@ -2457,7 +2484,7 @@ export async function handleUnifyDreamTrigger(msg = {}) {
     // PR #743.
     sendToServer({
       type: 'unify_dream_result',
-      vpId,
+      ...tag,
       ...result,
       success: !result.error && !result.skipped,
       entriesCreated,
@@ -2466,7 +2493,7 @@ export async function handleUnifyDreamTrigger(msg = {}) {
   } catch (err) {
     sendToServer({
       type: 'unify_dream_result',
-      vpId,
+      ...tag,
       success: false,
       error: err?.message || String(err),
     });