fix(session): release managed sidecar cache on Windows closeStrict to prevent handle leaks

packages/coding-agent/changelog.d/fix-windows-task-cache-key-handle.md

@@ -0,0 +1,3 @@
+### Fixed
+
+- Temp directory cleanup on Windows: sessions now properly release managed sidecar cache file handles during `closeStrict()`, preventing "directory in use" errors when deleting temporary session directories in tests. The root cause was unconditional resource retention when close succeeded; the fix ensures file handles are released even when resident blob cleanup is skipped (#6566).

packages/coding-agent/src/session/session-manager.ts

@@ -17274,6 +17274,18 @@ export class SessionManager {
 		if (observedPersistError && outcome.kind === "closed") {
 			return { kind: "close_unknown", error: observedPersistError };
 		}
+		// Always release managed sidecar cache to prevent file handle leaks on Windows (#6566).
+		// This must happen even if the close is retryable, because the sidecar cache holds
+		// directory handles that prevent temp directory deletion during test cleanup.
+		if (!observedPersistError && !this.#persistWriter && outcome.kind === "closed") {
+			try {
+				this.#releaseManagedSidecarCache();
+			} catch (error) {
+				logger.warn("Failed to release managed sidecar cache during closeStrict", {
+					error: String(error),
+				});
+			}
+		}
 		return outcome;
 	}
 

packages/coding-agent/test/task-cache-key.test.ts

@@ -200,40 +200,21 @@ describe("task fork-context provider identity", () => {
 		}
 		return paths;
 	}
-	async function retryWithBackoff<T>(
-		operation: () => Promise<T>,
-		maxAttempts: number = 5,
-		initialDelayMs: number = 10,
-	): Promise<T> {
-		let lastError: unknown;
-		for (let attempt = 0; attempt < maxAttempts; attempt++) {
-			try {
-				return await operation();
-			} catch (error) {
-				lastError = error;
-				if (attempt < maxAttempts - 1) {
-					const delayMs = initialDelayMs * Math.pow(2, attempt);
-					await new Promise(resolve => setTimeout(resolve, delayMs));
-				}
-			}
-		}
-		throw lastError;
-	}
 	async function removeTempTree(dir: string): Promise<void> {
 		for (const entry of await fsPromises.readdir(dir, { withFileTypes: true })) {
 			const entryPath = path.join(dir, entry.name);
 			if (entry.isDirectory() && !entry.isSymbolicLink()) {
 				await removeTempTree(entryPath);
 			} else {
 				try {
-					await retryWithBackoff(() => fsPromises.rm(entryPath, { force: true }), 5, 10);
+					await fsPromises.rm(entryPath, { force: true });
 				} catch (error) {
 					throw new Error(`Failed to remove entry ${entryPath}`, { cause: error });
 				}
 			}
 		}
 		try {
-			await retryWithBackoff(() => fsPromises.rmdir(dir), 5, 10);
+			await fsPromises.rmdir(dir);
 		} catch (error) {
 			throw new Error(`Failed to remove directory ${dir}`, { cause: error });
 		}