@@ -11,11 +11,13 @@ import {
     languages,
     Range,
     TextDocument,
+    TextDocumentChangeEvent,
 } from 'vscode';
 import { findInlineScriptBlock } from '../../common/inlineScript/block';
 import { getInlineScriptSourceHash, sliceHeaderBytes } from '../../common/inlineScript/metadata';
 import { getInlineScriptRoutingKey, InlineScriptRoutingRegistry } from '../../common/inlineScript/routingRegistry';
 import { InlineScriptStrings } from '../../common/localize';
+import { onDidChangeTextDocument } from '../../common/workspace.apis';
 import { shortenVersionString } from '../../managers/common/utils';
 
 /**
@@ -27,13 +29,15 @@ export class InlineScriptCodeLensProvider implements CodeLensProvider, Disposabl
     private readonly _onDidChangeCodeLenses = new EventEmitter<void>();
     public readonly onDidChangeCodeLenses = this._onDidChangeCodeLenses.event;
     private readonly subscriptions: Disposable[] = [];
+    private readonly liveBlockKeys = new Set<string>();
     private disposed = false;
 
     constructor(
         private readonly routing: InlineScriptRoutingRegistry,
         private readonly setupCommand: string,
     ) {
         this.subscriptions.push(
+            onDidChangeTextDocument((event) => this.handleDocumentChange(event)),
             this.routing.onDidChangeRouteability(() => this._onDidChangeCodeLenses.fire()),
             this.routing.onDidChangeAvailability(() => this._onDidChangeCodeLenses.fire()),
             this.routing.onDidChangeEnvironmentVersion(() => this._onDidChangeCodeLenses.fire()),
@@ -47,14 +51,17 @@ export class InlineScriptCodeLensProvider implements CodeLensProvider, Disposabl
 
     public provideCodeLenses(document: TextDocument, _token: CancellationToken): CodeLens[] {
         const uri = document.uri;
-        if (this.disposed || !getInlineScriptRoutingKey(uri)) {
+        const routingKey = getInlineScriptRoutingKey(uri);
+        if (this.disposed || !routingKey) {
             return [];
         }
         const header = sliceHeaderBytes(document.getText());
         const block = findInlineScriptBlock(header);
         if (!block) {
+            this.liveBlockKeys.delete(routingKey);
             return [];
         }
+        this.liveBlockKeys.add(routingKey);
         const position = document.positionAt(block.start);
         const range = new Range(position, position);
         const savedHash = this.routing.getMetadata(uri)?.sourceHash;
@@ -82,10 +89,45 @@ export class InlineScriptCodeLensProvider implements CodeLensProvider, Disposabl
         ];
     }
 
+    private handleDocumentChange(event: TextDocumentChangeEvent): void {
+        if (this.disposed || event.contentChanges.length === 0) {
+            return;
+        }
+        const uri = event.document.uri;
+        const routingKey = getInlineScriptRoutingKey(uri);
+        if (!routingKey) {
+            return;
+        }
+
+        const header = sliceHeaderBytes(event.document.getText());
+        const block = findInlineScriptBlock(header);
+        const hadLiveBlock = this.liveBlockKeys.has(routingKey);
+        if (block) {
+            this.liveBlockKeys.add(routingKey);
+        } else {
+            this.liveBlockKeys.delete(routingKey);
+        }
+
+        if (hadLiveBlock !== !!block) {
+            this._onDidChangeCodeLenses.fire();
+            return;
+        }
+
+        const savedMetadata = this.routing.getMetadata(uri);
+        const blockEnd = block?.end ?? savedMetadata?.sourceRange?.end ?? savedMetadata?.range.end;
+        if (
+            blockEnd !== undefined &&
+            event.contentChanges.some((change) => change.rangeOffset < blockEnd)
+        ) {
+            this._onDidChangeCodeLenses.fire();
+        }
+    }
+
     public dispose(): void {
         this.disposed = true;
         this.subscriptions.forEach((s) => s.dispose());
         this.subscriptions.length = 0;
+        this.liveBlockKeys.clear();
         this._onDidChangeCodeLenses.dispose();
     }
 }
 
@@ -40,7 +40,7 @@ export const SETUP_INLINE_SCRIPT_ENV_COMMAND = 'python-envs.setupInlineScriptEnv
  */
 export const SETUP_INLINE_SCRIPT_ENVS_COMMAND = 'python-envs.setupInlineScriptEnvs';
 
