@yeaft/webchat-agent 0.1.680 → 0.1.683

package/package.json

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

package/unify/conversation/persist.js

@@ -442,6 +442,42 @@ export class ConversationStore {
     return this.#loadFromDir(this.#msgDir, Infinity);
   }
 
+  /**
+   * Load recent hot messages stamped with `groupId`, sorted chronologically.
+   * Group-history-isolation (Bug 7): a message lives in exactly one group.
+   * Messages without a `groupId` frontmatter (legacy / pre-grouping) are
+   * NOT returned — they would otherwise leak into every group's stream.
+   *
+   * Implementation note: filters AFTER reading the most recent N files
+   * because the on-disk order is global by sequence id. We over-read by
+   * loading all hot files and slicing the tail of the filtered set so
+   * `limit` reflects "N most recent messages in this group", not "N most
+   * recent messages on disk that happen to be in this group". For typical
+   * inboxes (≤ a few thousand hot messages) this is cheap; if it ever
+   * becomes a hot path we add a per-group on-disk index.
+   *
+   * @param {string} groupId — required; null/empty returns []
+   * @param {number} [limit=50]
+   * @returns {object[]}
+   */
+  loadRecentByGroup(groupId, limit = 50) {
+    if (!groupId) return [];
+    const all = this.#loadFromDir(this.#msgDir, Infinity);
+    const filtered = all.filter(m => m && m.groupId === groupId);
+    if (limit === Infinity || limit < 0) return filtered;
+    return filtered.slice(-limit);
+  }
+
+  /**
+   * Load every hot message stamped with `groupId`.
+   *
+   * @param {string} groupId
+   * @returns {object[]}
+   */
+  loadAllByGroup(groupId) {
+    return this.loadRecentByGroup(groupId, Infinity);
+  }
+
   /**
    * Count hot messages.
    *

package/unify/tool-folding/index.js

@@ -23,12 +23,27 @@ export { buildFallbackStub } from './fallback-stub.js';
 
 /**
  * Collapse messages[startIdx..endIdx] (inclusive) into a single
- * `{ role: 'assistant', content }` message. Returns a NEW array; does not
- * mutate the input.
+ * `{ role: 'user', content }` reflection message. Returns a NEW array; does
+ * not mutate the input.
  *
- * The original assistant+tool sequence (the action arc) is replaced by the
- * reflection; user messages within that range stay put (defensive — the
- * caller normally passes a range that contains only assistant+tool).
+ * The original assistant+tool sequence (the action arc) is replaced by ONE
+ * synthetic user message carrying the reflection summary. User messages
+ * that happened to appear inside the range stay put (defensive — the caller
+ * normally passes a range that contains only assistant+tool).
+ *
+ * Why role='user' (not 'assistant'):
+ *   The Anthropic Messages API requires the messages array to end with a
+ *   user message before the next assistant turn. If we collapsed into an
+ *   assistant message and the reflection happened to land at the tail
+ *   (e.g. immediately before #applyPendingT2Reflections fires its next
+ *   query), the API rejects the request with "model does not support
+ *   assistant message prefill".
+ *
+ *   Following Claude Code's compact pattern, we wrap the reflection as a
+ *   synthetic user message — the model treats it as a context-recovery
+ *   directive and continues from there. The opening line ("The previous N
+ *   tool calls have been folded ...") plus the closing "Continue from
+ *   here." make it unambiguous that this is not a fresh user prompt.
  *
  * @param {Array} messages
  * @param {number} startIdx
@@ -43,13 +58,28 @@ export function collapseRangeToReflection(messages, startIdx, endIdx, reflection
   const collapsed = messages.slice(startIdx, endIdx + 1);
   const after = messages.slice(endIdx + 1);
 
+  // Count tool_use occurrences inside the collapsed range so the wrapper
+  // text can name how many calls were folded. Falls back to "previous"
+  // wording when no tool calls are detected.
+  let toolCount = 0;
+  for (const m of collapsed) {
+    if (m && m.role === 'assistant' && Array.isArray(m.toolCalls)) {
+      toolCount += m.toolCalls.length;
+    }
+  }
+
   // Preserve any user messages that happened to appear inside the range
   // (not expected per V7 spec, but defensive). Everything else (assistant +
-  // tool) is replaced by ONE assistant reflection message.
+  // tool) is replaced by ONE synthetic user reflection message.
   const preservedUsers = collapsed.filter(m => m && m.role === 'user');
+  const header = toolCount > 0
+    ? `The previous ${toolCount} tool call${toolCount === 1 ? '' : 's'} have been folded for context efficiency.`
+    : 'The previous tool calls have been folded for context efficiency.';
+  const wrappedContent =
+    `${header}\n\nSummary:\n${reflectionContent}\n\nContinue from here.`;
   const reflectionMsg = {
-    role: 'assistant',
-    content: reflectionContent,
+    role: 'user',
+    content: wrappedContent,
     _reflection: true,
   };
   return [...before, ...preservedUsers, reflectionMsg, ...after];

package/unify/web-bridge.js

@@ -1384,8 +1384,18 @@ export function handleUnifyModelSwitch(msg) {
 /**
  * Handle history load request. Loads recent messages from ConversationStore
  * and replays them through the standard claude_output pipeline.
+ *
+ * Group-history-isolation (Bug 7): when `msg.groupId` is provided the
+ * replay AND the engine's bootstrap context are filtered to that group.
+ * Messages tagged with another groupId — and legacy messages with no
+ * groupId at all — are excluded so a stale `grp_default` (or any other
+ * group) never bleeds into the active group's pane.
  */
 export async function handleUnifyLoadHistory(msg) {
+  const groupId = (msg && typeof msg.groupId === 'string' && msg.groupId) || null;
+  const pickRecent = (store, lim) =>
+    groupId ? store.loadRecentByGroup(groupId, lim) : store.loadRecent(lim);
+
   if (!session) {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
     session = await loadSession({
@@ -1397,7 +1407,12 @@ export async function handleUnifyLoadHistory(msg) {
 
     unifyConversationId = `unify-${Date.now()}`;
 
-    restoreHistoryFromRecent(session.conversationStore.loadRecent(50));
+    restoreHistoryFromRecent(pickRecent(session.conversationStore, 50));
+  } else if (groupId) {
+    // Re-entering an existing session with a (possibly new) group filter:
+    // re-seed the engine's flat history so it doesn't carry messages from
+    // another group into the next turn's context.
+    restoreHistoryFromRecent(pickRecent(session.conversationStore, 50));
   }
 
   // Always replay session_ready so refresh / reconnect rebuilds UI state.
@@ -1413,7 +1428,7 @@ export async function handleUnifyLoadHistory(msg) {
   sendGroupSnapshotBroadcast();
 
   const limit = (typeof msg.limit === 'number') ? msg.limit : 50;
-  const messages = limit > 0 ? session.conversationStore.loadRecent(limit) : [];
+  const messages = limit > 0 ? pickRecent(session.conversationStore, limit) : [];
   const compactSummary = session.conversationStore.readCompactSummary();
 
   for (const m of messages) {
@@ -1434,6 +1449,7 @@ export async function handleUnifyLoadHistory(msg) {
     hasCompactSummary: !!compactSummary,
     totalHot: session.conversationStore.countHot(),
     totalCold: session.conversationStore.countCold(),
+    groupId,
   });
 }