@yeaft/webchat-agent 1.0.509 → 1.0.511

package/yeaft/history-window.js

@@ -27,7 +27,8 @@ export const DEFAULT_RUNTIME_CACHE_TURN_CAP = 25;
 export const DEFAULT_RUNTIME_CACHE_TOKEN_BUDGET = 32768;
 export const DEFAULT_RUNTIME_CACHE_MESSAGE_CAP = 256;
 
-const MINIMUM_RECENT_PROVIDER_TURNS = 5;
+const DEFAULT_PROVIDER_RECENT_TURNS = 10;
+const MINIMUM_RECENT_PROVIDER_TURNS = 3;
 const IMAGE_PART_TOKEN_COST = 1024;
 const DOCUMENT_PART_TOKEN_COST = 2048;
 const CONTENT_PART_FRAME_TOKENS = 2;
@@ -894,16 +895,56 @@ function describeBucket(turns, messages = turns.flatMap(turn => turn.text)) {
   };
 }
 
+/**
+ * Emergency projection for the three-turn floor. It reuses the existing
+ * deterministic message fitter against a disposable provider copy, while
+ * sharing rows/tokens across the newest three human boundaries. The durable
+ * transcript is never rewritten.
+ */
+function compressRecentTurns(turns, tokenBudget, messageCap) {
+  const fitted = [];
+  let tokens = tokenBudget;
+  let rows = messageCap;
+  for (let index = 0; index < turns.length; index += 1) {
+    const turn = turns[index];
+    const remaining = turns.length - index;
+    let turnTokens = Math.floor(tokens / remaining);
+    const minimumRowTokens = Array.isArray(turn.text[0]?.content) ? 5 : 3;
+    const turnRows = Math.min(Math.floor(rows / remaining), Math.floor(turnTokens / minimumRowTokens));
+    if (turnTokens < minimumRowTokens || turnRows < 1) continue;
+    const selected = turn.text.length <= turnRows ? turn.text
+      : [turn.text[0], ...(turnRows > 1 ? turn.text.slice(-(turnRows - 1)) : [])];
+    const text = [];
+    for (let row = 0; row < selected.length; row += 1) {
+      const allowance = Math.floor(turnTokens / (selected.length - row));
+      const message = shrinkMessageToBudget(selected[row], allowance);
+      const cost = estimateMessageTokens(message);
+      if (cost <= allowance && hasProviderContent(message.content)) {
+        text.push(message);
+        turnTokens -= cost;
+      } else if (row === 0) break;
+    }
+    if (!text.some(bucketUserBoundary)) continue;
+    const cost = estimateMessagesTokens(text);
+    fitted.push({ ...turn, text, tokens: cost });
+    tokens -= cost;
+    rows -= text.length;
+  }
+  return fitted;
+}
+
 /**
  * Recompute provider history from untrimmed candidates; never mutate/cache the
  * result in the transcript. Past human turn boundaries are retained when the
  * configured recent window fits; tools are optional enrichment, newest first.
  *
- * The active turn is outside both buckets and consumes the global budget first.
- * Its opening user row is protected. Recent text stays complete: reduce the
- * oldest end of the suffix down to five turns (or all available for a new
- * Session); fail closed if that floor cannot fit. Related recall only uses
- * remaining budget and stays optional and complete. External recall must have
+ * The active turn is outside both buckets and outside the history budget. Its
+ * opening user row is protected by the later whole-request fitter. Prefer ten
+ * complete recent turns, reducing the oldest end down to three. If that floor
+ * cannot fit, omit recall and compress only those three turns; historical tool
+ * replay then narrows from the normal newest three turns to the newest one.
+ * Related recall otherwise uses remaining history budget and stays optional and
+ * complete. External recall must have
  * comparable userSeq/source identities to establish
  * that it predates recent/current history; unknown chronology fails closed.
  *
@@ -918,7 +959,7 @@ export function buildHistoryBuckets(snapshot, options = {}) {
   const source = Array.isArray(snapshot) ? snapshot : [];
   const tokenBudget = bucketCap(options.messageTokenBudget, DEFAULT_MESSAGE_TOKEN_BUDGET);
   const messageCap = bucketCap(options.maxMessageCount, DEFAULT_RUNTIME_CACHE_MESSAGE_CAP);
-  const recentCap = bucketCap(options.recentTurnCap, 20);
+  const recentCap = bucketCap(options.recentTurnCap, DEFAULT_PROVIDER_RECENT_TURNS);
   const relatedCap = bucketCap(options.relatedTurnCap, 5, 5);
   const keepToolTurns = bucketCap(options.keepToolTurns, DEFAULT_KEEP_TOOL_TURNS);
   const allTurns = splitBucketTurns(source);
@@ -927,41 +968,16 @@ export function buildHistoryBuckets(snapshot, options = {}) {
     : (allTurns.at(-1)?.index ?? source.length);
   const currentSource = source.slice(currentStart);
   const currentIdentity = bucketTurn(currentSource, currentStart);
-  let current = [];
-  if (currentSource.length && tokenBudget >= 2 && messageCap > 0) {
-    // Reserve the opening prompt before fitting later active execution units.
-    const first = shrinkMessageToBudget(stripAllToolNoise([currentSource[0]])[0], tokenBudget);
-    if (first && estimateMessageTokens(first) <= tokenBudget) current.push(first);
-    const remainingTokens = tokenBudget - estimateMessagesTokens(current);
-    const remainingRows = messageCap - current.length;
-    if (remainingTokens >= 2 && remainingRows > 0) {
-      // Active execution is not visible historical text: internal completion
-      // notices must reach the next provider call. Fit newest protocol units
-      // directly, without legacy human-turn filtering or text projection.
-      const units = providerUnits(pairSanitize(truncateToolResultsForModel(
-        currentSource.slice(1), { language: options.language },
-      )));
-      const fitted = [];
-      let tokens = remainingTokens;
-      let rows = remainingRows;
-      for (let index = units.length - 1; index >= 0; index -= 1) {
-        const unit = fitProviderUnit(units[index], tokens);
-        const cost = estimateMessagesTokens(unit);
-        if (unit.length > rows || cost > tokens) continue;
-        fitted.unshift(unit);
-        tokens -= cost;
-        rows -= unit.length;
-      }
-      current.push(...fitted.flat());
-    }
-    // The legacy fitter assumes a normal positive budget; at tiny allowances
-    // even an empty row's framing can exceed it. Remove complete tail units.
-    while (estimateMessagesTokens(current) > tokenBudget || current.length > messageCap) {
-      current = pairSanitize(current.slice(0, -1));
-    }
-  }
-  const availableTokens = Math.max(0, tokenBudget - estimateMessagesTokens(current));
-  const availableRows = Math.max(0, messageCap - current.length);
+  // The 32K/default budget owns only rows before currentStart. Keep the active
+  // turn intact here; whole-request fitting runs at every provider boundary and
+  // uses the actual model context window. Tool bodies may still receive their
+  // normal deterministic per-result truncation, without touching the durable
+  // transcript or charging that copy against history.
+  const current = pairSanitize(truncateToolResultsForModel(
+    currentSource.map(message => ({ ...message })), { language: options.language },
+  ));
+  const availableTokens = tokenBudget;
+  const availableRows = messageCap;
   let duplicateCount = 0;
   const past = [];
   for (const turn of splitBucketTurns(source.slice(0, currentStart))) {
@@ -1023,11 +1039,12 @@ export function buildHistoryBuckets(snapshot, options = {}) {
       // past-turn boundary is still a safe fence; never guess from text/time.
       || (turn.index == null && currentIdentity.userSeq == null && past.length > 0
         && bucketBefore(turn, past.at(-1)))));
-  // Recent text has first claim on history budget. Drop whole oldest turns,
-  // never reserve space for recall or truncate text to manufacture turn counts.
-  const recent = [];
+  // Recent text has first claim on history budget. Drop whole oldest turns down
+  // to the three-turn floor before projecting that floor more aggressively.
+  let recent = [];
   let recentTokens = 0;
   let recentRows = 0;
+  let compressedRecentFloor = false;
   const recentCandidates = recentCap > 0 ? past.slice(-recentCap) : [];
   for (let index = recentCandidates.length - 1; index >= 0; index -= 1) {
     const turn = recentCandidates[index];
@@ -1037,16 +1054,15 @@ export function buildHistoryBuckets(snapshot, options = {}) {
     recentTokens += turn.tokens;
     recentRows += turn.text.length;
   }
-  const minimumRecent = Math.min(MINIMUM_RECENT_PROVIDER_TURNS, recentCandidates.length);
-  if (recent.length < minimumRecent) {
-    const error = new Error(`Context budget cannot retain ${minimumRecent} complete recent history turns`);
-    error.code = 'HISTORY_RECENT_BUDGET_EXCEEDED';
-    throw error;
+  const recentFloor = Math.min(MINIMUM_RECENT_PROVIDER_TURNS, recentCandidates.length);
+  if (recent.length < recentFloor) {
+    compressedRecentFloor = true;
+    recent = compressRecentTurns(recentCandidates.slice(-recentFloor), availableTokens, availableRows);
   }
   let remainingTokens = availableTokens - recent.reduce((total, turn) => total + turn.tokens, 0);
   let remainingRows = availableRows - recent.reduce((total, turn) => total + turn.text.length, 0);
   const related = [];
-  const ranked = eligible.slice().sort((a, b) => b.score - a.score
+  const ranked = compressedRecentFloor ? [] : eligible.slice().sort((a, b) => b.score - a.score
     || (a.userSeq ?? a.index ?? 0) - (b.userSeq ?? b.index ?? 0));
   for (const turn of ranked) {
     if (related.length >= relatedCap) break;
@@ -1067,8 +1083,9 @@ export function buildHistoryBuckets(snapshot, options = {}) {
   // Enrich only after both complete-text buckets and the active turn are paid.
   // Tool protocol is useful only for immediate continuity; unlike visible text,
   // it never reaches farther back than the configured recent tool window.
-  const recentToolSource = keepToolTurns > 0
-    ? recent.slice(-keepToolTurns).flatMap(turn => turn.messages).filter(isVisibleConversationRow)
+  const effectiveKeepToolTurns = compressedRecentFloor ? Math.min(1, keepToolTurns) : keepToolTurns;
+  const recentToolSource = effectiveKeepToolTurns > 0
+    ? recent.slice(-effectiveKeepToolTurns).flatMap(turn => turn.messages).filter(isVisibleConversationRow)
     : [];
   const recentMessages = withoutHistorySourceIndexes(addOptionalRecentToolPairs(
     recentBaseline,
@@ -1097,9 +1114,14 @@ export function buildHistoryBuckets(snapshot, options = {}) {
       budget: {
         messageTokenBudget: tokenBudget, maxMessageCount: messageCap,
         recentTurnCap: recentCap, relatedTurnCap: relatedCap,
-        minimumRecentTurns: minimumRecent,
+        minimumRecentTurns: recentFloor,
+        compressedRecentFloor,
+        effectiveKeepToolTurns,
         relatedReservedTokens: 0, availableHistoryTokens: availableTokens,
-        usedTokens: estimateMessagesTokens(messages), usedMessages: messages.length,
+        usedTokens: estimateMessagesTokens([...relatedMessages, ...recentMessages]),
+        usedMessages: relatedMessages.length + recentMessages.length,
+        requestTokensBeforeWholeRequestFit: estimateMessagesTokens(messages),
+        requestMessagesBeforeWholeRequestFit: messages.length,
       },
       dropped: {
         pastTurnCount: droppedTurns.length,
@@ -1113,6 +1135,97 @@ export function buildHistoryBuckets(snapshot, options = {}) {
   };
 }
 
+/**
+ * Fit one provider-request copy to the actual model window. The caller tells
+ * us where current-turn rows begin; only the prefix is subject to the history
+ * budget. If the complete request is still too large, old history disappears
+ * first, followed by the oldest disposable current-turn protocol units. The
+ * source array and durable transcript are never mutated.
+ *
+ * @param {Array<object>} messages
+ * @param {{ contextWindow:number, systemTokens?:number, toolSchemaTokens?:number,
+ * outputReserve?:number, historyMessageCount?:number, historyTokenBudget?:number,
+ * maxMessageCount?:number, language?:string }} options
+ * @returns {{messages:Array<object>, meta:object}}
+ */
+export function fitProviderRequestToContext(messages, options = {}) {
+  const source = Array.isArray(messages) ? messages : [];
+  const contextWindow = bucketCap(options.contextWindow, 0);
+  const staticTokens = bucketCap(options.systemTokens, 0)
+    + bucketCap(options.toolSchemaTokens, 0)
+    + bucketCap(options.outputReserve, 0);
+  const messageBudget = Math.max(0, contextWindow - staticTokens);
+  const split = Math.max(0, Math.min(source.length,
+    Number.isInteger(options.historyMessageCount) ? options.historyMessageCount : 0));
+  // The runtime cache's 256-row cap is a history-storage concern, not a model
+  // request limit. Current-turn tool loops may legitimately exceed it while
+  // remaining inside the model window. Only enforce a cap when the caller
+  // explicitly supplies one.
+  const messageCap = options.maxMessageCount === undefined
+    ? Number.MAX_SAFE_INTEGER
+    : bucketCap(options.maxMessageCount, Number.MAX_SAFE_INTEGER);
+  const historySource = source.slice(0, split);
+  const currentSource = source.slice(split);
+
+  let current = pairSanitize(truncateToolResultsForModel(
+    currentSource.map(message => ({ ...message })), { language: options.language },
+  ));
+  if (estimateMessagesTokens(current) > messageBudget || current.length > messageCap) {
+    const fitted = [];
+    if (current.length > 0 && messageBudget >= 2 && messageCap > 0) {
+      const first = shrinkMessageToBudget(stripAllToolNoise([current[0]])[0], messageBudget);
+      if (first && estimateMessageTokens(first) <= messageBudget) fitted.push(first);
+      let tokens = messageBudget - estimateMessagesTokens(fitted);
+      let rows = messageCap - fitted.length;
+      const units = providerUnits(pairSanitize(current.slice(1)));
+      const tail = [];
+      for (let index = units.length - 1; index >= 0; index -= 1) {
+        const unit = fitProviderUnit(units[index], tokens);
+        const cost = estimateMessagesTokens(unit);
+        if (unit.length > rows || cost > tokens) continue;
+        tail.unshift(unit);
+        tokens -= cost;
+        rows -= unit.length;
+      }
+      fitted.push(...tail.flat());
+    }
+    current = pairSanitize(fitted);
+  }
+
+  const configuredHistoryBudget = bucketCap(
+    options.historyTokenBudget, DEFAULT_MESSAGE_TOKEN_BUDGET,
+  );
+  const remainingTokens = Math.max(0, Math.min(
+    configuredHistoryBudget,
+    messageBudget - estimateMessagesTokens(current),
+  ));
+  const remainingRows = Math.max(0, messageCap - current.length);
+  const history = remainingTokens >= 2 && remainingRows > 0
+    ? trimSnapshotForBudget(historySource, {
+        messageTokenBudget: remainingTokens,
+        maxMessageCount: remainingRows,
+        recentTurnCap: Number.MAX_SAFE_INTEGER,
+        language: options.language,
+      })
+    : [];
+  const fittedMessages = [...history, ...current];
+  return {
+    messages: fittedMessages,
+    meta: {
+      contextWindow,
+      staticTokens,
+      messageBudget,
+      estimatedTokens: staticTokens + estimateMessagesTokens(fittedMessages),
+      historyMessagesBefore: historySource.length,
+      historyMessagesAfter: history.length,
+      currentMessagesBefore: currentSource.length,
+      currentMessagesAfter: current.length,
+      droppedHistoryMessages: historySource.length - history.length,
+      droppedCurrentMessages: currentSource.length - current.length,
+    },
+  };
+}
+
 /**
  * Bound the Session-level runtime history cache. This is deliberately stricter
  * than the provider configuration: the cache is only a disposable source

package/yeaft/post-compact.js

@@ -0,0 +1,76 @@
+/**
+ * Non-blocking, post-response conversation compaction.
+ *
+ * The compact artifact is a derived provider-context cache. It never replaces
+ * or tombstones ConversationStore rows. A generation fence in Engine decides
+ * whether a completed artifact is still current before this module writes it.
+ */
+import { promises as fs } from 'fs';
+import { dirname, join } from 'path';
+
+export const POST_COMPACT_CONTEXT_RATIO = 0.8;
+
+function safePart(value, fallback) {
+  const text = typeof value === 'string' && value.trim() ? value.trim() : fallback;
+  return encodeURIComponent(text).replace(/%/g, '_');
+}
+
+export function postCompactPath(yeaftDir, { sessionId, vpId, threadId } = {}) {
+  if (!yeaftDir || !sessionId) return null;
+  const file = `${safePart(vpId, 'default')}--${safePart(threadId, 'main')}.json`;
+  return join(yeaftDir, 'sessions', safePart(sessionId, 'session'), 'conversation', 'post-compact', file);
+}
+
+export async function loadPostCompact(path) {
+  if (!path) return null;
+  try {
+    const parsed = JSON.parse(await fs.readFile(path, 'utf8'));
+    return parsed && parsed.version === 1 && typeof parsed.summary === 'string'
+      ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+export async function savePostCompact(path, artifact, isCurrent = null) {
+  if (!path) return false;
+  await fs.mkdir(dirname(path), { recursive: true });
+  const temp = `${path}.${process.pid}.${Date.now()}.tmp`;
+  await fs.writeFile(temp, `${JSON.stringify({ version: 1, ...artifact }, null, 2)}\n`, 'utf8');
+  if (typeof isCurrent === 'function' && !isCurrent()) {
+    await fs.unlink(temp).catch(() => {});
+    return false;
+  }
+  await fs.rename(temp, path);
+  return true;
+}
+
+export async function removePostCompactIfSource(path, sourceTurnId) {
+  if (!path || !sourceTurnId) return false;
+  try {
+    const parsed = JSON.parse(await fs.readFile(path, 'utf8'));
+    if (parsed?.sourceTurnId !== sourceTurnId) return false;
+    await fs.unlink(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function generatePostCompact({ adapter, model, messages, maxTokens = 4096 }) {
+  const transcript = JSON.stringify((Array.isArray(messages) ? messages : []).map(message => ({
+    role: message?.role,
+    content: message?.content,
+    ...(Array.isArray(message?.toolCalls) ? { toolCalls: message.toolCalls } : {}),
+    ...(message?.toolCallId ? { toolCallId: message.toolCallId } : {}),
+  })));
+  const result = await adapter.call({
+    model,
+    system: 'Summarize the earlier conversation for use as context in a later turn. Preserve user goals, decisions, constraints, unresolved work, and important results. Omit raw tool payloads and do not invent facts. Return only the compact summary.',
+    messages: [{ role: 'user', content: `Compact this transcript:\n${transcript}` }],
+    maxTokens,
+  });
+  const summary = typeof result?.text === 'string' ? result.text.trim() : '';
+  if (!summary) throw new Error('post compact returned empty content');
+  return summary;
+}

package/yeaft/session.js

@@ -180,7 +180,7 @@ export async function loadSession(options = {}) {
   if (typeof dreamEnabled === 'boolean') config.dream.enabled = dreamEnabled;
 
   // Propagate the (clamped) cold-start replay window to the conversation
-  // store. The default is 20 turns; a user wanting more recall after a
+  // store. The default is 10 turns; a user wanting more recall after a
   // fresh boot sets `yeaft.recentTurnsLimit` in ~/.yeaft/config.json.
   // Called once per session boot — subsequent boots overwrite the
   // module-level default safely (single-process model).

package/yeaft/tool-folding/index.js

@@ -2,7 +2,8 @@
  * tool-folding/index.js — V7 reflection subsystem entry (PR-L).
  *
  * Exposes:
- *   - Constants TOOL_BATCH_SIZE, TURN_SUMMARY_THRESHOLD, DUP_TOOL_THRESHOLD
+ *   - Constants TOOL_LOOP_REFLECTION_INTERVAL, TURN_SUMMARY_THRESHOLD,
+ *     DUP_TOOL_THRESHOLD
  *   - Reflector helpers (T1 sync, T2 async, fallback stub)
  *   - Helpers for collapsing message ranges into a single assistant
  *     reflection message
@@ -10,19 +11,10 @@
  *
  * The constants are NOT config-driven — V7 design freezes them in code.
  *
- * Invariant: TURN_SUMMARY_THRESHOLD < TOOL_BATCH_SIZE. T1 runs inside the
- * turn and collapses history in place; T2 fires at end_turn and is gated
- * by `t1CollapsesDone === 0` (engine.js). If T2 were ever set ≥ T1, T1
- * would collapse first and T2 could never fire — silently disabling the
- * end-of-turn reflection path. Keep a usefully wide gap between the two
- * so the (T2, T1) band where T2-alone applies stays meaningful.
- *
- * TOOL_BATCH_SIZE history: was 13 originally; raised to 30 (2026-05-15)
- * after user feedback that 13 fired too often inside a single task and
- * fragmented otherwise-coherent tool arcs into multiple reflections. 30
- * keeps the periodic-reflection contract (it still fires every N tools,
- * not just once) but gives a single task arc room to breathe before the
- * arc gets collapsed.
+ * T1 runs inside the turn and collapses history in place. Its cadence is
+ * measured in provider tool loops (assistant tool_use batch → execution →
+ * next provider boundary), not in the number of calls inside a batch. A model
+ * returning 30 parallel tools has completed one loop, not thirty.
  *
  * TURN_SUMMARY_THRESHOLD history: was 5 originally; raised to 8
  * (2026-05-18). 5 was too aggressive — small "read a few files, edit one,
@@ -32,7 +24,9 @@
  * before the next turn's history grows.
  */
 
-export const TOOL_BATCH_SIZE = 30;
+export const TOOL_LOOP_REFLECTION_INTERVAL = 30;
+// Compatibility for external imports; the engine uses the loop-specific name.
+export const TOOL_BATCH_SIZE = TOOL_LOOP_REFLECTION_INTERVAL;
 export const TURN_SUMMARY_THRESHOLD = 8;
 export const DUP_TOOL_THRESHOLD = 3;
 

package/yeaft/tool-folding/t1-reflector.js

@@ -1,8 +1,9 @@
 /**
  * t1-reflector.js — V7 in-turn (synchronous) reflection (PR-L).
  *
- * Triggered when the current turn has accumulated TOOL_BATCH_SIZE (30) tool
- * results and the engine is about to loop back into adapter.stream(). Calls
+ * Triggered after each interval of 30 completed tool loops, immediately before
+ * the engine loops back into adapter.stream(). Parallel calls returned in one
+ * assistant tool-use batch count as one loop. Calls
  * the PRIMARY model — never the fast model — to generate a markdown
  * reflection over the batch.
  *

package/yeaft/web-bridge.js

@@ -7174,7 +7174,7 @@ export async function handleYeaftLoadHistory(msg) {
   // `lim` is now expressed in TURNS, not raw messages. `loadRecent` and
   // `loadRecentBySession` use turn-based slicing so the cut never lands
   // mid-tool-arc. Pass `undefined` to use the persistence-layer default
-  // (DEFAULT_RECENT_TURNS = 20 turns).
+  // (DEFAULT_RECENT_TURNS = 10 turns).
   const pickRecent = (store, lim) =>
     sessionId ? store.loadRecentBySession(sessionId, lim) : store.loadRecent(lim);
   let historyAlreadyReplayed = false;