Apply XAML styling fixes

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

.github/actions/spell-check/expect.txt

@@ -1234,8 +1234,6 @@ NOTSRCCOPY
 NOTSRCERASE
 Notupdated
 notwindows
-NOTXORPEN
-Nouveaut
 nowarn
 NOZORDER
 NPH

Cpp.Build.props

@@ -2,34 +2,6 @@
 <Project ToolsVersion="4.0"
   xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 
-  <!--
-    Cold "Rebuild All" ordering fix for native PackageReference projects.
-
-    A handful of native projects use <RestoreProjectStyle>PackageReference</RestoreProjectStyle>
-    (Microsoft.CommandPalette.Extensions, Microsoft.Terminal.UI, PowerToys.MeasureToolCore,
-    FindMyMouse, PowerRenameUILib, runner). For those, the CppWinRT configuration - most importantly
-    the MIDL default <EnableWindowsRuntime>true</EnableWindowsRuntime> that makes IInspectable /
-    IUnknown resolvable - only arrives via the restore-generated obj\*.nuget.g.props.
-
-    On a cold "Rebuild All", MSBuild evaluates the project (resolving imports) before the in-session
-    NuGet restore regenerates those obj props, so MIDL runs in non-WinRT mode and fails with
-    "MIDL2009: undefined symbol IInspectable". Because Microsoft.CommandPalette.Extensions and
-    Microsoft.Terminal.UI are winmd producers consumed (by file path) across the entire Command
-    Palette graph, that single race cascades into dozens of downstream CS0006/CS0234 failures. A
-    second build "works" only because restore has since written the obj props. This is why the
-    RestoreThenBuild PowerShell helper (two separate msbuild invocations) already avoids the issue.
-
-    Statically importing the committed CppWinRT props here makes the WinRT MIDL configuration present
-    at evaluation time regardless of restore ordering, so it is durable across Visual Studio, the
-    build scripts, and CI. It is scoped to PackageReference-style vcxproj only (the ~100 other native
-    projects already import this same committed package directly), and the Exists() guard plus
-    CppWinRT's own import guards keep it a safe no-op once restore has run.
-  -->
-  <Import Project="$(MSBuildThisFileDirectory)packages\Microsoft.Windows.CppWinRT.2.0.250303.1\build\native\Microsoft.Windows.CppWinRT.props"
-          Condition="'$(MSBuildProjectExtension)' == '.vcxproj'
-                     and '$(RestoreProjectStyle)' == 'PackageReference'
-                     and Exists('$(MSBuildThisFileDirectory)packages\Microsoft.Windows.CppWinRT.2.0.250303.1\build\native\Microsoft.Windows.CppWinRT.props')" />
-
   <!-- Skip building C++ test projects when BuildTests=false -->
   <PropertyGroup Condition="'$(_IsSkippedTestProject)' == 'true'">
     <UsePrecompiledHeaders>false</UsePrecompiledHeaders>

Cpp.Build.targets

@@ -13,25 +13,4 @@
   -->
   <Import Project="$(VcpkgRoot)\scripts\buildsystems\msbuild\vcpkg.targets"
           Condition="'$(MSBuildProjectExtension)' == '.vcxproj' and '$(VcpkgEnabled)' == 'true' and Exists('$(VcpkgRoot)\scripts\buildsystems\msbuild\vcpkg.targets')" />
-
-  <!--
-    Cold "Rebuild All" ordering fix (matching partner to the CppWinRT props import in Cpp.Build.props).
-
-    Native PackageReference projects (Microsoft.CommandPalette.Extensions, Microsoft.Terminal.UI,
-    PowerToys.MeasureToolCore, FindMyMouse, PowerRenameUILib, runner) receive the CppWinRT MIDL
-    metadata wiring (CppWinRTMidlResponseFile, AdditionalMetadataDirectories, the MdMerge step that
-    produces the .winmd) only from the restore-generated obj\*.nuget.g.targets. On a cold "Rebuild
-    All" that file has not been regenerated yet when the project is evaluated, so MIDL cannot resolve
-    IInspectable / IUnknown and the Command Palette graph fails with MIDL2009 - until a second build.
-
-    Importing the committed CppWinRT targets here - after Microsoft.Cpp.targets, exactly where the
-    statically-wired native projects put their own CppWinRT ExtensionTargets import - makes that wiring
-    present regardless of restore ordering. Scoped to PackageReference-style vcxproj only; the Exists()
-    guard and CppWinRT's own import guards make it a safe no-op once restore has run or for the ~100
-    native projects that already import this committed package directly.
-  -->
-  <Import Project="$(MSBuildThisFileDirectory)packages\Microsoft.Windows.CppWinRT.2.0.250303.1\build\native\Microsoft.Windows.CppWinRT.targets"
-          Condition="'$(MSBuildProjectExtension)' == '.vcxproj'
-                     and '$(RestoreProjectStyle)' == 'PackageReference'
-                     and Exists('$(MSBuildThisFileDirectory)packages\Microsoft.Windows.CppWinRT.2.0.250303.1\build\native\Microsoft.Windows.CppWinRT.targets')" />
 </Project>

Directory.Packages.props

@@ -26,7 +26,7 @@
     <PackageVersion Include="CommunityToolkit.WinUI.Controls.Sizers" Version="8.2.251219" />
     <PackageVersion Include="CommunityToolkit.WinUI.Converters" Version="8.2.251219" />
     <PackageVersion Include="CommunityToolkit.WinUI.Extensions" Version="8.2.251219" />
-    <PackageVersion Include="CommunityToolkit.WinUI.UI.Controls.DataGrid" Version="7.1.2" />
+    <PackageVersion Include="CommunityToolkit.WinUI.UI.Controls.DataGrid" Version="7.1.2" /> 
     <PackageVersion Include="CommunityToolkit.Labs.WinUI.Controls.MarkdownTextBlock" Version="0.1.260116-build.2514" />
     <PackageVersion Include="ControlzEx" Version="6.0.0" />
     <PackageVersion Include="HelixToolkit" Version="2.24.0" />
@@ -38,7 +38,7 @@
     <PackageVersion Include="Mages" Version="3.0.0" />
     <PackageVersion Include="Markdig.Signed" Version="0.34.0" />
     <!-- Including MessagePack to force version, since it's used by StreamJsonRpc but contains vulnerabilities. After StreamJsonRpc updates the version of MessagePack, we can upgrade StreamJsonRpc instead. -->
-    <PackageVersion Include="MessagePack" Version="3.1.7" />
+    <PackageVersion Include="MessagePack" Version="3.1.3" />
     <PackageVersion Include="Microsoft.CodeAnalysis.NetAnalyzers" Version="10.0.102" />
     <PackageVersion Include="Microsoft.CommandPalette.Extensions" Version="0.9.260303001" />
     <PackageVersion Include="Microsoft.Data.Sqlite" Version="10.0.8" />
@@ -64,7 +64,7 @@
     <PackageVersion Include="Microsoft.SemanticKernel.Connectors.MistralAI" Version="1.71.0-alpha" />
     <PackageVersion Include="Microsoft.SemanticKernel.Connectors.Ollama" Version="1.71.0-alpha" />
     <PackageVersion Include="Microsoft.Toolkit.Uwp.Notifications" Version="7.1.2" />
-    <PackageVersion Include="Microsoft.Web.WebView2" Version="1.0.4022.49" />
+    <PackageVersion Include="Microsoft.Web.WebView2" Version="1.0.3719.77" />
     <!-- Package Microsoft.Win32.SystemEvents added as a hack for being able to exclude the runtime assets so they don't conflict with 8.0.1. This is a dependency of System.Drawing.Common but the 8.0.1 version wasn't published to nuget. -->
     <PackageVersion Include="Microsoft.Win32.SystemEvents" Version="10.0.8" />
     <PackageVersion Include="Microsoft.WindowsPackageManager.ComInterop" Version="1.10.340" />
@@ -76,7 +76,7 @@
       This is present due to a bug in CsWinRT where WPF projects cause the analyzer to fail.
 	-->
     <PackageVersion Include="Microsoft.Windows.CsWinRT" Version="2.2.0" />
-    <PackageVersion Include="Microsoft.Windows.ImplementationLibrary" Version="1.0.250325.1" />
+    <PackageVersion Include="Microsoft.Windows.ImplementationLibrary" Version="1.0.250325.1"/>
     <PackageVersion Include="Microsoft.Windows.SDK.BuildTools" Version="10.0.26100.6901" />
     <PackageVersion Include="Microsoft.WindowsAppSDK" Version="2.2.0" />
     <PackageVersion Include="Microsoft.WindowsAppSDK.Foundation" Version="2.1.0" />
@@ -151,4 +151,4 @@
     <PackageVersion Include="Microsoft.VariantAssignment.Client" Version="2.4.17140001" />
     <PackageVersion Include="Microsoft.VariantAssignment.Contract" Version="3.0.16990001" />
   </ItemGroup>
-</Project>
+</Project>

doc/devdocs/modules/advancedpaste-python-scripts.md

