fix(cli): share compression rewind markers

Author: Jerry2003826

packages/cli/src/acp-integration/session/Session.test.ts

@@ -8,7 +8,11 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import * as fs from 'node:fs/promises';
 import * as os from 'node:os';
 import * as path from 'node:path';
-import { computeInitialTurnFromHistory, Session } from './Session.js';
+import {
+  computeInitialModelFacingUserTurnCountFromHistory,
+  computeInitialTurnFromHistory,
+  Session,
+} from './Session.js';
 import type { Content } from '@google/genai';
 import type { ChatRecord, Config, GeminiChat } from '@qwen-code/qwen-code-core';
 import { ApprovalMode, AuthType } from '@qwen-code/qwen-code-core';
@@ -123,6 +127,41 @@ describe('computeInitialTurnFromHistory', () => {
   });
 });
 
+describe('computeInitialModelFacingUserTurnCountFromHistory', () => {
+  it('counts model-facing user text records without slash-only records', () => {
+    expect(
+      computeInitialModelFacingUserTurnCountFromHistory(
+        [
+          chatRecord({
+            uuid: 'user-1',
+            message: { parts: [{ text: 'first' }] },
+          }),
+          chatRecord({
+            uuid: 'slash-1',
+            message: { parts: [{ text: '/help' }] },
+          }),
+          chatRecord({
+            uuid: 'cron-1',
+            subtype: 'cron',
+            message: { parts: [{ text: 'cron prompt' }] },
+          }),
+          chatRecord({
+            uuid: 'notification-1',
+            subtype: 'notification',
+            message: { parts: [{ text: 'FYI' }] },
+          }),
+          chatRecord({
+            uuid: 'other-session',
+            sessionId: 'other-session-id',
+            message: { parts: [{ text: 'other' }] },
+          }),
+        ],
+        'test-session-id',
+      ),
+    ).toBe(2);
+  });
+});
+
 // Helper to create empty async generator (avoids memory leak from inline generators)
 function createEmptyStream() {
   return (async function* () {})();
@@ -153,6 +192,13 @@ function expectCompressBeforeSend(
   );
 }
 
