From 7d6c70d46b6b308d63099263bc3f3a3fb626d7f5 Mon Sep 17 00:00:00 2001
From: _Kerman <kermanx@qq.com>
Date: Wed, 27 May 2026 15:04:03 +0800
Subject: [PATCH 01/15] fix: compaction

---
 .../agent-core/src/agent/compaction/full.ts   | 104 +-----------------
 .../src/agent/compaction/strategy.ts          |  97 ++++++++++++++++
 .../src/agent/context/complete-slice.ts       |  55 ---------
 3 files changed, 100 insertions(+), 156 deletions(-)
 create mode 100644 packages/agent-core/src/agent/compaction/strategy.ts
 delete mode 100644 packages/agent-core/src/agent/context/complete-slice.ts

diff --git a/packages/agent-core/src/agent/compaction/full.ts b/packages/agent-core/src/agent/compaction/full.ts
index 4f20cb26..e432ec17 100644
--- a/packages/agent-core/src/agent/compaction/full.ts
+++ b/packages/agent-core/src/agent/compaction/full.ts
@@ -29,109 +29,14 @@ import {
 import { renderPrompt } from '../../utils/render-prompt';
 import {
   estimateTokens,
-  estimateTokensForMessage,
   estimateTokensForMessages,
 } from '../../utils/tokens';
-import { sliceCompleteMessages } from '../context/complete-slice';
 import { project } from '../context/projector';
 import compactionInstructionTemplate from './compaction-instruction.md';
-import { DEFAULT_COMPACTION_CONFIG, type CompactionConfig } from './config';
+import { DEFAULT_COMPACTION_CONFIG } from './config';
 import { renderMessagesToText } from './render-messages';
 import type { CompactionBeginData, CompactionResult } from './types';
-
-export interface CompactionStrategy {
-  shouldCompact(usedSize: number, maxSize: number): boolean;
-  shouldBlock(usedSize: number, maxSize: number): boolean;
-  computeCompactCount(messages: readonly Message[], maxSize: number): number;
-  readonly checkAfterStep: boolean;
-  readonly maxCompactionPerTurn: number;
-}
-
-export class DefaultCompactionStrategy implements CompactionStrategy {
-  constructor(protected readonly config: CompactionConfig = DEFAULT_COMPACTION_CONFIG) {}
-
-  shouldCompact(usedSize: number, maxSize: number): boolean {
-    if (maxSize <= 0) return false;
-    return (
-      usedSize >= maxSize * this.config.triggerRatio ||
-      this.shouldUseReservedContext(maxSize, usedSize)
-    );
-  }
-
-  shouldBlock(usedSize: number, maxSize: number): boolean {
-    if (maxSize <= 0) return false;
-    return (
-      usedSize >= maxSize * this.config.blockRatio ||
-      this.shouldUseReservedContext(maxSize, usedSize)
-    );
-  }
-
-  private shouldUseReservedContext(maxSize: number, usedSize: number): boolean {
-    const reservedSize = this.config.reservedContextSize;
-    return reservedSize > 0 && reservedSize < maxSize && usedSize + reservedSize >= maxSize;
-  }
-
-  computeCompactCount(messages: readonly Message[], maxSize: number) {
-    let splitAt = messages.length;
-    let recentSize = 0;
-    let userMessageCount = 0;
-    let onlySeenTrailingUsers = true;
-    for (let i = messages.length - 1; i >= 0; i--) {
-      const m1 = messages[i - 1];
-      const m2 = messages[i];
-      if (m2 === undefined) continue;
-      const isTrailingAssistantPlaceholder =
-        onlySeenTrailingUsers &&
-        m2.role === 'assistant' &&
-        m2.content.length === 0 &&
-        m2.toolCalls.length === 0;
-      if (isTrailingAssistantPlaceholder) {
-        splitAt = i;
-        continue;
-      }
-      const isTrailingUserMessage = onlySeenTrailingUsers && m2.role === 'user';
-      if (!isTrailingUserMessage && messages.length - i >= this.config.maxRecentSteps) break;
-
-      if (m2.role === 'user') {
-        userMessageCount++;
-        if (!isTrailingUserMessage && userMessageCount > this.config.maxRecentUserMessages) {
-          break;
-        }
-      }
-
-      recentSize += estimateTokensForMessage(m2);
-      if (isTrailingUserMessage) {
-        splitAt = i;
-        continue;
-      }
-      if (recentSize > maxSize * this.config.maxRecentSizeRatio) {
-        break;
-      }
-      const canSplitBeforeMessage =
-        m1?.role !== m2.role && !(m1?.role === 'user' && m2.role === 'assistant') && m2.role !== 'tool';
-      if (canSplitBeforeMessage) {
-        splitAt = i;
-      }
-      if (m2.role !== 'user') {
-        onlySeenTrailingUsers = false;
-      }
-    }
-
-    return splitAt;
-  }
-
-  get checkAfterStep(): boolean {
-    return this.config.triggerRatio !== this.config.blockRatio;
-  }
-
-  get maxCompactionPerTurn(): number {
-    return this.config.maxCompactionPerTurn;
-  }
-}
-
-export interface CompactedHistory {
-  text: string;
-}
+import { DefaultCompactionStrategy, type CompactedHistory, type CompactionStrategy } from './strategy';
 
 type CompactionTelemetryTrigger = CompactionBeginData['source'] | 'manual-with-prompt' | 'unknown';
 
@@ -511,10 +416,7 @@ export class FullCompaction {
   }
 
   private computeCompactableCount(history: readonly Message[]): number {
-    return sliceCompleteMessages(
-      history,
-      this.strategy.computeCompactCount(history, this.maxContextSize),
-    );
+    return this.strategy.computeCompactCount(history, this.maxContextSize);
   }
 }
 
diff --git a/packages/agent-core/src/agent/compaction/strategy.ts b/packages/agent-core/src/agent/compaction/strategy.ts
new file mode 100644
index 00000000..85f251f9
--- /dev/null
+++ b/packages/agent-core/src/agent/compaction/strategy.ts
@@ -0,0 +1,97 @@
+import type { Message } from "@moonshot-ai/kosong";
+import { estimateTokensForMessage } from "../../utils/tokens";
+import { type CompactionConfig, DEFAULT_COMPACTION_CONFIG } from "./config";
+
+export interface CompactionStrategy {
+  shouldCompact(usedSize: number, maxSize: number): boolean;
+  shouldBlock(usedSize: number, maxSize: number): boolean;
+  computeCompactCount(messages: readonly Message[], maxSize: number): number;
+  readonly checkAfterStep: boolean;
+  readonly maxCompactionPerTurn: number;
+}
+
+export class DefaultCompactionStrategy implements CompactionStrategy {
+  constructor(protected readonly config: CompactionConfig = DEFAULT_COMPACTION_CONFIG) {}
+
+  shouldCompact(usedSize: number, maxSize: number): boolean {
+    if (maxSize <= 0) return false;
+    return (
+      usedSize >= maxSize * this.config.triggerRatio ||
+      this.shouldUseReservedContext(maxSize, usedSize)
+    );
+  }
+
+  shouldBlock(usedSize: number, maxSize: number): boolean {
+    if (maxSize <= 0) return false;
+    return (
+      usedSize >= maxSize * this.config.blockRatio ||
+      this.shouldUseReservedContext(maxSize, usedSize)
+    );
+  }
+
+  private shouldUseReservedContext(maxSize: number, usedSize: number): boolean {
+    const reservedSize = this.config.reservedContextSize;
+    return reservedSize > 0 && reservedSize < maxSize && usedSize + reservedSize >= maxSize;
+  }
+
+  computeCompactCount(messages: readonly Message[], maxSize: number) {
+    let splitAt = messages.length;
+    let recentSize = 0;
+    let userMessageCount = 0;
+    let onlySeenTrailingUsers = true;
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const m1 = messages[i - 1];
+      const m2 = messages[i];
+      if (m2 === undefined) continue;
+      const isTrailingAssistantPlaceholder =
+        onlySeenTrailingUsers &&
+        m2.role === 'assistant' &&
+        m2.content.length === 0 &&
+        m2.toolCalls.length === 0;
+      if (isTrailingAssistantPlaceholder) {
+        splitAt = i;
+        continue;
+      }
+      const isTrailingUserMessage = onlySeenTrailingUsers && m2.role === 'user';
+      if (!isTrailingUserMessage && messages.length - i >= this.config.maxRecentSteps) break;
+
+      if (m2.role === 'user') {
+        userMessageCount++;
+        if (!isTrailingUserMessage && userMessageCount > this.config.maxRecentUserMessages) {
+          break;
+        }
+      }
+
+      recentSize += estimateTokensForMessage(m2);
+      if (isTrailingUserMessage) {
+        splitAt = i;
+        continue;
+      }
+      if (recentSize > maxSize * this.config.maxRecentSizeRatio) {
+        break;
+      }
+      const canSplitBeforeMessage =
+        m1?.role !== m2.role && !(m1?.role === 'user' && m2.role === 'assistant') && m2.role !== 'tool';
+      if (canSplitBeforeMessage) {
+        splitAt = i;
+      }
+      if (m2.role !== 'user') {
+        onlySeenTrailingUsers = false;
+      }
+    }
+
+    return splitAt;
+  }
+
+  get checkAfterStep(): boolean {
+    return this.config.triggerRatio !== this.config.blockRatio;
+  }
+
+  get maxCompactionPerTurn(): number {
+    return this.config.maxCompactionPerTurn;
+  }
+}
+
+export interface CompactedHistory {
+  text: string;
+}
diff --git a/packages/agent-core/src/agent/context/complete-slice.ts b/packages/agent-core/src/agent/context/complete-slice.ts
deleted file mode 100644
index 258cdf90..00000000
--- a/packages/agent-core/src/agent/context/complete-slice.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-import type { Message } from '@moonshot-ai/kosong';
-
-export function sliceCompleteMessages(
-  messages: readonly Message[],
-  requestedEnd: number,
-): number {
-  let normalized = Math.max(0, Math.min(messages.length, requestedEnd));
-
-  for (let i = 0; i < messages.length; i += 1) {
-    const message = messages[i];
-    if (message?.role !== 'assistant' || message.toolCalls.length === 0) continue;
-
-    const end = findToolExchangeEnd(messages, i);
-    if (end === undefined) {
-      if (normalized > i) {
-        normalized = includePromptForAssistant(messages, i);
-      }
-      continue;
-    }
-
-    if (normalized > i && normalized < end) {
-      normalized = includePromptForAssistant(messages, i);
-    }
-  }
-
-  return normalized;
-}
-
-function findToolExchangeEnd(
-  messages: readonly Message[],
-  assistantIndex: number,
-): number | undefined {
-  const assistant = messages[assistantIndex];
-  if (assistant?.role !== 'assistant') return undefined;
-
-  const pending = new Set(assistant.toolCalls.map((call) => call.id));
-  if (pending.size === 0) return assistantIndex + 1;
-
-  for (let i = assistantIndex + 1; i < messages.length; i += 1) {
-    const message = messages[i];
-    if (message?.role !== 'tool') return undefined;
-    if (message.toolCallId !== undefined) {
-      pending.delete(message.toolCallId);
-    }
-    if (pending.size === 0) return i + 1;
-  }
-
-  return undefined;
-}
-
-function includePromptForAssistant(messages: readonly Message[], assistantIndex: number): number {
-  const previous = messages[assistantIndex - 1];
-  if (previous?.role === 'user') return assistantIndex - 1;
-  return assistantIndex;
-}

From 97a29a3574c047f97081a7db492ff6744f744236 Mon Sep 17 00:00:00 2001
From: _Kerman <kermanx@qq.com>
Date: Wed, 27 May 2026 15:04:35 +0800
Subject: [PATCH 02/15] fix

---
 packages/agent-core/src/agent/compaction/full.ts     | 6 +++++-
 packages/agent-core/src/agent/compaction/strategy.ts | 4 ----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/packages/agent-core/src/agent/compaction/full.ts b/packages/agent-core/src/agent/compaction/full.ts
index e432ec17..3bb55fff 100644
--- a/packages/agent-core/src/agent/compaction/full.ts
+++ b/packages/agent-core/src/agent/compaction/full.ts
@@ -36,10 +36,14 @@ import compactionInstructionTemplate from './compaction-instruction.md';
 import { DEFAULT_COMPACTION_CONFIG } from './config';
 import { renderMessagesToText } from './render-messages';
 import type { CompactionBeginData, CompactionResult } from './types';
-import { DefaultCompactionStrategy, type CompactedHistory, type CompactionStrategy } from './strategy';
+import { DefaultCompactionStrategy, type CompactionStrategy } from './strategy';
 
 type CompactionTelemetryTrigger = CompactionBeginData['source'] | 'manual-with-prompt' | 'unknown';
 
