Fix CLI context pollution between sessions

Resolves context pollution issue where CLI sessions would retain
state from previous invocations, causing responses to reference
conversations that should have been isolated.

Changes:
- Added SessionManager.reset() static method for proper cleanup
- Updated initializeChatHistory() to create new session by default
- Clear undo/redo stacks in ChatHistoryService on initialization
- Added comprehensive session isolation tests

Fixes CON-4530

Co-authored-by: Username <nate@continue.dev>
Generated with [Continue](https://continue.dev)

Co-Authored-By: Continue <noreply@continue.dev>

Author: sestinj

extensions/cli/package-lock.json

@@ -118,6 +118,11 @@ export async function initializeChatHistory(
     }
   }
 
+  // Starting a new session - ensure clean state
+  // This prevents context pollution from previous CLI sessions
+  const { startNewSession } = await import("../session.js");
+  startNewSession([]); // Creates a new session with empty history
+
   return [];
 }
 

extensions/cli/src/commands/chat.ts

@@ -81,6 +81,11 @@ export class ChatHistoryService extends BaseService<ChatHistoryState> {
     session?: any,
     isRemoteMode = false,
   ): Promise<ChatHistoryState> {
+    // Clear undo/redo stacks when initializing to prevent pollution
+    this.past = [];
+    this.future = [];
+    this._memoSnapshot = { stateRef: null, historyRef: null, snapshot: null };
+
     const activeSession = session || createSession([]);
 
     logger.debug("Initializing ChatHistoryService", {

extensions/cli/src/services/ChatHistoryService.ts

@@ -16,6 +16,7 @@ import {
   updateSessionHistory,
   updateSessionTitle,
 } from "./session.js";
+import type SessionManager from "./session.js";
 
 // Mock dependencies first, before any imports
 vi.mock("os", () => ({
@@ -401,4 +402,100 @@ describe("SessionManager", () => {
       expect(currentSession).not.toBe(originalSession);
     });
   });
+
+  describe("session isolation", () => {
+    it("should not pollute new sessions with previous session history", () => {
+      // Simulate first CLI session
+      vi.mocked(uuidv4).mockReturnValue("session-1" as any);
+      const session1 = createSession();
+      const history1: ChatHistoryItem[] = [
+        {
+          message: {
+            role: "user",
+            content: "Tell me about dogs",
+          },
+          contextItems: [],
+        },
+        {
+          message: {
+            role: "assistant",
+            content: "Dogs are loyal companions...",
+          },
+          contextItems: [],
+        },
+      ];
+      updateSessionHistory(history1);
+
+      // Simulate starting a new CLI session (without --resume)
+      vi.mocked(uuidv4).mockReturnValue("session-2" as any);
+      const session2 = startNewSession([]);
+
+      // New session should have clean state
+      expect(session2.sessionId).toBe("session-2");
+      expect(session2.sessionId).not.toBe(session1.sessionId);
+      expect(session2.history).toEqual([]);
+      expect(session2.history.length).toBe(0);
+    });
+
+    it("should create independent sessions for concurrent operations", () => {
+      // Create first session with some data
+      vi.mocked(uuidv4).mockReturnValue("concurrent-1" as any);
+      const session1 = createSession();
+      updateSessionTitle("Session 1");
+      updateSessionHistory([
+        {
+          message: {
+            role: "user",
+            content: "First session message",
+          },
+          contextItems: [],
+        },
+      ]);
+
+      // Start a new session
+      vi.mocked(uuidv4).mockReturnValue("concurrent-2" as any);
+      const session2 = startNewSession([]);
+
+      // Verify session2 is clean
+      expect(session2.title).toBe("Untitled Session");
+      expect(session2.history).toEqual([]);
+      expect(session2.sessionId).not.toBe(session1.sessionId);
+    });
+
+    it("should properly clear session state when transitioning between sessions", () => {
+      // First session with complex history
+      vi.mocked(uuidv4).mockReturnValue("complex-session-1" as any);
+      const session1 = createSession();
+      updateSessionTitle("Complex Session");
+      const complexHistory: ChatHistoryItem[] = [
+        {
+          message: {
+            role: "user",
+            content: "What were we discussing?",
+          },
+          contextItems: [],
+        },
+        {
+          message: {
+            role: "assistant",
+            content: "We were discussing dogs earlier.",
+          },
+          contextItems: [],
+        },
+      ];
+      updateSessionHistory(complexHistory);
+
+      // Verify first session has data
+      expect(getCurrentSession().history.length).toBe(2);
+
+      // Start fresh session
+      vi.mocked(uuidv4).mockReturnValue("fresh-session-2" as any);
+      const session2 = startNewSession([]);
+
+      // Verify clean state
+      expect(session2.history.length).toBe(0);
+      expect(session2.title).toBe("Untitled Session");
+      expect(getCurrentSession().sessionId).toBe("fresh-session-2");
+    });
+  });
 });

extensions/cli/src/session.test.ts

@@ -122,6 +122,15 @@ class SessionManager {
     this.currentSession = null;
   }
 
+  /**
+   * Reset singleton instance for testing or to ensure clean state
+   */
+  static reset(): void {
+    if (SessionManager.instance) {
+      SessionManager.instance.currentSession = null;
+    }
+  }
+
   hasSession(): boolean {
     return this.currentSession !== null;
   }