@yeaft/webchat-agent 0.1.546 → 0.1.548

package/connection/message-router.js

@@ -36,7 +36,7 @@ import { sendToServer, flushMessageBuffer } from './buffer.js';
 import { handleRestartAgent, handleUpgradeAgent } from './upgrade.js';
 import { loadMcpServers, updateMcpConfig } from '../mcp.js';
 import { getLlmConfig, updateLlmConfig, getUnifySettings, updateUnifySettings } from '../unify/config-api.js';
-import { handleUnifyChat, handleUnifyModeSwitch, handleUnifyModelSwitch, resetUnifySession, handleUnifyLoadHistory, handleUnifyMergeThread, handleUnifyForkThread, handleUnifyAbortThread, handleUnifyAbortAll, handleUnifyVpSubscribe, handleUnifyVpCreate, handleUnifyVpUpdate, handleUnifyVpDelete, handleUnifyVpRead, handleUnifyTaskMessage, handleUnifyUserMemoryWrite, handleUnifyUserMemoryRemove, handleUnifyListGroups, handleUnifyCreateGroup, handleUnifyRenameGroup, handleUnifyArchiveGroup, handleUnifyAddMember, handleUnifyRemoveMember, handleUnifySetDefaultVp } from '../unify/web-bridge.js';
+import { handleUnifyChat, handleUnifyModeSwitch, handleUnifyModelSwitch, resetUnifySession, handleUnifyLoadHistory, handleUnifyMergeThread, handleUnifyForkThread, handleUnifyAbortThread, handleUnifyAbortAll, handleUnifyVpSubscribe, handleUnifyVpCreate, handleUnifyVpUpdate, handleUnifyVpDelete, handleUnifyVpRead, handleUnifyTaskMessage, handleUnifyUserMemoryWrite, handleUnifyUserMemoryRemove, handleUnifyListGroups, handleUnifyCreateGroup, handleUnifyRenameGroup, handleUnifyArchiveGroup, handleUnifyAddMember, handleUnifyRemoveMember, handleUnifySetDefaultVp, handleUnifyDreamTrigger } from '../unify/web-bridge.js';
 
 export async function handleMessage(msg) {
   switch (msg.type) {
@@ -462,6 +462,11 @@ export async function handleMessage(msg) {
       handleUnifySetDefaultVp(msg);
       break;
 
+    // wave-6b: manual dream trigger from VP detail page
+    case 'unify_dream_trigger':
+      await handleUnifyDreamTrigger(msg);
+      break;
+
     // Expert roles definition (for ExpertPanel detail view)
     case 'get_expert_roles': {
       const { getExpertRolesDefinition } = await import('../expert-roles.js');

package/package.json

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

package/unify/memory/dream-scheduler.js

@@ -0,0 +1,182 @@
+/**
+ * dream-scheduler.js — wave-6b: idle-timer dream trigger + per-VP orchestration.
+ *
+ * Responsibilities:
+ *   1. Idle timer: fires after 30 min of no user messages if there are
+ *      un-ingested (new since last dream) messages in the session.
+ *   2. Per-VP dream orchestration: runs dreamShard() per VP, serial within
+ *      each VP, max 2 VPs concurrently.
+ *   3. Integrates the 334f recompression hook post-dream.
+ *   4. Exposes `triggerDreamNow()` for manual "Run dream now" from the UI.
+ *
+ * Usage (from session.js / web-bridge.js):
+ *   const scheduler = createDreamScheduler({ session });
+ *   scheduler.noteUserMessage();          // reset idle timer on each user msg
+ *   scheduler.triggerDreamNow();          // manual trigger from WS event
+ *   scheduler.shutdown();                 // cleanup on session close
+ *
+ * References:
+ *   - 334g dream-shard.js: dreamShard(), scanShards(), runCompactJob()
+ *   - 334f recompression.js: checkRecompression()
+ *   - PM spec: "30min 无消息 AND 有未 ingest message → 触发"
+ */
+
+import { dreamShard } from './dream-shard.js';
+import { checkRecompression } from './recompression.js';
+
+/** Default idle timeout before dream triggers (ms). */
+export const DREAM_IDLE_MS = 30 * 60 * 1000; // 30 min
+
+/** Max concurrent VP dream runs. */
+const MAX_CONCURRENT_DREAMS = 2;
+
+/**
+ * Create a dream scheduler instance.
+ *
+ * @param {{
+ *   memoryShardStore: object | null,
+ *   adapter: object | null,
+ *   config: object,
+ *   idleMs?: number,
+ *   onDreamStart?: (vpId: string) => void,
+ *   onDreamEnd?: (vpId: string, result: object) => void,
+ *   onError?: (vpId: string, err: Error) => void,
+ * }} opts
+ * @returns {DreamScheduler}
+ */
+export function createDreamScheduler(opts = {}) {
+  const {
+    memoryShardStore,
+    adapter,
+    config,
+    idleMs = DREAM_IDLE_MS,
+    onDreamStart,
+    onDreamEnd,
+    onError,
+  } = opts;
+
+  let idleTimer = null;
+  let messagesSinceLastDream = 0;
+  let dreamRunning = false;
+  let lastDreamAt = 0;
+  let destroyed = false;
+
+  // ── Idle timer management ────────────────────────────────
+
+  function resetIdleTimer() {
+    if (destroyed) return;
+    if (idleTimer) {
+      clearTimeout(idleTimer);
+      idleTimer = null;
+    }
+    if (messagesSinceLastDream > 0) {
+      idleTimer = setTimeout(() => {
+        idleTimer = null;
+        if (messagesSinceLastDream > 0 && !dreamRunning && !destroyed) {
+          runDream('idle').catch(() => {});
+        }
+      }, idleMs);
+      if (idleTimer && typeof idleTimer.unref === 'function') {
+        idleTimer.unref();
+      }
+    }
+  }
+
+  /**
+   * Call on every user message to reset the idle timer and increment
+   * the un-ingested message counter.
+   */
+  function noteUserMessage() {
+    if (destroyed) return;
+    messagesSinceLastDream++;
+    resetIdleTimer();
+  }
+
+  // ── Dream execution ──────────────────────────────────────
+
+  /**
+   * Run a dream cycle. Currently single-VP (Unify default VP), but
+   * structured for future multi-VP with maxConcurrent=2.
+   *
+   * @param {'idle'|'manual'} trigger
+   * @returns {Promise<object>} dream result
+   */
+  async function runDream(trigger = 'manual') {
+    if (dreamRunning) {
+      return { skipped: true, reason: 'already_running' };
+    }
+    if (!memoryShardStore) {
+      return { skipped: true, reason: 'no_shard_store' };
+    }
+    if (!adapter) {
+      return { skipped: true, reason: 'no_adapter' };
+    }
+
+    dreamRunning = true;
+    const vpId = 'default'; // single-VP Unify mode
+
+    try {
+      onDreamStart?.(vpId);
+
+      const result = await dreamShard({
+        shardStore: memoryShardStore,
+        adapter,
+        config: { model: config?.primaryModel || config?.model || 'default' },
+        onPhase: (phase, data) => {
+          // Could forward to UI in future
+        },
+      });
+
+      // Post-dream: run recompression hook (334f)
+      try {
+        const recompResult = checkRecompression(memoryShardStore);
+        result.recompression = recompResult;
+      } catch {
+        // Non-fatal
+      }
+
+      messagesSinceLastDream = 0;
+      lastDreamAt = Date.now();
+      onDreamEnd?.(vpId, { ...result, trigger });
+
+      return result;
+    } catch (err) {
+      onError?.(vpId, err);
+      return { error: err.message, trigger };
+    } finally {
+      dreamRunning = false;
+    }
+  }
+
+  /**
+   * Manual trigger from UI ("Run dream now" button).
+   * @returns {Promise<object>}
+   */
+  function triggerDreamNow() {
+    return runDream('manual');
+  }
+
+  /**
+   * Cleanup: clear timers, prevent further runs.
+   */
+  function shutdown() {
+    destroyed = true;
+    if (idleTimer) {
+      clearTimeout(idleTimer);
+      idleTimer = null;
+    }
+  }
+
+  return {
+    noteUserMessage,
+    triggerDreamNow,
+    shutdown,
+    get isRunning() { return dreamRunning; },
+    get messagesSinceLastDream() { return messagesSinceLastDream; },
+    get lastDreamAt() { return lastDreamAt; },
+  };
+}
+
+/**
+ * @typedef {ReturnType<typeof createDreamScheduler>} DreamScheduler
+ */

package/unify/session.js

@@ -33,6 +33,7 @@ import { createIntentClassifier } from './router/intent-classifier.js';
 import { initInputQueueStore } from './input-queue/store.js';
 import { createDispatcher } from './pipeline/dispatcher.js';
 import { ensureDefaultGroupIfEmpty } from './groups/group-crud.js';
+import { createDreamScheduler } from './memory/dream-scheduler.js';
 import { join } from 'path';
 import { existsSync as existsSyncSafe, readFileSync as readFileSyncSafe } from 'fs';
 
@@ -232,6 +233,28 @@ export async function loadSession(options = {}) {
     yeaftDir,
   });
 
+  // ─── 9a. Create dream scheduler (wave-6b) ─────────────
+  const dreamScheduler = createDreamScheduler({
+    memoryShardStore,
+    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
   // messages array and tags all events with the bound threadId. Legacy
@@ -283,8 +306,13 @@ export async function loadSession(options = {}) {
     tools: toolRegistry.size,
   };
 
-  /** Graceful shutdown: disconnect MCP, close trace DB. */
+  /** Graceful shutdown: disconnect MCP, close trace DB, stop dream scheduler. */
   async function shutdown() {
+    try {
+      dreamScheduler.shutdown();
+    } catch {
+      // Best-effort cleanup
+    }
     try {
       engineRegistry.terminateAll();
     } catch {
@@ -313,6 +341,7 @@ export async function loadSession(options = {}) {
     conversationStore,
     memoryStore,
     memoryShardStore,
+    dreamScheduler,
     skillManager,
     mcpManager,
     toolRegistry,

package/unify/web-bridge.js

@@ -1016,6 +1016,11 @@ export async function handleUnifyChat(msg) {
       sendGroupSnapshotBroadcast();
     }
 
+    // wave-6b: notify dream scheduler of user activity
+    if (session?.dreamScheduler) {
+      session.dreamScheduler.noteUserMessage();
+    }
+
     // ─── Per-call AbortController (task-320) ──
     // Each call owns its own controller. Only once the router resolves the
     // target thread do we register it into `abortByThread` and abort any
@@ -1260,6 +1265,50 @@ export function __testGetRegisteredThreadIds() {
   return [...abortByThread.keys()];
 }
 
+/**
+ * wave-6b: Handle manual dream trigger from VP detail page.
+ * Payload: { vpId?: string } (optional, defaults to 'default').
+ * Emits unify_dream_result with the dream outcome.
+ *
+ * @param {{ vpId?: string }} msg
+ */
+export async function handleUnifyDreamTrigger(msg = {}) {
+  if (!session?.dreamScheduler) {
+    sendToServer({
+      type: 'unify_dream_result',
+      success: false,
+      error: 'Dream scheduler not initialized — session not loaded.',
+    });
+    return;
+  }
+
+  const vpId = msg.vpId || 'default';
+
+  try {
+    sendToServer({
+      type: 'unify_dream_status',
+      vpId,
+      status: 'running',
+    });
+
+    const result = await session.dreamScheduler.triggerDreamNow();
+
+    sendToServer({
+      type: 'unify_dream_result',
+      vpId,
+      success: !result.error && !result.skipped,
+      ...result,
+    });
+  } catch (err) {
+    sendToServer({
+      type: 'unify_dream_result',
+      vpId,
+      success: false,
+      error: err?.message || String(err),
+    });
+  }
+}
+
 /**
  * Handle mode switch from the web UI.
  * DEPRECATED (task-297): Unify no longer has chat/work mode distinction.