diff --git a/docs/API-Reference/language/CodeInspection.md b/docs/API-Reference/language/CodeInspection.md
index e73b770a91..49c0e9d862 100644
--- a/docs/API-Reference/language/CodeInspection.md
+++ b/docs/API-Reference/language/CodeInspection.md
@@ -164,6 +164,7 @@ Each error object in the results should have the following structure:
                type:?Type ,
                fix: { // an optional fix, if present will show the fix button
                     replaceText: "text to replace the offset given below",
+                    title: "optional tooltip describing what the fix does",
                     rangeOffset: {
                         start: number,
                         end: number
@@ -195,6 +196,7 @@ Each error object in the results should have the following structure:
 | type | [<code>Type</code>](#Type) | The type of the error. Defaults to `Type.WARNING` if unspecified. |
 | fix | <code>Object</code> | An optional fix object. |
 | fix.replaceText | <code>string</code> | The text to replace the error with. |
+| fix.title | <code>string</code> | Optional tooltip on the Fix button describing what the fix does. |
 | fix.rangeOffset | <code>Object</code> | The range within the text to replace. |
 | fix.rangeOffset.start | <code>number</code> | The start offset of the range. |
 | fix.rangeOffset.end | <code>number</code> | The end offset of the range. If no errors are found, return either `null`(treated as file is problem free) or an object with a zero-length `errors` array. Always use `message` to safely display the error as text. If you want to display HTML error message, then explicitly use `htmlMessage` to display it. Both `message` and `htmlMessage` can be used simultaneously. After scanning the file, if you need to omit the lint result, return or resolve with `{isIgnored: true}`. This prevents the file from being marked with a no errors tick mark in the status bar and excludes the linter from the problems panel. |
diff --git a/docs/API-Reference/utils/NodeUtils.md b/docs/API-Reference/utils/NodeUtils.md
index 9243e256a3..e9a44eb11d 100644
--- a/docs/API-Reference/utils/NodeUtils.md
+++ b/docs/API-Reference/utils/NodeUtils.md
@@ -56,6 +56,72 @@ This is only available in the native app.
 | url | <code>string</code> | 
 | browserName | <code>string</code> | 
 
+<a name="downloadFile"></a>
+
+## downloadFile(url, destFile, [options]) ⇒ <code>Promise.&lt;void&gt;</code>
+Downloads a URL to a file on disk, fully node-side (native fetch, streamed to disk).
+When an expected sha256 is given, a mismatch deletes the file and rejects - a resolved
+promise means the file holds exactly the pinned bytes.
+This is only available in the native app.
+
+**Kind**: global function  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| url | <code>string</code> | download URL (redirects followed) |
+| destFile | <code>string</code> | platform path to write (parent directories created) |
+| [options] | <code>Object</code> |  |
+| [options.sha256] | <code>string</code> | expected hex digest of the downloaded bytes |
+| [options.progress] | <code>function</code> | called with (transferredBytes,        totalBytes) as the download advances; totalBytes is 0 if the server sent no length |
+
+<a name="extractZipFile"></a>
+
+## extractZipFile(zipPath, destDir) ⇒ <code>Promise.&lt;void&gt;</code>
+Extracts a zip file into a directory node-side (stdlib only, no browser JSZip; creates the
+directory if missing, restores unix executable bits recorded in the archive). Python wheels
+are plain zips, so this installs those too.
+This is only available in the native app.
+
+**Kind**: global function  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| zipPath | <code>string</code> | platform path of the zip file |
+| destDir | <code>string</code> | platform path of the directory to extract into |
+
+<a name="setExecutableBits"></a>
+
+## setExecutableBits(filePath) ⇒ <code>Promise.&lt;void&gt;</code>
+Marks a file as executable (chmod 755); no-op on Windows. For binaries whose archives did
+not carry unix mode bits.
+This is only available in the native app.
+
+**Kind**: global function  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| filePath | <code>string</code> | platform path of the file |
+
+<a name="execFileWithInput"></a>
+
+## execFileWithInput(command, [args], [options]) ⇒ <code>Promise.&lt;{code: number, stdout: string, stderr: string}&gt;</code>
+Runs an executable with the given args, feeding it text on stdin and capturing its output -
+a one-shot filter-style invocation (e.g. `ruff format -` for the Python beautifier). No
+shell is involved. Resolves with the exit code rather than rejecting on non-zero, so
+callers can read stderr for the reason.
+This is only available in the native app.
+
+**Kind**: global function  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| command | <code>string</code> | platform path of the executable (or a PATH command name) |
+| [args] | <code>Array.&lt;string&gt;</code> |  |
+| [options] | <code>Object</code> |  |
+| [options.stdinText] | <code>string</code> | written to the process's stdin, then closed |
+| [options.cwd] | <code>string</code> | working directory |
+| [options.timeoutMs] | <code>number</code> | kill the process and reject after this long |
+
 <a name="getEnvironmentVariable"></a>
 
 ## getEnvironmentVariable(varName) ⇒ <code>Promise.&lt;string&gt;</code>
diff --git a/gulpfile.js/index.js b/gulpfile.js/index.js
index 961ea91419..81e69f8430 100644
--- a/gulpfile.js/index.js
+++ b/gulpfile.js/index.js
@@ -909,8 +909,8 @@ function _renameExtensionConcatAsExtensionJSInDist(extensionName) {
 }
 
 const minifyableExtensions = ["CloseOthers", "CodeFolding", "DebugCommands", "Git",
-    "HealthData", "JavaScriptCodeHints", "JavaScriptRefactoring", "PHPSupport", "QuickView",
-    "TypeScriptSupport"];
+    "HealthData", "JavaScriptCodeHints", "JavaScriptRefactoring", "PHPSupport", "PythonSupport",
+    "QuickView", "TypeScriptSupport"];
 // extensions that nned not be minified either coz they are single file extensions or some other reason.
 const nonMinifyExtensions = ["CSSAtRuleCodeHints", "CSSCodeHints",
     "CSSPseudoSelectorHints", "DarkTheme", "DocCommentHints", "HandlebarsSupport", "HTMLCodeHints",
diff --git a/src-node/lsp-client.js b/src-node/lsp-client.js
index 0bbfd0bdce..1d3724632e 100644
--- a/src-node/lsp-client.js
+++ b/src-node/lsp-client.js
@@ -153,10 +153,37 @@ function handleMessage(serverId, msg) {
     }
 }
 
+/**
+ * Resolve a workspace/configuration item's dotted section (e.g. "python" or "python.pyrefly")
+ * inside a server's registered workspaceConfiguration object. Returns null when any path
+ * segment is missing - the spec's "no config" answer.
+ * @param {?Object} config - the server's workspaceConfiguration (may be undefined)
+ * @param {?string} section - the requested section; no section means the whole object
+ * @return {*}
+ */
+function _lookupConfigSection(config, section) {
+    if (!config) {
+        return null;
+    }
+    if (!section) {
+        return config;
+    }
+    let value = config;
+    for (const part of section.split('.')) {
+        if (value === null || typeof value !== 'object' || !(part in value)) {
+            return null;
+        }
+        value = value[part];
+    }
+    return value;
+}
+
 /**
  * Answer a server-initiated request with a benign, spec-shaped reply. We advertise minimal client
  * capabilities (no dynamic registration, workspace.configuration=false), so servers should rarely
  * send these - this is the safety net that guarantees no server hangs awaiting a reply.
+ * Servers that pull configuration regardless (e.g. pyrefly) get the workspaceConfiguration
+ * object registered at startServer; anything else gets the spec's null "no config".
  * @param {string} serverId - The server identifier (for logging)
  * @param {Object} server - The server state object
  * @param {Object} msg - The incoming JSON-RPC request (method + id)
@@ -168,7 +195,8 @@ function _respondToServerRequest(serverId, server, msg) {
         // Result must be an array matching params.items length; null entries mean "no config".
         response = {
             jsonrpc: '2.0', id: msg.id,
-            result: ((msg.params && msg.params.items) || []).map(() => null)
+            result: ((msg.params && msg.params.items) || []).map(
+                item => _lookupConfigSection(server.workspaceConfiguration, item && item.section))
         };
         break;
     case 'client/registerCapability':
@@ -205,10 +233,13 @@ exports.ping = async function ping() {
  * @param {string} params.command - Command used to spawn the language server
  * @param {string[]} [params.args=['--stdio']] - Arguments for the command
  * @param {string} params.rootUri - Root URI of the workspace
+ * @param {Object} [params.workspaceConfiguration] - settings tree served to the server's
+ *        workspace/configuration pulls (sections resolved by dotted path); pulls answer null
+ *        without it
  * @returns {Promise<Object>} Result with success status and server info
  */
 exports.startServer = async function startServer(params) {
-    const { serverId, command, args = ['--stdio'], rootUri } = params;
+    const { serverId, command, args = ['--stdio'], rootUri, workspaceConfiguration } = params;
 
     if (!serverId || !command) {
         throw new Error('serverId and command are required');
@@ -224,7 +255,9 @@ exports.startServer = async function startServer(params) {
     //    same spawn-self pattern _npmInstallInFolder and the ESLint service use. This sidesteps
     //    node_modules/.bin shims entirely (they are sh scripts / .cmd on Windows).
     // 2. A server bundled in src-node/node_modules/.bin.
-    // 3. Fall back to PATH.
+    // 3. Fall back to spawning the command as given - which also covers an absolute path to a
+    //    native binary (e.g. a user-installed server like pyrefly), spawned as-is, or a PATH
+    //    lookup for a bare command name.
     let commandPath = command;
     let spawnArgs = args;
     if (path.isAbsolute(command) && command.endsWith('.js')) {
@@ -245,6 +278,7 @@ exports.startServer = async function startServer(params) {
             process: serverProcess,
             pending: new Map(),
             rootUri,
+            workspaceConfiguration,
             stderrTail: [] // keep the last few stderr lines to attach to crash reports
         };
 
diff --git a/src-node/utils.js b/src-node/utils.js
index d2e4525edc..005f166427 100644
--- a/src-node/utils.js
+++ b/src-node/utils.js
@@ -1,9 +1,11 @@
 const NodeConnector = require("./node-connector");
-const { exec, execFile } = require('child_process');
+const { exec, execFile, spawn } = require('child_process');
 const fs = require('fs');
 const fsPromise = require('fs').promises;
 const path = require('path');
 const os = require('os');
+const crypto = require('crypto');
+const zlib = require('zlib');
 const { SYSTEM_SETTINGS_DIR } = require('./constants');
 const { lintFile } = require("./ESLint/service");
 const { addDeviceLicense, getDeviceID, isLicensedDevice, removeDeviceLicense } = require("./licence-device");
@@ -18,7 +20,7 @@ async function _importOpen() {
 }
 
 const UTILS_NODE_CONNECTOR = "ph_utils";
-NodeConnector.createNodeConnector(UTILS_NODE_CONNECTOR, exports);
+const utilsConnector = NodeConnector.createNodeConnector(UTILS_NODE_CONNECTOR, exports);
 
 async function getURLContent({url, options}) {
     options = options || {
@@ -149,6 +151,213 @@ async function _npmInstallInFolder({moduleNativeDir}) {
     });
 }
 
+// no dot in the name - EventDispatcher treats anything after a "." as a listener namespace
+const DOWNLOAD_PROGRESS_EVENT = "downloadProgress";
+
+/**
+ * Downloads a URL to a file on disk with node's native fetch (redirects followed), streaming
+ * `downloadProgress` events carrying {url, transferred, total} to the browser side. When an
+ * expected sha256 hex digest is given, a mismatch deletes the file and rejects - so a resolved
+ * promise means the file on disk is exactly the bytes the caller pinned.
+ *
+ * @param {string} url - download URL
+ * @param {string} destFile - platform path to write (parent directories created)
+ * @param {string} [sha256] - expected hex digest of the downloaded bytes
+ * @return {Promise<void>}
+ */
+async function downloadFile({url, destFile, sha256}) {
+    const response = await fetch(url, { redirect: "follow" });
+    if (!response.ok) {
+        throw new Error("Download failed with HTTP " + response.status + " for " + url);
+    }
+    const total = parseInt(response.headers.get("content-length"), 10) || 0;
+    await fsPromise.mkdir(path.dirname(destFile), { recursive: true });
+    const fileHandle = await fsPromise.open(destFile, "w");
+    const hash = crypto.createHash("sha256");
+    let transferred = 0;
+    let lastReported = 0;
+    try {
+        for await (const chunk of response.body) {
+            await fileHandle.write(chunk);
+            hash.update(chunk);
+            transferred += chunk.length;
+            // throttle the websocket chatter: one event per 256KB is plenty for a progress bar
+            if (transferred - lastReported > 262144 || transferred === total) {
+                lastReported = transferred;
+                utilsConnector.triggerPeer(DOWNLOAD_PROGRESS_EVENT, {url, transferred, total});
+            }
+        }
+    } finally {
+        await fileHandle.close();
+    }
+    if (sha256) {
+        const actual = hash.digest("hex");
+        if (actual !== sha256.toLowerCase()) {
+            await fsPromise.unlink(destFile).catch(() => {});
+            throw new Error("sha256 mismatch for " + url + " - expected " + sha256 + " got " + actual);
+        }
+    }
+}
+
+/*
+ * Minimal zip extraction on the node stdlib alone (zlib) - no external dependencies. Written for
+ * installing language-server archives (e.g. Python wheels, which are plain zips): supports the
+ * stored and deflate methods, restores unix executable bits from the central-directory external
+ * attributes, and refuses path traversal. Does NOT support zip64, encryption or other exotic
+ * compression methods - fine for our curated downloads, not a general-purpose unzipper.
+ */
+/* eslint-disable no-bitwise -- zip header parsing is inherently bit-twiddling */
+
+const EOCD_SIG = 0x06054b50;   // end of central directory
+const CEN_SIG = 0x02014b50;    // central directory entry
+const ZIP64_MARKER = 0xffffffff;
+
+function _findEndOfCentralDirectory(buf) {
+    // EOCD is at the very end, possibly followed by a comment of up to 65535 bytes
+    const earliest = Math.max(0, buf.length - 22 - 65535);
+    for (let i = buf.length - 22; i >= earliest; i--) {
+        if (buf.readUInt32LE(i) === EOCD_SIG) {
+            return i;
+        }
+    }
+    throw new Error("Not a zip file: end of central directory not found");
+}
+
+// Extracts a zip held in a Buffer to destDir, creating directories as needed. Entries whose
+// unix mode carries any execute bit are chmod 755 after writing (except on Windows).
+async function _extractZipBuffer(buf, destDir) {
+    const eocd = _findEndOfCentralDirectory(buf);
+    const entryCount = buf.readUInt16LE(eocd + 10);
+    let offset = buf.readUInt32LE(eocd + 16);
+    const destRoot = path.resolve(destDir);
+    await fsPromise.mkdir(destRoot, { recursive: true });
+    for (let i = 0; i < entryCount; i++) {
+        if (offset + 46 > buf.length || buf.readUInt32LE(offset) !== CEN_SIG) {
+            throw new Error("zip central directory corrupt");
+        }
+        const method = buf.readUInt16LE(offset + 10);
+        const compressedSize = buf.readUInt32LE(offset + 20);
+        const nameLen = buf.readUInt16LE(offset + 28);
+        const extraLen = buf.readUInt16LE(offset + 30);
+        const commentLen = buf.readUInt16LE(offset + 32);
+        const externalAttrs = buf.readUInt32LE(offset + 38);
+        const localOffset = buf.readUInt32LE(offset + 42);
+        const name = buf.toString('utf8', offset + 46, offset + 46 + nameLen);
+        offset += 46 + nameLen + extraLen + commentLen;
+
+        if (compressedSize === ZIP64_MARKER || localOffset === ZIP64_MARKER) {
+            throw new Error("zip64 archives are not supported: " + name);
+        }
+        const destPath = path.resolve(destRoot, name);
+        if (destPath !== destRoot && !destPath.startsWith(destRoot + path.sep)) {
+            throw new Error("zip entry escapes destination directory: " + name);
+        }
+        if (name.endsWith("/")) {
+            await fsPromise.mkdir(destPath, { recursive: true });
+            continue;
+        }
+        // data sits after the entry's LOCAL header, whose name/extra lengths can differ from
+        // the central directory's copy - re-read them from the local header itself
+        const locNameLen = buf.readUInt16LE(localOffset + 26);
+        const locExtraLen = buf.readUInt16LE(localOffset + 28);
+        const dataStart = localOffset + 30 + locNameLen + locExtraLen;
+        const raw = buf.subarray(dataStart, dataStart + compressedSize);
+        let data;
+        if (method === 0) {          // stored
+            data = raw;
+        } else if (method === 8) {   // deflate
+            data = zlib.inflateRawSync(raw);
+        } else {
+            throw new Error("unsupported zip compression method " + method + " in " + name);
+        }
+        await fsPromise.mkdir(path.dirname(destPath), { recursive: true });
+        await fsPromise.writeFile(destPath, data);
+        const unixMode = (externalAttrs >>> 16) & 0xFFFF;
+        if ((unixMode & 0o111) && process.platform !== "win32") {
+            await fsPromise.chmod(destPath, 0o755);
+        }
+    }
+}
+/* eslint-enable no-bitwise */
+
+/**
+ * Extracts a zip file into destDir using the stdlib-only extractor above (creates destDir
+ * if missing, restores unix executable bits recorded in the archive). Python wheels are plain
+ * zips, so this also installs those.
+ *
+ * @param {string} zipPath - platform path of the zip file
+ * @param {string} destDir - platform path of the directory to extract into
+ * @return {Promise<void>}
+ */
+async function extractZipFile({zipPath, destDir}) {
+    const buf = await fsPromise.readFile(zipPath);
+    await _extractZipBuffer(buf, destDir);
+}
+
+/**
+ * Runs an executable with the given args, feeding it text on stdin and capturing its output -
+ * a one-shot filter-style invocation (e.g. `ruff format -` for the Python beautifier). No shell
+ * is involved; the command is spawned directly. Resolves with the exit code rather than
+ * rejecting on non-zero, so callers can read stderr for the reason.
+ *
+ * @param {string} command - platform path of the executable (or a PATH command name)
+ * @param {string[]} [args]
+ * @param {string} [stdinText] - written to the process's stdin, which is then closed
+ * @param {string} [cwd] - working directory (e.g. for tools that discover config upward)
+ * @param {number} [timeoutMs] - kill the process and reject after this long
+ * @return {Promise<{code: number, stdout: string, stderr: string}>}
+ */
+async function execFileWithInput({command, args, stdinText, cwd, timeoutMs}) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args || [], { cwd: cwd || undefined, stdio: ['pipe', 'pipe', 'pipe'] });
+        let stdout = "", stderr = "", settled = false;
+        const timer = timeoutMs ? setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                child.kill();
+                reject(new Error("execFileWithInput timed out: " + command));
+            }
+        }, timeoutMs) : null;
+        child.stdout.on('data', (data) => { stdout += data.toString(); });
+        child.stderr.on('data', (data) => { stderr += data.toString(); });
+        child.on('error', (err) => {
+            if (!settled) {
+                settled = true;
+                if (timer) {
+                    clearTimeout(timer);
+                }
+                reject(err);
+            }
+        });
+        child.on('close', (code) => {
+            if (!settled) {
+                settled = true;
+                if (timer) {
+                    clearTimeout(timer);
+                }
+                resolve({ code, stdout, stderr });
+            }
+        });
+        child.stdin.on('error', () => {}); // EPIPE if the process exits before reading stdin
+        child.stdin.write(stdinText || "");
+        child.stdin.end();
+    });
+}
+
+/**
+ * Marks a file as executable (chmod 755). No-op on Windows, where execute permission does not
+ * exist. For binaries whose archives did not carry unix mode bits.
+ *
+ * @param {string} filePath - platform path of the file
+ * @return {Promise<void>}
+ */
+async function setExecutableBits({filePath}) {
+    if (process.platform === "win32") {
+        return;
+    }
+    await fsPromise.chmod(filePath, 0o755);
+}
+
 /**
  * If it's a dir that exists, returns that
  * If it's a file, it returns the parent directory if it exists
@@ -296,3 +505,7 @@ exports.getOSUserName = getOSUserName;
 exports.getSystemSettingsDir = getSystemSettingsDir;
 exports._loadNodeExtensionModule = _loadNodeExtensionModule;
 exports._npmInstallInFolder = _npmInstallInFolder;
+exports.downloadFile = downloadFile;
+exports.extractZipFile = extractZipFile;
+exports.setExecutableBits = setExecutableBits;
+exports.execFileWithInput = execFileWithInput;
diff --git a/src/extensions/default/DefaultExtensions.json b/src/extensions/default/DefaultExtensions.json
index 68032c2994..fc78c3b13b 100644
--- a/src/extensions/default/DefaultExtensions.json
+++ b/src/extensions/default/DefaultExtensions.json
@@ -29,7 +29,8 @@
   "desktopOnly": [
     "Git",
     "TypeScriptSupport",
-    "PHPSupport"
+    "PHPSupport",
+    "PythonSupport"
   ],
  "warnExtensionStoreExtensions": {
    "description": "list extension ids here that you want to show this warning in extension store: 'You may not need this extension. Phoenix comes built in with this feature.'",
diff --git a/src/extensions/default/PHPSupport/ServerInstaller.js b/src/extensions/default/PHPSupport/ServerInstaller.js
index 82bca7b0c2..35227102ab 100644
--- a/src/extensions/default/PHPSupport/ServerInstaller.js
+++ b/src/extensions/default/PHPSupport/ServerInstaller.js
@@ -49,6 +49,8 @@ define(function (require, exports, module) {
         NativeApp = brackets.getModule("utils/NativeApp"),
         ModalBar = brackets.getModule("widgets/ModalBar").ModalBar,
         NotificationUI = brackets.getModule("widgets/NotificationUI"),
+        Dialogs = brackets.getModule("widgets/Dialogs"),
+        DefaultDialogs = brackets.getModule("widgets/DefaultDialogs"),
         TaskManager = brackets.getModule("features/TaskManager"),
         PreferencesManager = brackets.getModule("preferences/PreferencesManager"),
         StringUtils = brackets.getModule("utils/StringUtils"),
@@ -59,6 +61,11 @@ define(function (require, exports, module) {
 
     const INTELEPHENSE_HOME_URL = "https://intelephense.com";
 
+    // once-per-lifetime: the first time the install bar shows, a dialog is raised over it so the
+    // offer cannot be missed. Never shown again (even on cancel) - the bar remains the
+    // ongoing affordance.
+    const STATE_INSTALL_DIALOG_SHOWN = "php.installDialogShown";
+
     let _onInstalled = null;        // main.js callback: ({entryPath, upgraded}) => void
     let _inFlight = null;           // single-flight install promise
     // projects where the user clicked "Not Now" - the bar stops reappearing there for the
@@ -218,23 +225,83 @@ define(function (require, exports, module) {
         }
     }
 
+    function _benefitRows() {
+        return [
+            [Strings.PHP_BENEFIT_COMPLETIONS, Strings.PHP_BENEFIT_COMPLETIONS_SUB],
+            [Strings.PHP_BENEFIT_DOCS, Strings.PHP_BENEFIT_DOCS_SUB],
+            [Strings.PHP_BENEFIT_ERRORS, Strings.PHP_BENEFIT_ERRORS_SUB],
+            [Strings.PHP_BENEFIT_NAV, Strings.PHP_BENEFIT_NAV_SUB]
+        ];
+    }
+
     // Compact benefits card for the bar's (i) icon - term -> what it means, one line each.
     function _benefitsTipHtml() {
         const $tip = $("<div>");
         $("<div class='ph-tip-title'>").text(Strings.PHP_INSTALL_TITLE).appendTo($tip);
         const $rows = $("<div class='ph-tip-rows'>").appendTo($tip);
-        [
-            [Strings.PHP_BENEFIT_COMPLETIONS, Strings.PHP_BENEFIT_COMPLETIONS_SUB],
-            [Strings.PHP_BENEFIT_DOCS, Strings.PHP_BENEFIT_DOCS_SUB],
-            [Strings.PHP_BENEFIT_ERRORS, Strings.PHP_BENEFIT_ERRORS_SUB],
-            [Strings.PHP_BENEFIT_NAV, Strings.PHP_BENEFIT_NAV_SUB]
-        ].forEach(function (row) {
+        _benefitRows().forEach(function (row) {
             $("<span class='ph-tip-term'>").text(row[0]).appendTo($rows);
             $("<span class='ph-tip-def'>").text(row[1]).appendTo($rows);
         });
         return $tip.html();
     }
 
+    // The very first offer ever also raises a dialog over the bar - the bar alone is easy to
+    // miss. One shot per install (lifetime): cancelling leaves only the bar from then on.
+    // Deliberately terse: one line + an (i) whose hover card lists what it provides (same
+    // rich tooltip as the bar's info icon).
+    function _maybeShowFirstTimeDialog() {
+        const stateManager = PreferencesManager.stateManager;
+        if (stateManager.get(STATE_INSTALL_DIALOG_SHOWN)) {
+            return;
+        }
+        stateManager.set(STATE_INSTALL_DIALOG_SHOWN, true);
+        const $body = $("<div>");
+        const $text = $("<p>").appendTo($body);
+        $("<span>").text(Strings.PHP_INSTALL_DIALOG_TEXT).appendTo($text);
+        $text.append("&nbsp;");
+        $("<i class='fa-solid fa-circle-info lsp-install-dialog-info'>").appendTo($text);
+        $("<p class='lsp-install-dialog-later'>").text(Strings.PHP_INSTALL_LATER_INFO).appendTo($body);
+        // quiet colophon crediting (and linking) the server this rides on
+        const $credit = $("<p class='lsp-install-dialog-credit'>").appendTo($body);
+        $("<span>").text(Strings.LSP_INSTALL_POWERED_BY + " ").appendTo($credit);
+        $("<a href='#' data-href='" + INTELEPHENSE_HOME_URL + "'>").text("Intelephense").appendTo($credit);
+        const dialog = Dialogs.showModalDialog(DefaultDialogs.DIALOG_ID_INFO, Strings.PHP_INSTALL_DIALOG_TITLE,
+            $body.html(), [
+                {
+                    className: Dialogs.DIALOG_BTN_CLASS_NORMAL,
+                    id: Dialogs.DIALOG_BTN_CANCEL,
+                    text: Strings.PHP_INSTALL_NOT_NOW
+                },
+                {
+                    className: Dialogs.DIALOG_BTN_CLASS_PRIMARY,
+                    id: Dialogs.DIALOG_BTN_OK,
+                    text: Strings.PHP_INSTALL_ENABLE
+                }
+            ]);
+        const benefitsTip = NotificationUI.attachRichTooltip(
+            dialog.getElement().find(".lsp-install-dialog-info"), _benefitsTipHtml(), { showDelayMs: 150 });
+        // the body went in as serialized HTML, so link handling is delegated on the live dialog
+        dialog.getElement().on("click", "a[data-href]", function (e) {
+            e.preventDefault();
+            NativeApp.openURLInDefaultBrowser($(e.currentTarget).attr("data-href"));
+        });
+        // the download size sits at the decision point - in the footer, left of the buttons -
+        // so the cost is read exactly when the user weighs Install (store-style metadata chip)
+        const $size = $("<span class='lsp-install-dialog-size'>");
+        $("<i class='fa-solid fa-download'>").appendTo($size);
+        $size.append(document.createTextNode(" " + Strings.PHP_INSTALL_DIALOG_SIZE));
+        $size.prependTo(dialog.getElement().find(".modal-footer"));
+        dialog.done(function (id) {
+            benefitsTip.detach();
+            if (id === Dialogs.DIALOG_BTN_OK) {
+                _closePromptBar();
+                installNow();
+            }
+            // on cancel the bar stays - it is the ongoing affordance
+        });
+    }
+
     // A find-bar-style banner across the top of the editor - impossible to miss on the file that
     // triggered it, but passive (autoClose false: clicking back into the code doesn't dismiss it).
     function _showPromptBar() {
@@ -245,31 +312,31 @@ define(function (require, exports, module) {
         }
         // built as detached DOM then serialized (ModalBar takes an HTML string); all click
         // handling is delegated on the live bar root below
-        const $tpl = $("<div class='php-install-bar'>");
-        $("<span class='php-install-bar-text'>").text(Strings.PHP_INSTALL_MESSAGE).appendTo($tpl);
-        $("<i class='fa-solid fa-circle-info php-install-bar-info'>").appendTo($tpl);
+        const $tpl = $("<div class='lsp-install-bar'>");
+        $("<span class='lsp-install-bar-text'>").text(Strings.PHP_INSTALL_MESSAGE).appendTo($tpl);
+        $("<i class='fa-solid fa-circle-info lsp-install-bar-info'>").appendTo($tpl);
         // credit where due (and where premium lives) - not license-required, just right
-        $("<a class='php-intel-powered-by' href='#'>").text(Strings.PHP_POWERED_BY_INTELEPHENSE)
+        $("<a class='lsp-install-bar-powered-by' href='#'>").text(Strings.PHP_POWERED_BY_INTELEPHENSE)
             .appendTo($tpl);
-        $("<button class='btn btn-mini php-install-bar-later'>")
+        $("<button class='btn btn-mini lsp-install-bar-later'>")
             .text(Strings.PHP_INSTALL_NOT_NOW).appendTo($tpl);
-        $("<button class='btn btn-mini primary php-install-bar-install'>")
+        $("<button class='btn btn-mini primary lsp-install-bar-install'>")
             .text(Strings.PHP_INSTALL_ENABLE).appendTo($tpl);
 
         _promptBar = new ModalBar($tpl[0].outerHTML, false);
         const $bar = _promptBar.getRoot();
         _promptBarTip = NotificationUI.attachRichTooltip(
-            $bar.find(".php-install-bar-info"), _benefitsTipHtml(), { showDelayMs: 150 });
-        $bar.on("click", ".php-install-bar-install", function () {
+            $bar.find(".lsp-install-bar-info"), _benefitsTipHtml(), { showDelayMs: 150 });
+        $bar.on("click", ".lsp-install-bar-install", function () {
             _closePromptBar();
             installNow();
         });
-        $bar.on("click", ".php-install-bar-later", function () {
+        $bar.on("click", ".lsp-install-bar-later", function () {
             const projRoot = ProjectManager.getProjectRoot();
             _promptDismissedForProject.add((projRoot && projRoot.fullPath) || "");
             _closePromptBar();
         });
-        $bar.on("click", ".php-intel-powered-by", function (e) {
+        $bar.on("click", ".lsp-install-bar-powered-by", function (e) {
             e.preventDefault();
             NativeApp.openURLInDefaultBrowser(INTELEPHENSE_HOME_URL);
         });
@@ -355,6 +422,7 @@ define(function (require, exports, module) {
         }
         if (phpDocumentActive) {
             _showPromptBar();
+            _maybeShowFirstTimeDialog();
         }
         updatePanelRow(phpDocumentActive);
     }
diff --git a/src/extensions/default/PythonSupport/Beautifier.js b/src/extensions/default/PythonSupport/Beautifier.js
new file mode 100644
index 0000000000..ae93841509
--- /dev/null
+++ b/src/extensions/default/PythonSupport/Beautifier.js
@@ -0,0 +1,83 @@
+/*
+ * GNU AGPL-3.0 License
+ *
+ * Copyright (c) 2021 - present core.ai . All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see https://opensource.org/licenses/AGPL-3.0.
+ *
+ */
+
+/**
+ * Beautifier - Python formatting for the Beautify command via Ruff. Deliberately standalone:
+ * each format is a one-shot `ruff format --stdin-filename <name> -` call over stdin/stdout
+ * (NodeUtils.execFileWithInput) - Ruff is NOT wired into the LSP framework at all. The binary
+ * arrives with the Pyrefly install (see ServerInstaller); until then the provider rejects and
+ * Beautify reports no formatter, same as any other unsupported language.
+ *
+ * Runs with the project root as cwd so a project's own ruff config (pyproject.toml/ruff.toml)
+ * is discovered and respected, exactly like running ruff in a terminal there.
+ *
+ * @module extensions/default/PythonSupport/Beautifier
+ */
+define(function (require, exports, module) {
+
+
+    const BeautificationManager = brackets.getModule("features/BeautificationManager"),
+        ProjectManager = brackets.getModule("project/ProjectManager"),
+        NodeUtils = brackets.getModule("utils/NodeUtils"),
+        ServerInstaller = require("./ServerInstaller");
+
+    const FORMAT_TIMEOUT_MS = 20000;
+
+    async function _runRuffFormat(text, fileNameHint) {
+        const state = await ServerInstaller.installedState();
+        if (!state.installed) {
+            throw new Error("ruff is not installed yet");
+        }
+        const root = ProjectManager.getProjectRoot();
+        const cwd = root ? Phoenix.fs.getTauriPlatformPath(root.fullPath) : undefined;
+        // the stdin filename only feeds ruff's language/config resolution - a bare name is fine
+        const stdinName = (fileNameHint || "file.py").split("/").pop();
+        const result = await NodeUtils.execFileWithInput(
+            ServerInstaller.getRuffBinaryPlatformPath(),
+            ["format", "--stdin-filename", stdinName, "-"],
+            { stdinText: text, cwd: cwd, timeoutMs: FORMAT_TIMEOUT_MS });
+        if (result.code !== 0) {
+            // typically a syntax error in the file - surface ruff's message
+            throw new Error(result.stderr || ("ruff format exited with " + result.code));
+        }
+        return result.stdout;
+    }
+
+    function beautifyTextProvider(textToBeautify, filePathOrFileName) {
+        return _runRuffFormat(textToBeautify, filePathOrFileName).then(function (changedText) {
+            return { originalText: textToBeautify, changedText: changedText };
+        });
+    }
+
+    function beautifyEditorProvider(editor) {
+        const text = editor.document.getText();
+        return _runRuffFormat(text, editor.document.file.fullPath).then(function (changedText) {
+            return { originalText: text, changedText: changedText };
+        });
+    }
+
+    function init() {
+        BeautificationManager.registerBeautificationProvider(exports, ["python"]);
+    }
+
+    exports.init = init;
+    exports.beautifyEditorProvider = beautifyEditorProvider;
+    exports.beautifyTextProvider = beautifyTextProvider;
+});
diff --git a/src/extensions/default/PythonSupport/ServerInstaller.js b/src/extensions/default/PythonSupport/ServerInstaller.js
new file mode 100644
index 0000000000..67bdee885b
--- /dev/null
+++ b/src/extensions/default/PythonSupport/ServerInstaller.js
@@ -0,0 +1,550 @@
+/*
+ * GNU AGPL-3.0 License
+ *
+ * Copyright (c) 2021 - present core.ai . All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see https://opensource.org/licenses/AGPL-3.0.
+ *
+ */
+
+/**
+ * ServerInstaller - on-demand acquisition of the Python tooling: the Pyrefly language server
+ * (MIT, by Meta) and the Ruff formatter (MIT, by Astral). Both are single self-contained Rust
+ * binaries distributed as per-platform wheels on PyPI - neither is on npm and neither needs a
+ * Python runtime. Ruff is used ONLY by the Beautify command (a standalone `ruff format` call,
+ * see Beautifier.js); it is NOT wired into the LSP framework.
+ *
+ * A ~25MB combined download is too big to bundle for one language, so like PHP/Intelephense it
+ * installs on demand: the user consents via the find-bar prompt / first-time dialog /
+ * Problems-panel row, then the pinned wheels for this platform+arch are resolved through the
+ * PyPI JSON API, downloaded, sha256-verified and extracted - all node-side
+ * (NodeUtils.downloadFile/extractZipFile; a wheel is a plain zip). Download progress streams
+ * into a status-bar task. Works identically on Windows, macOS and Linux.
+ *
+ * Layout under <appSupport>/lspServers/:
+ *   pyrefly/installed.json                                  (version marker, written on success)
+ *   pyrefly/pyrefly-<version>.data/scripts/pyrefly[.exe]    (the language server binary)
+ *   ruff/installed.json
+ *   ruff/ruff-<version>.data/scripts/ruff[.exe]             (the formatter binary)
+ *
+ * Version upgrades: bumping a pin makes the next start detect the marker mismatch and reinstall
+ * just the out-of-date unit silently (consent already given). The pins are exact and downloads
+ * sha256-verified against PyPI, so installs are deterministic. The same mechanism transparently
+ * completes older installs when a new unit is added (e.g. ruff arriving after pyrefly).
+ *
+ * @module extensions/default/PythonSupport/ServerInstaller
+ */
+define(function (require, exports, module) {
+
+
+    const NodeUtils = brackets.getModule("utils/NodeUtils"),
+        ProjectManager = brackets.getModule("project/ProjectManager"),
+        NativeApp = brackets.getModule("utils/NativeApp"),
+        ModalBar = brackets.getModule("widgets/ModalBar").ModalBar,
+        NotificationUI = brackets.getModule("widgets/NotificationUI"),
+        Dialogs = brackets.getModule("widgets/Dialogs"),
+        DefaultDialogs = brackets.getModule("widgets/DefaultDialogs"),
+        TaskManager = brackets.getModule("features/TaskManager"),
+        PreferencesManager = brackets.getModule("preferences/PreferencesManager"),
+        StringUtils = brackets.getModule("utils/StringUtils"),
+        Strings = brackets.getModule("strings");
+
+    // Exact tested pins - never ranges. The wheels are sha256-verified against PyPI's manifest,
+    // so what we tested is byte-for-byte what users get. Upgrades are a deliberate pin bump here.
+    const PYREFLY_VERSION = "1.1.1";
+    const RUFF_VERSION = "0.15.20";
+    const PREF_PYTHON_CODE_INTELLIGENCE = "python.codeIntelligence";
+
+    const PYREFLY_HOME_URL = "https://pyrefly.org";
+    const RUFF_HOME_URL = "https://docs.astral.sh/ruff/";
+
+    // The independently pinned/installed pieces. `pkg` is the PyPI package name; the binary of a
+    // wheel build lives at <pkg>-<version>.data/scripts/<pkg>[.exe].
+    const UNITS = {
+        pyrefly: { pkg: "pyrefly", version: PYREFLY_VERSION },
+        ruff: { pkg: "ruff", version: RUFF_VERSION }
+    };
+
+    // once-per-lifetime: the first time the install bar shows, a dialog is raised over it so the
+    // offer cannot be missed. Never shown again (even on cancel) - the bar remains the
+    // ongoing affordance.
+    const STATE_INSTALL_DIALOG_SHOWN = "python.installDialogShown";
+
+    let _onInstalled = null;        // main.js callback: ({binaryPath, upgraded}) => void
+    let _inFlight = null;           // single-flight install promise
+    // projects where the user clicked "Not Now" - the bar stops reappearing there for the
+    // session. Until then it returns on every python file switch (closing on switch-away is not
+    // a dismissal - only the explicit button is).
+    const _promptDismissedForProject = new Set();
+    let _promptBar = null;          // the ModalBar install prompt, when showing
+    let _promptBarTip = null;       // the benefits tooltip binding on the bar's info icon
+    let _panelRowDismissed = false; // Problems-panel row dismissed this session
+
+    function _installDirVfs(unit) {
+        return Phoenix.VFS.getAppSupportDir() + "lspServers/" + unit.pkg + "/";
+    }
+
+    // wheel-relative path of the unit's binary (/-separated)
+    function _binaryRelPath(unit) {
+        const exe = brackets.platform === "win" ? ".exe" : "";
+        return unit.pkg + "-" + unit.version + ".data/scripts/" + unit.pkg + exe;
+    }
+
+    function _binaryVfs(unit) {
+        return _installDirVfs(unit) + _binaryRelPath(unit);
+    }
+
+    function _markerVfs(unit) {
+        return _installDirVfs(unit) + "installed.json";
+    }
+
+    function _binaryPlatformPath(unit) {
+        return Phoenix.fs.getTauriPlatformPath(_binaryVfs(unit));
+    }
+
+    /**
+     * The platform (real disk) path of the Pyrefly language server binary, for spawning.
+     * @return {string}
+     */
+    function getBinaryPlatformPath() {
+        return _binaryPlatformPath(UNITS.pyrefly);
+    }
+
+    /**
+     * The platform (real disk) path of the Ruff binary - used only by the Beautify command.
+     * @return {string}
+     */
+    function getRuffBinaryPlatformPath() {
+        return _binaryPlatformPath(UNITS.ruff);
+    }
+
+    async function _unitState(unit) {
+        const binExists = await Phoenix.VFS.existsAsync(_binaryVfs(unit));
+        if (binExists) {
+            try {
+                const marker = JSON.parse(await Phoenix.VFS.readFileAsync(_markerVfs(unit), "utf8"));
+                return { installed: true, pinMatches: marker.version === unit.version };
+            } catch (e) {
+                return { installed: true, pinMatches: false };
+            }
+        }
+        // binary of the CURRENT pin absent, but a marker means an older version is installed
+        // (its binary path carries its version) - report installed so the upgrade is silent.
+        const markerExists = await Phoenix.VFS.existsAsync(_markerVfs(unit));
+        return { installed: markerExists, pinMatches: false };
+    }
+
+    /**
+     * Combined install state. `installed` keys off pyrefly (its presence is the consent signal);
+     * anything less than every unit present at its exact pin reports pinMatches false, which the
+     * caller treats as "complete/upgrade silently" - that is also how a ruff-less older install
+     * transparently gains ruff.
+     * @return {Promise<{installed: boolean, pinMatches: boolean}>}
+     */
+    async function installedState() {
+        const pyrefly = await _unitState(UNITS.pyrefly);
+        const ruff = await _unitState(UNITS.ruff);
+        return {
+            installed: pyrefly.installed,
+            pinMatches: pyrefly.pinMatches && ruff.installed && ruff.pinMatches
+        };
+    }
+
+    // ----- install mechanics ----------------------------------------------------------------------
+
+    /**
+     * The PyPI wheel tag for this machine. Phoenix desktop ships win/mac/linux on
+     * x64 + arm64 - anything else has no wheel we can pick safely.
+     * @return {Promise<string>}
+     */
+    async function _wheelTag() {
+        const platform = brackets.platform;
+        const arch = String(await Phoenix.app.getPlatformArch() || "").toLowerCase();
+        const isX64 = arch === "x86_64" || arch === "x64" || arch === "amd64";
+        const isArm64 = arch === "aarch64" || arch === "arm64";
+        if (platform === "win") {
+            if (isX64) {
+                return "win_amd64";
+            }
+            if (isArm64) {
+                return "win_arm64";
+            }
+        } else if (platform === "mac") {
+            if (isArm64) {
+                return "macosx_11_0_arm64";
+            }
+            if (isX64) {
+                return "macosx_10_12_x86_64";
+            }
+        } else if (platform === "linux") {
+            if (isX64) {
+                return "manylinux_2_17_x86_64.manylinux2014_x86_64";
+            }
+            if (isArm64) {
+                return "manylinux_2_17_aarch64.manylinux2014_aarch64";
+            }
+        }
+        throw new Error("no " + Object.keys(UNITS).join("/") + " build for " + platform + "/" + arch);
+    }
+
+    /**
+     * Resolve a unit's pinned wheel download URL and sha256 from the PyPI JSON API (CORS-open).
+     * @return {Promise<{url: string, sha256: string}>}
+     */
+    async function _resolveWheel(unit, tag) {
+        const metaUrl = "https://pypi.org/pypi/" + unit.pkg + "/" + unit.version + "/json";
+        const response = await fetch(metaUrl);
+        if (!response.ok) {
+            throw new Error("PyPI metadata fetch failed with HTTP " + response.status);
+        }
+        const meta = await response.json();
+        const wheel = (meta.urls || []).find(function (u) {
+            return u.filename && u.filename.endsWith(".whl") && u.filename.indexOf(tag) !== -1;
+        });
+        if (!wheel) {
+            throw new Error("no " + unit.pkg + " " + unit.version + " wheel for " + tag);
+        }
+        return { url: wheel.url, sha256: wheel.digests && wheel.digests.sha256 };
+    }
+
+    // Download + extract one unit's wheel, reporting progress in [pctFrom, pctTo] of `task`.
+    async function _installUnit(unit, tag, task, pctFrom, pctTo) {
+        const wheel = await _resolveWheel(unit, tag);
+        // any older version's tree is dead weight (paths carry the version) - wipe it all
+        await Phoenix.VFS.unlinkAsync(_installDirVfs(unit)).catch(function () {});
+        const destDir = Phoenix.fs.getTauriPlatformPath(_installDirVfs(unit));
+        const wheelFile = Phoenix.fs.getTauriPlatformPath(_installDirVfs(unit) + "download.whl");
+        const downloadShare = (pctTo - pctFrom) * 0.85;   // extraction takes the rest
+        await NodeUtils.downloadFile(wheel.url, wheelFile, {
+            sha256: wheel.sha256,
+            progress: function (transferred, total) {
+                if (total > 0) {
+                    task.setProgressPercent(Math.round(pctFrom + (transferred / total) * downloadShare));
+                }
+            }
+        });
+        // a wheel is a plain zip; extraction restores the archive's unix exec bits, and the
+        // explicit chmod below covers archives that lost them
+        await NodeUtils.extractZipFile(wheelFile, destDir);
+        await NodeUtils.setExecutableBits(_binaryPlatformPath(unit));
+        await Phoenix.VFS.unlinkAsync(_installDirVfs(unit) + "download.whl").catch(function () {});
+        const ok = await Phoenix.VFS.existsAsync(_binaryVfs(unit));
+        if (!ok) {
+            throw new Error(unit.pkg + " binary missing after wheel extraction");
+        }
+        await Phoenix.VFS.writeFileAsync(_markerVfs(unit),
+            JSON.stringify({ version: unit.version }, null, 4), "utf8");
+        task.setProgressPercent(pctTo);
+    }
+
+    async function _doInstall() {
+        const state = await installedState();
+        if (state.installed && state.pinMatches) {
+            return { binaryPath: getBinaryPlatformPath(), upgraded: false };
+        }
+        const upgrading = state.installed;
+        hidePanelRow();
+        // Status-bar task the user can track from anywhere; the downloads stream real progress.
+        const task = TaskManager.addNewTask(Strings.PYTHON_INSTALL_TITLE, Strings.PYTHON_INSTALLING,
+            "<i class='fa-brands fa-python'></i>", { progressPercent: 2 });
+        task.show();
+        try {
+            const tag = await _wheelTag();
+            // only the units that are missing or off-pin - a version bump of one tool does not
+            // re-download the other
+            const pending = [];
+            for (const key of Object.keys(UNITS)) {
+                const unitState = await _unitState(UNITS[key]);
+                if (!(unitState.installed && unitState.pinMatches)) {
+                    pending.push(UNITS[key]);
+                }
+            }
+            task.setProgressPercent(5);
+            const span = 90 / (pending.length || 1);
+            for (let i = 0; i < pending.length; i++) {
+                await _installUnit(pending[i], tag, task, Math.round(5 + i * span),
+                    Math.round(5 + (i + 1) * span));
+            }
+            task.setProgressPercent(100);
+            task.setMessage(Strings.PYTHON_INSTALL_DONE);
+            task.setSucceded(); // (sic - TaskManager's exported name)
+            setTimeout(task.close, 4000);
+            return { binaryPath: getBinaryPlatformPath(), upgraded: upgrading };
+        } catch (err) {
+            const message = (err && err.message) || String(err);
+            task.setFailed();
+            task.setMessage(StringUtils.format(Strings.PYTHON_INSTALL_FAILED, message));
+            setTimeout(task.close, 10000);
+            return null;
+        }
+    }
+
+    /**
+     * Install (or upgrade) now - single-flighted. On success, notifies the onInstalled callback so
+     * the language server can start immediately.
+     * @return {Promise<?{binaryPath: string, upgraded: boolean}>} null on failure
+     */
+    function installNow() {
+        if (_inFlight) {
+            return _inFlight;
+        }
+        _inFlight = _doInstall().then(function (result) {
+            if (result && _onInstalled) {
+                _onInstalled(result);
+            }
+            return result;
+        }).finally(function () {
+            _inFlight = null;
+        });
+        return _inFlight;
+    }
+
+    // ----- consent UI: find-bar prompt + first-time dialog + Problems-panel row -------------------
+
+    function _closePromptBar() {
+        if (_promptBarTip) {
+            _promptBarTip.detach();
+            _promptBarTip = null;
+        }
+        if (_promptBar) {
+            _promptBar.close();
+            _promptBar = null;
+        }
+    }
+
+    function _benefitRows() {
+        return [
+            [Strings.PYTHON_BENEFIT_COMPLETIONS, Strings.PYTHON_BENEFIT_COMPLETIONS_SUB],
+            [Strings.PYTHON_BENEFIT_DOCS, Strings.PYTHON_BENEFIT_DOCS_SUB],
+            [Strings.PYTHON_BENEFIT_ERRORS, Strings.PYTHON_BENEFIT_ERRORS_SUB],
+            [Strings.PYTHON_BENEFIT_NAV, Strings.PYTHON_BENEFIT_NAV_SUB],
+            [Strings.PYTHON_BENEFIT_FORMAT, Strings.PYTHON_BENEFIT_FORMAT_SUB]
+        ];
+    }
+
+    // Compact benefits card for the bar's (i) icon - term -> what it means, one line each.
+    function _benefitsTipHtml() {
+        const $tip = $("<div>");
+        $("<div class='ph-tip-title'>").text(Strings.PYTHON_INSTALL_TITLE).appendTo($tip);
+        const $rows = $("<div class='ph-tip-rows'>").appendTo($tip);
+        _benefitRows().forEach(function (row) {
+            $("<span class='ph-tip-term'>").text(row[0]).appendTo($rows);
+            $("<span class='ph-tip-def'>").text(row[1]).appendTo($rows);
+        });
+        return $tip.html();
+    }
+
+    // The very first offer ever also raises a dialog over the bar - the bar alone is easy to
+    // miss. One shot per install (lifetime): cancelling leaves only the bar from then on.
+    // Deliberately terse: one line + an (i) whose hover card lists what it provides (same
+    // rich tooltip as the bar's info icon).
+    function _maybeShowFirstTimeDialog() {
+        const stateManager = PreferencesManager.stateManager;
+        if (stateManager.get(STATE_INSTALL_DIALOG_SHOWN)) {
+            return;
+        }
+        stateManager.set(STATE_INSTALL_DIALOG_SHOWN, true);
+        const $body = $("<div>");
+        const $text = $("<p>").appendTo($body);
+        $("<span>").text(Strings.PYTHON_INSTALL_DIALOG_TEXT).appendTo($text);
+        $text.append("&nbsp;");
+        $("<i class='fa-solid fa-circle-info lsp-install-dialog-info'>").appendTo($text);
+        $("<p class='lsp-install-dialog-later'>").text(Strings.PYTHON_INSTALL_LATER_INFO).appendTo($body);
+        // quiet colophon crediting (and linking) the tools this rides on
+        const $credit = $("<p class='lsp-install-dialog-credit'>").appendTo($body);
+        $("<span>").text(Strings.LSP_INSTALL_POWERED_BY + " ").appendTo($credit);
+        $("<a href='#' data-href='" + PYREFLY_HOME_URL + "'>").text("Pyrefly").appendTo($credit);
+        $credit.append(document.createTextNode(" · "));
+        $("<a href='#' data-href='" + RUFF_HOME_URL + "'>").text("Ruff").appendTo($credit);
+        const dialog = Dialogs.showModalDialog(DefaultDialogs.DIALOG_ID_INFO, Strings.PYTHON_INSTALL_DIALOG_TITLE,
+            $body.html(), [
+                {
+                    className: Dialogs.DIALOG_BTN_CLASS_NORMAL,
+                    id: Dialogs.DIALOG_BTN_CANCEL,
+                    text: Strings.PYTHON_INSTALL_NOT_NOW
+                },
+                {
+                    className: Dialogs.DIALOG_BTN_CLASS_PRIMARY,
+                    id: Dialogs.DIALOG_BTN_OK,
+                    text: Strings.PYTHON_INSTALL_ENABLE
+                }
+            ]);
+        const benefitsTip = NotificationUI.attachRichTooltip(
+            dialog.getElement().find(".lsp-install-dialog-info"), _benefitsTipHtml(), { showDelayMs: 150 });
+        // the body went in as serialized HTML, so link handling is delegated on the live dialog
+        dialog.getElement().on("click", "a[data-href]", function (e) {
+            e.preventDefault();
+            NativeApp.openURLInDefaultBrowser($(e.currentTarget).attr("data-href"));
+        });
+        // the download size sits at the decision point - in the footer, left of the buttons -
+        // so the cost is read exactly when the user weighs Install (store-style metadata chip)
+        const $size = $("<span class='lsp-install-dialog-size'>");
+        $("<i class='fa-solid fa-download'>").appendTo($size);
+        $size.append(document.createTextNode(" " + Strings.PYTHON_INSTALL_DIALOG_SIZE));
+        $size.prependTo(dialog.getElement().find(".modal-footer"));
+        dialog.done(function (id) {
+            benefitsTip.detach();
+            if (id === Dialogs.DIALOG_BTN_OK) {
+                _closePromptBar();
+                installNow();
+            }
+            // on cancel the bar stays - it is the ongoing affordance
+        });
+    }
+
+    // A find-bar-style banner across the top of the editor - impossible to miss on the file that
+    // triggered it, but passive (autoClose false: clicking back into the code doesn't dismiss it).
+    function _showPromptBar() {
+        const root = ProjectManager.getProjectRoot();
+        const rootPath = (root && root.fullPath) || "";
+        if (_promptDismissedForProject.has(rootPath) || _promptBar) {
+            return;
+        }
+        // built as detached DOM then serialized (ModalBar takes an HTML string); all click
+        // handling is delegated on the live bar root below
+        const $tpl = $("<div class='lsp-install-bar'>");
+        $("<span class='lsp-install-bar-text'>").text(Strings.PYTHON_INSTALL_MESSAGE).appendTo($tpl);
+        $("<i class='fa-solid fa-circle-info lsp-install-bar-info'>").appendTo($tpl);
+        // credit where due - not license-required, just right
+        $("<a class='lsp-install-bar-powered-by' href='#'>").text(Strings.PYTHON_POWERED_BY_PYREFLY)
+            .appendTo($tpl);
+        $("<button class='btn btn-mini lsp-install-bar-later'>")
+            .text(Strings.PYTHON_INSTALL_NOT_NOW).appendTo($tpl);
+        $("<button class='btn btn-mini primary lsp-install-bar-install'>")
+            .text(Strings.PYTHON_INSTALL_ENABLE).appendTo($tpl);
+
+        _promptBar = new ModalBar($tpl[0].outerHTML, false);
+        const $bar = _promptBar.getRoot();
+        _promptBarTip = NotificationUI.attachRichTooltip(
+            $bar.find(".lsp-install-bar-info"), _benefitsTipHtml(), { showDelayMs: 150 });
+        $bar.on("click", ".lsp-install-bar-install", function () {
+            _closePromptBar();
+            installNow();
+        });
+        $bar.on("click", ".lsp-install-bar-later", function () {
+            const projRoot = ProjectManager.getProjectRoot();
+            _promptDismissedForProject.add((projRoot && projRoot.fullPath) || "");
+            _closePromptBar();
+        });
+        $bar.on("click", ".lsp-install-bar-powered-by", function (e) {
+            e.preventDefault();
+            NativeApp.openURLInDefaultBrowser(PYREFLY_HOME_URL);
+        });
+    }
+
+    function _ensurePanelRow() {
+        const $panel = $("#problems-panel");
+        if (!$panel.length) {
+            return null;
+        }
+        let $row = $panel.find(".py-intel-panel-row");
+        if ($row.length) {
+            return $row;
+        }
+        // reuse the TS row's styling; the extra class scopes our own lookups
+        $row = $("<div class='ts-code-intel-panel-row py-intel-panel-row'>").hide();
+        $("<span class='ts-code-intel-panel-text'>").text(Strings.PYTHON_PANEL_TEXT).appendTo($row);
+        $("<button class='btn btn-mini primary ts-code-intel-panel-enable'>")
+            .text(Strings.PYTHON_INSTALL_ENABLE)
+            .on("click", function () {
+                installNow();
+            })
+            .appendTo($row);
+        $("<a class='ts-code-intel-panel-close'>")
+            .attr("title", Strings.PYTHON_INSTALL_NOT_NOW).html("&times;")
+            .on("click", function () {
+                _panelRowDismissed = true; // session-only: reappears next launch
+                $row.hide();
+            })
+            .appendTo($row);
+        $panel.children(".toolbar").after($row);
+        return $row;
+    }
+
+    /**
+     * Hide the Problems-panel install row (e.g. once an install starts or completes).
+     */
+    function hidePanelRow() {
+        const $row = $("#problems-panel .py-intel-panel-row");
+        if ($row.length) {
+            $row.hide();
+        }
+    }
+
+    /**
+     * Show/hide the Problems-panel install row for the current state. Call on active-editor and
+     * project changes with whether a Python DOCUMENT is active.
+     * @param {boolean} pythonDocumentActive
+     */
+    function updatePanelRow(pythonDocumentActive) {
+        if (typeof Phoenix !== "undefined" && Phoenix.isTestWindow) {
+            return;
+        }
+        const $row = _ensurePanelRow();
+        if (!$row) {
+            return;
+        }
+        if (!pythonDocumentActive) {
+            _closePromptBar();  // the bar belongs to the python file that triggered it
+        }
+        if (!pythonDocumentActive || _panelRowDismissed || _inFlight ||
+                PreferencesManager.get(PREF_PYTHON_CODE_INTELLIGENCE) === false) {
+            $row.hide();
+            return;
+        }
+        installedState().then(function (state) {
+            if (state.installed) {
+                $row.hide();
+            } else {
+                $row.show();
+            }
+        });
+    }
+
+    /**
+     * Offer the install to the user: the find-bar prompt (plus a once-ever dialog over it) + the
+     * persistent Problems-panel row. Call when a Python document is active but the server is not
+     * installed.
+     * @param {boolean} pythonDocumentActive
+     */
+    function offerInstallUI(pythonDocumentActive) {
+        if (typeof Phoenix !== "undefined" && Phoenix.isTestWindow) {
+            return;
+        }
+        if (pythonDocumentActive) {
+            _showPromptBar();
+            _maybeShowFirstTimeDialog();
+        }
+        updatePanelRow(pythonDocumentActive);
+    }
+
+    /**
+     * @param {{onInstalled: function({binaryPath: string, upgraded: boolean})}} options
+     */
+    function init(options) {
+        _onInstalled = (options && options.onInstalled) || null;
+    }
+
+    exports.init = init;
+    exports.installedState = installedState;
+    exports.installNow = installNow;
+    exports.offerInstallUI = offerInstallUI;
+    exports.updatePanelRow = updatePanelRow;
+    exports.hidePanelRow = hidePanelRow;
+    exports.getBinaryPlatformPath = getBinaryPlatformPath;
+    exports.getRuffBinaryPlatformPath = getRuffBinaryPlatformPath;
+    exports.PYREFLY_VERSION = PYREFLY_VERSION;
+    exports.RUFF_VERSION = RUFF_VERSION;
+    exports.PREF_PYTHON_CODE_INTELLIGENCE = PREF_PYTHON_CODE_INTELLIGENCE;
+});
diff --git a/src/extensions/default/PythonSupport/main.js b/src/extensions/default/PythonSupport/main.js
new file mode 100644
index 0000000000..11e8b6dc69
--- /dev/null
+++ b/src/extensions/default/PythonSupport/main.js
@@ -0,0 +1,234 @@
+/*
+ * GNU AGPL-3.0 License
+ *
+ * Copyright (c) 2021 - present core.ai . All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see https://opensource.org/licenses/AGPL-3.0.
+ *
+ */
+
+/**
+ * PythonSupport - Python code intelligence via the Pyrefly language server (MIT, by Meta):
+ * completion with docs, hover, signature help, jump-to-definition, find references, type-error
+ * diagnostics and quick fixes, all through the shared LSP framework. Desktop only.
+ *
+ * The server is a single ~13MB Rust binary too large to bundle for one language - see
+ * ServerInstaller for the consent + on-demand PyPI wheel download flow.
+ *
+ * @module extensions/default/PythonSupport/main
+ */
+define(function (require, exports, module) {
+
+
+    const AppInit = brackets.getModule("utils/AppInit"),
+        ProjectManager = brackets.getModule("project/ProjectManager"),
+        EditorManager = brackets.getModule("editor/EditorManager"),
+        PreferencesManager = brackets.getModule("preferences/PreferencesManager"),
+        NodeConnector = brackets.getModule("NodeConnector"),
+        Strings = brackets.getModule("strings"),
+        ServerInstaller = require("./ServerInstaller"),
+        Beautifier = require("./Beautifier");
+
+    const SERVER_ID = "python";
+    const SUPPORTED_LANGUAGES = ["python"];
+
+    // Master switch; also doubles as the durable memory of a declined install prompt (the
+    // decline sets it false; setting it back to true re-offers the install).
+    PreferencesManager.definePreference(ServerInstaller.PREF_PYTHON_CODE_INTELLIGENCE, "boolean", true, {
+        description: Strings.DESCRIPTION_PYTHON_CODE_INTELLIGENCE
+    });
+
+    let lspClientPromise = null;
+    let registered = false;
+    let starting = false;
+    let pendingRepoint = false;
+    let initErrorReported = false;
+    let _client = null;
+
+    function canRun() {
+        return Phoenix.isNativeApp && NodeConnector.isNodeAvailable();
+    }
+
+    function loadLSPClient() {
+        if (!lspClientPromise) {
+            lspClientPromise = new Promise(function (resolve, reject) {
+                brackets.getModule(["languageTools/LSPClient"], resolve, function () {
+                    setTimeout(function () {
+                        brackets.getModule(["languageTools/LSPClient"], resolve, reject);
+                    }, 500);
+                });
+            });
+        }
+        return lspClientPromise;
+    }
+
+    function waitForNodeReady(timeout) {
+        return new Promise(function (resolve) {
+            const deadline = Date.now() + timeout;
+            (function check() {
+                if (NodeConnector.isNodeReady()) {
+                    resolve(true);
+                } else if (Date.now() > deadline) {
+                    resolve(false);
+                } else {
+                    setTimeout(check, 300);
+                }
+            }());
+        });
+    }
+
+    async function _registerServer(binaryPath) {
+        if (registered) {
+            return;
+        }
+        const LSPClient = await loadLSPClient();
+        const client = await LSPClient.registerLanguageServer({
+            serverId: SERVER_ID,
+            command: binaryPath,                // absolute native binary, spawned as-is
+            args: ["lsp"],
+            languages: SUPPORTED_LANGUAGES,
+            languageIdMap: { python: "python" },
+            initializationOptions: {},
+            // pyrefly pulls the "python" section and treats a null answer as everything-off;
+            // "default" mode gives full type diagnostics. A project's own pyrefly.toml /
+            // pyproject.toml stays authoritative over this.
+            workspaceConfiguration: {
+                python: { pyrefly: { typeCheckingMode: "default" } }
+            }
+        });
+        if (client) {
+            registered = true;
+            _client = client;
+        }
+    }
+
+    async function start() {
+        if (registered || !canRun()) {
+            return;
+        }
+        const ready = await waitForNodeReady(30000);
+        if (!ready) {
+            console.error("[PythonSupport] Node not ready - Python LSP disabled");
+            return;
+        }
+        const state = await ServerInstaller.installedState();
+        if (!state.installed) {
+            // not acquired yet: offer the unobtrusive consent UI (find-bar prompt +
+            // Problems-panel row). Clicking Install runs the installer; its onInstalled
+            // callback starts us.
+            ServerInstaller.offerInstallUI(_isPythonDocumentActive());
+            return;
+        }
+        if (!state.pinMatches) {
+            // silent version upgrade - consent was given when it first installed
+            const result = await ServerInstaller.installNow();
+            if (!result) {
+                return;
+            }
+            // installNow's onInstalled callback registers the server
+            return;
+        }
+        await _registerServer(ServerInstaller.getBinaryPlatformPath());
+    }
+
+    /**
+     * True when the active editor's DOCUMENT is Python.
+     * @return {boolean}
+     */
+    function _isPythonDocumentActive() {
+        const editor = EditorManager.getActiveEditor();
+        if (!editor || !editor.document) {
+            return false;
+        }
+        return editor.document.getLanguage().getId() === "python";
+    }
+
+    function _ensureServerForActiveEditor() {
+        if (!canRun() || !_isPythonDocumentActive()) {
+            return;
+        }
+        if (PreferencesManager.get(ServerInstaller.PREF_PYTHON_CODE_INTELLIGENCE) === false) {
+            return;
+        }
+        if (!registered) {
+            if (starting) {
+                return;
+            }
+            starting = true;
+            pendingRepoint = false;
+            start().catch(function (err) {
+                if (!initErrorReported) {
+                    initErrorReported = true;
+                    window.logger && window.logger.reportError(err, "[PythonSupport] Python LSP init failed");
+                }
+            }).finally(function () {
+                starting = false;
+            });
+            return;
+        }
+        if (pendingRepoint) {
+            pendingRepoint = false;
+            loadLSPClient().then(function (LSPClient) {
+                LSPClient.changeWorkspaceRoot(SERVER_ID);
+            });
+        }
+    }
+
+    // Pre-warm the framework module (not the server) as soon as the extension loads.
+    if (canRun()) {
+        loadLSPClient();
+    }
+
+    AppInit.appReady(function () {
+        if (!canRun()) {
+            return;
+        }
+
+        ServerInstaller.init({
+            onInstalled: function (result) {
+                _registerServer(result.binaryPath).catch(function (err) {
+                    window.logger && window.logger.reportError(err, "[PythonSupport] start after install failed");
+                });
+            }
+        });
+        // Beautify-command formatting via a standalone ruff call (not part of the LSP wiring)
+        Beautifier.init();
+
+        EditorManager.on("activeEditorChange.pythonSupport", function () {
+            _ensureServerForActiveEditor();
+            ServerInstaller.updatePanelRow(_isPythonDocumentActive() && !registered);
+        });
+        _ensureServerForActiveEditor();
+
+        ProjectManager.on(ProjectManager.EVENT_PROJECT_OPEN + ".pythonSupport", function () {
+            pendingRepoint = true;
+            _ensureServerForActiveEditor();
+        });
+
+        // Master switch flipped back on (e.g. after an earlier decline): offer install again on
+        // the currently open python file.
+        PreferencesManager.on("change", ServerInstaller.PREF_PYTHON_CODE_INTELLIGENCE, function () {
+            if (PreferencesManager.get(ServerInstaller.PREF_PYTHON_CODE_INTELLIGENCE) !== false) {
+                _ensureServerForActiveEditor();
+            }
+        });
+    });
+
+    // for tests
+    exports._ensureServerForActiveEditor = _ensureServerForActiveEditor;
+    exports._getClient = function () {
+        return _client;
+    };
+    exports.SERVER_ID = SERVER_ID;
+});
diff --git a/src/extensions/default/PythonSupport/package.json b/src/extensions/default/PythonSupport/package.json
new file mode 100644
index 0000000000..0b3ed16c6a
--- /dev/null
+++ b/src/extensions/default/PythonSupport/package.json
@@ -0,0 +1,9 @@
+{
+    "name": "python-support",
+    "title": "Python Language Support",
+    "description": "Provides Python language intelligence (completion, hover, signature help, jump-to-definition, find references and diagnostics) via the Pyrefly language server, installed on demand with user consent. Desktop only.",
+    "version": "1.0.0",
+    "engines": {
+        "brackets": ">=2.0.0"
+    }
+}
diff --git a/src/extensions/default/PythonSupport/unittests.js b/src/extensions/default/PythonSupport/unittests.js
new file mode 100644
index 0000000000..cdb65d813a
--- /dev/null
+++ b/src/extensions/default/PythonSupport/unittests.js
@@ -0,0 +1,202 @@
+/*
+ * GNU AGPL-3.0 License
+ *
+ * Copyright (c) 2021 - present core.ai . All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see https://opensource.org/licenses/AGPL-3.0.
+ *
+ */
+
+/*global describe, it, expect, beforeAll, afterAll, awaitsFor, awaitsForDone */
+
+define(function (require, exports, module) {
+
+
+    if (!Phoenix.isNativeApp) {
+        // The Python language server is a native binary spawned via node - desktop builds only.
+        return;
+    }
+
+    const SpecRunnerUtils = brackets.getModule("spec/SpecRunnerUtils");
+
+    describe("integration:Python LSP", function () {
+        const testFolder = SpecRunnerUtils.getTestPath("/spec/PythonSupport-test-files");
+        let testWindow,
+            $,
+            CommandManager,
+            Commands,
+            EditorManager,
+            QuickViewManager;
+
+        // Resolve a module from the PythonSupport extension inside the test window.
+        function _pyModule(name) {
+            return new Promise(function (resolve, reject) {
+                const ExtensionLoader = testWindow.brackets.test.ExtensionLoader;
+                const ctx = ExtensionLoader.getRequireContextForExtension("PythonSupport");
+                ctx([name], resolve, reject);
+            });
+        }
+
+        async function _openFile(fileName) {
+            await awaitsForDone(
+                CommandManager.execute(Commands.CMD_ADD_TO_WORKINGSET_AND_OPEN,
+                    { fullPath: testFolder + "/" + fileName }));
+        }
+
+        function _problemsText() {
+            return $("#problems-panel").text();
+        }
+
+        beforeAll(async function () {
+            testWindow = await SpecRunnerUtils.createTestWindowAndRun();
+            $ = testWindow.$;
+            CommandManager = testWindow.brackets.test.CommandManager;
+            Commands = testWindow.brackets.test.Commands;
+            EditorManager = testWindow.brackets.test.EditorManager;
+            QuickViewManager = testWindow.brackets.getModule("features/QuickViewManager");
+            await SpecRunnerUtils.loadProjectInTestWindow(testFolder);
+
+            // Acquire the server directly (the consent UI is suppressed in test windows). First CI
+            // run downloads the ~13MB wheel from PyPI; local runs hit the installed copy instantly.
+            const ServerInstaller = await _pyModule("ServerInstaller");
+            const result = await ServerInstaller.installNow();
+            if (!result) {
+                throw new Error("Pyrefly install failed - network needed for the first run");
+            }
+
+            // Warm-up: opening a python file lazily starts the server; the first diagnostic is
+            // the readiness signal. Generous budget for the very first start.
+            await _openFile("error.py");
+            await awaitsFor(function () {
+                return /python \(/.test(_problemsText());
+            }, "first pyrefly diagnostics in the problems panel", 120000);
+        }, 240000);
+
+        afterAll(async function () {
+            testWindow = null;
+            await SpecRunnerUtils.closeTestWindow();
+        }, 30000);
+
+        it("should report Python type errors from the language server", async function () {
+            await _openFile("error.py");
+            await awaitsFor(function () {
+                // the fixture has a str-into-int assignment and an unbound name - either message
+                // proves pyrefly's type diagnostics flow into the problems panel
+                return /python \(/.test(_problemsText()) &&
+                    /undefined_name_here|not assignable/i.test(_problemsText());
+            }, "python type diagnostic", 30000);
+        }, 45000);
+
+        it("should mark the python linting provider active (and cpp untouched by it)", async function () {
+            const LSPClient = testWindow.brackets.getModule("languageTools/LSPClient");
+            expect(LSPClient.isLintingProviderActive("python")).toBe(true);
+            expect(LSPClient.isLintingProviderActive("cpp")).toBe(false);
+        }, 45000);
+
+        it("should show hover docs for a user-defined function", async function () {
+            await _openFile("funcs.py");
+            const editor = EditorManager.getActiveEditor();
+            const lines = editor.document.getText().split("\n");
+            const callLine = lines.findIndex(function (l) { return l.indexOf("print(compute_total") !== -1; });
+            const pos = { line: callLine, ch: lines[callLine].indexOf("compute_total") + 3 };
+            let hoverText = null;
+            await awaitsFor(function () {
+                return QuickViewManager._queryPreviewProviders(editor, pos, editor.getToken(pos))
+                    .then(function (popover) {
+                        if (popover && popover.content) {
+                            hoverText = $(popover.content).text();
+                        }
+                    }).then(function () {
+                        return hoverText && hoverText.indexOf("compute_total") !== -1;
+                    });
+            }, "hover docs for compute_total", 30000);
+            expect(hoverText).toContain("compute_total");
+        }, 45000);
+
+        it("should jump to definition within the file", async function () {
+            await _openFile("funcs.py");
+            const editor = EditorManager.getActiveEditor();
+            const lines = editor.document.getText().split("\n");
+            const callLine = lines.findIndex(function (l) { return l.indexOf("print(compute_total") !== -1; });
+            const defLine = lines.findIndex(function (l) { return l.indexOf("def compute_total") !== -1; });
+            editor.setCursorPos({ line: callLine, ch: lines[callLine].indexOf("compute_total") + 3 });
+            await awaitsForDone(CommandManager.execute(Commands.NAVIGATE_JUMPTO_DEFINITION));
+            await awaitsFor(function () {
+                return EditorManager.getActiveEditor().getCursorPos().line === defLine;
+            }, "cursor to land on the definition", 30000);
+        }, 45000);
+
+        it("should offer pyrefly completions for a partial identifier", async function () {
+            await _openFile("funcs.py");
+            const editor = EditorManager.getActiveEditor();
+            const lines = editor.document.getText().split("\n");
+            const callLine = lines.findIndex(function (l) { return l.indexOf("print(compute_total") !== -1; });
+            // cursor right after the "compute_" prefix inside the call - an explicit invocation
+            // there must surface compute_total from the LSP hint provider
+            editor.setCursorPos({ line: callLine, ch: lines[callLine].indexOf("compute_total") + 8 });
+            const pyMain = await _pyModule("main");
+            const provider = pyMain._getClient().codeHints;
+            let hintTexts = null;
+            await awaitsFor(function () {
+                if (!provider.hasHints(editor, null)) {
+                    return false;
+                }
+                const response = provider.getHints(null);
+                if (!response) {
+                    return false;
+                }
+                response.done(function (result) {
+                    hintTexts = (result && result.hints || []).map(function ($item) {
+                        return $item.text ? $item.text() : String($item);
+                    });
+                });
+                return hintTexts && hintTexts.join("|").indexOf("compute_total") !== -1;
+            }, "compute_total in pyrefly completions", 30000);
+        }, 45000);
+
+        it("should attach the server's quickfix with its title on unknown-name diagnostics", async function () {
+            await _openFile("error.py");
+            const pyMain = await _pyModule("main");
+            const provider = pyMain._getClient().lintingProvider;
+            const editor = EditorManager.getActiveEditor();
+            const filePath = editor.document.file.fullPath;
+            // quickfixes attach on an idle timer after diagnostics publish - poll the cached
+            // inspection results for a fix on the `valu` typo (pyrefly's first action for
+            // unknown-name is "Generate variable `valu`"; the title must ride along so the Fix
+            // button can say what it does)
+            let fix = null;
+            await awaitsFor(function () {
+                const results = provider.getInspectionResults(null, filePath);
+                const errors = (results && results.errors) || [];
+                const typo = errors.find(function (err) {
+                    return err.message && err.message.indexOf("`valu`") !== -1;
+                });
+                fix = typo && typo.fix;
+                return !!fix;
+            }, "server quickfix on the `valu` diagnostic", 30000);
+            expect(typeof fix.replaceText).toBe("string");
+            expect(fix.title).toContain("valu");
+        }, 45000);
+
+        it("should format python through the standalone ruff Beautify provider", async function () {
+            const Beautifier = await _pyModule("Beautifier");
+            const ugly = "x=1\ndef f( a,b ):\n  return a+b\n";
+            const result = await Beautifier.beautifyTextProvider(ugly, "scratch.py");
+            expect(result.originalText).toBe(ugly);
+            expect(result.changedText).toContain("x = 1");
+            expect(result.changedText).toContain("def f(a, b):");
+            expect(result.changedText).toContain("return a + b");
+        }, 45000);
+    });
+});
diff --git a/src/htmlContent/problems-panel-table.html b/src/htmlContent/problems-panel-table.html
index 8b797f45b7..60d44d26e4 100644
--- a/src/htmlContent/problems-panel-table.html
+++ b/src/htmlContent/problems-panel-table.html
@@ -28,7 +28,7 @@
             <td>
                 {{#fix.id}}
                 <button class="btn btn-mini table-fix-err-button ph-fix-problem"
-                        data-fixid="{{fix.id}}">
+                        data-fixid="{{fix.id}}" title="{{fix.title}}">
                     {{Strings.FIX}}
                 </button>
                 {{/fix.id}}
diff --git a/src/language/CodeInspection.js b/src/language/CodeInspection.js
index 8ca27655ba..c278421c7e 100644
--- a/src/language/CodeInspection.js
+++ b/src/language/CodeInspection.js
@@ -564,10 +564,14 @@ define(function (require, exports, module) {
                 const fixID = `${mark.metadata}`;
                 let errorMessageHTML = `<a style="cursor:pointer;color: unset;">${_.escape(mark.message)}</a>`;
                 if(documentFixes.get(fixID)){
+                    // the fix's title (when the provider gave one) tells the user what clicking
+                    // Fix will actually do - e.g. LSP code actions can be generators/suppressions
+                    const fixTitle = _.escape(documentFixes.get(fixID).title || "");
                     $problemView = $(`<div class="code-inspection-quick-view-item">
                         <i title="${Strings.CLICK_VIEW_PROBLEM}" style="margin-right: 3px;cursor: pointer;"
                             class="${_getIconClassForType(mark.type, mark.isFixable)}"></i>
-                        <button class="btn btn-mini fix-problem-btn" style="margin-right: 5px;">${Strings.FIX}</button>
+                        <button class="btn btn-mini fix-problem-btn" style="margin-right: 5px;"
+                            title="${fixTitle}">${Strings.FIX}</button>
                         ${errorMessageHTML}
                         <button class="btn btn-mini copy-qv-error-text-btn" title="${Strings.COPY_ERROR}">
                             <i class="fas fa-copy copy-qv-error-text-btn"></i>
@@ -913,6 +917,7 @@ define(function (require, exports, module) {
      *                type:?Type ,
      *                fix: { // an optional fix, if present will show the fix button
      *                     replaceText: "text to replace the offset given below",
+     *                     title: "optional tooltip describing what the fix does",
      *                     rangeOffset: {
      *                         start: number,
      *                         end: number
@@ -930,6 +935,7 @@ define(function (require, exports, module) {
      * @property {?Type} type - The type of the error. Defaults to `Type.WARNING` if unspecified.
      * @property {?Object} fix - An optional fix object.
      * @property {string} fix.replaceText - The text to replace the error with.
+     * @property {?string} fix.title - Optional tooltip on the Fix button describing what the fix does.
      * @property {Object} fix.rangeOffset - The range within the text to replace.
      * @property {number} fix.rangeOffset.start - The start offset of the range.
      * @property {number} fix.rangeOffset.end - The end offset of the range.
diff --git a/src/languageTools/DefaultProviders.js b/src/languageTools/DefaultProviders.js
index 6eeee349e6..089ac0d7eb 100644
--- a/src/languageTools/DefaultProviders.js
+++ b/src/languageTools/DefaultProviders.js
@@ -1052,6 +1052,10 @@ define(function (require, exports, module) {
         var range = edits[0].range;
         return {
             replaceText: edits[0].newText,
+            // the action's human title (e.g. "Generate variable `x`") - shown as the Fix
+            // button's tooltip so the user knows WHAT will be applied before clicking (servers
+            // often offer generators/suppressions, not the rename the message may suggest)
+            title: action.title,
             rangeOffset: {
                 start: editor.indexFromPos({ line: range.start.line, ch: range.start.character }),
                 end: editor.indexFromPos({ line: range.end.line, ch: range.end.character })
diff --git a/src/languageTools/LSPClient.js b/src/languageTools/LSPClient.js
index e6b20d47ec..184095f3d5 100644
--- a/src/languageTools/LSPClient.js
+++ b/src/languageTools/LSPClient.js
@@ -704,7 +704,8 @@ define(function (require, exports, module) {
             serverId: client.serverId,
             command: config.command,
             args: config.args || ["--stdio"],
-            rootUri: rootUri
+            rootUri: rootUri,
+            workspaceConfiguration: config.workspaceConfiguration
         });
 
         const initResult = await conn.execPeer("sendRequest", {
@@ -805,6 +806,10 @@ define(function (require, exports, module) {
      * @param {boolean} [config.completionSnippetSupport] - advertise snippet support in the client
      *        completion capability. Only for servers that refuse to offer completion without it
      *        (vscode-json-language-server); snippet placeholders are stripped on insert.
+     * @param {Object} [config.workspaceConfiguration] - settings tree served node-side to the
+     *        server's workspace/configuration pulls, sections resolved by dotted path (e.g.
+     *        pyrefly pulls section "python" despite our capabilities saying we have none, and
+     *        treats the default null answer as "all diagnostics off").
      * @param {function(Array):Array} [config.filterDiagnostics] - server-specific post-filter for
      *        published diagnostics
      * @return {Promise<LanguageClient|null>} the client, or null if it could not be started
diff --git a/src/nls/root/strings.js b/src/nls/root/strings.js
index 04d3c983a2..002a8e85e8 100644
--- a/src/nls/root/strings.js
+++ b/src/nls/root/strings.js
@@ -1804,6 +1804,7 @@ define({
     "CODE_INTEL_PANEL_DISMISS": "Dismiss",
     // PHP language support (PHPSupport)
     "PHP_INSTALL_TITLE": "PHP Code Intelligence",
+    "PHP_INSTALL_DIALOG_TITLE": "Install PHP Code Intelligence",
     "PHP_INSTALL_MESSAGE": "Install advanced PHP code intelligence?",
     "PHP_INSTALL_ENABLE": "Install",
     "PHP_INSTALL_NOT_NOW": "Not Now",
@@ -1816,12 +1817,41 @@ define({
     "PHP_BENEFIT_ERRORS_SUB": "mistakes flagged as you code",
     "PHP_BENEFIT_NAV": "Navigation",
     "PHP_BENEFIT_NAV_SUB": "go to definition and find usages",
+    "PHP_INSTALL_DIALOG_TEXT": "Advanced completions, error checking, docs and more for PHP.",
+    "PHP_INSTALL_DIALOG_SIZE": "9 MB download",
+    "PHP_INSTALL_LATER_INFO": "You can always install later — the install bar appears whenever a PHP file is open.",
     "PHP_PANEL_TEXT": "PHP code intelligence is off. Install the Intelephense language server (free, ~9 MB download) for completions, error checking, docs and go to definition.",
     "PHP_INSTALLING": "Setting up PHP support — downloading the language server…",
     "PHP_INSTALL_DONE": "PHP code intelligence is ready.",
     "PHP_INSTALL_FAILED": "Could not set up PHP support: {0}. {APP_NAME} will retry when you open a PHP file again.",
     "DESCRIPTION_PHP_CODE_INTELLIGENCE": "false to disable PHP code intelligence (Intelephense). Setting it back to true offers the language server download again.",
     "DESCRIPTION_PHP_LICENSE_KEY": "Intelephense premium licence key (or an absolute path to a key file) enabling premium features like rename and code actions. Not needed if your licence is already in the standard global intelephense licence file.",
+    // Python language support (PythonSupport); LSP_INSTALL_POWERED_BY is shared with PHPSupport
+    "LSP_INSTALL_POWERED_BY": "Powered by",
+    "PYTHON_INSTALL_TITLE": "Python Code Intelligence",
+    "PYTHON_INSTALL_DIALOG_TITLE": "Install Python Code Intelligence",
+    "PYTHON_INSTALL_MESSAGE": "Install advanced Python code intelligence?",
+    "PYTHON_INSTALL_ENABLE": "Install",
+    "PYTHON_INSTALL_NOT_NOW": "Not Now",
+    "PYTHON_POWERED_BY_PYREFLY": "Powered by Pyrefly",
+    "PYTHON_BENEFIT_COMPLETIONS": "Completions",
+    "PYTHON_BENEFIT_COMPLETIONS_SUB": "smart suggestions as you type",
+    "PYTHON_BENEFIT_DOCS": "Docs on hover",
+    "PYTHON_BENEFIT_DOCS_SUB": "function help right in the editor",
+    "PYTHON_BENEFIT_ERRORS": "Error checking",
+    "PYTHON_BENEFIT_ERRORS_SUB": "mistakes flagged as you code",
+    "PYTHON_BENEFIT_NAV": "Navigation",
+    "PYTHON_BENEFIT_NAV_SUB": "go to definition and find usages",
+    "PYTHON_BENEFIT_FORMAT": "Formatting",
+    "PYTHON_BENEFIT_FORMAT_SUB": "one-command code cleanup with Ruff",
+    "PYTHON_INSTALL_DIALOG_TEXT": "Advanced completions, error checking, docs and formatting for Python.",
+    "PYTHON_INSTALL_DIALOG_SIZE": "25 MB download",
+    "PYTHON_INSTALL_LATER_INFO": "You can always install later — the install bar appears whenever a Python file is open.",
+    "PYTHON_PANEL_TEXT": "Python code intelligence is off. Install the Pyrefly language server and Ruff formatter (free, ~25 MB download) for completions, error checking, docs, formatting and go to definition.",
+    "PYTHON_INSTALLING": "Setting up Python support — downloading the language tools…",
+    "PYTHON_INSTALL_DONE": "Python code intelligence is ready.",
+    "PYTHON_INSTALL_FAILED": "Could not set up Python support: {0}. {APP_NAME} will retry when you open a Python file again.",
+    "DESCRIPTION_PYTHON_CODE_INTELLIGENCE": "false to disable Python code intelligence (Pyrefly). Setting it back to true offers the language server download again.",
     // JSON / package.json intelligence (JSONSupport)
     "NPM_VULN_PROVIDER_NAME": "npm Security Advisories",
     "NPM_VULN_MESSAGE": "{0}@{1} is vulnerable: {2} ({3} severity)",
diff --git a/src/styles/brackets.less b/src/styles/brackets.less
index 971b525b9d..d3027d69f3 100644
--- a/src/styles/brackets.less
+++ b/src/styles/brackets.less
@@ -2303,12 +2303,13 @@ a, img {
     }
 }
 
-// PHP install prompt bar (PHPSupport) - find-bar-style banner across the editor top.
-.modal-bar .php-install-bar {
+// Language-server install prompt bar (PHPSupport, PythonSupport) - find-bar-style banner
+// across the editor top.
+.modal-bar .lsp-install-bar {
     display: flex;
     align-items: center;
     gap: 12px;
-    .php-install-bar-text {
+    .lsp-install-bar-text {
         flex: none;      // hug the question so the (i) sits right after it
         min-width: 0;
         overflow: hidden;
@@ -2316,7 +2317,7 @@ a, img {
         white-space: nowrap;
     }
     // sits right after the question; margin-right:auto pushes everything else to the right edge
-    .php-install-bar-info {
+    .lsp-install-bar-info {
         flex: none;
         margin-left: -4px;
         margin-right: auto;
@@ -2324,7 +2325,7 @@ a, img {
         cursor: default;
         &:hover { opacity: 0.9; }
     }
-    .php-intel-powered-by {
+    .lsp-install-bar-powered-by {
         flex: none;
         cursor: pointer;
         white-space: nowrap;
@@ -2335,6 +2336,35 @@ a, img {
     }
 }
 
+// First-time language-server install dialog (PHPSupport, PythonSupport): terse one-liner with an
+// (i) whose hover card lists the benefits, plus a muted "install later" note.
+.lsp-install-dialog-info {
+    opacity: 0.5;
+    cursor: default;
+    &:hover { opacity: 0.9; }
+}
+.lsp-install-dialog-later {
+    opacity: 0.75;
+    margin-bottom: 0;
+}
+.lsp-install-dialog-credit {
+    margin: 14px 0 0;
+    font-size: 12px;
+    span { opacity: 0.6; }
+    a { cursor: pointer; }
+}
+// download size in the footer, left of the action buttons - read at the moment of decision
+.modal-footer .lsp-install-dialog-size {
+    float: left;
+    opacity: 0.65;
+    font-size: 12px;
+    line-height: 30px;   // optically centers against the .btn row
+    i {
+        font-size: 11px;
+        margin-right: 3px;
+    }
+}
+
 // On bright colored toast surfaces (e.g. the PHP install prompt on INFO blue) the link-blue
 // action text is invisible - use high-contrast white bold links there, both themes.
 .notification-popup-container.style-info .ts-code-intel-action,
@@ -4308,6 +4338,11 @@ label input {
         gap: 5px 10px;
         font-size: 13px;
     }
+    // Rows directly under the title (no .ph-tip-sub between): without this the title hugs the
+    // first row tighter than the rows' own visual rhythm and the card looks top-cramped.
+    .ph-tip-title + .ph-tip-rows {
+        margin-top: 6px;
+    }
     .ph-tip-term {
         font-weight: @font-weight-semibold;
         white-space: nowrap;
diff --git a/src/utils/NodeUtils.js b/src/utils/NodeUtils.js
index 38e8c5325b..d22a788ea6 100644
--- a/src/utils/NodeUtils.js
+++ b/src/utils/NodeUtils.js
@@ -128,6 +128,110 @@ define(function (require, exports, module) {
         return utilsConnector.execPeer("_npmInstallInFolder", {moduleNativeDir});
     }
 
+    const DOWNLOAD_PROGRESS_EVENT = "downloadProgress";
+    let _downloadCounter = 0;
+
+    /**
+     * Downloads a URL to a file on disk, fully node-side (native fetch, streamed to disk).
+     * When an expected sha256 is given, a mismatch deletes the file and rejects - a resolved
+     * promise means the file holds exactly the pinned bytes.
+     * This is only available in the native app.
+     *
+     * @param {string} url - download URL (redirects followed)
+     * @param {string} destFile - platform path to write (parent directories created)
+     * @param {Object} [options]
+     * @param {string} [options.sha256] - expected hex digest of the downloaded bytes
+     * @param {function(number, number)} [options.progress] - called with (transferredBytes,
+     *        totalBytes) as the download advances; totalBytes is 0 if the server sent no length
+     * @return {Promise<void>}
+     */
+    async function downloadFile(url, destFile, options) {
+        if(!Phoenix.isNativeApp) {
+            throw new Error("downloadFile not available in browser");
+        }
+        const progress = options && options.progress;
+        _downloadCounter++;
+        const eventName = DOWNLOAD_PROGRESS_EVENT + ".dl" + _downloadCounter;
+        if(progress) {
+            utilsConnector.on(eventName, function (_evt, data) {
+                if(data && data.url === url) {
+                    progress(data.transferred, data.total);
+                }
+            });
+        }
+        try {
+            return await utilsConnector.execPeer("downloadFile", {
+                url: url,
+                destFile: destFile,
+                sha256: (options && options.sha256) || undefined
+            });
+        } finally {
+            if(progress) {
+                utilsConnector.off(eventName);
+            }
+        }
+    }
+
+    /**
+     * Extracts a zip file into a directory node-side (stdlib only, no browser JSZip; creates the
+     * directory if missing, restores unix executable bits recorded in the archive). Python wheels
+     * are plain zips, so this installs those too.
+     * This is only available in the native app.
+     *
+     * @param {string} zipPath - platform path of the zip file
+     * @param {string} destDir - platform path of the directory to extract into
+     * @return {Promise<void>}
+     */
+    async function extractZipFile(zipPath, destDir) {
+        if(!Phoenix.isNativeApp) {
+            throw new Error("extractZipFile not available in browser");
+        }
+        return utilsConnector.execPeer("extractZipFile", {zipPath, destDir});
+    }
+
+    /**
+     * Marks a file as executable (chmod 755); no-op on Windows. For binaries whose archives did
+     * not carry unix mode bits.
+     * This is only available in the native app.
+     *
+     * @param {string} filePath - platform path of the file
+     * @return {Promise<void>}
+     */
+    async function setExecutableBits(filePath) {
+        if(!Phoenix.isNativeApp) {
+            throw new Error("setExecutableBits not available in browser");
+        }
+        return utilsConnector.execPeer("setExecutableBits", {filePath});
+    }
+
+    /**
+     * Runs an executable with the given args, feeding it text on stdin and capturing its output -
+     * a one-shot filter-style invocation (e.g. `ruff format -` for the Python beautifier). No
+     * shell is involved. Resolves with the exit code rather than rejecting on non-zero, so
+     * callers can read stderr for the reason.
+     * This is only available in the native app.
+     *
+     * @param {string} command - platform path of the executable (or a PATH command name)
+     * @param {string[]} [args]
+     * @param {Object} [options]
+     * @param {string} [options.stdinText] - written to the process's stdin, then closed
+     * @param {string} [options.cwd] - working directory
+     * @param {number} [options.timeoutMs] - kill the process and reject after this long
+     * @return {Promise<{code: number, stdout: string, stderr: string}>}
+     */
+    async function execFileWithInput(command, args, options) {
+        if(!Phoenix.isNativeApp) {
+            throw new Error("execFileWithInput not available in browser");
+        }
+        return utilsConnector.execPeer("execFileWithInput", {
+            command: command,
+            args: args || [],
+            stdinText: options && options.stdinText,
+            cwd: options && options.cwd,
+            timeoutMs: options && options.timeoutMs
+        });
+    }
+
     /**
      * Gets an environment variable's value
      * This is only available in the native app
@@ -334,6 +438,10 @@ define(function (require, exports, module) {
     // private apis
     exports._loadNodeExtensionModule = _loadNodeExtensionModule;
     exports._npmInstallInFolder = _npmInstallInFolder;
+    exports.downloadFile = downloadFile;
+    exports.extractZipFile = extractZipFile;
+    exports.setExecutableBits = setExecutableBits;
+    exports.execFileWithInput = execFileWithInput;
 
     // public apis
     exports.fetchURLText = fetchURLText;
diff --git a/test/spec/PythonSupport-test-files/error.py b/test/spec/PythonSupport-test-files/error.py
new file mode 100644
index 0000000000..9d61b8f0d9
--- /dev/null
+++ b/test/spec/PythonSupport-test-files/error.py
@@ -0,0 +1,8 @@
+"""Fixture with deliberate type errors for the Python LSP integration tests."""
+
+count: int = "not a number"
+
+print(undefined_name_here)
+
+value = 42
+print(valu)
diff --git a/test/spec/PythonSupport-test-files/funcs.py b/test/spec/PythonSupport-test-files/funcs.py
new file mode 100644
index 0000000000..f49bada820
--- /dev/null
+++ b/test/spec/PythonSupport-test-files/funcs.py
@@ -0,0 +1,9 @@
+"""Fixture with a documented function for hover / jump-to-definition / completion tests."""
+
+
+def compute_total(prices, tax_rate):
+    """Compute the total price of all items including tax."""
+    return sum(prices) * (1 + tax_rate)
+
+
+print(compute_total([1.5, 2.5], 0.2))