@@ -0,0 +1,285 @@
+# Advanced Paste – Python Scripts
+
+Advanced Paste supports user-defined Python scripts that transform clipboard content. Scripts are
+discovered automatically from a configurable folder and appear as actions in the Advanced Paste UI.
+
+## Quick start
+
+1. Open the scripts folder — by default `%LOCALAPPDATA%\Microsoft\PowerToys\AdvancedPaste\Scripts`.
+   You can change this in **Settings → Advanced Paste → Python scripts → Scripts folder**.
+2. Drop a `.py` file into the folder.
+3. Define one `advanced_paste_from_<input>_to_<output>` function (see [Writing a script](#writing-a-script)).
+4. Open the Advanced Paste UI (`Win+Shift+V`) — your script will appear in the action list.
+
+> **Important:** Each `.py` file must define exactly one `advanced_paste_from_<input>_to_<output>`
+> function. Scripts with zero or multiple such functions are ignored.
+
+## Writing a script
+
+You write a single Python function whose **name** declares both what clipboard input it accepts
+and what output type it produces.
+No imports from PowerToys are needed — zero setup, zero dependencies on our side.
+
+### Function naming convention
+
+The function name follows the pattern:
+
+```
+advanced_paste_from_<input>_to_<output>(<param>)
+```
+
+**Input types** (what the function receives):
+
+| Input | Parameter | When it runs |
+|-------|-----------|--------------|
+| `text` | `str` — clipboard text | Clipboard has text |
+| `html` | `str` — clipboard HTML | Clipboard has HTML |
+| `image` | `str` — path to temp image file | Clipboard has an image |
+| `audio` | `str` — path to audio file | Clipboard has an audio file |
+| `video` | `str` — path to video file | Clipboard has a video file |
+| `files` | `list[str]` — file paths | Clipboard has files |
+
+**Output types** (what the function produces — declared via `_to_` suffix):
+
+| Output | Effect |
+|--------|--------|
+| `text` | Sets clipboard to text |
+| `html` | Sets clipboard to HTML |
+| `image` | Sets clipboard to image |
+| `audio` | Sets clipboard to audio file |
+| `video` | Sets clipboard to video file |
+| `file` | Sets clipboard to a file |
+| `files` | Sets clipboard to multiple files |
+
+### Return value
+
+The return value is interpreted according to the declared output type:
+
+| Output type | Expected return value |
+|-------------|---------------------|
+| `text` | `str` (or any value — will be converted via `str()`) |
+| `html` | `str` containing HTML |
+| `image` | `str` or `pathlib.Path` pointing to an image file |
+| `file` | `str` or `pathlib.Path` pointing to a file |
+| `files` | `list` of `str`/`pathlib.Path` file paths |
+
+Returning `None` produces an empty result (no-op).
+
+## Examples
+
+### Minimal — uppercase text
+
+```python
+def advanced_paste_from_text_to_text(text):
+    return text.upper()
+```
+
+That's it. No headers required, no imports from PowerToys.
+
+### With optional metadata
+
+```python
+# @advancedpaste:name   Reverse Text
+# @advancedpaste:desc   Reverses clipboard text character by character
+
+def advanced_paste_from_text_to_text(text):
+    return text[::-1]
+```
+
+### Text to HTML
+
+```python
+# @advancedpaste:name   Markdown Table to HTML
+# @advancedpaste:desc   Convert a markdown table to an HTML table
+
+def advanced_paste_from_text_to_html(text):
+    headers = text.splitlines()[0].split("|")
+    return f"<table><tr>{''.join(f'<th>{h.strip()}</th>' for h in headers if h.strip())}</tr></table>"
+```
+
+### Image to text (OCR)
+
+```python
+# @advancedpaste:requires pytesseract
+
+def advanced_paste_from_image_to_text(image_path):
+    import pytesseract
+    return pytesseract.image_to_string(image_path).strip()
+```
+
+### Save text as file
+
+```python
+import os
+from pathlib import Path
+import tempfile
+
+def advanced_paste_from_text_to_file(text):
+    # Use ADVANCED_PASTE_WORK_DIR for WSL compatibility; falls back to temp dir on Windows.
+    out_dir = os.environ.get("ADVANCED_PASTE_WORK_DIR") or tempfile.gettempdir()
+    out = Path(out_dir) / "clipboard.txt"
+    out.write_text(text, encoding="utf-8")
+    return out
+```
+
+### Image processing (image → image)
+
+```python
+import os
+from PIL import Image
+from pathlib import Path
+import tempfile
+
+def advanced_paste_from_image_to_image(image_path):
+    """Convert image to grayscale."""
+    img = Image.open(image_path).convert("L")
+    out_dir = os.environ.get("ADVANCED_PASTE_WORK_DIR") or tempfile.gettempdir()
+    out = Path(out_dir) / "gray.png"
+    img.save(out)
+    return out
+```
+
+### File listing (files → text)
+
+```python
+import os
+
+def advanced_paste_from_files_to_text(file_paths):
+    lines = []
+    for p in file_paths:
+        size = os.path.getsize(p)
+        lines.append(f"{os.path.basename(p)} ({size} bytes)")
+    return "\n".join(lines)
+```
+
+## Header tags
+
+All header tags are **optional**. Tags are placed in comment lines at the top of the script.
+
+| Tag | Description |
+|-----|-------------|
+| `name` | Display name in the Advanced Paste UI. If omitted, the filename is used. |
+| `desc` | Short description / tooltip. |
+| `disabled` | Presence of this tag disables the script (it won't appear in the UI). |
+| `requires` | Declare Python package dependencies (see [Dependencies](#declaring-dependencies)). |
+
+### Example header
+
+```python
+# @advancedpaste:name   My Formatter
+# @advancedpaste:desc   Formats clipboard text as markdown table
+```
+
+To disable a script without deleting it, add:
+
+```python
+# @advancedpaste:disabled
+```
+
+Remove the line to re-enable.
+
+## Declaring dependencies
+
+Use `requires` to declare Python packages the script needs:
+
+```python
+# @advancedpaste:requires PIL=Pillow
+# @advancedpaste:requires cv2=opencv-python-headless numpy requests
+```
+
+Each token is either:
+
+- **`import_name`** — the pip package is assumed to have the same name (e.g. `requests`).
+- **`import_name=pip_package`** — when the import name differs from the pip package
+  (e.g. `cv2=opencv-python-headless`, `PIL=Pillow`).
+
+### Automatic import detection
+
+Advanced Paste also scans the script body for `import` and `from ... import` statements
+and cross-references them against the Python standard library. Any non-stdlib import
+that is not already installed triggers a prompt to install it automatically.
+
+## Security — script trust
+
+The first time a script is executed (or after it has been modified), Advanced Paste
+shows a confirmation dialog. Upon approval the SHA-256 hash of the script is stored.
+Subsequent runs of the unchanged file skip the dialog.
+
+## Error handling
+
+When a script fails, Advanced Paste extracts the Python traceback from stderr and
+displays a user-friendly summary in the UI:
+
+- **ModuleNotFoundError** — identifies the missing module and suggests installing it.
+- **SyntaxError** — shows the file and line number.
+- **Timeout** — shows the configured timeout value (default 30 s; configurable in Settings).
+- **Other errors** — shows the last line of the traceback as a summary, with the full
+  traceback available in the expandable *Details* section.
+
+## Settings
+
+The Python scripts feature uses a **mode selector** (dropdown) with three options:
+
+| Mode | Description |
+|------|-------------|
+| **Disabled** | Python scripts are not active. |
+| **Windows** | Scripts run using a native Windows Python interpreter. |
+| **WSL** | Scripts run inside Windows Subsystem for Linux. |
+
+Each mode maintains its own independent settings (scripts folder, interpreter path, etc.),
+so switching between Windows and WSL does not lose your previous configuration.
+
+### Windows mode settings
+
+| Setting | Description | Default |
+|---------|-------------|---------|
+| Scripts folder | Folder to scan for `.py` scripts. | `%LOCALAPPDATA%\Microsoft\PowerToys\AdvancedPaste\Scripts` |
+| Python interpreter | Path to the Python executable. Leave blank for auto-detection. | *(auto-detect)* |
+
+### WSL mode settings
+
+| Setting | Description | Default |
+|---------|-------------|---------|
+| Scripts folder | Folder to scan for `.py` scripts (Windows path — auto-translated to `/mnt/...`). | `%LOCALAPPDATA%\Microsoft\PowerToys\AdvancedPaste\Scripts` |
+| WSL distribution | Which WSL distro to use (e.g. `Ubuntu`). Leave blank for the default distribution. | *(default)* |
+
+### Scripts list
+
+The Settings page shows a read-only list of discovered scripts. For each script you can see:
+
+- **Name** — from `@advancedpaste:name` tag, or the filename if not set.
+- **Description** — from `@advancedpaste:desc` tag.
+- **Conversion** — the input → output types detected from the function name (e.g. "text → image").
+
+The list is **not editable** from Settings. To change a script's name, description, enabled state,
+or any other metadata, open the script file directly (click the "Open in editor" button) and edit
+the `# @advancedpaste:...` header tags. After saving, click **Refresh** in Settings to reload.
+
+### WSL mode details
+
+When **WSL** mode is selected:
+
+- Scripts are executed via `wsl.exe bash -l -c "python3 ..."` using the configured distribution.
+- The scripts folder remains on the Windows filesystem; paths are automatically translated
+  to `/mnt/c/...` format for WSL access.
+- Package installation uses `pip3 install` inside the WSL environment.
+- Output files from scripts must be written under `/mnt/` (the Windows-mounted filesystem)
+  so they can be accessed from Windows. The runner sets the `ADVANCED_PASTE_WORK_DIR` environment
+  variable to a temp directory under `/mnt/c/...` — use it instead of `tempfile.gettempdir()`
+  when producing file output for cross-platform compatibility.
+
+> **Tip:** If you have Python installed only in WSL (not on Windows), select WSL mode
+> to use your existing WSL Python environment with all its packages.
+
+## Tips
+
+- Each `.py` file must contain exactly one `advanced_paste_from_<input>_to_<output>` function.
+  If you need to handle multiple input types, create separate script files for each.
+- A `.py` file without any matching function is ignored — use this for helper modules
+  that other scripts can import.
+- Scripts can be tested from the command line:
+  ```
+  echo {"format":["text"],"text":"hello"} | python _runner.py my_script.py
+  ```
+- The script's directory is added to `sys.path` at runtime, so you can import sibling `.py`
+  files as helper modules.

src/common/COMUtils/packages.config

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="Microsoft.Windows.ImplementationLibrary" version="1.0.260126.7" targetFramework="native" />
-</packages>
+  <package id="Microsoft.Windows.ImplementationLibrary" version="1.0.250325.1" targetFramework="native" />
+</packages>

src/modules/AdvancedPaste/AdvancedPaste.UnitTests/Mocks/IntegrationTestUserSettings.cs

@@ -47,8 +47,6 @@ internal sealed class IntegrationTestUserSettings : IUserSettings
 
     public bool ShowCustomPreview => false;
 
-    public bool ShowAIPaste => true;
-
     public bool CloseAfterLosingFocus => false;
 
     public bool EnableClipboardPreview => true;
@@ -59,6 +57,22 @@ internal sealed class IntegrationTestUserSettings : IUserSettings
 
     public PasteAIConfiguration PasteAIConfiguration => _configuration;
 
+    public IReadOnlyList<AdvancedPastePythonScriptAction> PythonScriptActions => Array.Empty<AdvancedPastePythonScriptAction>();
+
+    public string PythonScriptsFolder => string.Empty;
+
+    public string PythonExecutablePath => string.Empty;
+
+    public bool PythonUseWsl => false;
+
+    public string PythonWslDistribution => string.Empty;
+
+    public int PythonScriptTimeoutSeconds => 30;
+
+    public bool IsPythonScriptsEnabled => true;
+
+    public IReadOnlyDictionary<string, string> TrustedScriptHashes => new Dictionary<string, string>();
+
     public event EventHandler Changed;
 
     public Task SetActiveAIProviderAsync(string providerId)
@@ -67,4 +81,8 @@ internal sealed class IntegrationTestUserSettings : IUserSettings
         Changed?.Invoke(this, EventArgs.Empty);
         return Task.CompletedTask;
     }
+
+    public void StoreTrustedScriptHash(string scriptPath, string hash)
+    {
+    }
 }

src/modules/AdvancedPaste/AdvancedPaste.UnitTests/ServicesTests/PythonScriptServiceTests.cs

@@ -0,0 +1,560 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+using AdvancedPaste.Helpers;
+using AdvancedPaste.Services.PythonScripts;
+using AdvancedPaste.UnitTests.Mocks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace AdvancedPaste.UnitTests.ServicesTests;
+
+[TestClass]
+public sealed class PythonScriptServiceTests
+{
+    private PythonScriptService _service;
+
+    [TestInitialize]
+    public void Setup()
+    {
+        _service = new PythonScriptService(new IntegrationTestUserSettings());
+    }
+
+    [TestMethod]
+    public void MergeWithAutoDetectedImports_DetectsSimpleImports()
+    {
+        var lines = new[]
+        {
+            "# @advancedpaste:name test",
+            "import requests",
+            "import numpy",
+            "import os",
+            "import sys",
+        };
+
+        var result = PythonScriptService.MergeWithAutoDetectedImports(lines, []);
+
+        Assert.AreEqual(2, result.Count); // requests + numpy; os and sys are stdlib
+        Assert.IsTrue(result.Any(r => r.ImportName == "requests" && r.PipPackage == "requests"));
+        Assert.IsTrue(result.Any(r => r.ImportName == "numpy" && r.PipPackage == "numpy"));
+    }
+
+    [TestMethod]
+    public void MergeWithAutoDetectedImports_DetectsFromImports()
+    {
+        var lines = new[]
+        {
+            "from PIL import Image",
+            "from markitdown import MarkItDown",
+        };
+
+        var result = PythonScriptService.MergeWithAutoDetectedImports(lines, []);
+
+        Assert.AreEqual(2, result.Count);
+        Assert.IsTrue(result.Any(r => r.ImportName == "PIL" && r.PipPackage == "Pillow"));
+        Assert.IsTrue(result.Any(r => r.ImportName == "markitdown" && r.PipPackage == "markitdown"));
+    }
+
+    [TestMethod]
+    public void MergeWithAutoDetectedImports_WellKnownMappings()
+    {
+        var lines = new[]
+        {
+            "import cv2",
+            "import win32clipboard",
+            "import yaml",
+        };
+
+        var result = PythonScriptService.MergeWithAutoDetectedImports(lines, []);
+
+        Assert.AreEqual(3, result.Count);
+        Assert.IsTrue(result.Any(r => r.ImportName == "cv2" && r.PipPackage == "opencv-python"));
+        Assert.IsTrue(result.Any(r => r.ImportName == "win32clipboard" && r.PipPackage == "pywin32"));
+        Assert.IsTrue(result.Any(r => r.ImportName == "yaml" && r.PipPackage == "PyYAML"));
+    }
+
+    [TestMethod]
+    public void MergeWithAutoDetectedImports_ExplicitRequirementsTakePrecedence()
+    {
+        var lines = new[]
+        {
+            "import cv2",
+            "import requests",
+        };
+
+        var explicitReqs = new List<PythonRequirement>
+        {
+            new("cv2", "opencv-python-headless"),
+        };
+
+        var result = PythonScriptService.MergeWithAutoDetectedImports(lines, explicitReqs);
+
+        Assert.AreEqual(2, result.Count);
+
+        // cv2 should use the explicit pip package name, not the well-known mapping
+        var cv2Req = result.First(r => r.ImportName == "cv2");
+        Assert.AreEqual("opencv-python-headless", cv2Req.PipPackage);
+
+        // requests should be auto-detected
+        Assert.IsTrue(result.Any(r => r.ImportName == "requests"));
+    }
+
+    [TestMethod]
+    public void MergeWithAutoDetectedImports_SkipsStdlib()
+    {
+        var lines = new[]
+        {
+            "import os",
+            "import sys",
+            "import json",
+            "import io",
+            "import pathlib",
+            "import tempfile",
+            "import subprocess",
+        };
+
+        var result = PythonScriptService.MergeWithAutoDetectedImports(lines, []);
+
+        Assert.AreEqual(0, result.Count);
+    }
+
+    [TestMethod]
+    public void MergeWithAutoDetectedImports_SkipsComments()
+    {
+        var lines = new[]
+        {
+            "# import requests",
+            "# from PIL import Image",
+            "import json",
+        };
+
+        var result = PythonScriptService.MergeWithAutoDetectedImports(lines, []);
+
+        Assert.AreEqual(0, result.Count);
+    }
+
+    [TestMethod]
+    public void MergeWithAutoDetectedImports_HandlesMultipleImportsOnOneLine()
+    {
+        var lines = new[]
+        {
+            "import requests, numpy, pandas",
+        };
+
+        var result = PythonScriptService.MergeWithAutoDetectedImports(lines, []);
+
+        Assert.AreEqual(3, result.Count);
+        Assert.IsTrue(result.Any(r => r.ImportName == "requests"));
+        Assert.IsTrue(result.Any(r => r.ImportName == "numpy"));
+        Assert.IsTrue(result.Any(r => r.ImportName == "pandas"));
+    }
+
+    [TestMethod]
+    public void MergeWithAutoDetectedImports_HandlesSubmoduleImport()
+    {
+        var lines = new[]
+        {
+            "import win32com.client",
+            "from llama_cpp import Llama",
+        };
+
+        var result = PythonScriptService.MergeWithAutoDetectedImports(lines, []);
+
+        Assert.AreEqual(2, result.Count);
+        Assert.IsTrue(result.Any(r => r.ImportName == "win32com" && r.PipPackage == "pywin32"));
+        Assert.IsTrue(result.Any(r => r.ImportName == "llama_cpp" && r.PipPackage == "llama-cpp-python"));
+    }
+
+    [TestMethod]
+    public void ParsePythonError_ModuleNotFoundError()
+    {
+        var stderr = """
+            Traceback (most recent call last):
+              File "C:\scripts\reverse.py", line 4, in <module>
+                import win32clipboard
+            ModuleNotFoundError: No module named 'win32clipboard'
+            """;
+
+        var (summary, details) = PythonScriptService.ParsePythonError(stderr);
+
+        Assert.IsTrue(summary.Contains("reverse.py"), $"Summary should mention the script: {summary}");
+        Assert.IsTrue(summary.Contains("line 4"), $"Summary should mention the line: {summary}");
+        Assert.IsTrue(summary.Contains("win32clipboard"), $"Summary should mention the module: {summary}");
+        Assert.IsTrue(summary.Contains("pywin32"), $"Summary should suggest pip package: {summary}");
+        Assert.IsTrue(!string.IsNullOrEmpty(details));
+    }
+
+    [TestMethod]
+    public void ParsePythonError_SyntaxError()
+    {
+        var stderr = """
+            File "test.py", line 5
+                def foo(
+                       ^
+            SyntaxError: unexpected EOF while parsing
+            """;
+
+        var (summary, details) = PythonScriptService.ParsePythonError(stderr);
+
+        Assert.IsTrue(summary.Contains("test.py"), $"Summary should mention the script: {summary}");
+        Assert.IsTrue(summary.Contains("line 5"), $"Summary should mention the line: {summary}");
+        Assert.IsTrue(summary.Contains("Python syntax error:"), $"Summary: {summary}");
+        Assert.IsTrue(!string.IsNullOrEmpty(details));
+    }
+
+    [TestMethod]
+    public void ParsePythonError_SyntaxErrorWithColumn()
+    {
+        var stderr = "  File \"script.py\", line 3\n    x = (1 +\n        ^\nSyntaxError: '(' was never closed\n";
+
+        var (summary, details) = PythonScriptService.ParsePythonError(stderr);
+
+        Assert.IsTrue(summary.Contains("script.py"), $"Summary should mention the script: {summary}");
+        Assert.IsTrue(summary.Contains("line 3"), $"Summary should mention the line: {summary}");
+        Assert.IsTrue(summary.Contains("col"), $"Summary should mention the column: {summary}");
+        Assert.IsTrue(summary.Contains("Python syntax error:"), $"Summary: {summary}");
+        Assert.IsTrue(!string.IsNullOrEmpty(details));
+    }
+
+    [TestMethod]
+    public void ParsePythonError_GenericError()
+    {
+        var stderr = """
+            Traceback (most recent call last):
+              File "test.py", line 10, in <module>
+                result = 1 / 0
+            ZeroDivisionError: division by zero
+            """;
+
+        var (summary, details) = PythonScriptService.ParsePythonError(stderr);
+
+        Assert.IsTrue(summary.Contains("test.py"), $"Summary should mention the script: {summary}");
+        Assert.IsTrue(summary.Contains("line 10"), $"Summary should mention the line: {summary}");
+        Assert.IsTrue(summary.Contains("ZeroDivisionError"), $"Summary: {summary}");
+        Assert.IsTrue(!string.IsNullOrEmpty(details));
+    }
+
+    [TestMethod]
+    public void ParsePythonError_NestedTraceback_ShowsLastFrame()
+    {
+        var stderr = """
+            Traceback (most recent call last):
+              File "main.py", line 5, in <module>
+                helper()
+              File "helper.py", line 12, in helper
+                do_work()
+              File "worker.py", line 8, in do_work
+                raise RuntimeError("bad state")
+            RuntimeError: bad state
+            """;
+
+        var (summary, details) = PythonScriptService.ParsePythonError(stderr);
+
+        Assert.IsTrue(summary.Contains("worker.py"), $"Summary should mention the last script in the chain: {summary}");
+        Assert.IsTrue(summary.Contains("line 8"), $"Summary should mention the line of the last frame: {summary}");
+        Assert.IsTrue(summary.Contains("bad state"), $"Summary should contain the error message: {summary}");
+    }
+
+    [TestMethod]
+    public void ParsePythonError_EmptyStderr()
+    {
+        var (summary, details) = PythonScriptService.ParsePythonError(string.Empty);
+
+        Assert.IsTrue(!string.IsNullOrEmpty(summary));
+        Assert.AreEqual(string.Empty, details);
+    }
+
+    [TestMethod]
+    public void ParsePythonError_NoTraceback_PlainStderr()
+    {
+        var stderr = "Something went wrong in the script\n";
+
+        var (summary, details) = PythonScriptService.ParsePythonError(stderr);
+
+        // No File "..." reference, so no location — just the message
+        Assert.IsTrue(summary.Contains("Something went wrong"), $"Summary: {summary}");
+        Assert.IsFalse(summary.Contains("line"), $"Summary should not contain 'line' without a traceback: {summary}");
+    }
+
+    [TestMethod]
+    public void ExtractLastTracebackLocation_BasicTraceback()
+    {
+        var lines = new[]
+        {
+            "Traceback (most recent call last):",
+            "  File \"script.py\", line 10, in <module>",
+            "    result = 1 / 0",
+            "ZeroDivisionError: division by zero",
+        };
+
+        var location = PythonScriptService.ExtractLastTracebackLocation(lines);
+
+        Assert.IsNotNull(location);
+        Assert.AreEqual("script.py", location.Value.FileName);
+        Assert.AreEqual(10, location.Value.Line);
+        Assert.IsNull(location.Value.Column);
+    }
+
+    [TestMethod]
+    public void ExtractLastTracebackLocation_WithCaret()
+    {
+        var lines = new[]
+        {
+            "  File \"test.py\", line 5",
+            "    def foo(",
+            "           ^",
+            "SyntaxError: unexpected EOF while parsing",
+        };
+
+        var location = PythonScriptService.ExtractLastTracebackLocation(lines);
+
+        Assert.IsNotNull(location);
+        Assert.AreEqual("test.py", location.Value.FileName);
+        Assert.AreEqual(5, location.Value.Line);
+        Assert.IsNotNull(location.Value.Column);
+    }
+
+    [TestMethod]
+    public void ExtractLastTracebackLocation_FullPath_ReturnsBasename()
+    {
+        var lines = new[]
+        {
+            "Traceback (most recent call last):",
+            "  File \"C:\\Users\\user\\scripts\\my_script.py\", line 42, in <module>",
+            "    some_call()",
+            "ValueError: invalid value",
+        };
+
+        var location = PythonScriptService.ExtractLastTracebackLocation(lines);
+
+        Assert.IsNotNull(location);
+        Assert.AreEqual("my_script.py", location.Value.FileName);
+        Assert.AreEqual(42, location.Value.Line);
+    }
+
+    [TestMethod]
+    public void ExtractLastTracebackLocation_NoFileLine_ReturnsNull()
+    {
+        var lines = new[]
+        {
+            "Some random error output",
+            "No traceback here",
+        };
+
+        var location = PythonScriptService.ExtractLastTracebackLocation(lines);
+
+        Assert.IsNull(location);
+    }
+
+    [TestMethod]
+    public void ParsePipInstallError_ExtractsErrorLine()
+    {
+        var stderr = """
+            Collecting some-package
+              Downloading some-package-1.0.tar.gz (15 kB)
+            ERROR: Could not find a version that satisfies the requirement some-package (from versions: none)
+            ERROR: No matching distribution found for some-package
+            """;
+
+        var (summary, fullStderr) = PythonScriptService.ParsePipInstallError(stderr);
+
+        Assert.IsTrue(summary.Contains("No matching distribution"), $"Summary should contain the last ERROR line: {summary}");
+        Assert.IsTrue(!string.IsNullOrEmpty(fullStderr));
+    }
+
+    [TestMethod]
+    public void ParsePipInstallError_NoErrorPrefix_UsesLastLine()
+    {
+        var stderr = "permission denied: /usr/lib/python3/dist-packages\n";
+
+        var (summary, fullStderr) = PythonScriptService.ParsePipInstallError(stderr);
+
+        Assert.IsTrue(summary.Contains("permission denied"), $"Summary: {summary}");
+        Assert.IsTrue(!string.IsNullOrEmpty(fullStderr));
+    }
+
+    [TestMethod]
+    public void ParsePipInstallError_EmptyStderr()
+    {
+        var (summary, fullStderr) = PythonScriptService.ParsePipInstallError(string.Empty);
+
+        Assert.AreEqual("unknown error", summary);
+        Assert.AreEqual(string.Empty, fullStderr);
+    }
+
+    [TestMethod]
+    public void ReadMetadata_FunctionNameDeterminesFormat_Text()
+    {
+        // The new interface uses function names like advanced_paste_from_text_to_text(...)
+        // to determine supported formats, not parameter signatures.
+        var scriptPath = CreateTempScript("def advanced_paste_from_text_to_text(text):\n    return text.upper()\n");
+        var metadata = _service.ReadMetadata(scriptPath);
+
+        Assert.IsNotNull(metadata);
+        Assert.AreEqual(Models.ClipboardFormat.Text, metadata.SupportedFormats);
+        Assert.AreEqual("text", metadata.OutputTypeHint);
+        File.Delete(scriptPath);
+    }
+
+    [TestMethod]
+    public void ReadMetadata_FunctionNameDeterminesFormat_Html()
+    {
+        var scriptPath = CreateTempScript("def advanced_paste_from_html_to_text(html: str) -> str:\n    return html\n");
+        var metadata = _service.ReadMetadata(scriptPath);
+
+        Assert.IsNotNull(metadata);
+        Assert.AreEqual(Models.ClipboardFormat.Html, metadata.SupportedFormats);
+        Assert.AreEqual("text", metadata.OutputTypeHint);
+        File.Delete(scriptPath);
+    }
+
+    [TestMethod]
+    public void ReadMetadata_FunctionNameDeterminesFormat_Image()
+    {
+        var scriptPath = CreateTempScript("def advanced_paste_from_image_to_text(image_path):\n    return 'desc'\n");
+        var metadata = _service.ReadMetadata(scriptPath);
+
+        Assert.IsNotNull(metadata);
+        Assert.AreEqual(Models.ClipboardFormat.Image, metadata.SupportedFormats);
+        Assert.AreEqual("text", metadata.OutputTypeHint);
+        File.Delete(scriptPath);
+    }
+
+    [TestMethod]
+    public void ReadMetadata_FunctionNameDeterminesFormat_Files()
+    {
+        var scriptPath = CreateTempScript("def advanced_paste_from_files_to_text(file_paths):\n    return ''\n");
+        var metadata = _service.ReadMetadata(scriptPath);
+
+        Assert.IsNotNull(metadata);
+        Assert.AreEqual(Models.ClipboardFormat.File, metadata.SupportedFormats);
+        Assert.AreEqual("text", metadata.OutputTypeHint);
+        File.Delete(scriptPath);
+    }
+
+    [TestMethod]
+    public void ReadMetadata_OutputTypeHint_Image()
+    {
+        var scriptPath = CreateTempScript("def advanced_paste_from_text_to_image(text):\n    return '/path/img.png'\n");
+        var metadata = _service.ReadMetadata(scriptPath);
+
+        Assert.IsNotNull(metadata);
+        Assert.AreEqual("image", metadata.OutputTypeHint);
+        File.Delete(scriptPath);
+    }
+
+    [TestMethod]
+    public void ReadMetadata_OutputTypeHint_File()
+    {
+        var scriptPath = CreateTempScript("def advanced_paste_from_text_to_file(text):\n    return '/path/out.txt'\n");
+        var metadata = _service.ReadMetadata(scriptPath);
+
+        Assert.IsNotNull(metadata);
+        Assert.AreEqual("file", metadata.OutputTypeHint);
+        File.Delete(scriptPath);
+    }
+
+    [TestMethod]
+    public void ReadMetadata_OutputTypeHint_Files()
+    {
+        var scriptPath = CreateTempScript("def advanced_paste_from_files_to_files(file_paths):\n    return file_paths\n");
+        var metadata = _service.ReadMetadata(scriptPath);
+
+        Assert.IsNotNull(metadata);
+        Assert.AreEqual("files", metadata.OutputTypeHint);
+        File.Delete(scriptPath);
+    }
+
+    [TestMethod]
+    public void ReadMetadata_RejectsMultipleFunctions()
+    {
+        var scriptPath = CreateTempScript(
+            "def advanced_paste_from_text_to_text(text):\n    return text\n\n" +
+            "def advanced_paste_from_html_to_text(html):\n    return html\n");
+        var metadata = _service.ReadMetadata(scriptPath);
+
+        Assert.IsNull(metadata);
+        File.Delete(scriptPath);
+    }
+
+    [TestMethod]
+    public void ReadMetadata_RejectsNoFunction()
+    {
+        var scriptPath = CreateTempScript("def some_other_function(text):\n    return text\n");
+        var metadata = _service.ReadMetadata(scriptPath);
+
+        Assert.IsNull(metadata);
+        File.Delete(scriptPath);
+    }
+
+    [TestMethod]
+    public void ReadMetadata_RejectsOldFormatWithoutTo()
+    {
+        // Old format (advanced_paste_from_text without _to_) should be rejected.
+        var scriptPath = CreateTempScript("def advanced_paste_from_text(text):\n    return text\n");
+        var metadata = _service.ReadMetadata(scriptPath);
+
+        Assert.IsNull(metadata);
+        File.Delete(scriptPath);
+    }
+
+    [TestMethod]
+    public void ReadMetadata_FunctionNameDeterminesFormat_Audio()
+    {
+        var scriptPath = CreateTempScript("def advanced_paste_from_audio_to_text(audio_path):\n    return 'transcribed'\n");
+        var metadata = _service.ReadMetadata(scriptPath);
+
+        Assert.IsNotNull(metadata);
+        Assert.AreEqual(Models.ClipboardFormat.Audio, metadata.SupportedFormats);
+        Assert.AreEqual("text", metadata.OutputTypeHint);
+        File.Delete(scriptPath);
+    }
+
+    [TestMethod]
+    public void ReadMetadata_FunctionNameDeterminesFormat_Video()
+    {
+        var scriptPath = CreateTempScript("def advanced_paste_from_video_to_text(video_path):\n    return 'description'\n");
+        var metadata = _service.ReadMetadata(scriptPath);
+
+        Assert.IsNotNull(metadata);
+        Assert.AreEqual(Models.ClipboardFormat.Video, metadata.SupportedFormats);
+        Assert.AreEqual("text", metadata.OutputTypeHint);
+        File.Delete(scriptPath);
+    }
+
+    [TestMethod]
+    public void ReadMetadata_OutputTypeHint_Audio()
+    {
+        var scriptPath = CreateTempScript("def advanced_paste_from_text_to_audio(text):\n    return '/path/out.mp3'\n");
+        var metadata = _service.ReadMetadata(scriptPath);
+
+        Assert.IsNotNull(metadata);
+        Assert.AreEqual(Models.ClipboardFormat.Text, metadata.SupportedFormats);
+        Assert.AreEqual("audio", metadata.OutputTypeHint);
+        File.Delete(scriptPath);
+    }
+
+    [TestMethod]
+    public void ReadMetadata_OutputTypeHint_Video()
+    {
+        var scriptPath = CreateTempScript("def advanced_paste_from_text_to_video(text):\n    return '/path/out.mp4'\n");
+        var metadata = _service.ReadMetadata(scriptPath);
+
+        Assert.IsNotNull(metadata);
+        Assert.AreEqual(Models.ClipboardFormat.Text, metadata.SupportedFormats);
+        Assert.AreEqual("video", metadata.OutputTypeHint);
+        File.Delete(scriptPath);
+    }
+
+    private static string CreateTempScript(string content)
+    {
+        var path = Path.Combine(Path.GetTempPath(), $"test_script_{Guid.NewGuid():N}.py");
+        File.WriteAllText(path, content);
+        return path;
+    }
+}

src/modules/AdvancedPaste/AdvancedPaste/AdvancedPaste.csproj

@@ -153,5 +153,9 @@
     <Content Include="Assets\AdvancedPaste\SemanticKernel.svg">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
+
+    <Content Include="Services\PythonScripts\_runner.py">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
   </ItemGroup>
 </Project>

src/modules/AdvancedPaste/AdvancedPaste/AdvancedPasteXAML/App.xaml.cs

@@ -14,6 +14,7 @@ using AdvancedPaste.Helpers;
 using AdvancedPaste.Models;
 using AdvancedPaste.Services;
 using AdvancedPaste.Services.CustomActions;
+using AdvancedPaste.Services.PythonScripts;
 using AdvancedPaste.Settings;
 using AdvancedPaste.ViewModels;
 using ManagedCommon;
@@ -83,6 +84,8 @@ namespace AdvancedPaste
                 services.AddSingleton<IPasteAIProviderFactory, PasteAIProviderFactory>();
                 services.AddSingleton<ICustomActionTransformService, CustomActionTransformService>();
                 services.AddSingleton<IKernelService, AdvancedAIKernelService>();
+                services.AddSingleton<IPythonScriptService, PythonScriptService>();
+                services.AddSingleton<IPythonScriptTrustService, PythonScriptTrustService>();
                 services.AddSingleton<IPasteFormatExecutor, PasteFormatExecutor>();
                 services.AddSingleton<OptionsViewModel>();
             }).Build();

src/modules/AdvancedPaste/AdvancedPaste/AdvancedPasteXAML/Controls/ClipboardHistoryItemPreviewControl.xaml

@@ -70,12 +70,12 @@
             Spacing="2">
             <TextBlock
                 Style="{StaticResource BodyTextBlockStyle}"
-                Text="{x:Bind Header, Mode=OneTime}"
+                Text="{x:Bind Header, Mode=OneWay}"
                 TextWrapping="NoWrap" />
             <TextBlock
                 Foreground="{ThemeResource TextFillColorSecondaryBrush}"
                 Style="{StaticResource CaptionTextBlockStyle}"
-                Text="{x:Bind Timestamp, Converter={StaticResource DateTimeToFriendlyStringConverter}, Mode=OneTime}" />
+                Text="{x:Bind Timestamp, Converter={StaticResource DateTimeToFriendlyStringConverter}, Mode=OneWay}" />
         </StackPanel>
     </Grid>
 </UserControl>

src/modules/AdvancedPaste/AdvancedPaste/AdvancedPasteXAML/Controls/PromptBox.xaml

@@ -755,63 +755,7 @@
                 <animations:OpacityAnimation To="0.0" Duration="0:0:0.167" />
             </animations:Implicit.HideAnimations>
         </TextBlock>
-        <Grid
-            x:Name="ErrorMessageGrid"
-            x:Uid="ErrorMessageGrid"
-            Grid.Row="1"
-            Margin="8,8,0,0"
-            ColumnSpacing="8"
-            Visibility="Collapsed">
-            <Grid.ColumnDefinitions>
-                <ColumnDefinition Width="Auto" />
-                <ColumnDefinition Width="*" />
-            </Grid.ColumnDefinitions>
-            <StackPanel Grid.Column="0" Orientation="Horizontal">
-                <ToolTipService.ToolTip>
-                    <ToolTip VerticalOffset="-105" Visibility="{x:Bind ViewModel.PasteActionError.HasDetails, Mode=OneWay, Converter={StaticResource BoolToVisibilityConverter}}">
-                        <StackPanel
-                            MinWidth="300"
-                            HorizontalAlignment="Stretch"
-                            Orientation="Vertical">
-                            <TextBox
-                                x:Name="AIErrorMessage"
-                                x:Uid="AIErrorMessage"
-                                FontSize="12"
-                                IsReadOnly="True"
-                                Text="{x:Bind ViewModel.PasteActionError.Details, Mode=OneWay}"
-                                TextWrapping="Wrap" />
-                        </StackPanel>
-                    </ToolTip>
-                </ToolTipService.ToolTip>
-                <FontIcon
-                    Margin="0,3,3,0"
-                    VerticalAlignment="Top"
-                    FontSize="12"
-                    Foreground="{ThemeResource AccentTextFillColorPrimaryBrush}"
-                    Glyph="&#xE946;"
-                    Visibility="{x:Bind ViewModel.PasteActionError.HasDetails, Mode=OneWay, Converter={StaticResource BoolToVisibilityConverter}}" />
-                <TextBlock
-                    FontWeight="SemiBold"
-                    Foreground="{ThemeResource SystemFillColorCriticalBrush}"
-                    Style="{StaticResource CaptionTextBlockStyle}"
-                    Text="{x:Bind ViewModel.PasteActionError.Text, Mode=OneWay}" />
-            </StackPanel>
-            <HyperlinkButton
-                x:Uid="SettingsBtn"
-                Grid.Column="1"
-                Margin="0,-1,0,0"
-                Padding="0"
-                HorizontalAlignment="Left"
-                VerticalAlignment="Top"
-                Command="{x:Bind ViewModel.OpenSettingsCommand}"
-                FontSize="12" />
-            <animations:Implicit.ShowAnimations>
-                <animations:OpacityAnimation To="1.0" Duration="0:0:0.6" />
-            </animations:Implicit.ShowAnimations>
-            <animations:Implicit.HideAnimations>
-                <animations:OpacityAnimation To="0.0" Duration="0:0:0.167" />
-            </animations:Implicit.HideAnimations>
-        </Grid>
+        <!--  Error message grid moved to MainPage.xaml so it remains enabled when PromptBox is disabled  -->
         <VisualStateManager.VisualStateGroups>
             <VisualStateGroup x:Name="CommonStates">
                 <VisualState x:Name="DefaultState" />
@@ -832,7 +776,6 @@
                     <VisualState.Setters>
                         <Setter Target="InputTxtBox.BorderBrush" Value="{ThemeResource SystemFillColorCriticalBrush}" />
                         <Setter Target="DisclaimerPresenter.Visibility" Value="Collapsed" />
-                        <Setter Target="ErrorMessageGrid.Visibility" Value="Visible" />
                     </VisualState.Setters>
                 </VisualState>
             </VisualStateGroup>

src/modules/AdvancedPaste/AdvancedPaste/AdvancedPasteXAML/MainWindow.xaml.cs

@@ -43,7 +43,8 @@ namespace AdvancedPaste
                 double GetHeight(int maxCustomActionCount) =>
                     baseHeight +
                     new PasteFormatsToHeightConverter().GetHeight(coreActionCount + _userSettings.AdditionalActions.Count) +
-                    new PasteFormatsToHeightConverter() { MaxItems = maxCustomActionCount }.GetHeight(_optionsViewModel.IsCustomAIServiceEnabled ? _userSettings.CustomActions.Count : 0);
+                    new PasteFormatsToHeightConverter() { MaxItems = maxCustomActionCount }.GetHeight(_optionsViewModel.IsCustomAIServiceEnabled ? _userSettings.CustomActions.Count : 0) +
+                    new PasteFormatsToHeightConverter() { MaxItems = maxCustomActionCount }.GetHeight(_optionsViewModel.PythonScriptPasteFormats.Count);
 
                 MinHeight = GetHeight(1);
                 Height = GetHeight(5);
@@ -59,6 +60,7 @@ namespace AdvancedPaste
                     UpdateHeight();
                 }
             };
+            _optionsViewModel.PythonScriptPasteFormats.CollectionChanged += (_, _) => UpdateHeight();
 
             AppWindow.SetIcon("Assets/AdvancedPaste/AdvancedPaste.ico");
             this.ExtendsContentIntoTitleBar = true;
@@ -141,11 +143,7 @@ namespace AdvancedPaste
         internal void FinishLoading(bool success)
         {
             MainPage.CustomFormatTextBox.IsLoading(false);
-
-            if (success)
-            {
-                VisualStateManager.GoToState(MainPage.CustomFormatTextBox, "DefaultState", true);
-            }
+            VisualStateManager.GoToState(MainPage.CustomFormatTextBox, "DefaultState", true);
         }
     }
 }

src/modules/AdvancedPaste/AdvancedPaste/AdvancedPasteXAML/Pages/MainPage.xaml

@@ -29,31 +29,31 @@
                         Padding="-9,0,0,0"
                         HorizontalAlignment="Stretch"
                         VerticalAlignment="Stretch"
-                        AutomationProperties.AcceleratorKey="{x:Bind ShortcutText, Mode=OneTime}"
+                        AutomationProperties.AcceleratorKey="{x:Bind ShortcutText, Mode=OneWay}"
                         AutomationProperties.AutomationControlType="ListItem"
-                        AutomationProperties.FullDescription="{x:Bind ToolTip, Mode=OneTime}"
-                        AutomationProperties.HelpText="{x:Bind Name, Mode=OneTime}"
-                        AutomationProperties.Name="{x:Bind AccessibleName, Mode=OneTime}">
+                        AutomationProperties.FullDescription="{x:Bind ToolTip, Mode=OneWay}"
+                        AutomationProperties.HelpText="{x:Bind Name, Mode=OneWay}"
+                        AutomationProperties.Name="{x:Bind AccessibleName, Mode=OneWay}">
                         <Grid.ColumnDefinitions>
                             <ColumnDefinition Width="48" />
                             <ColumnDefinition Width="*" />
                             <ColumnDefinition Width="Auto" />
                         </Grid.ColumnDefinitions>
                         <ToolTipService.ToolTip>
-                            <TextBlock Text="{x:Bind ToolTip, Mode=OneTime}" />
+                            <TextBlock Text="{x:Bind ToolTip, Mode=OneWay}" />
                         </ToolTipService.ToolTip>
                         <FontIcon
                             Margin="0,0,0,0"
                             VerticalAlignment="Center"
                             AutomationProperties.AccessibilityView="Raw"
                             FontSize="16"
-                            Glyph="{x:Bind IconGlyph, Mode=OneTime}" />
+                            Glyph="{x:Bind IconGlyph, Mode=OneWay}" />
                         <TextBlock
                             Grid.Column="1"
                             VerticalAlignment="Center"
                             x:Phase="1"
                             Style="{StaticResource CaptionTextBlockStyle}"
-                            Text="{x:Bind Name, Mode=OneTime}" />
+                            Text="{x:Bind Name, Mode=OneWay}" />
                         <TextBlock
                             Grid.Column="2"
                             Margin="0,0,8,0"
@@ -61,7 +61,7 @@
                             VerticalAlignment="Center"
                             Foreground="{ThemeResource TextFillColorSecondaryBrush}"
                             Style="{StaticResource CaptionTextBlockStyle}"
-                            Text="{x:Bind ShortcutText, Mode=OneTime}" />
+                            Text="{x:Bind ShortcutText, Mode=OneWay}" />
                     </Grid>
                 </DataTemplate>
             </controls:PasteFormatTemplateSelector.ItemTemplate>
@@ -83,13 +83,13 @@
                             Margin="0,0,0,0"
                             VerticalAlignment="Center"
                             FontSize="16"
-                            Glyph="{x:Bind IconGlyph, Mode=OneTime}" />
+                            Glyph="{x:Bind IconGlyph, Mode=OneWay}" />
                         <TextBlock
                             Grid.Column="1"
                             VerticalAlignment="Center"
                             x:Phase="1"
                             Style="{StaticResource CaptionTextBlockStyle}"
-                            Text="{x:Bind Name, Mode=OneTime}" />
+                            Text="{x:Bind Name, Mode=OneWay}" />
                     </Grid>
                 </DataTemplate>
             </controls:PasteFormatTemplateSelector.ItemTemplateDisabled>
@@ -144,6 +144,7 @@
     </Page.KeyboardAccelerators>
     <Grid>
         <Grid.RowDefinitions>
+            <RowDefinition Height="Auto" />
             <RowDefinition Height="Auto" />
             <RowDefinition Height="Auto" />
             <RowDefinition Height="*" />
@@ -198,7 +199,7 @@
                             <ItemsView.ItemTemplate>
                                 <DataTemplate x:DataType="local:ClipboardItem">
                                     <ItemContainer
-                                        AutomationProperties.Name="{x:Bind Description, Mode=OneTime}"
+                                        AutomationProperties.Name="{x:Bind Description, Mode=OneWay}"
                                         CornerRadius="16"
                                         ToolTipService.ToolTip="{x:Bind Content}">
                                         <Grid
@@ -250,11 +251,10 @@
             Grid.Row="1"
             Margin="20,0,20,0"
             x:FieldModifier="public"
-            IsEnabled="{x:Bind ViewModel.IsCustomAIServiceEnabled, Mode=OneWay}"
-            TabIndex="0"
-            Visibility="{x:Bind ViewModel.ShowAIPasteSection, Converter={StaticResource BoolToVisibilityConverter}, Mode=OneWay}">
+            IsEnabled="True"
+            TabIndex="0">
             <controls:PromptBox.Footer>
-                <StackPanel Orientation="Horizontal">
+                <StackPanel Orientation="Horizontal" Visibility="{x:Bind ViewModel.IsCustomAIServiceEnabled, Mode=OneWay, Converter={StaticResource BoolToVisibilityConverter}}">
                     <TextBlock
                         x:Uid="AIMistakeNote"
                         Margin="0,0,2,0"
@@ -300,19 +300,70 @@
                 </StackPanel>
             </controls:PromptBox.Footer>
         </controls:PromptBox>
