@yeaft/webchat-agent 1.0.447 → 1.0.449

package/yeaft/session.js

@@ -27,8 +27,6 @@ import { resolveMcpPluginPolicy } from './plugins.js';
 import { createFullRegistry } from './tools/index.js';
 import { buildMcpFlattenedTools } from './tools/mcp-tools.js';
 import { Engine } from './engine.js';
-import { Compactor } from './compact/compactor.js';
-import { resolveContextWindow } from './models.js';
 import { ToolUsageStats } from './stats/tool-usage.js';
 import { TaskManager } from './tasks/manager.js';
 // H2.f.5 removed the old user-facing thread pipeline/dispatcher. The base
@@ -59,18 +57,6 @@ import { openAmsRegistry } from './memory/ams-registry.js';
 import { join } from 'path';
 import { existsSync as existsSyncSafe, readFileSync as readFileSyncSafe, mkdirSync as mkdirSyncSafe } from 'fs';
 
-/**
- * Application-wide default for `Compactor`'s trigger ratio (the
- * "fraction of model context" gate). The user-stated requirement is
- * "model context 的 70%"; this is the canonical literal for it. Lives
- * in session.js (not in compactor.js) because `Compactor` is also used
- * by test fixtures that intentionally skip the ratio injector to
- * exercise the library default (`history-compact.js#DEFAULT_TOKEN_FRACTION`).
- * The two defaults are kept separate on purpose — see the Compactor
- * constructor JSDoc for the boundary.
- */
-const DEFAULT_COMPACT_TRIGGER_RATIO = 0.7;
-
 /**
  * @typedef {Object} SessionOptions
  * @property {string} [dir] — Yeaft data directory override (default: ~/.yeaft)
@@ -88,7 +74,6 @@ const DEFAULT_COMPACT_TRIGGER_RATIO = 0.7;
 /**
  * @typedef {Object} Session
  * @property {Engine} engine — The wired engine, ready for .query()
- * @property {import('./compact/compactor.js').Compactor} compactor — Per-group history compactor
  * @property {import('./llm/adapter.js').LLMAdapter} adapter — The LLM adapter
  * @property {object} config — Resolved configuration
  * @property {ConversationStore} conversationStore — Conversation persistence
@@ -481,41 +466,6 @@ export async function loadSession(options = {}) {
     managedCliReady: managedCliInstall,
   });
 
-  // ─── 9a-pre. Create per-group history Compactor ────────
-  // Owns the post-turn single-flight + race-guarded compactor that used
-  // to live inline in web-bridge.js. Bridge keeps history ownership and
-  // wires the WS sink (`yeaft_history_compacted`) via
-  // `compactor.setOnCompacted` from `installYeaftRuntimeBridge`.
-  const compactor = new Compactor({
-    summarize: ({ system, prompt, maxTokens } = {}) =>
-      engine.summarizeForCompact({ system, prompt, maxTokens }),
-    // Resolve the model's true context window (GPT-5 256K vs Claude 200K
-    // etc.) instead of pinning to a flat `config.maxContextTokens`.
-    // The 70% threshold then floats with the model in use — the
-    // user-stated requirement ("超过 model context 70% 这一个约束").
-    getMaxContextTokens: () =>
-      resolveContextWindow(
-        typeof config.model === 'string' && config.model
-          ? config.model
-          : (config.primaryModel || ''),
-        config
-      ),
-    // Trigger ratio knob. Defaults to DEFAULT_COMPACT_TRIGGER_RATIO (0.7)
-    // per the user directive; a finite number in (0, 1) wins. Anything
-    // else (NaN, ≤0, ≥1, missing) falls back to the default so a typo in
-    // config.json can't disable compact.
-    getTriggerRatio: () => {
-      const r = Number(config?.compactTriggerRatio);
-      return Number.isFinite(r) && r > 0 && r < 1 ? r : DEFAULT_COMPACT_TRIGGER_RATIO;
-    },
-    // Live-read: `config.language` is mutated in place by
-    // `engine.setLanguage()` (which broadcastLanguageChange fans out to
-    // every per-VP engine). The compactor must see the post-broadcast
-    // value, not a boot-time snapshot, so the summary prompt + the
-    // "session continued" wrapper render in the user's current locale.
-    getLanguage: () =>
-      typeof config.language === 'string' ? config.language : undefined,
-  });
 
   // ─── 9a. Create dream scheduler ────────────
   // The legacy R6 dream-scheduler was retired alongside recall-r6;
@@ -626,7 +576,6 @@ export async function loadSession(options = {}) {
     config,
     conversationStore,
     dreamScheduler,
-    compactor,
     skillManager,
     mcpManager,
     toolRegistry,

package/yeaft/stdio-protocol.js

@@ -421,7 +421,6 @@ export function createStreamProjector({
       case 'llm_retry':
       case 'memory_used':
       case 'recall':
-      case 'consolidate':
       case 'reflection':
       case 'tool_result_update':
       case 'user_append':

package/yeaft/stop-hooks.js

@@ -4,9 +4,8 @@
  * Runs after each query loop completes:
  *   1. Persist messages to conversation/messages/
  *
- * Consolidation (compact orchestrator) is driven by the engine itself
- * via `#maybeConsolidate`; the legacy LLM-driven `consolidate()` plus
- * entries-store extraction was retired in the H2-AMS rip.
+ * Conversation persistence is handled incrementally by the engine. There is
+ * no post-turn LLM conversation-summary maintenance step.
  *
  * Dream V2 owns all background memory maintenance (scope summaries +
  * memory writes via dream/session-wiring.js → createV2DreamScheduler).
@@ -195,9 +194,9 @@ export async function runStopHooks(context) {
     }
   }
 
-  // 2. Consolidation is owned by the engine (#maybeConsolidate → compact
-  //    orchestrator). Dream V2 owns background scope-memory maintenance
-  //    via the session dream scheduler (createV2DreamScheduler).
+  // 2. Dream V2 owns background scope-memory maintenance via the session
+  //    dream scheduler (createV2DreamScheduler). Transcript persistence above
+  //    is the only end-of-turn storage work here.
 
   return result;
 }

package/yeaft/turn-utils.js

@@ -7,10 +7,9 @@
  *
  * Two concerns this module unifies:
  *
- *   1. `compact/turn-group.js` already does atomicity grouping —
- *      `[user, assistant, tool…]` triples that must move as a unit
- *      so we don't split tool_use/tool_result pairs. That's storage-
- *      invariant work.
+ *   1. Tool turns are grouped atomically — `[user, assistant, tool…]`
+ *      triples must move as a unit so we don't split tool_use/tool_result
+ *      pairs. That's storage-invariant work.
  *
  *   2. THIS module does turn IDENTITY — "is the next user-role message
  *      the start of a new conversational turn, or is it just another
@@ -87,7 +86,8 @@ export function countTurns(messages) {
  * Find the index of the message that opens the (n)-th-from-end turn.
  * Returns -1 if there aren't n turns in the history.
  *
- * Algorithm (mirrors `history-compact.js#findCutIndex`):
+ * Algorithm: walk user-role boundaries from the end while counting
+ * distinct canonical turns.
  *   - Walk user-role messages from END backwards, counting DISTINCT
  *     turns by canonical text.
  *   - When `turnsFromEnd === n`, record the index. Keep walking — the

package/yeaft/web-bridge.js

@@ -65,9 +65,7 @@ import { loadSessionConfig, normalizeSessionConfig, resolveSessionConfig, Sessio
 import { updateSessionConfig } from './sessions/session-crud.js';
 import { createCoordinator } from './sessions/coordinator.js';
 import { seedDefaultSession } from './sessions/seed-default.js';
-import {
-  trimSnapshotForBudget,
-} from './history-compact.js';
+import { trimHistoryCacheForRuntime, trimSnapshotForBudget } from './history-window.js';
 import { persistYeaftAttachments, attachmentsForPersistence, persistedAttachmentPreviewPayload } from './attachments.js';
 import { normalizeSessionMessageQuote, sessionMessageQuotePrompt } from './session-message-quote.js';
 import { ConversationStore, parseSeqFromId, projectVisibleSessionMessages } from './conversation/persist.js';
@@ -1249,11 +1247,12 @@ let _vpUnsubscribe = null;
  * of which group it belonged to. Disk was group-tagged correctly, but
  * the in-memory tape was unified.
  *
- * Post-refactor: each GroupContext owns its own `history`, lazily
- * hydrated from `conversationStore.loadRecentBySession(sessionId)` on first
- * access. Group-A and group-B are isolated.
+ * Post-refactor: each Session context owns its own bounded `history` cache,
+ * lazily hydrated from `conversationStore.loadRecentBySession(sessionId)` on
+ * first access. Group-A and group-B are isolated; the durable transcript is
+ * never replaced by the cache trim.
  *
- * @typedef {Array<{role:'user'|'assistant'|'tool', content:string|Array, toolCalls?:Array, toolCallId?:string, isError?:boolean}>} GroupHistory
+ * @typedef {Array<{role:'user'|'assistant'|'tool', content:string|Array, toolCalls?:Array, thinkingBlocks?:Array, toolCallId?:string, isError?:boolean}>} GroupHistory
  */
 
 /**
@@ -1261,10 +1260,10 @@ let _vpUnsubscribe = null;
  * @property {object|null} coord — group coordinator (lazily built by getOrCreateSessionContext)
  * @property {object|null} router — message router (lazily built by getOrCreateSessionContext)
  * @property {object|null} sessionHandle — opened group handle (lazily built by getOrCreateSessionContext)
- * @property {GroupHistory} history — per-group conversation tape
+ * @property {GroupHistory} history — per-Session bounded runtime history cache
  * @property {boolean} historyHydrated — true once history has been loaded
  *   from disk (or explicitly assigned). The flag is required because an
- *   empty array is legitimate post-consolidate / post-clear state and
+ *   empty array is legitimate post-clear state and
  *   MUST NOT trigger a re-hydrate. Without the flag, a partial entry
  *   would short-circuit `getOrCreateSessionHistory` on truthy `[]` and skip
  *   the disk load.
@@ -1366,6 +1365,24 @@ function projectPersistedToHistoryEntry(m, { includeReflections = false } = {})
       input: tc.input,
     }));
   }
+  // Anthropic thinking blocks carry provider-signed replay state. The durable
+  // parser already validates them; preserve the complete payload + signature
+  // in the runtime history owner so a restart does not create a tool arc with
+  // its required thinking prefix missing. `filterSnapshotForVp` strips these
+  // blocks from other VPs before any provider request.
+  if (Array.isArray(m.thinkingBlocks) && m.thinkingBlocks.length > 0) {
+    const thinkingBlocks = m.thinkingBlocks
+      .filter(tb => tb
+        && typeof tb.signature === 'string'
+        && tb.signature
+        && (tb.redacted === true
+          ? typeof tb.data === 'string'
+          : typeof tb.thinking === 'string'))
+      .map(tb => tb.redacted === true
+        ? { redacted: true, data: tb.data, signature: tb.signature }
+        : { thinking: tb.thinking, signature: tb.signature });
+    if (thinkingBlocks.length > 0) entry.thinkingBlocks = thinkingBlocks;
+  }
   if (m.isError) entry.isError = true;
   if (m.ts) entry.ts = m.ts;
   else if (m.time) entry.ts = m.time;
@@ -1373,7 +1390,7 @@ function projectPersistedToHistoryEntry(m, { includeReflections = false } = {})
   if (Array.isArray(m.attachments) && m.attachments.length > 0) entry.attachments = m.attachments;
   if (m.quote && typeof m.quote === 'object') entry.quote = m.quote;
   if (Array.isArray(m.todos)) entry.todos = m.todos;
-  if ((entry.role === 'user' || entry.role === 'assistant') && !entry.content && !entry.attachments && !entry.images && !entry.toolCalls && !entry.todos && !entry.askUserResults) return null;
+  if ((entry.role === 'user' || entry.role === 'assistant') && !entry.content && !entry.attachments && !entry.images && !entry.toolCalls && !entry.thinkingBlocks && !entry.todos && !entry.askUserResults) return null;
   return entry;
 }
 
@@ -1639,6 +1656,12 @@ function hydrateGroupHistory(sessionId) {
   return out;
 }
 
+function boundRuntimeSessionHistory(history) {
+  return trimHistoryCacheForRuntime(history, {
+    language: session?.config?.language,
+  });
+}
+
 /**
  * Get-or-create the per-group history array. Used everywhere the bridge
  * needs to read/append/snapshot a group's conversation tape. Lazily
@@ -1648,9 +1671,8 @@ function hydrateGroupHistory(sessionId) {
  * opened the group can still read history).
  *
  * Returns the SAME array reference across calls within the same
- * lifecycle, so consumers can mutate-in-place. Reassigned only by
- * compact (race guard checks reference equality), `consolidate`
- * events, and session reset.
+ * lifecycle, so consumers can mutate-in-place. Reassigned by session
+ * hydration/reset paths when the canonical array must be replaced.
  *
  * @param {string} sessionId
  * @returns {GroupHistory}
@@ -1659,7 +1681,7 @@ function getOrCreateSessionHistory(sessionId) {
   if (!sessionId) return [];
   let entry = sessionContexts.get(sessionId);
   // Use `historyHydrated` rather than truthiness on `history` itself —
-  // an empty array (post-consolidate, post-clear, or a partial entry
+  // an empty array (post-clear or a partial entry
   // seeded by an early `getOrCreateSessionContext` call before data was
   // loaded) is legitimate state that does NOT mean "needs hydration"...
   // unless we never loaded from disk in the first place. The flag
@@ -1669,19 +1691,19 @@ function getOrCreateSessionHistory(sessionId) {
     entry = makeGroupContextStub();
     sessionContexts.set(sessionId, entry);
   }
-  entry.history = hydrateGroupHistory(sessionId);
+  entry.history = boundRuntimeSessionHistory(hydrateGroupHistory(sessionId));
   entry.historyHydrated = true;
   return entry.history;
 }
 
 /**
- * Reassign a group's history reference. Used by compact + consolidate +
- * clear paths that need to swap the array (not just mutate it). Returns
+ * Reassign a group's history reference. Used by session reset and clear
+ * paths that need to swap the array (not just mutate it). Returns
  * the new reference. Idempotent if the entry doesn't exist (creates one).
  *
  * Sets `historyHydrated = true` because an explicit assignment is itself
- * a hydration — even setting `[]` after `consolidate` means "this is the
- * canonical state right now, don't re-load from disk".
+ * a hydration — even setting `[]` after clear means "this is the canonical
+ * state right now, don't re-load from disk".
  *
  * @param {string} sessionId
  * @param {GroupHistory} next
@@ -1693,7 +1715,7 @@ function setGroupHistory(sessionId, next) {
     entry = makeGroupContextStub();
     sessionContexts.set(sessionId, entry);
   }
-  entry.history = next;
+  entry.history = boundRuntimeSessionHistory(Array.isArray(next) ? next : []);
   entry.historyHydrated = true;
 }
 
@@ -1876,10 +1898,8 @@ function getOrCreateVpEngine(sessionId, vpId, threadId = 'main') {
     // are silently dropped.
     toolStats: session.toolStats || null,
     taskManager: session.taskManager || null,
-    // Per-VP fan-out: bind the engine to its (sessionId, 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).
+    // Per-VP fan-out: bind the engine to its (sessionId, vpId) for scoped
+    // history, memory, and tool ownership.
     sessionId,
     vpId,
   });
@@ -1941,7 +1961,7 @@ function getOrCreateSessionContext(sessionId, sessionHandle) {
   // having gone through `getOrCreateSessionHistory` first: a partial entry
   // could exist with `historyHydrated:false`, so do the load now.
   if (!entry.historyHydrated) {
-    entry.history = hydrateGroupHistory(sessionId);
+    entry.history = boundRuntimeSessionHistory(hydrateGroupHistory(sessionId));
     entry.historyHydrated = true;
   }
   return entry;
@@ -2428,12 +2448,6 @@ export async function __testResetVpState() {
   }
   yeaftConversationId = null;
   lastYeaftSlashCommandSnapshot = null;
-  // Per-group compact in-flight + pending state lives on the session's
-  // Compactor. Clear it so a follow-on test doesn't see ghost in-flight
-  // promises from a prior run.
-  if (session?.compactor && typeof session.compactor.__testReset === 'function') {
-    session.compactor.__testReset();
-  }
 }
 
 
@@ -3920,28 +3934,6 @@ export function installYeaftRuntimeBridge(s) {
     }
   };
 
-  // Wire the post-compact WS sink. Compactor is constructed in
-  // session.js with a no-op sink; bridge owns `sendSessionEvent` /
-  // `yeaftConversationId`, so the sink is wired here once a session is
-  // present. Per-group `yeaft_history_compacted` events fire after a
-  // successful summarize+swap.
-  if (s.compactor && typeof s.compactor.setOnCompacted === 'function') {
-    s.compactor.setOnCompacted((sessionId, result) => {
-      try {
-        sendSessionEvent({
-          type: 'yeaft_history_compacted',
-          reason: result?.reason ?? null,
-          beforeTurns: result?.beforeTurns,
-          afterTurns: result?.afterTurns,
-          beforeTokens: result?.beforeTokens,
-          afterTokens: result?.afterTokens,
-          archivedCount: result?.archivedCount,
-          ts: Date.now(),
-        }, { sessionId });
-      } catch { /* WS pipeline failure must not crash compact */ }
-    });
-  }
-
   ctx.yeaftRuntimeSettings = {
     // No multi-thread settings to surface anymore. Stub for back-compat
     // with message-router's update_yeaft_settings branch — assignments are
@@ -4365,17 +4357,6 @@ function handleEngineEvent(event, hctx) {
       }, envelope);
       break;
 
