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/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 4f20cb26..d3d008a4 100644
--- a/packages/agent-core/src/agent/compaction/full.ts
+++ b/packages/agent-core/src/agent/compaction/full.ts
@@ -8,132 +8,36 @@ import {
 import {
   APIEmptyResponseError,
   isRetryableGenerateError,
-  inputTotal,
   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,
-  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 { renderMessagesToText } from './render-messages';
 import type { CompactionBeginData, CompactionResult } from './types';
+import { DEFAULT_COMPACTION_CONFIG, DefaultCompactionStrategy, type CompactionStrategy } from './strategy';
 
-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;
-  }
-}
+type CompactionTelemetryTrigger = CompactionBeginData['source'] | 'manual-with-prompt' | 'unknown';
 
 export interface CompactedHistory {
   text: string;
 }
 
-type CompactionTelemetryTrigger = CompactionBeginData['source'] | 'manual-with-prompt' | 'unknown';
+export const MAX_COMPACTION_RETRY_ATTEMPTS = 5;
 
 export class FullCompaction {
   protected compactionCountInTurn = 0;
@@ -152,23 +56,26 @@ 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',
-      ...data,
-    });
     if (this.compacting) return;
     if (data.source === 'manual') {
       this.compactionCountInTurn = 0;
@@ -176,12 +83,24 @@ export class FullCompaction {
       this.compactionCountInTurn += 1;
     }
     if (this.compactionCountInTurn > this.strategy.maxCompactionPerTurn) return;
-    if (!this.agent.records.restoring) {
-      this.startCompactionWorker(data);
+    if (this.agent.records.restoring) {
+      return;
+    }
+    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.');
     }
+    this.agent.records.logRecord({
+      type: 'full_compaction.begin',
+      ...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',
@@ -195,7 +114,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 {
@@ -212,55 +131,20 @@ export class FullCompaction {
     this.agent.emitEvent({ type: 'compaction.cancelled' });
   }
 
-  complete(
-    result: CompactionResult,
-    llmUsage?: TokenUsage | undefined,
-    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,
-      };
-      if (llmUsage !== undefined) {
-        properties['llm_input_tokens'] = inputTotal(llmUsage);
-        properties['llm_output_tokens'] = llmUsage.output;
-      }
-      this.agent.telemetry.track('compaction_finished', properties);
-    }
   }
 
   private get tokenCountWithPending(): number {
     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;
   }
@@ -274,7 +158,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);
     }
   }
@@ -288,7 +172,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);
   }
@@ -304,17 +188,8 @@ 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 });
-    return true;
+    this.begin({ source: 'auto', instruction: undefined });
+    return this.compacting !== null;
   }
 
   private async block(signal: AbortSignal): Promise<void> {
@@ -336,46 +211,70 @@ export class FullCompaction {
   private async compactionWorker(
     signal: AbortSignal,
     data: Readonly<CompactionBeginData>,
+    initialCompactedCount: number,
   ): Promise<void> {
     const startedAt = Date.now();
-    let tokensBeforeForError = 0;
-    let retryCountForTelemetry = 0;
+    const originalHistory = [...this.agent.context.history];
+    const tokensBefore = estimateTokensForMessages(originalHistory);
+    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 = initialCompactedCount;
+
       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;
-        },
-      });
-      if (response.usage !== null) {
-        this.agent.usage.record(model, response.usage);
+
+      const delays = retryBackoffDelays(MAX_COMPACTION_RETRY_ATTEMPTS);
+      let usage: TokenUsage | null;
+      let summary: string;
+      while (true) {
+        const messagesToCompact = originalHistory.slice(0, compactedCount);
+        const messages = [
+          ...project(messagesToCompact),
+          {
+            role: 'user',
+            content: [
+              {
+                type: 'text',
+                text: COMPACTION_INSTRUCTION(data.instruction),
+              },
+            ],
+            toolCalls: [],
+          } satisfies Message,
+        ];
+        class TruncatedError extends Error {}
+        try {
+          const response = await this.agent.generate(
+            this.agent.config.provider,
+            this.agent.config.systemPrompt,
+            [...this.agent.tools.loopTools],
+            messages,
+            undefined,
+            { signal },
+          );
+          if (response.finishReason === 'truncated') {
+            throw new TruncatedError();
+          }
+          usage = response.usage;
+          summary = extractCompactionSummary(response);
+          break;
+        } catch (error) {
+          if (error instanceof APIContextOverflowError || error instanceof TruncatedError) {
+            compactedCount = this.strategy.reduceCompactOnOverflow(messagesToCompact);
+          }
+          else if (!isRetryableGenerateError(error)) {
+            throw error;
+          }
+          if (retryCount + 1 >= MAX_COMPACTION_RETRY_ATTEMPTS) {
+            throw error;
+          }
+          await sleepForRetry(delays[retryCount]!, signal);
+          retryCount += 1;
+        }
+      }
+
+      if (usage !== null) {
+        this.agent.usage.record(model, usage);
       }
 
       const newHistory = this.agent.context.history;
@@ -388,7 +287,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,
@@ -397,7 +296,18 @@ export class FullCompaction {
         tokensAfter,
       };
 
-      this.complete(result, response.usage ?? undefined, 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) {
@@ -417,76 +327,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,
@@ -495,6 +350,7 @@ export class FullCompaction {
         tokenCount,
       },
     });
