Preserve referenced environments from TTL eviction

TTL eviction ranked entries only by the sidecar lastUsedAt, which is refreshed on create/reuse but never when an environment is resolved for run, debug, or Pylance. A stable script's environment could therefore look stale and be evicted (clearing its association) while still in active use. Skip eviction of any cache entry a script association still references, so the sweep reclaims only orphaned entries (superseded by a dependency change, or left by a deleted/deselected script).

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

Author: StellaHuang95

src/managers/builtin/inlineScript/envManager.ts

@@ -2933,8 +2933,19 @@ export class InlineScriptEnvManager implements EnvironmentManager, Disposable {
         const persistedAssociations = await this.getPersistedAssociationSnapshot();
         const scriptPaths = this.getTrackedScriptPaths(persistedAssociations);
         const priorSelections = this.getPriorSelections(scriptPaths);
+        // Never evict an environment that a script association still points to. `lastUsedAt` is only
+        // refreshed when an environment is created or reused (never when it is resolved for run, debug,
+        // or Pylance), so an actively-used environment can look stale here. Reclaim only orphaned entries
+        // (e.g. superseded by a dependency change, or left behind by a deleted or deselected script).
+        const referencedEnvDirs = this.getReferencedCacheEntryDirs(persistedAssociations, scriptPaths);
+        const evictableStaleEntries = staleEntries.filter(
+            (staleEntry) => !referencedEnvDirs.has(normalizePath(staleEntry)),
+        );
+        if (evictableStaleEntries.length === 0) {
+            return;
+        }
         const removedCacheEntries = new Set<string>();
-        for (const staleEntry of staleEntries) {
+        for (const staleEntry of evictableStaleEntries) {
             try {
                 const removed = await this.removeCacheEntryForClear(
                     cacheRoot,
@@ -3323,6 +3334,26 @@ export class InlineScriptEnvManager implements EnvironmentManager, Disposable {
         return fs.remove(entryPath);
     }
 
+    private getReferencedCacheEntryDirs(
+        persistedAssociations: PersistedInlineScriptEnvironments,
+        scriptPaths: ReadonlySet<string>,
+    ): Set<string> {
+        const referenced = new Set<string>();
+        for (const scriptPath of scriptPaths) {
+            const environmentPaths = [
+                persistedAssociations[scriptPath]?.environmentPath,
+                this.fsPathToPersistedAssociation.get(scriptPath)?.environmentPath,
+                this.fsPathToEnv.get(scriptPath)?.environmentPath.fsPath,
+            ].filter((value): value is string => value !== undefined);
+            for (const environmentPath of environmentPaths) {
+                // Mirror isRemovedOrMissingCacheAssociation: the cache-entry dir is two levels above the
+                // interpreter executable (e.g. <envDir>/bin/python -> <envDir>).
+                referenced.add(normalizePath(path.dirname(path.dirname(environmentPath))));
+            }
+        }
+        return referenced;
+    }
+
     private async getInvalidatedAssociationPaths(
         scriptPaths: ReadonlySet<string>,
         persistedAssociations: PersistedInlineScriptEnvironments,

src/test/managers/builtin/inlineScript/envManager.unit.test.ts

@@ -5803,35 +5803,41 @@ suite('InlineScriptEnvManager', () => {
             assert.strictEqual(await fs.pathExists(stale.sysPrefix), true);
         });
 
-        test('invalidates associations and discovered environments for deleted entries', async () => {
-            const uri = scriptUri('associated.py');
+        test('removes discovered environments for evicted orphaned entries', async () => {
             const stale = await createOwnedEnvironment('aaaaaaaaaaaaaaaa');
             await setLastUsedAt(stale, new Date(NOW.getTime() - TTL_MS - 1));
-            await manager.set(uri, stale);
             (manager as unknown as { collection: PythonEnvironment[] }).collection = [stale];
-            const selectionListener = sinon.spy();
             const collectionListener = sinon.spy();
-            manager.onDidChangeEnvironment(selectionListener);
             manager.onDidChangeEnvironments(collectionListener);
 
             assert.ok(await manager.create(scriptUri('trigger.py')));
 
-            assert.strictEqual(await manager.get(uri), undefined);
-            assert.strictEqual(persistedAssociations, undefined);
+            assert.strictEqual(await fs.pathExists(stale.sysPrefix), false);
             assert.deepStrictEqual(await manager.getEnvironments('all'), []);
-            sinon.assert.calledOnce(selectionListener);
-            assert.strictEqual(
-                normalizePath(selectionListener.firstCall.args[0].uri.fsPath),
-                normalizePath(uri.fsPath),
-            );
-            assert.strictEqual(selectionListener.firstCall.args[0].old, stale);
-            assert.strictEqual(selectionListener.firstCall.args[0].new, undefined);
             sinon.assert.calledOnceWithExactly(collectionListener, [
                 { kind: EnvironmentChangeKind.remove, environment: stale },
             ]);
         });
 
-        test('invalidates an association when another host removes the stale entry first', async () => {
+        test('preserves a stale entry and its association while a script still references it', async () => {
+            const uri = scriptUri('associated.py');
+            const stale = await createOwnedEnvironment('aaaaaaaaaaaaaaaa');
+            await setLastUsedAt(stale, new Date(NOW.getTime() - TTL_MS - 1));
+            await manager.set(uri, stale);
+            (manager as unknown as { collection: PythonEnvironment[] }).collection = [stale];
+            const selectionListener = sinon.spy();
+            manager.onDidChangeEnvironment(selectionListener);
+
+            assert.ok(await manager.create(scriptUri('trigger.py')));
+
+            assert.strictEqual(await fs.pathExists(stale.sysPrefix), true);
+            assert.strictEqual(await manager.get(uri), stale);
+            assert.notStrictEqual(persistedAssociations, undefined);
+            assert.ok((await manager.getEnvironments('all')).some((env) => env === stale));
+            sinon.assert.notCalled(selectionListener);
+        });
+
+        test('does not attempt to remove a stale entry that a script still references', async () => {
             const uri = scriptUri('associated.py');
             const stale = await createOwnedEnvironment('aaaaaaaaaaaaaaaa');
             await setLastUsedAt(stale, new Date(NOW.getTime() - TTL_MS - 1));
@@ -5847,15 +5853,14 @@ suite('InlineScriptEnvManager', () => {
                     },
                 ): Promise<string | undefined>;
             };
-            sinon.stub(internalManager, 'removeCacheEntryForClear').callsFake(async () => {
-                await fs.remove(stale.sysPrefix);
-                return undefined;
-            });
+            const removeSpy = sinon.spy(internalManager, 'removeCacheEntryForClear');
 
             assert.ok(await manager.create(scriptUri('trigger.py')));
 
-            assert.strictEqual(persistedAssociations, undefined);
-            assert.strictEqual(await manager.get(uri), undefined);
+            sinon.assert.notCalled(removeSpy);
+            assert.strictEqual(await fs.pathExists(stale.sysPrefix), true);
+            assert.strictEqual(await manager.get(uri), stale);
+            assert.notStrictEqual(persistedAssociations, undefined);
         });
 
         test('does not let an in-flight refresh re-add an evicted environment', async () => {
@@ -5913,14 +5918,19 @@ suite('InlineScriptEnvManager', () => {
         });
 
         test('does not fail creation when association cleanup cannot be persisted', async () => {
-            const uri = scriptUri('associated.py');
-            const stale = await createOwnedEnvironment('aaaaaaaaaaaaaaaa');
-            await setLastUsedAt(stale, new Date(NOW.getTime() - TTL_MS - 1));
-            await manager.set(uri, stale);
+            const orphan = await createOwnedEnvironment('aaaaaaaaaaaaaaaa');
+            await setLastUsedAt(orphan, new Date(NOW.getTime() - TTL_MS - 1));
+            // A separate association whose environment was deleted out from under us. Evicting the
+            // orphaned entry above drives the association cleanup pass, and persisting that cleanup is
+            // what fails here.
+            const missingUri = scriptUri('missing.py');
+            const missing = await createOwnedEnvironment('bbbbbbbbbbbbbbbb');
+            await manager.set(missingUri, missing);
+            await fs.remove(missing.sysPrefix);
             workspaceState.update.onSecondCall().rejects(new Error('Memento unavailable'));
 
             assert.ok(await manager.create(scriptUri('trigger.py')));
-            assert.strictEqual(await fs.pathExists(stale.sysPrefix), false);
+            assert.strictEqual(await fs.pathExists(orphan.sysPrefix), false);
         });
     });