@yeaft/webchat-agent 0.1.931 → 0.1.933

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.931",
+  "version": "0.1.933",
   "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/engine.js

@@ -612,6 +612,7 @@ export class Engine {
    *   ownVpId: string|null,
    *   scopes: string[],
    *   snapshotBlock: string,
+ *   residentEntries: Array<{scope:string, summary:string}>,
    * } | null}
    */
   #prepareAms(args) {
@@ -650,7 +651,7 @@ export class Engine {
       vpId: ownVpId,
     });
 
-    return { ams, groupKey, ownVpId, scopes, snapshotBlock };
+    return { ams, groupKey, ownVpId, scopes, snapshotBlock, residentEntries };
   }
 
   /**
@@ -1475,6 +1476,25 @@ export class Engine {
       memoryInjection = amsContext.snapshotBlock;
     }
 
+    // Diagnostic payload for the Dream debug panel. The full AMS Resident
+    // layer can include user and per-VP summaries, but the browser-facing
+    // Dream prompt-load view only needs to prove the active group Dream
+    // summary entered `system_prompt.memory`. Keep the payload scoped to the
+    // exact group resident to avoid leaking unrelated resident summaries into
+    // frontend state. The full system prompt remains visible in the existing
+    // debug-only system-prompt panel.
+    const activeGroupDreamScope = sessionId ? `group/${sessionId}` : null;
+    const dreamResidentLoaded = amsContext && Array.isArray(amsContext.residentEntries)
+      ? amsContext.residentEntries
+        .filter(e => e && e.scope === activeGroupDreamScope && e.summary)
+        .map(e => ({
+          scope: e.scope,
+          summary: String(e.summary).slice(0, 4000),
+          truncated: String(e.summary).length > 4000,
+          source: 'resident-summary',
+        }))
+      : [];
+
     // ─── Active Scope (DESIGN-PROMPT §3 ④) ──────────────────────
     // Structured per-turn scope summary: group + vp + envelope routing
     // info. Long-form scope content lives in AMS — this block carries
@@ -1652,6 +1672,17 @@ export class Engine {
       };
     }
 
+    if (dreamResidentLoaded.length > 0) {
+      yield {
+        type: 'dream_memory_loaded',
+        turnId: queryTurnId,
+        vpId: queryVpId,
+        sessionId: sessionId || null,
+        loadedInto: 'system_prompt.memory',
+        resident: dreamResidentLoaded,
+      };
+    }
+
     const toolDefs = this.#getToolDefs();
     let turnNumber = 0;
     let continueTurns = 0; // auto-continue counter

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
@@ -2179,6 +2212,17 @@ function handleEngineEvent(event, hctx) {
       }, envelope);
       break;
 
+    case 'dream_memory_loaded':
+      sendYeaftEvent({
+        type: 'dream_memory_loaded',
+        turnId: event.turnId,
+        vpId: event.vpId || null,
+        sessionId: event.sessionId || null,
+        loadedInto: event.loadedInto || 'system_prompt.memory',
+        resident: Array.isArray(event.resident) ? event.resident : [],
+      }, envelope);
+      break;
+
     case 'memory_adjust':
       sendYeaftEvent({
         type: 'memory_adjust',
@@ -3594,6 +3638,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 +3663,7 @@ export async function handleYeaftDreamTrigger(msg = {}) {
       ...tag,
       ...result,
       ...normalized,
+      ...(snapshot ? { snapshot } : {}),
     });
   } catch (err) {
     const error = err?.message || String(err);
@@ -3829,6 +3877,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.