+export interface CompactedHistory {
+  text: string;
+}
+
 export class FullCompaction {
   protected compactionCountInTurn = 0;
   protected compacting: {
diff --git a/packages/agent-core/src/agent/compaction/strategy.ts b/packages/agent-core/src/agent/compaction/strategy.ts
index 85f251f9..6135f363 100644
--- a/packages/agent-core/src/agent/compaction/strategy.ts
+++ b/packages/agent-core/src/agent/compaction/strategy.ts
@@ -91,7 +91,3 @@ export class DefaultCompactionStrategy implements CompactionStrategy {
     return this.config.maxCompactionPerTurn;
   }
 }
-
-export interface CompactedHistory {
-  text: string;
-}

From d9bbb6e57276fd626a573dff321be73b241ecf84 Mon Sep 17 00:00:00 2001
From: _Kerman <kermanx@qq.com>
Date: Wed, 27 May 2026 15:08:51 +0800
Subject: [PATCH 03/15] fix

---
 .../agent-core/src/agent/compaction/config.ts | 19 -----------------
 .../agent-core/src/agent/compaction/full.ts   |  3 +--
 .../src/agent/compaction/strategy.ts          | 21 ++++++++++++++++++-
 3 files changed, 21 insertions(+), 22 deletions(-)
 delete mode 100644 packages/agent-core/src/agent/compaction/config.ts

diff --git a/packages/agent-core/src/agent/compaction/config.ts b/packages/agent-core/src/agent/compaction/config.ts
deleted file mode 100644
index 50d92f30..00000000
--- a/packages/agent-core/src/agent/compaction/config.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-export interface CompactionConfig {
-  triggerRatio: number;
-  blockRatio: number;
-  reservedContextSize: number;
-  maxCompactionPerTurn: number;
-  maxRecentSteps: number;
-  maxRecentUserMessages: number;
-  maxRecentSizeRatio: number;
-}
-
-export const DEFAULT_COMPACTION_CONFIG: CompactionConfig = {
-  triggerRatio: 0.85,
-  blockRatio: 0.85, // Same as triggerRatio to disable async compaction
-  reservedContextSize: 50_000,
-  maxCompactionPerTurn: 3,
-  maxRecentSteps: 3,
-  maxRecentUserMessages: Infinity,
-  maxRecentSizeRatio: 0.2,
-};
diff --git a/packages/agent-core/src/agent/compaction/full.ts b/packages/agent-core/src/agent/compaction/full.ts
index 3bb55fff..c6005456 100644
--- a/packages/agent-core/src/agent/compaction/full.ts
+++ b/packages/agent-core/src/agent/compaction/full.ts
@@ -33,10 +33,9 @@ import {
 } from '../../utils/tokens';
 import { project } from '../context/projector';
 import compactionInstructionTemplate from './compaction-instruction.md';
-import { DEFAULT_COMPACTION_CONFIG } from './config';
 import { renderMessagesToText } from './render-messages';
 import type { CompactionBeginData, CompactionResult } from './types';
-import { DefaultCompactionStrategy, type CompactionStrategy } from './strategy';
+import { DEFAULT_COMPACTION_CONFIG, DefaultCompactionStrategy, type CompactionStrategy } from './strategy';
 
 type CompactionTelemetryTrigger = CompactionBeginData['source'] | 'manual-with-prompt' | 'unknown';
 
diff --git a/packages/agent-core/src/agent/compaction/strategy.ts b/packages/agent-core/src/agent/compaction/strategy.ts
index 6135f363..73b87eef 100644
--- a/packages/agent-core/src/agent/compaction/strategy.ts
+++ b/packages/agent-core/src/agent/compaction/strategy.ts
@@ -1,6 +1,25 @@
 import type { Message } from "@moonshot-ai/kosong";
 import { estimateTokensForMessage } from "../../utils/tokens";
-import { type CompactionConfig, DEFAULT_COMPACTION_CONFIG } from "./config";
+
+export interface CompactionConfig {
+  triggerRatio: number;
+  blockRatio: number;
+  reservedContextSize: number;
+  maxCompactionPerTurn: number;
+  maxRecentSteps: number;
+  maxRecentUserMessages: number;
+  maxRecentSizeRatio: number;
+}
+
+export const DEFAULT_COMPACTION_CONFIG: CompactionConfig = {
+  triggerRatio: 0.85,
+  blockRatio: 0.85, // Same as triggerRatio to disable async compaction
+  reservedContextSize: 50_000,
+  maxCompactionPerTurn: 3,
+  maxRecentSteps: 3,
+  maxRecentUserMessages: Infinity,
+  maxRecentSizeRatio: 0.2,
+};
 
 export interface CompactionStrategy {
   shouldCompact(usedSize: number, maxSize: number): boolean;

From 1654d2d524846225b41022aa9f1e627b012d5972 Mon Sep 17 00:00:00 2001
From: _Kerman <kermanx@qq.com>
Date: Wed, 27 May 2026 17:21:59 +0800
Subject: [PATCH 04/15] fix

---
 .../agent-core/src/agent/compaction/full.ts   | 201 +++++++-----------
 .../src/agent/compaction/strategy.ts          | 120 ++++++-----
 2 files changed, 137 insertions(+), 184 deletions(-)

diff --git a/packages/agent-core/src/agent/compaction/full.ts b/packages/agent-core/src/agent/compaction/full.ts
index c6005456..1fe914e4 100644
--- a/packages/agent-core/src/agent/compaction/full.ts
+++ b/packages/agent-core/src/agent/compaction/full.ts
@@ -12,20 +12,16 @@ import {
   type GenerateResult,
   type Message,
   type TokenUsage,
+  APIContextOverflowError,
 } from '@moonshot-ai/kosong';
 
 import type { Agent } from '..';
 import { isAbortError } from '../../loop/errors';
 import {
-  DEFAULT_MAX_RETRY_ATTEMPTS,
   retryBackoffDelays,
   sleepForRetry,
 } from '../../loop/retry';
 import type { TelemetryPropertyValue } from '../../telemetry';
-import {
-  applyCompletionBudget,
-  resolveCompletionBudget,
-} from '../../utils/completion-budget';
 import { renderPrompt } from '../../utils/render-prompt';
 import {
   estimateTokens,
@@ -43,6 +39,8 @@ export interface CompactedHistory {
   text: string;
 }
 
+export const MAX_COMPACTION_RETRY_ATTEMPTS = 5;
+
 export class FullCompaction {
   protected compactionCountInTurn = 0;
   protected compacting: {
@@ -60,18 +58,25 @@ export class FullCompaction {
   ) {
     this.strategy =
       strategy ??
-      new DefaultCompactionStrategy({
-        ...DEFAULT_COMPACTION_CONFIG,
-        reservedContextSize:
-          agent.providerManager?.config.loopControl?.reservedContextSize ??
-          DEFAULT_COMPACTION_CONFIG.reservedContextSize,
-      });
+      new DefaultCompactionStrategy(
+        () => agent.config.modelCapabilities.max_context_tokens,
+        {
+          ...DEFAULT_COMPACTION_CONFIG,
+          reservedContextSize:
+            agent.providerManager?.config.loopControl?.reservedContextSize ??
+            DEFAULT_COMPACTION_CONFIG.reservedContextSize,
+        }
+      );
   }
 
   get isCompacting(): boolean {
     return this.compacting !== null;
   }
 
+  get compactedHistory(): readonly CompactedHistory[] {
+    return this._compactedHistory;
+  }
+
   begin(data: Readonly<CompactionBeginData>): void {
     this.agent.records.logRecord({
       type: 'full_compaction.begin',
@@ -157,18 +162,6 @@ export class FullCompaction {
     return this.agent.context.tokenCountWithPending;
   }
 
-  private get maxContextSize() {
-    return this.agent.config.modelCapabilities.max_context_tokens;
-  }
-
-  private get shouldCompact(): boolean {
-    return this.strategy.shouldCompact(this.tokenCountWithPending, this.maxContextSize);
-  }
-
-  private get shouldBlock(): boolean {
-    return this.strategy.shouldBlock(this.tokenCountWithPending, this.maxContextSize);
-  }
-
   resetForTurn(): void {
     this.compactionCountInTurn = 0;
   }
@@ -182,7 +175,7 @@ export class FullCompaction {
 
   async beforeStep(signal: AbortSignal): Promise<void> {
     this.checkAutoCompaction();
-    if (this.shouldBlock) {
+    if (this.strategy.shouldBlock(this.tokenCountWithPending)) {
       await this.block(signal);
     }
   }
@@ -196,7 +189,7 @@ export class FullCompaction {
 
   private checkAutoCompaction(throwOnLimit: boolean = true): boolean {
     if (this.compacting) return true;
-    if (!this.shouldCompact) return false;
+    if (!this.strategy.shouldCompact(this.tokenCountWithPending)) return false;
 
     return this.beginAutoCompaction(throwOnLimit);
   }
@@ -212,16 +205,7 @@ export class FullCompaction {
       }
       return false;
     }
-    const history = this.agent.context.history;
-    const compactedCount = this.computeCompactableCount(history);
-    if (compactedCount === 0) return false;
-    if (
-      this.maxContextSize > 0 &&
-      estimateTokensForMessages(project(history.slice(compactedCount))) >= this.maxContextSize
-    ) {
-      return false;
-    }
-    this.agent.fullCompaction.begin({ source: 'auto', instruction: undefined });
+    this.begin({ source: 'auto', instruction: undefined });
     return true;
   }
 
@@ -246,42 +230,59 @@ export class FullCompaction {
     data: Readonly<CompactionBeginData>,
   ): Promise<void> {
     const startedAt = Date.now();
-    let tokensBeforeForError = 0;
-    let retryCountForTelemetry = 0;
+    const originalHistory = [...this.agent.context.history];
+    const tokensBefore = this.agent.context.tokenCount;
+    let retryCount = 0;
     try {
-      const originalHistory = [...this.agent.context.history];
-      const tokensBefore = this.agent.context.tokenCount;
-      tokensBeforeForError = tokensBefore;
-      const compactedCount = this.computeCompactableCount(originalHistory);
-      if (compactedCount === 0) {
-        this.markCanceled();
-        return undefined;
-      }
-      signal.throwIfAborted();
+      let compactedCount = this.strategy.computeCompactCount(originalHistory);
+
       await this.triggerPreCompactHook(data, tokensBefore, signal);
-      signal.throwIfAborted();
 
       const model = this.agent.config.model;
-      const messages = [
-        ...project(originalHistory.slice(0, compactedCount)),
-        {
-          role: 'user',
-          content: [
-            {
-              type: 'text',
-              text: COMPACTION_INSTRUCTION(data.instruction),
-            },
-          ],
-          toolCalls: [],
-        } satisfies Message,
-      ];
-      const { response, retryCount, summary } = await this.generateCompactionResponse({
-        messages,
-        signal,
-        onRetry: (count) => {
-          retryCountForTelemetry = count;
-        },
-      });
+
+      const delays = retryBackoffDelays(MAX_COMPACTION_RETRY_ATTEMPTS);
+      let response: GenerateResult;
+      while (true) {
+        const messagesToCompact = originalHistory.slice(0, compactedCount);
+        const messages = [
+          ...messagesToCompact,
+          {
+            role: 'user',
+            content: [
+              {
+                type: 'text',
+                text: COMPACTION_INSTRUCTION(data.instruction),
+              },
+            ],
+            toolCalls: [],
+          } satisfies Message,
+        ];
+        try {
+          response = await this.agent.generate(
+            this.agent.config.provider,
+            this.agent.config.systemPrompt,
+            [...this.agent.tools.loopTools],
+            messages,
+            undefined,
+            { signal },
+          );
+          break;
+        } catch (error) {
+          retryCount += 1;
+          if (retryCount >= MAX_COMPACTION_RETRY_ATTEMPTS) {
+            throw error;
+          }
+          if (error instanceof APIContextOverflowError) {
+            compactedCount = this.strategy.reduceCompactOnOverflow(messagesToCompact);
+          }
+          if (!isRetryableGenerateError(error)) {
+            throw error;
+          }
+          await sleepForRetry(delays[retryCount - 1]!, signal);
+        }
+      }
+      const summary = extractCompactionSummary(response);
+
       if (response.usage !== null) {
         this.agent.usage.record(model, response.usage);
       }
@@ -325,76 +326,21 @@ export class FullCompaction {
         });
         this.agent.telemetry.track('compaction_failed', {
           trigger_type: compactionTelemetryTrigger(data.source, data.instruction),
-          before_tokens: tokensBeforeForError,
+          before_tokens: tokensBefore,
           duration_ms: Date.now() - startedAt,
-          retry_count: retryCountForTelemetry,
+          retry_count: retryCount,
           error_type: error instanceof Error ? error.name : 'Unknown',
         });
       }
     }
   }
 
-  private async generateCompactionResponse({
-    messages,
-    signal,
-    onRetry,
-  }: {
-    readonly messages: Message[];
-    readonly signal: AbortSignal;
-    readonly onRetry?: ((retryCount: number) => void) | undefined;
-  }): Promise<{
-    readonly response: GenerateResult;
-    readonly summary: string;
-    readonly retryCount: number;
-  }> {
-    const maxAttempts =
-      this.agent.providerManager?.config.loopControl?.maxRetriesPerStep ??
-      DEFAULT_MAX_RETRY_ATTEMPTS;
-    const delays = retryBackoffDelays(maxAttempts);
-    let retryCount = 0;
-
-    const completionBudget = resolveCompletionBudget({
-      reservedContextSize:
-        this.agent.providerManager?.config.loopControl?.reservedContextSize,
-    });
-    const effectiveProvider = applyCompletionBudget({
-      provider: this.agent.config.provider,
-      budget: completionBudget,
-      capability: this.agent.config.modelCapabilities,
-    });
-
-    for (let attempt = 1; ; attempt += 1) {
-      try {
-        const response = await this.agent.generate(
-          effectiveProvider,
-          this.agent.config.systemPrompt,
-          [...this.agent.tools.loopTools],
-          messages,
-          undefined,
-          { signal },
-        );
-        const summary = extractCompactionSummary(response);
-        return { response, summary, retryCount };
-      } catch (error) {
-        if (attempt >= maxAttempts || !isRetryableGenerateError(error)) {
-          throw error;
-        }
-        retryCount += 1;
-        onRetry?.(retryCount);
-        await sleepForRetry(delays[attempt - 1] ?? 0, signal);
-      }
-    }
-  }
-
-  get compactedHistory(): readonly CompactedHistory[] {
-    return this._compactedHistory;
-  }
-
   private async triggerPreCompactHook(
     data: Readonly<CompactionBeginData>,
     tokenCount: number,
     signal: AbortSignal,
   ): Promise<void> {
+    signal.throwIfAborted();
     await this.agent.hooks?.trigger('PreCompact', {
       matcherValue: data.source,
       signal,
@@ -403,6 +349,7 @@ export class FullCompaction {
         tokenCount,
       },
     });
+    signal.throwIfAborted();
   }
 
   private triggerPostCompactHook(
@@ -417,10 +364,6 @@ export class FullCompaction {
       },
     });
   }
-
-  private computeCompactableCount(history: readonly Message[]): number {
-    return this.strategy.computeCompactCount(history, this.maxContextSize);
-  }
 }
 
 function extractCompactionSummary(response: GenerateResult): string {
diff --git a/packages/agent-core/src/agent/compaction/strategy.ts b/packages/agent-core/src/agent/compaction/strategy.ts
index 73b87eef..48498cad 100644
--- a/packages/agent-core/src/agent/compaction/strategy.ts
+++ b/packages/agent-core/src/agent/compaction/strategy.ts
@@ -6,7 +6,7 @@ export interface CompactionConfig {
   blockRatio: number;
   reservedContextSize: number;
   maxCompactionPerTurn: number;
-  maxRecentSteps: number;
+  maxRecentMessages: number;
   maxRecentUserMessages: number;
   maxRecentSizeRatio: number;
 }
@@ -16,90 +16,96 @@ export const DEFAULT_COMPACTION_CONFIG: CompactionConfig = {
   blockRatio: 0.85, // Same as triggerRatio to disable async compaction
   reservedContextSize: 50_000,
   maxCompactionPerTurn: 3,
-  maxRecentSteps: 3,
+  maxRecentMessages: 4,
   maxRecentUserMessages: Infinity,
   maxRecentSizeRatio: 0.2,
 };
 
 export interface CompactionStrategy {
-  shouldCompact(usedSize: number, maxSize: number): boolean;
-  shouldBlock(usedSize: number, maxSize: number): boolean;
-  computeCompactCount(messages: readonly Message[], maxSize: number): number;
+  shouldCompact(usedSize: number): boolean;
+  shouldBlock(usedSize: number): boolean;
+  computeCompactCount(messages: readonly Message[]): number;
+  reduceCompactOnOverflow(messages: readonly Message[]): number;
   readonly checkAfterStep: boolean;
   readonly maxCompactionPerTurn: number;
 }
 
 export class DefaultCompactionStrategy implements CompactionStrategy {
-  constructor(protected readonly config: CompactionConfig = DEFAULT_COMPACTION_CONFIG) {}
+  constructor(
+    protected readonly maxSizeProvider: () => number,
+    protected readonly config: CompactionConfig = DEFAULT_COMPACTION_CONFIG
+  ) { }
 
-  shouldCompact(usedSize: number, maxSize: number): boolean {
-    if (maxSize <= 0) return false;
+  protected get maxSize(): number {
+    return this.maxSizeProvider();
+  }
+
+  shouldCompact(usedSize: number): boolean {
+    if (this.maxSize <= 0) return false;
     return (
-      usedSize >= maxSize * this.config.triggerRatio ||
-      this.shouldUseReservedContext(maxSize, usedSize)
+      usedSize >= this.maxSize * this.config.triggerRatio ||
+      this.shouldUseReservedContext(usedSize)
     );
   }
 
-  shouldBlock(usedSize: number, maxSize: number): boolean {
-    if (maxSize <= 0) return false;
+  shouldBlock(usedSize: number): boolean {
+    if (this.maxSize <= 0) return false;
     return (
-      usedSize >= maxSize * this.config.blockRatio ||
-      this.shouldUseReservedContext(maxSize, usedSize)
+      usedSize >= this.maxSize * this.config.blockRatio ||
+      this.shouldUseReservedContext(usedSize)
     );
   }
 
-  private shouldUseReservedContext(maxSize: number, usedSize: number): boolean {
+  private shouldUseReservedContext(usedSize: number): boolean {
     const reservedSize = this.config.reservedContextSize;
-    return reservedSize > 0 && reservedSize < maxSize && usedSize + reservedSize >= maxSize;
+    return reservedSize > 0 && reservedSize < this.maxSize && usedSize + reservedSize >= this.maxSize;
   }
 
-  computeCompactCount(messages: readonly Message[], maxSize: number) {
-    let splitAt = messages.length;
+  computeCompactCount(messages: readonly Message[]): number {
+    // Return value: N messages to be compacted
+    // LLM Input: messages.slice(0, N) + [user:instruction]
+    // Preserved recent messages: messages.slice(N)
+    //
+    // Rules (in order of precedence):
+    // 1. messages[N-1] must not be a user message or assistant message with tool calls
+    // 2. At least one recent message must be preserved
+    // 3. At most maxRecentMessages recent messages should be preserved
+    // 4. At most maxRecentUserMessages recent user messages should be preserved
+    // 5. At most maxRecentSizeRatio * maxSize recent messages should be preserved
+    // 6. N should be as small as possible
+
+    let recentMessages = 1;
+    let recentUserMessages = 0;
     let recentSize = 0;
-    let userMessageCount = 0;
-    let onlySeenTrailingUsers = true;
-    for (let i = messages.length - 1; i >= 0; i--) {
-      const m1 = messages[i - 1];
-      const m2 = messages[i];
-      if (m2 === undefined) continue;
-      const isTrailingAssistantPlaceholder =
-        onlySeenTrailingUsers &&
-        m2.role === 'assistant' &&
-        m2.content.length === 0 &&
-        m2.toolCalls.length === 0;
-      if (isTrailingAssistantPlaceholder) {
-        splitAt = i;
-        continue;
-      }
-      const isTrailingUserMessage = onlySeenTrailingUsers && m2.role === 'user';
-      if (!isTrailingUserMessage && messages.length - i >= this.config.maxRecentSteps) break;
 
+    for (; recentMessages < messages.length; recentMessages++) {
+      const m1 = messages[messages.length - recentMessages - 1]!;
+      const m2 = messages[messages.length - recentMessages]!;
+
+      recentMessages++;
       if (m2.role === 'user') {
-        userMessageCount++;
-        if (!isTrailingUserMessage && userMessageCount > this.config.maxRecentUserMessages) {
-          break;
-        }
+        recentUserMessages++;
       }
-
       recentSize += estimateTokensForMessage(m2);
-      if (isTrailingUserMessage) {
-        splitAt = i;
-        continue;
-      }
-      if (recentSize > maxSize * this.config.maxRecentSizeRatio) {
-        break;
-      }
-      const canSplitBeforeMessage =
-        m1?.role !== m2.role && !(m1?.role === 'user' && m2.role === 'assistant') && m2.role !== 'tool';
-      if (canSplitBeforeMessage) {
-        splitAt = i;
-      }
-      if (m2.role !== 'user') {
-        onlySeenTrailingUsers = false;
+
+      const reachesMax = recentMessages >= this.config.maxRecentMessages
+        || recentUserMessages >= this.config.maxRecentUserMessages
+        || recentSize >= this.maxSize * this.config.maxRecentSizeRatio;
+      if (!cannotSplitAfter(m1) && reachesMax) {
+        return messages.length - recentMessages;
       }
     }
 
-    return splitAt;
+    throw new Error('Unable to compact messages: all messages are too recent or cannot be split');
+  }
+
+  reduceCompactOnOverflow(messages: readonly Message[]): number {
+    for (let i = messages.length - 2; i > 0; i--) {
+      if (!cannotSplitAfter(messages[i]!)) {
+        return i + 1;
+      }
+    }
+    return messages.length;
   }
 
   get checkAfterStep(): boolean {
@@ -110,3 +116,7 @@ export class DefaultCompactionStrategy implements CompactionStrategy {
     return this.config.maxCompactionPerTurn;
   }
 }
+
+function cannotSplitAfter(message: Message): boolean {
+  return message.role === 'user' || (message.role === 'assistant' && message.toolCalls.length > 0);
+}

From ed22e9d19176fe6010548c07595b24dcb4ba8ed4 Mon Sep 17 00:00:00 2001
From: _Kerman <kermanx@qq.com>
Date: Wed, 27 May 2026 19:51:22 +0800
Subject: [PATCH 05/15] fix

---
 .changeset/fix-compaction-edge-cases.md       |   6 +
 apps/kimi-code/src/tui/kimi-tui.ts            |   8 +-
 .../agent-core/src/agent/compaction/full.ts   |  41 ++--
 .../agent-core/src/agent/compaction/index.ts  |   2 +-
 .../src/agent/compaction/strategy.ts          |  17 +-
 packages/agent-core/src/errors/codes.ts       |   7 +
 .../agent-core/test/agent/compaction.test.ts  | 208 ++++++------------
 .../agent-core/test/agent/context.test.ts     |  51 -----
 packages/node-sdk/test/session-cancel.test.ts |  20 +-
 .../session-plan-compact-usage-resume.test.ts |  14 +-
 10 files changed, 138 insertions(+), 236 deletions(-)
 create mode 100644 .changeset/fix-compaction-edge-cases.md

diff --git a/.changeset/fix-compaction-edge-cases.md b/.changeset/fix-compaction-edge-cases.md
new file mode 100644
index 00000000..001dcb95
--- /dev/null
+++ b/.changeset/fix-compaction-edge-cases.md
@@ -0,0 +1,6 @@
+---
+"@moonshot-ai/agent-core": patch
+"@moonshot-ai/kimi-code": patch
+---
+
+Fix compaction to handle edge cases where no messages are compactable and improve retry logic.
diff --git a/apps/kimi-code/src/tui/kimi-tui.ts b/apps/kimi-code/src/tui/kimi-tui.ts
index 0e71ef4e..73051835 100644
--- a/apps/kimi-code/src/tui/kimi-tui.ts
+++ b/apps/kimi-code/src/tui/kimi-tui.ts
@@ -5594,7 +5594,13 @@ export class KimiTUI {
     }
 
     const customInstruction = args.trim() || undefined;
-    await session.compact({ instruction: customInstruction });
+    try {
+      await session.compact({ instruction: customInstruction });
+    } catch (error) {
+      const code = (error as { code?: string } | null)?.code;
+      const message = error instanceof Error ? error.message : String(error);
+      this.showError(code !== undefined ? `[${code}] ${message}` : message);
+    }
   }
 
   // Handles the /init command.
diff --git a/packages/agent-core/src/agent/compaction/full.ts b/packages/agent-core/src/agent/compaction/full.ts
index 1fe914e4..2ccc3cb5 100644
--- a/packages/agent-core/src/agent/compaction/full.ts
+++ b/packages/agent-core/src/agent/compaction/full.ts
@@ -78,10 +78,6 @@ export class FullCompaction {
   }
 
   begin(data: Readonly<CompactionBeginData>): void {
-    this.agent.records.logRecord({
-      type: 'full_compaction.begin',
-      ...data,
-    });
     if (this.compacting) return;
     if (data.source === 'manual') {
       this.compactionCountInTurn = 0;
@@ -89,12 +85,23 @@ export class FullCompaction {
       this.compactionCountInTurn += 1;
     }
     if (this.compactionCountInTurn > this.strategy.maxCompactionPerTurn) return;
+    const compactedCount = this.strategy.computeCompactCount(this.agent.context.history);
+    if (compactedCount === 0) {
+      throw new KimiError(ErrorCodes.COMPACTION_UNABLE, 'No compactable prefix in current history.');
+    }
+    this.agent.records.logRecord({
+      type: 'full_compaction.begin',
+      ...data,
+    });
     if (!this.agent.records.restoring) {
-      this.startCompactionWorker(data);
+      this.startCompactionWorker(data, compactedCount);
     }
   }
 
-  private startCompactionWorker(data: Readonly<CompactionBeginData>): void {
+  private startCompactionWorker(
+    data: Readonly<CompactionBeginData>,
+    compactedCount: number,
+  ): void {
     const abortController = new AbortController();
     this.agent.emitEvent({
       type: 'compaction.started',
@@ -108,7 +115,7 @@ export class FullCompaction {
       promise: Promise.resolve(),
     };
     this.compacting = active;
-    active.promise = this.compactionWorker(abortController.signal, data);
+    active.promise = this.compactionWorker(abortController.signal, data, compactedCount);
   }
 
   cancel(): void {
@@ -206,7 +213,7 @@ export class FullCompaction {
       return false;
     }
     this.begin({ source: 'auto', instruction: undefined });
-    return true;
+    return this.compacting !== null;
   }
 
   private async block(signal: AbortSignal): Promise<void> {
@@ -228,13 +235,14 @@ export class FullCompaction {
   private async compactionWorker(
     signal: AbortSignal,
     data: Readonly<CompactionBeginData>,
+    initialCompactedCount: number,
   ): Promise<void> {
     const startedAt = Date.now();
     const originalHistory = [...this.agent.context.history];
     const tokensBefore = this.agent.context.tokenCount;
     let retryCount = 0;
     try {
-      let compactedCount = this.strategy.computeCompactCount(originalHistory);
+      let compactedCount = initialCompactedCount;
 
       await this.triggerPreCompactHook(data, tokensBefore, signal);
 
@@ -242,10 +250,11 @@ export class FullCompaction {
 
       const delays = retryBackoffDelays(MAX_COMPACTION_RETRY_ATTEMPTS);
       let response: GenerateResult;
+      let summary: string;
       while (true) {
         const messagesToCompact = originalHistory.slice(0, compactedCount);
         const messages = [
-          ...messagesToCompact,
+          ...project(messagesToCompact),
           {
             role: 'user',
             content: [
@@ -266,22 +275,22 @@ export class FullCompaction {
             undefined,
             { signal },
           );
+          summary = extractCompactionSummary(response);
           break;
         } catch (error) {
-          retryCount += 1;
-          if (retryCount >= MAX_COMPACTION_RETRY_ATTEMPTS) {
-            throw error;
-          }
           if (error instanceof APIContextOverflowError) {
             compactedCount = this.strategy.reduceCompactOnOverflow(messagesToCompact);
           }
           if (!isRetryableGenerateError(error)) {
             throw error;
           }
-          await sleepForRetry(delays[retryCount - 1]!, signal);
+          if (retryCount + 1 >= MAX_COMPACTION_RETRY_ATTEMPTS) {
+            throw error;
+          }
+          await sleepForRetry(delays[retryCount]!, signal);
+          retryCount += 1;
         }
       }
-      const summary = extractCompactionSummary(response);
 
       if (response.usage !== null) {
         this.agent.usage.record(model, response.usage);
diff --git a/packages/agent-core/src/agent/compaction/index.ts b/packages/agent-core/src/agent/compaction/index.ts
index d8da8bbd..876ee14e 100644
--- a/packages/agent-core/src/agent/compaction/index.ts
+++ b/packages/agent-core/src/agent/compaction/index.ts
@@ -1,3 +1,3 @@
 export * from './full';
-export * from './config';
+export * from './strategy';
 export * from './types';
diff --git a/packages/agent-core/src/agent/compaction/strategy.ts b/packages/agent-core/src/agent/compaction/strategy.ts
index 48498cad..8b5cb63f 100644
--- a/packages/agent-core/src/agent/compaction/strategy.ts
+++ b/packages/agent-core/src/agent/compaction/strategy.ts
@@ -62,7 +62,7 @@ export class DefaultCompactionStrategy implements CompactionStrategy {
   }
 
   computeCompactCount(messages: readonly Message[]): number {
-    // Return value: N messages to be compacted
+    // Return value: N messages to be compacted (0 means no compaction possible)
     // LLM Input: messages.slice(0, N) + [user:instruction]
     // Preserved recent messages: messages.slice(N)
     //
@@ -77,26 +77,33 @@ export class DefaultCompactionStrategy implements CompactionStrategy {
     let recentMessages = 1;
     let recentUserMessages = 0;
     let recentSize = 0;
+    let bestN: number | undefined;
 
     for (; recentMessages < messages.length; recentMessages++) {
       const m1 = messages[messages.length - recentMessages - 1]!;
       const m2 = messages[messages.length - recentMessages]!;
 
-      recentMessages++;
       if (m2.role === 'user') {
         recentUserMessages++;
       }
       recentSize += estimateTokensForMessage(m2);
 
+      if (!cannotSplitAfter(m1)) {
+        bestN = messages.length - recentMessages;
+      }
+
       const reachesMax = recentMessages >= this.config.maxRecentMessages
         || recentUserMessages >= this.config.maxRecentUserMessages
         || recentSize >= this.maxSize * this.config.maxRecentSizeRatio;
-      if (!cannotSplitAfter(m1) && reachesMax) {
-        return messages.length - recentMessages;
+      if (reachesMax && bestN !== undefined) {
+        break;
       }
     }
 
-    throw new Error('Unable to compact messages: all messages are too recent or cannot be split');
+    if (bestN !== undefined) return bestN;
+    const last = messages.at(-1);
+    if (last && !cannotSplitAfter(last)) return messages.length;
+    return 0;
   }
 
   reduceCompactOnOverflow(messages: readonly Message[]): number {
diff --git a/packages/agent-core/src/errors/codes.ts b/packages/agent-core/src/errors/codes.ts
index 2583a8fa..4dbf16cb 100644
--- a/packages/agent-core/src/errors/codes.ts
+++ b/packages/agent-core/src/errors/codes.ts
@@ -51,6 +51,7 @@ export const ErrorCodes = {
 
   RECORDS_WRITE_FAILED: 'records.write_failed',
   COMPACTION_FAILED: 'compaction.failed',
+  COMPACTION_UNABLE: 'compaction.unable',
 
   BACKGROUND_TASK_ID_EMPTY: 'background.task_id_empty',
   MCP_SERVER_NOT_FOUND: 'mcp.server_not_found',
@@ -304,6 +305,12 @@ export const KIMI_ERROR_INFO = {
     public: true,
     action: 'Inspect logs and consider increasing compaction limits.',
   },
+  'compaction.unable': {
+    title: 'Unable to compact',
+    retryable: false,
+    public: true,
+    action: 'The current history has no prefix that can be compacted (e.g. only a pending user message). Start a new turn or session instead.',
+  },
 
   'background.task_id_empty': {
     title: 'Background task id is empty',
diff --git a/packages/agent-core/test/agent/compaction.test.ts b/packages/agent-core/test/agent/compaction.test.ts
index 8b518981..0df8cba7 100644
--- a/packages/agent-core/test/agent/compaction.test.ts
+++ b/packages/agent-core/test/agent/compaction.test.ts
@@ -46,7 +46,7 @@ describe('Agent compaction', () => {
       textMessage('user', `pending user ${'x'.repeat(1_200)}`),
     ];
 
-    expect(strategy.computeCompactCount(messages, 1_000)).toBe(2);
+    expect(strategy.computeCompactCount(messages)).toBe(2);
   });
 
   it('keeps consecutive trailing user messages as recent', () => {
@@ -58,10 +58,10 @@ describe('Agent compaction', () => {
       textMessage('user', `pending user two ${'x'.repeat(1_200)}`),
     ];
 
-    expect(strategy.computeCompactCount(messages, 1_000)).toBe(2);
+    expect(strategy.computeCompactCount(messages)).toBe(2);
   });
 
-  it('does not keep an oversized completed exchange as recent', () => {
+  it('compacts the prefix when the trailing exchange itself is oversized', () => {
     const strategy = testCompactionStrategy();
     const messages = [
       textMessage('user', 'old user'),
@@ -70,31 +70,31 @@ describe('Agent compaction', () => {
       textMessage('assistant', `recent assistant ${'x'.repeat(1_200)}`),
     ];
 
-    expect(strategy.computeCompactCount(messages, 1_000)).toBe(messages.length);
+    expect(strategy.computeCompactCount(messages)).toBe(2);
   });
 
   it('reserves response context by default before the ratio threshold is reached', () => {
-    const strategy = new DefaultCompactionStrategy();
+    const strategy = new DefaultCompactionStrategy(() => 256_000);
 
-    expect(strategy.shouldCompact(210_000, 256_000)).toBe(true);
-    expect(strategy.shouldBlock(210_000, 256_000)).toBe(true);
+    expect(strategy.shouldCompact(210_000)).toBe(true);
+    expect(strategy.shouldBlock(210_000)).toBe(true);
   });
 
   it('ignores reserved context when the reserve is not smaller than the model window', () => {
-    const strategy = new DefaultCompactionStrategy({
+    const strategy = new DefaultCompactionStrategy(() => 32_000, {
       triggerRatio: 0.85,
       blockRatio: 0.85,
       reservedContextSize: 50_000,
       maxCompactionPerTurn: 3,
-      maxRecentSteps: 3,
+      maxRecentMessages: 3,
       maxRecentUserMessages: Infinity,
       maxRecentSizeRatio: 0.2,
     });
 
-    expect(strategy.shouldCompact(1, 32_000)).toBe(false);
-    expect(strategy.shouldBlock(1, 32_000)).toBe(false);
-    expect(strategy.shouldCompact(28_000, 32_000)).toBe(true);
-    expect(strategy.shouldBlock(28_000, 32_000)).toBe(true);
+    expect(strategy.shouldCompact(1)).toBe(false);
+    expect(strategy.shouldBlock(1)).toBe(false);
+    expect(strategy.shouldCompact(28_000)).toBe(true);
+    expect(strategy.shouldBlock(28_000)).toBe(true);
   });
 
   it('runs manual compaction and applies the compacted context', async () => {
@@ -123,12 +123,12 @@ describe('Agent compaction', () => {
       [wire] context.append_message     { "message": { "role": "user", "content": [ { "type": "text", "text": "recent user three" } ], "toolCalls": [], "origin": { "kind": "user" } }, "time": "<time>" }
       [wire] full_compaction.begin      { "source": "manual", "instruction": "Keep the important test facts.", "time": "<time>" }
       [emit] compaction.started         { "trigger": "manual", "instruction": "Keep the important test facts." }
-      [wire] usage.record               { "model": "kimi-code", "usage": { "inputOther": 480, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "session", "time": "<time>" }
-      [emit] agent.status.updated       { "model": "kimi-code", "contextTokens": 120, "maxContextTokens": 256000, "contextUsage": 0.00046875, "planMode": false, "permission": "manual", "usage": { "byModel": { "kimi-code": { "inputOther": 480, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 480, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
-      [wire] full_compaction.complete   { "summary": "Compacted summary.", "compactedCount": 4, "tokensBefore": 120, "tokensAfter": 20, "time": "<time>" }
-      [emit] compaction.completed       { "result": { "summary": "Compacted summary.", "compactedCount": 4, "tokensBefore": 120, "tokensAfter": 20 } }
-      [wire] context.apply_compaction   { "summary": "Compacted summary.", "compactedCount": 4, "tokensBefore": 120, "tokensAfter": 20, "time": "<time>" }
-      [emit] agent.status.updated       { "model": "kimi-code", "contextTokens": 20, "maxContextTokens": 256000, "contextUsage": 0.000078125, "planMode": false, "permission": "manual", "usage": { "byModel": { "kimi-code": { "inputOther": 480, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 480, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
+      [wire] usage.record               { "model": "kimi-code", "usage": { "inputOther": 468, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "session", "time": "<time>" }
+      [emit] agent.status.updated       { "model": "kimi-code", "contextTokens": 120, "maxContextTokens": 256000, "contextUsage": 0.00046875, "planMode": false, "permission": "manual", "usage": { "byModel": { "kimi-code": { "inputOther": 468, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 468, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
+      [wire] full_compaction.complete   { "summary": "Compacted summary.", "compactedCount": 2, "tokensBefore": 120, "tokensAfter": 32, "time": "<time>" }
+      [emit] compaction.completed       { "result": { "summary": "Compacted summary.", "compactedCount": 2, "tokensBefore": 120, "tokensAfter": 32 } }
+      [wire] context.apply_compaction   { "summary": "Compacted summary.", "compactedCount": 2, "tokensBefore": 120, "tokensAfter": 32, "time": "<time>" }
+      [emit] agent.status.updated       { "model": "kimi-code", "contextTokens": 32, "maxContextTokens": 256000, "contextUsage": 0.000125, "planMode": false, "permission": "manual", "usage": { "byModel": { "kimi-code": { "inputOther": 468, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 468, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
     `);
     expect(ctx.lastLlmInput()).toMatchInlineSnapshot(`
       system: <system-prompt>
@@ -136,8 +136,6 @@ describe('Agent compaction', () => {
       messages:
         user: text "old user one"
         assistant: text "old assistant one"
-        user: text "old user two"
-        assistant: text "old assistant two"
         user: text <compaction-instruction>
     `);
     expect(ctx.compactHistory()).toMatchInlineSnapshot(`
@@ -146,6 +144,14 @@ describe('Agent compaction', () => {
           "role": "assistant",
           "text": "Compacted summary.",
         },
+        {
+          "role": "user",
+          "text": "old user two",
+        },
+        {
+          "role": "assistant",
+          "text": "old assistant two",
+        },
         {
           "role": "user",
           "text": "recent user three",
@@ -190,64 +196,17 @@ describe('Agent compaction', () => {
       properties: {
         trigger_type: 'manual-with-prompt',
         before_tokens: 120,
-        after_tokens: 20,
+        after_tokens: 32,
         duration_ms: expect.any(Number),
-        compacted_count: 4,
+        compacted_count: 2,
         retry_count: 0,
-        llm_input_tokens: 480,
+        llm_input_tokens: 468,
         llm_output_tokens: 8,
       },
     });
     await ctx.expectResumeMatches();
   });
 
-  it('uses the model context window for compaction completion budget', async () => {
-    const maxContextTokens = 5_000;
-    let appliedCap: number | undefined;
-    const generate: GenerateFn = async (provider) => {
-      const cap = (provider as { readonly modelParameters?: Record<string, unknown> })
-        .modelParameters?.['max_completion_tokens'];
-      if (typeof cap !== 'number') throw new Error('Expected max_completion_tokens to be applied');
-      appliedCap = cap;
-
-      return {
-        id: 'mock-compaction-budget',
-        message: {
-          role: 'assistant',
-          content: [{ type: 'text', text: 'Budgeted summary.' }],
-          toolCalls: [],
-        },
-        usage: {
-          inputOther: 1,
-          output: 4,
-          inputCacheRead: 0,
-          inputCacheCreation: 0,
-        },
-        finishReason: 'completed',
-        rawFinishReason: 'stop',
-      };
-    };
-    const ctx = testAgent({ compactionStrategy: alwaysCompactOnce, generate });
-    ctx.configure({
-      provider: CATALOGUED_PROVIDER,
-      modelCapabilities: {
-        ...CATALOGUED_MODEL_CAPABILITIES,
-        max_context_tokens: maxContextTokens,
-      },
-    });
-    ctx.appendExchange(1, 'old user one', 'old assistant one', maxContextTokens - 100);
-    const compacted = new Promise<void>((resolve) => {
-      ctx.emitter.once('context.apply_compaction', () => {
-        resolve();
-      });
-    });
-
-    await ctx.rpc.beginCompaction({ instruction: 'Keep the important test facts.' });
-    await compacted;
-
-    expect(appliedCap).toBe(maxContextTokens);
-  });
-
   it('projects the compacted prefix before sending the summary request', async () => {
     const ctx = testAgent({ compactionStrategy: alwaysCompactOnce });
     ctx.configure({
@@ -638,6 +597,7 @@ describe('Agent compaction', () => {
   });
 
   it('reports compaction retry_count when retryable generation failures are exhausted', async () => {
+    vi.useFakeTimers();
     const records: TelemetryRecord[] = [];
     let attempts = 0;
     const generate: GenerateFn = async () => {
@@ -654,16 +614,17 @@ describe('Agent compaction', () => {
     const failed = ctx.once('error');
 
     await ctx.rpc.beginCompaction({});
+    await vi.advanceTimersByTimeAsync(60_000);
     await failed;
 
-    expect(attempts).toBe(3);
+    expect(attempts).toBe(5);
     expect(records).toContainEqual({
       event: 'compaction_failed',
       properties: {
         trigger_type: 'manual',
         before_tokens: 80,
         duration_ms: expect.any(Number),
-        retry_count: 2,
+        retry_count: 4,
         error_type: 'APIConnectionError',
       },
     });
@@ -872,20 +833,20 @@ describe('Agent compaction', () => {
       [wire] full_compaction.begin       { "source": "auto", "time": "<time>" }
       [emit] compaction.started          { "trigger": "auto" }
       [emit] compaction.blocked          { "turnId": 0 }
-      [wire] usage.record                { "model": "kimi-code", "usage": { "inputOther": 487, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "session", "time": "<time>" }
-      [emit] agent.status.updated        { "model": "kimi-code", "contextTokens": 950000, "maxContextTokens": 256000, "contextUsage": 3.7109375, "planMode": false, "permission": "manual", "usage": { "byModel": { "kimi-code": { "inputOther": 487, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 487, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
-      [wire] full_compaction.complete    { "summary": "Auto compacted summary.", "compactedCount": 6, "tokensBefore": 950000, "tokensAfter": 13, "time": "<time>" }
-      [emit] compaction.completed        { "result": { "summary": "Auto compacted summary.", "compactedCount": 6, "tokensBefore": 950000, "tokensAfter": 13 } }
-      [wire] context.apply_compaction    { "summary": "Auto compacted summary.", "compactedCount": 6, "tokensBefore": 950000, "tokensAfter": 13, "time": "<time>" }
-      [emit] agent.status.updated        { "model": "kimi-code", "contextTokens": 13, "maxContextTokens": 256000, "contextUsage": 0.00005078125, "planMode": false, "permission": "manual", "usage": { "byModel": { "kimi-code": { "inputOther": 487, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 487, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
+      [wire] usage.record                { "model": "kimi-code", "usage": { "inputOther": 472, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "session", "time": "<time>" }
+      [emit] agent.status.updated        { "model": "kimi-code", "contextTokens": 950000, "maxContextTokens": 256000, "contextUsage": 3.7109375, "planMode": false, "permission": "manual", "usage": { "byModel": { "kimi-code": { "inputOther": 472, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 472, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
+      [wire] full_compaction.complete    { "summary": "Auto compacted summary.", "compactedCount": 4, "tokensBefore": 950000, "tokensAfter": 28, "time": "<time>" }
+      [emit] compaction.completed        { "result": { "summary": "Auto compacted summary.", "compactedCount": 4, "tokensBefore": 950000, "tokensAfter": 28 } }
+      [wire] context.apply_compaction    { "summary": "Auto compacted summary.", "compactedCount": 4, "tokensBefore": 950000, "tokensAfter": 28, "time": "<time>" }
+      [emit] agent.status.updated        { "model": "kimi-code", "contextTokens": 28, "maxContextTokens": 256000, "contextUsage": 0.000109375, "planMode": false, "permission": "manual", "usage": { "byModel": { "kimi-code": { "inputOther": 472, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 472, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
       [wire] context.append_loop_event   { "event": { "type": "step.begin", "uuid": "<uuid-1>", "turnId": "0", "step": 1 }, "time": "<time>" }
       [emit] turn.step.started           { "turnId": 0, "step": 1, "stepId": "<uuid-1>" }
       [emit] assistant.delta             { "turnId": 0, "delta": "I can answer after compaction." }
       [wire] context.append_loop_event   { "event": { "type": "content.part", "uuid": "<uuid-2>", "turnId": "0", "step": 1, "stepUuid": "<uuid-1>", "part": { "type": "text", "text": "I can answer after compaction." } }, "time": "<time>" }
-      [wire] context.append_loop_event   { "event": { "type": "step.end", "uuid": "<uuid-1>", "turnId": "0", "step": 1, "usage": { "inputOther": 16, "output": 11, "inputCacheRead": 0, "inputCacheCreation": 0 }, "finishReason": "end_turn" }, "time": "<time>" }
-      [emit] turn.step.completed         { "turnId": 0, "step": 1, "stepId": "<uuid-1>", "usage": { "inputOther": 16, "output": 11, "inputCacheRead": 0, "inputCacheCreation": 0 }, "finishReason": "end_turn" }
-      [wire] usage.record                { "model": "kimi-code", "usage": { "inputOther": 16, "output": 11, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "turn", "time": "<time>" }
-      [emit] agent.status.updated        { "model": "kimi-code", "contextTokens": 27, "maxContextTokens": 256000, "contextUsage": 0.00010546875, "planMode": false, "permission": "manual", "usage": { "byModel": { "kimi-code": { "inputOther": 503, "output": 20, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 503, "output": 20, "inputCacheRead": 0, "inputCacheCreation": 0 }, "currentTurn": { "inputOther": 16, "output": 11, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
+      [wire] context.append_loop_event   { "event": { "type": "step.end", "uuid": "<uuid-1>", "turnId": "0", "step": 1, "usage": { "inputOther": 31, "output": 11, "inputCacheRead": 0, "inputCacheCreation": 0 }, "finishReason": "end_turn" }, "time": "<time>" }
+      [emit] turn.step.completed         { "turnId": 0, "step": 1, "stepId": "<uuid-1>", "usage": { "inputOther": 31, "output": 11, "inputCacheRead": 0, "inputCacheCreation": 0 }, "finishReason": "end_turn" }
+      [wire] usage.record                { "model": "kimi-code", "usage": { "inputOther": 31, "output": 11, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "turn", "time": "<time>" }
+      [emit] agent.status.updated        { "model": "kimi-code", "contextTokens": 42, "maxContextTokens": 256000, "contextUsage": 0.0001640625, "planMode": false, "permission": "manual", "usage": { "byModel": { "kimi-code": { "inputOther": 503, "output": 20, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 503, "output": 20, "inputCacheRead": 0, "inputCacheCreation": 0 }, "currentTurn": { "inputOther": 31, "output": 11, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
       [emit] turn.ended                  { "turnId": 0, "reason": "completed" }
     `);
     expect(ctx.llmInputs()).toMatchInlineSnapshot(`
@@ -897,13 +858,13 @@ describe('Agent compaction', () => {
           assistant: text "old assistant one"
           user: text "old user two"
           assistant: text "old assistant two"
-          user: text "recent user three"
-          assistant: text "recent assistant three"
           user: text <compaction-instruction>
 
       call 2:
         messages:
           assistant: text "Auto compacted summary."
+          user: text "recent user three"
+          assistant: text "recent assistant three"
           user: text "Answer after compacting"
     `);
     expect(records).toContainEqual({
@@ -911,15 +872,15 @@ describe('Agent compaction', () => {
       properties: expect.objectContaining({
         trigger_type: 'auto',
         before_tokens: 950000,
-        after_tokens: 13,
-        compacted_count: 6,
+        after_tokens: 28,
+        compacted_count: 4,
         retry_count: 0,
       }),
     });
     await ctx.expectResumeMatches();
   });
 
-  it('does not auto compact when an oversized first prompt has no compactable prefix', async () => {
+  it('fails the turn with compaction.unable when auto compaction has no compactable prefix', async () => {
     const ctx = testAgent();
     ctx.configure({
       provider: CATALOGUED_PROVIDER,
@@ -930,28 +891,34 @@ describe('Agent compaction', () => {
     });
     const oversizedPrompt = `initial-pending-verbatim:${'x'.repeat(8_000)}`;
 
-    ctx.mockNextResponse({ type: 'text', text: 'I can answer the initial prompt.' });
     await ctx.rpc.prompt({ input: [{ type: 'text', text: oversizedPrompt }] });
     const events = await ctx.untilTurnEnd();
 
     expect(eventIndex(events, 'compaction.started')).toBe(-1);
-    expect(ctx.llmCalls).toHaveLength(1);
-    expect(messageText(ctx.llmCalls[0]?.history.at(-1))).toBe(oversizedPrompt);
+    expect(ctx.llmCalls).toHaveLength(0);
+    expect(events).toContainEqual(
+      expect.objectContaining({
+        event: 'turn.ended',
+        args: expect.objectContaining({
+          reason: 'failed',
+          error: expect.objectContaining({ code: 'compaction.unable' }),
+        }),
+      }),
+    );
     await ctx.expectResumeMatches();
   });
 
-  it('cancels manual compaction without leaving compaction stuck when no prefix is compactable', async () => {
+  it('rejects manual compaction with compaction.unable when no prefix is compactable', async () => {
     const ctx = testAgent();
     ctx.configure({
       provider: CATALOGUED_PROVIDER,
       modelCapabilities: CATALOGUED_MODEL_CAPABILITIES,
     });
     ctx.agent.context.appendUserMessage([{ type: 'text', text: 'only pending user' }]);
-    const canceled = ctx.once('compaction.cancelled');
-
-    await ctx.rpc.beginCompaction({});
-    await canceled;
 
+    await expect(ctx.rpc.beginCompaction({})).rejects.toMatchObject({
+      code: 'compaction.unable',
+    });
     expect(ctx.llmCalls).toHaveLength(0);
 
     ctx.agent.context.clear();
@@ -1227,42 +1194,6 @@ describe('Agent compaction', () => {
     );
   });
 
-  it('does not compact a prefix when the retained pending prompt already exceeds the model window', async () => {
-    let callCount = 0;
-    const inputs: string[][] = [];
-    const generate: GenerateFn = async (_provider, _system, _tools, history) => {
-      callCount += 1;
-      inputs.push(inputHistorySnapshot(history));
-      throw new APIContextOverflowError(400, 'Context length exceeded', 'req-oversized-pending');
-    };
-    const ctx = testAgent({ generate });
-    ctx.configure({
-      provider: CATALOGUED_PROVIDER,
-      modelCapabilities: {
-        ...CATALOGUED_MODEL_CAPABILITIES,
-        max_context_tokens: 2_000,
-      },
-    });
-    ctx.appendExchange(1, 'old user one', 'old assistant one', 20);
-    const oversizedPrompt = `uncompactable-pending:${'x'.repeat(9_000)}`;
-    ctx.newEvents();
-
-    await ctx.rpc.prompt({ input: [{ type: 'text', text: oversizedPrompt }] });
-    const events = await ctx.untilTurnEnd();
-
-    expect(callCount).toBe(1);
-    expect(eventIndex(events, 'compaction.started')).toBe(-1);
-    expect(inputs).toHaveLength(1);
-    expect(inputs[0]?.at(-1)).toBe(`user: ${oversizedPrompt}`);
-    expect(events).toContainEqual(
-      expect.objectContaining({
-        event: 'turn.ended',
-        args: expect.objectContaining({ reason: 'failed' }),
-      }),
-    );
-    await ctx.expectResumeMatches();
-  });
-
   it('ignores filtered assistant placeholders when checking the retained overflow suffix', async () => {
     let callCount = 0;
     const generate: GenerateFn = async (_provider, _system, _tools, history, callbacks) => {
@@ -1454,6 +1385,7 @@ const alwaysCompactOnce: CompactionStrategy = {
   shouldCompact: () => true,
   shouldBlock: () => true,
   computeCompactCount: (messages: readonly Message[]) => messages.length,
+  reduceCompactOnOverflow: (messages: readonly Message[]) => messages.length,
   checkAfterStep: true,
   maxCompactionPerTurn: 1,
 };
@@ -1467,25 +1399,25 @@ function missingToolCall(): ToolCall {
   };
 }
 
-function testCompactionStrategy(): DefaultCompactionStrategy {
-  return new DefaultCompactionStrategy({
+function testCompactionStrategy(maxSize: number = 1_000): DefaultCompactionStrategy {
+  return new DefaultCompactionStrategy(() => maxSize, {
     triggerRatio: 0.85,
     blockRatio: 0.85,
     reservedContextSize: 0,
     maxCompactionPerTurn: 3,
-    maxRecentSteps: 10,
+    maxRecentMessages: 10,
     maxRecentUserMessages: Infinity,
     maxRecentSizeRatio: 0.2,
   });
 }
 
-function overflowOnlyCompactionStrategy(): DefaultCompactionStrategy {
-  return new DefaultCompactionStrategy({
+function overflowOnlyCompactionStrategy(maxSize: number = 14): DefaultCompactionStrategy {
+  return new DefaultCompactionStrategy(() => maxSize, {
     triggerRatio: Infinity,
     blockRatio: Infinity,
     reservedContextSize: 0,
     maxCompactionPerTurn: 3,
-    maxRecentSteps: 3,
+    maxRecentMessages: 3,
     maxRecentUserMessages: Infinity,
     maxRecentSizeRatio: 0.2,
   });
diff --git a/packages/agent-core/test/agent/context.test.ts b/packages/agent-core/test/agent/context.test.ts
index 406183bf..fc89ba78 100644
--- a/packages/agent-core/test/agent/context.test.ts
+++ b/packages/agent-core/test/agent/context.test.ts
@@ -1,7 +1,6 @@
 import type { Message } from '@moonshot-ai/kosong';
 import { describe, expect, it } from 'vitest';
 
-import { sliceCompleteMessages } from '../../src/agent/context/complete-slice';
 import { renderNotificationXml } from '../../src/agent/context/notification-xml';
 import { project } from '../../src/agent/context/projector';
 import { estimateTokensForMessages } from '../../src/utils/tokens';
@@ -468,26 +467,6 @@ describe('Agent context', () => {
     );
   });
 
-  it('normalizes message slice ends around tool exchanges', () => {
-    const messages: Message[] = [
-      userMessage('old prompt'),
-      assistantMessage('old answer'),
-      userMessage('run both tools'),
-      assistantToolCallMessage(['call_one', 'call_two']),
-      toolMessage('call_one', 'one result'),
-      toolMessage('call_two', 'two result'),
-      userMessage('recent prompt'),
-    ];
-
-    expect(sliceCompleteMessages(messages, 1)).toBe(1);
-    expect(sliceCompleteMessages(messages, 4)).toBe(2);
-    expect(sliceCompleteMessages(messages, 5)).toBe(2);
-    expect(sliceCompleteMessages(messages, 6)).toBe(6);
-    expect(sliceCompleteMessages(messages, 99)).toBe(7);
-
-    const incomplete = messages.slice(0, 5);
-    expect(sliceCompleteMessages(incomplete, 5)).toBe(2);
-  });
 });
 
 describe('Agent context notification projection', () => {
@@ -565,36 +544,6 @@ function userMessage(text: string): Message {
   };
 }
 
-function assistantMessage(text: string): Message {
-  return {
-    role: 'assistant',
-    content: [{ type: 'text', text }],
-    toolCalls: [],
-  };
-}
-
-function assistantToolCallMessage(ids: readonly string[]): Message {
-  return {
-    role: 'assistant',
-    content: [],
-    toolCalls: ids.map((id) => ({
-      type: 'function',
-      id,
-      name: 'Lookup',
-      arguments: '{}',
-    })),
-  };
-}
-
-function toolMessage(toolCallId: string, text: string): Message {
-  return {
-    role: 'tool',
-    content: [{ type: 'text', text }],
-    toolCalls: [],
-    toolCallId,
-  };
-}
-
 function textOf(message: Message): string {
   return message.content
     .filter((part): part is { type: 'text'; text: string } => part.type === 'text')
diff --git a/packages/node-sdk/test/session-cancel.test.ts b/packages/node-sdk/test/session-cancel.test.ts
index b3155eb7..51899247 100644
--- a/packages/node-sdk/test/session-cancel.test.ts
+++ b/packages/node-sdk/test/session-cancel.test.ts
@@ -80,7 +80,7 @@ describe('Session.cancel', () => {
     }
   });
 
-  it('cancels an active manual compaction and emits compaction.cancelled', async () => {
+  it('rejects manual compaction on an empty session with compaction.unable', async () => {
     const homeDir = await makeTempDir(tempDirs, 'kimi-sdk-cancel-compact-home-');
     const workDir = await makeTempDir(tempDirs, 'kimi-sdk-cancel-compact-work-');
     await writeFakeModelConfig(homeDir);
@@ -88,21 +88,11 @@ describe('Session.cancel', () => {
 
     try {
       const session = await harness.createSession({ id: 'ses_cancel_compaction', workDir });
-      const started = waitForSDKEvent(session, (event) => event.type === 'compaction.started');
-      const cancelled = waitForSDKEvent(session, (event) => event.type === 'compaction.cancelled');
 
-      await session.compact({ instruction: 'Keep the compact test pending.' });
-      await expect(started).resolves.toMatchObject({
-        type: 'compaction.started',
-        sessionId: session.id,
-        trigger: 'manual',
-      });
-      await session.cancelCompaction();
-
-      await expect(cancelled).resolves.toMatchObject({
-        type: 'compaction.cancelled',
-        sessionId: session.id,
-      });
+      await expect(session.compact({ instruction: 'Keep the compact test pending.' })).rejects.toMatchObject({
+        name: 'KimiError',
+        code: 'compaction.unable',
+      } satisfies Partial<KimiError>);
     } finally {
       await harness.close();
     }
diff --git a/packages/node-sdk/test/session-plan-compact-usage-resume.test.ts b/packages/node-sdk/test/session-plan-compact-usage-resume.test.ts
index 74c3ec3d..11a8c125 100644
--- a/packages/node-sdk/test/session-plan-compact-usage-resume.test.ts
+++ b/packages/node-sdk/test/session-plan-compact-usage-resume.test.ts
@@ -82,7 +82,7 @@ describe('Session plan, compact, usage, and resume APIs', () => {
     }
   });
 
-  it('starts manual compaction with an optional instruction', async () => {
+  it('rejects manual compaction on an empty session with compaction.unable', async () => {
     const homeDir = await makeTempDir(tempDirs, 'kimi-sdk-compact-home-');
     const workDir = await makeTempDir(tempDirs, 'kimi-sdk-compact-work-');
     await writeTestConfig(homeDir);
@@ -91,14 +91,10 @@ describe('Session plan, compact, usage, and resume APIs', () => {
     try {
       const session = await harness.createSession({ id: 'ses_compact_runtime', workDir });
 
-      const started = waitForSessionEvent(session, (event) => event.type === 'compaction.started');
-      await session.compact({ instruction: 'Keep important facts.' });
-
-      await expect(started).resolves.toMatchObject({
-        type: 'compaction.started',
-        trigger: 'manual',
-        instruction: 'Keep important facts.',
-      });
+      await expect(session.compact({ instruction: 'Keep important facts.' })).rejects.toMatchObject({
+        name: 'KimiError',
+        code: 'compaction.unable',
+      } satisfies Partial<KimiError>);
     } finally {
       await harness.close();
     }

From d6277866e94e3e22eeaa46f6998072f167f8ba65 Mon Sep 17 00:00:00 2001
From: _Kerman <kermanx@qq.com>
Date: Wed, 27 May 2026 20:10:17 +0800
Subject: [PATCH 06/15] fix

---
 .../agent-core/src/agent/compaction/full.ts   |  6 +-
 packages/agent-core/src/agent/index.ts        |  2 +-
 packages/agent-core/src/utils/tokens.ts       |  2 +-
 .../agent-core/test/agent/compaction.test.ts  | 78 ++++++++++++++-----
 .../agent-core/test/agent/context.test.ts     |  4 +-
 5 files changed, 67 insertions(+), 25 deletions(-)

diff --git a/packages/agent-core/src/agent/compaction/full.ts b/packages/agent-core/src/agent/compaction/full.ts
index 2ccc3cb5..032dc96e 100644
--- a/packages/agent-core/src/agent/compaction/full.ts
+++ b/packages/agent-core/src/agent/compaction/full.ts
@@ -87,7 +87,7 @@ export class FullCompaction {
     if (this.compactionCountInTurn > this.strategy.maxCompactionPerTurn) return;
     const compactedCount = this.strategy.computeCompactCount(this.agent.context.history);
     if (compactedCount === 0) {
-      throw new KimiError(ErrorCodes.COMPACTION_UNABLE, 'No compactable prefix in current history.');
+      throw new KimiError(ErrorCodes.COMPACTION_UNABLE, 'No prefix that can be compacted in current history.');
     }
     this.agent.records.logRecord({
       type: 'full_compaction.begin',
@@ -239,7 +239,7 @@ export class FullCompaction {
   ): Promise<void> {
     const startedAt = Date.now();
     const originalHistory = [...this.agent.context.history];
-    const tokensBefore = this.agent.context.tokenCount;
+    const tokensBefore = estimateTokensForMessages(originalHistory);
     let retryCount = 0;
     try {
       let compactedCount = initialCompactedCount;
@@ -306,7 +306,7 @@ export class FullCompaction {
       }
 
       const recent = originalHistory.slice(compactedCount);
-      const tokensAfter = estimateTokens(summary) + estimateTokensForMessages(project(recent));
+      const tokensAfter = estimateTokens(summary) + estimateTokensForMessages(recent);
 
       const result: CompactionResult = {
         summary,
diff --git a/packages/agent-core/src/agent/index.ts b/packages/agent-core/src/agent/index.ts
index cdb1def9..5907985f 100644
--- a/packages/agent-core/src/agent/index.ts
+++ b/packages/agent-core/src/agent/index.ts
@@ -474,7 +474,7 @@ function buildLlmRequestMetadata(
 
   const estimatedInputTokens =
     estimateTokens(systemPrompt) +
-    estimateTokensForMessages([...history]) +
+    estimateTokensForMessages(history) +
     estimateTokensForTools(tools);
 
   const metadata: LlmRequestMetadata = {
diff --git a/packages/agent-core/src/utils/tokens.ts b/packages/agent-core/src/utils/tokens.ts
index a6547e96..1b4f7955 100644
--- a/packages/agent-core/src/utils/tokens.ts
+++ b/packages/agent-core/src/utils/tokens.ts
@@ -21,7 +21,7 @@ export function estimateTokens(text: string): number {
   return Math.ceil(asciiCount / 4) + nonAsciiCount;
 }
 
-export function estimateTokensForMessages(messages: Message[]): number {
+export function estimateTokensForMessages(messages: readonly Message[]): number {
   let total = 0;
   for (const message of messages) {
     total += estimateTokensForMessage(message);
diff --git a/packages/agent-core/test/agent/compaction.test.ts b/packages/agent-core/test/agent/compaction.test.ts
index 0df8cba7..fc64cfcd 100644
--- a/packages/agent-core/test/agent/compaction.test.ts
+++ b/packages/agent-core/test/agent/compaction.test.ts
@@ -73,6 +73,48 @@ describe('Agent compaction', () => {
     expect(strategy.computeCompactCount(messages)).toBe(2);
   });
 
+  it('returns 0 when there is nothing to compact', () => {
+    const strategy = testCompactionStrategy();
+    expect(strategy.computeCompactCount([])).toBe(0);
+    expect(strategy.computeCompactCount([textMessage('user', 'only pending')])).toBe(0);
+    expect(
+      strategy.computeCompactCount([
+        textMessage('user', 'a'),
+        textMessage('user', 'b'),
+        textMessage('user', 'c'),
+      ]),
+    ).toBe(0);
+  });
+
+  it('falls back to compacting everything when no intermediate split exists but the last message is splittable', () => {
+    const strategy = testCompactionStrategy();
+    const messages: Message[] = [
+      textMessage('user', 'inspect'),
+      {
+        role: 'assistant',
+        content: [],
+        toolCalls: [{ type: 'function', id: 'call_a', name: 'Lookup', arguments: '{}' }],
+      },
+      { role: 'tool', content: [{ type: 'text', text: 'result' }], toolCalls: [], toolCallId: 'call_a' },
+    ];
+
+    expect(strategy.computeCompactCount(messages)).toBe(messages.length);
+  });
+
+  it('returns 0 when no intermediate split exists and the last message is also unsplittable', () => {
+    const strategy = testCompactionStrategy();
+    const messages: Message[] = [
+      textMessage('user', 'inspect'),
+      {
+        role: 'assistant',
+        content: [],
+        toolCalls: [{ type: 'function', id: 'call_a', name: 'Lookup', arguments: '{}' }],
+      },
+    ];
+
+    expect(strategy.computeCompactCount(messages)).toBe(0);
+  });
+
   it('reserves response context by default before the ratio threshold is reached', () => {
     const strategy = new DefaultCompactionStrategy(() => 256_000);
 
@@ -125,9 +167,9 @@ describe('Agent compaction', () => {
       [emit] compaction.started         { "trigger": "manual", "instruction": "Keep the important test facts." }
       [wire] usage.record               { "model": "kimi-code", "usage": { "inputOther": 468, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "session", "time": "<time>" }
       [emit] agent.status.updated       { "model": "kimi-code", "contextTokens": 120, "maxContextTokens": 256000, "contextUsage": 0.00046875, "planMode": false, "permission": "manual", "usage": { "byModel": { "kimi-code": { "inputOther": 468, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 468, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
-      [wire] full_compaction.complete   { "summary": "Compacted summary.", "compactedCount": 2, "tokensBefore": 120, "tokensAfter": 32, "time": "<time>" }
-      [emit] compaction.completed       { "result": { "summary": "Compacted summary.", "compactedCount": 2, "tokensBefore": 120, "tokensAfter": 32 } }
-      [wire] context.apply_compaction   { "summary": "Compacted summary.", "compactedCount": 2, "tokensBefore": 120, "tokensAfter": 32, "time": "<time>" }
+      [wire] full_compaction.complete   { "summary": "Compacted summary.", "compactedCount": 2, "tokensBefore": 39, "tokensAfter": 32, "time": "<time>" }
+      [emit] compaction.completed       { "result": { "summary": "Compacted summary.", "compactedCount": 2, "tokensBefore": 39, "tokensAfter": 32 } }
+      [wire] context.apply_compaction   { "summary": "Compacted summary.", "compactedCount": 2, "tokensBefore": 39, "tokensAfter": 32, "time": "<time>" }
       [emit] agent.status.updated       { "model": "kimi-code", "contextTokens": 32, "maxContextTokens": 256000, "contextUsage": 0.000125, "planMode": false, "permission": "manual", "usage": { "byModel": { "kimi-code": { "inputOther": 468, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 468, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
     `);
     expect(ctx.lastLlmInput()).toMatchInlineSnapshot(`
@@ -195,7 +237,7 @@ describe('Agent compaction', () => {
       event: 'compaction_finished',
       properties: {
         trigger_type: 'manual-with-prompt',
-        before_tokens: 120,
+        before_tokens: 39,
         after_tokens: 32,
         duration_ms: expect.any(Number),
         compacted_count: 2,
@@ -353,7 +395,7 @@ describe('Agent compaction', () => {
       session_id: 'session-hooks',
       cwd: dir,
       trigger: 'auto',
-      token_count: 120,
+      token_count: 39,
     });
     expect(post).toMatchObject({
       hook_event_name: 'PostCompact',
@@ -434,7 +476,7 @@ describe('Agent compaction', () => {
       event: 'compaction_finished',
       properties: expect.objectContaining({
         trigger_type: 'manual',
-        before_tokens: 80,
+        before_tokens: 25,
         retry_count: 1,
       }),
     });
@@ -584,7 +626,7 @@ describe('Agent compaction', () => {
       event: 'compaction_failed',
       properties: {
         trigger_type: 'manual',
-        before_tokens: 80,
+        before_tokens: 25,
         duration_ms: expect.any(Number),
         retry_count: 0,
         error_type: 'Error',
@@ -622,7 +664,7 @@ describe('Agent compaction', () => {
       event: 'compaction_failed',
       properties: {
         trigger_type: 'manual',
-        before_tokens: 80,
+        before_tokens: 25,
         duration_ms: expect.any(Number),
         retry_count: 4,
         error_type: 'APIConnectionError',
@@ -733,9 +775,9 @@ describe('Agent compaction', () => {
       [wire] context.append_message     { "message": { "role": "user", "content": [ { "type": "text", "text": "new user while compacting" } ], "toolCalls": [], "origin": { "kind": "user" } }, "time": "<time>" }
       [wire] usage.record               { "model": "kimi-code", "usage": { "inputOther": 460, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "session", "time": "<time>" }
       [emit] agent.status.updated       { "model": "kimi-code", "contextTokens": 80, "maxContextTokens": 256000, "contextUsage": 0.0003125, "planMode": false, "permission": "manual", "usage": { "byModel": { "kimi-code": { "inputOther": 460, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 460, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
-      [wire] full_compaction.complete   { "summary": "Compacted prefix.", "compactedCount": 2, "tokensBefore": 80, "tokensAfter": 18, "time": "<time>" }
-      [emit] compaction.completed       { "result": { "summary": "Compacted prefix.", "compactedCount": 2, "tokensBefore": 80, "tokensAfter": 18 } }
-      [wire] context.apply_compaction   { "summary": "Compacted prefix.", "compactedCount": 2, "tokensBefore": 80, "tokensAfter": 18, "time": "<time>" }
+      [wire] full_compaction.complete   { "summary": "Compacted prefix.", "compactedCount": 2, "tokensBefore": 25, "tokensAfter": 18, "time": "<time>" }
+      [emit] compaction.completed       { "result": { "summary": "Compacted prefix.", "compactedCount": 2, "tokensBefore": 25, "tokensAfter": 18 } }
+      [wire] context.apply_compaction   { "summary": "Compacted prefix.", "compactedCount": 2, "tokensBefore": 25, "tokensAfter": 18, "time": "<time>" }
       [emit] agent.status.updated       { "model": "kimi-code", "contextTokens": 18, "maxContextTokens": 256000, "contextUsage": 0.0000703125, "planMode": false, "permission": "manual", "usage": { "byModel": { "kimi-code": { "inputOther": 460, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 460, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
     `);
     expect(ctx.lastLlmInput()).toMatchInlineSnapshot(`
@@ -835,9 +877,9 @@ describe('Agent compaction', () => {
       [emit] compaction.blocked          { "turnId": 0 }
       [wire] usage.record                { "model": "kimi-code", "usage": { "inputOther": 472, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "session", "time": "<time>" }
       [emit] agent.status.updated        { "model": "kimi-code", "contextTokens": 950000, "maxContextTokens": 256000, "contextUsage": 3.7109375, "planMode": false, "permission": "manual", "usage": { "byModel": { "kimi-code": { "inputOther": 472, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 472, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
-      [wire] full_compaction.complete    { "summary": "Auto compacted summary.", "compactedCount": 4, "tokensBefore": 950000, "tokensAfter": 28, "time": "<time>" }
-      [emit] compaction.completed        { "result": { "summary": "Auto compacted summary.", "compactedCount": 4, "tokensBefore": 950000, "tokensAfter": 28 } }
-      [wire] context.apply_compaction    { "summary": "Auto compacted summary.", "compactedCount": 4, "tokensBefore": 950000, "tokensAfter": 28, "time": "<time>" }
+      [wire] full_compaction.complete    { "summary": "Auto compacted summary.", "compactedCount": 4, "tokensBefore": 46, "tokensAfter": 28, "time": "<time>" }
+      [emit] compaction.completed        { "result": { "summary": "Auto compacted summary.", "compactedCount": 4, "tokensBefore": 46, "tokensAfter": 28 } }
+      [wire] context.apply_compaction    { "summary": "Auto compacted summary.", "compactedCount": 4, "tokensBefore": 46, "tokensAfter": 28, "time": "<time>" }
       [emit] agent.status.updated        { "model": "kimi-code", "contextTokens": 28, "maxContextTokens": 256000, "contextUsage": 0.000109375, "planMode": false, "permission": "manual", "usage": { "byModel": { "kimi-code": { "inputOther": 472, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 472, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
       [wire] context.append_loop_event   { "event": { "type": "step.begin", "uuid": "<uuid-1>", "turnId": "0", "step": 1 }, "time": "<time>" }
       [emit] turn.step.started           { "turnId": 0, "step": 1, "stepId": "<uuid-1>" }
@@ -871,7 +913,7 @@ describe('Agent compaction', () => {
       event: 'compaction_finished',
       properties: expect.objectContaining({
         trigger_type: 'auto',
-        before_tokens: 950000,
+        before_tokens: 46,
         after_tokens: 28,
         compacted_count: 4,
         retry_count: 0,
@@ -1276,9 +1318,9 @@ describe('Agent compaction', () => {
       [emit] compaction.blocked          { "turnId": 0 }
       [wire] usage.record                { "model": "mock-model", "usage": { "inputOther": 456, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "session", "time": "<time>" }
       [emit] agent.status.updated        { "model": "mock-model", "contextTokens": 0, "maxContextTokens": 1000000, "contextUsage": 0, "planMode": false, "permission": "manual", "usage": { "byModel": { "mock-model": { "inputOther": 456, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 456, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
-      [wire] full_compaction.complete    { "summary": "First compacted summary.", "compactedCount": 1, "tokensBefore": 0, "tokensAfter": 6, "time": "<time>" }
-      [emit] compaction.completed        { "result": { "summary": "First compacted summary.", "compactedCount": 1, "tokensBefore": 0, "tokensAfter": 6 } }
-      [wire] context.apply_compaction    { "summary": "First compacted summary.", "compactedCount": 1, "tokensBefore": 0, "tokensAfter": 6, "time": "<time>" }
+      [wire] full_compaction.complete    { "summary": "First compacted summary.", "compactedCount": 1, "tokensBefore": 8, "tokensAfter": 6, "time": "<time>" }
+      [emit] compaction.completed        { "result": { "summary": "First compacted summary.", "compactedCount": 1, "tokensBefore": 8, "tokensAfter": 6 } }
+      [wire] context.apply_compaction    { "summary": "First compacted summary.", "compactedCount": 1, "tokensBefore": 8, "tokensAfter": 6, "time": "<time>" }
       [emit] agent.status.updated        { "model": "mock-model", "contextTokens": 6, "maxContextTokens": 1000000, "contextUsage": 0.000006, "planMode": false, "permission": "manual", "usage": { "byModel": { "mock-model": { "inputOther": 456, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 456, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
       [wire] context.append_loop_event   { "event": { "type": "step.begin", "uuid": "<uuid-1>", "turnId": "0", "step": 1 }, "time": "<time>" }
       [emit] turn.step.started           { "turnId": 0, "step": 1, "stepId": "<uuid-1>" }
diff --git a/packages/agent-core/test/agent/context.test.ts b/packages/agent-core/test/agent/context.test.ts
index fc89ba78..ad49e7a3 100644
--- a/packages/agent-core/test/agent/context.test.ts
+++ b/packages/agent-core/test/agent/context.test.ts
@@ -408,7 +408,7 @@ describe('Agent context', () => {
 
     const pendingMessages = ctx.agent.context.history.slice(-1);
     expect(ctx.agent.context.tokenCountWithPending).toBe(
-      ctx.agent.context.tokenCount + estimateTokensForMessages([...pendingMessages]),
+      ctx.agent.context.tokenCount + estimateTokensForMessages(pendingMessages),
     );
   });
 
@@ -463,7 +463,7 @@ describe('Agent context', () => {
     const pendingMessages = ctx.agent.context.history.slice(-1);
     expect(ctx.agent.context.tokenCount).toBe(1_280);
     expect(ctx.agent.context.tokenCountWithPending).toBe(
-      1_280 + estimateTokensForMessages([...pendingMessages]),
+      1_280 + estimateTokensForMessages(pendingMessages),
     );
   });
 

From 34b4691435524057fddab16d5f985a62bebaf66d Mon Sep 17 00:00:00 2001
From: _Kerman <kermanx@qq.com>
Date: Wed, 27 May 2026 20:15:27 +0800
Subject: [PATCH 07/15] fix

---
 packages/agent-core/src/agent/compaction/full.ts | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/packages/agent-core/src/agent/compaction/full.ts b/packages/agent-core/src/agent/compaction/full.ts
index 032dc96e..94b7cf26 100644
--- a/packages/agent-core/src/agent/compaction/full.ts
+++ b/packages/agent-core/src/agent/compaction/full.ts
@@ -8,7 +8,6 @@ import {
 import {
   APIEmptyResponseError,
   isRetryableGenerateError,
-  inputTotal,
   type GenerateResult,
   type Message,
   type TokenUsage,
@@ -134,7 +133,7 @@ export class FullCompaction {
 
   complete(
     result: CompactionResult,
-    llmUsage?: TokenUsage | undefined,
+    llmUsage: TokenUsage | null,
     retryCount: number = 0,
   ): void {
     this.agent.records.logRecord({
@@ -156,11 +155,8 @@ export class FullCompaction {
         duration_ms: Date.now() - active.startedAt,
         compacted_count: result.compactedCount,
         retry_count: retryCount,
+        ...llmUsage,
       };
-      if (llmUsage !== undefined) {
-        properties['llm_input_tokens'] = inputTotal(llmUsage);
-        properties['llm_output_tokens'] = llmUsage.output;
-      }
       this.agent.telemetry.track('compaction_finished', properties);
     }
   }
@@ -315,7 +311,7 @@ export class FullCompaction {
         tokensAfter,
       };
 
-      this.complete(result, response.usage ?? undefined, retryCount);
+      this.complete(result, response.usage, retryCount);
       this.agent.context.applyCompaction(result);
       this.triggerPostCompactHook(data, result);
     } catch (error) {

From d0d49ce4048f3aa02563b118d8ef5ad766486657 Mon Sep 17 00:00:00 2001
From: _Kerman <kermanx@qq.com>
Date: Wed, 27 May 2026 21:13:47 +0800
Subject: [PATCH 08/15] fix

---
 .../agent-core/test/agent/compaction.test.ts  | 130 +++++++++++++++++-
 1 file changed, 128 insertions(+), 2 deletions(-)

diff --git a/packages/agent-core/test/agent/compaction.test.ts b/packages/agent-core/test/agent/compaction.test.ts
index fc64cfcd..26b4f29c 100644
--- a/packages/agent-core/test/agent/compaction.test.ts
+++ b/packages/agent-core/test/agent/compaction.test.ts
@@ -242,8 +242,10 @@ describe('Agent compaction', () => {
         duration_ms: expect.any(Number),
         compacted_count: 2,
         retry_count: 0,
-        llm_input_tokens: 468,
-        llm_output_tokens: 8,
+        inputOther: 468,
+        output: 8,
+        inputCacheRead: 0,
+        inputCacheCreation: 0,
       },
     });
     await ctx.expectResumeMatches();
@@ -922,6 +924,130 @@ describe('Agent compaction', () => {
     await ctx.expectResumeMatches();
   });
 
+  it('keeps a deferred system reminder behind an unresolved tool exchange across compaction', async () => {
+    const ctx = testAgent();
+    ctx.configure({
+      provider: CATALOGUED_PROVIDER,
+      modelCapabilities: CATALOGUED_MODEL_CAPABILITIES,
+    });
+    ctx.appendExchange(1, 'old user one', 'old assistant one', 20);
+    ctx.appendUnresolvedToolExchange(0);
+    ctx.agent.context.appendSystemReminder('host note', {
+      kind: 'injection',
+      variant: 'host',
+    });
+
+    // Tool exchange is open, so the reminder is deferred — not yet in history.
+    expect(ctx.agent.context.history.map((m) => m.role)).toEqual([
+      'user',
+      'assistant',
+      'user',
+      'assistant',
+    ]);
+
+    const compacted = ctx.once('context.apply_compaction');
+    ctx.mockNextResponse({ type: 'text', text: 'Compacted with open tools.' });
+    await ctx.rpc.beginCompaction({});
+    await compacted;
+
+    // Compaction preserves the in-flight tool exchange in recent; the deferred
+    // reminder still cannot land because the tool exchange is still open.
+    expect(ctx.agent.context.history.map((m) => m.role)).toEqual([
+      'assistant',
+      'user',
+      'assistant',
+    ]);
+
+    // Closing the exchange flushes the deferred reminder to history.
+    ctx.dispatch({
+      type: 'context.append_loop_event',
+      event: {
+        type: 'tool.result',
+        parentUuid: 'call_unresolved_one',
+        toolCallId: 'call_unresolved_one',
+        result: { output: 'one result' },
+      },
+    });
+    ctx.dispatch({
+      type: 'context.append_loop_event',
+      event: {
+        type: 'tool.result',
+        parentUuid: 'call_unresolved_two',
+        toolCallId: 'call_unresolved_two',
+        result: { output: 'two result' },
+      },
+    });
+
+    expect(ctx.agent.context.history.map((m) => m.role)).toEqual([
+      'assistant',
+      'user',
+      'assistant',
+      'tool',
+      'tool',
+      'user',
+    ]);
+    expect(ctx.agent.context.history.at(-1)?.content).toEqual([
+      { type: 'text', text: '<system-reminder>\nhost note\n</system-reminder>' },
+    ]);
+  });
+
+  it('keeps a deferred system reminder behind a partially resolved tool exchange across compaction', async () => {
+    const ctx = testAgent();
+    ctx.configure({
+      provider: CATALOGUED_PROVIDER,
+      modelCapabilities: CATALOGUED_MODEL_CAPABILITIES,
+    });
+    ctx.appendExchange(1, 'old user one', 'old assistant one', 20);
+    ctx.appendUnresolvedToolExchange(1);
+    ctx.agent.context.appendSystemReminder('host note', {
+      kind: 'injection',
+      variant: 'host',
+    });
+
+    // One tool result has landed but the second is still pending — reminder defers.
+    expect(ctx.agent.context.history.map((m) => m.role)).toEqual([
+      'user',
+      'assistant',
+      'user',
+      'assistant',
+      'tool',
+    ]);
+
+    const compacted = ctx.once('context.apply_compaction');
+    ctx.mockNextResponse({ type: 'text', text: 'Compacted with partial tools.' });
+    await ctx.rpc.beginCompaction({});
+    await compacted;
+
+    expect(ctx.agent.context.history.map((m) => m.role)).toEqual([
+      'assistant',
+      'user',
+      'assistant',
+      'tool',
+    ]);
+
+    ctx.dispatch({
+      type: 'context.append_loop_event',
+      event: {
+        type: 'tool.result',
+        parentUuid: 'call_unresolved_two',
+        toolCallId: 'call_unresolved_two',
+        result: { output: 'two result' },
+      },
+    });
+
+    expect(ctx.agent.context.history.map((m) => m.role)).toEqual([
+      'assistant',
+      'user',
+      'assistant',
+      'tool',
+      'tool',
+      'user',
+    ]);
+    expect(ctx.agent.context.history.at(-1)?.content).toEqual([
+      { type: 'text', text: '<system-reminder>\nhost note\n</system-reminder>' },
+    ]);
+  });
+
   it('fails the turn with compaction.unable when auto compaction has no compactable prefix', async () => {
     const ctx = testAgent();
     ctx.configure({

From 4937f7f5008eaf880989e974af59917511695c94 Mon Sep 17 00:00:00 2001
From: _Kerman <kermanx@qq.com>
Date: Wed, 27 May 2026 21:16:21 +0800
Subject: [PATCH 09/15] fix

---
 packages/agent-core/test/agent/compaction.test.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/agent-core/test/agent/compaction.test.ts b/packages/agent-core/test/agent/compaction.test.ts
index 26b4f29c..3a970e37 100644
--- a/packages/agent-core/test/agent/compaction.test.ts
+++ b/packages/agent-core/test/agent/compaction.test.ts
@@ -1300,7 +1300,7 @@ describe('Agent compaction', () => {
 
   it('compacts provider overflow when model context size is unknown', async () => {
     let callCount = 0;
-    const generate: GenerateFn = async (_provider, _system, _tools, history, callbacks) => {
+    const generate: GenerateFn = async (_provider, _system, _tools, _history, callbacks) => {
       callCount += 1;
       if (callCount === 1) {
         throw new APIContextOverflowError(400, 'Context length exceeded', 'req-unknown-context');
@@ -1364,7 +1364,7 @@ describe('Agent compaction', () => {
 
   it('ignores filtered assistant placeholders when checking the retained overflow suffix', async () => {
     let callCount = 0;
-    const generate: GenerateFn = async (_provider, _system, _tools, history, callbacks) => {
+    const generate: GenerateFn = async (_provider, _system, _tools, _history, callbacks) => {
       callCount += 1;
       if (callCount === 1) {
         throw new APIContextOverflowError(

From b112bebb31b5ccd9b332106bac4698ecbf9ef511 Mon Sep 17 00:00:00 2001
From: _Kerman <kermanx@qq.com>
Date: Wed, 27 May 2026 21:50:15 +0800
Subject: [PATCH 10/15] fix

---
 .../agent-core/src/agent/compaction/full.ts   | 19 ++++++++++++-------
 .../agent-core/src/agent/records/index.ts     |  2 +-
 2 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/packages/agent-core/src/agent/compaction/full.ts b/packages/agent-core/src/agent/compaction/full.ts
index 94b7cf26..d0d4a979 100644
--- a/packages/agent-core/src/agent/compaction/full.ts
+++ b/packages/agent-core/src/agent/compaction/full.ts
@@ -245,7 +245,7 @@ export class FullCompaction {
       const model = this.agent.config.model;
 
       const delays = retryBackoffDelays(MAX_COMPACTION_RETRY_ATTEMPTS);
-      let response: GenerateResult;
+      let usage: TokenUsage | null;
       let summary: string;
       while (true) {
         const messagesToCompact = originalHistory.slice(0, compactedCount);
@@ -262,8 +262,9 @@ export class FullCompaction {
             toolCalls: [],
           } satisfies Message,
         ];
+        class TruncatedError extends Error {}
         try {
-          response = await this.agent.generate(
+          const response = await this.agent.generate(
             this.agent.config.provider,
             this.agent.config.systemPrompt,
             [...this.agent.tools.loopTools],
@@ -271,13 +272,17 @@ export class FullCompaction {
             undefined,
             { signal },
           );
+          if (response.finishReason === 'truncated') {
+            throw new TruncatedError();
+          }
+          usage = response.usage;
           summary = extractCompactionSummary(response);
           break;
         } catch (error) {
-          if (error instanceof APIContextOverflowError) {
+          if (error instanceof APIContextOverflowError || error instanceof TruncatedError) {
             compactedCount = this.strategy.reduceCompactOnOverflow(messagesToCompact);
           }
-          if (!isRetryableGenerateError(error)) {
+          else if (!isRetryableGenerateError(error)) {
             throw error;
           }
           if (retryCount + 1 >= MAX_COMPACTION_RETRY_ATTEMPTS) {
@@ -288,8 +293,8 @@ export class FullCompaction {
         }
       }
 
-      if (response.usage !== null) {
-        this.agent.usage.record(model, response.usage);
+      if (usage !== null) {
+        this.agent.usage.record(model, usage);
       }
 
       const newHistory = this.agent.context.history;
@@ -311,7 +316,7 @@ export class FullCompaction {
         tokensAfter,
       };
 
-      this.complete(result, response.usage, retryCount);
+      this.complete(result, usage, retryCount);
       this.agent.context.applyCompaction(result);
       this.triggerPostCompactHook(data, result);
     } catch (error) {
diff --git a/packages/agent-core/src/agent/records/index.ts b/packages/agent-core/src/agent/records/index.ts
index 2e4ede74..dccd9072 100644
--- a/packages/agent-core/src/agent/records/index.ts
+++ b/packages/agent-core/src/agent/records/index.ts
@@ -54,7 +54,7 @@ function restoreAgentRecord(agent: Agent, input: AgentRecord): void {
       agent.fullCompaction.cancel();
       return;
     case 'full_compaction.complete':
-      agent.fullCompaction.complete(input);
+      agent.fullCompaction.complete(input, null);
       return;
     case 'plan_mode.enter':
       agent.planMode.restoreEnter(input);

From 5f6e8b7f31484900ec793a76562d679563e78c43 Mon Sep 17 00:00:00 2001
From: _Kerman <kermanx@qq.com>
Date: Wed, 27 May 2026 23:38:11 +0800
Subject: [PATCH 11/15] fix

---
 .../agent-core/src/agent/compaction/full.ts   |  7 +++--
 .../src/agent/compaction/strategy.ts          |  5 +---
 .../agent-core/test/agent/compaction.test.ts  | 28 ++++++++-----------
 3 files changed, 16 insertions(+), 24 deletions(-)

diff --git a/packages/agent-core/src/agent/compaction/full.ts b/packages/agent-core/src/agent/compaction/full.ts
index d0d4a979..359a560e 100644
--- a/packages/agent-core/src/agent/compaction/full.ts
+++ b/packages/agent-core/src/agent/compaction/full.ts
@@ -84,6 +84,9 @@ export class FullCompaction {
       this.compactionCountInTurn += 1;
     }
     if (this.compactionCountInTurn > this.strategy.maxCompactionPerTurn) return;
+    if (this.agent.records.restoring) {
+      return;
+    }
     const compactedCount = this.strategy.computeCompactCount(this.agent.context.history);
     if (compactedCount === 0) {
       throw new KimiError(ErrorCodes.COMPACTION_UNABLE, 'No prefix that can be compacted in current history.');
@@ -92,9 +95,7 @@ export class FullCompaction {
       type: 'full_compaction.begin',
       ...data,
     });
-    if (!this.agent.records.restoring) {
-      this.startCompactionWorker(data, compactedCount);
-    }
+    this.startCompactionWorker(data, compactedCount);
   }
 
   private startCompactionWorker(
diff --git a/packages/agent-core/src/agent/compaction/strategy.ts b/packages/agent-core/src/agent/compaction/strategy.ts
index 8b5cb63f..deca62b2 100644
--- a/packages/agent-core/src/agent/compaction/strategy.ts
+++ b/packages/agent-core/src/agent/compaction/strategy.ts
@@ -100,10 +100,7 @@ export class DefaultCompactionStrategy implements CompactionStrategy {
       }
     }
 
-    if (bestN !== undefined) return bestN;
-    const last = messages.at(-1);
-    if (last && !cannotSplitAfter(last)) return messages.length;
-    return 0;
+    return bestN ?? 0;
   }
 
   reduceCompactOnOverflow(messages: readonly Message[]): number {
diff --git a/packages/agent-core/test/agent/compaction.test.ts b/packages/agent-core/test/agent/compaction.test.ts
index 3a970e37..7252f8db 100644
--- a/packages/agent-core/test/agent/compaction.test.ts
+++ b/packages/agent-core/test/agent/compaction.test.ts
@@ -86,21 +86,6 @@ describe('Agent compaction', () => {
     ).toBe(0);
   });
 
-  it('falls back to compacting everything when no intermediate split exists but the last message is splittable', () => {
-    const strategy = testCompactionStrategy();
-    const messages: Message[] = [
-      textMessage('user', 'inspect'),
-      {
-        role: 'assistant',
-        content: [],
-        toolCalls: [{ type: 'function', id: 'call_a', name: 'Lookup', arguments: '{}' }],
-      },
-      { role: 'tool', content: [{ type: 'text', text: 'result' }], toolCalls: [], toolCallId: 'call_a' },
-    ];
-
-    expect(strategy.computeCompactCount(messages)).toBe(messages.length);
-  });
-
   it('returns 0 when no intermediate split exists and the last message is also unsplittable', () => {
     const strategy = testCompactionStrategy();
     const messages: Message[] = [
@@ -681,6 +666,7 @@ describe('Agent compaction', () => {
       provider: CATALOGUED_PROVIDER,
       modelCapabilities: CATALOGUED_MODEL_CAPABILITIES,
     });
+    ctx.appendExchange(1, 'old user one', 'old assistant one', 20);
     ctx.appendRichToolExchange();
     const compacted = new Promise<void>((resolve) => {
       ctx.emitter.once('context.apply_compaction', () => {
@@ -696,11 +682,19 @@ describe('Agent compaction', () => {
       [
         {
           "text": "--- message 1 role=user ---
+      text:
+        old user one
+
+      --- message 2 role=assistant ---
+      text:
+        old assistant one
+
+      --- message 3 role=user ---
       text:
         inspect this image
       image_url: ms://image-1 (id=image-1)
 
-      --- message 2 role=assistant ---
+      --- message 4 role=assistant ---
       think:
         checking metadata
       text:
@@ -713,7 +707,7 @@ describe('Agent compaction', () => {
           "limit": 2
         }
 
-      --- message 3 role=tool toolCallId="call_lookup" ---
+      --- message 5 role=tool toolCallId="call_lookup" ---
       text:
         lookup result
       video_url: ms://video-1 (id=video-1)",

From 74eaf747af96cb66e52d683ada200376f7493ec1 Mon Sep 17 00:00:00 2001
From: _Kerman <kermanx@qq.com>
Date: Thu, 28 May 2026 00:12:30 +0800
Subject: [PATCH 12/15] fix

---
 .../src/agent/compaction/strategy.ts          | 34 +++++++++++++++----
 .../agent-core/test/agent/compaction.test.ts  | 24 +++++++++++++
 2 files changed, 51 insertions(+), 7 deletions(-)

diff --git a/packages/agent-core/src/agent/compaction/strategy.ts b/packages/agent-core/src/agent/compaction/strategy.ts
index deca62b2..eb74238b 100644
--- a/packages/agent-core/src/agent/compaction/strategy.ts
+++ b/packages/agent-core/src/agent/compaction/strategy.ts
@@ -67,7 +67,9 @@ export class DefaultCompactionStrategy implements CompactionStrategy {
     // Preserved recent messages: messages.slice(N)
     //
     // Rules (in order of precedence):
-    // 1. messages[N-1] must not be a user message or assistant message with tool calls
+    // 1. The split after messages[N-1] must be safe per `canSplitAfter`:
+    //    messages[N-1] is not a user or asst-with-tool-calls, and the retained
+    //    suffix messages.slice(N) has no orphan tool result.
     // 2. At least one recent message must be preserved
     // 3. At most maxRecentMessages recent messages should be preserved
     // 4. At most maxRecentUserMessages recent user messages should be preserved
@@ -80,7 +82,7 @@ export class DefaultCompactionStrategy implements CompactionStrategy {
     let bestN: number | undefined;
 
     for (; recentMessages < messages.length; recentMessages++) {
-      const m1 = messages[messages.length - recentMessages - 1]!;
+      const splitIndex = messages.length - recentMessages - 1;
       const m2 = messages[messages.length - recentMessages]!;
 
       if (m2.role === 'user') {
@@ -88,8 +90,8 @@ export class DefaultCompactionStrategy implements CompactionStrategy {
       }
       recentSize += estimateTokensForMessage(m2);
 
-      if (!cannotSplitAfter(m1)) {
-        bestN = messages.length - recentMessages;
+      if (canSplitAfter(messages, splitIndex)) {
+        bestN = splitIndex + 1;
       }
 
       const reachesMax = recentMessages >= this.config.maxRecentMessages
@@ -105,7 +107,7 @@ export class DefaultCompactionStrategy implements CompactionStrategy {
 
   reduceCompactOnOverflow(messages: readonly Message[]): number {
     for (let i = messages.length - 2; i > 0; i--) {
-      if (!cannotSplitAfter(messages[i]!)) {
+      if (canSplitAfter(messages, i)) {
         return i + 1;
       }
     }
@@ -121,6 +123,24 @@ export class DefaultCompactionStrategy implements CompactionStrategy {
   }
 }
 
-function cannotSplitAfter(message: Message): boolean {
-  return message.role === 'user' || (message.role === 'assistant' && message.toolCalls.length > 0);
+/**
+ * Decide whether a compaction split is safe to place immediately after
+ * `messages[index]`. A split is safe only when:
+ *   - `messages[index]` itself is not a user message or an assistant message
+ *     with pending tool calls (cutting either of those off from what follows
+ *     would break the conversation), AND
+ *   - the next message is not a tool result. The history is well-formed:
+ *     tool results only appear after their owning `asst_w_tc` and all tool
+ *     results for one exchange land consecutively before the next non-tool
+ *     message. So if the suffix starts with a tool result, its `asst_w_tc`
+ *     must be in the compacted prefix, which would orphan that result
+ *     (e.g. splitting between tool_a and tool_b of a parallel call).
+ */
+function canSplitAfter(messages: readonly Message[], index: number): boolean {
+  const m = messages[index];
+  if (m === undefined) return false;
+  if (m.role === 'user') return false;
+  if (m.role === 'assistant' && m.toolCalls.length > 0) return false;
+  if (messages[index + 1]?.role === 'tool') return false;
+  return true;
 }
diff --git a/packages/agent-core/test/agent/compaction.test.ts b/packages/agent-core/test/agent/compaction.test.ts
index 7252f8db..59fcae23 100644
--- a/packages/agent-core/test/agent/compaction.test.ts
+++ b/packages/agent-core/test/agent/compaction.test.ts
@@ -100,6 +100,30 @@ describe('Agent compaction', () => {
     expect(strategy.computeCompactCount(messages)).toBe(0);
   });
 
+  it('does not split inside a parallel tool exchange', () => {
+    const strategy = testCompactionStrategy();
+    const messages: Message[] = [
+      textMessage('user', 'old user'),
+      textMessage('assistant', 'old assistant'),
+      textMessage('user', 'run both tools'),
+      {
+        role: 'assistant',
+        content: [],
+        toolCalls: [
+          { type: 'function', id: 'call_a', name: 'Lookup', arguments: '{}' },
+          { type: 'function', id: 'call_b', name: 'Lookup', arguments: '{}' },
+        ],
+      },
+      { role: 'tool', content: [{ type: 'text', text: 'a' }], toolCalls: [], toolCallId: 'call_a' },
+      { role: 'tool', content: [{ type: 'text', text: 'b' }], toolCalls: [], toolCallId: 'call_b' },
+      textMessage('user', 'next prompt'),
+    ];
+
+    // The only valid split is before the parallel exchange (after 'old assistant'),
+    // never between tool_a and tool_b — that would leave tool_b as an orphan.
+    expect(strategy.computeCompactCount(messages)).toBe(2);
+  });
+
   it('reserves response context by default before the ratio threshold is reached', () => {
     const strategy = new DefaultCompactionStrategy(() => 256_000);
 

From 72758c30e2b9dcb16ed73864cc68312be76f1952 Mon Sep 17 00:00:00 2001
From: _Kerman <kermanx@qq.com>
Date: Thu, 28 May 2026 12:25:56 +0800
Subject: [PATCH 13/15] fix

---
 .../agent-core/src/agent/compaction/full.ts   | 40 +++++++------------
 .../src/agent/compaction/strategy.ts          | 19 +++++++--
 .../agent-core/src/agent/compaction/types.ts  |  4 +-
 .../agent-core/src/agent/records/index.ts     |  2 +-
 .../agent-core/src/agent/records/types.ts     |  2 +-
 5 files changed, 35 insertions(+), 32 deletions(-)

diff --git a/packages/agent-core/src/agent/compaction/full.ts b/packages/agent-core/src/agent/compaction/full.ts
index 359a560e..d3d008a4 100644
--- a/packages/agent-core/src/agent/compaction/full.ts
+++ b/packages/agent-core/src/agent/compaction/full.ts
@@ -20,7 +20,6 @@ import {
   retryBackoffDelays,
   sleepForRetry,
 } from '../../loop/retry';
-import type { TelemetryPropertyValue } from '../../telemetry';
 import { renderPrompt } from '../../utils/render-prompt';
 import {
   estimateTokens,
@@ -87,7 +86,7 @@ export class FullCompaction {
     if (this.agent.records.restoring) {
       return;
     }
-    const compactedCount = this.strategy.computeCompactCount(this.agent.context.history);
+    const compactedCount = this.strategy.computeCompactCount(this.agent.context.history, data.source);
     if (compactedCount === 0) {
       throw new KimiError(ErrorCodes.COMPACTION_UNABLE, 'No prefix that can be compacted in current history.');
     }
@@ -132,34 +131,14 @@ export class FullCompaction {
     this.agent.emitEvent({ type: 'compaction.cancelled' });
   }
 
-  complete(
-    result: CompactionResult,
-    llmUsage: TokenUsage | null,
-    retryCount: number = 0,
-  ): void {
+  markCompleted() {
     this.agent.records.logRecord({
       type: 'full_compaction.complete',
-      ...result,
     });
-    const active = this.compacting;
     this.compacting = null;
-    const history = this.agent.context.history;
     this._compactedHistory.push({
-      text: renderMessagesToText(history),
+      text: renderMessagesToText(this.agent.context.history),
     });
-    this.agent.emitEvent({ type: 'compaction.completed', result });
-    if (active !== null) {
-      const properties: Record<string, TelemetryPropertyValue> = {
-        trigger_type: active.telemetryTrigger,
-        before_tokens: result.tokensBefore,
-        after_tokens: result.tokensAfter,
-        duration_ms: Date.now() - active.startedAt,
-        compacted_count: result.compactedCount,
-        retry_count: retryCount,
-        ...llmUsage,
-      };
-      this.agent.telemetry.track('compaction_finished', properties);
-    }
   }
 
   private get tokenCountWithPending(): number {
@@ -317,7 +296,18 @@ export class FullCompaction {
         tokensAfter,
       };
 
-      this.complete(result, usage, retryCount);
+      const active = this.compacting!;
+      this.agent.telemetry.track('compaction_finished', {
+        trigger_type: active.telemetryTrigger,
+        before_tokens: result.tokensBefore,
+        after_tokens: result.tokensAfter,
+        duration_ms: Date.now() - active.startedAt,
+        compacted_count: result.compactedCount,
+        retry_count: retryCount,
+        ...usage,
+      });
+      this.markCompleted();
+      this.agent.emitEvent({ type: 'compaction.completed', result });
       this.agent.context.applyCompaction(result);
       this.triggerPostCompactHook(data, result);
     } catch (error) {
diff --git a/packages/agent-core/src/agent/compaction/strategy.ts b/packages/agent-core/src/agent/compaction/strategy.ts
index eb74238b..577a39dc 100644
--- a/packages/agent-core/src/agent/compaction/strategy.ts
+++ b/packages/agent-core/src/agent/compaction/strategy.ts
@@ -1,5 +1,6 @@
 import type { Message } from "@moonshot-ai/kosong";
 import { estimateTokensForMessage } from "../../utils/tokens";
+import type { CompactionSource } from "./types";
 
 export interface CompactionConfig {
   triggerRatio: number;
@@ -24,7 +25,7 @@ export const DEFAULT_COMPACTION_CONFIG: CompactionConfig = {
 export interface CompactionStrategy {
   shouldCompact(usedSize: number): boolean;
   shouldBlock(usedSize: number): boolean;
-  computeCompactCount(messages: readonly Message[]): number;
+  computeCompactCount(messages: readonly Message[], source: CompactionSource): number;
   reduceCompactOnOverflow(messages: readonly Message[]): number;
   readonly checkAfterStep: boolean;
   readonly maxCompactionPerTurn: number;
@@ -61,12 +62,22 @@ export class DefaultCompactionStrategy implements CompactionStrategy {
     return reservedSize > 0 && reservedSize < this.maxSize && usedSize + reservedSize >= this.maxSize;
   }
 
-  computeCompactCount(messages: readonly Message[]): number {
+  computeCompactCount(messages: readonly Message[], source: CompactionSource): number {
     // Return value: N messages to be compacted (0 means no compaction possible)
     // LLM Input: messages.slice(0, N) + [user:instruction]
     // Preserved recent messages: messages.slice(N)
-    //
-    // Rules (in order of precedence):
+
+    // Manual compaction
+    if (source === 'manual') {
+      for (let i = messages.length - 1; i > 0; i--) {
+        if (canSplitAfter(messages, i)) {
+          return i;
+        }
+      }
+      return 0;
+    }
+
+    // Auto compaction rules (in order of precedence):
     // 1. The split after messages[N-1] must be safe per `canSplitAfter`:
     //    messages[N-1] is not a user or asst-with-tool-calls, and the retained
     //    suffix messages.slice(N) has no orphan tool result.
diff --git a/packages/agent-core/src/agent/compaction/types.ts b/packages/agent-core/src/agent/compaction/types.ts
index 3936faef..820365cd 100644
--- a/packages/agent-core/src/agent/compaction/types.ts
+++ b/packages/agent-core/src/agent/compaction/types.ts
@@ -5,7 +5,9 @@ export interface CompactionResult {
   tokensAfter: number;
 }
 
+export type CompactionSource = 'manual' | 'auto';
+
 export interface CompactionBeginData {
   instruction?: string;
-  source: 'manual' | 'auto';
+  source: CompactionSource;
 }
diff --git a/packages/agent-core/src/agent/records/index.ts b/packages/agent-core/src/agent/records/index.ts
index dccd9072..fed074f6 100644
--- a/packages/agent-core/src/agent/records/index.ts
+++ b/packages/agent-core/src/agent/records/index.ts
@@ -54,7 +54,7 @@ function restoreAgentRecord(agent: Agent, input: AgentRecord): void {
       agent.fullCompaction.cancel();
       return;
     case 'full_compaction.complete':
-      agent.fullCompaction.complete(input, null);
+      agent.fullCompaction.markCompleted();
       return;
     case 'plan_mode.enter':
       agent.planMode.restoreEnter(input);
diff --git a/packages/agent-core/src/agent/records/types.ts b/packages/agent-core/src/agent/records/types.ts
index 3300bce5..88fbe6ef 100644
--- a/packages/agent-core/src/agent/records/types.ts
+++ b/packages/agent-core/src/agent/records/types.ts
@@ -63,7 +63,7 @@ export interface AgentRecordEvents {
   };
 
   'full_compaction.cancel': {};
-  'full_compaction.complete': CompactionResult;
+  'full_compaction.complete': {};
 
   'context.append_message': { message: ContextMessage };
   'context.mark_last_user_prompt_blocked': { hookEvent: string };

From 4cc1014dbee5d5e72bbbdd1388a13e91a39f8415 Mon Sep 17 00:00:00 2001
From: _Kerman <kermanx@qq.com>
Date: Thu, 28 May 2026 13:24:36 +0800
Subject: [PATCH 14/15] fix

---
 .../src/agent/compaction/strategy.ts          |   2 +-
 .../agent-core/test/agent/compaction.test.ts  | 121 +++++++-----------
 packages/agent-core/test/agent/resume.test.ts |   4 -
 3 files changed, 50 insertions(+), 77 deletions(-)

diff --git a/packages/agent-core/src/agent/compaction/strategy.ts b/packages/agent-core/src/agent/compaction/strategy.ts
index 577a39dc..98b3fd80 100644
--- a/packages/agent-core/src/agent/compaction/strategy.ts
+++ b/packages/agent-core/src/agent/compaction/strategy.ts
@@ -71,7 +71,7 @@ export class DefaultCompactionStrategy implements CompactionStrategy {
     if (source === 'manual') {
       for (let i = messages.length - 1; i > 0; i--) {
         if (canSplitAfter(messages, i)) {
-          return i;
+          return i + 1;
         }
       }
       return 0;
diff --git a/packages/agent-core/test/agent/compaction.test.ts b/packages/agent-core/test/agent/compaction.test.ts
index 59fcae23..020c58bb 100644
--- a/packages/agent-core/test/agent/compaction.test.ts
+++ b/packages/agent-core/test/agent/compaction.test.ts
@@ -46,7 +46,7 @@ describe('Agent compaction', () => {
       textMessage('user', `pending user ${'x'.repeat(1_200)}`),
     ];
 
-    expect(strategy.computeCompactCount(messages)).toBe(2);
+    expect(strategy.computeCompactCount(messages, 'auto')).toBe(2);
   });
 
   it('keeps consecutive trailing user messages as recent', () => {
@@ -58,7 +58,7 @@ describe('Agent compaction', () => {
       textMessage('user', `pending user two ${'x'.repeat(1_200)}`),
     ];
 
-    expect(strategy.computeCompactCount(messages)).toBe(2);
+    expect(strategy.computeCompactCount(messages, 'auto')).toBe(2);
   });
 
   it('compacts the prefix when the trailing exchange itself is oversized', () => {
@@ -70,19 +70,22 @@ describe('Agent compaction', () => {
       textMessage('assistant', `recent assistant ${'x'.repeat(1_200)}`),
     ];
 
-    expect(strategy.computeCompactCount(messages)).toBe(2);
+    expect(strategy.computeCompactCount(messages, 'auto')).toBe(2);
   });
 
   it('returns 0 when there is nothing to compact', () => {
     const strategy = testCompactionStrategy();
-    expect(strategy.computeCompactCount([])).toBe(0);
-    expect(strategy.computeCompactCount([textMessage('user', 'only pending')])).toBe(0);
+    expect(strategy.computeCompactCount([], 'auto')).toBe(0);
+    expect(strategy.computeCompactCount([textMessage('user', 'only pending')], 'auto')).toBe(0);
     expect(
-      strategy.computeCompactCount([
-        textMessage('user', 'a'),
-        textMessage('user', 'b'),
-        textMessage('user', 'c'),
-      ]),
+      strategy.computeCompactCount(
+        [
+          textMessage('user', 'a'),
+          textMessage('user', 'b'),
+          textMessage('user', 'c'),
+        ],
+        'auto',
+      ),
     ).toBe(0);
   });
 
@@ -97,7 +100,7 @@ describe('Agent compaction', () => {
       },
     ];
 
-    expect(strategy.computeCompactCount(messages)).toBe(0);
+    expect(strategy.computeCompactCount(messages, 'auto')).toBe(0);
   });
 
   it('does not split inside a parallel tool exchange', () => {
@@ -121,7 +124,7 @@ describe('Agent compaction', () => {
 
     // The only valid split is before the parallel exchange (after 'old assistant'),
     // never between tool_a and tool_b — that would leave tool_b as an orphan.
-    expect(strategy.computeCompactCount(messages)).toBe(2);
+    expect(strategy.computeCompactCount(messages, 'auto')).toBe(2);
   });
 
   it('reserves response context by default before the ratio threshold is reached', () => {
@@ -174,12 +177,12 @@ describe('Agent compaction', () => {
       [wire] context.append_message     { "message": { "role": "user", "content": [ { "type": "text", "text": "recent user three" } ], "toolCalls": [], "origin": { "kind": "user" } }, "time": "<time>" }
       [wire] full_compaction.begin      { "source": "manual", "instruction": "Keep the important test facts.", "time": "<time>" }
       [emit] compaction.started         { "trigger": "manual", "instruction": "Keep the important test facts." }
-      [wire] usage.record               { "model": "kimi-code", "usage": { "inputOther": 468, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "session", "time": "<time>" }
-      [emit] agent.status.updated       { "model": "kimi-code", "contextTokens": 120, "maxContextTokens": 256000, "contextUsage": 0.00046875, "planMode": false, "permission": "manual", "usage": { "byModel": { "kimi-code": { "inputOther": 468, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 468, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
-      [wire] full_compaction.complete   { "summary": "Compacted summary.", "compactedCount": 2, "tokensBefore": 39, "tokensAfter": 32, "time": "<time>" }
-      [emit] compaction.completed       { "result": { "summary": "Compacted summary.", "compactedCount": 2, "tokensBefore": 39, "tokensAfter": 32 } }
-      [wire] context.apply_compaction   { "summary": "Compacted summary.", "compactedCount": 2, "tokensBefore": 39, "tokensAfter": 32, "time": "<time>" }
-      [emit] agent.status.updated       { "model": "kimi-code", "contextTokens": 32, "maxContextTokens": 256000, "contextUsage": 0.000125, "planMode": false, "permission": "manual", "usage": { "byModel": { "kimi-code": { "inputOther": 468, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 468, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
+      [wire] usage.record               { "model": "kimi-code", "usage": { "inputOther": 495, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "session", "time": "<time>" }
+      [emit] agent.status.updated       { "model": "kimi-code", "contextTokens": 120, "maxContextTokens": 256000, "contextUsage": 0.00046875, "planMode": false, "permission": "manual", "usage": { "byModel": { "kimi-code": { "inputOther": 495, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 495, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
+      [wire] full_compaction.complete   { "time": "<time>" }
+      [emit] compaction.completed       { "result": { "summary": "Compacted summary.", "compactedCount": 6, "tokensBefore": 39, "tokensAfter": 5 } }
+      [wire] context.apply_compaction   { "summary": "Compacted summary.", "compactedCount": 6, "tokensBefore": 39, "tokensAfter": 5, "time": "<time>" }
+      [emit] agent.status.updated       { "model": "kimi-code", "contextTokens": 5, "maxContextTokens": 256000, "contextUsage": 0.00001953125, "planMode": false, "permission": "manual", "usage": { "byModel": { "kimi-code": { "inputOther": 495, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 495, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
     `);
     expect(ctx.lastLlmInput()).toMatchInlineSnapshot(`
       system: <system-prompt>
@@ -187,6 +190,10 @@ describe('Agent compaction', () => {
       messages:
         user: text "old user one"
         assistant: text "old assistant one"
+        user: text "old user two"
+        assistant: text "old assistant two"
+        user: text "recent user three"
+        assistant: text "recent assistant three"
         user: text <compaction-instruction>
     `);
     expect(ctx.compactHistory()).toMatchInlineSnapshot(`
@@ -195,22 +202,6 @@ describe('Agent compaction', () => {
           "role": "assistant",
           "text": "Compacted summary.",
         },
-        {
-          "role": "user",
-          "text": "old user two",
-        },
-        {
-          "role": "assistant",
-          "text": "old assistant two",
-        },
-        {
-          "role": "user",
-          "text": "recent user three",
-        },
-        {
-          "role": "assistant",
-          "text": "recent assistant three",
-        },
       ]
     `);
     expect(ctx.agent.fullCompaction.compactedHistory).toMatchInlineSnapshot(`
@@ -247,11 +238,11 @@ describe('Agent compaction', () => {
       properties: {
         trigger_type: 'manual-with-prompt',
         before_tokens: 39,
-        after_tokens: 32,
+        after_tokens: 5,
         duration_ms: expect.any(Number),
-        compacted_count: 2,
+        compacted_count: 6,
         retry_count: 0,
-        inputOther: 468,
+        inputOther: 495,
         output: 8,
         inputCacheRead: 0,
         inputCacheCreation: 0,
@@ -362,8 +353,6 @@ describe('Agent compaction', () => {
     expect(tokenCalls).toEqual([undefined, undefined, true, undefined]);
     expect(ctx.compactHistory()).toEqual([
       { role: 'assistant', text: 'Recovered compacted summary.' },
-      { role: 'user', text: 'recent user two' },
-      { role: 'assistant', text: 'recent assistant two' },
     ]);
     await ctx.expectResumeMatches();
   });
@@ -523,14 +512,14 @@ describe('Agent compaction', () => {
     expect(attempts).toBe(3);
     expect(ctx.compactHistory()).toEqual([
       { role: 'assistant', text: 'Recovered compacted summary.' },
-      { role: 'user', text: 'recent user two' },
-      { role: 'assistant', text: 'recent assistant two' },
     ]);
     expect(
-      ctx.allEvents.filter((event) => event.event === 'full_compaction.complete'),
+      ctx.allEvents.filter((event) => event.event === 'compaction.completed'),
     ).toEqual([
       expect.objectContaining({
-        args: expect.objectContaining({ summary: 'Recovered compacted summary.' }),
+        args: expect.objectContaining({
+          result: expect.objectContaining({ summary: 'Recovered compacted summary.' }),
+        }),
       }),
     ]);
     await ctx.expectResumeMatches();
@@ -761,13 +750,13 @@ describe('Agent compaction', () => {
       messages:
         user: text "old user one"
         assistant: text "old assistant one"
+        user: text "run both tools"
+        assistant: []  calls call_open_one:LookupOne { "query": "one" }, call_open_two:LookupTwo { "query": "two" }
+        tool[call_open_one]: text "one result"
         user: text <compaction-instruction>
     `);
     expect(ctx.agent.context.history.map((message) => message.role)).toEqual([
       'assistant',
-      'user',
-      'assistant',
-      'tool',
     ]);
     await ctx.expectResumeMatches();
   });
@@ -793,12 +782,12 @@ describe('Agent compaction', () => {
       [wire] full_compaction.begin      { "source": "manual", "time": "<time>" }
       [emit] compaction.started         { "trigger": "manual" }
       [wire] context.append_message     { "message": { "role": "user", "content": [ { "type": "text", "text": "new user while compacting" } ], "toolCalls": [], "origin": { "kind": "user" } }, "time": "<time>" }
-      [wire] usage.record               { "model": "kimi-code", "usage": { "inputOther": 460, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "session", "time": "<time>" }
-      [emit] agent.status.updated       { "model": "kimi-code", "contextTokens": 80, "maxContextTokens": 256000, "contextUsage": 0.0003125, "planMode": false, "permission": "manual", "usage": { "byModel": { "kimi-code": { "inputOther": 460, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 460, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
-      [wire] full_compaction.complete   { "summary": "Compacted prefix.", "compactedCount": 2, "tokensBefore": 25, "tokensAfter": 18, "time": "<time>" }
-      [emit] compaction.completed       { "result": { "summary": "Compacted prefix.", "compactedCount": 2, "tokensBefore": 25, "tokensAfter": 18 } }
-      [wire] context.apply_compaction   { "summary": "Compacted prefix.", "compactedCount": 2, "tokensBefore": 25, "tokensAfter": 18, "time": "<time>" }
-      [emit] agent.status.updated       { "model": "kimi-code", "contextTokens": 18, "maxContextTokens": 256000, "contextUsage": 0.0000703125, "planMode": false, "permission": "manual", "usage": { "byModel": { "kimi-code": { "inputOther": 460, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 460, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
+      [wire] usage.record               { "model": "kimi-code", "usage": { "inputOther": 473, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "session", "time": "<time>" }
+      [emit] agent.status.updated       { "model": "kimi-code", "contextTokens": 80, "maxContextTokens": 256000, "contextUsage": 0.0003125, "planMode": false, "permission": "manual", "usage": { "byModel": { "kimi-code": { "inputOther": 473, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 473, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
+      [wire] full_compaction.complete   { "time": "<time>" }
+      [emit] compaction.completed       { "result": { "summary": "Compacted prefix.", "compactedCount": 4, "tokensBefore": 25, "tokensAfter": 5 } }
+      [wire] context.apply_compaction   { "summary": "Compacted prefix.", "compactedCount": 4, "tokensBefore": 25, "tokensAfter": 5, "time": "<time>" }
+      [emit] agent.status.updated       { "model": "kimi-code", "contextTokens": 5, "maxContextTokens": 256000, "contextUsage": 0.00001953125, "planMode": false, "permission": "manual", "usage": { "byModel": { "kimi-code": { "inputOther": 473, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 473, "output": 8, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
     `);
     expect(ctx.lastLlmInput()).toMatchInlineSnapshot(`
       system: <system-prompt>
@@ -806,6 +795,8 @@ describe('Agent compaction', () => {
       messages:
         user: text "old user one"
         assistant: text "old assistant one"
+        user: text "recent user two"
+        assistant: text "recent assistant two"
         user: text <compaction-instruction>
     `);
     expect(ctx.compactHistory()).toMatchInlineSnapshot(`
@@ -814,14 +805,6 @@ describe('Agent compaction', () => {
           "role": "assistant",
           "text": "Compacted prefix.",
         },
-        {
-          "role": "user",
-          "text": "recent user two",
-        },
-        {
-          "role": "assistant",
-          "text": "recent assistant two",
-        },
         {
           "role": "user",
           "text": "new user while compacting",
@@ -853,8 +836,8 @@ describe('Agent compaction', () => {
       [emit] compaction.started       { "trigger": "manual" }
       [wire] context.clear            { "time": "<time>" }
       [emit] agent.status.updated     { "model": "kimi-code", "contextTokens": 0, "maxContextTokens": 256000, "contextUsage": 0, "planMode": false, "permission": "manual" }
-      [wire] usage.record             { "model": "kimi-code", "usage": { "inputOther": 460, "output": 7, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "session", "time": "<time>" }
-      [emit] agent.status.updated     { "model": "kimi-code", "contextTokens": 0, "maxContextTokens": 256000, "contextUsage": 0, "planMode": false, "permission": "manual", "usage": { "byModel": { "kimi-code": { "inputOther": 460, "output": 7, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 460, "output": 7, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
+      [wire] usage.record             { "model": "kimi-code", "usage": { "inputOther": 473, "output": 7, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "session", "time": "<time>" }
+      [emit] agent.status.updated     { "model": "kimi-code", "contextTokens": 0, "maxContextTokens": 256000, "contextUsage": 0, "planMode": false, "permission": "manual", "usage": { "byModel": { "kimi-code": { "inputOther": 473, "output": 7, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 473, "output": 7, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
       [wire] full_compaction.cancel   { "time": "<time>" }
       [emit] compaction.cancelled     {}
     `);
@@ -864,6 +847,8 @@ describe('Agent compaction', () => {
       messages:
         user: text "old user one"
         assistant: text "old assistant one"
+        user: text "recent user two"
+        assistant: text "recent assistant two"
         user: text <compaction-instruction>
     `);
     expect(ctx.compactHistory()).toMatchInlineSnapshot(`[]`);
@@ -897,7 +882,7 @@ describe('Agent compaction', () => {
       [emit] compaction.blocked          { "turnId": 0 }
       [wire] usage.record                { "model": "kimi-code", "usage": { "inputOther": 472, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "session", "time": "<time>" }
       [emit] agent.status.updated        { "model": "kimi-code", "contextTokens": 950000, "maxContextTokens": 256000, "contextUsage": 3.7109375, "planMode": false, "permission": "manual", "usage": { "byModel": { "kimi-code": { "inputOther": 472, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 472, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
-      [wire] full_compaction.complete    { "summary": "Auto compacted summary.", "compactedCount": 4, "tokensBefore": 46, "tokensAfter": 28, "time": "<time>" }
+      [wire] full_compaction.complete    { "time": "<time>" }
       [emit] compaction.completed        { "result": { "summary": "Auto compacted summary.", "compactedCount": 4, "tokensBefore": 46, "tokensAfter": 28 } }
       [wire] context.apply_compaction    { "summary": "Auto compacted summary.", "compactedCount": 4, "tokensBefore": 46, "tokensAfter": 28, "time": "<time>" }
       [emit] agent.status.updated        { "model": "kimi-code", "contextTokens": 28, "maxContextTokens": 256000, "contextUsage": 0.000109375, "planMode": false, "permission": "manual", "usage": { "byModel": { "kimi-code": { "inputOther": 472, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 472, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
@@ -1038,9 +1023,6 @@ describe('Agent compaction', () => {
 
     expect(ctx.agent.context.history.map((m) => m.role)).toEqual([
       'assistant',
-      'user',
-      'assistant',
-      'tool',
     ]);
 
     ctx.dispatch({
@@ -1055,9 +1037,6 @@ describe('Agent compaction', () => {
 
     expect(ctx.agent.context.history.map((m) => m.role)).toEqual([
       'assistant',
-      'user',
-      'assistant',
-      'tool',
       'tool',
       'user',
     ]);
@@ -1119,8 +1098,6 @@ describe('Agent compaction', () => {
     expect(ctx.llmCalls).toHaveLength(1);
     expect(ctx.compactHistory()).toEqual([
       { role: 'assistant', text: 'Compacted after no-op cancel.' },
-      { role: 'user', text: 'recent user two' },
-      { role: 'assistant', text: 'recent assistant two' },
     ]);
     await ctx.expectResumeMatches();
   });
@@ -1462,7 +1439,7 @@ describe('Agent compaction', () => {
       [emit] compaction.blocked          { "turnId": 0 }
       [wire] usage.record                { "model": "mock-model", "usage": { "inputOther": 456, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "session", "time": "<time>" }
       [emit] agent.status.updated        { "model": "mock-model", "contextTokens": 0, "maxContextTokens": 1000000, "contextUsage": 0, "planMode": false, "permission": "manual", "usage": { "byModel": { "mock-model": { "inputOther": 456, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 456, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
-      [wire] full_compaction.complete    { "summary": "First compacted summary.", "compactedCount": 1, "tokensBefore": 8, "tokensAfter": 6, "time": "<time>" }
+      [wire] full_compaction.complete    { "time": "<time>" }
       [emit] compaction.completed        { "result": { "summary": "First compacted summary.", "compactedCount": 1, "tokensBefore": 8, "tokensAfter": 6 } }
       [wire] context.apply_compaction    { "summary": "First compacted summary.", "compactedCount": 1, "tokensBefore": 8, "tokensAfter": 6, "time": "<time>" }
       [emit] agent.status.updated        { "model": "mock-model", "contextTokens": 6, "maxContextTokens": 1000000, "contextUsage": 0.000006, "planMode": false, "permission": "manual", "usage": { "byModel": { "mock-model": { "inputOther": 456, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 } }, "total": { "inputOther": 456, "output": 9, "inputCacheRead": 0, "inputCacheCreation": 0 } } }
diff --git a/packages/agent-core/test/agent/resume.test.ts b/packages/agent-core/test/agent/resume.test.ts
index a3ad386c..dafbc864 100644
--- a/packages/agent-core/test/agent/resume.test.ts
+++ b/packages/agent-core/test/agent/resume.test.ts
@@ -461,10 +461,6 @@ function resumeHistory(): AgentRecord[] {
     },
     {
       type: 'full_compaction.complete',
-      summary: 'Historical compacted summary.',
-      compactedCount: 3,
-      tokensBefore: 12,
-      tokensAfter: 4,
     },
     {
       type: 'context.apply_compaction',

From 87b503f2d218058cf20a43004839465fe2c8c9d5 Mon Sep 17 00:00:00 2001
From: _Kerman <kermanx@qq.com>
Date: Thu, 28 May 2026 16:31:03 +0800
Subject: [PATCH 15/15] fix

---
 apps/kimi-code/src/tui/kimi-tui.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/apps/kimi-code/src/tui/kimi-tui.ts b/apps/kimi-code/src/tui/kimi-tui.ts
index 35fc02ec..878e5037 100644
--- a/apps/kimi-code/src/tui/kimi-tui.ts
+++ b/apps/kimi-code/src/tui/kimi-tui.ts
@@ -1725,4 +1725,5 @@ export class KimiTUI {
     this.patchLivePane({ pendingQuestion: null });
     this.restoreEditor();
   }
+
 }