@yeaft/webchat-agent 1.0.207 → 1.0.209

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.207",
+  "version": "1.0.209",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/yeaft/conversation/persist.js

@@ -1577,40 +1577,72 @@ export class ConversationStore {
     const limit = Math.min(50, Math.max(1, Number.isFinite(opts.limit) ? Math.floor(opts.limit) : 20));
     const beforeSeq = Number.isFinite(opts.beforeSeq) ? opts.beforeSeq : Infinity;
     const results = [];
-    const seen = new Set();
     let hasMore = false;
 
-    for (const message of this.#iterateSessionRows(sessionId, { beforeSeq, desc: true })) {
-      if (!message || message.sessionId !== sessionId || isHiddenConversationRow(message)) continue;
-      if (message.role !== 'user' && message.role !== 'assistant') continue;
-      if (!message.id || seen.has(message.id)) continue;
-      seen.add(message.id);
-
-      const text = this.#visibleSearchText(message.content);
+    for (const entry of this.#iterateVisibleResponseEntries(sessionId, { beforeSeq })) {
+      const text = entry.textParts.join(' ');
       const matchIndex = text.toLocaleLowerCase().indexOf(needle);
       if (matchIndex < 0) continue;
       if (results.length >= limit) {
         hasMore = true;
         break;
       }
-
-      const seq = parseSeqFromId(message.id);
-      if (!Number.isFinite(seq)) continue;
       results.push({
-        messageId: message.id,
-        turnId: message.turnId || message.threadId || message.id,
-        seq,
-        role: message.role,
-        speakerVpId: message.speakerVpId || null,
-        timestamp: message.ts || message.time || null,
+        ...this.#projectVisibleResponseEntry(entry),
         snippet: this.#searchSnippet(text, matchIndex, needle.length),
       });
     }
 
+    const lastResult = results[results.length - 1] || null;
+    return {
+      results: results.map(({ _beforeSeq, ...result }) => result),
+      hasMore,
+      nextBeforeSeq: hasMore && lastResult ? lastResult._beforeSeq : null,
+    };
+  }
+
+  /**
+   * Load a lightweight outline page for one Session. Only user and assistant
+   * text metadata is projected; tool payloads, attachments and full message
+   * bodies never leave the Agent through this API.
+   *
+   * @param {string} sessionId
+   * @param {{ limit?: number, beforeSeq?: number|null, includeTotal?: boolean }} [opts]
+   * @returns {{ results: object[], hasMore: boolean, nextBeforeSeq: number|null, totalCount: number|null }}
+   */
+  loadVisibleOutlineBySession(sessionId, opts = {}) {
+    if (!sessionId) return { results: [], hasMore: false, nextBeforeSeq: null, totalCount: 0 };
+
+    const limit = Math.min(100, Math.max(1, Number.isFinite(opts.limit) ? Math.floor(opts.limit) : 50));
+    const beforeSeq = Number.isFinite(opts.beforeSeq) ? opts.beforeSeq : Infinity;
+    const newestFirst = [];
+    let hasMore = false;
+
+    for (const entry of this.#iterateVisibleResponseEntries(sessionId, { beforeSeq })) {
+      if (newestFirst.length >= limit) {
+        hasMore = true;
+        break;
+      }
+      const projected = this.#projectVisibleResponseEntry(entry);
+      newestFirst.push({
+        ...projected,
+        snippet: this.#outlineSnippet(entry.textParts.join(' ')),
+      });
+    }
+
+    let totalCount = null;
+    if (opts.includeTotal !== false) {
+      totalCount = 0;
+      for (const _entry of this.#iterateVisibleResponseEntries(sessionId)) totalCount += 1;
+    }
+
+    const oldestEntry = newestFirst[newestFirst.length - 1] || null;
+    const results = newestFirst.reverse().map(({ _beforeSeq, ...entry }) => entry);
     return {
       results,
       hasMore,
-      nextBeforeSeq: hasMore && results.length > 0 ? results[results.length - 1].seq : null,
+      nextBeforeSeq: hasMore && oldestEntry ? oldestEntry._beforeSeq : null,
+      totalCount,
     };
   }
 
@@ -2381,6 +2413,75 @@ export class ConversationStore {
     };
   }
 
+  *#iterateVisibleResponseEntries(sessionId, opts = {}) {
+    const beforeSeq = Number.isFinite(opts.beforeSeq) ? opts.beforeSeq : Infinity;
+    const seen = new Set();
+    let current = null;
+
+    const visibleRow = (message) => {
+      if (!message || message.sessionId !== sessionId || isHiddenConversationRow(message)) return null;
+      if (message.role !== 'user' && message.role !== 'assistant') return null;
+      if (!message.id || seen.has(message.id)) return null;
+      seen.add(message.id);
+      const seq = parseSeqFromId(message.id);
+      if (!Number.isFinite(seq)) return null;
+      const text = this.#visibleSearchText(message.content);
+      const speakerVpId = message.speakerVpId || null;
+      return {
+        message,
+        seq,
+        text,
+        speakerVpId,
+        groupKey: message.role === 'assistant'
+          ? `assistant:${message.turnId || message.id}:${speakerVpId || ''}`
+          : `user:${message.id}`,
+      };
+    };
+    const startEntry = (row) => ({
+      groupKey: row.groupKey,
+      role: row.message.role,
+      turnId: row.message.turnId || row.message.threadId || row.message.id,
+      speakerVpId: row.speakerVpId,
+      oldestSeq: row.seq,
+      anchor: row,
+      anchorHasText: !!row.text,
+      textParts: row.text ? [row.text] : [],
+    });
+    const mergeRow = (entry, row) => {
+      entry.oldestSeq = Math.min(entry.oldestSeq, row.seq);
+      if (row.text) entry.textParts.unshift(row.text);
+      if (!entry.anchorHasText && row.text) {
+        entry.anchor = row;
+        entry.anchorHasText = true;
+      }
+    };
+
+    for (const message of this.#iterateSessionRows(sessionId, { beforeSeq, desc: true })) {
+      const row = visibleRow(message);
+      if (!row) continue;
+      if (current && current.groupKey === row.groupKey) {
+        mergeRow(current, row);
+        continue;
+      }
+      if (current) yield current;
+      current = startEntry(row);
+    }
+    if (current) yield current;
+  }
+
+  #projectVisibleResponseEntry(entry) {
+    return {
+      messageId: entry.anchor.message.id,
+      ...(entry.anchor.message.clientMessageId ? { clientMessageId: entry.anchor.message.clientMessageId } : {}),
+      turnId: entry.turnId,
+      seq: entry.anchor.seq,
+      role: entry.role,
+      speakerVpId: entry.speakerVpId,
+      timestamp: entry.anchor.message.ts || entry.anchor.message.time || null,
+      _beforeSeq: entry.oldestSeq,
+    };
+  }
+
   #visibleSearchText(content) {
     if (typeof content === 'string') return content.replace(/\s+/g, ' ').trim();
     if (!Array.isArray(content)) return '';