-        <ScrollViewer Grid.Row="2">
+        <Grid
+            x:Name="ErrorMessageGrid"
+            Grid.Row="2"
+            Margin="20,4,20,0"
+            ColumnSpacing="8"
+            Visibility="{x:Bind ViewModel.PasteActionError.HasText, Mode=OneWay, Converter={StaticResource BoolToVisibilityConverter}}">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="Auto" />
+                <ColumnDefinition Width="*" />
+                <ColumnDefinition Width="Auto" />
+                <ColumnDefinition Width="Auto" />
+            </Grid.ColumnDefinitions>
+            <FontIcon
+                Grid.Column="0"
+                Margin="0,3,3,0"
+                VerticalAlignment="Top"
+                FontSize="12"
+                Foreground="{ThemeResource AccentTextFillColorPrimaryBrush}"
+                Glyph="&#xE946;"
+                Visibility="{x:Bind ViewModel.PasteActionError.HasDetails, Mode=OneWay, Converter={StaticResource BoolToVisibilityConverter}}" />
+            <TextBlock
+                Grid.Column="1"
+                FontWeight="SemiBold"
+                Foreground="{ThemeResource SystemFillColorCriticalBrush}"
+                MaxLines="2"
+                Style="{StaticResource CaptionTextBlockStyle}"
+                Text="{x:Bind ViewModel.PasteActionError.Text, Mode=OneWay}"
+                TextTrimming="CharacterEllipsis"
+                TextWrapping="Wrap" />
+            <HyperlinkButton
+                x:Name="ShowErrorDetailsBtn"
+                x:Uid="ShowErrorDetailsBtn"
+                Grid.Column="2"
+                Margin="4,-1,0,0"
+                Padding="0"
+                HorizontalAlignment="Left"
+                VerticalAlignment="Top"
+                Click="ShowErrorDetailsBtn_Click"
+                FontSize="12"
+                Visibility="{x:Bind ViewModel.PasteActionError.HasDetails, Mode=OneWay, Converter={StaticResource BoolToVisibilityConverter}}" />
+            <HyperlinkButton
+                x:Uid="SettingsBtn"
+                Grid.Column="3"
+                Margin="0,-1,0,0"
+                Padding="0"
+                HorizontalAlignment="Left"
+                VerticalAlignment="Top"
+                Command="{x:Bind ViewModel.OpenSettingsCommand}"
+                FontSize="12" />
+        </Grid>
+        <ScrollViewer Grid.Row="3">
             <Grid RowSpacing="4">
                 <Grid.RowDefinitions>
-                    <RowDefinition Height="{x:Bind ViewModel.StandardPasteFormats.Count, Mode=OneWay, Converter={StaticResource standardPasteFormatsToHeightConverter}}" />
                     <RowDefinition Height="Auto" />
-                    <RowDefinition Height="*" MinHeight="{x:Bind ViewModel.CustomActionPasteFormats.Count, Mode=OneWay, Converter={StaticResource customActionsToMinHeightConverter}}" />
+                    <RowDefinition Height="Auto" />
+                    <RowDefinition Height="Auto" />
+                    <RowDefinition Height="Auto" />
+                    <RowDefinition Height="Auto" />
                     <RowDefinition Height="Auto" />
                     <RowDefinition Height="Auto" />
                 </Grid.RowDefinitions>
                 <ListView
                     x:Name="PasteOptionsListView"
                     Grid.Row="0"
-                    VerticalAlignment="Bottom"
                     IsItemClickEnabled="True"
                     ItemClick="PasteFormat_ItemClick"
                     ItemContainerTransitions="{x:Null}"
@@ -342,6 +393,27 @@
                     ScrollViewer.VerticalScrollMode="Disabled"
                     SelectionMode="None"
                     TabIndex="2" />
+
+                <Rectangle
+                    Grid.Row="3"
+                    Height="1"
+                    HorizontalAlignment="Stretch"
+                    Fill="{ThemeResource DividerStrokeColorDefaultBrush}"
+                    Visibility="{x:Bind ViewModel.PythonScriptPasteFormats.Count, Mode=OneWay, Converter={StaticResource countToVisibilityConverter}}" />
+
+                <ListView
+                    x:Name="PythonScriptsListView"
+                    Grid.Row="4"
+                    VerticalAlignment="Top"
+                    IsItemClickEnabled="True"
+                    ItemClick="PasteFormat_ItemClick"
+                    ItemContainerTransitions="{x:Null}"
+                    ItemTemplateSelector="{StaticResource PasteFormatTemplateSelector}"
+                    ItemsSource="{x:Bind ViewModel.PythonScriptPasteFormats, Mode=OneWay}"
+                    ScrollViewer.VerticalScrollBarVisibility="Disabled"
+                    ScrollViewer.VerticalScrollMode="Disabled"
+                    SelectionMode="None"
+                    TabIndex="3" />
             </Grid>
         </ScrollViewer>
     </Grid>

src/modules/AdvancedPaste/AdvancedPaste/AdvancedPasteXAML/Pages/MainPage.xaml.cs

@@ -208,5 +208,43 @@ namespace AdvancedPaste.Pages
                 Clipboard.SetHistoryItemAsContent(item.Item);
             }
         }
+
+        private async void ShowErrorDetailsBtn_Click(object sender, RoutedEventArgs e)
+        {
+            var details = ViewModel.PasteActionError?.Details;
+            if (string.IsNullOrEmpty(details))
+            {
+                return;
+            }
+
+            var scrollViewer = new ScrollViewer
+            {
+                MaxHeight = 400,
+                MinWidth = 400,
+                HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled,
+                VerticalScrollBarVisibility = ScrollBarVisibility.Auto,
+            };
+
+            var textBlock = new TextBlock
+            {
+                Text = details,
+                TextWrapping = TextWrapping.Wrap,
+                FontFamily = new Microsoft.UI.Xaml.Media.FontFamily("Consolas"),
+                FontSize = 12,
+                IsTextSelectionEnabled = true,
+            };
+
+            scrollViewer.Content = textBlock;
+
+            var dialog = new ContentDialog
+            {
+                Title = ResourceLoaderInstance.ResourceLoader.GetString("ErrorDetailsDialogTitle"),
+                CloseButtonText = ResourceLoaderInstance.ResourceLoader.GetString("ErrorDetailsDialogClose"),
+                Content = scrollViewer,
+                XamlRoot = this.XamlRoot,
+            };
+
+            await dialog.ShowAsync();
+        }
     }
 }

src/modules/AdvancedPaste/AdvancedPaste/Helpers/IUserSettings.cs

@@ -17,8 +17,6 @@ namespace AdvancedPaste.Settings
 
         public bool ShowCustomPreview { get; }
 
-        public bool ShowAIPaste { get; }
-
         public bool CloseAfterLosingFocus { get; }
 
         public bool EnableClipboardPreview { get; }
@@ -29,8 +27,26 @@ namespace AdvancedPaste.Settings
 
         public PasteAIConfiguration PasteAIConfiguration { get; }
 
+        public IReadOnlyList<AdvancedPastePythonScriptAction> PythonScriptActions { get; }
+
+        public bool IsPythonScriptsEnabled { get; }
+
+        public string PythonScriptsFolder { get; }
+
+        public string PythonExecutablePath { get; }
+
+        public bool PythonUseWsl { get; }
+
+        public string PythonWslDistribution { get; }
+
+        public int PythonScriptTimeoutSeconds { get; }
+
+        public IReadOnlyDictionary<string, string> TrustedScriptHashes { get; }
+
         public event EventHandler Changed;
 
         Task SetActiveAIProviderAsync(string providerId);
+
+        void StoreTrustedScriptHash(string scriptPath, string hash);
     }
 }

src/modules/AdvancedPaste/AdvancedPaste/Helpers/UserSettings.cs

@@ -4,6 +4,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.IO.Abstractions;
 using System.Linq;
 using System.Threading;
@@ -25,6 +26,10 @@ namespace AdvancedPaste.Settings
         private readonly Lock _loadingSettingsLock = new();
         private readonly List<PasteFormats> _additionalActions;
         private readonly List<AdvancedPasteCustomAction> _customActions;
+        private readonly List<AdvancedPastePythonScriptAction> _pythonScriptActions;
+        private FileSystemWatcher _scriptFolderWatcher;
+        private CancellationTokenSource _scriptFolderDebounce;
+        private string _watchedScriptsFolder = string.Empty;
 
         private const string AdvancedPasteModuleName = "AdvancedPaste";
         private const int MaxNumberOfRetry = 5;
@@ -38,8 +43,6 @@ namespace AdvancedPaste.Settings
 
         public bool ShowCustomPreview { get; private set; }
 
-        public bool ShowAIPaste { get; private set; }
-
         public bool CloseAfterLosingFocus { get; private set; }
 
         public bool EnableClipboardPreview { get; private set; }
@@ -50,18 +53,39 @@ namespace AdvancedPaste.Settings
 
         public PasteAIConfiguration PasteAIConfiguration { get; private set; }
 
+        public IReadOnlyList<AdvancedPastePythonScriptAction> PythonScriptActions => _pythonScriptActions;
+
+        public string PythonScriptsFolder { get; private set; }
+
+        public bool IsPythonScriptsEnabled { get; private set; }
+
+        public string PythonExecutablePath { get; private set; }
+
+        public bool PythonUseWsl { get; private set; }
+
+        public string PythonWslDistribution { get; private set; } = string.Empty;
+
+        public int PythonScriptTimeoutSeconds { get; private set; } = 30;
+
+        public IReadOnlyDictionary<string, string> TrustedScriptHashes { get; private set; } = new Dictionary<string, string>();
+
         public UserSettings(IFileSystem fileSystem)
         {
             _settingsUtils = new SettingsUtils(fileSystem);
 
             IsAIEnabled = false;
             ShowCustomPreview = true;
-            ShowAIPaste = true;
             CloseAfterLosingFocus = false;
             EnableClipboardPreview = true;
             PasteAIConfiguration = new PasteAIConfiguration();
+            PythonScriptsFolder = GetDefaultScriptsFolder();
+            PythonExecutablePath = string.Empty;
+            PythonUseWsl = false;
+            PythonWslDistribution = string.Empty;
+            PythonScriptTimeoutSeconds = 30;
             _additionalActions = [];
             _customActions = [];
+            _pythonScriptActions = [];
             _taskScheduler = TaskScheduler.FromCurrentSynchronizationContext();
 
             LoadSettingsFromJson();
@@ -69,6 +93,14 @@ namespace AdvancedPaste.Settings
             _watcher = Helper.GetFileWatcher(AdvancedPasteModuleName, "settings.json", OnSettingsFileChanged, fileSystem);
         }
 
+        private static string GetDefaultScriptsFolder() =>
+            System.IO.Path.Combine(
+                Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
+                "Microsoft",
+                "PowerToys",
+                "AdvancedPaste",
+                "Scripts");
+
         private void OnSettingsFileChanged()
         {
             lock (_loadingSettingsLock)
@@ -112,7 +144,6 @@ namespace AdvancedPaste.Settings
 
                                 IsAIEnabled = properties.IsAIEnabled;
                                 ShowCustomPreview = properties.ShowCustomPreview;
-                                ShowAIPaste = properties.ShowAIPaste;
                                 CloseAfterLosingFocus = properties.CloseAfterLosingFocus;
                                 EnableClipboardPreview = properties.EnableClipboardPreview;
                                 PasteAIConfiguration = properties.PasteAIConfiguration ?? new PasteAIConfiguration();
@@ -135,6 +166,42 @@ namespace AdvancedPaste.Settings
                                 _customActions.Clear();
                                 _customActions.AddRange(properties.CustomActions.Value.Where(customAction => customAction.IsShown && customAction.IsValid));
 
+                                var pythonScripts = properties.PythonScripts ?? new AdvancedPastePythonScriptSettings();
+                                pythonScripts.MigrateLegacyIfNeeded();
+
+                                var mode = pythonScripts.Mode ?? "disabled";
+                                IsPythonScriptsEnabled = !string.Equals(mode, "disabled", StringComparison.OrdinalIgnoreCase);
+                                PythonUseWsl = string.Equals(mode, "wsl", StringComparison.OrdinalIgnoreCase);
+
+                                if (PythonUseWsl)
+                                {
+                                    var wslSettings = pythonScripts.WslSettings ?? new PythonScriptWslSettings();
+                                    PythonScriptsFolder = string.IsNullOrWhiteSpace(wslSettings.ScriptsFolder)
+                                        ? GetDefaultScriptsFolder()
+                                        : wslSettings.ScriptsFolder;
+                                    PythonExecutablePath = string.Empty;
+                                    PythonWslDistribution = wslSettings.Distribution ?? string.Empty;
+                                }
+                                else
+                                {
+                                    var winSettings = pythonScripts.WindowsSettings ?? new PythonScriptWindowsSettings();
+                                    PythonScriptsFolder = string.IsNullOrWhiteSpace(winSettings.ScriptsFolder)
+                                        ? GetDefaultScriptsFolder()
+                                        : winSettings.ScriptsFolder;
+                                    PythonExecutablePath = winSettings.PythonExecutablePath ?? string.Empty;
+                                    PythonWslDistribution = string.Empty;
+                                }
+
+                                PythonScriptTimeoutSeconds = pythonScripts.TimeoutSeconds > 0 ? pythonScripts.TimeoutSeconds : 30;
+                                TrustedScriptHashes = new Dictionary<string, string>(
+                                    pythonScripts.TrustedScriptHashes ?? new Dictionary<string, string>(),
+                                    StringComparer.OrdinalIgnoreCase);
+
+                                _pythonScriptActions.Clear();
+                                _pythonScriptActions.AddRange(pythonScripts.Value);
+
+                                UpdateScriptFolderWatcher(PythonScriptsFolder);
+
                                 Changed?.Invoke(this, EventArgs.Empty);
                             }
 
@@ -299,6 +366,103 @@ namespace AdvancedPaste.Settings
             return string.IsNullOrWhiteSpace(filtered) ? "default" : filtered.ToLowerInvariant();
         }
 
+        private void UpdateScriptFolderWatcher(string folderPath)
+        {
+            if (string.Equals(_watchedScriptsFolder, folderPath, StringComparison.OrdinalIgnoreCase))
+            {
+                return;
+            }
+
+            _scriptFolderWatcher?.Dispose();
+            _scriptFolderWatcher = null;
+            _watchedScriptsFolder = folderPath;
+
+            if (string.IsNullOrWhiteSpace(folderPath))
+            {
+                return;
+            }
+
+            try
+            {
+                if (!System.IO.Directory.Exists(folderPath))
+                {
+                    System.IO.Directory.CreateDirectory(folderPath);
+                }
+
+                _scriptFolderWatcher = new FileSystemWatcher(folderPath, "*.py")
+                {
+                    NotifyFilter = NotifyFilters.FileName | NotifyFilters.LastWrite | NotifyFilters.CreationTime,
+                    EnableRaisingEvents = true,
+                    IncludeSubdirectories = false,
+                };
+
+                _scriptFolderWatcher.Changed += OnScriptFolderChanged;
+                _scriptFolderWatcher.Created += OnScriptFolderChanged;
+                _scriptFolderWatcher.Deleted += OnScriptFolderChanged;
+                _scriptFolderWatcher.Renamed += OnScriptFolderChanged;
+            }
+            catch (Exception ex)
+            {
+                Logger.LogError($"Failed to set up script folder watcher for {folderPath}", ex);
+            }
+        }
+
+        private void OnScriptFolderChanged(object sender, FileSystemEventArgs e)
+        {
+            lock (_loadingSettingsLock)
+            {
+                _scriptFolderDebounce?.Cancel();
+                _scriptFolderDebounce?.Dispose();
+                _scriptFolderDebounce = new CancellationTokenSource();
+
+                var token = _scriptFolderDebounce.Token;
+                Task.Delay(TimeSpan.FromMilliseconds(500), token)
+                    .ContinueWith(
+                        _ =>
+                        {
+                            Task.Factory
+                                .StartNew(
+                                    () => Changed?.Invoke(this, EventArgs.Empty),
+                                    CancellationToken.None,
+                                    TaskCreationOptions.None,
+                                    _taskScheduler);
+                        },
+                        token,
+                        TaskContinuationOptions.NotOnCanceled,
+                        TaskScheduler.Default);
+            }
+        }
+
+        public void StoreTrustedScriptHash(string scriptPath, string hash)
+        {
+            lock (_loadingSettingsLock)
+            {
+                try
+                {
+                    var settings = _settingsUtils.GetSettingsOrDefault<AdvancedPasteSettings>(AdvancedPasteModuleName);
+                    if (settings?.Properties?.PythonScripts is null)
+                    {
+                        return;
+                    }
+
+                    settings.Properties.PythonScripts.TrustedScriptHashes ??= new Dictionary<string, string>();
+                    settings.Properties.PythonScripts.TrustedScriptHashes[scriptPath] = hash;
+                    settings.Save(_settingsUtils);
+
+                    // Update in-memory cache.
+                    var updated = new Dictionary<string, string>(TrustedScriptHashes, StringComparer.OrdinalIgnoreCase)
+                    {
+                        [scriptPath] = hash,
+                    };
+                    TrustedScriptHashes = updated;
+                }
+                catch (Exception ex)
+                {
+                    Logger.LogError("Failed to store trusted script hash", ex);
+                }
+            }
+        }
+
         public async Task SetActiveAIProviderAsync(string providerId)
         {
             if (string.IsNullOrWhiteSpace(providerId))
@@ -391,6 +555,8 @@ namespace AdvancedPaste.Settings
                 if (disposing)
                 {
                     _cancellationTokenSource?.Dispose();
+                    _scriptFolderDebounce?.Dispose();
+                    _scriptFolderWatcher?.Dispose();
                     _watcher?.Dispose();
                 }
 

src/modules/AdvancedPaste/AdvancedPaste/Models/PasteFormat.cs

@@ -40,6 +40,14 @@ public sealed class PasteFormat
             IsSavedQuery = isSavedQuery,
         };
 
+    public static PasteFormat CreatePythonScriptFormat(string name, string scriptPath, ClipboardFormat availableFormats) =>
+        new(PasteFormats.PythonScript, availableFormats, isAIServiceEnabled: false)
+        {
+            Name = name,
+            Prompt = scriptPath,
+            IsSavedQuery = true,
+        };
+
     public PasteFormatMetadataAttribute Metadata => MetadataDict[Format];
 
     public string IconGlyph => Metadata.IconGlyph;

src/modules/AdvancedPaste/AdvancedPaste/Models/PasteFormats.cs

@@ -122,4 +122,12 @@ public enum PasteFormats
         KernelFunctionDescription = "Takes user instructions and applies them to the current clipboard content (text or image). Use this function for image analysis, description, or transformation tasks beyond simple OCR.",
         RequiresPrompt = true)]
     CustomTextTransformation,
+
+    [PasteFormatMetadata(
+        IsCoreAction = false,
+        IconGlyph = "\uE943",
+        RequiresAIService = false,
+        CanPreview = true,
+        SupportedClipboardFormats = ClipboardFormat.Text | ClipboardFormat.Html | ClipboardFormat.Image | ClipboardFormat.Audio | ClipboardFormat.Video | ClipboardFormat.File)]
+    PythonScript,
 }

src/modules/AdvancedPaste/AdvancedPaste/Services/PasteFormatExecutor.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation
+// Copyright (c) Microsoft Corporation
 // The Microsoft Corporation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
@@ -9,15 +9,23 @@ using System.Threading.Tasks;
 using AdvancedPaste.Helpers;
 using AdvancedPaste.Models;
 using AdvancedPaste.Services.CustomActions;
+using AdvancedPaste.Services.PythonScripts;
+using ManagedCommon;
 using Microsoft.PowerToys.Telemetry;
 using Windows.ApplicationModel.DataTransfer;
 
 namespace AdvancedPaste.Services;
 