-    case 'consolidate':
-      // Engine compressed the context — clear THIS group's accumulated
-      // history. Other groups' histories stay intact.
-      if (hctx.sessionId) setGroupHistory(hctx.sessionId, []);
-      sendSessionEvent({
-        type: 'consolidate',
-        archivedCount: event.archivedCount,
-        extractedCount: event.extractedCount,
-      }, envelope);
-      break;
-
     case 'fallback':
       sendSessionEvent({
         type: 'fallback',
@@ -4703,20 +4684,6 @@ async function runYeaftSessionSend(msg) {
     },
   });
 
-  // Entry gate: if a compact is in flight from the previous turn IN
-  // THIS GROUP, wait for it to finish before reading the group's
-  // history. Compact runs at turn END (post-fanout) so it does not
-  // block the user's current message latency, but a fast double-send
-  // from the user must not race with the swap. Other groups' compacts
-  // never block this gate. Compactor is created in session.js — until
-  // a session has loaded (or in test paths that never call
-  // `ensureSessionLoaded`) it may be unavailable; skip gracefully.
-  if (session?.compactor) {
-    const compactWaitStart = perfNowMs();
-    await session.compactor.awaitInFlight(sessionId);
-    traceDuration('session_send.await_compactor', compactWaitStart);
-  }
-
   // yeaftDir is a hard prerequisite for both session boot and group seeding;
   // validate BEFORE booting so a misconfigured agent doesn't leave a zombie
   // session lying around.