@@ -2399,6 +2500,11 @@ export class ConversationStore {
     return `${start > 0 ? '…' : ''}${text.slice(start, end)}${end < text.length ? '…' : ''}`;
   }
 
+  #outlineSnippet(text) {
+    const limit = 180;
+    return text.length > limit ? `${text.slice(0, limit).trimEnd()}…` : text;
+  }
+
   #readSegmentRows(conversationDir, opts = {}) {
     return this.#segmentStoreForConversationDir(conversationDir).readAll(opts);
   }

package/yeaft/web-bridge.js

@@ -6537,18 +6537,50 @@ export async function handleYeaftLoadHistory(msg) {
 }
 
 /**
- * Handle a "load older messages" pagination request. Reads `turns` more
- * turns of history strictly older than `beforeSeq` for `sessionId`, and
- * emits them in a single `yeaft_history_chunk` envelope (NOT a
- * `yeaft_output` — that pipeline appends, but the frontend needs to
- * PREPEND these older messages above what it already has).
+ * Load one lightweight Conversation Outline page. The response contains only
+ * visible user/assistant metadata and bounded snippets; full message bodies and
+ * tool payloads stay on the Agent. `beforeSeq` is an exclusive older-page
+ * cursor, and `includeTotal` avoids recounting after the first page.
  *
- * Tool replay is NOT included in this PR — same projection as
- * `handleYeaftLoadHistory` (user / assistant text only). On any internal
- * failure we still emit an empty chunk so the spinner clears.
- *
- * @param {object} msg — { sessionId, beforeSeq, turns }
+ * @param {object} msg — { sessionId, beforeSeq, limit, includeTotal }
  */
