@yeaft/webchat-agent 1.0.508 → 1.0.510

package/yeaft/history-window.js

@@ -27,7 +27,6 @@ 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 = 20;
 const IMAGE_PART_TOKEN_COST = 1024;
 const DOCUMENT_PART_TOKEN_COST = 2048;
 const CONTENT_PART_FRAME_TOKENS = 2;
@@ -899,10 +898,11 @@ function describeBucket(turns, messages = turns.flatMap(turn => turn.text)) {
  * 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. Oversized recent text is fitted only in the
- * disposable provider copy so one large turn cannot evict the rest of the recent
- * window. Related recall remains 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. Recent text
+ * stays complete when it fits, but a configured turn count is never a hard
+ * request-success floor. Related recall only 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 +918,7 @@ export function buildHistoryBuckets(snapshot, options = {}) {
   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 relatedCap = bucketCap(options.relatedTurnCap, 8, 10);
+  const relatedCap = bucketCap(options.relatedTurnCap, 5, 5);
   const keepToolTurns = bucketCap(options.keepToolTurns, DEFAULT_KEEP_TOOL_TURNS);
   const allTurns = splitBucketTurns(source);
   const currentStart = Number.isInteger(options.currentTurnStartIndex)
@@ -926,41 +926,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))) {
@@ -1022,65 +997,20 @@ 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)))));
-  // A candidate inside the initial recent cap can become related after budget
-  // eviction. Reserve before picking the final suffix so it can re-enter.
-  const reservable = relatedCap > 0 ? eligible.filter(turn => turn.tokens <= availableTokens
-    && turn.text.length <= availableRows
-    && (recentCap === 0 || !past.length || bucketBefore(turn, past.at(-1)))) : [];
-  const reserve = reservable.length ? Math.floor(availableTokens * 0.25) : 0;
-  const reservedRows = reservable.length
-    ? Math.max(Math.floor(availableRows * 0.25), Math.min(...reservable.map(turn => turn.text.length))) : 0;
-  function fitRecentTurn(turn, tokenLimit) {
-    if (turn.tokens <= tokenLimit) return turn.text;
-    const fitted = [];
-    let tokens = tokenLimit;
-    for (let index = 0; index < turn.text.length; index += 1) {
-      const remainingRows = turn.text.length - index;
-      const allowance = Math.max(2, Math.floor(tokens / remainingRows));
-      const message = shrinkMessageToBudget(turn.text[index], allowance);
-      const rows = dropEmptyAssistantRows([message]);
-      fitted.push(...rows);
-      tokens -= estimateMessagesTokens(rows);
-    }
-    return fitted;
+  // 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 = [];
+  let recentTokens = 0;
+  let recentRows = 0;
+  const recentCandidates = recentCap > 0 ? past.slice(-recentCap) : [];
+  for (let index = recentCandidates.length - 1; index >= 0; index -= 1) {
+    const turn = recentCandidates[index];
+    if (recentTokens + turn.tokens > availableTokens
+      || recentRows + turn.text.length > availableRows) break;
+    recent.unshift(turn);
+    recentTokens += turn.tokens;
+    recentRows += turn.text.length;
   }
-  function selectRecent(limit, rowLimit = availableRows) {
-    const candidates = past.slice(-recentCap);
-    if (!candidates.length || limit <= 0 || rowLimit <= 0) return [];
-    const preserveBoundaries = candidates.length >= MINIMUM_RECENT_PROVIDER_TURNS
-      && rowLimit >= candidates.reduce((sum, turn) => sum + turn.text.length, 0)
-      && limit >= candidates.length * 2;
-    if (!preserveBoundaries) {
-      const selected = [];
-      let tokens = 0;
-      let rows = 0;
-      for (let index = candidates.length - 1; index >= 0; index -= 1) {
-        const turn = candidates[index];
-        if (tokens + turn.tokens > limit || rows + turn.text.length > rowLimit) break;
-        selected.unshift(turn);
-        tokens += turn.tokens;
-        rows += turn.text.length;
-      }
-      return selected;
-    }
-
-    const selected = [];
-    let tokens = Math.floor(limit);
-    let rows = Math.floor(rowLimit);
-    for (const turn of candidates) {
-      const remainingTurns = candidates.length - selected.length;
-      if (rows < remainingTurns) break;
-      const allowance = Math.max(2, Math.floor(tokens / remainingTurns));
-      const fitted = fitRecentTurn(turn, allowance);
-      if (!fitted.length || fitted.length > rows - (remainingTurns - 1)) continue;
-      const used = estimateMessagesTokens(fitted);
-      selected.push({ ...turn, text: fitted, tokens: used });
-      tokens -= used;
-      rows -= fitted.length;
-    }
-    return selected;
-  }
-  let recent = selectRecent(availableTokens - reserve, availableRows - reservedRows);
   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 = [];
@@ -1098,34 +1028,15 @@ export function buildHistoryBuckets(snapshot, options = {}) {
     remainingTokens -= turn.tokens;
     remainingRows -= turn.text.length;
   }
-  if (!related.length) recent = selectRecent(availableTokens);
-  else {
-    // Pay the actual related cost, not the provisional reserve. Expand the
-    // recent suffix only while every related turn remains strictly older.
-    const expanded = selectRecent(
-      availableTokens - related.reduce((sum, turn) => sum + turn.tokens, 0),
-      availableRows - related.reduce((sum, turn) => sum + turn.text.length, 0),
-    );
-    while (expanded.length > recent.length && related.some(turn => (
-      !bucketBefore(turn, expanded[0]) || bucketOverlap(turn, expanded[0])
-    ))) expanded.shift();
-    if (expanded.length > recent.length) recent = expanded;
-  }
   related.sort((a, b) => bucketBefore(a, b) ? -1 : bucketBefore(b, a) ? 1 : 0);
 
   const relatedMessages = related.flatMap(turn => turn.text);
-  const recentText = recent.flatMap(turn => turn.messages)
-    .filter(isVisibleConversationRow);
-  const recentWasFitted = recent.some(turn => turn.text !== turn.messages
-    && (turn.text.length !== bucketTextMessages(turn.messages).length
-      || turn.tokens !== estimateMessagesTokens(bucketTextMessages(turn.messages))));
-  const recentBaseline = recent.flatMap(turn => recentWasFitted ? turn.text : bucketTextMessages(turn.messages));
+  const recentBaseline = recent.flatMap(turn => turn.text);
   // 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 toolCutIndex = indexOfNthTurnFromEnd(recentText, keepToolTurns);
   const recentToolSource = keepToolTurns > 0
-    ? recentText.slice(toolCutIndex < 0 ? 0 : toolCutIndex)
+    ? recent.slice(-keepToolTurns).flatMap(turn => turn.messages).filter(isVisibleConversationRow)
     : [];
   const recentMessages = withoutHistorySourceIndexes(addOptionalRecentToolPairs(
     recentBaseline,
@@ -1154,8 +1065,12 @@ export function buildHistoryBuckets(snapshot, options = {}) {
       budget: {
         messageTokenBudget: tokenBudget, maxMessageCount: messageCap,
         recentTurnCap: recentCap, relatedTurnCap: relatedCap,
-        relatedReservedTokens: reserve, availableHistoryTokens: availableTokens,
-        usedTokens: estimateMessagesTokens(messages), usedMessages: messages.length,
+        minimumRecentTurns: 0,
+        relatedReservedTokens: 0, availableHistoryTokens: availableTokens,
+        usedTokens: estimateMessagesTokens([...relatedMessages, ...recentMessages]),
+        usedMessages: relatedMessages.length + recentMessages.length,
+        requestTokensBeforeWholeRequestFit: estimateMessagesTokens(messages),
+        requestMessagesBeforeWholeRequestFit: messages.length,
       },
       dropped: {
         pastTurnCount: droppedTurns.length,
@@ -1169,6 +1084,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/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.
  *