@yeaft/webchat-agent 0.1.779 → 0.1.781

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.779",
+  "version": "0.1.781",
   "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;
@@ -478,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);
@@ -544,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,
@@ -560,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()}`);
       }
@@ -1140,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/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/session.js

@@ -50,7 +50,7 @@ import { openSegmentIndex } from './memory/index-db.js';
 import { syncAll as syncSegmentIndex } from './memory/segment-sync.js';
 import { openAmsRegistry } from './memory/ams-registry.js';
 import { join } from 'path';
-import { existsSync as existsSyncSafe, readFileSync as readFileSyncSafe } from 'fs';
+import { existsSync as existsSyncSafe, readFileSync as readFileSyncSafe, mkdirSync as mkdirSyncSafe } from 'fs';
 
 /**
  * @typedef {Object} SessionOptions
@@ -80,6 +80,33 @@ import { existsSync as existsSyncSafe, readFileSync as readFileSyncSafe } from '
  * @property {() => Promise<void>} shutdown — Graceful shutdown
  */
 
+/**
+ * Eagerly create `<yeaftDir>/stats/` and surface failures as a warn.
+ *
+ * Returns the resolved path either way — the caller can still pass it
+ * to `ToolUsageStats`, which keeps an in-memory counter path even when
+ * the disk is read-only.
+ *
+ * NOTE: this knowledge ("stats lives under `stats/`") belongs inside
+ * `ToolUsageStats.init()`. Once that exists, delete this helper and
+ * the call site collapses to `await toolStats.init(yeaftDir)`.
+ *
+ * @param {string} yeaftDir
+ * @returns {string} statsDir
+ */
+function prepareToolStatsDir(yeaftDir) {
+  const statsDir = join(yeaftDir, 'stats');
+  try {
+    mkdirSyncSafe(statsDir, { recursive: true });
+  } catch (err) {
+    console.warn(
+      `[Unify] Could not create stats dir ${statsDir}: ${err?.message || err}. ` +
+      `Tool-usage counters will live in memory only.`
+    );
+  }
+  return statsDir;
+}
+
 /**
  * Load (or initialize) a Yeaft session.
  *
@@ -320,8 +347,24 @@ export async function loadSession(options = {}) {
   // Tool-call usage statistics: persisted to <yeaftDir>/stats/tool-usage.json.
   // Loaded synchronously at boot so the first turn already sees prior counts.
   // Threaded into the engine so it can `record` each tool_exec event.
+  //
+  // 2026-05-16: eagerly create the `stats/` directory at boot. The
+  // ToolUsageStats writer does `fsp.mkdir(..., {recursive:true})` lazily
+  // inside `#doFlush()` and swallows any mkdir error, which meant an
+  // unwritable parent (perm denied, ENOSPC) was silently invisible
+  // until the user filed a support ticket. Doing it here surfaces the
+  // failure as a console.warn while still leaving the in-memory
+  // counter path functional — the engine keeps recording even if the
+  // disk is read-only.
+  //
+  // FOLLOW-UP: this leaks `ToolUsageStats`'s storage layout (its
+  // directory name) into the session orchestrator. The right home is
+  // a `ToolUsageStats.init()` that owns the mkdir + the warn + a
+  // `writesDisabled` flag. Tracking as future work; for now the helper
+  // below visually quarantines the leak so the migration is one delete.
+  const statsDir = prepareToolStatsDir(yeaftDir);
   const toolStats = new ToolUsageStats({
-    path: join(yeaftDir, 'stats', 'tool-usage.json'),
+    path: join(statsDir, 'tool-usage.json'),
   });
   toolStats.loadSync();
   const engine = new Engine({

package/unify/web-bridge.js

@@ -2692,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` /
@@ -2704,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;
   }
@@ -2724,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;
   }
@@ -2764,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
@@ -2791,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.