feat(core): persist file history snapshots for cross-session /rewind (T2.1)

integration-tests/cli/qwen-serve-routes.test.ts

@@ -193,6 +193,7 @@ describe('qwen serve — capabilities envelope', () => {
       'session_create',
       'session_scope_override',
       'session_load',
+      'session_resume',
       'unstable_session_resume',
       'session_list',
       'session_prompt',

packages/cli/src/acp-integration/acpAgent.ts

@@ -6763,6 +6763,12 @@ class QwenAgent implements Agent {
       // <available_skills> at cold start.
       buildDisabledSkillNamesProvider(this.settings),
     );
+    // ACP sessions run with piped stdio (non-TTY), so the default
+    // interactive-based gating disables file checkpointing. Enable it
+    // explicitly so /rewind works across daemon session resume.
+    if (typeof config.enableFileCheckpointing === 'function') {
+      config.enableFileCheckpointing();
+    }
     // Inject the workspace-shared MCP transport pool BEFORE
     // `config.initialize()` so the ToolRegistry picks it up.
     if (

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

@@ -307,6 +307,12 @@ describe('Session', () => {
         .fn()
         .mockReturnValue(mockBackgroundShellRegistry),
       getMonitorRegistry: vi.fn().mockReturnValue(mockMonitorRegistry),
+      getFileHistoryService: vi.fn().mockReturnValue({
+        makeSnapshot: vi.fn().mockResolvedValue(undefined),
+        getSnapshots: vi.fn().mockReturnValue([]),
+        restoreFromSnapshots: vi.fn(),
+        rewind: vi.fn(),
+      }),
     } as unknown as Config;
 
     mockClient = {
@@ -446,9 +452,11 @@ describe('Session', () => {
       expect(result).toEqual({ targetTurnIndex: 1, apiTruncateIndex: 2 });
       expect(mockChat.truncateHistory).toHaveBeenCalledWith(2);
       expect(mockChat.stripThoughtsFromHistory).toHaveBeenCalled();
-      expect(mockChatRecordingService.rewindRecording).toHaveBeenCalledWith(1, {
-        truncatedCount: 2,
-      });
+      expect(mockChatRecordingService.rewindRecording).toHaveBeenCalledWith(
+        1,
+        { truncatedCount: 2 },
+        [],
+      );
     });
 
     it('preserves startup context when rewinding to the first user turn', () => {

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

@@ -614,9 +614,20 @@ export class Session implements SessionContext {
     chat.truncateHistory(apiTruncateIndex);
     chat.stripThoughtsFromHistory();
 
-    this.config.getChatRecordingService()?.rewindRecording(targetTurnIndex, {
-      truncatedCount: Math.max(0, apiHistory.length - apiTruncateIndex),
-    });
+    const fileHistoryService = this.config.getFileHistoryService();
+    const survivingSnapshots = fileHistoryService
+      .getSnapshots()
+      .slice(0, targetTurnIndex + 1);
+
+    fileHistoryService.restoreFromSnapshots(survivingSnapshots);
+
+    this.config
+      .getChatRecordingService()
+      ?.rewindRecording(
+        targetTurnIndex,
+        { truncatedCount: Math.max(0, apiHistory.length - apiTruncateIndex) },
+        survivingSnapshots,
+      );
 
     return { targetTurnIndex, apiTruncateIndex };
   }
@@ -1054,6 +1065,27 @@ export class Session implements SessionContext {
               }
             }
 
+            // Snapshot file state before this turn (mirrors the makeSnapshot
+            // block in GeminiClient.sendMessageStream). Placed after
+            // slash-command and hook early-returns so locally handled commands
+            // don't create phantom snapshots that desync the snapshot index.
+            try {
+              const fileHistoryService = this.config.getFileHistoryService();
+              await fileHistoryService.makeSnapshot(promptId);
+              try {
+                const latestSnapshot = fileHistoryService.getSnapshots().at(-1);
+                if (latestSnapshot) {
+                  this.config
+                    .getChatRecordingService()
+                    ?.recordFileHistorySnapshot(latestSnapshot);
+                }
+              } catch (e) {
+                debugLogger.error(`FileHistory: recordSnapshot failed: ${e}`);
+              }
+            } catch (e) {
+              debugLogger.error(`FileHistory: makeSnapshot failed: ${e}`);
+            }
+
             // Prepend session-level system reminders (plan mode / subagent /
             // arena) so the model sees them, matching the behaviour of
             // `GeminiClient.sendMessageStream` in the CLI/TUI path. Without this,

packages/cli/src/serve/capabilities.ts

@@ -35,9 +35,9 @@ export const SERVE_CAPABILITY_REGISTRY = {
   session_create: { since: 'v1' },
   session_scope_override: { since: 'v1' },
   session_load: { since: 'v1' },
-  // ACP backs this with `connection.unstable_resumeSession`. Surface
-  // the unstable prefix so clients don't pin against a `v1` shape that
-  // the underlying ACP method may still change.
+  session_resume: { since: 'v1' },
+  // Deprecated alias — kept until @agentclientprotocol/sdk graduates
+  // the underlying ACP method from unstable_resumeSession to resumeSession.
   unstable_session_resume: { since: 'v1' },
   session_list: { since: 'v1' },
   session_prompt: { since: 'v1' },

packages/cli/src/serve/server.test.ts

@@ -107,6 +107,7 @@ const EXPECTED_STAGE1_FEATURES = [
   'session_create',
   'session_scope_override',
   'session_load',
+  'session_resume',
   'unstable_session_resume',
   'session_list',
   'session_prompt',

packages/cli/src/ui/AppContainer.tsx

@@ -441,7 +441,11 @@ export const AppContainer = (props: AppContainerProps) => {
   );
 
   // Additional hooks moved from App.tsx
-  const { stats: sessionStats, startNewSession } = useSessionStats();
+  const {
+    stats: sessionStats,
+    startNewSession,
+    seedPromptCount,
+  } = useSessionStats();
   const logger = useLogger(config.storage, sessionStats.sessionId);
   const branchName = useGitBranchName(config.getTargetDir());
   const worktreeSession = useWorktreeSession(config);
@@ -549,6 +553,15 @@ export const AppContainer = (props: AppContainerProps) => {
         );
         historyManager.loadHistory(historyItems);
 
+        // Seed the prompt counter from the resumed conversation so new
+        // promptIds don't collide with restored file history snapshots.
+        const userTurnCount = resumedSessionData.conversation.messages.filter(
+          (m) => m.type === 'user' && m.subtype !== 'mid_turn_user_message',
+        ).length;
+        if (userTurnCount > 0) {
+          seedPromptCount(userTurnCount);
+        }
+
         // Re-arm any `/goal` that was active when the prior session ended.
         try {
           restoreGoalFromHistory(historyItems, config, historyManager.addItem);
@@ -2622,9 +2635,16 @@ export const AppContainer = (props: AppContainerProps) => {
             Date.now(),
           );
 
-          config.getChatRecordingService()?.rewindRecording(targetTurnIndex, {
-            truncatedCount: originalLength - truncatedUi.length,
-          });
+          config.getChatRecordingService()?.rewindRecording(
+            targetTurnIndex,
+            { truncatedCount: originalLength - truncatedUi.length },
+            !hasRestoreFailure
+              ? config
+                  .getFileHistoryService()
+                  .getSnapshots()
+                  .slice(0, targetTurnIndex + 1)
+              : undefined,
+          );
         }
 
         // Show file restore result after conversation truncation so the

packages/cli/src/ui/contexts/SessionContext.tsx

@@ -191,6 +191,7 @@ interface SessionStatsContextValue {
   startNewSession: (sessionId: string) => void;
   startNewPrompt: () => void;
   getPromptCount: () => number;
+  seedPromptCount: (count: number) => void;
 }
 
 // --- Context Definition ---
@@ -271,14 +272,22 @@ export const SessionStatsProvider: React.FC<{
     [stats.promptCount],
   );
 
+  const seedPromptCount = useCallback((count: number) => {
+    setStats((prevState) => ({
+      ...prevState,
+      promptCount: Math.max(prevState.promptCount, count),
+    }));
+  }, []);
+
   const value = useMemo(
     () => ({
       stats,
       startNewSession,
       startNewPrompt,
       getPromptCount,
+      seedPromptCount,
     }),
-    [stats, startNewSession, startNewPrompt, getPromptCount],
+    [stats, startNewSession, startNewPrompt, getPromptCount, seedPromptCount],
   );
 
   return (

packages/core/src/config/config.ts

@@ -1151,7 +1151,7 @@ export class Config {
   private fileDiscoveryService: FileDiscoveryService | null = null;
   private sessionService: SessionService | undefined = undefined;
   private chatRecordingService: ChatRecordingService | undefined = undefined;
-  private readonly fileCheckpointingEnabled: boolean;
+  private fileCheckpointingEnabled: boolean;
   private fileHistoryService: FileHistoryService | undefined;
   private readonly proxy: string | undefined;
   private readonly cwd: string;
@@ -3604,13 +3604,27 @@ export class Config {
     return this.fileCheckpointingEnabled;
   }
 
+  enableFileCheckpointing(): void {
+    this.fileCheckpointingEnabled = true;
+    this.fileHistoryService = undefined;
+  }
+
   getFileHistoryService(): FileHistoryService {
     if (!this.fileHistoryService) {
       this.fileHistoryService = new FileHistoryService(
         this.sessionId,
         this.fileCheckpointingEnabled,
         this.cwd,
       );
+      const snapshots = this.sessionData?.fileHistorySnapshots;
+      if (snapshots?.length && this.fileHistoryService.isEnabled()) {
+        this.fileHistoryService.restoreFromSnapshots(snapshots);
+        void this.fileHistoryService.validateRestoredSnapshots().catch((e) => {
+          this.debugLogger.error(
+            `FileHistory: validateRestoredSnapshots failed: ${e}`,
+          );
+        });
+      }
     }
     return this.fileHistoryService;
   }

packages/core/src/core/client.ts

@@ -1661,6 +1661,19 @@ export class GeminiClient {
         if (messageType === SendMessageType.UserQuery) {
           try {
             await this.config.getFileHistoryService().makeSnapshot(prompt_id);
+            try {
+              const latestSnapshot = this.config
+                .getFileHistoryService()
+                .getSnapshots()
+                .at(-1);
+              if (latestSnapshot) {
+                this.config
+                  .getChatRecordingService()
+                  ?.recordFileHistorySnapshot(latestSnapshot);
+              }
+            } catch (e) {
+              debugLogger.error(`FileHistory: recordSnapshot failed: ${e}`);
+            }
           } catch (e) {
             debugLogger.error(`FileHistory: makeSnapshot failed: ${e}`);
           }

packages/core/src/services/chatRecordingService.ts

@@ -28,6 +28,11 @@ import type {
 import type { Status } from '../core/coreToolScheduler.js';
 import type { AgentResultDisplay, FileDiff } from '../tools/tools.js';
 import type { UiEvent } from '../telemetry/uiTelemetry.js';
+import type {
+  FileHistorySnapshot,
+  SerializedFileHistorySnapshot,
+} from './fileHistoryService.js';
+import { serializeSnapshot } from './fileHistoryService.js';
 
 const debugLogger = createDebugLogger('CHAT_RECORDING');
 
@@ -235,7 +240,8 @@ export interface ChatRecord {
     | 'custom_title'
     | 'rewind'
     | 'agent_bootstrap'
-    | 'agent_launch_prompt';
+    | 'agent_launch_prompt'
+    | 'file_history_snapshot';
   /** Working directory at time of message */
   cwd: string;
   /** CLI version for compatibility tracking */
@@ -281,7 +287,8 @@ export interface ChatRecord {
     | CustomTitleRecordPayload
     | NotificationRecordPayload
     | RewindRecordPayload
-    | AgentBootstrapRecordPayload;
+    | AgentBootstrapRecordPayload
+    | FileHistorySnapshotRecordPayload;
 
   /** Background subagent that produced this record (e.g. "explore-7f3c"). */
   agentId?: string;
@@ -428,6 +435,14 @@ export interface RewindRecordPayload {
   truncatedCount: number;
 }
 
+/**
+ * Stored payload for file history snapshot persistence.
+ * Each entry records one or more snapshots for session resume.
+ */
+export interface FileHistorySnapshotRecordPayload {
+  snapshots: SerializedFileHistorySnapshot[];
+}
+
 /**
  * Service for recording the current chat session to disk.
  *
@@ -1140,7 +1155,11 @@ export class ChatRecordingService {
    *   nothing before it), 1 means keep the first user turn, etc.
    * @param payload Additional metadata to persist with the rewind record.
    */
-  rewindRecording(targetTurnIndex: number, payload: RewindRecordPayload): void {
+  rewindRecording(
+    targetTurnIndex: number,
+    payload: RewindRecordPayload,
+    survivingFileHistorySnapshots?: FileHistorySnapshot[],
+  ): void {
     try {
       // Re-root: point back to the record just before the target user turn.
       this.lastRecordUuid = this.turnParentUuids[targetTurnIndex] ?? null;
@@ -1161,6 +1180,12 @@ export class ChatRecordingService {
       };
 
       this.appendRecord(record);
+
+      // Re-record surviving file history snapshots on the active branch so
+      // they are visible to reconstructHistory on resume.
+      if (survivingFileHistorySnapshots?.length) {
+        this.recordFileHistorySnapshotBatch(survivingFileHistorySnapshots);
+      }
     } catch (error) {
       debugLogger.error('Error saving rewind record:', error);
     }
@@ -1346,4 +1371,23 @@ export class ChatRecordingService {
       debugLogger.error('Error saving attribution snapshot:', error);
     }
   }
+
+  recordFileHistorySnapshot(snapshot: FileHistorySnapshot): void {
+    this.recordFileHistorySnapshotBatch([snapshot]);
+  }
+
+  recordFileHistorySnapshotBatch(snapshots: FileHistorySnapshot[]): void {
+    if (snapshots.length === 0) return;
+    try {
+      const record: ChatRecord = {
+        ...this.createBaseRecord('system'),
+        type: 'system',
+        subtype: 'file_history_snapshot',
+        systemPayload: { snapshots: snapshots.map(serializeSnapshot) },
+      };
+      this.appendRecord(record);
+    } catch (error) {
+      debugLogger.error('Error saving file history snapshot batch:', error);
+    }
+  }
 }