@yeaft/webchat-agent 0.1.631 → 0.1.633

package/package.json

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

package/unify/config.js

@@ -217,8 +217,8 @@ function loadLegacyConfig(dir, overrides) {
     maxContinueTurns: overrides.maxContinueTurns ?? fileConfig.maxContinueTurns ?? DEFAULTS.maxContinueTurns,
     // task-318: legacy path never had the `unify` section — defaults.
     unify: normaliseUnifySection(null),
-    // DESIGN-v2 feature flag — opt-in via override only on legacy path.
-    memoryV2: !!overrides.memoryV2,
+    // DESIGN-v2 feature flag. Default true (PR-E flipped). Override wins.
+    memoryV2: overrides.memoryV2 !== undefined ? !!overrides.memoryV2 : true,
     providers: null,
     primaryModel: null,
     fastModel: null,
@@ -316,11 +316,12 @@ export function loadConfig(overrides = {}) {
     unify: normaliseUnifySection(jsonConfig.unify),
 
     // DESIGN-v2 feature flag. When true the engine routes recall through
-    // memory/recall-v2.js (per-scope memory.md + summary.md) and reads from
-    // the v2 store layout. Defaults to false during the rollout; PR-E flips
-    // the default and deletes the legacy paths.
+    // memory/recall-v2.js (per-scope memory.md + summary.md) and the
+    // session wires the v2 dream pipeline (dream-v2/runner.js). PR-E
+    // flipped the default to true; users who need the legacy R6 paths
+    // can opt out via `"memoryV2": false` in ~/.yeaft/config.json.
     memoryV2: overrides.memoryV2 !== undefined ? !!overrides.memoryV2
-      : (jsonConfig.memoryV2 !== undefined ? !!jsonConfig.memoryV2 : false),
+      : (jsonConfig.memoryV2 !== undefined ? !!jsonConfig.memoryV2 : true),
 
     // Legacy fields (null when using config.json)
     apiKey: overrides.apiKey || null,

package/unify/dream-v2/session-wiring.js

@@ -0,0 +1,171 @@
+/**
+ * dream-v2/session-wiring.js — DESIGN-v2 §13 wire-up for session.js.
+ *
+ * Bridges the framework-agnostic `runDream` orchestrator (dream-v2/runner.js)
+ * to the live yeaft session: groups store, conversation log, LLM adapter,
+ * and the engine's progress event sink.
+ *
+ * The dream pipeline only activates when `config.memoryV2 === true`. When
+ * the flag is off, this module is a no-op — the legacy R6 dream-scheduler
+ * keeps running as before (session.js still wires it).
+ */
+
+import { join } from 'path';
+import { runDream } from './runner.js';
+import { createDreamScheduler } from './schedule.js';
+import { listGroups, openGroup } from '../groups/group-store.js';
+
+/**
+ * Build the per-call options for runDream. Pure: takes a session and returns
+ * the closures runDream needs (listGroups, countMessages, loadGroupDiff, etc.).
+ *
+ * @param {Object} session  — the live Session object from loadSession()
+ * @param {(event: object) => void} [onProgress]
+ * @returns {Object}
+ */
+export function buildRunDreamOpts(session, onProgress) {
+  const yeaftDir = session.yeaftDir;
+  const memoryRoot = join(yeaftDir, 'memory');
+  const groupsRoot = join(yeaftDir, 'groups');
+
+  return {
+    root: memoryRoot,
+    llm: makeLlm(session),
+    listGroups: async () => {
+      try { return listGroups(groupsRoot).map(g => g.id); }
+      catch { return []; }
+    },
+    countMessages: async (gid) => {
+      try {
+        const h = openGroup(groupsRoot, gid);
+        let n = 0;
+        for (const _m of h.streamMessages()) n += 1;
+        return n;
+      } catch { return 0; }
+    },
+    loadGroupDiff: async (gid, sinceId) => {
+      try {
+        const h = openGroup(groupsRoot, gid);
+        const out = [];
+        let started = !sinceId;
+        for (const m of h.streamMessages()) {
+          if (!started) {
+            if (m.id === sinceId) started = true;
+            continue;
+          }
+          out.push(translateGroupMessage(m));
+        }
+        return out;
+      } catch { return []; }
+    },
+    loadOverlapPreamble: async (gid, beforeId, n) => {
+      try {
+        const h = openGroup(groupsRoot, gid);
+        const buf = [];
+        for (const m of h.streamMessages()) {
+          if (m.id === beforeId) break;
+          buf.push(m);
+        }
+        return buf.slice(-n).map(translateGroupMessage);
+      } catch { return []; }
+    },
+    onProgress,
+  };
+}
+
+/**
+ * Translate a group-store message record (id, from, role, text, ...) into
+ * the shape runDream expects (id, role, body, vpId, author, featureId).
+ *
+ * @param {Object} m
+ */
+function translateGroupMessage(m) {
+  const role = m.role || (m.from === 'user' ? 'user' : 'assistant');
+  const out = {
+    id: m.id,
+    role,
+    body: m.text || '',
+  };
+  if (role === 'assistant' && m.from && m.from !== 'user') {
+    out.vpId = m.from;
+  }
+  if (m.meta && typeof m.meta === 'object' && m.meta.featureId) {
+    out.featureId = m.meta.featureId;
+  }
+  return out;
+}
+
+/**
+ * Build the LLM callable that runDream's triage/apply prompts use.
+ *
+ * @param {Object} session
+ */
+function makeLlm(session) {
+  return async ({ pass, prompt, system }) => {
+    const adapter = session.adapter;
+    const model = session.config?.fastModelId || session.config?.model;
+    if (!adapter || typeof adapter.call !== 'function') {
+      throw new Error(`dream-v2: no adapter.call available (pass=${pass})`);
+    }
+    const r = await adapter.call({
+      model,
+      system: system || `You are the dream pipeline — pass: ${pass}.`,
+      messages: [{ role: 'user', content: prompt }],
+      maxTokens: 2048,
+    });
+    return (r && r.text) ? r.text : '';
+  };
+}
+
+/**
+ * Create a v2 dream scheduler bound to a session and wire its progress
+ * events into the engine's sub-agent event sink (web-bridge translates
+ * `dream_progress` into `unify_output` for the debug panel).
+ *
+ * @param {Object} session
+ * @returns {Object}                   — scheduler (start/stop/triggerNow)
+ */
+export function createV2DreamScheduler(session) {
+  const onProgress = (evt) => {
+    try {
+      const sink = session.engine?.subAgentEventSink || null;
+      // We don't have a sub-agent id; emit on the engine's standard
+      // event channel instead. session.engine exposes setSubAgentEventSink
+      // for nested events; for top-level dream, we route through trace.
+      if (typeof session.trace?.event === 'function') {
+        session.trace.event('dream_progress', evt);
+      }
+      if (typeof session._dreamProgressSink === 'function') {
+        session._dreamProgressSink(evt);
+      }
+      // Best-effort console for debug builds.
+      if (session.config?.debug) {
+        // eslint-disable-next-line no-console
+        console.log('[dream-v2]', evt);
+      }
+    } catch { /* never let progress reporting kill the run */ }
+  };
+
+  const run = (opts = {}) => runDream({
+    ...buildRunDreamOpts(session, onProgress),
+    manual: !!opts.manual,
+    scopeFilter: Array.isArray(opts.scopeFilter) ? opts.scopeFilter : undefined,
+  });
+
+  const v2 = createDreamScheduler({
+    run,
+    logger: session.config?.debug ? console : undefined,
+  });
+  // Auto-start the timer.
+  v2.start();
+  // Adapter shim: legacy callers (web-bridge) call .noteUserMessage() and
+  // .triggerDreamNow() / .shutdown(). Map them onto the v2 API.
+  return {
+    noteUserMessage() { /* v2 doesn't gate on user-message count */ },
+    triggerDreamNow() { return v2.triggerNow(); },
+    shutdown() { v2.stop(); },
+    get isRunning() { return v2.isRunning(); },
+    // Preserve direct access for tests.
+    _v2: v2,
+  };
+}

package/unify/session.js

@@ -35,6 +35,7 @@ import { createDispatcher } from './pipeline/dispatcher.js';
 import { ensureDefaultGroupIfEmpty } from './groups/group-crud.js';
 import { seedDefaultVps } from './vp/seed-defaults.js';
 import { createDreamScheduler } from './memory/dream-scheduler.js';
+import { createV2DreamScheduler } from './dream-v2/session-wiring.js';
 import { getUserMemoryStore } from './memory/user-memory-store.js';
 import { join } from 'path';
 import { existsSync as existsSyncSafe, readFileSync as readFileSyncSafe } from 'fs';
@@ -246,29 +247,47 @@ export async function loadSession(options = {}) {
     yeaftDir,
   });
 
-  // ─── 9a. Create dream scheduler (wave-6b) ─────────────
-  const dreamScheduler = createDreamScheduler({
-    memoryShardStore,
-    userMemoryStore: getUserMemoryStore(),
-    conversationStore,
-    adapter,
-    config,
-    onDreamStart: (vpId) => {
-      if (config.debug) console.log(`[Yeaft] Dream started for VP ${vpId}`);
-    },
-    onDreamEnd: (vpId, result) => {
-      if (config.debug) console.log(`[Yeaft] Dream ended for VP ${vpId}:`, JSON.stringify({
-        trigger: result.trigger,
-        entriesMerged: result.entriesMerged,
-        entriesPruned: result.entriesPruned,
-        bytesReclaimed: result.bytesReclaimed,
-        errors: result.errors?.length || 0,
-      }));
-    },
-    onError: (vpId, err) => {
-      console.warn(`[Yeaft] Dream error for VP ${vpId}:`, err?.message || err);
-    },
-  });
+  // ─── 9a. Create dream scheduler (wave-6b / DESIGN-v2) ──
+  // When config.memoryV2 is on, route through the v2 pipeline (per-scope
+  // memory.md + summary.md). Otherwise keep the legacy R6 dream-scheduler.
+  let dreamScheduler;
+  if (config.memoryV2) {
+    // Build a partial session reference so the v2 wiring can see adapter,
+    // config, yeaftDir, engine, and trace. The scheduler's `run` closure
+    // dereferences these lazily, so mutating the object after this line
+    // (e.g. attaching engine) is safe.
+    const partialSession = {
+      yeaftDir,
+      adapter,
+      config,
+      engine,
+      trace,
+    };
+    dreamScheduler = createV2DreamScheduler(partialSession);
+  } else {
+    dreamScheduler = createDreamScheduler({
+      memoryShardStore,
+      userMemoryStore: getUserMemoryStore(),
+      conversationStore,
+      adapter,
+      config,
+      onDreamStart: (vpId) => {
+        if (config.debug) console.log(`[Yeaft] Dream started for VP ${vpId}`);
+      },
+      onDreamEnd: (vpId, result) => {
+        if (config.debug) console.log(`[Yeaft] Dream ended for VP ${vpId}:`, JSON.stringify({
+          trigger: result.trigger,
+          entriesMerged: result.entriesMerged,
+          entriesPruned: result.entriesPruned,
+          bytesReclaimed: result.bytesReclaimed,
+          errors: result.errors?.length || 0,
+        }));
+      },
+      onError: (vpId, err) => {
+        console.warn(`[Yeaft] Dream error for VP ${vpId}:`, err?.message || err);
+      },
+    });
+  }
 
   // task-308 Phase 2: thread-aware engine registry.
   // Each thread gets its own EngineInstance (lazy-created) that owns its

package/unify/web-bridge.js

@@ -532,6 +532,17 @@ export function installUnifyRuntimeBridge(s) {
   if (!s) return;
   const initialMax = s.engineRegistry?.maxConcurrent ?? null;
   const initialIdle = s.threadStore?.idleArchiveDays ?? 0;
+
+  // DESIGN-v2 §19.4: forward dream pipeline progress events to the web
+  // client so the debug panel can render live state. Events flow through
+  // the same `unify_output` channel; no new WebSocket message type is
+  // introduced.
+  s._dreamProgressSink = (evt) => {
+    try {
+      sendUnifyEvent({ type: 'dream_progress', ...evt });
+    } catch { /* never let event delivery throw */ }
+  };
+
   ctx.unifyRuntimeSettings = {
     get maxConcurrentThreads() { return s.engineRegistry?.maxConcurrent ?? initialMax; },
     set maxConcurrentThreads(v) {