@yeaft/webchat-agent 0.1.851 → 0.1.852

package/package.json

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

package/unify/conversation/persist.js

@@ -22,7 +22,7 @@ import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, rename
 import { join, basename } from 'path';
 import { isPermissionError } from '../init.js';
 import { pairSanitize } from '../pair-sanitize.js';
-import { sliceLastNTurns } from '../turn-utils.js';
+import { indexOfNthTurnFromEnd, sliceLastNTurns } from '../turn-utils.js';
 
 /**
  * Default cold-start "recent window" size, expressed in TURNS (not raw
@@ -870,6 +870,43 @@ export class ConversationStore {
     return { messages: sliced, oldestSeq, hasMore };
   }
 
+  /**
+   * Visible UI pagination read for one group. Unlike `loadOlderByGroup`, this
+   * projects out internal/reflection/system rows BEFORE applying the turn
+   * window, so a dense run of hidden metadata cannot force the first screen to
+   * scan and materialize the group's entire history in the web bridge.
+   *
+   * @param {string} groupId
+   * @param {number|null} beforeSeq — exclusive upper bound, or null for newest
+   * @param {number} [turnsLimit=DEFAULT_RECENT_TURNS]
+   * @returns {{ messages: object[], oldestSeq: number|null, hasMore: boolean }}
+   */
+  loadVisibleByGroup(groupId, beforeSeq, turnsLimit = DEFAULT_RECENT_TURNS) {
+    if (!groupId || !(turnsLimit > 0)) return { messages: [], oldestSeq: null, hasMore: false };
+
+    const cutoff = Number.isFinite(beforeSeq) ? beforeSeq : Infinity;
+    const hot = this.#loadVisibleFromDirByGroup(this.#msgDir, groupId, cutoff);
+    const cold = this.#loadVisibleFromDirByGroup(this.#coldDir, groupId, cutoff);
+    const visible = [...cold, ...hot];
+    if (visible.length === 0) return { messages: [], oldestSeq: null, hasMore: false };
+
+    const startIdx = indexOfNthTurnFromEnd(visible, turnsLimit);
+    const start = startIdx === -1 ? 0 : startIdx;
+    const messages = pairSanitize(visible.slice(start));
+    const oldestSeq = messages.length ? parseSeqFromId(messages[0].id) : null;
+    const firstVisibleSeq = parseSeqFromId(visible[0].id);
+    const hasMore = messages.length > 0
+      && Number.isFinite(oldestSeq)
+      && Number.isFinite(firstVisibleSeq)
+      && oldestSeq > firstVisibleSeq;
+
+    return {
+      messages,
+      oldestSeq: Number.isFinite(oldestSeq) ? oldestSeq : null,
+      hasMore,
+    };
+  }
+
   /**
    * Count hot messages.
    *
@@ -1319,6 +1356,32 @@ export class ConversationStore {
     return messages;
   }
 
+  #loadVisibleFromDirByGroup(dir, groupId, beforeSeq) {
+    if (!existsSync(dir)) return [];
+
+    const files = readdirSync(dir)
+      .filter(f => f.endsWith('.md'))
+      .sort();
+
+    const out = [];
+    for (const file of files) {
+      const seq = parseSeqFromId(basename(file, '.md'));
+      if (!Number.isFinite(seq) || seq >= beforeSeq) continue;
+
+      const raw = readFileSync(join(dir, file), 'utf8');
+      if (!raw.includes(`groupId: ${groupId}`)) continue;
+      if (!raw.includes('role: user') && !raw.includes('role: assistant')) continue;
+
+      const parsed = parseMessage(raw);
+      if (!parsed || parsed.groupId !== groupId) continue;
+      if (parsed._reflection || parsed.internal || parsed.systemOnly || parsed.systemOnlyMessage) continue;
+      if (parsed.role !== 'user' && parsed.role !== 'assistant') continue;
+      out.push(parsed);
+    }
+
+    return out;
+  }
+
   /**
    * Determine the next sequence number by scanning existing files.
    * @returns {number}

package/unify/web-bridge.js

@@ -602,10 +602,16 @@ function loadVisibleGroupHistoryPage(store, groupId, limit, beforeSeq = null) {
 
   let rows = [];
   try {
-    if (typeof store.loadOlderByGroup === 'function') {
-      // Use an unbounded raw prefix, then project/slice visible rows below.
-      // This preserves loadOlderByGroup's hot+cold scan without letting raw
-      // reflection/internal rows consume the UI-visible page window.
+    if (typeof store.loadVisibleByGroup === 'function') {
+      const page = store.loadVisibleByGroup(groupId, beforeSeq, limit);
+      return {
+        messages: (page.messages || []).map(projectPersistedToVisibleHistoryEntry).filter(Boolean),
+        oldestSeq: (typeof page.oldestSeq === 'number') ? page.oldestSeq : null,
+        hasMore: !!page.hasMore,
+      };
+    } else if (typeof store.loadOlderByGroup === 'function') {
+      // Compatibility fallback for older test doubles: use an unbounded raw
+      // prefix, then project/slice visible rows below.
       rows = store.loadOlderByGroup(groupId, beforeSeq, Infinity).messages || [];
     } else if (Number.isFinite(beforeSeq)) {
       const all = typeof store.loadAllByGroup === 'function'
@@ -3582,11 +3588,10 @@ export async function handleUnifyLoadHistory(msg) {
   }
 
   // `msg.limit` is the replay-scrollback request from the frontend (UI
-  // history pane, not engine context). Semantics changed (2026-05-01):
-  // now expressed in TURNS. The previous default (50 messages) maps to
-  // ~20–25 turns; in the turn-count world 50 turns of UI scrollback is
-  // still cheap and matches what the frontend already passes through.
-  const limit = (typeof msg.limit === 'number') ? msg.limit : 50;
+  // history pane, not engine context). Keep the bootstrap window small so
+  // opening a group can paint the latest messages quickly; older rows are
+  // paged via `unify_load_more_history` when the user scrolls upward.
+  const limit = (typeof msg.limit === 'number') ? msg.limit : 10;
   const visiblePage = groupId
     ? loadVisibleGroupHistoryPage(session.conversationStore, groupId, limit)
     : { messages: limit > 0 ? pickRecent(session.conversationStore, limit) : [], oldestSeq: null, hasMore: false };
@@ -3691,7 +3696,7 @@ export async function handleUnifyLoadMoreHistory(msg) {
   }
 
   const beforeSeq = (typeof msg.beforeSeq === 'number') ? msg.beforeSeq : null;
-  const turns = (typeof msg.turns === 'number' && msg.turns > 0) ? msg.turns : 20;
+  const turns = (typeof msg.turns === 'number' && msg.turns > 0) ? msg.turns : 10;
 
   let result;
   try {