@yeaft/webchat-agent 0.1.778 → 0.1.780

package/package.json

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

package/unify/dream-v2/apply.js

@@ -163,7 +163,7 @@ export async function applyMergedTarget(merged, opts) {
   await snapFn(opts.root, ts, scopeDirRel);
 
   let memoryMd = await readMemory(scope, { root: opts.root });
-  let summaryMd = await readSummary(scope, { root: opts.root });
+  let summaryMd = await readSummary(scope, { root: opts.root, language: opts.language });
 
   if (merged.kind === 'create' && (memoryMd || summaryMd)) {
     // Race / partial state: the scope already exists. Treat as update —
@@ -226,7 +226,7 @@ export async function applyMergedTarget(merged, opts) {
   // Stamp the per-scope dream marker, then atomically write both files.
   const stamped = withDreamMarker(memoryMd, { lastDreamAt: nowIso });
   await writeMemory(scope, stamped, { root: opts.root });
-  await writeSummary(scope, summaryMd || '', { root: opts.root });
+  await writeSummary(scope, summaryMd || '', { root: opts.root, language: opts.language });
 
   if (opts.onProgress) opts.onProgress({ phase: 'apply', target: merged.target, status: 'done', batches: batchesUsed });
   return { target: merged.target, kind: merged.kind, batches: batchesUsed };

package/unify/dream-v2/runner.js

@@ -88,6 +88,7 @@ export async function runDream(opts) {
   // 1. enumerate groups
   const groupIds = await safeCall(opts.listGroups, []);
   const filter = Array.isArray(opts.scopeFilter) ? new Set(opts.scopeFilter) : null;
+  const groupFilter = deriveGroupFilter(filter);
   const groupsReport = [];
   const groupTriages = [];
   const processedGroups = [];
@@ -95,12 +96,18 @@ export async function runDream(opts) {
   // 2. per-group: skip / segment / triage
   const topicSummaries = opts.listTopicSummaries
     ? await safeCall(opts.listTopicSummaries, [])
-    : await defaultListTopicSummaries(opts.root).catch(() => []);
+    : await defaultListTopicSummaries(opts.root, opts.language).catch(() => []);
 
   for (const groupId of groupIds) {
-    // NOTE: scopeFilter is applied at the merge/apply stage, not here.
-    // A filter like ['user'] still requires triaging every group so their
-    // hard-rule actions can contribute to the user target.
+    // Current-group manual dream passes are the one case where scopeFilter
+    // must constrain enumeration too: clicking the conversation header means
+    // "dream this group now", not "triage every group and then only apply
+    // group/<id>". Pure target filters such as ['user'] still triage every
+    // group so their hard-rule actions can contribute to the requested scope.
+    if (groupFilter && !groupFilter.has(groupId)) {
+      groupsReport.push({ groupId, new: 0, status: 'skipped', reason: 'scope-filtered' });
+      continue;
+    }
     const state = await readGroupState(opts.root, groupId);
     const beforeCount = await safeCall(() => opts.countMessages(groupId), 0);
     const newCount = Math.max(0, beforeCount - (state.messageCount || 0));
@@ -170,7 +177,7 @@ export async function runDream(opts) {
   // 3. merge
   const mergedTargets = mergeByTarget(groupTriages);
   const targetsToApply = filter && filter.size > 0 && !filter.has('*')
-    ? mergedTargets.filter(t => filter.has(t.target))
+    ? mergedTargets.filter(t => filter.has(t.target) || filter.has(`group/${sourceGroupId(t)}`))
     : mergedTargets;
 
   onProgress({ phase: 'merge', targets: targetsToApply.length });
@@ -263,6 +270,22 @@ function lastMessageId(messages) {
   return null;
 }
 
+function deriveGroupFilter(filter) {
+  if (!filter || filter.size === 0 || filter.has('*')) return null;
+  const groups = [];
+  for (const scope of filter) {
+    if (typeof scope !== 'string') continue;
+    const m = /^group\/([^/]+)$/.exec(scope);
+    if (m && m[1]) groups.push(m[1]);
+  }
+  return groups.length > 0 ? new Set(groups) : null;
+}
+
+function sourceGroupId(mergedTarget) {
+  const src = Array.isArray(mergedTarget?.sources) ? mergedTarget.sources[0] : null;
+  return src && typeof src.groupId === 'string' ? src.groupId : '';
+}
+
 async function safeCall(fn, fallback) {
   try {
     if (typeof fn !== 'function') return fallback;
@@ -273,12 +296,12 @@ async function safeCall(fn, fallback) {
   }
 }
 
-async function defaultListTopicSummaries(root) {
+async function defaultListTopicSummaries(root, language) {
   const all = await listScopes({ root });
   const out = [];
   for (const sc of all) {
     if (sc.kind !== 'topic') continue;
-    const summary = await readSummary(sc, { root });
+    const summary = await readSummary(sc, { root, language });
     out.push({ path: sc.path.join('/'), summary });
   }
   return out;

package/unify/engine.js

@@ -216,6 +216,10 @@ export function buildResidentEntries(args) {
   return out;
 }
 
+function isZhRuntimeLanguage(language) {
+  return String(language || '').toLowerCase().startsWith('zh');
+}
+
 export class Engine {
   /** @type {import('./llm/adapter.js').LLMAdapter} */
   #adapter;
@@ -326,10 +330,12 @@ export class Engine {
    *   config: object,
    *   conversationStore?: import('./conversation/persist.js').ConversationStore,
    *   memoryIndex?: import('./memory/index-db.js').SegmentIndex,
+   *   amsRegistry?: object,
    *   toolRegistry?: import('./tools/registry.js').ToolRegistry,
    *   skillManager?: import('./skills.js').SkillManager,
    *   mcpManager?: import('./mcp.js').MCPManager,
    *   yeaftDir?: string,
+   *   toolStats?: import('./stats/tool-usage.js').ToolUsageStats,
    * }} params
    */
   constructor({ adapter, trace, config, conversationStore, memoryIndex, amsRegistry, toolRegistry, skillManager, mcpManager, yeaftDir, toolStats = null }) {
@@ -476,19 +482,19 @@ export class Engine {
    * dream tick (Phase 6) is what populates these; on a fresh install they
    * all return ''.
    *
-   * @param {{groupId?: string, vpId?: string}} ctx
+   * @param {{groupId?: string, vpId?: string, language?: string}} ctx
    * @returns {Promise<{user:string, group:string, vp:string}>}
    */
-  async #loadLayerASummaries({ groupId, vpId } = {}) {
+  async #loadLayerASummaries({ groupId, vpId, language } = {}) {
     if (!this.#yeaftDir) return { user: '', group: '', vp: '' };
     const memoryRoot = `${this.#yeaftDir}/memory`;
     const tasks = [
-      readScopeSummary({ kind: 'user' }, { root: memoryRoot }).catch(() => ''),
+      readScopeSummary({ kind: 'user' }, { root: memoryRoot, language }).catch(() => ''),
       groupId
-        ? readScopeSummary({ kind: 'group', id: groupId }, { root: memoryRoot }).catch(() => '')
+        ? readScopeSummary({ kind: 'group', id: groupId }, { root: memoryRoot, language }).catch(() => '')
         : Promise.resolve(''),
       vpId
-        ? readScopeSummary({ kind: 'vp', id: vpId }, { root: memoryRoot }).catch(() => '')
+        ? readScopeSummary({ kind: 'vp', id: vpId }, { root: memoryRoot, language }).catch(() => '')
         : Promise.resolve(''),
     ];
     const [user, group, vp] = await Promise.all(tasks);
@@ -542,7 +548,7 @@ export class Engine {
     ams.setOnDemand(segs);
 
     // (c) Snapshot — render the AMS layers as a single prompt block.
-    const snapshotBlock = this.#renderAmsSnapshot(ams);
+    const snapshotBlock = this.#renderAmsSnapshot(ams, this.#config.language || 'en');
 
     const scopes = buildRelevantScopes({
       groupId: args.groupId,
@@ -558,30 +564,35 @@ export class Engine {
    * so the LLM sees a consistent layout.
    *
    * @param {import('./memory/ams.js').ActiveMemorySet} ams
+   * @param {string} [language]
    * @returns {string}
    */
-  #renderAmsSnapshot(ams) {
+  #renderAmsSnapshot(ams, language = 'en') {
     const snap = ams.snapshot();
     if (!snap) return '';
     const parts = [];
     if (snap.resident.length === 0 && snap.recent.length === 0 && snap.onDemand.length === 0) {
       return '';
     }
-    parts.push('## Active Memory Set');
+    const zh = isZhRuntimeLanguage(language);
+    parts.push(zh ? '## 活跃记忆集' : '## Active Memory Set');
+    parts.push(zh
+      ? '以下记忆按当前用户语言呈现；如果个别历史摘要仍是其他语言，请只把它当作事实来源，回答和新增记忆应使用中文。'
+      : 'Memory is presented for the current user language; if an older summary is in another language, treat it as factual context and continue in English.');
     if (snap.resident.length > 0) {
-      parts.push('### Resident');
+      parts.push(zh ? '### 常驻记忆' : '### Resident');
       for (const r of snap.resident) {
         parts.push(`- **${r.scope}**: ${r.summary}`);
       }
     }
     if (snap.recent.length > 0) {
-      parts.push('### Recent');
+      parts.push(zh ? '### 最近记忆' : '### Recent');
       for (const s of snap.recent) {
         parts.push(`- (${s.scope}) ${(s.body || '').trim()}`);
       }
     }
     if (snap.onDemand.length > 0) {
-      parts.push('### OnDemand');
+      parts.push(zh ? '### 按需记忆' : '### OnDemand');
       for (const s of snap.onDemand) {
         parts.push(`- (${s.scope}) ${(s.body || '').trim()}`);
       }
@@ -772,6 +783,11 @@ export class Engine {
         parentVpPersona: vpCtx?.vpPersona || null,
         onEvent: this.#subAgentEventSink || null,
         language: this.#config?.language || 'en',
+        // Forward the session-shared ToolUsageStats so sub-agent
+        // engines record tool calls into the same on-disk snapshot
+        // (~/.yeaft/stats/tool-usage.json) the parent engine writes
+        // to. Null when the parent has no stats wired (e.g. tests).
+        toolStats: this.#toolStats || null,
       },
     };
   }
@@ -1133,6 +1149,7 @@ export class Engine {
       vpId: vpPersona && typeof vpPersona === 'object' && typeof vpPersona.vpId === 'string'
         ? vpPersona.vpId
         : (typeof senderVpId === 'string' ? senderVpId : undefined),
+      language: this.#config.language || 'en',
     });
 
     // ─── AMS: populate + snapshot ───────────────────────────────

package/unify/eval/runner.js

@@ -90,7 +90,11 @@ export async function runSingleEval(evalCase, { adapter, model, config = {} }) {
   const trace = new NullTrace();
   const engineConfig = { model, maxOutputTokens: 4096, ...config };
 
-  // Build engine — optionally with ToolRegistry
+  // Build engine — optionally with ToolRegistry. NOTE: intentionally
+  // no `toolStats` here. The eval runner is an offline scoring harness
+  // and must NOT pollute the user-facing `~/.yeaft/stats/tool-usage.json`
+  // snapshot (see PR #782 for the session-shared ToolUsageStats
+  // wiring on the runtime paths).
   const engineOpts = { adapter, trace, config: engineConfig };
 
   if (evalCase.registryTools) {

package/unify/memory/store-v2.js

@@ -197,7 +197,7 @@ async function atomicWrite(absPath, content) {
  * Read a scope's memory.md. Missing → empty string.
  *
  * @param {Scope} scope
- * @param {{ root?: string, currentVpId?: string }} [opts]
+ * @param {{ root?: string, currentVpId?: string, language?: string }} [opts]
  * @returns {Promise<string>}
  */
 export async function readMemory(scope, opts = {}) {
@@ -254,23 +254,38 @@ export async function appendMemory(scope, chunk, opts = {}) {
 
 // ─── summary.md ────────────────────────────────────────────────
 
+
+function summaryFileName(language) {
+  const normalized = String(language || '').toLowerCase().startsWith('zh') ? 'zh' : 'en';
+  return normalized === 'zh' ? 'summary.zh.md' : 'summary.md';
+}
+
+function summaryCandidateRels(scope, language) {
+  const dir = scopeDir(scope);
+  const primary = `${dir}/${summaryFileName(language)}`;
+  const fallback = `${dir}/summary.md`;
+  return primary === fallback ? [fallback] : [primary, fallback];
+}
+
 /**
  * Read a scope's summary.md (trimmed). Missing → empty string.
  *
  * @param {Scope} scope
- * @param {{ root?: string, currentVpId?: string }} [opts]
+ * @param {{ root?: string, currentVpId?: string, language?: string }} [opts]
  * @returns {Promise<string>}
  */
 export async function readSummary(scope, opts = {}) {
-  const { root = DEFAULT_MEMORY_ROOT, currentVpId } = opts;
-  const rel = `${scopeDir(scope)}/summary.md`;
-  enforceVpAcl(rel, currentVpId);
-  const abs = join(root, rel);
-  try { return (await fsp.readFile(abs, 'utf8')).trim(); }
-  catch (err) {
-    if (err && err.code === 'ENOENT') return '';
-    throw err;
+  const { root = DEFAULT_MEMORY_ROOT, currentVpId, language } = opts;
+  for (const rel of summaryCandidateRels(scope, language)) {
+    enforceVpAcl(rel, currentVpId);
+    const abs = join(root, rel);
+    try { return (await fsp.readFile(abs, 'utf8')).trim(); }
+    catch (err) {
+      if (err && err.code === 'ENOENT') continue;
+      throw err;
+    }
   }
+  return '';
 }
 
 /**
@@ -278,11 +293,11 @@ export async function readSummary(scope, opts = {}) {
  *
  * @param {Scope} scope
  * @param {string} body
- * @param {{ root?: string, currentVpId?: string }} [opts]
+ * @param {{ root?: string, currentVpId?: string, language?: string }} [opts]
  */
 export async function writeSummary(scope, body, opts = {}) {
-  const { root = DEFAULT_MEMORY_ROOT, currentVpId } = opts;
-  const rel = `${scopeDir(scope)}/summary.md`;
+  const { root = DEFAULT_MEMORY_ROOT, currentVpId, language } = opts;
+  const rel = `${scopeDir(scope)}/${summaryFileName(language)}`;
   enforceVpAcl(rel, currentVpId);
   const abs = join(root, rel);
   await atomicWrite(abs, `${(body || '').trim()}\n`);

package/unify/sub-agent/runner.js

@@ -86,6 +86,7 @@ export function isRestrictedToolName(name) {
  *   parentName?: string,
  *   parentVpId?: string,
  *   parentVpPersona?: object,
+ *   toolStats?: object,
  *   onEvent?: (agentId: string, evt: object) => void,
  *   language?: 'en'|'zh',
  * }} deps
@@ -112,6 +113,11 @@ export function startSubAgent(agent, deps = {}) {
     skillManager: deps.skillManager || null,
     mcpManager: deps.mcpManager || null,
     yeaftDir: deps.yeaftDir || null,
+    // Share the session-shared ToolUsageStats so sub-agent tool calls
+    // land in the same on-disk snapshot the parent records into. Sub-
+    // agents are often the heaviest tool users — leaving them out
+    // skewed `unify_fetch_tool_stats` output.
+    toolStats: deps.toolStats || null,
   });
 
   agent.subEngine = subEngine;

package/unify/web-bridge.js

@@ -499,6 +499,19 @@ export function __testGroupContextEntry(groupId) {
   return groupContexts.get(groupId);
 }
 
+/**
+ * Test-only: build (or return cached) per-VP Engine for a session that
+ * was wired via `__testSetSession`. Lets tests assert that the engine's
+ * dependencies (notably `toolStats`) come from the session reference —
+ * see `test/agent/web-bridge-vp-engine-tool-stats.test.js`.
+ *
+ * @param {string} groupId
+ * @param {string} vpId
+ */
+export function __testGetOrCreateVpEngine(groupId, vpId) {
+  return getOrCreateVpEngine(groupId, vpId);
+}
+
 /** Whether we've already sent a permission warning to the UI */
 let _permissionDiagnosticSent = false;
 
@@ -540,6 +553,12 @@ function getOrCreateVpEngine(groupId, vpId) {
     skillManager: session.skillManager,
     mcpManager: session.mcpManager,
     yeaftDir: session.yeaftDir,
+    // Share the session-shared ToolUsageStats so per-VP tool calls land
+    // in the same on-disk snapshot the `unify_fetch_tool_stats` handler
+    // reads. Without this, engine's record-on-tool-exec guard
+    // (`if (this.#toolStats && ...)`) is false and group VP tool calls
+    // are silently dropped.
+    toolStats: session.toolStats || null,
   });
   vpEngines.set(key, eng);
   return eng;
@@ -2673,6 +2692,37 @@ export const __testRaceWithEscalation = raceWithEscalation;
  * Backwards-compat: when neither field is set, defaults to `vpId='default'`
  * which matches the pre-v0.1.754 behavior.
  */
+export function normalizeDreamResult(result) {
+  const groups = Array.isArray(result?.groups) ? result.groups : [];
+  const targets = Array.isArray(result?.targets) ? result.targets : [];
+  const groupsProcessed = groups.filter(g => g && g.status === 'triaged').length;
+  const skippedGroups = groups.filter(g => g && g.status === 'skipped');
+  const groupsSkipped = skippedGroups.length;
+  const targetsApplied = targets.filter(t => t && t.status === 'done').length;
+  const targetErrors = targets
+    .filter(t => t && t.status === 'error')
+    .map(t => ({ target: t.target || null, error: t.error || 'unknown' }));
+  const hardError = result?.error || null;
+  const skipped = !hardError && groupsProcessed === 0 && targetsApplied === 0;
+  const skippedReason = skipped
+    ? (skippedGroups[0]?.reason || 'no-targets-applied')
+    : null;
+  const success = !hardError && targetErrors.length === 0 && !skipped && targetsApplied > 0;
+
+  return {
+    success,
+    skipped,
+    skippedReason,
+    groupsProcessed,
+    groupsSkipped,
+    targetsApplied,
+    targetErrors,
+    entriesCreated: targetsApplied,
+    lastDreamAt: result?.startedAt || new Date().toISOString(),
+    error: hardError || (targetErrors[0]?.error || null),
+  };
+}
+
 export async function handleUnifyDreamTrigger(msg = {}) {
   // Resolve tag up-front so EVERY outbound envelope (including the
   // scheduler-uninitialised early-return below) carries `groupId` /
@@ -2685,11 +2735,11 @@ export async function handleUnifyDreamTrigger(msg = {}) {
   const tag = groupId ? { groupId } : { vpId };
 
   if (!session?.dreamScheduler) {
+    const error = 'Dream scheduler not initialized — session not loaded.';
     sendToServer({
       type: 'unify_dream_result',
       ...tag,
-      success: false,
-      error: 'Dream scheduler not initialized — session not loaded.',
+      ...normalizeDreamResult({ error }),
     });
     return;
   }
@@ -2705,11 +2755,11 @@ export async function handleUnifyDreamTrigger(msg = {}) {
   // dream-v2/schedule.js inflight reuse), so the user-facing semantics
   // are unchanged ("you already asked").
   if (groupId && inflightScopedDreamGroups.size > 0) {
+    const error = 'A dream pass is already running.';
     sendToServer({
       type: 'unify_dream_result',
       ...tag,
-      success: false,
-      error: 'A dream pass is already running.',
+      ...normalizeDreamResult({ error }),
     });
     return;
   }
@@ -2745,17 +2795,12 @@ export async function handleUnifyDreamTrigger(msg = {}) {
       ? 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
-    // shape (groups[], targets[]); the front-end button only needs a
-    // scalar plus the start timestamp.
-    const targets = Array.isArray(result?.targets) ? result.targets : [];
-    const entriesCreated = targets.filter(t => t && t.status === 'done').length;
-    const lastDreamAt = result?.startedAt || new Date().toISOString();
-    const success = !result.error && !result.skipped;
-
-    // Spread `result` FIRST so derived fields (success, entriesCreated,
-    // lastDreamAt) authoritatively shadow anything the runner might grow
+    const normalized = normalizeDreamResult(result);
+
+    // Spread `result` FIRST so normalized fields (success, skipped,
+    // skippedReason, groupsProcessed, groupsSkipped, targetsApplied,
+    // targetErrors, entriesCreated, lastDreamAt) authoritatively shadow
+    // anything the runner might grow
     // with the same name. Today there is no collision (runner.js returns
     // { groups, targets, startedAt, error?, skipped? }) but the failure
     // mode of the alternative ordering is silent — review feedback from
@@ -2772,16 +2817,14 @@ export async function handleUnifyDreamTrigger(msg = {}) {
       type: 'unify_dream_result',
       ...tag,
       ...result,
-      success,
-      entriesCreated,
-      lastDreamAt,
+      ...normalized,
     });
   } catch (err) {
+    const error = err?.message || String(err);
     sendToServer({
       type: 'unify_dream_result',
       ...tag,
-      success: false,
-      error: err?.message || String(err),
+      ...normalizeDreamResult({ error }),
     });
   } finally {
     // Restore the original sink and release the per-group inflight lock.