+function setSessionTurnCounters(
+  targetSession: Session,
+  counters: { turn?: number; modelFacingUserTurnCount?: number },
+) {
+  Object.assign(targetSession as unknown as Record<string, number>, counters);
+}
+
 describe('Session', () => {
   let mockChat: GeminiChat;
   let mockConfig: Config;
@@ -351,6 +397,117 @@ describe('Session', () => {
       expect(mockChat.truncateHistory).toHaveBeenCalledWith(2);
     });
 
+    it('maps ACP rewind to the uncompressed tail after chat compression', () => {
+      setSessionTurnCounters(session, {
+        turn: 3,
+        modelFacingUserTurnCount: 3,
+      });
+      const history: Content[] = [
+        { role: 'user', parts: [{ text: 'summary of first two turns' }] },
+        {
+          role: 'model',
+          parts: [{ text: core.COMPRESSION_SUMMARY_MODEL_ACK }],
+        },
+        { role: 'user', parts: [{ text: 'third' }] },
+        { role: 'model', parts: [{ text: 'third reply' }] },
+      ];
+      vi.mocked(mockChat.getHistory).mockReturnValue(history);
+
+      const result = session.rewindToTurn(2);
+
+      expect(result).toEqual({ targetTurnIndex: 2, apiTruncateIndex: 2 });
+      expect(mockChat.truncateHistory).toHaveBeenCalledWith(2);
+    });
+
+    it('uses model-facing turn count when slash commands advance prompt ids', () => {
+      setSessionTurnCounters(session, {
+        turn: 4,
+        modelFacingUserTurnCount: 3,
+      });
+      vi.mocked(mockChat.getHistory).mockReturnValue([
+        { role: 'user', parts: [{ text: 'summary of first two turns' }] },
+        {
+          role: 'model',
+          parts: [{ text: core.COMPRESSION_SUMMARY_MODEL_ACK }],
+        },
+        { role: 'user', parts: [{ text: 'third' }] },
+        { role: 'model', parts: [{ text: 'third reply' }] },
+      ]);
+
+      const result = session.rewindToTurn(2);
+
+      expect(result).toEqual({ targetTurnIndex: 2, apiTruncateIndex: 2 });
+      expect(mockChat.truncateHistory).toHaveBeenCalledWith(2);
+    });
+
+    it('uses model-facing turn count when cron adds user text entries', () => {
+      setSessionTurnCounters(session, {
+        turn: 2,
+        modelFacingUserTurnCount: 3,
+      });
+      vi.mocked(mockChat.getHistory).mockReturnValue([
+        { role: 'user', parts: [{ text: 'summary of first two turns' }] },
+        {
+          role: 'model',
+          parts: [{ text: core.COMPRESSION_SUMMARY_MODEL_ACK }],
+        },
+        { role: 'user', parts: [{ text: 'cron prompt' }] },
+        { role: 'model', parts: [{ text: 'cron reply' }] },
+      ]);
+
+      expect(() => session.rewindToTurn(1)).toThrow(
+        'Cannot rewind to the requested turn',
+      );
+      expect(mockChat.truncateHistory).not.toHaveBeenCalled();
+    });
+
+    it('rejects ACP rewind to the first turn after compression absorbed it', () => {
+      setSessionTurnCounters(session, {
+        turn: 3,
+        modelFacingUserTurnCount: 3,
+      });
+      vi.mocked(mockChat.getHistory).mockReturnValue([
+        { role: 'user', parts: [{ text: 'summary of first two turns' }] },
+        {
+          role: 'model',
+          parts: [{ text: core.COMPRESSION_SUMMARY_MODEL_ACK }],
+        },
+        { role: 'user', parts: [{ text: 'third' }] },
+        { role: 'model', parts: [{ text: 'third reply' }] },
+      ]);
+
+      expect(() => session.rewindToTurn(0)).toThrow(
+        'Cannot rewind to the requested turn',
+      );
+      expect(mockChat.truncateHistory).not.toHaveBeenCalled();
+    });
+
+    it('does not treat the compression bridge as an ACP rewind target', () => {
+      setSessionTurnCounters(session, {
+        turn: 3,
+        modelFacingUserTurnCount: 3,
+      });
+      vi.mocked(mockChat.getHistory).mockReturnValue([
+        { role: 'user', parts: [{ text: 'summary of first two turns' }] },
+        {
+          role: 'model',
+          parts: [{ text: core.COMPRESSION_SUMMARY_MODEL_ACK }],
+        },
+        {
+          role: 'user',
+          parts: [{ text: core.COMPRESSION_CONTINUATION_BRIDGE }],
+        },
+        { role: 'model', parts: [{ text: 'continued response' }] },
+        { role: 'user', parts: [{ text: 'third' }] },
+        { role: 'model', parts: [{ text: 'third reply' }] },
+      ]);
+
+      expect(() => session.rewindToTurn(1)).toThrow(
+        'Cannot rewind to the requested turn',
+      );
+      expect(mockChat.truncateHistory).not.toHaveBeenCalled();
+    });
+
     it('rejects unreachable user turns', () => {
       vi.mocked(mockChat.getHistory).mockReturnValue([
         { role: 'user', parts: [{ text: 'first' }] },

packages/cli/src/acp-integration/session/Session.ts

@@ -55,6 +55,8 @@ import {
   getSubagentSystemReminder,
   getArenaSystemReminder,
   STARTUP_CONTEXT_MODEL_ACK,
+  COMPRESSION_CONTINUATION_BRIDGE,
+  COMPRESSION_SUMMARY_MODEL_ACK,
   evaluatePermissionFlow,
   needsConfirmation,
   isPlanModeBlocked,
@@ -151,6 +153,16 @@ export function computeInitialTurnFromHistory(
   return maxPromptTurn > 0 ? maxPromptTurn : userMessageCount;
 }
 
+export function computeInitialModelFacingUserTurnCountFromHistory(
+  records: ChatRecord[],
+  sessionId: string,
+): number {
+  return records.filter(
+    (record) =>
+      record.sessionId === sessionId && isModelFacingUserPromptRecord(record),
+  ).length;
+}
+
 function getRecordPromptIds(record: ChatRecord): string[] {
   const promptIds: string[] = [];
   const recordPromptId = (record as { promptId?: unknown }).promptId;
@@ -187,6 +199,31 @@ function isUserPromptRecord(record: ChatRecord): boolean {
   );
 }
 
+function isModelFacingUserPromptRecord(record: ChatRecord): boolean {
+  if (record.type !== 'user') {
+    return false;
+  }
+  if (record.subtype === 'notification') {
+    return false;
+  }
+  const textParts =
+    record.message?.parts
+      ?.filter(
+        (part): part is { text: string } & Part =>
+          'text' in part &&
+          typeof part.text === 'string' &&
+          part.text.trim().length > 0,
+      )
+      .map((part) => part.text.trim()) ?? [];
+  if (textParts.length === 0) {
+    return false;
+  }
+  if (record.subtype === 'cron') {
+    return true;
+  }
+  return !isSlashCommand(textParts.join(' '));
+}
+
 /**
  * Session represents an active conversation session with the AI model.
  * It uses modular components for consistent event emission:
@@ -206,6 +243,7 @@ export class Session implements SessionContext {
    */
   private pendingPromptCompletion: Promise<void> | null = null;
   private turn: number = 0;
+  private modelFacingUserTurnCount: number = 0;
   private readonly runtimeBaseDir: string;
 
   // Cron scheduling state
@@ -278,6 +316,13 @@ export class Session implements SessionContext {
       this.turn,
       computeInitialTurnFromHistory(records, this.config.getSessionId()),
     );
+    this.modelFacingUserTurnCount = Math.max(
+      this.modelFacingUserTurnCount,
+      computeInitialModelFacingUserTurnCountFromHistory(
+        records,
+        this.config.getSessionId(),
+      ),
+    );
     await this.historyReplayer.replay(records);
   }
 
@@ -347,24 +392,76 @@ export class Session implements SessionContext {
   ): number {
     const startIndex = this.#hasStartupContext(apiHistory) ? 2 : 0;
 
+    if (this.#hasCompressionSummaryPair(apiHistory, startIndex)) {
+      const apiTailUserIndices = this.#getApiUserTextIndices(
+        apiHistory,
+        startIndex + 2,
+        true,
+      );
+      const totalUserTurns = Math.max(
+        this.modelFacingUserTurnCount,
+        targetTurnIndex + 1,
+      );
+      const compressedTurnCount = Math.max(
+        0,
+        totalUserTurns - apiTailUserIndices.length,
+      );
+
+      if (targetTurnIndex < compressedTurnCount) {
+        return -1;
+      }
+
+      // Defensive: the guard above should keep this index in range.
+      return apiTailUserIndices[targetTurnIndex - compressedTurnCount] ?? -1;
+    }
+
     if (targetTurnIndex === 0) {
       return startIndex;
     }
 
-    let realUserPromptCount = 0;
+    return (
+      this.#getApiUserTextIndices(apiHistory, startIndex, false)[
+        targetTurnIndex
+      ] ?? -1
+    );
+  }
+
+  #getApiUserTextIndices(
+    apiHistory: Content[],
+    startIndex: number,
+    skipContinuationBridge: boolean,
+  ): number[] {
+    const indices: number[] = [];
+
     for (let i = startIndex; i < apiHistory.length; i++) {
-      if (!this.#isUserTextContent(apiHistory[i]!)) {
+      const content = apiHistory[i]!;
+      if (!this.#isUserTextContent(content)) continue;
+      if (
+        skipContinuationBridge &&
+        this.#hasTextPart(content, COMPRESSION_CONTINUATION_BRIDGE)
+      ) {
         continue;
       }
 
-      if (realUserPromptCount === targetTurnIndex) {
-        return i;
-      }
-
-      realUserPromptCount += 1;
+      indices.push(i);
     }
 
-    return -1;
+    return indices;
+  }
+
+  #hasCompressionSummaryPair(
+    apiHistory: Content[],
+    startIndex: number,
+  ): boolean {
+    const summary = apiHistory[startIndex];
+    return (
+      !!summary &&
+      this.#isUserTextContent(summary) &&
+      this.#hasModelTextPart(
+        apiHistory[startIndex + 1],
+        COMPRESSION_SUMMARY_MODEL_ACK,
+      )
+    );
   }
 
   #hasStartupContext(apiHistory: Content[]): boolean {
@@ -379,6 +476,17 @@ export class Session implements SessionContext {
     );
   }
 
+  #hasTextPart(content: Content | undefined, text: string): boolean {
+    return (
+      content?.parts?.some((part) => 'text' in part && part.text === text) ??
+      false
+    );
+  }
+
+  #hasModelTextPart(content: Content | undefined, text: string): boolean {
+    return content?.role === 'model' && this.#hasTextPart(content, text);
+  }
+
   #isUserTextContent(content: Content): boolean {
     if (content.role !== 'user') return false;
     if (!content.parts || content.parts.length === 0) return false;
@@ -603,6 +711,7 @@ export class Session implements SessionContext {
         }
 
         let nextMessage: Content | null = { role: 'user', parts };
+        this.#recordModelFacingUserTurn(nextMessage);
 
         while (nextMessage !== null) {
           if (pendingSend.signal.aborted) {
@@ -1006,6 +1115,12 @@ export class Session implements SessionContext {
     return this.config.getGeminiClient()!.getChat();
   }
 
+  #recordModelFacingUserTurn(message: Content): void {
+    if (this.#isUserTextContent(message)) {
+      this.modelFacingUserTurnCount += 1;
+    }
+  }
+
   /**
    * Mirrors the core send path for ACP model sends.
    *
@@ -1324,6 +1439,7 @@ export class Session implements SessionContext {
             role: 'user',
             parts: [...cronReminders, { text: prompt }],
           };
+          this.#recordModelFacingUserTurn(nextMessage);
 
           while (nextMessage !== null) {
             if (ac.signal.aborted) return;