-/** Upper bound on the number of `.py` files the bulk command scans. */
+/** Upper bound on the number of Python files the bulk command scans. */
 const MAX_INLINE_SCRIPT_FILES = 1000;
 
 /** How many candidate files' PEP 723 headers are read concurrently during the bulk scan. */
@@ -277,7 +277,11 @@ export async function setUpInlineScriptEnvironmentsInWorkspace(
         showErrorMessage(l10n.t('The inline script environment manager is not available yet. Try again shortly.'));
         return;
     }
-    const files = await findFiles('**/*.py', '{**/.venv/**,**/node_modules/**}', MAX_INLINE_SCRIPT_FILES);
+    const files = await findFiles(
+        '**/*.{py,Py,pY,PY}',
+        '{**/.venv/**,**/node_modules/**}',
+        MAX_INLINE_SCRIPT_FILES,
+    );
     if (!files || files.length === 0) {
         showInformationMessage(l10n.t('No Python files were found in the workspace.'));
         return;
 
@@ -4,9 +4,15 @@
 import assert from 'assert';
 import * as path from 'path';
 import * as sinon from 'sinon';
-import { Uri } from 'vscode';
+import {
+    Disposable,
+    TextDocumentChangeEvent,
+    TextDocumentContentChangeEvent,
+    Uri,
+} from 'vscode';
 import { MAX_HEADER_BYTES, readInlineScriptMetadata } from '../../../common/inlineScript/metadata';
 import { InlineScriptRoutingRegistry } from '../../../common/inlineScript/routingRegistry';
+import * as wapi from '../../../common/workspace.apis';
 import { InlineScriptCodeLensProvider } from '../../../features/inlineScript/codeLens';
 import { MockDocument } from '../../mocks/mockDocument';
 
@@ -17,8 +23,16 @@ suite('Inline script CodeLens provider', () => {
     const scriptUri = Uri.file(path.join(process.cwd(), 'lens-tests', 'app.py'));
     let routing: InlineScriptRoutingRegistry;
     let provider: InlineScriptCodeLensProvider;
+    let changeListener: ((event: TextDocumentChangeEvent) => void) | undefined;
 
     setup(() => {
+        changeListener = undefined;
+        sinon.stub(wapi, 'onDidChangeTextDocument').callsFake((listener) => {
+            changeListener = listener;
+            return new Disposable(() => {
+                changeListener = undefined;
+            });
+        });
         routing = new InlineScriptRoutingRegistry();
         provider = new InlineScriptCodeLensProvider(routing, SETUP_COMMAND);
     });
@@ -49,10 +63,79 @@ suite('Inline script CodeLens provider', () => {
         return lenses[0];
     }
 
+    function fireChange(
+        text: string,
+        rangeOffset: number,
+        rangeLength: number,
+        insertedText: string,
+        uri = scriptUri,
+    ): void {
+        assert.ok(changeListener, 'document change listener should be registered');
+        const contentChange: TextDocumentContentChangeEvent = {
+            range: undefined as never,
+            rangeOffset,
+            rangeLength,
+            text: insertedText,
+        };
+        changeListener({
+            document: document(text, true, uri),
+            contentChanges: [contentChange],
+            reason: undefined,
+        });
+    }
+
     test('does not decorate ordinary Python files', () => {
         assert.deepStrictEqual(provider.provideCodeLenses(document('print("hello")'), {} as never), []);
     });
 
+    test('refreshes when a dirty ordinary file gains its first script block', () => {
+        assert.deepStrictEqual(provider.provideCodeLenses(document('print("hello")'), {} as never), []);
+        const changed = sinon.spy();
+        provider.onDidChangeCodeLenses(changed);
+
+        fireChange(SCRIPT, 0, 0, SCRIPT);
+
+        sinon.assert.calledOnce(changed);
+        assert.strictEqual(lens(SCRIPT, true).command?.command, SETUP_COMMAND);
+    });
+
+    test('refreshes when dirty inline metadata changes before routing catches up', () => {
+        ready();
+        assert.strictEqual(lens().command?.command, '');
+        const changed = sinon.spy();
+        provider.onDidChangeCodeLenses(changed);
+        const edited = SCRIPT.replace('requests', 'httpx');
+
+        fireChange(edited, SCRIPT.indexOf('requests'), 'requests'.length, 'httpx');
+
+        sinon.assert.calledOnce(changed);
+        assert.strictEqual(lens(edited, true).command?.command, SETUP_COMMAND);
+    });
+
+    test('does not refresh for a body-only edit after the inline block', () => {
+        ready();
+        assert.strictEqual(lens().command?.command, '');
+        const changed = sinon.spy();
+        provider.onDidChangeCodeLenses(changed);
+        const edited = SCRIPT.replace('hello', 'changed body');
+
+        fireChange(edited, SCRIPT.indexOf('hello'), 'hello'.length, 'changed body');
+
+        sinon.assert.notCalled(changed);
+    });
+
+    test('refreshes when a dirty script block is removed', () => {
+        assert.strictEqual(lens(SCRIPT, true).command?.command, SETUP_COMMAND);
+        const changed = sinon.spy();
+        provider.onDidChangeCodeLenses(changed);
+        const plain = 'print("hello")\n';
+
+        fireChange(plain, 0, SCRIPT.length, plain);
+
+        sinon.assert.calledOnce(changed);
+        assert.deepStrictEqual(provider.provideCodeLenses(document(plain, true), {} as never), []);
+    });
+
     test('offers setup for a newly typed block before detection or saving', () => {
         const result = lens(SCRIPT, true);
         assert.strictEqual(result.command?.command, SETUP_COMMAND);
 
@@ -4,7 +4,7 @@
 import assert from 'assert';
 import * as sinon from 'sinon';
 import * as typemoq from 'typemoq';
-import { Uri } from 'vscode';
+import { Disposable, Uri } from 'vscode';
 import { PythonEnvironment } from '../../../api';
 import { INLINE_SCRIPT_MANAGER_ID } from '../../../common/constants';
 import { InlineScriptMetadata } from '../../../common/inlineScript/metadata';
@@ -217,6 +217,19 @@ suite('setUpInlineScriptEnvironmentsInWorkspace', () => {
         manager.verify((m) => m.create(typemoq.It.isAny(), typemoq.It.isAny()), typemoq.Times.never());
     });
 
+    test('searches for Python file extensions case-insensitively', async () => {
+        findFilesStub.resolves([]);
+
+        await setUpInlineScriptEnvironmentsInWorkspace(em.object, routing);
+
+        sinon.assert.calledOnceWithExactly(
+            findFilesStub,
+            '**/*.{py,Py,pY,PY}',
+            '{**/.venv/**,**/node_modules/**}',
+            1000,
+        );
+    });
+
     test('only sets up the selected files that declare inline metadata', async () => {
         findFilesStub.resolves([withMeta, withoutMeta]);
         readMetadataStub.callsFake(async (uri: Uri) =>
@@ -543,6 +556,7 @@ suite('setupInlineScriptEnvironmentHandler', () => {
         sinon.assert.notCalled(saveStub);
         assert.deepStrictEqual(routing.getMetadata(scriptUri), metadata);
         assert.strictEqual(routing.shouldRoute(scriptUri), true);
+        sinon.stub(wapi, 'onDidChangeTextDocument').returns(new Disposable(() => undefined));
         const provider = new InlineScriptCodeLensProvider(routing, 'setup');
         try {
             const document = new MockDocument(currentText, scriptUri.fsPath, async () => true);
 
@@ -7,22 +7,21 @@ import * as path from 'path';
 import * as vscode from 'vscode';
 import { readInlineScriptMetadata } from '../../common/inlineScript/metadata';
 import { InlineScriptRoutingRegistry } from '../../common/inlineScript/routingRegistry';
-import { registerInlineScriptCodeLens } from '../../features/inlineScript/codeLens';
+import { InlineScriptCodeLensProvider, registerInlineScriptCodeLens } from '../../features/inlineScript/codeLens';
 import { registerInlineScriptDiagnostics } from '../../features/inlineScript/diagnostics';
 import { InlineScriptLazyDetector } from '../../features/inlineScript/lazyDetector';
 import { sleep, waitForCondition } from '../testUtils';
 
 const SETUP_COMMAND = 'python-envs.test.inlineScriptLensSetup';
 const SCRIPT = '# /// script\n# dependencies = []\n# ///\n\nprint("hello")\n';
 
-// TODO: Re-enable on Windows after https://github.com/microsoft/vscode-python-environments/issues/1911.
-const inlineScriptCodeLensSuite = process.platform === 'win32' ? suite.skip : suite;
-inlineScriptCodeLensSuite('Integration: Live inline script CodeLens', function () {
+suite('Integration: Live inline script CodeLens', function () {
     this.timeout(30_000);
 
     let root: string;
     let document: vscode.TextDocument;
     let routing: InlineScriptRoutingRegistry;
+    let provider: InlineScriptCodeLensProvider;
     let registration: vscode.Disposable;
     let diagnostics: vscode.Disposable;
     let detector: InlineScriptLazyDetector;
@@ -36,7 +35,9 @@ inlineScriptCodeLensSuite('Integration: Live inline script CodeLens', function (
 
     setup(async () => {
         routing = new InlineScriptRoutingRegistry();
-        registration = registerInlineScriptCodeLens(routing, SETUP_COMMAND).disposable;
+        const codeLens = registerInlineScriptCodeLens(routing, SETUP_COMMAND);
+        provider = codeLens.provider;
+        registration = codeLens.disposable;
         diagnostics = registerInlineScriptDiagnostics();
         detector = new InlineScriptLazyDetector(routing);
         detector.activate();
@@ -90,6 +91,19 @@ inlineScriptCodeLensSuite('Integration: Live inline script CodeLens', function (
         assert.strictEqual(await vscode.workspace.applyEdit(edit), true);
     }
 
+    async function replaceAndWaitForLensRefresh(text: string): Promise<void> {
+        let refreshed = false;
+        const subscription = provider.onDidChangeCodeLenses(() => {
+            refreshed = true;
+        });
+        try {
+            await replace(text);
+            await waitForCondition(() => refreshed, 5_000, 'The CodeLens provider should refresh after the edit');
+        } finally {
+            subscription.dispose();
+        }
+    }
+
     function validateSavedEnvironment(version = '3.12.4'): void {
         const metadata = readInlineScriptMetadata(document.getText());
         assert.ok(metadata);
@@ -137,14 +151,24 @@ inlineScriptCodeLensSuite('Integration: Live inline script CodeLens', function (
         await replace(SCRIPT.replace('hello', 'dirty body'));
         assert.strictEqual(document.isDirty, true);
         assert.strictEqual((await lenses())[0]?.command?.command, '');
-        await replace(SCRIPT.replace('[]', '["requests"]'));
+        await replaceAndWaitForLensRefresh(SCRIPT.replace('[]', '["requests"]'));
         assert.strictEqual((await lenses())[0]?.command?.command, SETUP_COMMAND);
         assert.strictEqual(routing.shouldRoute(document.uri), false, 'the detector must still invalidate changed headers');
         await replace(SCRIPT);
         assert.strictEqual((await lenses())[0]?.command?.command, '');
         assert.strictEqual(routing.shouldRoute(document.uri), true, 'Undo must restore the validated route');
     });
 
+    test('a dirty ordinary file gains its setup lens without being saved', async () => {
+        await replace('print("ordinary Python")\n');
+        assert.deepStrictEqual(await lenses(), []);
+
+        await replaceAndWaitForLensRefresh(SCRIPT);
+
+        assert.strictEqual(document.isDirty, true);
+        assert.strictEqual((await lenses())[0]?.command?.command, SETUP_COMMAND);
+    });
+
     test('restored associations show the version and availability changes switch the label', async () => {
         validateSavedEnvironment('3.13.2');
         registration.dispose();
 
@@ -240,6 +240,7 @@ suite('InlineScriptEnvManager', () => {
                     renameFilesListener = undefined;
                 });
             });
+        sinon.stub(workspaceApis, 'onDidChangeTextDocument').returns(new Disposable(() => undefined));
         openDocumentsStub = sinon.stub(workspaceApis, 'getOpenTextDocuments').returns([]);
         createWithProgressStub = sinon.stub(venvUtils, 'createWithProgress').callsFake(async (...args: unknown[]) => {
             const envDir = args[6] as string;