+    signal.throwIfAborted();
   }
 
   private triggerPostCompactHook(
@@ -509,13 +365,6 @@ export class FullCompaction {
       },
     });
   }
-
-  private computeCompactableCount(history: readonly Message[]): number {
-    return sliceCompleteMessages(
-      history,
-      this.strategy.computeCompactCount(history, this.maxContextSize),
-    );
-  }
 }
 
 function extractCompactionSummary(response: GenerateResult): string {
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
new file mode 100644
index 00000000..98b3fd80
--- /dev/null
+++ b/packages/agent-core/src/agent/compaction/strategy.ts
@@ -0,0 +1,157 @@
+import type { Message } from "@moonshot-ai/kosong";
+import { estimateTokensForMessage } from "../../utils/tokens";
+import type { CompactionSource } from "./types";
+
+export interface CompactionConfig {
+  triggerRatio: number;
+  blockRatio: number;
+  reservedContextSize: number;
+  maxCompactionPerTurn: number;
+  maxRecentMessages: 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,
+  maxRecentMessages: 4,
+  maxRecentUserMessages: Infinity,
+  maxRecentSizeRatio: 0.2,
+};
+
+export interface CompactionStrategy {
+  shouldCompact(usedSize: number): boolean;
+  shouldBlock(usedSize: number): boolean;
+  computeCompactCount(messages: readonly Message[], source: CompactionSource): number;
+  reduceCompactOnOverflow(messages: readonly Message[]): number;
+  readonly checkAfterStep: boolean;
+  readonly maxCompactionPerTurn: number;
+}
+
+export class DefaultCompactionStrategy implements CompactionStrategy {
+  constructor(
+    protected readonly maxSizeProvider: () => number,
+    protected readonly config: CompactionConfig = DEFAULT_COMPACTION_CONFIG
+  ) { }
+
+  protected get maxSize(): number {
+    return this.maxSizeProvider();
+  }
+
+  shouldCompact(usedSize: number): boolean {
+    if (this.maxSize <= 0) return false;
+    return (
+      usedSize >= this.maxSize * this.config.triggerRatio ||
+      this.shouldUseReservedContext(usedSize)
+    );
+  }
+
+  shouldBlock(usedSize: number): boolean {
+    if (this.maxSize <= 0) return false;
+    return (
+      usedSize >= this.maxSize * this.config.blockRatio ||
+      this.shouldUseReservedContext(usedSize)
+    );
+  }
+
+  private shouldUseReservedContext(usedSize: number): boolean {
+    const reservedSize = this.config.reservedContextSize;
+    return reservedSize > 0 && reservedSize < this.maxSize && usedSize + reservedSize >= this.maxSize;
+  }
+
+  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)
+
+    // Manual compaction
+    if (source === 'manual') {
+      for (let i = messages.length - 1; i > 0; i--) {
+        if (canSplitAfter(messages, i)) {
+          return i + 1;
+        }
+      }
+      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.
+    // 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 bestN: number | undefined;
+
+    for (; recentMessages < messages.length; recentMessages++) {
+      const splitIndex = messages.length - recentMessages - 1;
+      const m2 = messages[messages.length - recentMessages]!;
+
+      if (m2.role === 'user') {
+        recentUserMessages++;
+      }
+      recentSize += estimateTokensForMessage(m2);
+
+      if (canSplitAfter(messages, splitIndex)) {
+        bestN = splitIndex + 1;
+      }
+
+      const reachesMax = recentMessages >= this.config.maxRecentMessages
+        || recentUserMessages >= this.config.maxRecentUserMessages
+        || recentSize >= this.maxSize * this.config.maxRecentSizeRatio;
+      if (reachesMax && bestN !== undefined) {
+        break;
+      }
+    }
+
+    return bestN ?? 0;
+  }
+
+  reduceCompactOnOverflow(messages: readonly Message[]): number {
+    for (let i = messages.length - 2; i > 0; i--) {
+      if (canSplitAfter(messages, i)) {
+        return i + 1;
+      }
+    }
+    return messages.length;
+  }
+
+  get checkAfterStep(): boolean {
+    return this.config.triggerRatio !== this.config.blockRatio;
+  }
+
+  get maxCompactionPerTurn(): number {
+    return this.config.maxCompactionPerTurn;
+  }
+}
+
+/**
+ * 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/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/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;
-}
diff --git a/packages/agent-core/src/agent/index.ts b/packages/agent-core/src/agent/index.ts
index 88f95d90..4667d5e9 100644
--- a/packages/agent-core/src/agent/index.ts
+++ b/packages/agent-core/src/agent/index.ts
@@ -479,7 +479,7 @@ function buildLlmRequestMetadata(
 
   const estimatedInputTokens =
     estimateTokens(systemPrompt) +
-    estimateTokensForMessages([...history]) +
+    estimateTokensForMessages(history) +
     estimateTokensForTools(tools);
 
   const metadata: LlmRequestMetadata = {
diff --git a/packages/agent-core/src/agent/records/index.ts b/packages/agent-core/src/agent/records/index.ts
index 2e4ede74..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);
+      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 };
diff --git a/packages/agent-core/src/errors/codes.ts b/packages/agent-core/src/errors/codes.ts
index 2014dba2..97c5daad 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',
@@ -307,6 +308,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/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 8b518981..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, 1_000)).toBe(2);
+    expect(strategy.computeCompactCount(messages, 'auto')).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, 'auto')).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,85 @@ describe('Agent compaction', () => {
       textMessage('assistant', `recent assistant ${'x'.repeat(1_200)}`),
     ];
 
-    expect(strategy.computeCompactCount(messages, 1_000)).toBe(messages.length);
+    expect(strategy.computeCompactCount(messages, 'auto')).toBe(2);
+  });
+
+  it('returns 0 when there is nothing to compact', () => {
+    const strategy = testCompactionStrategy();
+    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'),
+        ],
+        'auto',
+      ),
+    ).toBe(0);
+  });
+
+  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, 'auto')).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, 'auto')).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 +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": 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": 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>
@@ -138,6 +192,8 @@ 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>
     `);
     expect(ctx.compactHistory()).toMatchInlineSnapshot(`
@@ -146,14 +202,6 @@ describe('Agent compaction', () => {
           "role": "assistant",
           "text": "Compacted summary.",
         },
-        {
-          "role": "user",
-          "text": "recent user three",
-        },
-        {
-          "role": "assistant",
-          "text": "recent assistant three",
-        },
       ]
     `);
     expect(ctx.agent.fullCompaction.compactedHistory).toMatchInlineSnapshot(`
@@ -189,65 +237,20 @@ describe('Agent compaction', () => {
       event: 'compaction_finished',
       properties: {
         trigger_type: 'manual-with-prompt',
-        before_tokens: 120,
-        after_tokens: 20,
+        before_tokens: 39,
+        after_tokens: 5,
         duration_ms: expect.any(Number),
-        compacted_count: 4,
+        compacted_count: 6,
         retry_count: 0,
-        llm_input_tokens: 480,
-        llm_output_tokens: 8,
+        inputOther: 495,
+        output: 8,
+        inputCacheRead: 0,
+        inputCacheCreation: 0,
       },
     });
     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({
@@ -350,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();
   });
@@ -394,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',
@@ -475,7 +476,7 @@ describe('Agent compaction', () => {
       event: 'compaction_finished',
       properties: expect.objectContaining({
         trigger_type: 'manual',
-        before_tokens: 80,
+        before_tokens: 25,
         retry_count: 1,
       }),
     });
@@ -511,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();
@@ -625,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',
@@ -638,6 +639,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 +656,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,
+        before_tokens: 25,
         duration_ms: expect.any(Number),
-        retry_count: 2,
+        retry_count: 4,
         error_type: 'APIConnectionError',
       },
     });
@@ -676,6 +679,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', () => {
@@ -691,11 +695,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:
@@ -708,7 +720,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)",
@@ -738,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();
   });
@@ -770,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": 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>" }
-      [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>
@@ -783,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(`
@@ -791,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",
@@ -830,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     {}
     `);
@@ -841,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(`[]`);
@@ -872,20 +880,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    { "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>" }
       [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,29 +905,147 @@ 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({
       event: 'compaction_finished',
       properties: expect.objectContaining({
         trigger_type: 'auto',
-        before_tokens: 950000,
-        after_tokens: 13,
-        compacted_count: 6,
+        before_tokens: 46,
+        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('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',
+    ]);
+
+    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',
+      '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({
       provider: CATALOGUED_PROVIDER,
@@ -930,28 +1056,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();
@@ -966,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();
   });
@@ -1165,7 +1295,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');
@@ -1227,45 +1357,9 @@ 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) => {
+    const generate: GenerateFn = async (_provider, _system, _tools, _history, callbacks) => {
       callCount += 1;
       if (callCount === 1) {
         throw new APIContextOverflowError(
@@ -1345,9 +1439,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    { "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>" }
@@ -1454,6 +1548,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 +1562,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..ad49e7a3 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';
@@ -409,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),
     );
   });
 
@@ -464,30 +463,10 @@ 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),
     );
   });
 
-  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/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',
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();
     }