@yeaft/webchat-agent 0.1.1090 → 0.1.1091

package/package.json

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

package/yeaft/conversation/persist.js

@@ -27,7 +27,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 { countTurns, indexOfNthTurnFromEnd, sliceLastNTurns } from '../turn-utils.js';
+import { countTurns, indexOfNthTurnFromEnd, sliceLastNTurns, stripVpMentionPrefix } from '../turn-utils.js';
 
 /**
  * Default cold-start "recent window" size, expressed in TURNS (not raw
@@ -167,6 +167,17 @@ function compareMessagesBySeq(a, b) {
   return String(a?.time || '').localeCompare(String(b?.time || ''));
 }
 
+function canonicalUserTurnContent(content) {
+  if (typeof content === 'string') return stripVpMentionPrefix(content);
+  if (!Array.isArray(content)) return null;
+  const text = content
+    .filter(part => part && typeof part === 'object' && part.type === 'text')
+    .map(part => typeof part.text === 'string' ? part.text : '')
+    .join('\n')
+    .trim();
+  return text ? stripVpMentionPrefix(text) : null;
+}
+
 // ─── Frontmatter helpers ─────────────────────────────────────
 
 /**
@@ -1057,19 +1068,24 @@ export class ConversationStore {
     if (!sessionId || !(turnsLimit > 0)) return { messages: [], oldestSeq: null, hasMore: false };
 
     const cutoff = Number.isFinite(beforeSeq) ? beforeSeq : Infinity;
-    const hot = this.#loadVisibleFromDirsBySession([...this.#sessionMessageDirs('messages', sessionId), this.#legacyMsgDir], sessionId, cutoff);
-    const cold = this.#loadVisibleFromDirsBySession([...this.#sessionMessageDirs('cold', sessionId), this.#legacyColdDir], sessionId, cutoff);
-    const visible = [...cold, ...hot];
-    if (visible.length === 0) return { messages: [], oldestSeq: null, hasMore: false };
+    const page = this.#loadVisibleWindowBySession(
+      [
+        ...this.#sessionMessageDirs('messages', sessionId),
+        this.#legacyMsgDir,
+        ...this.#sessionMessageDirs('cold', sessionId),
+        this.#legacyColdDir,
+      ],
+      sessionId,
+      cutoff,
+      turnsLimit
+    );
 
-    const startIdx = indexOfNthTurnFromEnd(visible, turnsLimit);
-    const start = startIdx === -1 ? 0 : startIdx;
     // Visible history is for UI replay, not LLM context. The visible loader
     // already excludes tool-result rows, so running pairSanitize here can
     // incorrectly treat tool-using assistant replies as orphaned tool arcs and
     // drop/trim VP messages. Strip tool-call metadata instead and keep the
     // user-visible assistant text for the conversation pane.
-    const messages = visible.slice(start).map(m => {
+    const messages = page.messages.map(m => {
       if (m && m.role === 'assistant' && Array.isArray(m.toolCalls) && m.toolCalls.length > 0) {
         const { toolCalls, ...rest } = m;
         return rest;
@@ -1077,16 +1093,11 @@ export class ConversationStore {
       return m;
     });
     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,
+      hasMore: page.hasMore,
     };
   }
 
@@ -1733,9 +1744,85 @@ export class ConversationStore {
     return total;
   }
 
-  #loadVisibleFromDirsBySession(dirs, sessionId, beforeSeq) {
-    return dirs.flatMap(dir => this.#loadVisibleFromDirBySession(dir, sessionId, beforeSeq))
-      .sort(compareMessagesBySeq);
+  #loadVisibleWindowBySession(dirs, sessionId, beforeSeq, turnsLimit) {
+    const candidates = [];
+    const seen = new Set();
+    for (const dir of dirs) {
+      if (!existsSync(dir)) continue;
+      let files = [];
+      try {
+        files = readdirSync(dir);
+      } catch (err) {
+        if (!isPermissionError(err)) throw err;
+        continue;
+      }
+      for (const file of files) {
+        if (!file.endsWith('.md')) continue;
+        const seq = parseSeqFromId(basename(file, '.md'));
+        if (!Number.isFinite(seq) || seq >= beforeSeq) continue;
+        const path = join(dir, file);
+        if (seen.has(path)) continue;
+        seen.add(path);
+        candidates.push({ seq, path });
+      }
+    }
+
+    candidates.sort((a, b) => b.seq - a.seq);
+
+    const selected = [];
+    const pendingBoundaryTail = [];
+    let turnsSeen = 0;
+    let openCanonical = null;
+    let boundaryCanonical = null;
+    let hasMore = false;
+
+    for (const candidate of candidates) {
+      let raw = '';
+      try {
+        raw = readFileSync(candidate.path, 'utf8');
+      } catch (err) {
+        if (!isPermissionError(err)) throw err;
+        continue;
+      }
+      if (!raw.includes(`sessionId: ${sessionId}`)) continue;
+      if (!raw.includes('role: user') && !raw.includes('role: assistant')) continue;
+
+      const parsed = parseMessage(raw);
+      if (!parsed || parsed.sessionId !== sessionId) continue;
+      if (parsed._reflection || parsed.internal || parsed.systemOnly || parsed.systemOnlyMessage) continue;
+      if (parsed.role !== 'user' && parsed.role !== 'assistant') continue;
+
+      if (boundaryCanonical !== null) {
+        if (parsed.role !== 'user') {
+          pendingBoundaryTail.push(parsed);
+          continue;
+        }
+
+        const canonical = canonicalUserTurnContent(parsed.content);
+        if (canonical !== boundaryCanonical) {
+          hasMore = true;
+          break;
+        }
+
+        if (pendingBoundaryTail.length > 0) {
+          selected.push(...pendingBoundaryTail.splice(0));
+        }
+        selected.push(parsed);
+        continue;
+      }
+
+      selected.push(parsed);
+      if (parsed.role === 'user') {
+        const canonical = canonicalUserTurnContent(parsed.content);
+        if (canonical != null && canonical !== openCanonical) {
+          turnsSeen += 1;
+          openCanonical = canonical;
+          if (turnsSeen === turnsLimit) boundaryCanonical = canonical;
+        }
+      }
+    }
+
+    return { messages: selected.reverse(), hasMore };
   }
 
   // task-314: per-thread sub-directory for forked threads.
@@ -1796,32 +1883,6 @@ export class ConversationStore {
     return messages;
   }
 
-  #loadVisibleFromDirBySession(dir, sessionId, 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(`sessionId: ${sessionId}`)) continue;
-      if (!raw.includes('role: user') && !raw.includes('role: assistant')) continue;
-
-      const parsed = parseMessage(raw);
-      if (!parsed || parsed.sessionId !== sessionId) 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/yeaft/web-bridge.js

@@ -22,6 +22,7 @@ import { join } from 'node:path';
 import { COLLAB_TOOL_POLICY } from './tools/registry.js';
 import { existsSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
+import { DEFAULT_YEAFT_DIR } from './init.js';
 import { buildDreamOutputSnapshot } from './dream/output-snapshot.js';
 import { Engine } from './engine.js';
 import { loadSession } from './session.js';
@@ -60,7 +61,7 @@ import {
   trimSnapshotForBudget,
 } from './history-compact.js';
 import { persistYeaftAttachments, attachmentsForPersistence, persistedAttachmentPreviewPayload } from './attachments.js';
-import { parseSeqFromId } from './conversation/persist.js';
+import { ConversationStore, parseSeqFromId } from './conversation/persist.js';
 import { sliceLastNTurns } from './turn-utils.js';
 import { pairSanitize } from './pair-sanitize.js';
 import { filterSnapshotForVp } from './snapshot-filter.js';
@@ -766,6 +767,76 @@ function loadVisibleGroupHistoryPage(store, sessionId, limit, beforeSeq = null)
   };
 }
 
+function ensureYeaftConversationId() {
+  if (!yeaftConversationId) yeaftConversationId = `yeaft-${Date.now()}`;
+  return yeaftConversationId;
+}
+
+function emitVisibleHistoryReplay({ store, sessionId, limit, beforeSeq = null, mode = 'recent' }) {
+  const visiblePage = sessionId
+    ? loadVisibleGroupHistoryPage(store, sessionId, limit, beforeSeq)
+    : { messages: limit > 0 ? (store.loadRecent?.(limit) || []) : [], oldestSeq: null, hasMore: false };
+  const replayEntries = sessionId
+    ? visiblePage.messages
+    : visiblePage.messages
+      .map(projectPersistedToVisibleHistoryEntry)
+      .filter(Boolean);
+
+  for (const entry of replayEntries) {
+    if (entry.role === 'user') {
+      sendSessionOutputFrame({
+        type: 'user',
+        message: {
+          content: entry.content,
+          id: entry.id || null,
+          ...(Array.isArray(entry.attachments) && entry.attachments.length > 0 ? { attachments: hydrateHistoryAttachmentPreviews(entry.attachments) } : {}),
+        },
+        ts: entry.ts || null,
+      }, { sessionId: entry.sessionId || null, threadId: entry.threadId || 'main', turnId: entry.turnId || entry.threadId || 'main' });
+    } else if (entry.role === 'assistant') {
+      const envelopeOpts = {
+        sessionId: entry.sessionId || null,
+        threadId: entry.threadId || 'main',
+        turnId: entry.turnId || entry.threadId || 'main',
+      };
+      if (entry.speakerVpId) envelopeOpts.vpId = entry.speakerVpId;
+      sendSessionOutputFrame({
+        type: 'assistant',
+        message: { id: entry.id || null, content: [{ type: 'text', text: entry.content }] },
+        ts: entry.ts || null,
+      }, envelopeOpts);
+      if (Array.isArray(entry.toolCalls) && entry.toolCalls.length > 0) {
+        sendSessionOutputFrame({
+          type: 'assistant',
+          message: {
+            content: [{
+              type: 'tool_summary',
+              count: entry.toolCalls.length,
+              omittedCount: entry.toolCalls.length,
+              source: 'history',
+            }],
+          },
+          ts: entry.ts || null,
+        }, envelopeOpts);
+      }
+      sendSessionOutputFrame({ type: 'result', result_text: '' }, envelopeOpts);
+    }
+  }
+
+  const latestSeq = replayEntries.length
+    ? parseSeqFromId(replayEntries[replayEntries.length - 1]?.id)
+    : null;
+  sendSessionEvent({
+    type: 'history_loaded',
+    mode,
+    count: replayEntries.length,
+    sessionId,
+    hasMore: visiblePage.hasMore,
+    oldestSeq: visiblePage.oldestSeq,
+    latestSeq: Number.isFinite(latestSeq) ? latestSeq : null,
+  });
+}
+
 /**
  * Hydrate a freshly-created GroupContext's history from the on-disk
  * conversation store. Returns an empty array if the session isn't
@@ -873,6 +944,7 @@ export function __testGroupHistory(sessionId) {
  */
 export function __testSetSession(sessionLike) {
   session = sessionLike;
+  if (!sessionLike) yeaftConversationId = null;
 }
 
 /**
@@ -4303,18 +4375,60 @@ export async function handleYeaftLoadHistory(msg) {
   // (DEFAULT_RECENT_TURNS = 20 turns).
   const pickRecent = (store, lim) =>
     sessionId ? store.loadRecentBySession(sessionId, lim) : store.loadRecent(lim);
+  let historyAlreadyReplayed = false;
 
   if (!session) {
-    const yeaftDir = ctx.CONFIG?.yeaftDir;
+    const yeaftDir = ctx.CONFIG?.yeaftDir || DEFAULT_YEAFT_DIR;
+    const afterSeqRaw = (msg && Number.isFinite(msg.afterSeq)) ? msg.afterSeq : null;
+    const afterMessageId = (msg && typeof msg.afterMessageId === 'string') ? msg.afterMessageId : null;
+    const limit = (typeof msg.limit === 'number') ? msg.limit : 10;
+    ensureYeaftConversationId();
+
+    // First paint must not wait for full Yeaft runtime boot (MCP connects,
+    // skill scans, memory index sync). The conversation markdown store is the
+    // source of truth and can be opened cheaply, so replay the visible message
+    // window immediately, then finish loadSession below for actual turns.
+    const coldStore = new ConversationStore(yeaftDir);
+    if (sessionId && (afterSeqRaw !== null || afterMessageId)) {
+      let afterSeq = afterSeqRaw;
+      if (afterSeq === null && afterMessageId && typeof coldStore.getMessageSeqById === 'function') {
+        afterSeq = coldStore.getMessageSeqById(afterMessageId);
+      }
+      const delta = afterSeq !== null && typeof coldStore.loadAfterSeqByGroup === 'function'
+        ? coldStore.loadAfterSeqByGroup(sessionId, afterSeq)
+        : { messages: [], latestSeq: null };
+      for (const entry of delta.messages) {
+        if (entry.role === 'user') {
+          sendSessionOutputFrame({
+            type: 'user',
+            message: { content: entry.content, id: entry.id || null },
+            ts: entry.ts || null,
+          }, { sessionId: entry.sessionId || null, threadId: entry.threadId || 'main', turnId: entry.turnId || entry.threadId || 'main' });
+        } else if (entry.role === 'assistant') {
+          const envelopeOpts = { sessionId: entry.sessionId || null, threadId: entry.threadId || 'main', turnId: entry.turnId || entry.threadId || 'main' };
+          if (entry.speakerVpId) envelopeOpts.vpId = entry.speakerVpId;
+          sendSessionOutputFrame({
+            type: 'assistant',
+            message: { id: entry.id || null, content: [{ type: 'text', text: entry.content }] },
+            ts: entry.ts || null,
+          }, envelopeOpts);
+          sendSessionOutputFrame({ type: 'result', result_text: '' }, envelopeOpts);
+        }
+      }
+      sendSessionEvent({ type: 'history_loaded', mode: 'delta', count: delta.messages.length, sessionId, latestSeq: delta.latestSeq, afterSeq });
+    } else {
+      emitVisibleHistoryReplay({ store: coldStore, sessionId, limit, mode: 'recent' });
+    }
+    historyAlreadyReplayed = true;
+
     session = await loadSession({
-      ...(yeaftDir && { dir: yeaftDir }),
+      dir: yeaftDir,
       skipMCP: false,
       skipSkills: false,
       serverMode: true,
     });
     installYeaftRuntimeBridge(session);
 
-    yeaftConversationId = `yeaft-${Date.now()}`;
     refreshLiveSessionConfig();
     hydrateYeaftStatusFromSession(session, { reason: 'history_load', emitEvent: true });
 
@@ -4362,6 +4476,8 @@ export async function handleYeaftLoadHistory(msg) {
     console.warn('[Yeaft] vp-status snapshot broadcast (replay) failed:', err?.message || err);
   }
 
+  if (historyAlreadyReplayed) return;
+
   // Delta path: caller knows the latest seq (or message id) it has cached
   // and wants only the messages that arrived after that cursor. Returns
   // early with mode:'delta' so the frontend can append+dedupe instead of