+export async function handleYeaftLoadHistoryOutline(msg) {
+  const sessionId = typeof msg?.sessionId === 'string' ? msg.sessionId.trim() : '';
+  const requestId = typeof msg?.requestId === 'string' ? msg.requestId : null;
+  const beforeSeq = Number.isFinite(msg?.beforeSeq) ? msg.beforeSeq : null;
+  const limit = Math.min(100, Math.max(1, Number.isFinite(msg?.limit) ? Math.floor(msg.limit) : 50));
+  const response = {
+    type: 'yeaft_history_outline',
+    requestId,
+    sessionId: sessionId || null,
+    results: [],
+    hasMore: false,
+    nextBeforeSeq: null,
+    totalCount: null,
+    _requestClientId: msg?._requestClientId || null,
+  };
+
+  if (!sessionId) {
+    sendToServer({ ...response, error: 'invalid_session' });
+    return;
+  }
+
+  try {
+    const defaultYeaftDir = ctx.CONFIG?.yeaftDir || DEFAULT_YEAFT_DIR;
+    const storeDir = resolveSessionYeaftDir(defaultYeaftDir, sessionId);
+    const store = new ConversationStore(storeDir);
+    const result = store.loadVisibleOutlineBySession(sessionId, {
+      limit,
+      beforeSeq,
+      includeTotal: msg?.includeTotal !== false,
+    });
+    sendToServer({ ...response, ...result });
+  } catch (err) {
+    console.error('[Yeaft] Session history outline failed:', err?.message || err);
+    sendToServer({ ...response, error: 'outline_failed' });
+  }
+}
+
 export async function handleYeaftSearchHistory(msg) {
   const sessionId = typeof msg?.sessionId === 'string' ? msg.sessionId.trim() : '';
   const query = typeof msg?.query === 'string' ? msg.query.trim().slice(0, 500) : '';

package/yeaft/work-center/projection.js

@@ -33,6 +33,18 @@ function currentAction(detail) {
   return detail.actions.find(action => action.id === detail.currentActionId) || null;
 }
 
+function projectCurrentActionSummary(action, projectedAction = action) {
+  if (!projectedAction?.id) return null;
+  return {
+    id: projectedAction.id,
+    type: projectedAction.type,
+    stageId: projectedAction.stageId,
+    assignmentMode: projectedAction.assignmentPolicy?.mode || (projectedAction.requiredRole ? 'fixed' : null),
+    status: projectedAction.status,
+    objective: truncateUtf8(action?.brief?.objective, 1_000) || null,
+  };
+}
+
 function count(value) {
   return Math.max(0, Number(value) || 0);
 }
@@ -652,7 +664,9 @@ export function projectWorkItemSummary(detail) {
       activeActionIds: Array.isArray(detail.activeActionIds) ? detail.activeActionIds : undefined,
       attentionActionIds: Array.isArray(detail.attentionActionIds) ? detail.attentionActionIds : undefined,
       currentActionId: detail.currentActionId || null,
-      currentAction: null,
+      currentAction: projectCurrentActionSummary(detail.currentAction),
+      actionCount: count(detail.actionCount),
+      completedActionCount: count(detail.completedActionCount),
       executionStats: executionStats(detail.executionStats),
       origin: detail.origin?.sessionId ? { sessionId: detail.origin.sessionId } : null,
       linkedSessionIds: Array.isArray(detail.linkedSessionIds) ? detail.linkedSessionIds : [],
@@ -677,18 +691,14 @@ export function projectWorkItemSummary(detail) {
     activeActionIds: Array.isArray(detail.activeActionIds) ? detail.activeActionIds : undefined,
     attentionActionIds: Array.isArray(detail.attentionActionIds) ? detail.attentionActionIds : undefined,
     currentActionId: detail.currentActionId || null,
+    actionCount: detail.actions.filter(item => !['superseded', 'cancelled'].includes(item?.status)).length,
+    completedActionCount: detail.actions.filter(item => item?.status === 'completed').length,
     executionStats: Array.isArray(detail.runs)
       ? sumExecutionStats(detail.runs)
       : executionStats(detail.executionStats),
     failureReason: workItemFailureReason(detail),
 
-    currentAction: projectedAction ? {
-      id: projectedAction.id,
-      type: projectedAction.type,
-      stageId: projectedAction.stageId,
-      assignmentMode: projectedAction.assignmentPolicy?.mode || (projectedAction.requiredRole ? 'fixed' : null),
-      status: projectedAction.status,
-    } : null,
+    currentAction: projectCurrentActionSummary(action, projectedAction),
     origin: detail.origin?.sessionId ? { sessionId: detail.origin.sessionId } : null,
     linkedSessionIds: Array.isArray(detail.linkedSessionIds) ? detail.linkedSessionIds : [],
     attachmentCount: Array.isArray(detail.attachments) ? detail.attachments.length : 0,

package/yeaft/work-center/store.js

@@ -70,12 +70,21 @@ function mapWorkItem(row) {
     workflowSnapshot: parseJson(row.workflow_snapshot, null),
     status: row.status,
     currentActionId: row.current_action_id || null,
+    currentAction: row.current_action_type ? {
+      id: row.current_action_id,
+      type: row.current_action_type,
+      stageId: row.current_action_stage_id || row.current_action_type,
+      status: row.current_action_status || null,
+      brief: parseJson(row.current_action_brief, null),
+    } : null,
     currentRunId: row.current_run_id || null,
     workDir: row.work_dir || '',
     workspaceKey: row.workspace_key || '',
     reuseMemory: row.reuse_memory !== 0,
     origin: parseJson(row.origin, null),
     linkedSessionIds: parseJson(row.linked_session_ids, []),
+    actionCount: Math.max(0, Number(row.action_count) || 0),
+    completedActionCount: Math.max(0, Number(row.completed_action_count) || 0),
     sessionContext: parseJson(row.session_context, []),
     messages: parseJson(row.messages, []),
     attachments: parseJson(row.attachments, []),
@@ -1190,6 +1199,14 @@ export class WorkItemStore {
     }
     const limit = Math.min(Math.max(Number(filters.limit) || 100, 1), 500);
     const sql = `SELECT w.*,
+        current_action.type AS current_action_type,
+        current_action.stage_id AS current_action_stage_id,
+        current_action.status AS current_action_status,
+        current_action.brief AS current_action_brief,
+        (SELECT COUNT(*) FROM actions a WHERE a.work_item_id = w.id
+          AND a.status NOT IN ('superseded', 'cancelled')) AS action_count,
+        (SELECT COUNT(*) FROM actions a WHERE a.work_item_id = w.id
+          AND a.status = 'completed') AS completed_action_count,
         COALESCE(SUM(r.llm_request_count), 0) AS usage_llm_request_count,
         COALESCE(SUM(r.loop_count), 0) AS usage_loop_count,
         COALESCE(SUM(r.tool_count), 0) AS usage_tool_count,
@@ -1198,7 +1215,9 @@ export class WorkItemStore {
         COALESCE(SUM(r.cache_read_tokens), 0) AS usage_cache_read_tokens,
         COALESCE(SUM(r.cache_write_tokens), 0) AS usage_cache_write_tokens,
         COALESCE(SUM(r.total_tokens), 0) AS usage_total_tokens
-      FROM work_items w LEFT JOIN runs r ON r.work_item_id = w.id
+      FROM work_items w
+      LEFT JOIN actions current_action ON current_action.id = w.current_action_id
+      LEFT JOIN runs r ON r.work_item_id = w.id
       ${where.length ? `WHERE ${where.join(' AND ')}` : ''}
       GROUP BY w.id ORDER BY w.updated_at DESC LIMIT ?`;
     return this.db.prepare(sql).all(...values, limit).map(mapWorkItem).map(workItem => {