-public sealed class PasteFormatExecutor(IKernelService kernelService, ICustomActionTransformService customActionTransformService) : IPasteFormatExecutor
+public sealed class PasteFormatExecutor(
+    IKernelService kernelService,
+    ICustomActionTransformService customActionTransformService,
+    IPythonScriptService pythonScriptService,
+    IPythonScriptTrustService pythonScriptTrustService) : IPasteFormatExecutor
 {
     private readonly IKernelService _kernelService = kernelService;
     private readonly ICustomActionTransformService _customActionTransformService = customActionTransformService;
+    private readonly IPythonScriptService _pythonScriptService = pythonScriptService;
+    private readonly IPythonScriptTrustService _pythonScriptTrustService = pythonScriptTrustService;
 
     public async Task<DataPackage> ExecutePasteFormatAsync(PasteFormat pasteFormat, PasteActionSource source, CancellationToken cancellationToken, IProgress<double> progress)
     {
@@ -32,6 +40,15 @@ public sealed class PasteFormatExecutor(IKernelService kernelService, ICustomAct
 
         var clipboardData = Clipboard.GetContent();
 
+        // PythonScript must NOT run inside Task.Run: the trust confirmation (ContentDialog)
+        // requires the UI (XAML) thread and will throw if called from a thread-pool thread.
+        // Python script execution is fully async (process.WaitForExitAsync), so it is safe
+        // to await it directly without wrapping in Task.Run.
+        if (format == PasteFormats.PythonScript)
+        {
+            return await ExecutePythonScriptAsync(pasteFormat.Prompt, clipboardData, cancellationToken, progress);
+        }
+
         // Run on thread-pool; although we use Async routines consistently, some actions still occasionally take a long time without yielding.
         return await Task.Run(async () =>
             pasteFormat.Format switch
@@ -42,6 +59,111 @@ public sealed class PasteFormatExecutor(IKernelService kernelService, ICustomAct
             });
     }
 
+    private async Task<DataPackage> ExecutePythonScriptAsync(
+        string scriptPath,
+        DataPackageView clipboardData,
+        CancellationToken cancellationToken,
+        IProgress<double> progress)
+    {
+        // Security: ensure the script is trusted before executing.
+        if (!_pythonScriptTrustService.IsTrusted(scriptPath))
+        {
+            string hash;
+            try
+            {
+                hash = _pythonScriptTrustService.ComputeHash(scriptPath);
+            }
+            catch (System.IO.FileNotFoundException)
+            {
+                throw new PasteActionException(
+                    string.Format(System.Globalization.CultureInfo.CurrentCulture, ResourceLoaderInstance.ResourceLoader.GetString("PythonScriptNotFound"), scriptPath),
+                    new System.IO.FileNotFoundException(null, scriptPath));
+            }
+
+            var approved = await _pythonScriptTrustService.RequestTrustAsync(scriptPath, hash);
+
+            if (!approved)
+            {
+                throw new OperationCanceledException("User declined to trust the Python script.");
+            }
+
+            _pythonScriptTrustService.StoreTrust(scriptPath, hash);
+        }
+
+        var metadata = _pythonScriptService.ReadMetadata(scriptPath);
+
+        if (metadata is null)
+        {
+            throw new InvalidOperationException($"Script '{scriptPath}' does not define a valid advanced_paste_from_*_to_*() function.");
+        }
+
+        // Pre-flight: check for missing packages and offer to install them.
+        var missingPackages = await _pythonScriptService.GetMissingRequirementsAsync(metadata, cancellationToken);
+        if (missingPackages.Count > 0)
+        {
+            var approved = await _pythonScriptTrustService.RequestInstallAsync(metadata.Name, missingPackages);
+            if (!approved)
+            {
+                throw new OperationCanceledException("User declined to install missing Python packages.");
+            }
+
+            await _pythonScriptService.InstallRequirementsAsync(missingPackages, metadata.Platform, cancellationToken);
+        }
+
+        var detectedFormat = await clipboardData.GetAvailableFormatsAsync();
+
+        // V2 interface: script defines advanced_paste_from_*_to_*() — use unified runner.
+        if (metadata.IsV2)
+        {
+            return await _pythonScriptService.ExecuteScriptAsync(scriptPath, metadata.Platform, clipboardData, detectedFormat, cancellationToken, progress);
+        }
+
+        // Legacy paths for backward compatibility.
+        if (string.Equals(metadata.Platform, "linux", StringComparison.OrdinalIgnoreCase))
+        {
+            return await _pythonScriptService.ExecuteWslScriptAsync(scriptPath, clipboardData, detectedFormat, cancellationToken, progress);
+        }
+        else
+        {
+            // Windows mode: script modifies the clipboard in-process; we return the updated clipboard.
+            await _pythonScriptService.ExecuteWindowsScriptAsync(scriptPath, detectedFormat, cancellationToken, progress);
+
+            // Re-read clipboard after script has run.
+            return Clipboard.GetContent() is { } updatedView
+                ? await DataPackageFromViewAsync(updatedView)
+                : new DataPackage();
+        }
+    }
+
+    private static async Task<DataPackage> DataPackageFromViewAsync(DataPackageView view)
+    {
+        var pkg = new DataPackage();
+
+        if (view.Contains(StandardDataFormats.Text))
+        {
+            pkg.SetText(await view.GetTextAsync());
+        }
+
+        if (view.Contains(StandardDataFormats.Html))
+        {
+            pkg.SetHtmlFormat(await view.GetHtmlFormatAsync());
+        }
+
+        if (view.Contains(StandardDataFormats.StorageItems))
+        {
+            var items = await view.GetStorageItemsAsync();
+            pkg.SetStorageItems(items);
+        }
+
+        if (view.Contains(StandardDataFormats.Bitmap))
+        {
+            var bitmap = await view.GetBitmapAsync();
+            pkg.SetBitmap(bitmap);
+        }
+
+        return pkg;
+    }
+
     private static void WriteTelemetry(PasteFormats format, PasteActionSource source)
     {
         switch (source)

src/modules/AdvancedPaste/AdvancedPaste/Services/PythonScripts/IPythonScriptService.cs

@@ -0,0 +1,71 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+using AdvancedPaste.Models;
+using Windows.ApplicationModel.DataTransfer;
+
+namespace AdvancedPaste.Services.PythonScripts;
+
+public interface IPythonScriptService
+{
+    /// <summary>
+    /// V2 unified execution: C# reads the clipboard, pipes data as JSON to the runner,
+    /// and receives a DataPackage from JSON stdout. Works on both Windows and WSL
+    /// depending on the specified platform.
+    /// </summary>
+    Task<DataPackage> ExecuteScriptAsync(string scriptPath, string platform, DataPackageView clipboardData, ClipboardFormat detectedFormat, CancellationToken cancellationToken, IProgress<double> progress);
+
+    /// <summary>
+    /// Legacy Windows mode: the script directly manipulates the clipboard. C# waits for the process to exit.
+    /// Kept for backward compatibility with scripts that use win32clipboard directly.
+    /// </summary>
+    Task ExecuteWindowsScriptAsync(string scriptPath, ClipboardFormat detectedFormat, CancellationToken cancellationToken, IProgress<double> progress);
+
+    /// <summary>
+    /// Legacy WSL mode: C# passes data via JSON stdin, receives a DataPackage from JSON stdout.
+    /// Kept for backward compatibility with scripts that use json.load(sys.stdin) directly.
+    /// </summary>
+    Task<DataPackage> ExecuteWslScriptAsync(string scriptPath, DataPackageView clipboardData, ClipboardFormat detectedFormat, CancellationToken cancellationToken, IProgress<double> progress);
+
+    /// <summary>
+    /// Parses the @advancedpaste: header comments from a Python script file.
+    /// </summary>
+    PythonScriptMetadata ReadMetadata(string scriptPath);
+
+    /// <summary>
+    /// Discovers all .py scripts in <paramref name="folderPath"/> and returns their metadata.
+    /// </summary>
+    IReadOnlyList<PythonScriptMetadata> DiscoverScripts(string folderPath);
+
+    /// <summary>
+    /// Finds the Python executable to use. Returns null if none is found.
+    /// </summary>
+    string TryFindPythonExecutable(string overridePath = null);
+
+    /// <summary>
+    /// Returns true if wsl.exe is available on this machine.
+    /// </summary>
+    bool IsWslAvailable();
+
+    /// <summary>
+    /// Checks which of the declared requirements are not yet importable.
+    /// Returns an empty list if all packages are installed.
+    /// </summary>
+    Task<IReadOnlyList<PythonRequirement>> GetMissingRequirementsAsync(
+        PythonScriptMetadata metadata,
+        CancellationToken cancellationToken);
+
+    /// <summary>
+    /// Installs the given packages via pip / pip3.
+    /// </summary>
+    Task InstallRequirementsAsync(
+        IReadOnlyList<PythonRequirement> requirements,
+        string platform,
+        CancellationToken cancellationToken);
+}

src/modules/AdvancedPaste/AdvancedPaste/Services/PythonScripts/IPythonScriptTrustService.cs

@@ -0,0 +1,37 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace AdvancedPaste.Services.PythonScripts;
+
+public interface IPythonScriptTrustService
+{
+    /// <summary>
+    /// Returns true if the script at <paramref name="scriptPath"/> is currently trusted (hash matches stored value).
+    /// </summary>
+    bool IsTrusted(string scriptPath);
+
+    /// <summary>
+    /// Shows a UI confirmation dialog for the script. Returns true if the user approved execution.
+    /// </summary>
+    Task<bool> RequestTrustAsync(string scriptPath, string hash);
+
+    /// <summary>
+    /// Persists the trust entry for <paramref name="scriptPath"/> with the given <paramref name="hash"/>.
+    /// </summary>
+    void StoreTrust(string scriptPath, string hash);
+
+    /// <summary>
+    /// Computes the SHA-256 hash of the script file and returns the hex string.
+    /// </summary>
+    string ComputeHash(string scriptPath);
+
+    /// <summary>
+    /// Shows a confirmation dialog listing the missing packages and asking the user
+    /// whether to install them. Returns true if the user approved installation.
+    /// </summary>
+    Task<bool> RequestInstallAsync(string scriptName, IReadOnlyList<PythonRequirement> missingPackages);
+}

src/modules/AdvancedPaste/AdvancedPaste/Services/PythonScripts/PythonRequirement.cs

@@ -0,0 +1,13 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace AdvancedPaste.Services.PythonScripts;
+
+/// <summary>
+/// Represents a single Python package requirement declared via
+/// <c># @advancedpaste:requires import_name=pip_package</c>.
+/// </summary>
+/// <param name="ImportName">The Python import name used in the script (e.g. "cv2").</param>
+/// <param name="PipPackage">The pip install name (e.g. "opencv-python-headless"). Equals <see cref="ImportName"/> when not explicitly specified.</param>
+public sealed record PythonRequirement(string ImportName, string PipPackage);

src/modules/AdvancedPaste/AdvancedPaste/Services/PythonScripts/PythonScriptMetadata.cs

@@ -0,0 +1,21 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+
+using AdvancedPaste.Models;
+
+namespace AdvancedPaste.Services.PythonScripts;
+
+public sealed record PythonScriptMetadata(
+    string ScriptPath,
+    string Name,
+    string Description,
+    ClipboardFormat SupportedFormats,
+    string Platform,
+    string Version,
+    bool IsEnabled,
+    IReadOnlyList<PythonRequirement> Requirements,
+    bool IsV2 = false,
+    string OutputTypeHint = null);

src/modules/AdvancedPaste/AdvancedPaste/Services/PythonScripts/PythonScriptTrustService.cs

@@ -0,0 +1,127 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Threading.Tasks;
+
+using AdvancedPaste.Helpers;
+using AdvancedPaste.Settings;
+using ManagedCommon;
+using Microsoft.UI.Xaml.Controls;
+
+namespace AdvancedPaste.Services.PythonScripts;
+
+public sealed class PythonScriptTrustService(IUserSettings userSettings) : IPythonScriptTrustService
+{
+    private readonly IUserSettings _userSettings = userSettings;
+
+    public bool IsTrusted(string scriptPath)
+    {
+        var hashes = _userSettings.TrustedScriptHashes;
+        if (hashes is null || !hashes.TryGetValue(scriptPath, out var storedHash))
+        {
+            return false;
+        }
+
+        try
+        {
+            var currentHash = ComputeHash(scriptPath);
+            return string.Equals(currentHash, storedHash, StringComparison.OrdinalIgnoreCase);
+        }
+        catch (Exception ex)
+        {
+            Logger.LogError($"Failed to compute hash for {scriptPath}", ex);
+            return false;
+        }
+    }
+
+    public async Task<bool> RequestTrustAsync(string scriptPath, string hash)
+    {
+        try
+        {
+            var resourceLoader = ResourceLoaderInstance.ResourceLoader;
+
+            var dialog = new ContentDialog
+            {
+                Title = resourceLoader.GetString("PythonScriptTrustTitle"),
+                Content = string.Format(
+                    System.Globalization.CultureInfo.CurrentCulture,
+                    resourceLoader.GetString("PythonScriptTrustContent"),
+                    scriptPath,
+                    hash),
+                PrimaryButtonText = resourceLoader.GetString("PythonScriptTrustConfirm"),
+                CloseButtonText = resourceLoader.GetString("PythonScriptTrustCancel"),
+            };
+
+            // XamlRoot must be set for ContentDialog to function.
+            var mainWindow = (Microsoft.UI.Xaml.Application.Current as AdvancedPaste.App)?.GetMainWindow();
+            if (mainWindow?.Content?.XamlRoot is { } xamlRoot)
+            {
+                dialog.XamlRoot = xamlRoot;
+            }
+
+            var result = await dialog.ShowAsync();
+            return result == ContentDialogResult.Primary;
+        }
+        catch (Exception ex)
+        {
+            Logger.LogError("Failed to show trust dialog", ex);
+            return false;
+        }
+    }
+
+    public void StoreTrust(string scriptPath, string hash)
+    {
+        _userSettings.StoreTrustedScriptHash(scriptPath, hash);
+    }
+
+    public string ComputeHash(string scriptPath)
+    {
+        using var stream = File.OpenRead(scriptPath);
+        var hashBytes = SHA256.HashData(stream);
+        return Convert.ToHexStringLower(hashBytes);
+    }
+
+    public async Task<bool> RequestInstallAsync(string scriptName, IReadOnlyList<PythonRequirement> missingPackages)
+    {
+        try
+        {
+            var resourceLoader = ResourceLoaderInstance.ResourceLoader;
+            var packageList = string.Join("\n", missingPackages.Select(r =>
+                string.Equals(r.ImportName, r.PipPackage, StringComparison.Ordinal)
+                    ? $"  • {r.PipPackage}"
+                    : $"  • {r.PipPackage}  (import: {r.ImportName})"));
+
+            var dialog = new ContentDialog
+            {
+                Title = resourceLoader.GetString("PythonPackageInstallTitle"),
+                Content = string.Format(
+                    System.Globalization.CultureInfo.CurrentCulture,
+                    resourceLoader.GetString("PythonPackageInstallContent"),
+                    scriptName,
+                    packageList),
+                PrimaryButtonText = resourceLoader.GetString("PythonPackageInstallConfirm"),
+                CloseButtonText = resourceLoader.GetString("PythonPackageInstallCancel"),
+            };
+
+            var mainWindow = (Microsoft.UI.Xaml.Application.Current as AdvancedPaste.App)?.GetMainWindow();
+            if (mainWindow?.Content?.XamlRoot is { } xamlRoot)
+            {
+                dialog.XamlRoot = xamlRoot;
+            }
+
+            var result = await dialog.ShowAsync();
+            return result == ContentDialogResult.Primary;
+        }
+        catch (Exception ex)
+        {
+            Logger.LogError("Failed to show package install dialog", ex);
+            return false;
+        }
+    }
+}

src/modules/AdvancedPaste/AdvancedPaste/Services/PythonScripts/_runner.py

@@ -0,0 +1,255 @@
+# Copyright (c) Microsoft Corporation
+# The Microsoft Corporation licenses this file to you under the MIT license.
+# See the LICENSE file in the project root for more information.
+
+"""
+Advanced Paste – Script Runner (V3 Named Function Interface)
+
+This runner is shipped with PowerToys and is NOT user-editable.
+It loads a user script, discovers the single advanced_paste_from_<input>_to_<output>
+function by name convention, calls it with the current clipboard data, and formats
+the return value into JSON on stdout.
+
+Each script must define exactly one function matching the pattern:
+  def advanced_paste_from_<input>_to_<output>(<param>)
+
+Supported input types:
+  - text, html, image, audio, video, files
+
+Required output types (declared via _to_ suffix):
+  - text, html, image, file, files
+
+Examples:
+  - advanced_paste_from_text_to_text(text: str)    → output is text
+  - advanced_paste_from_text_to_image(text: str)   → output is image
+  - advanced_paste_from_image_to_text(image_path)  → output is text
+  - advanced_paste_from_files_to_text(file_paths)  → output is text
+
+Protocol:
+  - Input:  JSON on stdin (clipboard data from C#)
+  - Output: JSON on stdout (result for C# to set on clipboard)
+  - Errors: stderr (displayed to user on failure)
+"""
+
+import importlib.util
+import json
+import os
+import re
+import sys
+from pathlib import Path
+
+
+def _apply_output_hint(result, hint: str) -> dict:
+    """
+    Force the output to the type specified by the _to_ suffix in the function name.
+    Converts the return value to match the hinted type.
+    """
+    if result is None:
+        if hint == "text":
+            return {"result_type": "text", "text": ""}
+        elif hint == "html":
+            return {"result_type": "html", "html": ""}
+        elif hint == "image":
+            return {"result_type": "image", "image_path": ""}
+        elif hint == "audio":
+            return {"result_type": "audio", "audio_path": ""}
+        elif hint == "video":
+            return {"result_type": "video", "video_path": ""}
+        elif hint in ("file", "files"):
+            return {"result_type": hint, "file_paths": []}
+
+    if hint == "text":
+        return {"result_type": "text", "text": str(result) if not isinstance(result, str) else result}
+    elif hint == "html":
+        return {"result_type": "html", "html": str(result) if not isinstance(result, str) else result}
+    elif hint == "image":
+        path = str(result)
+        return {"result_type": "image", "image_path": path}
+    elif hint == "audio":
+        path = str(result)
+        return {"result_type": "audio", "audio_path": path}
+    elif hint == "video":
+        path = str(result)
+        return {"result_type": "video", "video_path": path}
+    elif hint == "file":
+        if isinstance(result, (list, tuple)):
+            paths = [str(p) for p in result]
+        else:
+            paths = [str(result)]
+        return {"result_type": "file", "file_paths": paths}
+    elif hint == "files":
+        if isinstance(result, (list, tuple)):
+            paths = [str(p) for p in result]
+        else:
+            paths = [str(result)]
+        return {"result_type": "files", "file_paths": paths}
+
+    # Fallback (shouldn't happen with valid hints)
+    return {"result_type": "text", "text": str(result)}
+
+# Pattern matching advanced_paste_from_<input>_to_<output> function names.
+_AP_FUNCTION_PATTERN = re.compile(
+    r"^advanced_paste_from_(text|html|image|audio|video|files)_to_(text|html|image|audio|video|file|files)$"
+)
+
+
+def _load_user_module(script_path: str):
+    """Dynamically load the user script as a Python module."""
+    spec = importlib.util.spec_from_file_location("_user_script", script_path)
+    if spec is None or spec.loader is None:
+        raise ImportError(f"Cannot load script: {script_path}")
+    module = importlib.util.module_from_spec(spec)
+    # Add the script's directory to sys.path so relative imports/helpers work.
+    script_dir = os.path.dirname(os.path.abspath(script_path))
+    if script_dir not in sys.path:
+        sys.path.insert(0, script_dir)
+    spec.loader.exec_module(module)
+    return module
+
+
+def _discover_ap_function(module) -> tuple:
+    """
+    Discover the single advanced_paste_from_<input>_to_<output> function in the module.
+    Returns a tuple (input_type, output_type, function) or None if not found.
+    Exits with error if multiple functions are defined.
+    """
+    matches = []
+    for name in dir(module):
+        match = _AP_FUNCTION_PATTERN.match(name)
+        if match:
+            fn = getattr(module, name)
+            if callable(fn):
+                input_type = match.group(1)
+                output_type = match.group(2)
+                matches.append((input_type, output_type, fn))
+
+    if len(matches) == 0:
+        return None
+    if len(matches) > 1:
+        names = [f"advanced_paste_from_{m[0]}_to_{m[1]}" for m in matches]
+        print(
+            f"Error: script defines multiple advanced_paste_from_*_to_* functions "
+            f"({', '.join(names)}). Only one is allowed per script.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+    return matches[0]
+
+
+def _format_output(result, output_type: str) -> dict:
+    """
+    Format the return value according to the declared output type from the function name.
+    The output_type comes from the _to_ suffix and is always provided.
+    """
+    if result is None:
+        if output_type in ("file", "files"):
+            return {"result_type": output_type, "file_paths": []}
+        elif output_type == "image":
+            return {"result_type": "image", "image_path": ""}
+        elif output_type == "audio":
+            return {"result_type": "audio", "audio_path": ""}
+        elif output_type == "video":
+            return {"result_type": "video", "video_path": ""}
+        elif output_type == "html":
+            return {"result_type": "html", "html": ""}
+        return {"result_type": "text", "text": ""}
+
+    return _apply_output_hint(result, output_type)
+
+
+# ---------------------------------------------------------------------------
+# Main entry point
+# ---------------------------------------------------------------------------
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: _runner.py <script_path>", file=sys.stderr)
+        sys.exit(1)
+
+    script_path = sys.argv[1]
+
+    if not os.path.isfile(script_path):
+        print(f"Error: script not found: {script_path}", file=sys.stderr)
+        sys.exit(1)
+
+    # Read input payload from stdin.
+    try:
+        data = json.load(sys.stdin)
+    except json.JSONDecodeError as e:
+        print(f"Error: invalid JSON input: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    # Load the user script.
+    module = _load_user_module(script_path)
+
+    # Discover the single advanced_paste_from_* function.
+    ap_result = _discover_ap_function(module)
+
+    if ap_result is None:
+        print(
+            f"Error: script '{os.path.basename(script_path)}' does not define an "
+            f"advanced_paste_from_<input>_to_<output> function.\n"
+            f"Example: def advanced_paste_from_text_to_text(text): return text.upper()",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    input_type, output_type, fn = ap_result
+
+    # Determine the input data key for this function's input type.
+    input_map = {
+        "text": "text",
+        "html": "html",
+        "image": "image_path",
+        "audio": "audio_path",
+        "video": "video_path",
+        "files": "file_paths",
+    }
+
+    key = input_map.get(input_type, input_type)
+    input_value = data.get(key)
+
+    # Expose work_dir as environment variable so scripts can write output files
+    # to a location accessible from both WSL and Windows (under /mnt/c/...).
+    work_dir = data.get("work_dir", "")
+    if work_dir:
+        os.environ["ADVANCED_PASTE_WORK_DIR"] = work_dir
+
+    # Check if the clipboard has matching data for this script's input type.
+    formats = data.get("format", ["text"])
+    if isinstance(formats, str):
+        formats = [formats]
+
+    # Normalize: treat "file" and "files" as equivalent so that
+    # advanced_paste_from_files_to_* scripts match the C# ClipboardFormat.File flag.
+    normalized_formats = set(formats)
+    if "file" in normalized_formats:
+        normalized_formats.add("files")
+    if "files" in normalized_formats:
+        normalized_formats.add("file")
+
+    if input_type not in normalized_formats:
+        print(
+            f"Error: script expects '{input_type}' input but clipboard has [{', '.join(formats)}].",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    if input_value is None:
+        print(
+            f"Error: no data available for format '{input_type}' "
+            f"(expected '{key}' in input payload).",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    # Call the function.
+    result = fn(input_value)
+    output = _format_output(result, output_type)
+
+    # Output JSON result.
+    json.dump(output, sys.stdout, ensure_ascii=False)
+
+
+if __name__ == "__main__":
+    main()

src/modules/AdvancedPaste/AdvancedPaste/Strings/en-us/Resources.resw

@@ -212,10 +212,10 @@
     <value>Delete</value>
   </data>
   <data name="CustomFormatTextBox.PlaceholderText" xml:space="preserve">
-    <value>Describe what format you want..</value>
+    <value>Search or describe what format you want...</value>
   </data>
   <data name="InputTxtBoxTooltip.Text" xml:space="preserve">
-    <value>Describe what format you want..</value>
+    <value>Search or describe what format you want...</value>
   </data>
   <data name="LearnMoreLink.Text" xml:space="preserve">
     <value>Privacy</value>
@@ -372,4 +372,75 @@
     <value>Unable to load Foundry Local model: {0}</value>
     <comment>{0} is the model identifier. Do not translate {0}.</comment>
   </data>
+  <data name="PythonNotFound" xml:space="preserve">
+    <value>Python was not found. Please install Python or configure the path in Settings.</value>
+  </data>
+  <data name="WslNotAvailable" xml:space="preserve">
+    <value>WSL is not installed or not available. Cannot run Linux scripts.</value>
+  </data>
+  <data name="PythonScriptFailed" xml:space="preserve">
+    <value>The Python script failed to execute.</value>
+  </data>
+  <data name="PythonScriptTimeout" xml:space="preserve">
+    <value>Script execution timed out ({0} seconds).</value>
+    <comment>{0} is the configured timeout in seconds. Do not translate {0}.</comment>
+  </data>
+  <data name="PythonScriptNotFound" xml:space="preserve">
+    <value>Script file not found: {0}</value>
+    <comment>{0} is the script file path. Do not translate {0}.</comment>
+  </data>
+  <data name="PythonScriptInvalidJson" xml:space="preserve">
+    <value>The script output is not valid JSON.</value>
+  </data>
+  <data name="PythonScriptTrustTitle" xml:space="preserve">
+    <value>Run Python Script?</value>
+  </data>
+  <data name="PythonScriptTrustContent" xml:space="preserve">
+    <value>This script has not been verified. Running untrusted scripts can be a security risk. Do you want to run the following script?
+
+{0}
+
+SHA256: {1}</value>
+    <comment>{0} is the script file path. {1} is the SHA-256 hash of the script. Do not translate {0} or {1}.</comment>
+  </data>
+  <data name="PythonScriptTrustConfirm" xml:space="preserve">
+    <value>Run</value>
+  </data>
+  <data name="PythonScriptTrustCancel" xml:space="preserve">
+    <value>Cancel</value>
+  </data>
+  <data name="PythonPackageInstallTitle" xml:space="preserve">
+    <value>Install Missing Packages?</value>
+  </data>
+  <data name="PythonPackageInstallContent" xml:space="preserve">
+    <value>The script "{0}" requires the following Python packages that are not installed:
+
+{1}
+
+Install them now?</value>
+    <comment>{0} = script display name, {1} = bullet list of package names. Do not translate package names.</comment>
+  </data>
+  <data name="PythonPackageInstallConfirm" xml:space="preserve">
+    <value>Install</value>
+  </data>
+  <data name="PythonPackageInstallCancel" xml:space="preserve">
+    <value>Skip</value>
+  </data>
+  <data name="PythonPackageInstallFailed" xml:space="preserve">
+    <value>Failed to install package(s) "{0}": {1}</value>
+    <comment>{0} = pip package names, {1} = error detail. Do not translate package names.</comment>
+  </data>
+  <data name="PythonPackageInstallTimeout" xml:space="preserve">
+    <value>Package installation for "{0}" timed out ({1} seconds).</value>
+    <comment>{0} = pip package names, {1} = timeout in seconds. Do not translate {0} or {1}.</comment>
+  </data>
+  <data name="ShowErrorDetailsBtn.Content" xml:space="preserve">
+    <value>Show details</value>
+  </data>
+  <data name="ErrorDetailsDialogTitle" xml:space="preserve">
+    <value>Error Details</value>
+  </data>
+  <data name="ErrorDetailsDialogClose" xml:space="preserve">
+    <value>Close</value>
+  </data>
 </root>

src/modules/AdvancedPaste/AdvancedPaste/ViewModels/OptionsViewModel.cs

@@ -16,6 +16,7 @@ using System.Threading.Tasks;
 using AdvancedPaste.Helpers;
 using AdvancedPaste.Models;
 using AdvancedPaste.Services;
+using AdvancedPaste.Services.PythonScripts;
 using AdvancedPaste.Settings;
 using Common.UI;
 using CommunityToolkit.Mvvm.ComponentModel;
@@ -41,6 +42,7 @@ namespace AdvancedPaste.ViewModels
         private readonly IUserSettings _userSettings;
         private readonly IPasteFormatExecutor _pasteFormatExecutor;
         private readonly IAICredentialsProvider _credentialsProvider;
+        private readonly IPythonScriptService _pythonScriptService;
 
         private CancellationTokenSource _pasteActionCancellationTokenSource;
 
@@ -100,6 +102,8 @@ namespace AdvancedPaste.ViewModels
 
         public ObservableCollection<PasteFormat> CustomActionPasteFormats { get; } = [];
 
+        public ObservableCollection<PasteFormat> PythonScriptPasteFormats { get; } = [];
+
         public bool IsCustomAIServiceEnabled
         {
             get
@@ -234,8 +238,6 @@ namespace AdvancedPaste.ViewModels
 
         public bool ShowClipboardHistoryButton => ClipboardHistoryEnabled;
 
-        public bool ShowAIPasteSection => _userSettings.ShowAIPaste && IsAllowedByGPO;
-
         public bool HasIndeterminateTransformProgress => double.IsNaN(TransformProgress);
 
         private PasteFormats CustomAIFormat =>
@@ -260,11 +262,12 @@ namespace AdvancedPaste.ViewModels
 
         public event EventHandler PreviewRequested;
 
-        public OptionsViewModel(IFileSystem fileSystem, IAICredentialsProvider credentialsProvider, IUserSettings userSettings, IPasteFormatExecutor pasteFormatExecutor)
+        public OptionsViewModel(IFileSystem fileSystem, IAICredentialsProvider credentialsProvider, IUserSettings userSettings, IPasteFormatExecutor pasteFormatExecutor, IPythonScriptService pythonScriptService)
         {
             _credentialsProvider = credentialsProvider;
             _userSettings = userSettings;
             _pasteFormatExecutor = pasteFormatExecutor;
+            _pythonScriptService = pythonScriptService;
 
             GeneratedResponses = [];
             GeneratedResponses.CollectionChanged += (s, e) =>
@@ -322,7 +325,6 @@ namespace AdvancedPaste.ViewModels
             OnPropertyChanged(nameof(AIProviders));
             OnPropertyChanged(nameof(AllowedAIProviders));
             OnPropertyChanged(nameof(ShowClipboardPreview));
-            OnPropertyChanged(nameof(ShowAIPasteSection));
 
             NotifyActiveProviderChanged();
 
@@ -416,12 +418,51 @@ namespace AdvancedPaste.ViewModels
             }
 
             UpdateFormats(StandardPasteFormats, Enum.GetValues<PasteFormats>()
-                                                    .Where(format => PasteFormat.MetadataDict[format].IsCoreAction || _userSettings.AdditionalActions.Contains(format))
+                                                    .Where(format => format != PasteFormats.PythonScript &&
+                                                                     (PasteFormat.MetadataDict[format].IsCoreAction || _userSettings.AdditionalActions.Contains(format)))
                                                     .Select(CreateStandardPasteFormat));
 
             UpdateFormats(
                 CustomActionPasteFormats,
                 IsCustomAIServiceEnabled ? _userSettings.CustomActions.Select(customAction => CreateCustomAIPasteFormat(customAction.Name, customAction.Prompt, isSavedQuery: true)) : []);
+
+            UpdateFormats(
+                PythonScriptPasteFormats,
+                BuildPythonScriptFormats());
+        }
+
+        private IEnumerable<PasteFormat> BuildPythonScriptFormats()
+        {
+            if (!_userSettings.IsPythonScriptsEnabled)
+            {
+                yield break;
+            }
+
+            var folder = _userSettings.PythonScriptsFolder;
+            if (string.IsNullOrWhiteSpace(folder))
+            {
+                yield break;
+            }
+
+            var discoveredScripts = _pythonScriptService.DiscoverScripts(folder);
+            var scriptActions = _userSettings.PythonScriptActions;
+
+            // Use metadata from discovered scripts, but apply IsShown from saved settings.
+            var hiddenPaths = new System.Collections.Generic.HashSet<string>(
+                scriptActions.Where(a => !a.IsShown).Select(a => a.ScriptPath),
+                StringComparer.OrdinalIgnoreCase);
+
+            foreach (var meta in discoveredScripts)
+            {
+                if (hiddenPaths.Contains(meta.ScriptPath) || !meta.IsEnabled)
+                {
+                    continue;
+                }
+
+                // Filter by intersection: only pass clipboard formats the script supports.
+                var filteredFormats = AvailableClipboardFormats & meta.SupportedFormats;
+                yield return PasteFormat.CreatePythonScriptFormat(meta.Name, meta.ScriptPath, filteredFormats);
+            }
         }
 
         public void Dispose()
@@ -695,7 +736,10 @@ namespace AdvancedPaste.ViewModels
             _pasteActionCancellationTokenSource = new();
             TransformProgress = double.NaN;
             PasteActionError = PasteActionError.None;
-            Query = pasteFormat.Query;
+
+            // For Python scripts the Prompt field holds the file path, not a user-visible query.
+            // Setting Query to the path would show it in the AI prompt box, which is misleading.
+            Query = pasteFormat.Format == PasteFormats.PythonScript ? string.Empty : pasteFormat.Query;
 
             try
             {
@@ -735,7 +779,7 @@ namespace AdvancedPaste.ViewModels
 
         internal async Task ExecutePasteFormatAsync(VirtualKey key)
         {
-            var pasteFormat = StandardPasteFormats.Concat(CustomActionPasteFormats)
+            var pasteFormat = StandardPasteFormats.Concat(CustomActionPasteFormats).Concat(PythonScriptPasteFormats)
                                                   .Where(pasteFormat => pasteFormat.IsEnabled)
                                                   .ElementAtOrDefault(key - VirtualKey.Number1);
 

src/modules/AdvancedPaste/AdvancedPasteModuleInterface/dllmain.cpp

@@ -496,119 +496,23 @@ private:
 
         if (!GetGUIThreadInfo(0, &gui_info))
         {
-            Logger::warn(L"Auto-copy: GetGUIThreadInfo failed (error={})", GetLastError());
             return false;
         }
 
         HWND target = gui_info.hwndFocus ? gui_info.hwndFocus : gui_info.hwndActive;
         if (!target)
         {
-            Logger::warn(L"Auto-copy: no focused or active window found");
             return false;
         }
 
         DWORD_PTR result = 0;
-        auto sendResult = SendMessageTimeout(target, WM_COPY, 0, 0, SMTO_ABORTIFHUNG | SMTO_BLOCK, 50, &result);
-        return sendResult != 0;
-    }
-
-    // Helper: poll clipboard sequence number for a change from initial_sequence.
-    // Returns true if the sequence number changed within the given number of polls.
-    bool poll_clipboard_sequence(DWORD initial_sequence, int poll_attempts, std::chrono::milliseconds poll_delay)
-    {
-        for (int poll = 0; poll < poll_attempts; ++poll)
-        {
-            if (GetClipboardSequenceNumber() != initial_sequence)
-            {
-                return true;
-            }
-            std::this_thread::sleep_for(poll_delay);
-        }
-        return false;
-    }
-
-    // Helper: send Ctrl+C via SendInput, releasing any held modifier keys first
-    // (the hotkey combination may still have modifiers physically pressed).
-    bool send_ctrl_c_input()
-    {
-        std::vector<INPUT> inputs;
-
-        // Release all modifier keys that are currently held down from the hotkey.
-        // Without this, the target app sees e.g. Win+Shift+Ctrl+C instead of just Ctrl+C.
-        try_inject_modifier_key_up(inputs, VK_LCONTROL);
-        try_inject_modifier_key_up(inputs, VK_RCONTROL);
-        try_inject_modifier_key_up(inputs, VK_LWIN);
-        try_inject_modifier_key_up(inputs, VK_RWIN);
-        try_inject_modifier_key_up(inputs, VK_LSHIFT);
-        try_inject_modifier_key_up(inputs, VK_RSHIFT);
-        try_inject_modifier_key_up(inputs, VK_LMENU);
-        try_inject_modifier_key_up(inputs, VK_RMENU);
-
-        // Ctrl down
-        {
-            INPUT input_event = {};
-            input_event.type = INPUT_KEYBOARD;
-            input_event.ki.wVk = VK_CONTROL;
-            input_event.ki.dwExtraInfo = CENTRALIZED_KEYBOARD_HOOK_DONT_TRIGGER_FLAG;
-            inputs.push_back(input_event);
-        }
-
-        // C down
-        {
-            INPUT input_event = {};
-            input_event.type = INPUT_KEYBOARD;
-            input_event.ki.wVk = 0x43; // C
-            input_event.ki.dwExtraInfo = CENTRALIZED_KEYBOARD_HOOK_DONT_TRIGGER_FLAG;
-            inputs.push_back(input_event);
-        }
-
-        // C up
-        {
-            INPUT input_event = {};
-            input_event.type = INPUT_KEYBOARD;
-            input_event.ki.wVk = 0x43; // C
-            input_event.ki.dwFlags = KEYEVENTF_KEYUP;
-            input_event.ki.dwExtraInfo = CENTRALIZED_KEYBOARD_HOOK_DONT_TRIGGER_FLAG;
-            inputs.push_back(input_event);
-        }
-
-        // Ctrl up
-        {
-            INPUT input_event = {};
-            input_event.type = INPUT_KEYBOARD;
-            input_event.ki.wVk = VK_CONTROL;
-            input_event.ki.dwFlags = KEYEVENTF_KEYUP;
-            input_event.ki.dwExtraInfo = CENTRALIZED_KEYBOARD_HOOK_DONT_TRIGGER_FLAG;
-            inputs.push_back(input_event);
-        }
-
-        // Restore modifiers that were held down
-        try_inject_modifier_key_restore(inputs, VK_LCONTROL);
-        try_inject_modifier_key_restore(inputs, VK_RCONTROL);
-        try_inject_modifier_key_restore(inputs, VK_LWIN);
-        try_inject_modifier_key_restore(inputs, VK_RWIN);
-        try_inject_modifier_key_restore(inputs, VK_LSHIFT);
-        try_inject_modifier_key_restore(inputs, VK_RSHIFT);
-        try_inject_modifier_key_restore(inputs, VK_LMENU);
-        try_inject_modifier_key_restore(inputs, VK_RMENU);
-
-        // Prevent Start Menu from activating after Win key release/restore
-        INPUT dummyEvent = {};
-        dummyEvent.type = INPUT_KEYBOARD;
-        dummyEvent.ki.wVk = 0xFF;
-        dummyEvent.ki.dwFlags = KEYEVENTF_KEYUP;
-        inputs.push_back(dummyEvent);
-
-        auto uSent = SendInput(static_cast<UINT>(inputs.size()), inputs.data(), sizeof(INPUT));
-        if (uSent != inputs.size())
-        {
-            DWORD errorCode = GetLastError();
-            auto errorMessage = get_last_error_message(errorCode);
-            Logger::error(L"SendInput failed for Ctrl+C. Expected to send {} inputs and sent only {}. {}", inputs.size(), uSent, errorMessage.has_value() ? errorMessage.value() : L"");
-            Trace::AdvancedPaste_Error(errorCode, errorMessage.has_value() ? errorMessage.value() : L"", L"input.SendInput");
-            return false;
-        }
-        return true;
+        return SendMessageTimeout(target,
+                                  WM_COPY,
+                                  0,
+                                  0,
+                                  SMTO_ABORTIFHUNG | SMTO_BLOCK,
+                                  50,
+                                  &result) != 0;
     }
 
     bool send_copy_selection()
@@ -622,30 +526,99 @@ private:
         for (int attempt = 0; attempt < copy_attempts; ++attempt)
         {
             const auto initial_sequence = GetClipboardSequenceNumber();
+            copy_succeeded = try_send_copy_message();
 
-            // Strategy 1: Try WM_COPY message (works for standard Win32 controls)
-            bool wm_copy_sent = try_send_copy_message();
-
-            if (wm_copy_sent)
+            if (!copy_succeeded)
             {
-                if (poll_clipboard_sequence(initial_sequence, clipboard_poll_attempts, clipboard_poll_delay))
+                std::vector<INPUT> inputs;
+
+                // Release any held modifiers (from the Advanced Paste hotkey) before sending Ctrl+C.
+                // Without this, apps may receive Win+Shift+Ctrl+C instead of Ctrl+C.
+                try_inject_modifier_key_up(inputs, VK_LCONTROL);
+                try_inject_modifier_key_up(inputs, VK_RCONTROL);
+                try_inject_modifier_key_up(inputs, VK_LWIN);
+                try_inject_modifier_key_up(inputs, VK_RWIN);
+                try_inject_modifier_key_up(inputs, VK_LSHIFT);
+                try_inject_modifier_key_up(inputs, VK_RSHIFT);
+                try_inject_modifier_key_up(inputs, VK_LMENU);
+                try_inject_modifier_key_up(inputs, VK_RMENU);
+
+                // send Ctrl+C (key downs and key ups)
+                {
+                    INPUT input_event = {};
+                    input_event.type = INPUT_KEYBOARD;
+                    input_event.ki.wVk = VK_CONTROL;
+                    input_event.ki.dwExtraInfo = CENTRALIZED_KEYBOARD_HOOK_DONT_TRIGGER_FLAG;
+                    inputs.push_back(input_event);
+                }
+
+                {
+                    INPUT input_event = {};
+                    input_event.type = INPUT_KEYBOARD;
+                    input_event.ki.wVk = 0x43; // C
+                    // Avoid triggering detection by the centralized keyboard hook.
+                    input_event.ki.dwExtraInfo = CENTRALIZED_KEYBOARD_HOOK_DONT_TRIGGER_FLAG;
+                    inputs.push_back(input_event);
+                }
+
+                {
+                    INPUT input_event = {};
+                    input_event.type = INPUT_KEYBOARD;
+                    input_event.ki.wVk = 0x43; // C
+                    input_event.ki.dwFlags = KEYEVENTF_KEYUP;
+                    // Avoid triggering detection by the centralized keyboard hook.
+                    input_event.ki.dwExtraInfo = CENTRALIZED_KEYBOARD_HOOK_DONT_TRIGGER_FLAG;
+                    inputs.push_back(input_event);
+                }
+
+                {
+                    INPUT input_event = {};
+                    input_event.type = INPUT_KEYBOARD;
+                    input_event.ki.wVk = VK_CONTROL;
+                    input_event.ki.dwFlags = KEYEVENTF_KEYUP;
+                    input_event.ki.dwExtraInfo = CENTRALIZED_KEYBOARD_HOOK_DONT_TRIGGER_FLAG;
+                    inputs.push_back(input_event);
+                }
+
+                // Restore modifiers that were released above.
+                try_inject_modifier_key_restore(inputs, VK_LCONTROL);
+                try_inject_modifier_key_restore(inputs, VK_RCONTROL);
+                try_inject_modifier_key_restore(inputs, VK_LWIN);
+                try_inject_modifier_key_restore(inputs, VK_RWIN);
+                try_inject_modifier_key_restore(inputs, VK_LSHIFT);
+                try_inject_modifier_key_restore(inputs, VK_RSHIFT);
+                try_inject_modifier_key_restore(inputs, VK_LMENU);
+                try_inject_modifier_key_restore(inputs, VK_RMENU);
+
+                auto uSent = SendInput(static_cast<UINT>(inputs.size()), inputs.data(), sizeof(INPUT));
+                if (uSent != inputs.size())
+                {
+                    DWORD errorCode = GetLastError();
+                    auto errorMessage = get_last_error_message(errorCode);
+                    Logger::error(L"SendInput failed for Ctrl+C. Expected to send {} inputs and sent only {}. {}", inputs.size(), uSent, errorMessage.has_value() ? errorMessage.value() : L"");
+                    Trace::AdvancedPaste_Error(errorCode, errorMessage.has_value() ? errorMessage.value() : L"", L"input.SendInput");
+                }
+                else
                 {
                     copy_succeeded = true;
                 }
             }
 
-            // Strategy 2: If WM_COPY didn't work, try SendInput Ctrl+C (works for Electron, browsers, etc.)
-            if (!copy_succeeded)
+            if (copy_succeeded)
             {
-                const auto sequence_before_ctrl_c = GetClipboardSequenceNumber();
-
-                if (send_ctrl_c_input())
+                bool sequence_changed = false;
+                for (int poll_attempt = 0; poll_attempt < clipboard_poll_attempts; ++poll_attempt)
                 {
-                    if (poll_clipboard_sequence(sequence_before_ctrl_c, clipboard_poll_attempts, clipboard_poll_delay))
+                    if (GetClipboardSequenceNumber() != initial_sequence)
                     {
-                        copy_succeeded = true;
+                        sequence_changed = true;
+                        break;
                     }
+
+                    std::this_thread::sleep_for(clipboard_poll_delay);
                 }
+
+                copy_succeeded = sequence_changed;
             }
 
             if (copy_succeeded)
@@ -659,11 +632,6 @@ private:
             }
         }
 
-        if (!copy_succeeded)
-        {
-            Logger::warn(L"Auto-copy: all {} copy attempts failed — the target application did not update the clipboard after WM_COPY and Ctrl+C", copy_attempts);
-        }
-
         return copy_succeeded;
     }
 
@@ -1036,7 +1004,6 @@ public:
             {
                 if (!send_copy_selection())
                 {
-                    Logger::warn(L"Auto-copy: failed to copy selection for custom action index {} — aborting action", custom_action_index);
                     return false;
                 }
             }

src/modules/AdvancedPaste/UITest-AdvancedPaste/TestFiles/settings.json

@@ -1 +1 @@
-{"properties":{"IsAIEnabled":{"value":false},"ShowCustomPreview":{"value":true},"ShowAIPaste":{"value":true},"CloseAfterLosingFocus":{"value":false},"advanced-paste-ui-hotkey":{"win":true,"ctrl":false,"alt":false,"shift":true,"code":86,"key":""},"paste-as-plain-hotkey":{"win":true,"ctrl":true,"alt":true,"shift":false,"code":79,"key":""},"paste-as-markdown-hotkey":{"win":true,"ctrl":true,"alt":true,"shift":false,"code":77,"key":""},"paste-as-json-hotkey":{"win":true,"ctrl":true,"alt":true,"shift":false,"code":74,"key":""},"custom-actions":{"value":[]},"additional-actions":{"image-to-text":{"shortcut":{"win":false,"ctrl":false,"alt":false,"shift":false,"code":0,"key":""},"isShown":true},"paste-as-file":{"isShown":true,"paste-as-txt-file":{"shortcut":{"win":false,"ctrl":false,"alt":false,"shift":false,"code":0,"key":""},"isShown":true},"paste-as-png-file":{"shortcut":{"win":false,"ctrl":false,"alt":false,"shift":false,"code":0,"key":""},"isShown":true},"paste-as-html-file":{"shortcut":{"win":false,"ctrl":false,"alt":false,"shift":false,"code":0,"key":""},"isShown":true}},"transcode":{"isShown":true,"transcode-to-mp3":{"shortcut":{"win":false,"ctrl":false,"alt":false,"shift":false,"code":0,"key":""},"isShown":true},"transcode-to-mp4":{"shortcut":{"win":false,"ctrl":false,"alt":false,"shift":false,"code":0,"key":""},"isShown":true}}},"paste-ai-configuration":{"active-provider-id":"","providers":[],"use-shared-credentials":true}},"name":"AdvancedPaste","version":"1"}
+{"properties":{"IsAIEnabled":{"value":false},"ShowCustomPreview":{"value":true},"CloseAfterLosingFocus":{"value":false},"advanced-paste-ui-hotkey":{"win":true,"ctrl":false,"alt":false,"shift":true,"code":86,"key":""},"paste-as-plain-hotkey":{"win":true,"ctrl":true,"alt":true,"shift":false,"code":79,"key":""},"paste-as-markdown-hotkey":{"win":true,"ctrl":true,"alt":true,"shift":false,"code":77,"key":""},"paste-as-json-hotkey":{"win":true,"ctrl":true,"alt":true,"shift":false,"code":74,"key":""},"custom-actions":{"value":[]},"additional-actions":{"image-to-text":{"shortcut":{"win":false,"ctrl":false,"alt":false,"shift":false,"code":0,"key":""},"isShown":true},"paste-as-file":{"isShown":true,"paste-as-txt-file":{"shortcut":{"win":false,"ctrl":false,"alt":false,"shift":false,"code":0,"key":""},"isShown":true},"paste-as-png-file":{"shortcut":{"win":false,"ctrl":false,"alt":false,"shift":false,"code":0,"key":""},"isShown":true},"paste-as-html-file":{"shortcut":{"win":false,"ctrl":false,"alt":false,"shift":false,"code":0,"key":""},"isShown":true}},"transcode":{"isShown":true,"transcode-to-mp3":{"shortcut":{"win":false,"ctrl":false,"alt":false,"shift":false,"code":0,"key":""},"isShown":true},"transcode-to-mp4":{"shortcut":{"win":false,"ctrl":false,"alt":false,"shift":false,"code":0,"key":""},"isShown":true}}},"paste-ai-configuration":{"active-provider-id":"","providers":[],"use-shared-credentials":true}},"name":"AdvancedPaste","version":"1"}

src/modules/MouseWithoutBorders/ModuleInterface/MouseWithoutBordersModuleInterface.vcxproj.filters

@@ -39,7 +39,6 @@
   </ItemGroup>
   <ItemGroup>
     <Natvis Include="$(MSBuildThisFileDirectory)..\..\natvis\wil.natvis" />
-    <Natvis Include="$(MSBuildThisFileDirectory)..\..\natvis\wil.natstepfilter" />
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />

src/modules/MouseWithoutBorders/ModuleInterface/packages.config

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="Microsoft.Windows.ImplementationLibrary" version="1.0.260126.7" targetFramework="native" />
-</packages>
+  <package id="Microsoft.Windows.ImplementationLibrary" version="1.0.250325.1" targetFramework="native" />
+</packages>

src/modules/NewPlus/NewShellExtensionContextMenu.win10/resources.resx

@@ -119,7 +119,7 @@
   </resheader>
   <data name="context_menu_item_new" xml:space="preserve">
     <value>New+</value>
-    <comment>The main context menu item that users click on. This should be localized to match New in Windows. e.g. Danish it would become Ny+, French it would become Nouveau+ (not Nouveauté+)</comment>
+    <comment>The main context menu item that users click on. This should be localized to match New in Windows. e.g. Danish it would become Ny+</comment>
   </data>
   <data name="context_menu_item_open_templates" xml:space="preserve">
     <value>Open templates</value>

src/modules/NewPlus/NewShellExtensionContextMenu/resources.resx

@@ -119,7 +119,7 @@
   </resheader>
   <data name="context_menu_item_new" xml:space="preserve">
     <value>New+</value>
-    <comment>The main context menu item that users click on. This should be localized to match New in Windows. e.g. Danish it would become Ny+, French it would become Nouveau+ (not Nouveauté+)</comment>
+    <comment>The main context menu item that users click on. This should be localized to match New in Windows. e.g. Danish it would become Ny+</comment>
   </data>
   <data name="context_menu_item_open_templates" xml:space="preserve">
     <value>Open templates</value>

src/modules/cmdpal/Microsoft.CmdPal.Common/Helpers/ShellArgumentBuilder.cs

@@ -1,98 +0,0 @@
-// Copyright (c) Microsoft Corporation
-// The Microsoft Corporation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System.Text;
-
-namespace Microsoft.CmdPal.Common.Helpers;
-
-public static class ShellArgumentBuilder
-{
-    public static string BuildArguments(params string[] arguments)
-    {
-        if (arguments.Length <= 0)
-        {
-            return string.Empty;
-        }
-
-        var stringBuilder = new StringBuilder();
-        foreach (var argument in arguments)
-        {
-            AppendArgument(stringBuilder, argument);
-        }
-
-        return stringBuilder.ToString();
-    }
-
-    private static void AppendArgument(StringBuilder stringBuilder, string argument)
-    {
-        if (stringBuilder.Length > 0)
-        {
-            stringBuilder.Append(' ');
-        }
-
-        if (argument.Length == 0 || ShouldBeQuoted(argument))
-        {
-            stringBuilder.Append('"');
-            var index = 0;
-            while (index < argument.Length)
-            {
-                var c = argument[index++];
-                if (c == '\\')
-                {
-                    var numBackSlash = 1;
-                    while (index < argument.Length && argument[index] == '\\')
-                    {
-                        index++;
-                        numBackSlash++;
-                    }
-
-                    if (index == argument.Length)
-                    {
-                        stringBuilder.Append('\\', numBackSlash * 2);
-                    }
-                    else if (argument[index] == '"')
-                    {
-                        stringBuilder.Append('\\', (numBackSlash * 2) + 1);
-                        stringBuilder.Append('"');
-                        index++;
-                    }
-                    else
-                    {
-                        stringBuilder.Append('\\', numBackSlash);
-                    }
-
-                    continue;
-                }
-
-                if (c == '"')
-                {
-                    stringBuilder.Append('\\');
-                    stringBuilder.Append('"');
-                    continue;
-                }
-
-                stringBuilder.Append(c);
-            }
-
-            stringBuilder.Append('"');
-        }
-        else
-        {
-            stringBuilder.Append(argument);
-        }
-    }
-
-    private static bool ShouldBeQuoted(string argument)
-    {
-        foreach (var c in argument)
-        {
-            if (char.IsWhiteSpace(c) || c == '"')
-            {
-                return true;
-            }
-        }
-
-        return false;
-    }
-}

src/modules/cmdpal/Microsoft.CmdPal.Common/Services/HttpCaching/HttpCachingClient.cs

@@ -94,7 +94,6 @@ internal sealed partial class HttpCachingClient : IDisposable
     public void Dispose()
     {
         _httpClient.Dispose();
-        _cacheHandler.Dispose();
     }
 
     private static bool IsSupportedHttpUri(Uri resourceUri)

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Commands/MainListPage.cs

@@ -146,7 +146,13 @@ public sealed partial class MainListPage : DynamicListPage,
         // The all apps page will kick off a BG thread to start loading apps.
         // We just want to know when it is done.
         var allApps = AllAppsCommandProvider.Page;
-        allApps.PropChanged += AllApps_PropChanged;
+        allApps.PropChanged += (s, p) =>
+        {
+            if (p.PropertyName == nameof(allApps.IsLoading))
+            {
+                IsLoading = ActuallyLoading();
+            }
+        };
 
         WeakReferenceMessenger.Default.Register<ClearSearchMessage>(this);
         WeakReferenceMessenger.Default.Register<UpdateFallbackItemsMessage>(this);
@@ -166,14 +172,6 @@ public sealed partial class MainListPage : DynamicListPage,
         }
     }
 
-    private void AllApps_PropChanged(object? sender, IPropChangedEventArgs e)
-    {
-        if (e.PropertyName == nameof(AllAppsCommandProvider.Page.IsLoading))
-        {
-            IsLoading = ActuallyLoading();
-        }
-    }
-
     private void PinnedCommands_CollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
     {
         _defaultViewDirty = true;
@@ -784,8 +782,6 @@ public sealed partial class MainListPage : DynamicListPage,
         _tlcManager.TopLevelCommands.CollectionChanged -= Commands_CollectionChanged;
         _tlcManager.PinnedCommands.CollectionChanged -= PinnedCommands_CollectionChanged;
 
-        AllAppsCommandProvider.Page.PropChanged -= AllApps_PropChanged;
-
         if (_settingsService is not null)
         {
             _settingsService.SettingsChanged -= SettingsChangedHandler;

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Services/WinRTExtensionService.cs

@@ -541,9 +541,6 @@ public partial class WinRTExtensionService : IExtensionService, IDisposable
         {
             if (disposing)
             {
-                _catalog.PackageInstalling -= Catalog_PackageInstalling;
-                _catalog.PackageUninstalling -= Catalog_PackageUninstalling;
-                _catalog.PackageUpdating -= Catalog_PackageUpdating;
                 _getInstalledExtensionsLock.Dispose();
             }
 

src/modules/cmdpal/Microsoft.CmdPal.UI/Controls/BlurImageControl.cs

@@ -94,7 +94,6 @@ internal sealed partial class BlurImageControl : Control
     private SpriteVisual? _effectVisual;
     private CompositionEffectBrush? _effectBrush;
     private CompositionSurfaceBrush? _imageBrush;
-    private LoadedImageSurface? _lastLoadedSurface;
 
     public BlurImageControl()
     {
@@ -380,20 +379,10 @@ internal sealed partial class BlurImageControl : Control
             }
 
             Logger.LogDebug($"Starting load of BlurImageControl from '{bitmapImage.UriSource}'");
-
-            // Each call to LoadImageAsync creates a new LoadedImageSurface backed by native
-            // composition resources. The old surface becomes unrooted once the brush points at
-            // the new one, so it isn't leaked, but dispose it explicitly so the unmanaged
-            // resources are released deterministically instead of waiting for finalization.
-            var previousSurface = _lastLoadedSurface;
-
             var loadedSurface = LoadedImageSurface.StartLoadFromUri(bitmapImage.UriSource);
-            _lastLoadedSurface = loadedSurface;
             loadedSurface.LoadCompleted += OnLoadedSurfaceOnLoadCompleted;
             SetLoadedSurfaceToBrush(loadedSurface);
             _effectBrush?.SetSourceParameter(ImageSourceParameterName, _imageBrush);
-
-            previousSurface?.Dispose();
         }
         catch (Exception ex)
         {

src/modules/cmdpal/Microsoft.CmdPal.UI/Controls/ContentFormControl.xaml.cs

@@ -8,9 +8,7 @@ using Microsoft.CmdPal.UI.ViewModels;
 using Microsoft.UI.Xaml;
 using Microsoft.UI.Xaml.Automation;
 using Microsoft.UI.Xaml.Controls;
-using Microsoft.UI.Xaml.Input;
 using Microsoft.UI.Xaml.Media;
-using Windows.System;
 
 namespace Microsoft.CmdPal.UI.Controls;
 
@@ -24,7 +22,6 @@ public sealed partial class ContentFormControl : UserControl
     // tree. If this gets GC'ed, then it'll revoke our Action handler, and the
     // form will do seemingly nothing.
     private RenderedAdaptiveCard? _renderedCard;
-    private AdaptiveCard? _adaptiveCard;
 
     public ContentFormViewModel? ViewModel { get => _viewModel; set => AttachViewModel(value); }
 
@@ -98,11 +95,9 @@ public sealed partial class ContentFormControl : UserControl
     private void DisplayCard(AdaptiveCardParseResult result)
     {
         _renderedCard = _renderer.RenderAdaptiveCard(result.AdaptiveCard);
-        _adaptiveCard = result.AdaptiveCard;
         ContentGrid.Children.Clear();
         if (_renderedCard.FrameworkElement is not null)
         {
-            _renderedCard.FrameworkElement.KeyDown += OnFormKeyDown;
             ContentGrid.Children.Add(_renderedCard.FrameworkElement);
 
             // Use the Loaded event to ensure we focus after the card is in the visual tree
@@ -119,9 +114,8 @@ public sealed partial class ContentFormControl : UserControl
 
     private void OnFrameworkElementLayoutUpdated(object? sender, object e)
     {
-        // Only fix once — unhook from sender (not _renderedCard, which may have been
-        // reassigned by the time this fires).
-        if (sender is FrameworkElement element)
+        // Only fix once — unhook after first layout pass
+        if (_renderedCard?.FrameworkElement is FrameworkElement element)
         {
             element.LayoutUpdated -= OnFrameworkElementLayoutUpdated;
             FixToggleAccessibilityNames(element);
@@ -282,50 +276,6 @@ public sealed partial class ContentFormControl : UserControl
         return null;
     }
 
-    private void OnFormKeyDown(object sender, KeyRoutedEventArgs e)
-    {
-        // Snapshot the fields so a subsequent DisplayCard call can't swap the
-        // rendered/parsed card out from under us mid-method. This keeps the
-        // resolved submit action and the gathered inputs from the same card.
-        var renderedCard = _renderedCard;
-        var adaptiveCard = _adaptiveCard;
-
-        if (e.Key != VirtualKey.Enter || renderedCard == null || adaptiveCard == null)
-        {
-            return;
-        }
-
-        // Only submit when Enter is pressed inside a single-line TextBox
-        if (e.OriginalSource is TextBox textBox && !textBox.AcceptsReturn)
-        {
-            // Find the first Submit or Execute action on the card
-            IAdaptiveActionElement? submitAction = null;
-            foreach (var action in adaptiveCard.Actions)
-            {
-                if (action is AdaptiveSubmitAction or AdaptiveExecuteAction)
-                {
-                    submitAction = action;
-                    break;
-                }
-            }
-
-            if (submitAction != null)
-            {
-                e.Handled = true;
-
-                // Validate (and gather) the inputs before submitting. AsJson() only
-                // returns the values cached by a successful ValidateInputs() call, so
-                // skipping this would submit an empty payload. This mirrors what the
-                // renderer does internally when a submit button is clicked.
-                var inputs = renderedCard.UserInputs;
-                if (inputs.ValidateInputs(submitAction))
-                {
-                    ViewModel?.HandleSubmit(submitAction, inputs.AsJson());
-                }
-            }
-        }
-    }
-
     private void Rendered_Action(RenderedAdaptiveCard sender, AdaptiveActionEventArgs args) =>
         ViewModel?.HandleSubmit(args.Action, args.Inputs.AsJson());
 }

src/modules/cmdpal/Microsoft.CmdPal.UI/MainWindow.xaml.cs

@@ -192,7 +192,7 @@ public sealed partial class MainWindow : WindowEx,
         App.Current.Services.GetRequiredService<ISettingsService>().SettingsChanged += SettingsChangedHandler;
 
         // Make sure that we update the acrylic theme when the OS theme changes
-        RootElement.ActualThemeChanged += RootElement_ActualThemeChanged;
+        RootElement.ActualThemeChanged += (s, e) => DispatcherQueue.TryEnqueue(UpdateBackdrop);
 
         // Hardcoding event name to avoid bringing in the PowerToys.interop dependency. Event name must match CMDPAL_SHOW_EVENT from shared_constants.h
         NativeEventWaiter.WaitForEventLoop("Local\\PowerToysCmdPal-ShowEvent-62336fcd-8611-4023-9b30-091a6af4cc5a", () =>
@@ -222,11 +222,6 @@ public sealed partial class MainWindow : WindowEx,
         UpdateBackdrop();
     }
 
-    private void RootElement_ActualThemeChanged(FrameworkElement sender, object args)
-    {
-        DispatcherQueue.TryEnqueue(UpdateBackdrop);
-    }
-
     private static void LocalKeyboardListener_OnKeyPressed(object? sender, LocalKeyboardListenerKeyPressedEventArgs e)
     {
         if (e.Key == VirtualKey.GoBack)
@@ -1688,9 +1683,6 @@ public sealed partial class MainWindow : WindowEx,
 
     public void Dispose()
     {
-        _themeService.ThemeChanged -= ThemeServiceOnThemeChanged;
-        App.Current.Services.GetRequiredService<ISettingsService>().SettingsChanged -= SettingsChangedHandler;
-
         _localKeyboardListener.Dispose();
         _windowThemeSynchronizer.Dispose();
         DisposeAcrylic();

src/modules/cmdpal/Microsoft.CmdPal.UI/Settings/ExtensionsPage.xaml.cs

@@ -22,7 +22,6 @@ public sealed partial class ExtensionsPage : Page
 
     private readonly SettingsViewModel? viewModel;
     private readonly Dictionary<string, WeakReference<SettingsCard>> _vmToCardMap = new();
-    private readonly Dictionary<SettingsCard, ProviderSettingsViewModel> _cardToVmMap = new();
 
     public ExtensionsPage()
     {
@@ -32,23 +31,6 @@ public sealed partial class ExtensionsPage : Page
         var themeService = App.Current.Services.GetService<IThemeService>()!;
         var settingsService = App.Current.Services.GetRequiredService<ISettingsService>();
         viewModel = new SettingsViewModel(topLevelCommandManager, _mainTaskScheduler, themeService, settingsService);
-
-        Unloaded += ExtensionsPage_Unloaded;
-    }
-
-    private void ExtensionsPage_Unloaded(object sender, RoutedEventArgs e)
-    {
-        // ProviderSettingsViewModel subscribes to its CommandProviderWrapper (owned by the
-        // singleton TopLevelCommandManager), so a live VM roots this page through the
-        // PropertyChanged handler below. Drain any VMs still hooked when the page is torn
-        // down; SettingsCard_DataContextChanged only unhooks the ones that get recycled.
-        foreach (var vm in _cardToVmMap.Values)
-        {
-            vm.PropertyChanged -= ProviderViewModel_PropertyChanged;
-        }
-
-        _cardToVmMap.Clear();
-        _vmToCardMap.Clear();
     }
 
     private void SettingsCard_Click(object sender, RoutedEventArgs e)
@@ -64,28 +46,16 @@ public sealed partial class ExtensionsPage : Page
 
     private void SettingsCard_DataContextChanged(FrameworkElement sender, DataContextChangedEventArgs args)
     {
-        if (sender is SettingsCard card)
+        // Store the card reference keyed by Id (not the VM itself) to avoid leaking VM references
+        if (sender is SettingsCard card && card.DataContext is ProviderSettingsViewModel newVm)
         {
-            // Unsubscribe from the previous ViewModel to prevent handler accumulation
-            // when virtualization recycles items with a new DataContext.
-            if (_cardToVmMap.TryGetValue(card, out var oldVm))
-            {
-                oldVm.PropertyChanged -= ProviderViewModel_PropertyChanged;
-                _cardToVmMap.Remove(card);
-            }
+            _vmToCardMap[newVm.Id] = new WeakReference<SettingsCard>(card);
+            newVm.PropertyChanged += ProviderViewModel_PropertyChanged;
 
-            // Store the card reference keyed by Id (not the VM itself) to avoid leaking VM references
-            if (card.DataContext is ProviderSettingsViewModel newVm)
+            // Immediately update automation name in case DisplayName is already available
+            if (card.Content is ToggleSwitch toggle && !string.IsNullOrEmpty(newVm.DisplayName))
             {
-                _vmToCardMap[newVm.Id] = new WeakReference<SettingsCard>(card);
-                _cardToVmMap[card] = newVm;
-                newVm.PropertyChanged += ProviderViewModel_PropertyChanged;
-
-                // Immediately update automation name in case DisplayName is already available
-                if (card.Content is ToggleSwitch toggle && !string.IsNullOrEmpty(newVm.DisplayName))
-                {
-                    AutomationProperties.SetName(toggle, newVm.DisplayName);
-                }
+                AutomationProperties.SetName(toggle, newVm.DisplayName);
             }
         }
     }

src/modules/cmdpal/Tests/Microsoft.CmdPal.Common.UnitTests/Helpers/ShellArgumentBuilderTests.cs

@@ -1,32 +0,0 @@
-// Copyright (c) Microsoft Corporation
-// The Microsoft Corporation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using Microsoft.CmdPal.Common.Helpers;
-
-namespace Microsoft.CmdPal.Common.UnitTests.Helpers;
-
-[TestClass]
-public class ShellArgumentBuilderTests
-{
-    [DataTestMethod]
-    [DataRow("plain", "plain")]
-    [DataRow("C:\\Program Files\\PowerToys", "\"C:\\Program Files\\PowerToys\"")]
-    [DataRow("say \"hello\"", "\"say \\\"hello\\\"\"")]
-    [DataRow("", "\"\"")]
-    [DataRow("C:\\Program Files\\", "\"C:\\Program Files\\\\\"")]
-    public void BuildArguments_FormatsSingleArgument(string argument, string expected)
-    {
-        var actual = ShellArgumentBuilder.BuildArguments(argument);
-
-        Assert.AreEqual(expected, actual);
-    }
-
-    [TestMethod]
-    public void BuildArguments_FormatsMultipleArguments()
-    {
-        var actual = ShellArgumentBuilder.BuildArguments("plain", "C:\\Program Files\\PowerToys", "two words");
-
-        Assert.AreEqual("plain \"C:\\Program Files\\PowerToys\" \"two words\"", actual);
-    }
-}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Bookmark/Helpers/CommandLauncher.cs

@@ -5,7 +5,6 @@
 using System.ComponentModel;
 using System.Runtime.InteropServices;
 using ManagedCommon;
-using Microsoft.CmdPal.Common.Helpers;
 
 namespace Microsoft.CmdPal.Ext.Bookmarks.Helpers;
 
@@ -25,7 +24,7 @@ internal static class CommandLauncher
                 // You can notice the difference with Recycle Bin for example:
                 // - "explorer ::{645FF040-5081-101B-9F08-00AA002F954E}"
                 // - "::{645FF040-5081-101B-9F08-00AA002F954E}"
-                return ShellHelpers.OpenInShell("explorer.exe", ShellArgumentBuilder.BuildArguments(classification.Target));
+                return ShellHelpers.OpenInShell("explorer.exe", classification.Target);
 
             case LaunchMethod.ActivateAppId:
                 return ActivateAppId(classification.Target, classification.Arguments);

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Bookmark/Microsoft.CmdPal.Ext.Bookmarks.csproj

@@ -11,7 +11,6 @@
     <ProjectPriFileName>Microsoft.CmdPal.Ext.Bookmarks.pri</ProjectPriFileName>
   </PropertyGroup>
   <ItemGroup>
-    <ProjectReference Include="..\..\Microsoft.CmdPal.Common\Microsoft.CmdPal.Common.csproj" />
     <ProjectReference Include="..\..\extensionsdk\Microsoft.CommandPalette.Extensions.Toolkit\Microsoft.CommandPalette.Extensions.Toolkit.csproj" />
     <ProjectReference Include="..\..\ext\Microsoft.CmdPal.Ext.Indexer\Microsoft.CmdPal.Ext.Indexer.csproj" />
   </ItemGroup>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Shell/Helpers/ShellListPageHelpers.cs

@@ -2,7 +2,7 @@
 // The Microsoft Corporation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using Microsoft.CmdPal.Common.Helpers;
+using System.Text;
 using Microsoft.CommandPalette.Extensions.Toolkit;
 
 namespace Microsoft.CmdPal.Ext.Shell.Helpers;
@@ -42,7 +42,98 @@ public class ShellListPageHelpers
         executable = segments[0];
         if (segments.Length > 1)
         {
-            arguments = ShellArgumentBuilder.BuildArguments(segments[1..]);
+            arguments = ArgumentBuilder.BuildArguments(segments[1..]);
+        }
+    }
+
+    private static class ArgumentBuilder
+    {
+        internal static string BuildArguments(string[] arguments)
+        {
+            if (arguments.Length <= 0)
+            {
+                return string.Empty;
+            }
+
+            var stringBuilder = new StringBuilder();
+            foreach (var argument in arguments)
+            {
+                AppendArgument(stringBuilder, argument);
+            }
+
+            return stringBuilder.ToString();
+        }
+
+        private static void AppendArgument(StringBuilder stringBuilder, string argument)
+        {
+            if (stringBuilder.Length > 0)
+            {
+                stringBuilder.Append(' ');
+            }
+
+            if (argument.Length == 0 || ShouldBeQuoted(argument))
+            {
+                stringBuilder.Append('\"');
+                var index = 0;
+                while (index < argument.Length)
+                {
+                    var c = argument[index++];
+                    if (c == '\\')
+                    {
+                        var numBackSlash = 1;
+                        while (index < argument.Length && argument[index] == '\\')
+                        {
+                            index++;
+                            numBackSlash++;
+                        }
+
+                        if (index == argument.Length)
+                        {
+                            stringBuilder.Append('\\', numBackSlash * 2);
+                        }
+                        else if (argument[index] == '\"')
+                        {
+                            stringBuilder.Append('\\', (numBackSlash * 2) + 1);
+                            stringBuilder.Append('\"');
+                            index++;
+                        }
+                        else
+                        {
+                            stringBuilder.Append('\\', numBackSlash);
+                        }
+
+                        continue;
+                    }
+
+                    if (c == '\"')
+                    {
+                        stringBuilder.Append('\\');
+                        stringBuilder.Append('\"');
+                        continue;
+                    }
+
+                    stringBuilder.Append(c);
+                }
+
+                stringBuilder.Append('\"');
+            }
+            else
+            {
+                stringBuilder.Append(argument);
+            }
+        }
+
+        private static bool ShouldBeQuoted(string s)
+        {
+            foreach (var c in s)
+            {
+                if (char.IsWhiteSpace(c) || c == '\"')
+                {
+                    return true;
+                }
+            }
+
+            return false;
         }
     }
 }

src/modules/cmdpal/extensionsdk/Microsoft.CommandPalette.Extensions.Toolkit/Commands/ShowFileInFolderCommand.cs

@@ -27,7 +27,7 @@ public partial class ShowFileInFolderCommand : InvokableCommand
             try
             {
                 var argument = "/select, \"" + _path + "\"";
-                using var process = Process.Start("explorer.exe", argument);
+                Process.Start("explorer.exe", argument);
             }
             catch (Exception)
             {

src/modules/fancyzones/FancyZonesLib/FancyZones.cpp

@@ -866,14 +866,6 @@ void FancyZones::UpdateWorkAreas(bool updateWindowPositions) noexcept
         std::vector<FancyZonesDataTypes::MonitorId> monitors = { FancyZonesDataTypes::MonitorId{ .monitor = nullptr, .deviceId = { .id = ZonedWindowProperties::MultiMonitorName, .instanceId = ZonedWindowProperties::MultiMonitorInstance } } };
         if (ShouldWorkAreasBeRecreated(monitors, currentVirtualDesktop, m_workAreaConfiguration.GetAllWorkAreas()))
         {
-            // WindowMouseSnap caches a raw WorkArea* in m_currentWorkArea and the
-            // WorkArea map by reference. WorkAreaConfiguration::Clear() destroys
-            // every unique_ptr<WorkArea> (and hence the inner ZonesOverlay and
-            // its std::mutex). If a drag is in flight, the next MoveSizeUpdate
-            // would dereference that dangling WorkArea* and lock the freed
-            // mutex. Drain the active drag first so subsequent drag messages
-            // hit the snapper's `if (m_windowMouseSnapper)` guard and no-op.
-            MoveSizeEnd();
             m_workAreaConfiguration.Clear();
 
             FancyZonesDataTypes::WorkAreaId workAreaId;
@@ -890,8 +882,6 @@ void FancyZones::UpdateWorkAreas(bool updateWindowPositions) noexcept
         
         if (ShouldWorkAreasBeRecreated(monitors, currentVirtualDesktop, workAreas))
         {
-            // See comment above the matching Clear() in the span-zones branch.
-            MoveSizeEnd();
             m_workAreaConfiguration.Clear();
             for (const auto& monitor : monitors)
             {
@@ -1104,9 +1094,6 @@ void FancyZones::SettingsUpdate(SettingId id)
     break;
     case SettingId::SpanZonesAcrossMonitors:
     {
-        // See UpdateWorkAreas() — same WindowMouseSnap dangling-WorkArea*
-        // hazard if the user toggles this setting mid-drag.
-        MoveSizeEnd();
         m_workAreaConfiguration.Clear();
         PostMessageW(m_window, WM_PRIV_INIT, NULL, NULL);
     }

src/modules/fancyzones/FancyZonesLib/OnThreadExecutor.cpp

@@ -48,14 +48,7 @@ void OnThreadExecutor::worker_thread()
 
 OnThreadExecutor::~OnThreadExecutor()
 {
-    {
-        // Modify the shared shutdown flag while holding the mutex so the
-        // worker reliably observes it on its next wake. Without this, a notify
-        // racing the worker entering _task_cv.wait can be missed and the join
-        // below hangs forever.
-        std::lock_guard lock{ _task_mutex };
-        _shutdown_request = true;
-    }
+    _shutdown_request = true;
     _task_cv.notify_one();
     _worker_thread.join();
 }

src/modules/fancyzones/FancyZonesLib/WorkArea.cpp

@@ -115,11 +115,6 @@ WorkArea::WorkArea(HINSTANCE hinstance, const FancyZonesDataTypes::WorkAreaId& u
 
 WorkArea::~WorkArea()
 {
-    // Tear down the renderer (joining its background thread) before returning
-    // the HWND to the pool. Otherwise, the render thread can still be drawing
-    // through m_renderTarget into an HWND that has already been recycled by a
-    // subsequent NewZonesOverlayWindow call.
-    m_zonesOverlay.reset();
     windowPool.FreeZonesOverlayWindow(m_window);
 }
 

src/modules/fancyzones/FancyZonesLib/ZonesOverlay.cpp

@@ -340,19 +340,13 @@ void ZonesOverlay::DrawActiveZoneSet(const ZonesMap& zones,
 
 ZonesOverlay::~ZonesOverlay()
 {
-    // Constructor early-returns (e.g. CreateHwndRenderTarget failing during a
-    // display-driver TDR) leave m_renderThread default-constructed; calling
-    // join() on a non-joinable thread terminates the process.
-    if (m_renderThread.joinable())
     {
-        {
-            std::unique_lock lock(m_mutex);
-            m_abortThread = true;
-            m_shouldRender = true;
-        }
-        m_cv.notify_all();
-        m_renderThread.join();
+        std::unique_lock lock(m_mutex);
+        m_abortThread = true;
+        m_shouldRender = true;
     }
+    m_cv.notify_all();
+    m_renderThread.join();
 
     if (m_renderTarget)
     {

src/modules/imageresizer/tests/ImageResizer.UnitTests.csproj

@@ -26,31 +26,6 @@
     <ProjectReference Include="..\ui\ImageResizerUI.csproj" />
   </ItemGroup>
 
-  <!--
-    MSB3030 parallel-build race hardening.
-
-    ImageResizerUI is a self-contained WinUI 3 app whose PowerToys.ImageResizer.runtimeconfig.json
-    and PowerToys.ImageResizer.deps.json are written late into the shared WinUI3Apps output folder.
-    This unit test project references ImageResizerUI only for its types (see InternalsVisibleTo
-    "ImageResizer.Test" in ImageResizerUI.csproj); it never launches the app, so it does not need
-    those two app runtime json files. During a highly parallel "Build All" the test's
-    copy-to-output step can run before those files exist, producing:
-      MSB3030: Could not copy the file "...\PowerToys.ImageResizer.runtimeconfig.json" because it was not found.
-    Removing just those two never-needed files from this project's copy-to-output lists makes the
-    race impossible. The referenced PowerToys.ImageResizer.dll is still copied, so tests run normally.
-  -->
-  <Target Name="ExcludeReferencedAppRuntimeJsonFromCopy"
-          AfterTargets="GetCopyToOutputDirectoryItems">
-    <ItemGroup>
-      <_SourceItemsToCopyToOutputDirectory
-        Remove="@(_SourceItemsToCopyToOutputDirectory)"
-        Condition="'%(Filename)%(Extension)' == 'PowerToys.ImageResizer.runtimeconfig.json' or '%(Filename)%(Extension)' == 'PowerToys.ImageResizer.deps.json'" />
-      <_SourceItemsToCopyToOutputDirectoryAlways
-        Remove="@(_SourceItemsToCopyToOutputDirectoryAlways)"
-        Condition="'%(Filename)%(Extension)' == 'PowerToys.ImageResizer.runtimeconfig.json' or '%(Filename)%(Extension)' == 'PowerToys.ImageResizer.deps.json'" />
-    </ItemGroup>
-  </Target>
-
   <ItemGroup>
     <Content Include="Test.gif">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>

src/modules/keyboardmanager/KeyboardManagerEditor/KeyboardManagerEditor.vcxproj

@@ -59,6 +59,7 @@
   </PropertyGroup>
   <!-- Props that are constant for both Debug and Release configurations -->
   <PropertyGroup Label="Configuration">
+    
     <OutDir>..\..\..\..\$(Platform)\$(Configuration)\$(MSBuildProjectName)\</OutDir>
     <CharacterSet>Unicode</CharacterSet>
     <SpectreMitigation>Spectre</SpectreMitigation>
@@ -163,7 +164,7 @@
     <Import Project="..\..\..\..\packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.targets" Condition="Exists('..\..\..\..\packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.targets')" />
     <Import Project="..\..\..\..\packages\Microsoft.VCRTForwarders.140.1.0.7\build\native\Microsoft.VCRTForwarders.140.targets" Condition="Exists('..\..\..\..\packages\Microsoft.VCRTForwarders.140.1.0.7\build\native\Microsoft.VCRTForwarders.140.targets')" />
     <Import Project="..\..\..\..\packages\Microsoft.UI.Xaml.2.8.2-prerelease.220830001\build\native\Microsoft.UI.Xaml.targets" Condition="Exists('..\..\..\..\packages\Microsoft.UI.Xaml.2.8.2-prerelease.220830001\build\native\Microsoft.UI.Xaml.targets')" />
-    <Import Project="..\..\..\..\packages\Microsoft.Web.WebView2.1.0.4022.49\build\native\Microsoft.Web.WebView2.targets" Condition="Exists('..\..\..\..\packages\Microsoft.Web.WebView2.1.0.4022.49\build\native\Microsoft.Web.WebView2.targets')" />
+    <Import Project="..\..\..\..\packages\Microsoft.Web.WebView2.1.0.2903.40\build\native\Microsoft.Web.WebView2.targets" Condition="Exists('..\..\..\..\packages\Microsoft.Web.WebView2.1.0.2903.40\build\native\Microsoft.Web.WebView2.targets')" />
   </ImportGroup>
   <Import Project="..\..\..\..\deps\spdlog.props" />
   <Target Name="GenerateResourceFiles" BeforeTargets="PrepareForBuild">
@@ -180,7 +181,7 @@
     <Error Condition="!Exists('..\..\..\..\packages\Microsoft.VCRTForwarders.140.1.0.7\build\native\Microsoft.VCRTForwarders.140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.VCRTForwarders.140.1.0.7\build\native\Microsoft.VCRTForwarders.140.targets'))" />
     <Error Condition="!Exists('..\..\..\..\packages\Microsoft.UI.Xaml.2.8.2-prerelease.220830001\build\native\Microsoft.UI.Xaml.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.UI.Xaml.2.8.2-prerelease.220830001\build\native\Microsoft.UI.Xaml.props'))" />
     <Error Condition="!Exists('..\..\..\..\packages\Microsoft.UI.Xaml.2.8.2-prerelease.220830001\build\native\Microsoft.UI.Xaml.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.UI.Xaml.2.8.2-prerelease.220830001\build\native\Microsoft.UI.Xaml.targets'))" />
-    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.Web.WebView2.1.0.4022.49\build\native\Microsoft.Web.WebView2.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.Web.WebView2.1.0.4022.49\build\native\Microsoft.Web.WebView2.targets'))" />
+    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.Web.WebView2.1.0.2903.40\build\native\Microsoft.Web.WebView2.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.Web.WebView2.1.0.2903.40\build\native\Microsoft.Web.WebView2.targets'))" />
   </Target>
   <Target Name="FakeResourcesPriMerge" BeforeTargets="FinalizeBuildStatus" DependsOnTargets="CopyFilesToOutputDirectory">
     <Message Text="Renaming Microsoft.UI.Xaml.pri to resources.pri" />

src/modules/keyboardmanager/KeyboardManagerEditor/packages.config

@@ -3,6 +3,6 @@
   <package id="Microsoft.Toolkit.Win32.UI.XamlApplication" version="6.1.3" targetFramework="native" />
   <package id="Microsoft.UI.Xaml" version="2.8.2-prerelease.220830001" targetFramework="native" />
   <package id="Microsoft.VCRTForwarders.140" version="1.0.7" targetFramework="native" />
-  <package id="Microsoft.Web.WebView2" version="1.0.4022.49" targetFramework="native" />
+  <package id="Microsoft.Web.WebView2" version="1.0.2903.40" targetFramework="native" />
   <package id="Microsoft.Windows.CppWinRT" version="2.0.250303.1" targetFramework="native" />
 </packages>

src/modules/keyboardmanager/KeyboardManagerEditorLibrary/KeyboardManagerEditorLibrary.vcxproj

@@ -15,6 +15,7 @@
     <OutDir>..\..\..\..\$(Platform)\$(Configuration)\</OutDir>
   </PropertyGroup>
   <PropertyGroup Label="Configuration">
+    
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">
@@ -100,7 +101,7 @@
     <Import Project="..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.250303.1\build\native\Microsoft.Windows.CppWinRT.targets" Condition="Exists('..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.250303.1\build\native\Microsoft.Windows.CppWinRT.targets')" />
     <Import Project="..\..\..\..\packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.targets" Condition="Exists('..\..\..\..\packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.targets')" />
     <Import Project="..\..\..\..\packages\Microsoft.UI.Xaml.2.8.2-prerelease.220830001\build\native\Microsoft.UI.Xaml.targets" Condition="Exists('..\..\..\..\packages\Microsoft.UI.Xaml.2.8.2-prerelease.220830001\build\native\Microsoft.UI.Xaml.targets')" />
-    <Import Project="..\..\..\..\packages\Microsoft.Web.WebView2.1.0.4022.49\build\native\Microsoft.Web.WebView2.targets" Condition="Exists('..\..\..\..\packages\Microsoft.Web.WebView2.1.0.4022.49\build\native\Microsoft.Web.WebView2.targets')" />
+    <Import Project="..\..\..\..\packages\Microsoft.Web.WebView2.1.0.2903.40\build\native\Microsoft.Web.WebView2.targets" Condition="Exists('..\..\..\..\packages\Microsoft.Web.WebView2.1.0.2903.40\build\native\Microsoft.Web.WebView2.targets')" />
   </ImportGroup>
   <Import Project="..\..\..\..\deps\spdlog.props" />
   <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
@@ -113,7 +114,7 @@
     <Error Condition="!Exists('..\..\..\..\packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.Toolkit.Win32.UI.XamlApplication.6.1.3\build\native\Microsoft.Toolkit.Win32.UI.XamlApplication.targets'))" />
     <Error Condition="!Exists('..\..\..\..\packages\Microsoft.UI.Xaml.2.8.2-prerelease.220830001\build\native\Microsoft.UI.Xaml.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.UI.Xaml.2.8.2-prerelease.220830001\build\native\Microsoft.UI.Xaml.props'))" />
     <Error Condition="!Exists('..\..\..\..\packages\Microsoft.UI.Xaml.2.8.2-prerelease.220830001\build\native\Microsoft.UI.Xaml.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.UI.Xaml.2.8.2-prerelease.220830001\build\native\Microsoft.UI.Xaml.targets'))" />
-    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.Web.WebView2.1.0.4022.49\build\native\Microsoft.Web.WebView2.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.Web.WebView2.1.0.4022.49\build\native\Microsoft.Web.WebView2.targets'))" />
+    <Error Condition="!Exists('..\..\..\..\packages\Microsoft.Web.WebView2.1.0.2903.40\build\native\Microsoft.Web.WebView2.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\..\packages\Microsoft.Web.WebView2.1.0.2903.40\build\native\Microsoft.Web.WebView2.targets'))" />
   </Target>
   <Target Name="GenerateResourceFiles" BeforeTargets="PrepareForBuild">
     <Exec Command="powershell -NonInteractive -executionpolicy Unrestricted $(SolutionDir)tools\build\convert-resx-to-rc.ps1 $(MSBuildThisFileDirectory)\..\KeyboardManagerEditor\ resource.base.h resource.h KeyboardManagerEditor.base.rc KeyboardManagerEditor.rc" />

src/modules/keyboardmanager/KeyboardManagerEditorLibrary/packages.config

@@ -2,6 +2,6 @@
 <packages>
   <package id="Microsoft.Toolkit.Win32.UI.XamlApplication" version="6.1.3" targetFramework="native" />
   <package id="Microsoft.UI.Xaml" version="2.8.2-prerelease.220830001" targetFramework="native" />
-  <package id="Microsoft.Web.WebView2" version="1.0.4022.49" targetFramework="native" />
+  <package id="Microsoft.Web.WebView2" version="1.0.2903.40" targetFramework="native" />
   <package id="Microsoft.Windows.CppWinRT" version="2.0.250303.1" targetFramework="native" />
 </packages>

src/modules/poweraccent/PowerAccent.Core/PowerAccent.cs

@@ -22,7 +22,6 @@ public partial class PowerAccent : IDisposable
     private const double ScreenMinPadding = 150;
 
     private bool _visible;
-    private int _showGeneration;
     private string[] _characters = Array.Empty<string>();
     private string[] _characterDescriptions = Array.Empty<string>();
     private int _selectedIndex = -1;
@@ -99,10 +98,6 @@ public partial class PowerAccent : IDisposable
         _initialShiftState = WindowsFunctions.IsShiftState();
         _visible = true;
 
-        // Each summon gets a generation id so a delayed render queued by an earlier
-        // press can't fire for a newer one (or after the toolbar was hidden).
-        int generation = ++_showGeneration;
-
         _characters = GetCharacters(letterKey);
         _characterDescriptions = GetCharacterDescriptions(_characters);
         _showUnicodeDescription = _settingService.ShowUnicodeDescription;
@@ -110,7 +105,7 @@ public partial class PowerAccent : IDisposable
         Task.Delay(_settingService.InputTime).ContinueWith(
         t =>
         {
-            if (_visible && generation == _showGeneration)
+            if (_visible)
             {
                 OnChangeDisplay?.Invoke(true, _characters);
             }
@@ -242,7 +237,6 @@ public partial class PowerAccent : IDisposable
         OnChangeDisplay?.Invoke(false, null);
         _selectedIndex = -1;
         _visible = false;
-        _showGeneration++;
     }
 
     private void ProcessNextChar(TriggerKey triggerKey, bool shiftPressed)

src/settings-ui/Settings.UI.Library/AdvancedPasteProperties.cs

@@ -26,7 +26,6 @@ namespace Microsoft.PowerToys.Settings.UI.Library
             AdditionalActions = new();
             IsAIEnabled = false;
             ShowCustomPreview = true;
-            ShowAIPaste = true;
             CloseAfterLosingFocus = false;
             EnableClipboardPreview = true;
             AutoCopySelectionForCustomActionHotkey = false;
@@ -75,9 +74,6 @@ namespace Microsoft.PowerToys.Settings.UI.Library
         [JsonConverter(typeof(BoolPropertyJsonConverter))]
         public bool ShowCustomPreview { get; set; }
 
-        [JsonConverter(typeof(BoolPropertyJsonConverter))]
-        public bool ShowAIPaste { get; set; }
-
         [JsonConverter(typeof(BoolPropertyJsonConverter))]
         public bool CloseAfterLosingFocus { get; set; }
 
@@ -111,6 +107,10 @@ namespace Microsoft.PowerToys.Settings.UI.Library
         [CmdConfigureIgnoreAttribute]
         public PasteAIConfiguration PasteAIConfiguration { get; set; }
 
+        [JsonPropertyName("python-scripts")]
+        [CmdConfigureIgnoreAttribute]
+        public AdvancedPastePythonScriptSettings PythonScripts { get; set; } = new();
+
         public override string ToString()
             => JsonSerializer.Serialize(this, SettingsSerializationContext.Default.AdvancedPasteProperties);
     }

src/settings-ui/Settings.UI.Library/AdvancedPastePythonScriptAction.cs

@@ -0,0 +1,298 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json.Serialization;
+using Microsoft.PowerToys.Settings.UI.Library.Helpers;
+
+namespace Microsoft.PowerToys.Settings.UI.Library;
+
+public sealed class AdvancedPastePythonScriptAction : Observable, IAdvancedPasteAction, ICloneable
+{
+    private string _scriptPath = string.Empty;
+    private string _name = string.Empty;
+    private string _description = string.Empty;
+    private bool _isShown = true;
+    private bool _isEnabled = true;
+    private string _platform = "windows";
+    private string _formats = "any";
+    private string _requires = string.Empty;
+    private bool _requiresAutoDetect = true;
+    private HotkeySettings _shortcut = new();
+    private string _inputType = string.Empty;
+    private string _outputType = string.Empty;
+
+    [JsonPropertyName("scriptPath")]
+    public string ScriptPath
+    {
+        get => _scriptPath;
+        set => Set(ref _scriptPath, value ?? string.Empty);
+    }
+
+    [JsonPropertyName("name")]
+    public string Name
+    {
+        get => _name;
+        set
+        {
+            if (Set(ref _name, value ?? string.Empty))
+            {
+                OnPropertyChanged(nameof(DisplayName));
+            }
+        }
+    }
+
+    /// <summary>
+    /// Returns Name if non-empty, otherwise falls back to the script filename without extension.
+    /// </summary>
+    [JsonIgnore]
+    public string DisplayName =>
+        !string.IsNullOrWhiteSpace(_name)
+            ? _name
+            : System.IO.Path.GetFileNameWithoutExtension(_scriptPath);
+
+    [JsonPropertyName("description")]
+    public string Description
+    {
+        get => _description;
+        set => Set(ref _description, value ?? string.Empty);
+    }
+
+    [JsonPropertyName("isShown")]
+    public bool IsShown
+    {
+        get => _isShown;
+        set => Set(ref _isShown, value);
+    }
+
+    [JsonPropertyName("isEnabled")]
+    public bool IsEnabled
+    {
+        get => _isEnabled;
+        set => Set(ref _isEnabled, value);
+    }
+
+    [JsonPropertyName("platform")]
+    public string Platform
+    {
+        get => _platform;
+        set => Set(ref _platform, value ?? "windows");
+    }
+
+    [JsonPropertyName("formats")]
+    public string Formats
+    {
+        get => _formats;
+        set => Set(ref _formats, value ?? "any");
+    }
+
+    /// <summary>
+    /// Space-separated requires entries, e.g. "cv2=opencv-python-headless numpy requests".
+    /// Only written to header when RequiresAutoDetect is false (manual mode).
+    /// </summary>
+    [JsonPropertyName("requires")]
+    public string Requires
+    {
+        get => _requires;
+        set => Set(ref _requires, value ?? string.Empty);
+    }
+
+    /// <summary>
+    /// When true, dependencies are auto-detected from import statements.
+    /// When false, the manual <see cref="Requires"/> value is used.
+    /// </summary>
+    [JsonPropertyName("requiresAutoDetect")]
+    public bool RequiresAutoDetect
+    {
+        get => _requiresAutoDetect;
+        set => Set(ref _requiresAutoDetect, value);
+    }
+
+    /// <summary>
+    /// Inverted view of RequiresAutoDetect for UI binding.
+    /// Uses a separate field to avoid circular property change notifications.
+    /// </summary>
+    [JsonIgnore]
+    public bool IsRequiresManual
+    {
+        get => !_requiresAutoDetect;
+        set
+        {
+            var newAuto = !value;
+            if (_requiresAutoDetect != newAuto)
+            {
+                _requiresAutoDetect = newAuto;
+                OnPropertyChanged(nameof(RequiresAutoDetect));
+                OnPropertyChanged(nameof(IsRequiresManual));
+            }
+        }
+    }
+
+    [JsonPropertyName("shortcut")]
+    public HotkeySettings Shortcut
+    {
+        get => _shortcut;
+        set
+        {
+            if (_shortcut != value)
+            {
+                _shortcut = value ?? new();
+                OnPropertyChanged();
+            }
+        }
+    }
+
+    /// <summary>
+    /// The input type declared in the function name (e.g. "text", "image", "audio").
+    /// Read-only display property populated during script discovery.
+    /// </summary>
+    [JsonIgnore]
+    public string InputType
+    {
+        get => _inputType;
+        set => Set(ref _inputType, value ?? string.Empty);
+    }
+
+    /// <summary>
+    /// The output type declared in the function name (e.g. "text", "image", "file").
+    /// Read-only display property populated during script discovery.
+    /// </summary>
+    [JsonIgnore]
+    public string OutputType
+    {
+        get => _outputType;
+        set => Set(ref _outputType, value ?? string.Empty);
+    }
+
+    /// <summary>
+    /// Human-readable conversion summary, e.g. "text → image".
+    /// </summary>
+    [JsonIgnore]
+    public string ConversionSummary =>
+        !string.IsNullOrEmpty(_inputType) && !string.IsNullOrEmpty(_outputType)
+            ? $"{_inputType} → {_outputType}"
+            : string.Empty;
+
+    [JsonIgnore]
+    public IEnumerable<IAdvancedPasteAction> SubActions => [];
+
+    // Convenience properties for format checkboxes
+    [JsonIgnore]
+    public bool SupportsText
+    {
+        get => FormatContains("text");
+        set => ToggleFormat("text", value);
+    }
+
+    [JsonIgnore]
+    public bool SupportsHtml
+    {
+        get => FormatContains("html");
+        set => ToggleFormat("html", value);
+    }
+
+    [JsonIgnore]
+    public bool SupportsImage
+    {
+        get => FormatContains("image");
+        set => ToggleFormat("image", value);
+    }
+
+    [JsonIgnore]
+    public bool SupportsAudio
+    {
+        get => FormatContains("audio");
+        set => ToggleFormat("audio", value);
+    }
+
+    [JsonIgnore]
+    public bool SupportsVideo
+    {
+        get => FormatContains("video");
+        set => ToggleFormat("video", value);
+    }
+
+    [JsonIgnore]
+    public bool SupportsFiles
+    {
+        get => FormatContains("files") || FormatContains("file");
+        set => ToggleFormat("files", value);
+    }
+
+    private bool FormatContains(string format)
+    {
+        if (string.Equals(Formats, "any", StringComparison.OrdinalIgnoreCase))
+        {
+            return true;
+        }
+
+        return Formats.Split(',', StringSplitOptions.TrimEntries)
+                       .Any(f => string.Equals(f, format, StringComparison.OrdinalIgnoreCase));
+    }
+
+    private bool _isTogglingFormat;
+
+    private void ToggleFormat(string format, bool include)
+    {
+        if (_isTogglingFormat)
+        {
+            return;
+        }
+
+        _isTogglingFormat = true;
+        try
+        {
+            var currentFormats = string.Equals(Formats, "any", StringComparison.OrdinalIgnoreCase)
+                ? new HashSet<string>(["text", "html", "image", "audio", "video", "files"], StringComparer.OrdinalIgnoreCase)
+                : new HashSet<string>(Formats.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries), StringComparer.OrdinalIgnoreCase);
+
+            // Normalize file/files
+            currentFormats.Remove("file");
+
+            if (include)
+            {
+                currentFormats.Add(format);
+            }
+            else
+            {
+                currentFormats.Remove(format);
+            }
+
+            var allFormats = new HashSet<string>(["text", "html", "image", "audio", "video", "files"], StringComparer.OrdinalIgnoreCase);
+            Formats = currentFormats.SetEquals(allFormats) ? "any" : string.Join(", ", currentFormats);
+
+            OnPropertyChanged(nameof(SupportsText));
+            OnPropertyChanged(nameof(SupportsHtml));
+            OnPropertyChanged(nameof(SupportsImage));
+            OnPropertyChanged(nameof(SupportsAudio));
+            OnPropertyChanged(nameof(SupportsVideo));
+            OnPropertyChanged(nameof(SupportsFiles));
+        }
+        finally
+        {
+            _isTogglingFormat = false;
+        }
+    }
+
+    public object Clone()
+    {
+        return new AdvancedPastePythonScriptAction
+        {
+            ScriptPath = ScriptPath,
+            Name = Name,
+            Description = Description,
+            IsShown = IsShown,
+            IsEnabled = IsEnabled,
+            Platform = Platform,
+            Formats = Formats,
+            Requires = Requires,
+            RequiresAutoDetect = RequiresAutoDetect,
+            InputType = InputType,
+            OutputType = OutputType,
+            Shortcut = Shortcut != null ? new HotkeySettings(Shortcut.Win, Shortcut.Ctrl, Shortcut.Alt, Shortcut.Shift, Shortcut.Code) : null,
+        };
+    }
+}

src/settings-ui/Settings.UI.Library/AdvancedPastePythonScriptSettings.cs

@@ -0,0 +1,106 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using System.Text.Json.Serialization;
+
+namespace Microsoft.PowerToys.Settings.UI.Library;
+
+public sealed class AdvancedPastePythonScriptSettings
+{
+    /// <summary>
+    /// Execution mode: "disabled", "windows", or "wsl".
+    /// </summary>
+    [JsonPropertyName("mode")]
+    public string Mode { get; set; } = "disabled";
+
+    /// <summary>
+    /// Settings specific to Windows-native Python execution.
+    /// </summary>
+    [JsonPropertyName("windowsSettings")]
+    public PythonScriptWindowsSettings WindowsSettings { get; set; } = new();
+
+    /// <summary>
+    /// Settings specific to WSL Python execution.
+    /// </summary>
+    [JsonPropertyName("wslSettings")]
+    public PythonScriptWslSettings WslSettings { get; set; } = new();
+
+    [JsonPropertyName("timeoutSeconds")]
+    public int TimeoutSeconds { get; set; } = 30;
+
+    [JsonPropertyName("value")]
+    public List<AdvancedPastePythonScriptAction> Value { get; set; } = [];
+
+    [JsonPropertyName("trustedScriptHashes")]
+    public Dictionary<string, string> TrustedScriptHashes { get; set; } = [];
+
+    // Legacy properties — read for migration, never written back
+    [JsonPropertyName("isEnabled")]
+    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+    public bool? IsEnabled { get; set; }
+
+    [JsonPropertyName("useWsl")]
+    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+    public bool? UseWsl { get; set; }
+
+    [JsonPropertyName("scriptsFolder")]
+    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+    public string ScriptsFolder { get; set; }
+
+    [JsonPropertyName("pythonExecutablePath")]
+    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+    public string PythonExecutablePath { get; set; }
+
+    [JsonPropertyName("wslDistribution")]
+    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+    public string WslDistribution { get; set; }
+
+    /// <summary>
+    /// Migrates legacy settings (isEnabled/useWsl) to new mode format on first load.
+    /// </summary>
+    public void MigrateLegacyIfNeeded()
+    {
+        // Only migrate if Mode hasn't been set by the new UI yet
+        // (i.e., still at default "disabled") AND legacy fields are present.
+        if (IsEnabled.HasValue && string.Equals(Mode, "disabled", System.StringComparison.OrdinalIgnoreCase))
+        {
+            // Migrate from old format
+            if (!IsEnabled.Value)
+            {
+                Mode = "disabled";
+            }
+            else if (UseWsl == true)
+            {
+                Mode = "wsl";
+            }
+            else
+            {
+                Mode = "windows";
+            }
+
+            if (!string.IsNullOrEmpty(ScriptsFolder))
+            {
+                WindowsSettings.ScriptsFolder = ScriptsFolder;
+            }
+
+            if (!string.IsNullOrEmpty(PythonExecutablePath))
+            {
+                WindowsSettings.PythonExecutablePath = PythonExecutablePath;
+            }
+
+            if (!string.IsNullOrEmpty(WslDistribution))
+            {
+                WslSettings.Distribution = WslDistribution;
+            }
+        }
+
+        // Always clear legacy fields so they don't persist
+        IsEnabled = null;
+        UseWsl = null;
+        ScriptsFolder = null;
+        PythonExecutablePath = null;
+        WslDistribution = null;
+    }
+}

src/settings-ui/Settings.UI.Library/PythonScriptWindowsSettings.cs

@@ -0,0 +1,16 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Text.Json.Serialization;
+
+namespace Microsoft.PowerToys.Settings.UI.Library;
+
+public sealed class PythonScriptWindowsSettings
+{
+    [JsonPropertyName("scriptsFolder")]
+    public string ScriptsFolder { get; set; } = string.Empty;
+
+    [JsonPropertyName("pythonExecutablePath")]
+    public string PythonExecutablePath { get; set; } = string.Empty;
+}

src/settings-ui/Settings.UI.Library/PythonScriptWslSettings.cs

@@ -0,0 +1,16 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Text.Json.Serialization;
+
+namespace Microsoft.PowerToys.Settings.UI.Library;
+
+public sealed class PythonScriptWslSettings
+{
+    [JsonPropertyName("scriptsFolder")]
+    public string ScriptsFolder { get; set; } = string.Empty;
+
+    [JsonPropertyName("distribution")]
+    public string Distribution { get; set; } = string.Empty;
+}

src/settings-ui/Settings.UI.Library/SettingsSerializationContext.cs

@@ -140,6 +140,10 @@ namespace Microsoft.PowerToys.Settings.UI.Library
     [JsonSerializable(typeof(AdvancedPasteAdditionalAction))]
     [JsonSerializable(typeof(AdvancedPastePasteAsFileAction))]
     [JsonSerializable(typeof(AdvancedPasteTranscodeAction))]
+    [JsonSerializable(typeof(AdvancedPastePythonScriptSettings))]
+    [JsonSerializable(typeof(AdvancedPastePythonScriptAction))]
+    [JsonSerializable(typeof(PythonScriptWindowsSettings))]
+    [JsonSerializable(typeof(PythonScriptWslSettings))]
     [JsonSerializable(typeof(ImageResizerSizes))]
     [JsonSerializable(typeof(ImageResizerCustomSizeProperty))]
     [JsonSerializable(typeof(KeyboardKeysProperty))]

src/settings-ui/Settings.UI.UnitTests/ViewModelTests/AdvancedPaste.cs

@@ -0,0 +1,59 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+
+using Microsoft.PowerToys.Settings.UI.Library;
+using Microsoft.PowerToys.Settings.UI.ViewModels;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace ViewModelTests
+{
+    [TestClass]
+    public class AdvancedPaste
+    {
+        [TestMethod]
+        public void CreateActionFromScript_ExtractsConversionTypes()
+        {
+            var scriptPath = Path.Combine(Path.GetTempPath(), $"AdvancedPaste-{Guid.NewGuid():N}.py");
+
+            try
+            {
+                File.WriteAllLines(
+                    scriptPath,
+                    [
+                        "# @advancedpaste:name   transcribe audio",
+                        "# @advancedpaste:desc   Transcribes audio to text",
+                        string.Empty,
+                        "def advanced_paste_from_audio_to_text(audio_path):",
+                        "    return 'transcribed'",
+                    ]);
+
+                var createActionFromScript = typeof(AdvancedPasteViewModel)
+                    .GetMethod("CreateActionFromScript", BindingFlags.NonPublic | BindingFlags.Static);
+
+                Assert.IsNotNull(createActionFromScript);
+
+                var action = (AdvancedPastePythonScriptAction)createActionFromScript.Invoke(
+                    null, [scriptPath, new System.Collections.Generic.List<AdvancedPastePythonScriptAction>()]);
+
+                Assert.AreEqual("transcribe audio", action.Name);
+                Assert.AreEqual("Transcribes audio to text", action.Description);
+                Assert.AreEqual("audio", action.InputType);
+                Assert.AreEqual("text", action.OutputType);
+                Assert.AreEqual("audio → text", action.ConversionSummary);
+            }
+            finally
+            {
+                if (File.Exists(scriptPath))
+                {
+                    File.Delete(scriptPath);
+                }
+            }
+        }
+    }
+}

src/settings-ui/Settings.UI/SettingsXAML/Views/AdvancedPastePage.xaml

@@ -164,10 +164,10 @@
                                     </InfoBar.IconSource>
                                 </InfoBar>
                             </tkcontrols:SettingsExpander.ItemsHeader>
-                            <controls:ShortcutControl HotkeySettings="{x:Bind Path=ViewModel.AdvancedPasteUIShortcut, Mode=TwoWay}" />
+                            <controls:ShortcutControl MinWidth="{StaticResource SettingActionControlMinWidth}" HotkeySettings="{x:Bind Path=ViewModel.AdvancedPasteUIShortcut, Mode=TwoWay}" />
                             <tkcontrols:SettingsExpander.Items>
                                 <tkcontrols:SettingsCard Name="AdvancedPasteEnableClipboardPreview" ContentAlignment="Left">
-                                    <CheckBox x:Uid="AdvancedPaste_EnableClipboardPreview" IsChecked="{x:Bind ViewModel.EnableClipboardPreview, Mode=TwoWay}" />
+                                    <ptcontrols:CheckBoxWithDescriptionControl x:Uid="AdvancedPaste_EnableClipboardPreview" IsChecked="{x:Bind ViewModel.EnableClipboardPreview, Mode=TwoWay}" />
                                 </tkcontrols:SettingsCard>
                                 <tkcontrols:SettingsCard Name="AdvancedPasteAutoCopySelectionCustomAction" ContentAlignment="Left">
                                     <ptcontrols:CheckBoxWithDescriptionControl x:Uid="AdvancedPaste_AutoCopySelectionForCustomActionHotkey" IsChecked="{x:Bind ViewModel.AutoCopySelectionForCustomActionHotkey, Mode=TwoWay}" />
@@ -178,15 +178,13 @@
                                     IsEnabled="{x:Bind ViewModel.ClipboardHistoryEnabled, Mode=OneWay}">
                                     <ptcontrols:CheckBoxWithDescriptionControl x:Uid="AdvancedPaste_Clipboard_History_Enabled_SettingsCard" IsChecked="{x:Bind ViewModel.ClipboardHistoryEnabled, Mode=TwoWay}" />
                                 </tkcontrols:SettingsCard>
+
                                 <tkcontrols:SettingsCard Name="AdvancedPasteCloseAfterLosingFocus" ContentAlignment="Left">
                                     <CheckBox x:Uid="AdvancedPaste_CloseAfterLosingFocus" IsChecked="{x:Bind ViewModel.CloseAfterLosingFocus, Mode=TwoWay}" />
                                 </tkcontrols:SettingsCard>
                                 <tkcontrols:SettingsCard Name="AdvancedPasteShowCustomPreviewSettingsCard" ContentAlignment="Left">
                                     <ptcontrols:CheckBoxWithDescriptionControl x:Uid="AdvancedPaste_ShowCustomPreviewSettingsCard" IsChecked="{x:Bind ViewModel.ShowCustomPreview, Mode=TwoWay}" />
                                 </tkcontrols:SettingsCard>
-                                <tkcontrols:SettingsCard Name="AdvancedPasteShowAIPasteSettingsCard" ContentAlignment="Left">
-                                    <CheckBox x:Uid="AdvancedPaste_ShowAIPasteSettingsCard" IsChecked="{x:Bind ViewModel.ShowAIPaste, Mode=TwoWay}" />
-                                </tkcontrols:SettingsCard>
                             </tkcontrols:SettingsExpander.Items>
                         </tkcontrols:SettingsExpander>
                     </controls:SettingsGroup>
@@ -197,7 +195,7 @@
                             Name="PasteAsPlainTextShortcut"
                             x:Uid="PasteAsPlainText_Shortcut"
                             HeaderIcon="{ui:FontIcon Glyph=&#xE8E9;}">
-                            <controls:ShortcutControl HotkeySettings="{x:Bind Path=ViewModel.PasteAsPlainTextShortcut, Mode=TwoWay}" />
+                            <controls:ShortcutControl MinWidth="{StaticResource SettingActionControlMinWidth}" HotkeySettings="{x:Bind Path=ViewModel.PasteAsPlainTextShortcut, Mode=TwoWay}" />
                         </tkcontrols:SettingsCard>
                         <tkcontrols:SettingsCard
                             Name="PasteAsMarkdownShortcut"
@@ -392,6 +390,124 @@
                             IsTabStop="{x:Bind ViewModel.IsConflictingCopyShortcut, Mode=OneWay}"
                             Severity="Warning" />
                     </controls:SettingsGroup>
+
+                    <controls:SettingsGroup x:Uid="AdvancedPaste_PythonScripts_GroupSettings" IsEnabled="{x:Bind ViewModel.IsEnabled, Mode=OneWay}">
+                        <tkcontrols:SettingsCard x:Uid="AdvancedPaste_PythonScripts_RuntimeCard">
+                            <tkcontrols:SettingsCard.HeaderIcon>
+                                <FontIcon Glyph="&#xE943;" />
+                            </tkcontrols:SettingsCard.HeaderIcon>
+                            <ComboBox MinWidth="{StaticResource SettingActionControlMinWidth}" SelectedIndex="{x:Bind ViewModel.PythonScriptsModeIndex, Mode=TwoWay}">
+                                <ComboBoxItem x:Uid="AdvancedPaste_PythonScripts_ModeOff" />
+                                <ComboBoxItem x:Uid="AdvancedPaste_PythonScripts_ModeWindows" />
+                                <ComboBoxItem x:Uid="AdvancedPaste_PythonScripts_ModeWsl" />
+                            </ComboBox>
+                        </tkcontrols:SettingsCard>
+                        <tkcontrols:SettingsCard x:Uid="AdvancedPaste_ScriptsFolder_SettingsCard" IsEnabled="{x:Bind ViewModel.IsPythonScriptsEnabled, Mode=OneWay}">
+                            <tkcontrols:SettingsCard.HeaderIcon>
+                                <FontIcon Glyph="&#xE8B7;" />
+                            </tkcontrols:SettingsCard.HeaderIcon>
+                            <StackPanel Orientation="Horizontal" Spacing="8">
+                                <TextBox
+                                    x:Name="ScriptsFolderTextBox"
+                                    x:Uid="AdvancedPaste_ScriptsFolder_TextBox"
+                                    MinWidth="300"
+                                    HorizontalAlignment="Stretch"
+                                    Text="{x:Bind ViewModel.ScriptsFolder, Mode=TwoWay, UpdateSourceTrigger=LostFocus}" />
+                                <Button
+                                    VerticalAlignment="Bottom"
+                                    Click="BrowseScriptsFolder_Click"
+                                    Content="{ui:FontIcon Glyph=&#xE8DA;,
+                                                          FontSize=16}"
+                                    Style="{StaticResource SubtleButtonStyle}" />
+                                <Button
+                                    x:Name="OpenScriptsFolderButton"
+                                    VerticalAlignment="Bottom"
+                                    Click="OpenScriptsFolder_Click"
+                                    Content="{ui:FontIcon Glyph=&#xE838;,
+                                                          FontSize=16}"
+                                    Style="{StaticResource SubtleButtonStyle}" />
+                            </StackPanel>
+                        </tkcontrols:SettingsCard>
+
+                        <!--  Windows-mode settings  -->
+                        <tkcontrols:SettingsCard x:Uid="AdvancedPaste_PythonExecutablePath_SettingsCard" Visibility="{x:Bind ViewModel.IsWindowsMode, Mode=OneWay}">
+                            <tkcontrols:SettingsCard.HeaderIcon>
+                                <FontIcon Glyph="&#xE943;" />
+                            </tkcontrols:SettingsCard.HeaderIcon>
+                            <StackPanel Orientation="Horizontal" Spacing="8">
+                                <TextBox
+                                    x:Name="PythonExecutablePathTextBox"
+                                    x:Uid="AdvancedPaste_PythonExecutablePath_TextBox"
+                                    MinWidth="300"
+                                    HorizontalAlignment="Stretch"
+                                    Text="{x:Bind ViewModel.PythonExecutablePath, Mode=TwoWay, UpdateSourceTrigger=LostFocus}" />
+                                <Button
+                                    VerticalAlignment="Bottom"
+                                    Click="BrowsePythonExecutablePath_Click"
+                                    Content="{ui:FontIcon Glyph=&#xE8DA;,
+                                                          FontSize=16}"
+                                    Style="{StaticResource SubtleButtonStyle}" />
+                            </StackPanel>
+                        </tkcontrols:SettingsCard>
+
+                        <!--  WSL-mode settings  -->
+                        <tkcontrols:SettingsCard x:Uid="AdvancedPaste_WslDistribution_SettingsCard" Visibility="{x:Bind ViewModel.IsWslMode, Mode=OneWay}">
+                            <tkcontrols:SettingsCard.HeaderIcon>
+                                <FontIcon Glyph="&#xEC7A;" />
+                            </tkcontrols:SettingsCard.HeaderIcon>
+                            <ComboBox
+                                MinWidth="200"
+                                ItemsSource="{x:Bind ViewModel.WslDistroDisplayNames, Mode=OneWay}"
+                                SelectedIndex="{x:Bind ViewModel.WslDistributionIndex, Mode=TwoWay}" />
+                        </tkcontrols:SettingsCard>
+
+                        <!--  Discovered Python Scripts (read-only)  -->
+                        <tkcontrols:SettingsExpander
+                            x:Name="PythonScriptListExpander"
+                            x:Uid="AdvancedPaste_PythonScriptList"
+                            HeaderIcon="{ui:FontIcon Glyph=&#xE756;}"
+                            IsEnabled="{x:Bind ViewModel.IsPythonScriptsEnabled, Mode=OneWay}"
+                            IsExpanded="True"
+                            ItemsSource="{x:Bind ViewModel.PythonScriptActions, Mode=OneWay}">
+                            <StackPanel Orientation="Horizontal" Spacing="8">
+                                <Button
+                                    x:Name="RefreshScriptsButton"
+                                    x:Uid="AdvancedPaste_PythonScripts_LoadScripts"
+                                    Click="RefreshPythonScripts_Click"
+                                    Style="{ThemeResource AccentButtonStyle}" />
+                            </StackPanel>
+                            <tkcontrols:SettingsExpander.ItemTemplate>
+                                <DataTemplate x:DataType="models:AdvancedPastePythonScriptAction">
+                                    <tkcontrols:SettingsCard
+                                        Margin="0,0,0,2"
+                                        Description="{x:Bind Description, Mode=OneWay}"
+                                        Header="{x:Bind DisplayName, Mode=OneWay}"
+                                        IsActionIconVisible="False">
+                                        <StackPanel
+                                            VerticalAlignment="Center"
+                                            Orientation="Horizontal"
+                                            Spacing="12">
+                                            <TextBlock
+                                                VerticalAlignment="Center"
+                                                Foreground="{ThemeResource TextFillColorSecondaryBrush}"
+                                                Style="{StaticResource CaptionTextBlockStyle}"
+                                                Text="{x:Bind ConversionSummary, Mode=OneWay}" />
+                                            <Button
+                                                Click="OpenPythonScript_Click"
+                                                Content="&#xE8A7;"
+                                                FontFamily="{ThemeResource SymbolThemeFontFamily}"
+                                                Style="{StaticResource SubtleButtonStyle}"
+                                                Tag="{x:Bind}">
+                                                <ToolTipService.ToolTip>
+                                                    <TextBlock x:Uid="AdvancedPaste_PythonScripts_OpenScriptInEditor" />
+                                                </ToolTipService.ToolTip>
+                                            </Button>
+                                        </StackPanel>
+                                    </tkcontrols:SettingsCard>
+                                </DataTemplate>
+                            </tkcontrols:SettingsExpander.ItemTemplate>
+                        </tkcontrols:SettingsExpander>
+                    </controls:SettingsGroup>
                 </StackPanel>
             </controls:SettingsPageControl.ModuleContent>
             <controls:SettingsPageControl.PrimaryLinks>
@@ -430,7 +546,6 @@
             </StackPanel>
         </ContentDialog>
 
-        <!--  Paste AI provider dialog  -->
         <ContentDialog
             x:Name="PasteAIProviderConfigurationDialog"
             x:Uid="AdvancedPaste_EndpointDialog"

src/settings-ui/Settings.UI/SettingsXAML/Views/AdvancedPastePage.xaml.cs

@@ -65,6 +65,16 @@ namespace Microsoft.PowerToys.Settings.UI.Views
                 ViewModel.OnPageLoaded();
                 UpdatePasteAIUIVisibility();
                 await UpdateFoundryLocalUIAsync();
+
+                if (ViewModel.IsWslMode)
+                {
+                    ViewModel.RefreshWslDistros();
+                }
+
+                if (OpenScriptsFolderButton is not null)
+                {
+                    ToolTipService.SetToolTip(OpenScriptsFolderButton, ResourceLoaderInstance.ResourceLoader.GetString("AdvancedPaste_PythonScripts_OpenFolder"));
+                }
             };
 
             Unloaded += (_, _) =>
@@ -264,6 +274,75 @@ namespace Microsoft.PowerToys.Settings.UI.Views
             }
         }
 
+        private void BrowsePythonExecutablePath_Click(object sender, RoutedEventArgs e)
+        {
+            string selectedFile = PickFileDialog(
+                "Python Executable\0python.exe;python3.exe\0All Executables\0*.exe\0",
+                "Select Python Executable");
+
+            if (!string.IsNullOrEmpty(selectedFile))
+            {
+                PythonExecutablePathTextBox.Text = selectedFile;
+                if (ViewModel is not null)
+                {
+                    ViewModel.PythonExecutablePath = selectedFile;
+                }
+            }
+        }
+
+        private void BrowseScriptsFolder_Click(object sender, RoutedEventArgs e)
+        {
+            IntPtr windowHandle = WinRT.Interop.WindowNative.GetWindowHandle(App.GetSettingsWindow());
+            string selectedFolder = ShellGetFolder.GetFolderDialogWithFlags(
+                windowHandle,
+                ShellGetFolder.FolderDialogFlags._BIF_NEWDIALOGSTYLE);
+
+            if (!string.IsNullOrEmpty(selectedFolder))
+            {
+                ScriptsFolderTextBox.Text = selectedFolder;
+                if (ViewModel is not null)
+                {
+                    ViewModel.ScriptsFolder = selectedFolder;
+                }
+            }
+        }
+
+        private void OpenScriptsFolder_Click(object sender, RoutedEventArgs e)
+        {
+            var folder = ViewModel?.ScriptsFolder;
+            if (!string.IsNullOrEmpty(folder) && System.IO.Directory.Exists(folder))
+            {
+                System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo
+                {
+                    FileName = folder,
+                    UseShellExecute = true,
+                });
+            }
+        }
+
+        private void RefreshPythonScripts_Click(object sender, RoutedEventArgs e)
+        {
+            ViewModel?.RefreshPythonScripts();
+            RefreshScriptsButton.Content = ResourceLoaderInstance.ResourceLoader.GetString("AdvancedPaste_PythonScript_RefreshScripts/Content");
+        }
+
+        private void OpenPythonScript_Click(object sender, RoutedEventArgs e)
+        {
+            if (sender is not FrameworkElement { Tag: AdvancedPastePythonScriptAction action })
+            {
+                return;
+            }
+
+            if (System.IO.File.Exists(action.ScriptPath))
+            {
+                var startInfo = new System.Diagnostics.ProcessStartInfo(action.ScriptPath)
+                {
+                    UseShellExecute = true,
+                };
+                System.Diagnostics.Process.Start(startInfo);
+            }
+        }
+
         private static string PickFileDialog(string filter, string title, string initialDir = null, int initialFilter = 0)
         {
             // Use Win32 OpenFileName dialog as FileOpenPicker doesn't work with elevated permissions

src/settings-ui/Settings.UI/SettingsXAML/Views/NewPlusPage.xaml

@@ -207,7 +207,7 @@
             <controls:PageLink x:Uid="NewPlus_Learn_More" Link="https://aka.ms/PowerToysOverview_NewPlus" />
         </controls:SettingsPageControl.PrimaryLinks>
         <controls:SettingsPageControl.SecondaryLinks>
-            <controls:PageLink Link="https://www.onegreatworld.com/products/productivity-plus-pack/?ref=settings_pt" Text="Based on Christian Gaardmark's New++ from the Productivity Plus Pack" />
+            <controls:PageLink Link="https://www.linkedin.com/in/christian-gaardmark/" Text="Christian Gaardmark" />
         </controls:SettingsPageControl.SecondaryLinks>
     </controls:SettingsPageControl>
 

src/settings-ui/Settings.UI/Strings/en-us/Resources.resw

@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <root>
   <!-- 
     Microsoft ResX Schema 
@@ -4432,22 +4432,22 @@ Activate by holding the key for the character you want to add an accent to, then
   </data>
   <data name="NewPlus.ModuleTitle" xml:space="preserve">
     <value>New+</value>
-    <comment>New+ is the name of the utility. Localize product name in accordance with Windows New. e.g. French would be Nouveau+ (not Nouveauté+)</comment>
+    <comment>New+ is the name of the utility. Localize product name in accordance with Windows New</comment>
   </data>
   <data name="NewPlus.ModuleDescription" xml:space="preserve">
     <value>Create files and folders from a personalized set of templates</value>
   </data>
   <data name="NewPlus_Product_Name.Content" xml:space="preserve">
     <value>New+</value>
-    <comment>New+ is the name of the utility. Localize product name in accordance with Windows New. e.g. French would be Nouveau+ (not Nouveauté+)</comment>
+    <comment>New+ is the name of the utility. Localize product name in accordance with Windows New</comment>
   </data>
   <data name="NewPlus_Learn_More.Text" xml:space="preserve">
     <value>Learn more about New+</value>
-    <comment>New+ learn more link. Localize product name in accordance with Windows New. e.g. French would be Nouveau+ (not Nouveauté+)</comment>
+    <comment>New+ learn more link. Localize product name in accordance with Windows New</comment>
   </data>
   <data name="NewPlus_Enable_Toggle.Header" xml:space="preserve">
     <value>New+</value>
-    <comment>Localize product name in accordance with Windows New. e.g. French would be Nouveau+ (not Nouveauté+)</comment>
+    <comment>Localize product name in accordance with Windows New</comment>
   </data>
   <data name="NewPlus_TemplatesNotBackupAndRestoreWarning.Title" xml:space="preserve">
     <value>PowerToys "Back up and Restore" feature doesn't take templates into account at this moment. If you use that feature, templates will have to be copied manually.</value>
@@ -4534,7 +4534,7 @@ Activate by holding the key for the character you want to add an accent to, then
   </data>
   <data name="Oobe_NewPlus.Title" xml:space="preserve">
     <value>New+</value>
-    <comment>New+ is the name of the utility. Localize product name in accordance with Windows New. e.g. French would be Nouveau+ (not Nouveauté+)</comment>
+    <comment>New+ is the name of the utility. Localize product name in accordance with Windows New</comment>
   </data>
   <data name="Oobe_NewPlus.Description" xml:space="preserve">
     <value>Create files and folders from a personalized set of templates.</value>
@@ -6230,4 +6230,77 @@ Text uses the current drawing color.</value>
     <value>Example: outlook</value>
     <comment>{Locked="outlook"}</comment>
   </data>
+  <data name="AdvancedPaste_PythonScripts_GroupSettings.Header" xml:space="preserve">
+    <value>Python scripts</value>
+  </data>
+  <data name="AdvancedPaste_PythonScripts_RuntimeCard.Header" xml:space="preserve">
+    <value>Python runtime</value>
+  </data>
+  <data name="AdvancedPaste_PythonScripts_RuntimeCard.Description" xml:space="preserve">
+    <value>Choose how to run custom Python scripts from the Advanced Paste menu</value>
+  </data>
+  <data name="AdvancedPaste_ScriptsFolder_SettingsCard.Header" xml:space="preserve">
+    <value>Scripts folder</value>
+  </data>
+  <data name="AdvancedPaste_ScriptsFolder_SettingsCard.Description" xml:space="preserve">
+    <value>Folder to scan for Python scripts (.py files). Leave blank to use the default location.</value>
+  </data>
+  <data name="AdvancedPaste_ScriptsFolder_TextBox.PlaceholderText" xml:space="preserve">
+    <value>Default (%LOCALAPPDATA%\Microsoft\PowerToys\AdvancedPaste\Scripts)</value>
+  </data>
+  <data name="AdvancedPaste_PythonExecutablePath_SettingsCard.Header" xml:space="preserve">
+    <value>Python interpreter</value>
+  </data>
+  <data name="AdvancedPaste_PythonExecutablePath_SettingsCard.Description" xml:space="preserve">
+    <value>Path to the Python executable used to run scripts. Leave blank to detect automatically (supports Anaconda, Miniconda, system Python).</value>
+  </data>
+  <data name="AdvancedPaste_PythonExecutablePath_TextBox.PlaceholderText" xml:space="preserve">
+    <value>Auto-detect (e.g. C:\Users\&lt;user&gt;\anaconda3\python.exe)</value>
+  </data>
+  <data name="AdvancedPaste_UseWsl_SettingsCard.Header" xml:space="preserve">
+    <value>Use WSL</value>
+  </data>
+  <data name="AdvancedPaste_UseWsl_SettingsCard.Description" xml:space="preserve">
+    <value>Run Python scripts in Windows Subsystem for Linux instead of native Windows Python.</value>
+  </data>
+  <data name="AdvancedPaste_WslDistribution_SettingsCard.Header" xml:space="preserve">
+    <value>WSL distribution</value>
+  </data>
+  <data name="AdvancedPaste_WslDistribution_SettingsCard.Description" xml:space="preserve">
+    <value>Select which WSL distribution to use for running Python scripts.</value>
+  </data>
+  <data name="AdvancedPaste_PythonScriptList.Header" xml:space="preserve">
+    <value>Discovered scripts</value>
+  </data>
+  <data name="AdvancedPaste_PythonScriptList.Description" xml:space="preserve">
+    <value>Python scripts found in the scripts folder.</value>
+  </data>
+  <data name="AdvancedPaste_PythonScript_RefreshScripts.Content" xml:space="preserve">
+    <value>Refresh scripts</value>
+  </data>
+  <data name="AdvancedPaste_PythonScript_ApplyChanges.Content" xml:space="preserve">
+    <value>Apply changes</value>
+  </data>
+  <data name="AdvancedPaste_PythonScripts_ModeOff.Content" xml:space="preserve">
+    <value>Off</value>
+  </data>
+  <data name="AdvancedPaste_PythonScripts_ModeWindows.Content" xml:space="preserve">
+    <value>Windows Python</value>
+  </data>
+  <data name="AdvancedPaste_PythonScripts_ModeWsl.Content" xml:space="preserve">
+    <value>WSL Python</value>
+  </data>
+  <data name="AdvancedPaste_PythonScripts_LoadScripts.Content" xml:space="preserve">
+    <value>Load scripts</value>
+  </data>
+  <data name="AdvancedPaste_PythonScripts_OpenFolder" xml:space="preserve">
+    <value>Open folder</value>
+  </data>
+  <data name="AdvancedPaste_PythonScripts_OpenScriptInEditor.Text" xml:space="preserve">
+    <value>Open script in editor</value>
+  </data>
+  <data name="AdvancedPaste_PythonScripts_WslDefaultDistro" xml:space="preserve">
+    <value>(System default)</value>
+  </data>
+
 </root>

src/settings-ui/Settings.UI/ViewModels/AdvancedPasteViewModel.cs

@@ -293,6 +293,440 @@ namespace Microsoft.PowerToys.Settings.UI.ViewModels
 
         public AdvancedPasteAdditionalActions AdditionalActions => _additionalActions;
 
+        public bool IsPythonScriptsEnabled
+        {
+            get
+            {
+                var scripts = _advancedPasteSettings.Properties.PythonScripts;
+                return scripts != null && !string.Equals(scripts.Mode, "disabled", StringComparison.OrdinalIgnoreCase);
+            }
+        }
+
+        /// <summary>
+        /// ComboBox index: 0 = Disabled, 1 = Windows, 2 = WSL.
+        /// </summary>
+        public int PythonScriptsModeIndex
+        {
+            get
+            {
+                var scripts = _advancedPasteSettings.Properties.PythonScripts;
+                var mode = scripts?.Mode ?? "disabled";
+                return mode switch
+                {
+                    "windows" => 1,
+                    "wsl" => 2,
+                    _ => 0,
+                };
+            }
+
+            set
+            {
+                var scripts = _advancedPasteSettings.Properties.PythonScripts ??= new AdvancedPastePythonScriptSettings();
+                var newMode = value switch
+                {
+                    1 => "windows",
+                    2 => "wsl",
+                    _ => "disabled",
+                };
+
+                if (!string.Equals(scripts.Mode, newMode, StringComparison.Ordinal))
+                {
+                    scripts.Mode = newMode;
+                    OnPropertyChanged(nameof(PythonScriptsModeIndex));
+                    OnPropertyChanged(nameof(IsPythonScriptsEnabled));
+                    OnPropertyChanged(nameof(IsWindowsMode));
+                    OnPropertyChanged(nameof(IsWslMode));
+                    OnPropertyChanged(nameof(ScriptsFolder));
+                    OnPropertyChanged(nameof(PythonExecutablePath));
+                    OnPropertyChanged(nameof(WslDistribution));
+                    SaveAndNotifySettings();
+
+                    if (newMode == "wsl")
+                    {
+                        RefreshWslDistros();
+                    }
+
+                    if (_scriptsDiscovered)
+                    {
+                        RefreshPythonScripts();
+                    }
+                }
+            }
+        }
+
+        public bool IsWindowsMode => PythonScriptsModeIndex == 1;
+
+        public bool IsWslMode => PythonScriptsModeIndex == 2;
+
+        public bool ScriptsDiscovered => _scriptsDiscovered;
+
+        public string PythonExecutablePath
+        {
+            get => _advancedPasteSettings.Properties.PythonScripts?.WindowsSettings?.PythonExecutablePath ?? string.Empty;
+            set
+            {
+                var scripts = _advancedPasteSettings.Properties.PythonScripts ??= new AdvancedPastePythonScriptSettings();
+                scripts.WindowsSettings ??= new PythonScriptWindowsSettings();
+                if (!string.Equals(scripts.WindowsSettings.PythonExecutablePath, value, StringComparison.OrdinalIgnoreCase))
+                {
+                    scripts.WindowsSettings.PythonExecutablePath = value ?? string.Empty;
+                    OnPropertyChanged(nameof(PythonExecutablePath));
+                    SaveAndNotifySettings();
+                }
+            }
+        }
+
+        public string WslDistribution
+        {
+            get => _advancedPasteSettings.Properties.PythonScripts?.WslSettings?.Distribution ?? string.Empty;
+            set
+            {
+                var scripts = _advancedPasteSettings.Properties.PythonScripts ??= new AdvancedPastePythonScriptSettings();
+                scripts.WslSettings ??= new PythonScriptWslSettings();
+                if (!string.Equals(scripts.WslSettings.Distribution, value, StringComparison.Ordinal))
+                {
+                    scripts.WslSettings.Distribution = value ?? string.Empty;
+                    OnPropertyChanged(nameof(WslDistribution));
+                    OnPropertyChanged(nameof(WslDistributionIndex));
+                    SaveAndNotifySettings();
+                }
+            }
+        }
+
+        private List<string> _availableWslDistros = [string.Empty];
+
+        /// <summary>
+        /// Available WSL distributions. First item is "" (system default).
+        /// </summary>
+        public List<string> AvailableWslDistros
+        {
+            get => _availableWslDistros;
+            private set
+            {
+                _availableWslDistros = value;
+                OnPropertyChanged(nameof(AvailableWslDistros));
+                OnPropertyChanged(nameof(WslDistroDisplayNames));
+                OnPropertyChanged(nameof(WslDistributionIndex));
+            }
+        }
+
+        /// <summary>
+        /// Display names for the ComboBox (maps empty string to "(System default)").
+        /// </summary>
+        public List<string> WslDistroDisplayNames =>
+            _availableWslDistros.Select(d => string.IsNullOrEmpty(d) ? ResourceLoaderInstance.ResourceLoader.GetString("AdvancedPaste_PythonScripts_WslDefaultDistro") : d).ToList();
+
+        /// <summary>
+        /// Selected index into AvailableWslDistros for ComboBox binding.
+        /// </summary>
+        public int WslDistributionIndex
+        {
+            get
+            {
+                var current = WslDistribution;
+                var idx = _availableWslDistros.IndexOf(current);
+                return idx >= 0 ? idx : 0;
+            }
+
+            set
+            {
+                if (value >= 0 && value < _availableWslDistros.Count)
+                {
+                    WslDistribution = _availableWslDistros[value];
+                }
+            }
+        }
+
+        /// <summary>
+        /// Queries installed WSL distributions and populates AvailableWslDistros.
+        /// </summary>
+        public void RefreshWslDistros()
+        {
+            var distros = new List<string> { string.Empty }; // first = system default
+
+            try
+            {
+                var psi = new System.Diagnostics.ProcessStartInfo("wsl.exe", "-l -q")
+                {
+                    UseShellExecute = false,
+                    CreateNoWindow = true,
+                    RedirectStandardOutput = true,
+                    StandardOutputEncoding = System.Text.Encoding.Unicode,
+                };
+
+                using var process = System.Diagnostics.Process.Start(psi);
+                if (process != null)
+                {
+                    // WaitForExit first with timeout to avoid blocking indefinitely on ReadToEnd().
+                    // If the process doesn't finish in time, kill it and wait for exit before reading.
+                    if (!process.WaitForExit(5000))
+                    {
+                        try
+                        {
+                            process.Kill();
+                        }
+                        catch
+                        {
+                        }
+
+                        // After Kill, wait briefly for the process to actually terminate.
+                        // If it still hasn't exited, skip reading but still update with default-only list.
+                        if (!process.WaitForExit(2000))
+                        {
+                            AvailableWslDistros = distros;
+                            return;
+                        }
+                    }
+
+                    var output = process.StandardOutput.ReadToEnd();
+
+                    var names = output
+                        .Split('\n', StringSplitOptions.RemoveEmptyEntries)
+                        .Select(line => line.Trim().Trim('\0', '\r'))
+                        .Where(name => !string.IsNullOrWhiteSpace(name));
+
+                    foreach (var name in names)
+                    {
+                        distros.Add(name);
+                    }
+                }
+            }
+            catch
+            {
+                // WSL not available — just show the default option
+            }
+
+            AvailableWslDistros = distros;
+        }
+
+        public string ScriptsFolder
+        {
+            get
+            {
+                var scripts = _advancedPasteSettings.Properties.PythonScripts;
+                if (scripts == null)
+                {
+                    return DefaultScriptsFolder;
+                }
+
+                var folder = string.Equals(scripts.Mode, "wsl", StringComparison.OrdinalIgnoreCase)
+                    ? scripts.WslSettings?.ScriptsFolder
+                    : scripts.WindowsSettings?.ScriptsFolder;
+
+                return string.IsNullOrWhiteSpace(folder) ? DefaultScriptsFolder : folder;
+            }
+
+            set
+            {
+                var scripts = _advancedPasteSettings.Properties.PythonScripts ??= new AdvancedPastePythonScriptSettings();
+                if (string.Equals(scripts.Mode, "wsl", StringComparison.OrdinalIgnoreCase))
+                {
+                    scripts.WslSettings ??= new PythonScriptWslSettings();
+                    if (!string.Equals(scripts.WslSettings.ScriptsFolder, value, StringComparison.OrdinalIgnoreCase))
+                    {
+                        scripts.WslSettings.ScriptsFolder = value ?? string.Empty;
+                        OnPropertyChanged(nameof(ScriptsFolder));
+                        SaveAndNotifySettings();
+
+                        if (_scriptsDiscovered)
+                        {
+                            RefreshPythonScripts();
+                        }
+                    }
+                }
+                else
+                {
+                    scripts.WindowsSettings ??= new PythonScriptWindowsSettings();
+                    if (!string.Equals(scripts.WindowsSettings.ScriptsFolder, value, StringComparison.OrdinalIgnoreCase))
+                    {
+                        scripts.WindowsSettings.ScriptsFolder = value ?? string.Empty;
+                        OnPropertyChanged(nameof(ScriptsFolder));
+                        SaveAndNotifySettings();
+
+                        if (_scriptsDiscovered)
+                        {
+                            RefreshPythonScripts();
+                        }
+                    }
+                }
+            }
+        }
+
+        private static string DefaultScriptsFolder { get; } = System.IO.Path.Combine(
+            Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
+            "Microsoft",
+            "PowerToys",
+            "AdvancedPaste",
+            "Scripts");
+
+        private ObservableCollection<AdvancedPastePythonScriptAction> _pythonScriptActions = [];
+        private bool _scriptsDiscovered;
+
+        public ObservableCollection<AdvancedPastePythonScriptAction> PythonScriptActions
+        {
+            get => _pythonScriptActions;
+            set
+            {
+                _pythonScriptActions = value;
+                OnPropertyChanged(nameof(PythonScriptActions));
+            }
+        }
+
+        /// <summary>
+        /// Scans the scripts folder for .py files and populates PythonScriptActions
+        /// with metadata from their headers. Existing settings (hotkeys) are preserved.
+        /// </summary>
+        public void RefreshPythonScripts()
+        {
+            _scriptsDiscovered = true;
+            OnPropertyChanged(nameof(ScriptsDiscovered));
+
+            var folder = ScriptsFolder;
+            if (string.IsNullOrWhiteSpace(folder) || !System.IO.Directory.Exists(folder))
+            {
+                PythonScriptActions = [];
+                return;
+            }
+
+            var scripts = new ObservableCollection<AdvancedPastePythonScriptAction>();
+            var savedActions = _advancedPasteSettings.Properties.PythonScripts?.Value ?? [];
+
+            foreach (var file in System.IO.Directory.EnumerateFiles(folder, "*.py", System.IO.SearchOption.TopDirectoryOnly))
+            {
+                try
+                {
+                    var action = CreateActionFromScript(file, savedActions);
+
+                    // Only list scripts that define exactly one advanced_paste_from_*_to_*() function,
+                    // matching the runtime's discovery behavior in PythonScriptService.
+                    if (string.IsNullOrEmpty(action.InputType) || string.IsNullOrEmpty(action.OutputType))
+                    {
+                        continue;
+                    }
+
+                    scripts.Add(action);
+                }
+                catch
+                {
+                    // Skip scripts that can't be read
+                }
+            }
+
+            PythonScriptActions = scripts;
+        }
+
+        private static AdvancedPastePythonScriptAction CreateActionFromScript(
+            string filePath,
+            List<AdvancedPastePythonScriptAction> savedActions)
+        {
+            // Read header metadata from the .py file
+            var name = System.IO.Path.GetFileNameWithoutExtension(filePath);
+            var description = string.Empty;
+            var platform = "windows";
+            var formats = "any";
+            var enabled = true;
+            var requires = string.Empty;
+            var hasExplicitRequires = false;
+            var inputType = string.Empty;
+            var outputType = string.Empty;
+            int matchingFunctionCount = 0;
+
+            using var reader = new System.IO.StreamReader(filePath, System.Text.Encoding.UTF8);
+            string line;
+            while ((line = reader.ReadLine()) is not null)
+            {
+                var trimmed = line.Trim();
+
+                // Detect the function definition to extract input/output types
+                if (trimmed.StartsWith("def advanced_paste_from_", StringComparison.Ordinal))
+                {
+                    var match = System.Text.RegularExpressions.Regex.Match(
+                        trimmed,
+                        @"^def advanced_paste_from_(text|html|image|audio|video|files)_to_(text|html|image|audio|video|file|files)\s*\(");
+                    if (match.Success)
+                    {
+                        matchingFunctionCount++;
+                        inputType = match.Groups[1].Value;
+                        outputType = match.Groups[2].Value;
+                    }
+
+                    continue;
+                }
+
+                if (!trimmed.StartsWith('#'))
+                {
+                    continue;
+                }
+
+                if (TryParseTag(trimmed, "@advancedpaste:name", out var val))
+                {
+                    name = val;
+                }
+                else if (TryParseTag(trimmed, "@advancedpaste:desc", out val))
+                {
+                    description = val;
+                }
+                else if (TryParseTag(trimmed, "@advancedpaste:platform", out val))
+                {
+                    platform = val.ToLowerInvariant();
+                }
+                else if (TryParseTag(trimmed, "@advancedpaste:formats", out val))
+                {
+                    formats = val;
+                }
+                else if (TryParseTag(trimmed, "@advancedpaste:disabled", out _, presenceBased: true))
+                {
+                    enabled = false;
+                }
+                else if (TryParseTag(trimmed, "@advancedpaste:requires", out val))
+                {
+                    // Accumulate multiple requires tags
+                    requires = string.IsNullOrEmpty(requires) ? val : $"{requires} {val}";
+                    hasExplicitRequires = true;
+                }
+            }
+
+            // Runtime rejects scripts with more than one matching function.
+            if (matchingFunctionCount != 1)
+            {
+                inputType = string.Empty;
+                outputType = string.Empty;
+            }
+
+            // Preserve existing saved settings (hotkeys, IsShown)
+            var saved = savedActions?.FirstOrDefault(a =>
+                string.Equals(a.ScriptPath, filePath, StringComparison.OrdinalIgnoreCase));
+
+            return new AdvancedPastePythonScriptAction
+            {
+                ScriptPath = filePath,
+                Name = name,
+                Description = description,
+                Platform = platform,
+                Formats = formats,
+                IsEnabled = enabled,
+                Requires = requires,
+                RequiresAutoDetect = !hasExplicitRequires,
+                InputType = inputType,
+                OutputType = outputType,
+                IsShown = saved?.IsShown ?? true,
+                Shortcut = saved?.Shortcut ?? new HotkeySettings(),
+            };
+        }
+
+        private static bool TryParseTag(string line, string tag, out string value, bool presenceBased = false)
+        {
+            var idx = line.IndexOf(tag, StringComparison.OrdinalIgnoreCase);
+            if (idx < 0)
+            {
+                value = null;
+                return false;
+            }
+
+            value = line[(idx + tag.Length)..].Trim();
+            return presenceBased || value.Length > 0;
+        }
+
         public static IEnumerable<AIServiceTypeMetadata> AvailableProviders => AIServiceTypeRegistry.GetAvailableServiceTypes();
 
         /// <summary>
@@ -543,19 +977,6 @@ namespace Microsoft.PowerToys.Settings.UI.ViewModels
             }
         }
 
-        public bool ShowAIPaste
-        {
-            get => _advancedPasteSettings.Properties.ShowAIPaste;
-            set
-            {
-                if (value != _advancedPasteSettings.Properties.ShowAIPaste)
-                {
-                    _advancedPasteSettings.Properties.ShowAIPaste = value;
-                    NotifySettingsChanged();
-                }
-            }
-        }
-
         public bool CloseAfterLosingFocus
         {
             get => _advancedPasteSettings.Properties.CloseAfterLosingFocus;
@@ -1247,12 +1668,6 @@ namespace Microsoft.PowerToys.Settings.UI.ViewModels
                 OnPropertyChanged(nameof(ShowCustomPreview));
             }
 
-            if (target.ShowAIPaste != source.ShowAIPaste)
-            {
-                target.ShowAIPaste = source.ShowAIPaste;
-                OnPropertyChanged(nameof(ShowAIPaste));
-            }
-
             if (target.CloseAfterLosingFocus != source.CloseAfterLosingFocus)
             {
                 target.CloseAfterLosingFocus = source.CloseAfterLosingFocus;