fix(core): resolve dirty clusters before render, preserve tool output, async strategy flag

Bug fixes found via codex review:
- Resolve dirty clusters before render() so merged cold messages aren't
  lost (P1: non-root members dropped when summary not yet cached)
- Include 500-char tool response preview instead of name-only placeholder
  so error messages and file paths survive clustering (P1)
- Make getCompressionStrategy() async with ensureExperimentsLoaded() so
  the union-find flag isn't ignored on first compression (P2)
- Thread abortSignal into ClusterSummarizer; rethrow on abort instead of
  swallowing to fallback text (P2)

Author: kimjune01

packages/core/src/config/config.ts

@@ -2350,9 +2350,8 @@ export class Config implements McpContext, AgentLoopContext {
     if (this.experimentalJitContext && this.memoryContextManager) {
       await this.memoryContextManager.refresh();
     } else {
-      const { refreshServerHierarchicalMemory } = await import(
-        '../utils/memoryDiscovery.js'
-      );
+      const { refreshServerHierarchicalMemory } =
+        await import('../utils/memoryDiscovery.js');
       await refreshServerHierarchicalMemory(this);
     }
     if (this._geminiClient?.isInitialized()) {
@@ -3025,7 +3024,8 @@ export class Config implements McpContext, AgentLoopContext {
     return remoteThreshold;
   }
 
-  getCompressionStrategy(): string {
+  async getCompressionStrategy(): Promise<string> {
+    await this.ensureExperimentsLoaded();
     const remoteStrategy =
       this.experiments?.flags[ExperimentFlags.COMPRESSION_STRATEGY]
         ?.stringValue;

packages/core/src/context/chatCompressionService.ts

@@ -263,7 +263,7 @@ export class ChatCompressionService {
     hasFailedCompressionAttempt: boolean,
     abortSignal?: AbortSignal,
   ): Promise<{ newHistory: Content[] | null; info: ChatCompressionInfo }> {
-    const strategy = config.getCompressionStrategy();
+    const strategy = await config.getCompressionStrategy();
 
     if (strategy === 'union-find') {
       return this.compactWithUnionFind(
@@ -537,7 +537,7 @@ export class ChatCompressionService {
     model: string,
     config: Config,
     hasFailedCompressionAttempt: boolean,
-    _abortSignal?: AbortSignal,
+    abortSignal?: AbortSignal,
   ): Promise<{ newHistory: Content[] | null; info: ChatCompressionInfo }> {
     const curatedHistory = chat.getHistory(true);
 
@@ -609,6 +609,7 @@ export class ChatCompressionService {
     const summarizer = new ClusterSummarizer(
       config.getBaseLlmClient(),
       modelStringToModelConfigAlias(model),
+      abortSignal,
     );
     const contextWindow = new ContextWindow(embedder, summarizer, {
       graduateAt: UNION_FIND_GRADUATE_AT,
@@ -623,8 +624,16 @@ export class ChatCompressionService {
         ?.map((p) => {
           if (p.text) return p.text;
           if (p.functionCall) return `[Tool call: ${p.functionCall.name}]`;
-          if (p.functionResponse)
-            return `[Tool response: ${p.functionResponse.name}]`;
+          if (p.functionResponse) {
+            const responseStr = JSON.stringify(
+              p.functionResponse.response ?? '',
+            );
+            const preview =
+              responseStr.length > 500
+                ? responseStr.slice(0, 500) + '...'
+                : responseStr;
+            return `[Tool response: ${p.functionResponse.name}] ${preview}`;
+          }
           return '';
         })
         .join(' ')
@@ -634,18 +643,15 @@ export class ChatCompressionService {
       }
     }
 
-    // Render the compacted context (synchronous — uses cached summaries)
+    // Resolve dirty clusters before rendering so summaries are available
+    await contextWindow.resolveDirty();
+
     const rendered = contextWindow.render(
       null,
       UNION_FIND_RETRIEVE_K,
       UNION_FIND_RETRIEVE_MIN_SIM,
     );
 
-    // Fire-and-forget: resolve dirty clusters in background
-    // In production, this runs during the main LLM call wait.
-    // Here we await it since there's no concurrent main call.
-    await contextWindow.resolveDirty();
-
     // Build new history: cold summaries as a single user message, then hot messages
     const coldSummaries = rendered.slice(
       0,

packages/core/src/services/clusterSummarizer.ts

@@ -26,10 +26,16 @@ function sanitizePromptInput(value: string): string {
 export class ClusterSummarizer implements Summarizer {
   private _client: BaseLlmClient;
   private _modelConfigKey: string;
+  private _abortSignal?: AbortSignal;
 
-  constructor(client: BaseLlmClient, modelConfigKey: string) {
+  constructor(
+    client: BaseLlmClient,
+    modelConfigKey: string,
+    abortSignal?: AbortSignal,
+  ) {
     this._client = client;
     this._modelConfigKey = modelConfigKey;
+    this._abortSignal = abortSignal;
   }
 
   async summarize(messages: string[]): Promise<string> {
@@ -50,13 +56,14 @@ export class ClusterSummarizer implements Summarizer {
         ],
         promptId: 'cluster-summarize',
         role: LlmRole.UTILITY_COMPRESSOR,
-        abortSignal: new AbortController().signal,
+        abortSignal: this._abortSignal ?? new AbortController().signal,
       });
 
       const text = getResponseText(response)?.trim();
       if (!text) return fallback;
       return text;
-    } catch {
+    } catch (e) {
+      if (this._abortSignal?.aborted) throw e;
       return fallback;
     }
   }