@@ -4970,34 +4937,6 @@ async function runYeaftSessionSend(msg) {
     ok: true,
   });
 
-  // Post-turn compaction. Fire-and-forget — does NOT block the response
-  // path. The Compactor's own precheck (`shouldCompactHistory`) decides
-  // whether to engage the LLM, using the trigger ratio wired in
-  // `session.js` (default 70% of model context, knob:
-  // `config.compactTriggerRatio`). The single-flight + anti-starvation
-  // logic inside Compactor handles concurrent turns; the entry-gate
-  // `awaitInFlight` at the top of `handleYeaftSessionSend` (~:2291)
-  // ensures a follow-up turn never reads a half-mutated history.
-  //
-  // Why a per-call historyHandle: Compactor must NEVER close over a
-  // frozen snapshot — the array reference can be swapped by
-  // `consolidate`, session reset, or `route_forward` bursts. The handle
-  // re-resolves on each `get` via the same sessionId-keyed helpers used
-  // everywhere else in the bridge.
-  //
-  // Naming asymmetry note: `getOrCreateSessionHistory` and
-  // `setGroupHistory` are intentionally NOT renamed to match. Both are
-  // session-keyed today (the `set` helper's name is a historical alias
-  // from the pre-VP-thread era), but per CLAUDE.md's "不要为了改名而批量
-  // 重命名" guardrail we leave the wire-compat names alone and rely on
-  // co-location to make the symmetry obvious. The source-pinning test
-  // `web-bridge-post-turn-compact-wiring.test.js` matches both names.
-  if (session?.compactor && sessionId) {
-    session.compactor.scheduleAfterTurn(sessionId, {
-      get: () => getOrCreateSessionHistory(sessionId),
-      set: (next) => setGroupHistory(sessionId, next),
-    });
-  }
 }
 
 /**
@@ -5625,10 +5564,9 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
         markEngineTerminal,
         markTurnEnd,
       };
-      // Always trim the snapshot before passing to engine.query. This is
-      // the second-line defense (history-compact only fires above 30K
-      // tokens — small chats with many turns still bloat the messages
-      // array). See `trimSnapshotForBudget` doc-block for policy.
+      // Always trim the snapshot before passing to engine.query. This is a
+      // deterministic provider-request window; it never calls an LLM or
+      // changes the persisted transcript. See `trimSnapshotForBudget`.
       const trimStart = perfNowMs();
       const trimmedMessages = trimSnapshotForBudget(baseSnapshot, {
         messageTokenBudget: session?.config?.messageTokenBudget,
@@ -5930,11 +5868,12 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
  * raw user prompt(s) + the per-VP assistant text + tool results. Related
  * appends consumed by Engine loop-boundary hooks are passed in the prompt list
  * exactly once, with the same threadId as the running thread. The
- * engine's own `conversationMessages` (with T1/T2 collapse applied)
+ * engine's own `conversationMessages` (with T1/T2 tool-arc folding applied)
  * is persisted to disk via stop-hooks, so the next turn's history is
  * read from disk via `loadRecentBySession` on next session boot. Within
- * a session, this in-memory tape carries the un-collapsed form — which
- * is fine because each VP turn's `engine.query` re-collapses on the fly.
+ * a session, this in-memory tape is a bounded deterministic cache; the
+ * complete transcript remains in ConversationStore and each provider request
+ * applies its own pair-safe history window.
  */
 function buildTurnHistoryEntries(threadId, vpId, prompts, assistantTextParts, toolCallsAccum, toolResultsAccum, thinkingBlocksAccum, opts = {}) {
   const entries = [];
@@ -6019,6 +5958,11 @@ function appendTurnToSessionHistory(sessionId, threadId, vpId, prompts, assistan
   } else {
     history.push(...nextEntries);
   }
+  // The runtime tape is a disposable bounded cache. ConversationStore already
+  // owns the complete transcript, so replacing this reference cannot lose
+  // durable history. Keep the cache bounded after every partial/final append,
+  // including large tool outputs from a long-running turn.
+  setGroupHistory(sessionId, history);
 }
 
 /**
@@ -6135,14 +6079,6 @@ function persistInboundMessageOnceByMsgId({ msgId, text, sessionId, threadId = '
  */
 const _persistedUserMsgIds = new Set();
 
