@yeaft/webchat-agent 0.1.931 → 0.1.932

package/package.json

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

package/yeaft/dream/output-snapshot.js

@@ -0,0 +1,59 @@
+/**
+ * dream/output-snapshot.js.
+ *
+ * Read-only projection of Dream-owned output files for UI observability.
+ * The Dream write path remains `runner -> apply -> memory/store`; callers use
+ * this module to load the current `memory.md` / `summary.md` contents for a
+ * single Yeaft session when emitting status or restoring a switched session.
+ */
+
+import { join } from 'node:path';
+
+import { readMemory, readSummary } from '../memory/store.js';
+import { readGroupState } from './state.js';
+
+export const DREAM_SNAPSHOT_TEXT_LIMIT = 6000;
+
+export function truncateDreamText(value, limit = DREAM_SNAPSHOT_TEXT_LIMIT) {
+  const text = typeof value === 'string' ? value : '';
+  if (text.length <= limit) return { text, truncated: false };
+  return { text: text.slice(0, limit), truncated: true };
+}
+
+/**
+ * Build the loadable Dream output for one Yeaft session.
+ *
+ * @param {{ yeaftDir?: string|null }} sessionLike
+ * @param {string} sessionId
+ * @returns {Promise<object|null>}
+ */
+export async function buildDreamOutputSnapshot(sessionLike, sessionId) {
+  if (!sessionId || !sessionLike?.yeaftDir) return null;
+  const scope = `group/${sessionId}`;
+  const memoryScope = { kind: 'group', id: sessionId };
+  const root = join(sessionLike.yeaftDir, 'memory');
+  const [memoryRaw, summaryRaw, state] = await Promise.all([
+    readMemory(memoryScope, { root }).catch(() => ''),
+    readSummary(memoryScope, { root }).catch(() => ''),
+    readGroupState(root, sessionId).catch(() => ({
+      lastDreamMessageId: null,
+      lastDreamAt: null,
+      messageCount: 0,
+    })),
+  ]);
+  const memory = truncateDreamText(memoryRaw);
+  const summary = truncateDreamText(summaryRaw);
+  return {
+    scope,
+    sessionId,
+    loadedAt: new Date().toISOString(),
+    lastDreamAt: state?.lastDreamAt || null,
+    lastDreamMessageId: state?.lastDreamMessageId || null,
+    messageCount: Number.isFinite(state?.messageCount) ? state.messageCount : 0,
+    hasOutput: !!(memoryRaw || summaryRaw),
+    memoryText: memory.text,
+    memoryTruncated: memory.truncated,
+    summaryText: summary.text,
+    summaryTruncated: summary.truncated,
+  };
+}

package/yeaft/dream/session-wiring.js

@@ -338,7 +338,7 @@ export function createV2DreamScheduler(session) {
       ...buildRunDreamOpts(session, onProgress),
       manual: !!opts.manual,
       scopeFilter: Array.isArray(opts.scopeFilter) ? opts.scopeFilter : undefined,
-    }).then((result) => {
+    }).then(async (result) => {
       // Bug 2: emit turn_close when the dream pass completes.
       result.trigger = opts.manual ? 'manual' : 'auto';
       if (session._dreamActiveGroupId && !result.sessionId) result.sessionId = session._dreamActiveGroupId;
@@ -370,6 +370,11 @@ export function createV2DreamScheduler(session) {
       if (typeof session._dreamProgressSink === 'function') {
         session._dreamProgressSink(turnClose);
       }
+      if (typeof session._dreamResultSink === 'function') {
+        try {
+          await session._dreamResultSink(result);
+        } catch { /* dream result visibility must never fail the scheduler */ }
+      }
       return result;
     });
   };

package/yeaft/web-bridge.js

@@ -21,6 +21,7 @@
 import { join } from 'node:path';
 import { existsSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
+import { buildDreamOutputSnapshot } from './dream/output-snapshot.js';
 import { Engine } from './engine.js';
 import { loadSession } from './session.js';
 import { loadConfig } from './config.js';
@@ -112,6 +113,14 @@ export function __testSetThreadClassifier(fn) {
  */
 const inflightScopedDreamGroups = new Set();
 
+async function sendDreamSnapshotForSession(sessionId, extra = {}) {
+  const snapshot = await buildDreamOutputSnapshot(session, sessionId);
+  if (!snapshot) return null;
+  sendYeaftEvent({ type: 'yeaft_dream_snapshot', ...extra, snapshot }, { sessionId });
+  return snapshot;
+}
+
+
 /**
  * Single in-flight AbortController for legacy 1:1 chat. A new 1:1 user message
  * cancels the prior round (if any).
@@ -1865,6 +1874,30 @@ export function installYeaftRuntimeBridge(s) {
     } catch { /* never let event delivery throw */ }
   };
 
+  // Auto dream runs are triggered by the scheduler / nudges, not by the
+  // manual `handleYeaftDreamTrigger` path. Without this terminal sink the UI
+  // only saw progress debug events and could not restore the final dream
+  // output after switching sessions. Manual runs keep using their explicit
+  // handler below to avoid duplicate terminal events.
+  s._dreamResultSink = async (result = {}) => {
+    if (result?.trigger !== 'auto') return;
+    const normalized = normalizeDreamResult(result);
+    const processed = Array.isArray(result.groups)
+      ? result.groups.filter(g => g && g.status === 'processed' && g.sessionId)
+      : [];
+    for (const group of processed) {
+      const sessionId = group.sessionId;
+      const snapshot = await buildDreamOutputSnapshot(session, sessionId).catch(() => null);
+      sendToServer({
+        type: 'yeaft_dream_result',
+        sessionId,
+        ...result,
+        ...normalized,
+        snapshot,
+      });
+    }
+  };
+
   // Wire the post-compact WS sink. Compactor is constructed in
   // session.js with a no-op sink; bridge owns `sendYeaftEvent` /
   // `yeaftConversationId`, so the sink is wired here once a session is
@@ -3594,6 +3627,9 @@ export async function handleYeaftDreamTrigger(msg = {}) {
       : await session.dreamScheduler.triggerDreamNow();
 
     const normalized = normalizeDreamResult(result);
+    const snapshot = sessionId
+      ? await buildDreamOutputSnapshot(session, sessionId).catch(() => null)
+      : null;
 
     // Spread `result` FIRST so normalized fields (success, skipped,
     // skippedReason, groupsProcessed, groupsSkipped, targetsApplied,
@@ -3616,6 +3652,7 @@ export async function handleYeaftDreamTrigger(msg = {}) {
       ...tag,
       ...result,
       ...normalized,
+      ...(snapshot ? { snapshot } : {}),
     });
   } catch (err) {
     const error = err?.message || String(err);
@@ -3829,6 +3866,9 @@ export async function handleYeaftLoadHistory(msg) {
     yeaftDir: ctx.CONFIG?.yeaftDir || null,
   });
   sendSessionSnapshotBroadcast();
+  if (sessionId) {
+    await sendDreamSnapshotForSession(sessionId, { trigger: 'load_history' }).catch(() => null);
+  }
   // vp-status: replay the authoritative table on reconnect so a refreshed
   // frontend doesn't have to wait for the next transition to learn each
   // VP's current state.