@yeaft/webchat-agent 0.1.797 → 0.1.799

package/package.json

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

package/unify/dream-v2/schedule.js

@@ -50,7 +50,11 @@ export function createDreamScheduler({ run, intervalMs = DEFAULT_INTERVAL_MS, ke
   async function fire(opts) {
     if (inflight) {
       log.warn?.('[dream] tick dropped — previous run still in progress');
-      return inflight;
+      return {
+        skipped: true,
+        skippedReason: 'already-running',
+        trigger: opts?.manual ? 'manual' : 'auto',
+      };
     }
     inflight = (async () => {
       try {

package/unify/web-bridge.js

@@ -52,6 +52,7 @@ import {
 } from './history-compact.js';
 import { persistUnifyAttachments, attachmentsForPersistence } from './attachments.js';
 import { parseSeqFromId } from './conversation/persist.js';
+import { sliceLastNTurns } from './turn-utils.js';
 import { createVpStatusBroker } from './vp-status-broker.js';
 import { classifyThread as defaultClassifyThread, fallbackTitle } from './vp/thread-classifier.js';
 
@@ -76,8 +77,8 @@ export function __testSetThreadClassifier(fn) {
  * the first's inflight promise and dropped its own scope filter. So
  * "B during A's run" doesn't actually produce a separate scoped pass
  * for B — letting B install a second sink wrapper would only mis-stamp
- * A's events with B's groupId. Rejecting B with an explicit error is
- * the honest answer; the user can re-click after A settles.
+ * A's events with B's groupId. Reporting B as an explicit skipped
+ * result is the honest answer; the user can re-click after A settles.
  * @type {Set<string>}
  */
 const inflightScopedDreamGroups = new Set();
@@ -523,6 +524,54 @@ function projectPersistedToHistoryEntry(m) {
   return entry;
 }
 
+function projectPersistedToVisibleHistoryEntry(m) {
+  const entry = projectPersistedToHistoryEntry(m);
+  return entry && (entry.role === 'user' || entry.role === 'assistant') ? entry : null;
+}
+
+function loadVisibleGroupHistoryPage(store, groupId, limit, beforeSeq = null) {
+  if (!store || !groupId || !(limit > 0)) return { messages: [], oldestSeq: null, hasMore: false };
+
+  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.
+      rows = store.loadOlderByGroup(groupId, beforeSeq, Infinity).messages || [];
+    } else if (Number.isFinite(beforeSeq)) {
+      const all = typeof store.loadAllByGroup === 'function'
+        ? store.loadAllByGroup(groupId)
+        : store.loadRecentByGroup(groupId, Infinity);
+      rows = all.filter(m => parseSeqFromId(m?.id) < beforeSeq);
+    } else if (typeof store.loadAllByGroup === 'function') {
+      rows = store.loadAllByGroup(groupId);
+    } else {
+      rows = store.loadRecentByGroup(groupId, Infinity);
+    }
+  } catch (err) {
+    console.error('[Unify] visible history page load failed:', err?.message || err);
+    return { messages: [], oldestSeq: null, hasMore: false };
+  }
+
+  const visible = rows
+    .map(projectPersistedToVisibleHistoryEntry)
+    .filter(Boolean);
+  const messages = sliceLastNTurns(visible, limit);
+  const oldestSeq = messages.length ? parseSeqFromId(messages[0].id) : null;
+  const firstVisibleSeq = visible.length ? parseSeqFromId(visible[0].id) : null;
+  const hasMore = messages.length > 0
+    && Number.isFinite(oldestSeq)
+    && Number.isFinite(firstVisibleSeq)
+    && oldestSeq > firstVisibleSeq;
+
+  return {
+    messages,
+    oldestSeq: Number.isFinite(oldestSeq) ? oldestSeq : null,
+    hasMore,
+  };
+}
+
 /**
  * Hydrate a freshly-created GroupContext's history from the on-disk
  * conversation store. Returns an empty array if the session isn't
@@ -2955,10 +3004,12 @@ export function normalizeDreamResult(result) {
     .filter(t => t && t.status === 'error')
     .map(t => ({ target: t.target || null, error: t.error || 'unknown' }));
   const hardError = result?.error || null;
-  const skipped = !hardError && groupsProcessed === 0 && targetsApplied === 0;
+  const explicitSkipped = result?.skipped === true;
+  const skipped = !hardError && (explicitSkipped || (groupsProcessed === 0 && targetsApplied === 0));
   const skippedReason = skipped
-    ? (skippedGroups[0]?.reason || 'no-targets-applied')
+    ? (result?.skippedReason || skippedGroups[0]?.reason || 'no-targets-applied')
     : null;
+  const trigger = result?.trigger || null;
   const success = !hardError && targetErrors.length === 0 && !skipped && targetsApplied > 0;
 
   return {
@@ -2971,6 +3022,7 @@ export function normalizeDreamResult(result) {
     targetErrors,
     entriesCreated: targetsApplied,
     lastDreamAt: result?.startedAt || new Date().toISOString(),
+    trigger,
     error: hardError || (targetErrors[0]?.error || null),
   };
 }
@@ -3007,11 +3059,16 @@ export async function handleUnifyDreamTrigger(msg = {}) {
   // dream-v2/schedule.js inflight reuse), so the user-facing semantics
   // are unchanged ("you already asked").
   if (groupId && inflightScopedDreamGroups.size > 0) {
-    const error = 'A dream pass is already running.';
+    const skippedResult = {
+      skipped: true,
+      skippedReason: 'already-running',
+      trigger: msg.manual === false ? 'auto' : 'manual',
+    };
     sendToServer({
       type: 'unify_dream_result',
       ...tag,
-      ...normalizeDreamResult({ error }),
+      ...skippedResult,
+      ...normalizeDreamResult(skippedResult),
     });
     return;
   }
@@ -3283,12 +3340,17 @@ export async function handleUnifyLoadHistory(msg) {
   // ~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;
-  const messages = limit > 0 ? pickRecent(session.conversationStore, limit) : [];
+  const visiblePage = groupId
+    ? loadVisibleGroupHistoryPage(session.conversationStore, groupId, limit)
+    : { messages: limit > 0 ? pickRecent(session.conversationStore, limit) : [], oldestSeq: null, hasMore: false };
   const compactSummary = session.conversationStore.readCompactSummary();
+  const replayEntries = groupId
+    ? visiblePage.messages
+    : visiblePage.messages
+      .map(projectPersistedToVisibleHistoryEntry)
+      .filter(Boolean);
 
-  for (const m of messages) {
-    const entry = projectPersistedToHistoryEntry(m);
-    if (!entry) continue;
+  for (const entry of replayEntries) {
     if (entry.role === 'user') {
       sendUnifyOutput({ type: 'user', message: { content: entry.content, id: entry.id || null } }, { groupId: entry.groupId || null });
     } else if (entry.role === 'assistant') {
@@ -3310,33 +3372,19 @@ export async function handleUnifyLoadHistory(msg) {
 
   // Compute the pagination cursor for the bootstrap load so the frontend
   // knows whether a "Load older messages" hint should be shown and where
-  // to start the next page. The cursor is the seq of the oldest replayed
-  // message; `hasMore` is true iff there's an earlier message in the
-  // group that we did NOT replay.
+  // to start the next page. For group history, this is computed from the
+  // visible projected page, not raw persisted rows, so reflection/internal
+  // tail rows cannot consume the bootstrap window or create false hasMore.
   let hasMore = false;
   let oldestSeq = null;
-  if (groupId && messages.length > 0) {
-    const firstId = messages[0].id;
-    const seq = parseSeqFromId(firstId);
-    // Defend against malformed ids: a NaN cursor would round-trip back as
-    // a poison `beforeSeq` and degrade subsequent paginations to "give me
-    // the newest page again". Surface as null instead.
-    oldestSeq = Number.isFinite(seq) ? seq : null;
-    if (oldestSeq != null) {
-      // Consult the store for whether anything older exists in the same
-      // group. Cheap: a single extra `loadOlderByGroup` with turns=1.
-      try {
-        const probe = session.conversationStore.loadOlderByGroup(groupId, oldestSeq, 1);
-        hasMore = probe.messages.length > 0;
-      } catch (err) {
-        console.error('[Unify] history-load probe failed:', err.message);
-      }
-    }
+  if (groupId) {
+    hasMore = visiblePage.hasMore;
+    oldestSeq = visiblePage.oldestSeq;
   }
 
   sendUnifyEvent({
     type: 'history_loaded',
-    count: messages.length,
+    count: replayEntries.length,
     hasCompactSummary: !!compactSummary,
     totalHot: session.conversationStore.countHot(),
     totalCold: session.conversationStore.countCold(),
@@ -3378,7 +3426,7 @@ export async function handleUnifyLoadMoreHistory(msg) {
 
   let result;
   try {
-    result = session.conversationStore.loadOlderByGroup(groupId, beforeSeq, turns);
+    result = loadVisibleGroupHistoryPage(session.conversationStore, groupId, turns, beforeSeq);
   } catch (err) {
     console.error('[Unify] loadOlderByGroup failed:', err.message);
     result = { messages: [], oldestSeq: null, hasMore: false };
@@ -3389,8 +3437,6 @@ export async function handleUnifyLoadMoreHistory(msg) {
   // server-side, and stable ids + speaker attribution ride with each row
   // so older-history prepend renders exactly like refresh replay.
   const projected = (result.messages || [])
-    .map(projectPersistedToHistoryEntry)
-    .filter(m => m && (m.role === 'user' || m.role === 'assistant'))
     .map(m => ({
       ...(m.id ? { id: m.id } : {}),
       role: m.role,