-// Per-group post-turn compaction lives on `session.compactor`
-// (`agent/yeaft/compact/compactor.js`), constructed in `session.js`.
-// Bridge passes a per-call `historyHandle = { get, set }` and wires the
-// `yeaft_history_compacted` WS sink via `compactor.setOnCompacted` from
-// `installYeaftRuntimeBridge`. The bridge keeps history ownership; the
-// Compactor owns single-flight, anti-starvation, race-guard, and the
-// LLM summarize call.
-
 /**
  * Abort every in-flight VP turn and clear all queued envelopes across
  * every group/thread runtime. Shared by `handleYeaftAbortThread` when no
@@ -7102,10 +7038,6 @@ export async function handleYeaftLoadHistory(msg) {
       ? loadVisibleGroupHistoryPage(session.conversationStore, sessionId, limit)
       : { messages: limit > 0 ? pickRecent(session.conversationStore, limit) : [], oldestSeq: null, hasMore: false };
     traceDuration('history.store_load_recent', loadStart, { detail: { rawCount: visiblePage.messages?.length || 0, limit } });
-    // Legacy compact.md is a non-group fallback only. For group replay, reading
-    // it makes every group show "has compact" once any legacy/non-scoped compact
-    // exists, even when this group has no scoped summary.
-    const compactSummary = sessionId ? '' : session.conversationStore.readCompactSummary();
     const replayEntries = sessionId
       ? visiblePage.messages
       : visiblePage.messages
@@ -7152,20 +7084,10 @@ export async function handleYeaftLoadHistory(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. For group
-    // replay, only scoped per-(group, vp) summaries count; legacy compact.md is
-    // reserved for non-group / pre-scoped 1:1 callers.
-    let hasCompactSummaryFlag = !!compactSummary;
-    if (sessionId && typeof session.conversationStore.hasAnyCompactSummaryForSession === 'function') {
-      hasCompactSummaryFlag = session.conversationStore.hasAnyCompactSummaryForSession(sessionId);
-    }
-
     sendSessionEvent({
       type: 'history_loaded',
       mode: 'recent',
       count: replayEntries.length,
-      hasCompactSummary: hasCompactSummaryFlag,
       sessionId,
       requestId,
       hasMore,