@yeaft/webchat-agent 0.1.849 → 0.1.851

package/package.json

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

package/unify/conversation/persist.js

@@ -329,6 +329,7 @@ export class ConversationStore {
   #coldDir;     // ~/.yeaft/conversation/cold
   #indexPath;   // ~/.yeaft/conversation/index.md
   #compactPath; // ~/.yeaft/conversation/compact.md
+  #compactScopedDir; // ~/.yeaft/conversation/compact/  (per-(group,vp))
   #nextSeq;     // next message sequence number (global, legacy)
   #nextSeqByThread; // Map<threadId, number> — per-thread counters (task-314)
 
@@ -342,11 +343,15 @@ export class ConversationStore {
     this.#coldDir = join(dir, 'conversation', 'cold');
     this.#indexPath = join(dir, 'conversation', 'index.md');
     this.#compactPath = join(dir, 'conversation', 'compact.md');
+    // Per-(groupId, vpId) compact summary files live here. The legacy
+    // single-file `compact.md` above is kept for backward compatibility
+    // and the "no groupId/vpId" fallback (sub-agents, legacy callers).
+    this.#compactScopedDir = join(dir, 'conversation', 'compact');
     this.#nextSeq = null;
     this.#nextSeqByThread = new Map();
 
     // Ensure directories exist (graceful on permission errors)
-    for (const d of [this.#convDir, this.#msgDir, this.#coldDir]) {
+    for (const d of [this.#convDir, this.#msgDir, this.#coldDir, this.#compactScopedDir]) {
       try {
         if (!existsSync(d)) mkdirSync(d, { recursive: true, mode: 0o755 });
       } catch (err) {
@@ -481,6 +486,111 @@ export class ConversationStore {
     return readFileSync(this.#compactPath, 'utf8');
   }
 
+  /**
+   * Sanitize one id (groupId or vpId) into a safe filename component.
+   * Anything outside `[A-Za-z0-9._-]` collapses to `_`; max 120 chars.
+   * The result is only ever used as a basename joined to `compactScopedDir`
+   * — path traversal is blocked by the basename-only `join`, not by the
+   * regex (a literal `..` stays as `..` here and becomes part of a
+   * regular filename via the `__` separator + `.md` suffix).
+   *
+   * @param {string} s
+   * @returns {string}
+   */
+  #safeIdComponent(s) {
+    return String(s).replace(/[^A-Za-z0-9._-]/g, '_').slice(0, 120);
+  }
+
+  /**
+   * Sanitize a (groupId, vpId) pair into a safe filename. We accept
+   * arbitrary user strings here (groupIds and vpIds are user-set), so
+   * the result is purely a basename — never parsed back.
+   *
+   * @param {string} groupId
+   * @param {string} vpId
+   * @returns {string|null} — full path, or null if either id missing
+   */
+  #scopedCompactPath(groupId, vpId) {
+    if (!groupId || !vpId) return null;
+    return join(this.#compactScopedDir, `${this.#safeIdComponent(groupId)}__${this.#safeIdComponent(vpId)}.md`);
+  }
+
+  /**
+   * Read a per-(groupId, vpId) compact summary. Returns '' if no summary
+   * has been written yet. Falls back to nothing — callers that need the
+   * legacy global file should call `readCompactSummary()` explicitly.
+   *
+   * The (group, vp) scoping was introduced after we noticed the legacy
+   * single-file `compact.md` was shared across every group AND every VP
+   * in a session — so each new compact would clobber/append on top of
+   * unrelated content and every VP read the same merged blob. See
+   * `engine.#runOrchestratorCompact`.
+   *
+   * @param {string} groupId
+   * @param {string} vpId
+   * @returns {string}
+   */
+  readCompactSummaryFor(groupId, vpId) {
+    const path = this.#scopedCompactPath(groupId, vpId);
+    if (!path) return '';
+    if (!existsSync(path)) return '';
+    try { return readFileSync(path, 'utf8'); }
+    catch { return ''; }
+  }
+
+  /**
+   * Append a per-(groupId, vpId) compact summary entry. Same append-only
+   * "## YYYY-MM-DD ..." structure as the legacy `updateCompactSummary`,
+   * but isolated to one file per (group, vp).
+   *
+   * @param {string} groupId
+   * @param {string} vpId
+   * @param {string} summary
+   */
+  updateCompactSummaryFor(groupId, vpId, summary) {
+    const path = this.#scopedCompactPath(groupId, vpId);
+    if (!path) return;
+    let existing = '';
+    if (existsSync(path)) {
+      try { existing = readFileSync(path, 'utf8'); }
+      catch { existing = ''; }
+    }
+    const date = new Date().toISOString().split('T')[0];
+    const entry = `\n## ${date}\n\n${summary}\n`;
+    try {
+      writeFileSync(path, existing + entry, { encoding: 'utf8', mode: 0o644 });
+    } catch (err) {
+      if (isPermissionError(err)) {
+        if (!_permissionWarned) {
+          console.warn(`[Yeaft] Cannot write scoped compact summary: ${err.code}`);
+          _permissionWarned = true;
+        }
+      } else {
+        throw err;
+      }
+    }
+  }
+
+  /**
+   * Check whether ANY per-(group, vp) compact summary exists for `groupId`.
+   * Used by the history-replay path to decide whether to flag
+   * `hasCompactSummary` for the UI without committing to one VP's view.
+   *
+   * @param {string} groupId
+   * @returns {boolean}
+   */
+  hasAnyCompactSummaryForGroup(groupId) {
+    if (!groupId) return false;
+    if (!existsSync(this.#compactScopedDir)) return false;
+    const prefix = `${this.#safeIdComponent(groupId)}__`;
+    try {
+      for (const f of readdirSync(this.#compactScopedDir)) {
+        if (f.startsWith(prefix) && f.endsWith('.md')) return true;
+      }
+    } catch { /* best-effort */ }
+    return false;
+  }
+
   /**
    * Update the conversation index.md with current state.
    *
@@ -635,6 +745,71 @@ export class ConversationStore {
     return this.loadRecentByGroup(groupId, Infinity);
   }
 
+  /**
+   * VP-scoped view of group history, used by per-VP post-turn compact.
+   *
+   * Compact must operate on what the VP actually *saw* in its context,
+   * not the union of every VP's tool calls/results — otherwise compact
+   * tries to summarize tool transcripts that were never in this VP's
+   * prompt window. The rule we settled on (with the user, 2026-06-01):
+   *
+   *   - User rows (no speakerVpId): KEEP — every VP sees the prompt.
+   *   - This VP's own assistant rows + their paired tool rows: KEEP.
+   *   - OTHER VPs' assistant rows: KEEP TEXT ONLY (strip toolCalls AND
+   *     thinkingBlocks — thinking is VP-private per Anthropic's signed-
+   *     block contract and would never appear in another VP's context).
+   *   - OTHER VPs' tool result rows (role:'tool'): DROP — they pair with
+   *     stripped tool_use ids and would orphan on replay.
+   *   - Rows with `_reflection` / `internal` / `systemOnly`: DROP — they
+   *     are engine-private and never enter another VP's context.
+   *
+   * The output is pair-safe by construction for THIS VP's tool arcs and
+   * carries only summary-relevant text for the other VPs.
+   *
+   * @param {string} groupId
+   * @param {string} vpId
+   * @returns {object[]}
+   */
+  loadGroupHistoryForVp(groupId, vpId) {
+    if (!groupId || !vpId) return [];
+    const all = this.#loadFromDir(this.#msgDir, Infinity);
+    const out = [];
+    for (const m of all) {
+      if (!m || m.groupId !== groupId) continue;
+      if (m._reflection || m.internal || m.systemOnly || m.systemOnlyMessage) continue;
+      if (m.role === 'user') {
+        out.push(m);
+        continue;
+      }
+      if (m.role === 'assistant') {
+        if (m.speakerVpId === vpId) {
+          out.push(m);
+        } else {
+          // Other VP's assistant text only — drop their toolCalls so the
+          // following role:'tool' rows (which we also drop) don't leave
+          // orphan tool_use ids in the compact input.
+          const copy = { ...m };
+          delete copy.toolCalls;
+          delete copy.thinkingBlocks;
+          out.push(copy);
+        }
+        continue;
+      }
+      if (m.role === 'tool') {
+        // Tool results belong to the assistant turn that emitted the
+        // tool_use. Only keep ours; other VPs' results were dropped via
+        // their assistant's stripped toolCalls.
+        if (m.speakerVpId === vpId) out.push(m);
+        continue;
+      }
+    }
+    // Note: we don't run `sliceLastNTurns` here. The caller
+    // (#runOrchestratorCompact) decides what's "cooling" via
+    // `partitionMessages`, and we don't want to pre-truncate before that
+    // budget calc sees the full picture.
+    return pairSanitize(out);
+  }
+
   /**
    * Pagination-cursor read: load the page of `turnsLimit` TURNS that ends
    * just before `beforeSeq` (exclusive) for the given `groupId`. Used by

package/unify/engine.js

@@ -302,6 +302,10 @@ export class Engine {
 
   /** @type {string|null} */
   #yeaftDir;
+  /** @type {string|null} — set when this engine is bound to a specific group (per-VP fan-out path). */
+  #groupId = null;
+  /** @type {string|null} — set when this engine is bound to a specific VP (per-VP fan-out path). */
+  #vpId = null;
 
   /** @type {import('./stats/tool-usage.js').ToolUsageStats|null} — per-tool call/latency counters */
   #toolStats = null;
@@ -402,7 +406,7 @@ export class Engine {
    *   toolStats?: import('./stats/tool-usage.js').ToolUsageStats,
    * }} params
    */
-  constructor({ adapter, trace, config, conversationStore, memoryIndex, amsRegistry, toolRegistry, skillManager, mcpManager, yeaftDir, toolStats = null }) {
+  constructor({ adapter, trace, config, conversationStore, memoryIndex, amsRegistry, toolRegistry, skillManager, mcpManager, yeaftDir, toolStats = null, groupId = null, vpId = null }) {
     this.#adapter = adapter;
     this.#trace = trace;
     this.#config = config;
@@ -416,6 +420,14 @@ export class Engine {
     this.#mcpManager = mcpManager || null;
     this.#yeaftDir = yeaftDir || null;
     this.#toolStats = toolStats || null;
+    // Per-VP fan-out (2026-06-01): engine instances in the group path are
+    // keyed by ${groupId}::${vpId}::${threadId}, so binding the engine to
+    // its (groupId, vpId) pair at construction lets post-turn compact
+    // scope its read/write to THIS VP's view of the conversation instead
+    // of clobbering a session-global compact.md. Legacy / sub-agent
+    // callers leave both null → fall back to the global file.
+    this.#groupId = (typeof groupId === 'string' && groupId) ? groupId : null;
+    this.#vpId = (typeof vpId === 'string' && vpId) ? vpId : null;
 
     // PR-L: tool history reflection log. Keyed by traceId so distinct
     // engine instances don't stomp on each other's jsonl files. When
@@ -978,6 +990,16 @@ export class Engine {
    */
   #getCompactSummary() {
     if (!this.#conversationStore) return '';
+    // Per-(group, vp) scoping: when this engine is bound to a fan-out VP,
+    // read its own summary file. On a miss (empty scoped file) we fall
+    // through to the legacy global file so pre-PR sessions whose only
+    // summary lives in compact.md still surface their context — matches
+    // the OR-fallback in web-bridge's `hasCompactSummary` flag.
+    if (this.#groupId && this.#vpId
+        && typeof this.#conversationStore.readCompactSummaryFor === 'function') {
+      const scoped = this.#conversationStore.readCompactSummaryFor(this.#groupId, this.#vpId);
+      if (scoped) return scoped;
+    }
     return this.#conversationStore.readCompactSummary();
   }
 
@@ -1063,14 +1085,30 @@ export class Engine {
     const adapter = this.#adapter;
     const fastConfig = this.#fastConfig;
 
+    // Per-(group, vp) scoping: when this engine is bound to a fan-out VP
+    // (the common case in group mode), load only the rows THIS VP saw in
+    // its context — user prompts + every VP's assistant text, with other
+    // VPs' tool calls/results stripped (see persist.loadGroupHistoryForVp).
+    //
+    // Legacy / sub-agent callers (no groupId/vpId pair) keep the global
+    // loadAll() behaviour so we don't break those flows.
     let messages;
+    const scoped = !!(this.#groupId && this.#vpId
+      && typeof conversationStore.loadGroupHistoryForVp === 'function');
     try {
-      messages = conversationStore.loadAll();
+      messages = scoped
+        ? conversationStore.loadGroupHistoryForVp(this.#groupId, this.#vpId)
+        : conversationStore.loadAll();
     } catch { return null; }
     if (!Array.isArray(messages) || messages.length === 0) return null;
 
     const tokenCount = conversationStore.hotTokens();
-    const groupId = messages.find(m => m && typeof m.groupId === 'string' && m.groupId)?.groupId || null;
+    // In the scoped path, groupId is the engine's binding (authoritative).
+    // In the legacy path, fall back to scanning the messages (best-effort,
+    // used only for the group context-window gate).
+    const groupId = this.#groupId
+      || messages.find(m => m && typeof m.groupId === 'string' && m.groupId)?.groupId
+      || null;
     const groupContextGate = shouldAllowGroupReflection({
       system: '',
       messages,
@@ -1130,7 +1168,13 @@ export class Engine {
         }
       },
       archive: async (_groupIdx, groupMsgs) => {
-        for (const m of groupMsgs) if (m.id) archiveIds.push(m.id);
+        // Only collect archive ids when we'll actually use them. In the
+        // scoped (per-VP) path we never call moveToColdBatch — those
+        // rows are shared with sibling VPs in this group — so leaving
+        // the push in would be dead state a future reader has to chase.
+        if (!scoped) {
+          for (const m of groupMsgs) if (m.id) archiveIds.push(m.id);
+        }
         const turnId = groupMsgs[0]?.id || `g_${Date.now()}`;
         if (this.#yeaftDir) {
           try {
@@ -1150,10 +1194,28 @@ export class Engine {
       const out = await runCompactOrchestrator({
         messages, keepHot: 10, hooks,
       });
-      if (archiveIds.length > 0) conversationStore.moveToColdBatch(archiveIds);
-      if (out.compactSummary) conversationStore.updateCompactSummary(out.compactSummary);
-      const lastKept = messages[messages.length - 1];
-      conversationStore.updateIndex({ lastMessageId: lastKept?.id || null });
+      // Scoped path (per-(group, vp)): do NOT moveToColdBatch — those
+      // archive ids include user rows and other VPs' assistant rows that
+      // sibling VPs in this group still need in their hot context. The
+      // per-VP summary written below is the durable win; physical
+      // cold-archival across shared rows is the dream-level orchestrator's
+      // job, not post-turn compact's.
+      if (!scoped && archiveIds.length > 0) {
+        conversationStore.moveToColdBatch(archiveIds);
+      }
+      if (out.compactSummary) {
+        if (scoped && typeof conversationStore.updateCompactSummaryFor === 'function') {
+          conversationStore.updateCompactSummaryFor(this.#groupId, this.#vpId, out.compactSummary);
+        } else {
+          conversationStore.updateCompactSummary(out.compactSummary);
+        }
+      }
+      // Index update only makes sense for the legacy path that actually
+      // moved rows to cold. In the scoped path, nothing on disk changed.
+      if (!scoped) {
+        const lastKept = messages[messages.length - 1];
+        conversationStore.updateIndex({ lastMessageId: lastKept?.id || null });
+      }
 
       return {
         archivedCount: out.archivedMessages,

package/unify/history-compact.js

@@ -94,13 +94,14 @@ export const countTurns = countTurnsImpl;
  * Token thresholds are derived from `maxContextTokens` at evaluation
  * time so the policy auto-adjusts to the user's configured context.
  */
-export const DEFAULT_TURN_LIMIT = 30;
-export const DEFAULT_MIN_TOKEN_FLOOR = 12_000;
+export const DEFAULT_TURN_LIMIT = Infinity;
+export const DEFAULT_MIN_TOKEN_FLOOR = 0;
 export const DEFAULT_MAX_CONTEXT_TOKENS = 200_000;
-export const DEFAULT_TOKEN_FRACTION = 0.8;
-export const DEFAULT_HARD_TOKEN_CEILING = 200_000;
-export const DEFAULT_MIN_TURNS_FOR_COMPACT = 5;
+export const DEFAULT_TOKEN_FRACTION = 0.5;
+export const DEFAULT_HARD_TOKEN_CEILING = Infinity;
+export const DEFAULT_MIN_TURNS_FOR_COMPACT = 0;
 export const DEFAULT_KEEP_TOOL_TURNS = 3;
+export const DEFAULT_TOOL_CALL_COMPACT_THRESHOLD = 30;
 /**
  * Effective default token trigger when no `maxContextTokens` is provided:
  *   min(80% of 200K, 200K) = 160K. Preserved as `DEFAULT_TOKEN_LIMIT` for
@@ -116,7 +117,7 @@ export const DEFAULT_TOKEN_LIMIT = Math.min(
  * replaces everything before this window. 2 keeps "what we were just
  * talking about" lossless.
  */
-export const DEFAULT_KEEP_RECENT_TURNS = 2;
+export const DEFAULT_KEEP_RECENT_TURNS = 3;
 
 /**
  * Default cap on the number of turns kept in the per-call snapshot fed
@@ -233,9 +234,10 @@ export function shouldCompactHistory(messages, opts = {}) {
   const tokenCount = estimateMessagesTokens(messages);
 
   let reason = null;
-  // (1) Soft floor: never compact small conversations.
-  // (2) Short-history guard: fewer than five turns should not compact unless
-  //     the estimated prompt is already at the context-pressure threshold.
+  // Product rule: async group compact is allowed only when the current
+  // conversation exceeds the model context window threshold. Turn count is
+  // preserved as an explicit test/future-config override, but defaults to
+  // Infinity so it cannot compact a small context by itself.
   if (tokenCount < minTokenFloor || (turnCount < minTurnsForCompact && tokenCount < tokenLimit)) {
     return {
       trigger: false,
@@ -249,10 +251,8 @@ export function shouldCompactHistory(messages, opts = {}) {
       hardTokenCeiling,
     };
   }
-  // (2) Trigger evaluation. Turn check is opt-in (Infinity by default).
-  if (Number.isFinite(turnLimit) && turnCount > turnLimit) reason = 'turn_count';
-  else if (tokenCount > hardTokenCeiling) reason = 'token_ceiling';
-  else if (tokenCount >= tokenLimit) reason = 'token_threshold';
+  if (tokenCount > hardTokenCeiling) reason = 'token_ceiling';
+  else if (tokenCount > tokenLimit) reason = 'token_threshold';
 
   return {
     trigger: reason !== null,
@@ -273,6 +273,27 @@ function hasContentAfterToolStrip(content) {
   return content != null;
 }
 
+function countToolCallsInContent(content) {
+  if (!Array.isArray(content)) return 0;
+  let n = 0;
+  for (const part of content) {
+    if (!part || typeof part !== 'object') continue;
+    if (part.type === 'tool_use' || part.type === 'function_call') n++;
+  }
+  return n;
+}
+
+function countToolCallsInMessages(messages) {
+  if (!Array.isArray(messages)) return 0;
+  let n = 0;
+  for (const m of messages) {
+    if (!m || typeof m !== 'object') continue;
+    if (Array.isArray(m.toolCalls)) n += m.toolCalls.length;
+    n += countToolCallsInContent(m.content);
+  }
+  return n;
+}
+
 function stripToolContentParts(content) {
   if (!Array.isArray(content)) return content;
   return content.filter(part => {
@@ -326,6 +347,31 @@ export function stripToolNoiseFromOlderTurns(messages, opts = {}) {
   return [...cleanedOlder, ...recent.map(m => ({ ...m }))];
 }
 
+/**
+ * Apply the async compact retained-tail tool policy. Small retained tails keep
+ * every tool pair intact. Once the retained tail exceeds the threshold, keep
+ * full tool history only for the latest turn and strip tool noise from the
+ * earlier retained turns while preserving their normal text.
+ *
+ * @param {Array<object>} tail
+ * @param {{ keepToolTurns?: number, toolCallCompactThreshold?: number }} [opts]
+ * @returns {Array<object>}
+ */
+export function compactRetainedTailToolCalls(tail, opts = {}) {
+  if (!Array.isArray(tail) || tail.length === 0) return [];
+
+  const threshold = Number.isFinite(opts.toolCallCompactThreshold) && opts.toolCallCompactThreshold >= 0
+    ? opts.toolCallCompactThreshold
+    : DEFAULT_TOOL_CALL_COMPACT_THRESHOLD;
+  const toolCallCount = countToolCallsInMessages(tail);
+  if (toolCallCount <= threshold) return tail.map(m => ({ ...m }));
+
+  const keepToolTurns = Number.isFinite(opts.keepToolTurns) && opts.keepToolTurns >= 0
+    ? opts.keepToolTurns
+    : 1;
+  return stripToolNoiseFromOlderTurns(tail, { keepToolTurns });
+}
+
 /**
  * Strip noise from a message list before sending it to the summarizer:
  *   - drop `role: 'tool'` (raw tool results — too verbose, mostly redundant)
@@ -499,6 +545,8 @@ export async function compactHistory(messages, options) {
     tokenFraction,
     hardTokenCeiling,
     language,
+    keepToolTurns,
+    toolCallCompactThreshold,
   } = options || {};
 
   if (typeof summarize !== 'function') {
@@ -600,7 +648,11 @@ export async function compactHistory(messages, options) {
   // whose tool_use IDs aren't fully matched in the tail. This is what
   // keeps the next adapter call from 400-ing on tool_use/tool_result
   // mismatch when the storage / fan-out layer reorders messages.
-  const safeTail = pairSanitize(tail);
+  const compactedTail = compactRetainedTailToolCalls(tail, {
+    keepToolTurns,
+    toolCallCompactThreshold,
+  });
+  const safeTail = pairSanitize(compactedTail);
 
   const newMessages = [summaryMsg, ...safeTail];
   const after = shouldCompactHistory(newMessages, triggerOpts);

package/unify/web-bridge.js

@@ -851,6 +851,12 @@ function getOrCreateVpEngine(groupId, vpId, threadId = 'main') {
     // (`if (this.#toolStats && ...)`) is false and group VP tool calls
     // are silently dropped.
     toolStats: session.toolStats || null,
+    // Per-VP fan-out: bind the engine to its (groupId, vpId) so post-turn
+    // compact reads/writes a scoped summary instead of the legacy global
+    // compact.md (which every VP would otherwise share, producing
+    // identical, ever-growing summaries across groups).
+    groupId,
+    vpId,
   });
   vpEngines.set(key, eng);
   return eng;
@@ -3634,10 +3640,21 @@ export async function handleUnifyLoadHistory(msg) {
     oldestSeq = visiblePage.oldestSeq;
   }
 
+  // hasCompactSummary used to read a single session-global file, so it
+  // was always true once ANY group/VP in the session had compacted.
+  // Now we check (a) the scoped dir for any per-VP summary file in this
+  // group, falling back to (b) the legacy global file for sessions that
+  // pre-date the per-(group, vp) split.
+  let hasCompactSummaryFlag = !!compactSummary;
+  if (groupId && typeof session.conversationStore.hasAnyCompactSummaryForGroup === 'function') {
+    hasCompactSummaryFlag = session.conversationStore.hasAnyCompactSummaryForGroup(groupId)
+      || hasCompactSummaryFlag;
+  }
+
   sendUnifyEvent({
     type: 'history_loaded',
     count: replayEntries.length,
-    hasCompactSummary: !!compactSummary,
+    hasCompactSummary: hasCompactSummaryFlag,
     totalHot: session.conversationStore.countHot(),
     totalCold: session.conversationStore.countCold(),
     groupId,