Fix E2E sqlite test session_id recording and Windows flaky test

Go/Python/Rust: Fix E2E stub providers to record actual session ID
from stored state instead of hardcoded strings, so filterCalls
assertions match the real session.

Node.js: Move SQLite database Map to describe scope so it survives
handler re-creation. The factory-scoped closure variable caused each
handler invocation to create a fresh :memory: database, losing
previously inserted data. This caused intermittent failures on
Windows where the CLI re-creates the handler between tool calls.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: SteveSandersonMS

go/internal/e2e/session_fs_sqlite_e2e_test.go

@@ -200,7 +200,7 @@ func (p *inMemorySqliteProvider) SqliteQuery(queryType rpc.SessionFsSqliteQueryT
 	defer p.mu.Unlock()
 	p.hadQuery = true
 	*p.sqliteCalls = append(*p.sqliteCalls, sqliteCall{
-		SessionID: "stub",
+		SessionID: p.sessionID,
 		QueryType: string(queryType),
 		Query:     query,
 	})

nodejs/test/e2e/session_fs_sqlite.e2e.test.ts

@@ -40,9 +40,13 @@ describe("Session Fs SQLite", async () => {
     const provider = new MemoryProvider();
     /** Track which queries were received, per session */
     const sqliteCalls: { sessionId: string; queryType: string; query: string }[] = [];
+    /** Per-session SQLite databases, keyed by session ID.
+     *  Stored at describe scope so the database survives if the CLI
+     *  re-creates the handler (e.g., on reconnect). */
+    const sessionDbs = new Map<string, DatabaseSync>();
 
     const createSessionFsHandler = (session: CopilotSession) =>
-        createTestSessionFsHandlerWithSqlite(session, provider, sqliteCalls);
+        createTestSessionFsHandlerWithSqlite(session, provider, sqliteCalls, sessionDbs);
 
     // Helpers to build session-namespaced paths for direct provider assertions
     const p = (sessionId: string, path: string) =>
@@ -139,17 +143,17 @@ describe("Session Fs SQLite", async () => {
 function createTestSessionFsHandlerWithSqlite(
     session: CopilotSession,
     provider: VirtualProvider,
-    sqliteCalls: { sessionId: string; queryType: string; query: string }[]
+    sqliteCalls: { sessionId: string; queryType: string; query: string }[],
+    sessionDbs: Map<string, DatabaseSync>
 ): SessionFsProvider {
     const sp = (path: string) => `/${session.sessionId}${path.startsWith("/") ? path : "/" + path}`;
 
-    // Per-session SQLite database (in-memory)
-    let db: DatabaseSync | undefined;
-
     function getOrCreateDb(): DatabaseSync {
+        let db = sessionDbs.get(session.sessionId);
         if (!db) {
             db = new DatabaseSync(":memory:");
             db.exec("PRAGMA busy_timeout = 5000");
+            sessionDbs.set(session.sessionId, db);
         }
         return db;
     }
@@ -246,7 +250,7 @@ function createTestSessionFsHandlerWithSqlite(
                 }
             },
             async exists(): Promise<boolean> {
-                return db !== undefined;
+                return sessionDbs.has(session.sessionId);
             },
         },
     };

python/e2e/test_session_fs_sqlite_e2e.py

@@ -154,6 +154,7 @@ async def sqlite_query(
     ) -> SessionFsSqliteQueryResult:
         self._sqlite_calls.append(
             {
+                "sessionId": self._session_id,
                 "queryType": query_type.value,
                 "query": query,
             }

rust/tests/e2e/session_fs_sqlite.rs

@@ -19,17 +19,19 @@ struct SqliteCall {
 }
 
 struct InMemorySqliteProvider {
+    session_id: String,
     files: Mutex<HashMap<String, String>>,
     dirs: Mutex<std::collections::HashSet<String>>,
     db: Mutex<Option<Connection>>,
     sqlite_calls: Arc<Mutex<Vec<SqliteCall>>>,
 }
 
 impl InMemorySqliteProvider {
-    fn new(_session_id: &str, calls: Arc<Mutex<Vec<SqliteCall>>>) -> Self {
+    fn new(session_id: &str, calls: Arc<Mutex<Vec<SqliteCall>>>) -> Self {
         let mut dirs = std::collections::HashSet::new();
         dirs.insert("/".to_string());
         Self {
+            session_id: session_id.to_string(),
             files: Mutex::new(HashMap::new()),
             dirs: Mutex::new(dirs),
             db: Mutex::new(None),
@@ -222,7 +224,7 @@ impl SessionFsSqliteProvider for InMemorySqliteProvider {
             SessionFsSqliteQueryType::Unknown => "unknown",
         };
         self.sqlite_calls.lock().unwrap().push(SqliteCall {
-            session_id: "session".to_string(),
+            session_id: self.session_id.clone(),
             query_type: qt_str.to_string(),
             query: query.to_string(),
         });