diff --git a/.github/workflows/release-desktop.yml b/.github/workflows/release-desktop.yml
index 2d1c6f51f2..ea82739968 100644
--- a/.github/workflows/release-desktop.yml
+++ b/.github/workflows/release-desktop.yml
@@ -54,10 +54,43 @@ jobs:
         with:
           node-version: 24
 
+      - name: Install pinned Tauri CLI
+        run: npm install --save-dev --prefix studio @tauri-apps/cli@2.10.1
+
+      - name: Verify pinned Tauri CLI
+        shell: bash
+        run: |
+          out="$(npx --prefix studio tauri --version)"
+          echo "$out"
+          if [ "$out" != "tauri-cli 2.10.1" ]; then
+            echo "Expected tauri-cli 2.10.1, got $out" >&2
+            exit 1
+          fi
+
       - name: Install frontend dependencies
         working-directory: studio/frontend
         run: npm install
 
+      - name: Verify backend package is published
+        shell: bash
+        run: |
+          node <<'JS'
+          const { readFileSync } = require('node:fs');
+
+          (async () => {
+            const cargo = readFileSync('studio/src-tauri/Cargo.toml', 'utf8');
+            const match = cargo.match(/^version\s*=\s*"([^"]+)"/m);
+            if (!match) throw new Error('Could not read desktop app version');
+
+            const appVersion = match[1];
+            const response = await fetch(`https://pypi.org/pypi/unsloth/${appVersion}/json`);
+            if (!response.ok) {
+              const message = 'Publish unsloth=={app_version} to PyPI before the desktop release';
+              throw new Error(`${message.replace('{app_version}', appVersion)} (HTTP ${response.status})`);
+            }
+          })();
+          JS
+
       # ── Rust ──
       - name: Install Rust stable
         uses: dtolnay/rust-toolchain@stable
@@ -105,13 +138,14 @@ jobs:
       # ── Linux: build + sign + upload ──
       - name: Build Linux app
         if: matrix.platform == 'ubuntu-22.04'
-        uses: tauri-apps/tauri-action@fce9c6108b31ea247710505d3aaaa893ee6768d4
+        uses: tauri-apps/tauri-action@84b9d35b5fc46c1e45415bdb6144030364f7ebc5
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
           TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}
         with:
           projectPath: studio
+          tauriScript: npx --prefix . tauri
           tagName: desktop-v__VERSION__
           releaseName: 'Unsloth Studio (Desktop) v__VERSION__'
           releaseBody: |
@@ -123,6 +157,7 @@ jobs:
 
             > Linux in-app updates are AppImage-oriented. Package installs should update by downloading a new package.
             > Linux AppImage on Ubuntu 24.04+ may require: `sudo apt install libfuse2t64`
+            > First-run system dependency elevation is supported on Ubuntu/Debian. Other Linux distributions should install system packages manually.
           releaseDraft: ${{ inputs.draft }}
           prerelease: false
           args: -v ${{ matrix.args }}
@@ -130,7 +165,7 @@ jobs:
       # ── macOS: build + sign + notarize + upload ──
       - name: Build macOS app
         if: matrix.platform == 'macos-latest'
-        uses: tauri-apps/tauri-action@fce9c6108b31ea247710505d3aaaa893ee6768d4
+        uses: tauri-apps/tauri-action@84b9d35b5fc46c1e45415bdb6144030364f7ebc5
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
@@ -141,6 +176,7 @@ jobs:
           APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
         with:
           projectPath: studio
+          tauriScript: npx --prefix . tauri
           tagName: desktop-v__VERSION__
           releaseName: 'Unsloth Studio (Desktop) v__VERSION__'
           releaseBody: |
@@ -152,6 +188,7 @@ jobs:
 
             > Linux in-app updates are AppImage-oriented. Package installs should update by downloading a new package.
             > Linux AppImage on Ubuntu 24.04+ may require: `sudo apt install libfuse2t64`
+            > First-run system dependency elevation is supported on Ubuntu/Debian. Other Linux distributions should install system packages manually.
           releaseDraft: ${{ inputs.draft }}
           prerelease: false
           args: -v ${{ matrix.args }}
@@ -159,7 +196,7 @@ jobs:
       # ── Windows: build + sign + upload ──
       - name: Build Windows app
         if: matrix.platform == 'windows-latest'
-        uses: tauri-apps/tauri-action@fce9c6108b31ea247710505d3aaaa893ee6768d4
+        uses: tauri-apps/tauri-action@84b9d35b5fc46c1e45415bdb6144030364f7ebc5
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
@@ -171,6 +208,7 @@ jobs:
           AZURE_CERTIFICATE_PROFILE_NAME: ${{ secrets.AZURE_CERTIFICATE_PROFILE_NAME }}
         with:
           projectPath: studio
+          tauriScript: npx --prefix . tauri
           tagName: desktop-v__VERSION__
           releaseName: 'Unsloth Studio (Desktop) v__VERSION__'
           releaseBody: |
@@ -182,6 +220,7 @@ jobs:
 
             > Linux in-app updates are AppImage-oriented. Package installs should update by downloading a new package.
             > Linux AppImage on Ubuntu 24.04+ may require: `sudo apt install libfuse2t64`
+            > First-run system dependency elevation is supported on Ubuntu/Debian. Other Linux distributions should install system packages manually.
           releaseDraft: ${{ inputs.draft }}
           prerelease: false
           args: -v ${{ matrix.args }}
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 1d3137b373..a2a4995d62 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.15.11
+    rev: v0.15.12
     hooks:
       - id: ruff
         args:
diff --git a/README.md b/README.md
index e1b7e448ef..6c12b28096 100644
--- a/README.md
+++ b/README.md
@@ -79,8 +79,9 @@ irm https://unsloth.ai/install.ps1 | iex
 
 #### Launch
 ```bash
-unsloth studio -H 0.0.0.0 -p 8888
+unsloth studio -p 8888
 ```
+> For cloud VMs or LAN access, add `-H 0.0.0.0` to bind on all interfaces.
 
 #### Update
 To update, use the same install commands as above. Or run (does not work on Windows):
@@ -167,7 +168,7 @@ The below advanced instructions are for Unsloth Studio. For Unsloth Core advance
 git clone https://github.com/unslothai/unsloth
 cd unsloth
 ./install.sh --local
-unsloth studio -H 0.0.0.0 -p 8888
+unsloth studio -p 8888
 ```
 Then to update :
 ```bash
@@ -180,7 +181,7 @@ git clone https://github.com/unslothai/unsloth.git
 cd unsloth
 Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass
 .\install.ps1 --local
-unsloth studio -H 0.0.0.0 -p 8888
+unsloth studio -p 8888
 ```
 Then to update :
 ```bash
@@ -193,11 +194,11 @@ git clone https://github.com/unslothai/unsloth
 cd unsloth
 git checkout nightly
 ./install.sh --local
-unsloth studio -H 0.0.0.0 -p 8888
+unsloth studio -p 8888
 ```
 Then to launch every time:
 ```bash
-unsloth studio -H 0.0.0.0 -p 8888
+unsloth studio -p 8888
 ```
 
 #### Nightly: Windows:
@@ -208,11 +209,11 @@ cd unsloth
 git checkout nightly
 Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass
 .\install.ps1 --local
-unsloth studio -H 0.0.0.0 -p 8888
+unsloth studio -p 8888
 ```
 Then to launch every time:
 ```bash
-unsloth studio -H 0.0.0.0 -p 8888
+unsloth studio -p 8888
 ```
 
 #### Uninstall
diff --git a/install.ps1 b/install.ps1
index 44464101f3..7dc5a50250 100644
--- a/install.ps1
+++ b/install.ps1
@@ -8,6 +8,79 @@ function Install-UnslothStudio {
     $ErrorActionPreference = "Stop"
     $script:UnslothVerbose = ($env:UNSLOTH_VERBOSE -eq "1")
 
+    # ── Tauri structured output ──
+    function Write-TauriLog {
+        param([string]$Tag, [string]$Message)
+        if ($TauriMode) {
+            Write-Host "[TAURI:$Tag] $Message"
+        }
+    }
+
+    function Format-TauriDiagBool {
+        param([bool]$Value)
+        if ($Value) { return "true" }
+        return "false"
+    }
+
+    function Get-TauriDiagArch {
+        $arch = [string]$env:PROCESSOR_ARCHITECTURE
+        if ([string]::IsNullOrWhiteSpace($arch)) {
+            try { $arch = [System.Runtime.InteropServices.RuntimeInformation]::OSArchitecture.ToString() } catch { $arch = "unknown" }
+        }
+        $arch = $arch.ToLowerInvariant()
+        switch ($arch) {
+            "amd64" { return "x86_64" }
+            "x64" { return "x86_64" }
+            "arm64" { return "arm64" }
+            "x86" { return "x86" }
+            default { return ($arch -replace '[^a-z0-9_.-]', '_') }
+        }
+    }
+
+    function Get-TauriTorchIndexFamily {
+        param([string]$TorchIndexUrl)
+        if ($SkipTorch) { return "none" }
+        if ([string]::IsNullOrWhiteSpace($TorchIndexUrl)) { return "none" }
+        $leaf = ($TorchIndexUrl.TrimEnd('/') -split '/')[-1].ToLowerInvariant()
+        if (@("cpu", "cu118", "cu124", "cu126", "cu128", "cu130") -contains $leaf) { return $leaf }
+        if ($leaf -match '^rocm[0-9]+\.[0-9]+$') { return $leaf }
+        return "auto"
+    }
+
+    function Get-TauriGpuBranch {
+        param([string]$TorchIndexFamily)
+        if ($SkipTorch) { return "no_torch" }
+        if ($TorchIndexFamily -like "cu*") { return "cuda" }
+        if ($TorchIndexFamily -like "rocm*") { return "rocm" }
+        if ($TorchIndexFamily -eq "cpu") { return "cpu" }
+        return "unknown"
+    }
+
+    function Write-TauriDiag {
+        param(
+            [string]$GpuBranch = "unknown",
+            [string]$TorchIndexFamily = "none",
+            [string]$PythonVersionForDiag = $PythonVersion
+        )
+        if ([string]::IsNullOrWhiteSpace($PythonVersionForDiag)) { $PythonVersionForDiag = "unknown" }
+        Write-TauriLog "DIAG" "diag_schema=1 platform=windows arch=$(Get-TauriDiagArch) python_version=$($PythonVersionForDiag.ToLowerInvariant()) skip_torch=$(Format-TauriDiagBool $SkipTorch) mac_intel=false gpu_branch=$GpuBranch torch_index_family=$TorchIndexFamily"
+    }
+
+    function Exit-InstallFailure {
+        param(
+            [Parameter(Mandatory = $true)][string]$Message,
+            [int]$Code = 1
+        )
+        if ($Code -eq 0) { $Code = 1 }
+        Write-TauriLog "ERROR" $Message
+        if (Get-Command Restore-StudioVenvRollback -CommandType Function -ErrorAction SilentlyContinue) {
+            Restore-StudioVenvRollback
+        }
+        if ($TauriMode) {
+            exit $Code
+        }
+    }
+
     # ── Parse flags ──
     $StudioLocalInstall = $false
     $PackageName = "unsloth"
@@ -26,7 +99,7 @@ function Install-UnslothStudio {
                 $i++
                 if ($i -ge $argList.Count) {
                     Write-Host "[ERROR] --package requires an argument." -ForegroundColor Red
-                    return
+                    return (Exit-InstallFailure "--package requires an argument.")
                 }
                 $PackageName = $argList[$i]
             }
@@ -42,22 +115,14 @@ function Install-UnslothStudio {
         $RepoRoot = (Resolve-Path (Split-Path -Parent $PSCommandPath)).Path
         if (-not (Test-Path (Join-Path $RepoRoot "pyproject.toml"))) {
             Write-Host "[ERROR] --local must be run from the unsloth repo root (pyproject.toml not found at $RepoRoot)" -ForegroundColor Red
-            return
+            return (Exit-InstallFailure "--local must be run from the unsloth repo root")
         }
     }
 
     # Validate --package to prevent injection into shell/Python commands
     if ($PackageName -notmatch '^[a-zA-Z0-9][a-zA-Z0-9._-]*$') {
         Write-Host "[ERROR] --package name contains invalid characters (allowed: a-z A-Z 0-9 . _ -)" -ForegroundColor Red
-        return
-    }
-
-    # ── Tauri structured output ──
-    function Write-TauriLog {
-        param([string]$Tag, [string]$Message)
-        if ($TauriMode) {
-            Write-Host "[TAURI:$Tag] $Message"
-        }
+        return (Exit-InstallFailure "--package name contains invalid characters")
     }
 
     $PythonVersion = "3.13"
@@ -487,7 +552,7 @@ try {
         } catch {}
         exit 1
     }
-    `$studioCommand = '& "' + `$studioExe + '" studio -H 0.0.0.0 -p ' + `$launchPort
+    `$studioCommand = '& "' + `$studioExe + '" studio -p ' + `$launchPort
     `$launchArgs = @(
         '-NoExit',
         '-NoProfile',
@@ -630,7 +695,7 @@ shell.Run cmd, 0, False
         step "winget" "not available" "Red"
         substep "Install it from https://aka.ms/getwinget" "Yellow"
         substep "or install Python $PythonVersion and uv manually, then re-run." "Yellow"
-        return
+        return (Exit-InstallFailure "winget is not available")
     }
 
     # ── Helper: detect a working Python 3.11-3.13 on the system ──
@@ -749,9 +814,14 @@ shell.Run cmd, 0, False
             Write-Host "        Please install Python $PythonVersion manually from https://www.python.org/downloads/" -ForegroundColor Yellow
             Write-Host "        Make sure to check 'Add Python to PATH' during installation." -ForegroundColor Yellow
             Write-Host "        Then re-run this installer." -ForegroundColor Yellow
-            return
+            return (Exit-InstallFailure "Python installation failed")
         }
     }
+    $DiagPythonVersion = $PythonVersion
+    if ($DetectedPython) { $DiagPythonVersion = $DetectedPython.Version }
+    $InitialGpuBranch = "unknown"
+    if ($SkipTorch) { $InitialGpuBranch = "no_torch" }
+    Write-TauriDiag -GpuBranch $InitialGpuBranch -TorchIndexFamily "none" -PythonVersionForDiag $DiagPythonVersion
 
     # ── Install uv if not present ──
     Write-TauriLog "STEP" "Installing uv package manager"
@@ -773,7 +843,7 @@ shell.Run cmd, 0, False
     if (-not (Get-Command uv -ErrorAction SilentlyContinue)) {
         step "uv" "could not be installed" "Red"
         substep "Install it from https://docs.astral.sh/uv/" "Yellow"
-        return
+        return (Exit-InstallFailure "uv could not be installed")
     }
 
     # ── Create venv (migrate old layout if possible, otherwise fresh) ──
@@ -786,11 +856,68 @@ shell.Run cmd, 0, False
 
     $VenvPython = Join-Path $VenvDir "Scripts\python.exe"
     $_Migrated = $false
+    $script:StudioVenvRollbackDir = $null
+    $script:StudioVenvRollbackTarget = $VenvDir
+    $script:StudioVenvRollbackActive = $false
+
+    function Start-StudioVenvRollback {
+        param([Parameter(Mandatory = $true)][string]$ExistingDir)
+        $stamp = Get-Date -Format "yyyyMMddHHmmss"
+        $candidate = Join-Path $StudioHome "unsloth_studio.rollback.$stamp.$PID"
+        $suffix = 0
+        while (Test-Path $candidate) {
+            $suffix++
+            $candidate = Join-Path $StudioHome "unsloth_studio.rollback.$stamp.$PID.$suffix"
+        }
+        Move-Item -Path $ExistingDir -Destination $candidate -ErrorAction Stop
+        $script:StudioVenvRollbackDir = $candidate
+        $script:StudioVenvRollbackTarget = $ExistingDir
+        $script:StudioVenvRollbackActive = $true
+        substep "previous environment preserved for rollback"
+    }
+
+    function Restore-StudioVenvRollback {
+        if (-not $script:StudioVenvRollbackActive) { return }
+        $backup = $script:StudioVenvRollbackDir
+        $target = $script:StudioVenvRollbackTarget
+        if (-not $backup -or -not (Test-Path $backup)) {
+            $script:StudioVenvRollbackActive = $false
+            return
+        }
+        substep "restoring previous environment after failed install..." "Yellow"
+        try {
+            if (Test-Path $target) {
+                Remove-Item -Recurse -Force $target -ErrorAction SilentlyContinue
+            }
+            Move-Item -Path $backup -Destination $target -Force -ErrorAction Stop
+            substep "restored previous environment"
+            $script:StudioVenvRollbackActive = $false
+            $script:StudioVenvRollbackDir = $null
+        } catch {
+            Write-Host "[WARN] Could not restore previous environment from $backup to $target" -ForegroundColor Yellow
+            Write-Host "       $($_.Exception.Message)" -ForegroundColor Yellow
+        }
+    }
+
+    function Complete-StudioVenvRollback {
+        if (-not $script:StudioVenvRollbackActive) { return }
+        $backup = $script:StudioVenvRollbackDir
+        if ($backup -and (Test-Path $backup)) {
+            Remove-Item -Recurse -Force $backup -ErrorAction SilentlyContinue
+        }
+        $script:StudioVenvRollbackActive = $false
+        $script:StudioVenvRollbackDir = $null
+    }
 
     if (Test-Path $VenvPython) {
-        # New layout already exists -- nuke for fresh install
-        substep "removing existing environment for fresh install..."
-        Remove-Item -Recurse -Force $VenvDir
+        # New layout already exists -- replace only after preserving rollback copy.
+        substep "preserving existing environment for rollback..."
+        try {
+            Start-StudioVenvRollback -ExistingDir $VenvDir
+        } catch {
+            Write-Host "[ERROR] Could not prepare existing environment for reinstall: $($_.Exception.Message)" -ForegroundColor Red
+            return (Exit-InstallFailure "Could not prepare existing environment for reinstall")
+        }
     } elseif (Test-Path (Join-Path $StudioHome ".venv\Scripts\python.exe")) {
         # Old layout (~/.unsloth/studio/.venv) exists -- validate before migrating
         $OldVenv = Join-Path $StudioHome ".venv"
@@ -799,18 +926,23 @@ shell.Run cmd, 0, False
         $prevEAP2 = $ErrorActionPreference
         $ErrorActionPreference = "Continue"
         try {
-            & $OldPy -c "import torch; A = torch.ones((2,2)); B = A + A" 2>$null | Out-Null
-            $torchOk = ($LASTEXITCODE -eq 0)
-        } catch { $torchOk = $false }
+            if ($SkipTorch) {
+                & $OldPy -c "import sys; print(sys.executable)" 2>$null | Out-Null
+            } else {
+                & $OldPy -c "import torch; A = torch.ones((2,2)); B = A + A" 2>$null | Out-Null
+            }
+            $legacyOk = ($LASTEXITCODE -eq 0)
+        } catch { $legacyOk = $false }
         $ErrorActionPreference = $prevEAP2
-        if ($torchOk) {
+        if ($legacyOk) {
             substep "legacy environment is healthy -- migrating..."
             Move-Item -Path $OldVenv -Destination $VenvDir -Force
             substep "moved .venv -> unsloth_studio"
             $_Migrated = $true
         } else {
             substep "legacy environment failed validation -- creating fresh environment" "Yellow"
-            Remove-Item -Recurse -Force $OldVenv -ErrorAction SilentlyContinue
+            $invalidVenv = Join-Path $StudioHome (".venv.invalid.{0}.{1}" -f (Get-Date -Format "yyyyMMddHHmmss"), $PID)
+            Move-Item -Path $OldVenv -Destination $invalidVenv -Force -ErrorAction SilentlyContinue
         }
     } elseif (Test-Path (Join-Path $env:USERPROFILE "unsloth_studio\Scripts\python.exe")) {
         # CWD-relative venv from old install.ps1 -- migrate to absolute path
@@ -826,9 +958,8 @@ shell.Run cmd, 0, False
         substep "$VenvDir"
         $venvExit = Invoke-InstallCommand { uv venv $VenvDir --python "$($DetectedPython.Path)" }
         if ($venvExit -ne 0) {
-            Write-TauriLog "ERROR" "Failed to create virtual environment (exit code $venvExit)"
             Write-Host "[ERROR] Failed to create virtual environment (exit code $venvExit)" -ForegroundColor Red
-            return
+            return (Exit-InstallFailure "Failed to create virtual environment (exit code $venvExit)" $venvExit)
         }
     } else {
         step "venv" "using migrated environment"
@@ -886,6 +1017,9 @@ shell.Run cmd, 0, False
         return "$baseUrl/cu126"
     }
     $TorchIndexUrl = Get-TorchIndexUrl
+    $TorchIndexFamily = Get-TauriTorchIndexFamily $TorchIndexUrl
+    $GpuBranch = Get-TauriGpuBranch $TorchIndexFamily
+    Write-TauriDiag -GpuBranch $GpuBranch -TorchIndexFamily $TorchIndexFamily -PythonVersionForDiag $DetectedPython.Version
 
     # ── Print CPU-only hint when no GPU detected ──
     if (-not $SkipTorch -and $TorchIndexUrl -like "*/cpu") {
@@ -934,7 +1068,7 @@ shell.Run cmd, 0, False
         if ($SkipTorch) {
             # No-torch: install unsloth + unsloth-zoo with --no-deps, then
             # runtime deps (typer, safetensors, transformers, etc.) with --no-deps.
-            $baseInstallExit = Invoke-InstallCommand { uv pip install --python $VenvPython --no-deps --reinstall-package unsloth --reinstall-package unsloth-zoo "unsloth>=2026.4.7" unsloth-zoo }
+            $baseInstallExit = Invoke-InstallCommand { uv pip install --python $VenvPython --no-deps --reinstall-package unsloth --reinstall-package unsloth-zoo "unsloth>=2026.4.8" unsloth-zoo }
             if ($baseInstallExit -eq 0) {
                 $NoTorchReq = Find-NoTorchRuntimeFile
                 if ($NoTorchReq) {
@@ -942,18 +1076,24 @@ shell.Run cmd, 0, False
                 }
             }
         } else {
-            $baseInstallExit = Invoke-InstallCommand { uv pip install --python $VenvPython --reinstall-package unsloth --reinstall-package unsloth-zoo "unsloth>=2026.4.7" unsloth-zoo }
+            $baseInstallExit = Invoke-InstallCommand { uv pip install --python $VenvPython --reinstall-package unsloth --reinstall-package unsloth-zoo "unsloth>=2026.4.8" unsloth-zoo }
         }
         if ($baseInstallExit -ne 0) {
             Write-Host "[ERROR] Failed to install unsloth (exit code $baseInstallExit)" -ForegroundColor Red
-            return
+            return (Exit-InstallFailure "Failed to install unsloth (exit code $baseInstallExit)" $baseInstallExit)
         }
         if ($StudioLocalInstall) {
             substep "overlaying local repo (editable)..."
             $overlayExit = Invoke-InstallCommand { uv pip install --python $VenvPython -e $RepoRoot --no-deps }
             if ($overlayExit -ne 0) {
                 Write-Host "[ERROR] Failed to overlay local repo (exit code $overlayExit)" -ForegroundColor Red
-                return
+                return (Exit-InstallFailure "Failed to overlay local repo (exit code $overlayExit)" $overlayExit)
+            }
+            substep "overlaying unsloth-zoo from git main..."
+            $zooOverlayExit = Invoke-InstallCommand { uv pip install --python $VenvPython --no-deps --reinstall-package unsloth-zoo "unsloth-zoo @ git+https://github.com/unslothai/unsloth-zoo" }
+            if ($zooOverlayExit -ne 0) {
+                Write-Host "[ERROR] Failed to overlay unsloth-zoo (exit code $zooOverlayExit)" -ForegroundColor Red
+                return (Exit-InstallFailure "Failed to overlay unsloth-zoo (exit code $zooOverlayExit)" $zooOverlayExit)
             }
         }
     } elseif ($TorchIndexUrl) {
@@ -964,9 +1104,8 @@ shell.Run cmd, 0, False
             substep "installing PyTorch ($TorchIndexUrl)..."
             $torchInstallExit = Invoke-InstallCommand { uv pip install --python $VenvPython "torch>=2.4,<2.11.0" torchvision torchaudio --index-url $TorchIndexUrl }
             if ($torchInstallExit -ne 0) {
-                Write-TauriLog "ERROR" "Failed to install PyTorch (exit code $torchInstallExit)"
                 Write-Host "[ERROR] Failed to install PyTorch (exit code $torchInstallExit)" -ForegroundColor Red
-                return
+                return (Exit-InstallFailure "Failed to install PyTorch (exit code $torchInstallExit)" $torchInstallExit)
             }
         }
 
@@ -975,7 +1114,7 @@ shell.Run cmd, 0, False
         if ($SkipTorch) {
             # No-torch: install unsloth + unsloth-zoo with --no-deps, then
             # runtime deps (typer, safetensors, transformers, etc.) with --no-deps.
-            $baseInstallExit = Invoke-InstallCommand { uv pip install --python $VenvPython --no-deps --upgrade-package unsloth --upgrade-package unsloth-zoo "unsloth>=2026.4.7" unsloth-zoo }
+            $baseInstallExit = Invoke-InstallCommand { uv pip install --python $VenvPython --no-deps --upgrade-package unsloth --upgrade-package unsloth-zoo "unsloth>=2026.4.8" unsloth-zoo }
             if ($baseInstallExit -eq 0) {
                 $NoTorchReq = Find-NoTorchRuntimeFile
                 if ($NoTorchReq) {
@@ -983,14 +1122,13 @@ shell.Run cmd, 0, False
                 }
             }
         } elseif ($StudioLocalInstall) {
-            $baseInstallExit = Invoke-InstallCommand { uv pip install --python $VenvPython --upgrade-package unsloth "unsloth>=2026.4.7" unsloth-zoo }
+            $baseInstallExit = Invoke-InstallCommand { uv pip install --python $VenvPython --upgrade-package unsloth "unsloth>=2026.4.8" unsloth-zoo }
         } else {
             $baseInstallExit = Invoke-InstallCommand { uv pip install --python $VenvPython --upgrade-package unsloth -- "$PackageName" }
         }
         if ($baseInstallExit -ne 0) {
-            Write-TauriLog "ERROR" "Failed to install unsloth (exit code $baseInstallExit)"
             Write-Host "[ERROR] Failed to install unsloth (exit code $baseInstallExit)" -ForegroundColor Red
-            return
+            return (Exit-InstallFailure "Failed to install unsloth (exit code $baseInstallExit)" $baseInstallExit)
         }
 
         if ($StudioLocalInstall) {
@@ -998,7 +1136,13 @@ shell.Run cmd, 0, False
             $overlayExit = Invoke-InstallCommand { uv pip install --python $VenvPython -e $RepoRoot --no-deps }
             if ($overlayExit -ne 0) {
                 Write-Host "[ERROR] Failed to overlay local repo (exit code $overlayExit)" -ForegroundColor Red
-                return
+                return (Exit-InstallFailure "Failed to overlay local repo (exit code $overlayExit)" $overlayExit)
+            }
+            substep "overlaying unsloth-zoo from git main..."
+            $zooOverlayExit = Invoke-InstallCommand { uv pip install --python $VenvPython --no-deps --reinstall-package unsloth-zoo "unsloth-zoo @ git+https://github.com/unslothai/unsloth-zoo" }
+            if ($zooOverlayExit -ne 0) {
+                Write-Host "[ERROR] Failed to overlay unsloth-zoo (exit code $zooOverlayExit)" -ForegroundColor Red
+                return (Exit-InstallFailure "Failed to overlay unsloth-zoo (exit code $zooOverlayExit)" $zooOverlayExit)
             }
         }
     } else {
@@ -1006,53 +1150,72 @@ shell.Run cmd, 0, False
         Write-TauriLog "STEP" "Installing unsloth"
         substep "installing unsloth (this may take a few minutes)..."
         if ($StudioLocalInstall) {
-            $baseInstallExit = Invoke-InstallCommand { uv pip install --python $VenvPython unsloth-zoo "unsloth>=2026.4.7" --torch-backend=auto }
+            $baseInstallExit = Invoke-InstallCommand { uv pip install --python $VenvPython unsloth-zoo "unsloth>=2026.4.8" --torch-backend=auto }
             if ($baseInstallExit -ne 0) {
                 Write-Host "[ERROR] Failed to install unsloth (exit code $baseInstallExit)" -ForegroundColor Red
-                return
+                return (Exit-InstallFailure "Failed to install unsloth (exit code $baseInstallExit)" $baseInstallExit)
             }
             substep "overlaying local repo (editable)..."
             $overlayExit = Invoke-InstallCommand { uv pip install --python $VenvPython -e $RepoRoot --no-deps }
             if ($overlayExit -ne 0) {
                 Write-Host "[ERROR] Failed to overlay local repo (exit code $overlayExit)" -ForegroundColor Red
-                return
+                return (Exit-InstallFailure "Failed to overlay local repo (exit code $overlayExit)" $overlayExit)
+            }
+            substep "overlaying unsloth-zoo from git main..."
+            $zooOverlayExit = Invoke-InstallCommand { uv pip install --python $VenvPython --no-deps --reinstall-package unsloth-zoo "unsloth-zoo @ git+https://github.com/unslothai/unsloth-zoo" }
+            if ($zooOverlayExit -ne 0) {
+                Write-Host "[ERROR] Failed to overlay unsloth-zoo (exit code $zooOverlayExit)" -ForegroundColor Red
+                return (Exit-InstallFailure "Failed to overlay unsloth-zoo (exit code $zooOverlayExit)" $zooOverlayExit)
             }
         } else {
             $baseInstallExit = Invoke-InstallCommand { uv pip install --python $VenvPython --torch-backend=auto -- "$PackageName" }
             if ($baseInstallExit -ne 0) {
-                Write-TauriLog "ERROR" "Failed to install unsloth (exit code $baseInstallExit)"
                 Write-Host "[ERROR] Failed to install unsloth (exit code $baseInstallExit)" -ForegroundColor Red
-                return
+                return (Exit-InstallFailure "Failed to install unsloth (exit code $baseInstallExit)" $baseInstallExit)
             }
         }
     }
 
-    # Hotfix: patch install_python_stack.py for Windows GUI stdout
-    # The PyPI version crashes with OSError when stdout is piped from a GUI app.
-    # Copy our fixed version (bundled by Tauri) over the installed one.
-    # Remove this block once PyPI ships the fix from commit 18c5aae7.
+    # Overlay Tauri-bundled studio fixes that may be ahead of PyPI. Skipped
+    # for --local: the editable install above already makes _PACKAGE_ROOT in
+    # unsloth_cli/commands/studio.py resolve to the repo (PEP 660 __file__).
+    # Source paths match the Tauri bundle layout in studio/src-tauri/tauri.conf.json,
+    # which bundles install_python_stack.py at the bundle root next to install.ps1.
     if ($TauriMode) {
         $rawPath = if ($PSCommandPath) { $PSCommandPath } else { $MyInvocation.ScriptName }
-        $scriptDir = Split-Path -Parent ($rawPath -replace '^\\\\\?\\', '')
-        $fixedPy = Join-Path $scriptDir "install_python_stack.py"
-        $target = Join-Path $VenvDir "Lib\site-packages\studio\install_python_stack.py"
-        $sentinel = "# UNSLOTH_DESKTOP_HOTFIX_APPLIED_v1"
-        $sentinelPattern = [regex]::Escape($sentinel)
-        if ((Test-Path $fixedPy) -and (Test-Path $target)) {
-            $installed = Get-Content $target -Raw
-            if ($installed -notmatch $sentinelPattern) {
-                Copy-Item $fixedPy $target -Force
-                Add-Content -Path $target -Value "`n$sentinel"
-                substep "patched install_python_stack.py (stdout fix)"
-            } else {
-                substep "install_python_stack.py already has stdout fix"
+        if ($rawPath) {
+            # Strip leading \\?\ extended-length prefix if the launcher passed one.
+            $scriptDir = Split-Path -Parent ($rawPath -replace '^\\\\\?\\', '')
+            $overlayMap = [ordered]@{
+                "install_python_stack.py" = "Lib\site-packages\studio\install_python_stack.py"
+            }
+            foreach ($rel in $overlayMap.Keys) {
+                $src = Join-Path $scriptDir $rel
+                $dst = Join-Path $VenvDir $overlayMap[$rel]
+                if (-not (Test-Path $src)) { continue }
+                $dstParent = Split-Path -Parent $dst
+                if (-not (Test-Path $dstParent)) {
+                    Write-Host "[WARN] Overlay target dir missing: $dstParent; studio setup may use stale bundled file" -ForegroundColor Yellow
+                    continue
+                }
+                try {
+                    if (-not (Test-Path $dst)) {
+                        # Backfill: target file missing but parent dir exists.
+                        Copy-Item $src $dst -Force
+                        substep ("backfilled bundled " + (Split-Path -Leaf $rel))
+                    } else {
+                        # Hash-compare so re-runs are no-ops when files already match.
+                        $srcHash = (Get-FileHash $src -Algorithm SHA256).Hash
+                        $dstHash = (Get-FileHash $dst -Algorithm SHA256).Hash
+                        if ($srcHash -ne $dstHash) {
+                            Copy-Item $src $dst -Force
+                            substep ("applied bundled " + (Split-Path -Leaf $rel))
+                        }
+                    }
+                } catch {
+                    Write-Host "[WARN] Could not overlay $($rel): $($_.Exception.Message); studio setup may use stale bundled file" -ForegroundColor Yellow
+                }
             }
-        } elseif ((Test-Path $fixedPy) -and (Test-Path (Split-Path $target))) {
-            Copy-Item $fixedPy $target -Force
-            Add-Content -Path $target -Value "`n$sentinel"
-            substep "patched install_python_stack.py (stdout fix)"
-        } else {
-            Write-Host "[WARN] Could not patch install_python_stack.py (bundled file or target dir missing)" -ForegroundColor Yellow
         }
     }
 
@@ -1063,12 +1226,11 @@ shell.Run cmd, 0, False
     step "setup" "running unsloth studio setup..."
     $UnslothExe = Join-Path $VenvDir "Scripts\unsloth.exe"
     if (-not (Test-Path $UnslothExe)) {
-        Write-TauriLog "ERROR" "unsloth CLI was not installed correctly"
         Write-Host "[ERROR] unsloth CLI was not installed correctly." -ForegroundColor Red
         Write-Host "        Expected: $UnslothExe" -ForegroundColor Yellow
         Write-Host "        This usually means an older unsloth version was installed that does not include the Studio CLI." -ForegroundColor Yellow
         Write-Host "        Try re-running the installer or see: https://github.com/unslothai/unsloth?tab=readme-ov-file#-quickstart" -ForegroundColor Yellow
-        return
+        return (Exit-InstallFailure "unsloth CLI was not installed correctly")
     }
     # Tell setup.ps1 to skip base package installation (install.ps1 already did it)
     $env:SKIP_STUDIO_BASE = "1"
@@ -1090,12 +1252,16 @@ shell.Run cmd, 0, False
     # and bypass the fast-path version check from PR #4667.
     $studioArgs = @('studio', 'setup')
     if ($script:UnslothVerbose) { $studioArgs += '--verbose' }
-    & $UnslothExe @studioArgs
-    $setupExit = $LASTEXITCODE
+    $env:UNSLOTH_INSTALL_ROLLBACK_MANAGED = "1"
+    try {
+        & $UnslothExe @studioArgs
+        $setupExit = $LASTEXITCODE
+    } finally {
+        Remove-Item Env:UNSLOTH_INSTALL_ROLLBACK_MANAGED -ErrorAction SilentlyContinue
+    }
     if ($setupExit -ne 0) {
-        Write-TauriLog "ERROR" "unsloth studio setup failed (exit code $setupExit)"
         Write-Host "[ERROR] unsloth studio setup failed (exit code $setupExit)" -ForegroundColor Red
-        return
+        return (Exit-InstallFailure "unsloth studio setup failed (exit code $setupExit)" $setupExit)
     }
 
     # ── Expose `unsloth` via a shim dir containing only unsloth.exe ──
@@ -1168,6 +1334,7 @@ shell.Run cmd, 0, False
         step "path" "added unsloth launcher to PATH"
     }
     Refresh-SessionPath  # sync current session with registry
+    Complete-StudioVenvRollback
 
     # ── Tauri mode: done, skip shortcuts and auto-launch ──
     if ($TauriMode) {
@@ -1177,15 +1344,25 @@ shell.Run cmd, 0, False
 
     New-StudioShortcuts -UnslothExePath $UnslothExe
 
-    # Launch studio automatically in interactive terminals;
-    # in non-interactive environments (CI, Docker) just print instructions.
+    # In interactive terminals, ask the user before starting Studio.
+    # In non-interactive environments (CI, Docker) just print instructions.
     $IsInteractive = [Environment]::UserInteractive -and (-not [Console]::IsInputRedirected)
     if ($IsInteractive) {
-        & $UnslothExe studio -H 0.0.0.0 -p 8888
+        Write-Host ""
+        $reply = Read-Host "  Start Unsloth Studio now? [Y/n]"
+        if ([string]::IsNullOrWhiteSpace($reply) -or $reply -match '^[Yy]') {
+            & $UnslothExe studio -p 8888
+        } else {
+            step "launch" "to start later, run:"
+            substep "unsloth studio -p 8888"
+            substep "(add -H 0.0.0.0 to allow network / cloud access)"
+            Write-Host ""
+        }
     } else {
         step "launch" "manual commands:"
         substep "& `"$VenvDir\Scripts\Activate.ps1`""
-        substep "unsloth studio -H 0.0.0.0 -p 8888"
+        substep "unsloth studio -p 8888"
+        substep "(add -H 0.0.0.0 to allow network / cloud access)"
         Write-Host ""
     }
 }
diff --git a/install.sh b/install.sh
index 07473e441d..7948170043 100755
--- a/install.sh
+++ b/install.sh
@@ -162,9 +162,119 @@ tauri_log() {
     fi
 }
 
+tauri_diag_marker() {
+    _diag_gpu_branch="${1:-unknown}"
+    _diag_torch_index_family="${2:-none}"
+    tauri_log "DIAG" "diag_schema=1 platform=${OS:-unknown} arch=${_ARCH:-unknown} python_version=${PYTHON_VERSION:-unknown} skip_torch=${SKIP_TORCH:-false} mac_intel=${MAC_INTEL:-false} gpu_branch=${_diag_gpu_branch} torch_index_family=${_diag_torch_index_family}"
+}
+
+_tauri_torch_index_family() {
+    if [ "${SKIP_TORCH:-false}" = true ]; then
+        echo "none"
+        return
+    fi
+    _diag_url="${1:-}"
+    case "$_diag_url" in
+        */cu118) echo "cu118" ;;
+        */cu124) echo "cu124" ;;
+        */cu126) echo "cu126" ;;
+        */cu128) echo "cu128" ;;
+        */cu130) echo "cu130" ;;
+        */cpu) echo "cpu" ;;
+        */rocm[0-9]*.[0-9]*)
+            _diag_family=${_diag_url##*/}
+            case "$_diag_family" in
+                rocm[0-9]*.[0-9]*) echo "$_diag_family" ;;
+                *) echo "auto" ;;
+            esac ;;
+        "") echo "none" ;;
+        *) echo "auto" ;;
+    esac
+}
+
+_tauri_gpu_branch() {
+    _diag_family="${1:-unknown}"
+    _diag_radeon="${2:-false}"
+    if [ "${SKIP_TORCH:-false}" = true ]; then
+        echo "no_torch"
+        return
+    fi
+    if [ "${OS:-}" = "macos" ]; then
+        echo "mac"
+        return
+    fi
+    case "$_diag_family" in
+        cu*) echo "cuda" ;;
+        rocm*)
+            if [ "$_diag_radeon" = true ]; then
+                echo "rocm_radeon"
+            else
+                echo "rocm"
+            fi ;;
+        radeon) echo "rocm_radeon" ;;
+        cpu) echo "cpu" ;;
+        none) echo "no_torch" ;;
+        *) echo "unknown" ;;
+    esac
+}
+
 PYTHON_VERSION=""  # resolved after platform detection
 STUDIO_HOME="$HOME/.unsloth/studio"
 VENV_DIR="$STUDIO_HOME/unsloth_studio"
+_VENV_ROLLBACK_DIR=""
+_VENV_ROLLBACK_TARGET="$VENV_DIR"
+_VENV_ROLLBACK_ACTIVE=false
+
+_start_studio_venv_replacement() {
+    _existing_dir="$1"
+    _stamp=$(date +%Y%m%d%H%M%S 2>/dev/null || echo "time")
+    _candidate="$STUDIO_HOME/unsloth_studio.rollback.$_stamp.$$"
+    _suffix=0
+    while [ -e "$_candidate" ]; do
+        _suffix=$((_suffix + 1))
+        _candidate="$STUDIO_HOME/unsloth_studio.rollback.$_stamp.$$.$_suffix"
+    done
+    mv "$_existing_dir" "$_candidate"
+    _VENV_ROLLBACK_DIR="$_candidate"
+    _VENV_ROLLBACK_TARGET="$_existing_dir"
+    _VENV_ROLLBACK_ACTIVE=true
+    substep "previous environment preserved for rollback"
+}
+
+_restore_studio_venv_replacement() {
+    [ "$_VENV_ROLLBACK_ACTIVE" = true ] || return 0
+    [ -n "$_VENV_ROLLBACK_DIR" ] && [ -d "$_VENV_ROLLBACK_DIR" ] || {
+        _VENV_ROLLBACK_ACTIVE=false
+        return 0
+    }
+    substep "restoring previous environment after failed install..." "$C_WARN"
+    rm -rf "$_VENV_ROLLBACK_TARGET"
+    if mv "$_VENV_ROLLBACK_DIR" "$_VENV_ROLLBACK_TARGET"; then
+        substep "restored previous environment"
+        _VENV_ROLLBACK_ACTIVE=false
+        _VENV_ROLLBACK_DIR=""
+    else
+        echo "⚠️  Could not restore previous environment from $_VENV_ROLLBACK_DIR to $_VENV_ROLLBACK_TARGET" >&2
+    fi
+}
+
+_commit_studio_venv_replacement() {
+    [ "$_VENV_ROLLBACK_ACTIVE" = true ] || return 0
+    if [ -n "$_VENV_ROLLBACK_DIR" ] && [ -d "$_VENV_ROLLBACK_DIR" ]; then
+        rm -rf "$_VENV_ROLLBACK_DIR" || true
+    fi
+    _VENV_ROLLBACK_ACTIVE=false
+    _VENV_ROLLBACK_DIR=""
+}
+
+_on_install_exit() {
+    _status=$?
+    if [ "$_status" -ne 0 ]; then
+        _restore_studio_venv_replacement
+    fi
+    exit "$_status"
+}
+trap _on_install_exit EXIT
 
 # ── Helper: download a URL to a file (supports curl and wget) ──
 download() {
@@ -512,11 +622,11 @@ if [ -t 1 ]; then
     ) &
     # Clear traps so exec does not trigger _release_lock (the subshell owns it)
     trap - EXIT INT TERM
-    exec "$UNSLOTH_EXE" studio -H 0.0.0.0 -p "$_launch_port"
+    exec "$UNSLOTH_EXE" studio -p "$_launch_port"
 else
     # ── Background mode (no TTY) ──
     # Used by macOS .app and headless invocations.
-    _launch_cmd=$(printf '%q ' "$UNSLOTH_EXE" studio -H 0.0.0.0 -p "$_launch_port")
+    _launch_cmd=$(printf '%q ' "$UNSLOTH_EXE" studio -p "$_launch_port")
     _launch_cmd=${_launch_cmd% }
     _spawn_terminal "$_launch_cmd"
 
@@ -828,6 +938,14 @@ if [ "$_NO_TORCH_FLAG" = true ] || [ "$MAC_INTEL" = true ]; then
     SKIP_TORCH=true
 fi
 
+_TAURI_INITIAL_GPU_BRANCH="unknown"
+if [ "$SKIP_TORCH" = true ]; then
+    _TAURI_INITIAL_GPU_BRANCH="no_torch"
+elif [ "$OS" = "macos" ]; then
+    _TAURI_INITIAL_GPU_BRANCH="mac"
+fi
+tauri_diag_marker "$_TAURI_INITIAL_GPU_BRANCH" "none"
+
 # ── Check system dependencies ──
 # cmake and git are needed by unsloth studio setup to build the GGUF inference
 # engine (llama.cpp). build-essential and libcurl-dev are also needed on Linux.
@@ -856,9 +974,7 @@ case "$OS" in
         fi
         command -v gcc  >/dev/null 2>&1 || MISSING="$MISSING build-essential"
         # libcurl dev headers for llama.cpp HTTPS support
-        if command -v dpkg >/dev/null 2>&1; then
-            dpkg -s libcurl4-openssl-dev >/dev/null 2>&1 || MISSING="$MISSING libcurl4-openssl-dev"
-        fi
+        command -v curl-config >/dev/null 2>&1 || MISSING="$MISSING libcurl4-openssl-dev"
         ;;
 esac
 
@@ -883,9 +999,15 @@ if [ -n "$MISSING" ]; then
             if command -v apt-get >/dev/null 2>&1; then
                 _smart_apt_install $MISSING
             else
-                echo "    apt-get is not available. Please install with your package manager:"
+                echo "    Automatic system package installation is supported on apt-based"
+                echo "    Linux distributions (Ubuntu/Debian) only. Please install the"
+                echo "    missing dependencies with your package manager, then re-run setup:"
                 echo "    $MISSING"
-                echo "    Then re-run Unsloth Studio setup."
+                echo ""
+                echo "    Examples:"
+                echo "      Fedora/RHEL: sudo dnf install cmake git gcc gcc-c++ make libcurl-devel"
+                echo "      Arch:       sudo pacman -S --needed cmake git base-devel curl"
+                echo "      openSUSE:   sudo zypper install cmake git gcc gcc-c++ make libcurl-devel"
                 exit 1
             fi
             ;;
@@ -957,12 +1079,19 @@ mkdir -p "$STUDIO_HOME"
 _MIGRATED=false
 
 if [ -x "$VENV_DIR/bin/python" ]; then
-    # New layout already exists — nuke for fresh install
-    rm -rf "$VENV_DIR"
+    # New layout already exists — replace only after preserving rollback copy.
+    substep "preserving existing environment for rollback..."
+    _start_studio_venv_replacement "$VENV_DIR"
 elif [ -x "$STUDIO_HOME/.venv/bin/python" ]; then
-    # Old layout exists — validate before migrating
+    # Old layout exists — validate before migrating.
+    # In no-torch mode, a missing torch package is expected; validate Python only.
     substep "found legacy Studio environment, validating..."
-    if "$STUDIO_HOME/.venv/bin/python" -c "
+    _legacy_ok=false
+    if [ "$SKIP_TORCH" = true ]; then
+        if "$STUDIO_HOME/.venv/bin/python" -c "import sys; print(sys.executable)" >/dev/null 2>&1; then
+            _legacy_ok=true
+        fi
+    elif "$STUDIO_HOME/.venv/bin/python" -c "
 import torch
 device = 'cuda' if torch.cuda.is_available() else 'cpu'
 A = torch.ones((10, 10), device=device)
@@ -972,13 +1101,17 @@ D = A + B
 E = D @ C
 torch.testing.assert_close(torch.unique(E), torch.tensor((20,), device=E.device, dtype=E.dtype))
 " >/dev/null 2>&1; then
+        _legacy_ok=true
+    fi
+    if [ "$_legacy_ok" = true ]; then
         echo "✅ Legacy environment is healthy — migrating..."
         mv "$STUDIO_HOME/.venv" "$VENV_DIR"
         echo "   Moved ~/.unsloth/studio/.venv → $VENV_DIR"
         _MIGRATED=true
     else
         echo "⚠️  Legacy environment failed validation — creating fresh environment"
-        rm -rf "$STUDIO_HOME/.venv"
+        _invalid_venv="$STUDIO_HOME/.venv.invalid.$(date +%Y%m%d%H%M%S 2>/dev/null || echo time).$$"
+        mv "$STUDIO_HOME/.venv" "$_invalid_venv" 2>/dev/null || true
     fi
 fi
 
@@ -1308,6 +1441,12 @@ case "$TORCH_INDEX_URL" in
         fi
         ;;
 esac
+_TAURI_TORCH_INDEX_FAMILY=$(_tauri_torch_index_family "$TORCH_INDEX_URL")
+if [ "$_amd_gpu_radeon" = true ] && [ "$SKIP_TORCH" = false ]; then
+    _TAURI_TORCH_INDEX_FAMILY="radeon"
+fi
+_TAURI_GPU_BRANCH=$(_tauri_gpu_branch "$_TAURI_TORCH_INDEX_FAMILY" "$_amd_gpu_radeon")
+tauri_diag_marker "$_TAURI_GPU_BRANCH" "$_TAURI_TORCH_INDEX_FAMILY"
 
 # ── Print CPU-only hint when no GPU detected ──
 case "$TORCH_INDEX_URL" in
@@ -1347,7 +1486,7 @@ if [ "$_MIGRATED" = true ]; then
         # to prevent transitive torch resolution.
         run_install_cmd "install unsloth (migrated no-torch)" uv pip install --python "$_VENV_PY" --no-deps \
             --reinstall-package unsloth --reinstall-package unsloth-zoo \
-            "unsloth>=2026.4.7" unsloth-zoo
+            "unsloth>=2026.4.8" unsloth-zoo
         _NO_TORCH_RT="$(_find_no_torch_runtime)"
         if [ -n "$_NO_TORCH_RT" ]; then
             run_install_cmd "install no-torch runtime deps" uv pip install --python "$_VENV_PY" --no-deps -r "$_NO_TORCH_RT"
@@ -1355,11 +1494,15 @@ if [ "$_MIGRATED" = true ]; then
     else
         run_install_cmd "install unsloth (migrated)" uv pip install --python "$_VENV_PY" \
             --reinstall-package unsloth --reinstall-package unsloth-zoo \
-            "unsloth>=2026.4.7" unsloth-zoo
+            "unsloth>=2026.4.8" unsloth-zoo
     fi
     if [ "$STUDIO_LOCAL_INSTALL" = true ]; then
         substep "overlaying local repo (editable)..."
         run_install_cmd "overlay local repo" uv pip install --python "$_VENV_PY" -e "$_REPO_ROOT" --no-deps
+        substep "overlaying unsloth-zoo from git main..."
+        run_install_cmd "overlay unsloth-zoo (git main)" uv pip install --python "$_VENV_PY" \
+            --no-deps --reinstall-package unsloth-zoo \
+            "unsloth-zoo @ git+https://github.com/unslothai/unsloth-zoo"
     fi
     # AMD ROCm: install bitsandbytes even in migrated environments so
     # existing ROCm installs gain the AMD bitsandbytes build without a
@@ -1519,7 +1662,7 @@ elif [ -n "$TORCH_INDEX_URL" ]; then
         # runtime deps (typer, safetensors, transformers, etc.) with --no-deps.
         run_install_cmd "install unsloth (no-torch)" uv pip install --python "$_VENV_PY" --no-deps \
             --upgrade-package unsloth --upgrade-package unsloth-zoo \
-            "unsloth>=2026.4.7" unsloth-zoo
+            "unsloth>=2026.4.8" unsloth-zoo
         _NO_TORCH_RT="$(_find_no_torch_runtime)"
         if [ -n "$_NO_TORCH_RT" ]; then
             run_install_cmd "install no-torch runtime deps" uv pip install --python "$_VENV_PY" --no-deps -r "$_NO_TORCH_RT"
@@ -1527,12 +1670,20 @@ elif [ -n "$TORCH_INDEX_URL" ]; then
         if [ "$STUDIO_LOCAL_INSTALL" = true ]; then
             substep "overlaying local repo (editable)..."
             run_install_cmd "overlay local repo" uv pip install --python "$_VENV_PY" -e "$_REPO_ROOT" --no-deps
+            substep "overlaying unsloth-zoo from git main..."
+            run_install_cmd "overlay unsloth-zoo (git main)" uv pip install --python "$_VENV_PY" \
+                --no-deps --reinstall-package unsloth-zoo \
+                "unsloth-zoo @ git+https://github.com/unslothai/unsloth-zoo"
         fi
     elif [ "$STUDIO_LOCAL_INSTALL" = true ]; then
         run_install_cmd "install unsloth (local)" uv pip install --python "$_VENV_PY" \
-            --upgrade-package unsloth "unsloth>=2026.4.7" unsloth-zoo
+            --upgrade-package unsloth "unsloth>=2026.4.8" unsloth-zoo
         substep "overlaying local repo (editable)..."
         run_install_cmd "overlay local repo" uv pip install --python "$_VENV_PY" -e "$_REPO_ROOT" --no-deps
+        substep "overlaying unsloth-zoo from git main..."
+        run_install_cmd "overlay unsloth-zoo (git main)" uv pip install --python "$_VENV_PY" \
+            --no-deps --reinstall-package unsloth-zoo \
+            "unsloth-zoo @ git+https://github.com/unslothai/unsloth-zoo"
     else
         run_install_cmd "install unsloth" uv pip install --python "$_VENV_PY" \
             --upgrade-package unsloth -- "$PACKAGE_NAME"
@@ -1558,9 +1709,13 @@ else
     tauri_log "STEP" "Installing Unsloth"
     substep "installing unsloth (this may take a few minutes)..."
     if [ "$STUDIO_LOCAL_INSTALL" = true ]; then
-        run_install_cmd "install unsloth (auto torch backend)" uv pip install --python "$_VENV_PY" unsloth-zoo "unsloth>=2026.4.7" --torch-backend=auto
+        run_install_cmd "install unsloth (auto torch backend)" uv pip install --python "$_VENV_PY" unsloth-zoo "unsloth>=2026.4.8" --torch-backend=auto
         substep "overlaying local repo (editable)..."
         run_install_cmd "overlay local repo" uv pip install --python "$_VENV_PY" -e "$_REPO_ROOT" --no-deps
+        substep "overlaying unsloth-zoo from git main..."
+        run_install_cmd "overlay unsloth-zoo (git main)" uv pip install --python "$_VENV_PY" \
+            --no-deps --reinstall-package unsloth-zoo \
+            "unsloth-zoo @ git+https://github.com/unslothai/unsloth-zoo"
     else
         run_install_cmd "install unsloth (auto torch backend)" uv pip install --python "$_VENV_PY" --torch-backend=auto -- "$PACKAGE_NAME"
     fi
@@ -1679,6 +1834,8 @@ if [ "$_SETUP_EXIT" -ne 0 ]; then
     exit "$_SETUP_EXIT"
 fi
 
+_commit_studio_venv_replacement
+
 # ── Tauri mode: done, skip shortcuts and auto-launch ──
 if [ "$TAURI_MODE" = true ]; then
     tauri_log "DONE" ""
@@ -1690,28 +1847,46 @@ printf "  ${C_TITLE}%s${C_RST}\n" "Unsloth Studio installed!"
 printf "  ${C_DIM}%s${C_RST}\n" "$RULE"
 echo ""
 
-# Launch studio automatically in interactive terminals;
-# in non-interactive environments (Docker, CI, cloud-init) just print instructions.
+# In interactive terminals, ask the user before starting Studio.
+# In non-interactive environments (Docker, CI, cloud-init) just print instructions.
 if [ -t 1 ]; then
-    step "launch" "starting Unsloth Studio..."
-    "$VENV_DIR/bin/unsloth" studio -H 0.0.0.0 -p 8888
-    _LAUNCH_EXIT=$?
-    if [ "$_LAUNCH_EXIT" -ne 0 ] && [ "$_MIGRATED" = true ]; then
-        echo ""
-        echo "⚠️  Unsloth Studio failed to start after migration."
-        echo "   Your migrated environment may be incompatible."
-        echo "   To fix, remove the environment and reinstall:"
-        echo ""
-        echo "   rm -rf $VENV_DIR"
-        echo "   curl -fsSL https://unsloth.ai/install.sh | sh"
-        echo ""
+    echo ""
+    printf "  Start Unsloth Studio now? [Y/n] "
+    if [ -r /dev/tty ]; then
+        read -r _reply </dev/tty || _reply="y"
+    else
+        _reply="y"
     fi
-    exit "$_LAUNCH_EXIT"
+    case "${_reply:-y}" in
+        [Yy]*|"")
+            step "launch" "starting Unsloth Studio..."
+            "$VENV_DIR/bin/unsloth" studio -p 8888
+            _LAUNCH_EXIT=$?
+            if [ "$_LAUNCH_EXIT" -ne 0 ] && [ "$_MIGRATED" = true ]; then
+                echo ""
+                echo "⚠️  Unsloth Studio failed to start after migration."
+                echo "   Your migrated environment may be incompatible."
+                echo "   To fix, remove the environment and reinstall:"
+                echo ""
+                echo "   rm -rf $VENV_DIR"
+                echo "   curl -fsSL https://unsloth.ai/install.sh | sh"
+                echo ""
+            fi
+            exit "$_LAUNCH_EXIT"
+            ;;
+        *)
+            step "launch" "to start later, run:"
+            substep "unsloth studio -p 8888"
+            substep "(add -H 0.0.0.0 to allow network / cloud access)"
+            echo ""
+            ;;
+    esac
 else
     step "launch" "manual commands:"
-    substep "unsloth studio -H 0.0.0.0 -p 8888"
+    substep "unsloth studio -p 8888"
     substep "or activate env first:"
     substep "source ${VENV_DIR}/bin/activate"
-    substep "unsloth studio -H 0.0.0.0 -p 8888"
+    substep "unsloth studio -p 8888"
+    substep "(add -H 0.0.0.0 to allow network / cloud access)"
     echo ""
 fi
diff --git a/studio/Unsloth_Studio_Colab.ipynb b/studio/Unsloth_Studio_Colab.ipynb
index 46e2067ba7..c3aec04820 100644
--- a/studio/Unsloth_Studio_Colab.ipynb
+++ b/studio/Unsloth_Studio_Colab.ipynb
@@ -64,7 +64,7 @@
     "id": "27e68f91"
    },
    "outputs": [],
-   "source": "!git clone --depth 1 --branch main https://github.com/unslothai/unsloth.git\n%cd /content/unsloth\n!chmod +x studio/setup.sh && ./studio/setup.sh"
+   "source": "!git clone --depth 1 --branch main https://github.com/unslothai/unsloth.git\n%cd /content/unsloth\n!chmod +x studio/setup.sh && ./studio/setup.sh --local"
   },
   {
    "cell_type": "markdown",
diff --git a/studio/backend/auth/storage.py b/studio/backend/auth/storage.py
index 2b0e359d39..9a03f5f542 100644
--- a/studio/backend/auth/storage.py
+++ b/studio/backend/auth/storage.py
@@ -146,10 +146,18 @@ def get_connection() -> sqlite3.Connection:
             created_at TEXT NOT NULL,
             last_used_at TEXT,
             expires_at TEXT,
-            is_active  INTEGER NOT NULL DEFAULT 1
+            is_active  INTEGER NOT NULL DEFAULT 1,
+            is_internal INTEGER NOT NULL DEFAULT 0
         );
         """
     )
+    api_key_columns = {
+        row["name"] for row in conn.execute("PRAGMA table_info(api_keys)")
+    }
+    if "is_internal" not in api_key_columns:
+        conn.execute(
+            "ALTER TABLE api_keys ADD COLUMN is_internal INTEGER NOT NULL DEFAULT 0"
+        )
     conn.execute(
         """
         CREATE TABLE IF NOT EXISTS app_secrets (
@@ -592,11 +600,15 @@ def create_api_key(
     username: str,
     name: str,
     expires_at: Optional[str] = None,
+    internal: bool = False,
 ) -> Tuple[str, dict]:
     """Create a new API key for *username*.
 
     Returns ``(raw_key, row_dict)`` where *raw_key* is shown to the user
-    exactly once.  The database only stores the SHA-256 hash.
+    exactly once.  The database only stores the PBKDF2 hash.
+
+    Pass ``internal=True`` for keys minted by workflows (e.g. data-recipe
+    runs) that should not appear in user-facing key listings.
     """
     raw_key = API_KEY_PREFIX + secrets.token_hex(16)
     key_hash = _pbkdf2_api_key(raw_key)
@@ -607,10 +619,18 @@ def create_api_key(
     try:
         conn.execute(
             """
-            INSERT INTO api_keys (username, key_prefix, key_hash, name, created_at, expires_at)
-            VALUES (?, ?, ?, ?, ?, ?)
+            INSERT INTO api_keys (username, key_prefix, key_hash, name, created_at, expires_at, is_internal)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
             """,
-            (username, key_prefix, key_hash, name, now, expires_at),
+            (
+                username,
+                key_prefix,
+                key_hash,
+                name,
+                now,
+                expires_at,
+                1 if internal else 0,
+            ),
         )
         conn.commit()
         cur = conn.execute("SELECT * FROM api_keys WHERE key_hash = ?", (key_hash,))
@@ -620,19 +640,33 @@ def create_api_key(
         conn.close()
 
 
-def list_api_keys(username: str) -> list:
-    """Return all API keys for *username* (never exposes ``key_hash``)."""
+def list_api_keys(username: str, include_internal: bool = False) -> list:
+    """Return API keys for *username*. Internal workflow keys are hidden
+    by default so they do not clutter user-facing UIs."""
     conn = get_connection()
     try:
-        cur = conn.execute(
-            """
-            SELECT id, username, key_prefix, name, created_at, last_used_at, expires_at, is_active
-            FROM api_keys
-            WHERE username = ?
-            ORDER BY created_at DESC
-            """,
-            (username,),
-        )
+        if include_internal:
+            cur = conn.execute(
+                """
+                SELECT id, username, key_prefix, name, created_at, last_used_at,
+                       expires_at, is_active, is_internal
+                FROM api_keys
+                WHERE username = ?
+                ORDER BY created_at DESC
+                """,
+                (username,),
+            )
+        else:
+            cur = conn.execute(
+                """
+                SELECT id, username, key_prefix, name, created_at, last_used_at,
+                       expires_at, is_active, is_internal
+                FROM api_keys
+                WHERE username = ? AND is_internal = 0
+                ORDER BY created_at DESC
+                """,
+                (username,),
+            )
         return [dict(row) for row in cur.fetchall()]
     finally:
         conn.close()
@@ -652,6 +686,24 @@ def revoke_api_key(username: str, key_id: int) -> bool:
         conn.close()
 
 
+def revoke_internal_api_key(key_id: int) -> bool:
+    """Revoke an internal workflow-minted key without requiring a username.
+
+    Used by the recipe runner to retire its sk-unsloth-* key once the job
+    terminates, shrinking the window a leaked key could be abused.
+    """
+    conn = get_connection()
+    try:
+        cursor = conn.execute(
+            "UPDATE api_keys SET is_active = 0 WHERE id = ? AND is_internal = 1",
+            (key_id,),
+        )
+        conn.commit()
+        return cursor.rowcount > 0
+    finally:
+        conn.close()
+
+
 def validate_api_key(raw_key: str) -> Optional[str]:
     """Validate *raw_key* and return the owning username, or ``None``.
 
diff --git a/studio/backend/core/data_recipe/jobs/constants.py b/studio/backend/core/data_recipe/jobs/constants.py
index 08237326f8..0045276e20 100644
--- a/studio/backend/core/data_recipe/jobs/constants.py
+++ b/studio/backend/core/data_recipe/jobs/constants.py
@@ -9,6 +9,7 @@ STAGE_PREVIEW = "preview"
 STAGE_DAG = "dag"
 STAGE_HEALTHCHECK = "healthcheck"
 STAGE_SAMPLING = "sampling"
+STAGE_SOURCE = "source"
 STAGE_COLUMN_CONFIG = "column_config"
 STAGE_GENERATING = "generating"
 STAGE_BATCH = "batch"
diff --git a/studio/backend/core/data_recipe/jobs/manager.py b/studio/backend/core/data_recipe/jobs/manager.py
index 3d7cf2dbe6..cdc28d9560 100644
--- a/studio/backend/core/data_recipe/jobs/manager.py
+++ b/studio/backend/core/data_recipe/jobs/manager.py
@@ -33,6 +33,60 @@ from .worker import run_job_process
 _CTX = mp.get_context("spawn")
 
 
+def _github_source_estimated_total(recipe: dict) -> int | None:
+    seed_config = recipe.get("seed_config")
+    if not isinstance(seed_config, dict):
+        return None
+    source = seed_config.get("source")
+    if not isinstance(source, dict) or source.get("seed_type") != "github_repo":
+        return None
+
+    repos_raw = source.get("repos")
+    repos = (
+        [repo for repo in repos_raw if isinstance(repo, str) and repo.strip()]
+        if isinstance(repos_raw, list)
+        else []
+    )
+    item_types_raw = source.get("item_types")
+    item_types = (
+        [
+            item
+            for item in item_types_raw
+            if isinstance(item, str) and item in {"issues", "pulls", "commits"}
+        ]
+        if isinstance(item_types_raw, list)
+        else []
+    )
+    try:
+        limit = int(source.get("limit") or 0)
+    except (TypeError, ValueError):
+        return None
+    if not repos or not item_types or limit <= 0:
+        return None
+    return len(repos) * len(item_types) * limit
+
+
+def _source_progress_status(job: Job) -> dict[str, Any] | None:
+    progress = job.source_progress
+    if progress is None:
+        return None
+    return {
+        "source": progress.source,
+        "status": progress.status,
+        "repo": progress.repo,
+        "resource": progress.resource,
+        "page": progress.page,
+        "page_items": progress.page_items,
+        "fetched_items": progress.fetched_items,
+        "estimated_total": progress.estimated_total,
+        "percent": progress.percent,
+        "rate_remaining": progress.rate_remaining,
+        "retry_after_sec": progress.retry_after_sec,
+        "message": progress.message,
+        "updated_at": progress.updated_at,
+    }
+
+
 @dataclass
 class Subscription:
     replay: list[dict]
@@ -71,8 +125,20 @@ class JobManager:
         self._pump_thread: threading.Thread | None = None
         self._seq: int = 0
 
-    def start(self, *, recipe: dict, run: dict) -> str:
-        """Spawn the job subprocess (one at a time, no cap)."""
+    def start(
+        self,
+        *,
+        recipe: dict,
+        run: dict,
+        internal_api_key_id: int | None = None,
+    ) -> str:
+        """Spawn the job subprocess (one at a time, no cap).
+
+        ``internal_api_key_id`` is the row id of a workflow-scoped
+        sk-unsloth-* key minted by the route layer for local providers.
+        JobManager revokes it when the job reaches a terminal state so the
+        key's live window is no longer than the run.
+        """
         llm_columns = recipe.get("columns") or []
         llm_column_count = 0
         if isinstance(llm_columns, list):
@@ -92,18 +158,29 @@ class JobManager:
             job_id = uuid.uuid4().hex
             self._job = Job(job_id = job_id, status = "pending", started_at = time.time())
             self._job.progress_columns_total = llm_column_count
+            self._job.source_progress_estimated_total = _github_source_estimated_total(
+                recipe
+            )
+            self._job.internal_api_key_id = internal_api_key_id
             self._events.clear()
             self._seq = 0
 
             run_payload = dict(run)
             run_payload["_job_id"] = job_id
-            mp_q = _CTX.Queue()
-            proc = _CTX.Process(
-                target = run_job_process,
-                kwargs = {"event_queue": mp_q, "recipe": recipe, "run": run_payload},
-                daemon = True,
+            from utils.native_path_leases import (
+                native_path_secret_removed_for_child_start,
+                run_without_native_path_secret,
             )
-            proc.start()
+
+            with native_path_secret_removed_for_child_start():
+                mp_q = _CTX.Queue()
+                proc = _CTX.Process(
+                    target = run_without_native_path_secret,
+                    args = (run_job_process,),
+                    kwargs = {"event_queue": mp_q, "recipe": recipe, "run": run_payload},
+                    daemon = True,
+                )
+                proc.start()
 
             self._mp_q = mp_q
             self._proc = proc
@@ -163,6 +240,7 @@ class JobManager:
                     "ok": job.column_progress.ok,
                     "failed": job.column_progress.failed,
                 },
+                "source_progress": _source_progress_status(job),
                 "model_usage": {
                     name: {
                         "model": usage.model,
@@ -405,6 +483,7 @@ class JobManager:
             for e in self._drain_queue(mp_q):
                 self._handle_event(job, e)
 
+            retired_job: Job | None = None
             with self._lock:
                 if self._job and self._job.status in {
                     "pending",
@@ -429,6 +508,9 @@ class JobManager:
                             "job_id": self._job.job_id,
                         }
                     )
+                    retired_job = self._job
+            if retired_job is not None:
+                self._retire_workflow_key(retired_job)
             return
 
     def _handle_event(self, job: Job, event: dict) -> None:
@@ -436,6 +518,7 @@ class JobManager:
         et = event.get("type")
         msg = event.get("message") if et == "log" else None
 
+        terminal = False
         with self._lock:
             if self._job is None or self._job.job_id != job.job_id:
                 return
@@ -452,18 +535,43 @@ class JobManager:
                 if self._job.progress.total and self._job.progress.total > 0:
                     self._job.progress.done = self._job.progress.total
                     self._job.progress.percent = 100.0
+                terminal = True
             if et == EVENT_JOB_ERROR:
                 self._job.status = "error"
                 self._job.finished_at = time.time()
                 self._job.error = event.get("error") or "error"
+                terminal = True
+            if et == EVENT_JOB_CANCELLED:
+                terminal = True
 
             if msg:
                 upd = parse_log_message(msg)
                 if upd:
                     apply_update(self._job, upd)
 
+        if terminal:
+            self._retire_workflow_key(job)
+
         self._emit(event)
 
+    def _retire_workflow_key(self, job: Job) -> None:
+        """Revoke the workflow-scoped sk-unsloth-* key, if one was minted.
+
+        Best-effort: revocation failures are swallowed. The key would
+        expire on its own after 24h, so a missed revoke is a latency
+        concern, not a correctness one.
+        """
+        key_id = getattr(job, "internal_api_key_id", None)
+        if not key_id:
+            return
+        try:
+            from auth import storage  # deferred: avoids circular import
+
+            storage.revoke_internal_api_key(int(key_id))
+        except Exception:
+            pass
+        job.internal_api_key_id = None
+
 
 _JOB_MANAGER: JobManager | None = None
 
diff --git a/studio/backend/core/data_recipe/jobs/parse.py b/studio/backend/core/data_recipe/jobs/parse.py
index 324b62a92e..cea6d8ea64 100644
--- a/studio/backend/core/data_recipe/jobs/parse.py
+++ b/studio/backend/core/data_recipe/jobs/parse.py
@@ -4,6 +4,7 @@
 from __future__ import annotations
 
 import re
+import time
 from dataclasses import dataclass
 from typing import Any
 
@@ -17,9 +18,10 @@ from .constants import (
     STAGE_PREVIEW,
     STAGE_PROFILING,
     STAGE_SAMPLING,
+    STAGE_SOURCE,
     USAGE_RESET_STAGES,
 )
-from .types import Job, ModelUsage, Progress
+from .types import Job, ModelUsage, Progress, SourceProgress
 
 
 @dataclass(frozen = True)
@@ -41,6 +43,7 @@ class ParsedUpdate:
     usage_requests_total: int | None = None
     usage_rpm: float | None = None
     usage_section_start: bool | None = None
+    source_progress: SourceProgress | None = None
 
 
 # kinda of a bummber but currently only option, Best effort parser from data-designer logs -> structured status for UI.
@@ -61,9 +64,165 @@ _RE_USAGE_TOKENS = re.compile(
 _RE_USAGE_REQUESTS = re.compile(
     r"requests:\s*success=(?P<success>\d+),\s*failed=(?P<failed>\d+),\s*total=(?P<total>\d+),\s*rpm=(?P<rpm>[0-9.]+)"
 )
+_RE_GITHUB_PAGE = re.compile(
+    r"^\[(?P<repo>[^\]\s]+/[^\]\s]+)\]\s+"
+    r"(?P<resource>issues|PRs|commits)\s+page\s+(?P<page>\d+)\s+"
+    r"\(\+(?P<items>\d+)\).*?\bremaining=(?P<remaining>\d+)",
+    re.IGNORECASE,
+)
+_RE_GITHUB_RATE_LIMIT = re.compile(
+    r"Rate limit hit\. Sleeping (?P<seconds>\d+)s until reset\.",
+    re.IGNORECASE,
+)
+_RE_GITHUB_SECONDARY_RATE_LIMIT = re.compile(
+    r"Secondary rate limit(?: on REST)?\. Sleep (?P<seconds>\d+)s\.",
+    re.IGNORECASE,
+)
+_RE_GITHUB_REST_RATE_LIMIT = re.compile(
+    r"REST 403/429, sleep (?P<seconds>\d+)",
+    re.IGNORECASE,
+)
+_RE_GITHUB_TRANSIENT = re.compile(
+    r"^(?P<api>GraphQL|REST) (?P<code>\d{3}) transient, retrying",
+    re.IGNORECASE,
+)
+_RE_GITHUB_NETWORK_RETRY = re.compile(
+    r"^(?P<api>GraphQL|REST) network error: .* Retry\.",
+    re.IGNORECASE,
+)
+_RE_GITHUB_TRIAL_LIMIT = re.compile(
+    r"Trial limit reached for (?P<resource>issues|PRs|commits) \((?P<items>\d+)\)",
+    re.IGNORECASE,
+)
+_RE_GITHUB_COMPLETE = re.compile(
+    r"Scraper complete\. GraphQL calls=\d+ REST calls=\d+",
+    re.IGNORECASE,
+)
 
 
 def parse_log_message(msg: str) -> ParsedUpdate | None:
+    m = _RE_GITHUB_PAGE.search(msg)
+    if m:
+        resource_raw = m.group("resource")
+        resource = "pulls" if resource_raw.lower() == "prs" else resource_raw.lower()
+        repo = m.group("repo")
+        page = int(m.group("page"))
+        page_items = int(m.group("items"))
+        return ParsedUpdate(
+            stage = STAGE_SOURCE,
+            source_progress = SourceProgress(
+                source = "github",
+                status = "fetching",
+                repo = repo,
+                resource = resource,
+                page = page,
+                page_items = page_items,
+                rate_remaining = int(m.group("remaining")),
+                message = (
+                    f"Scraping GitHub source: {repo} "
+                    f"{resource} page {page} (+{page_items})"
+                ),
+            ),
+        )
+
+    m = _RE_GITHUB_RATE_LIMIT.search(msg)
+    if m:
+        seconds = int(m.group("seconds"))
+        return ParsedUpdate(
+            stage = STAGE_SOURCE,
+            source_progress = SourceProgress(
+                source = "github",
+                status = "rate_limited",
+                retry_after_sec = seconds,
+                message = (
+                    "Waiting for GitHub rate limit. "
+                    "Studio will resume automatically."
+                ),
+            ),
+        )
+
+    m = _RE_GITHUB_SECONDARY_RATE_LIMIT.search(msg)
+    if m:
+        seconds = int(m.group("seconds"))
+        return ParsedUpdate(
+            stage = STAGE_SOURCE,
+            source_progress = SourceProgress(
+                source = "github",
+                status = "rate_limited",
+                retry_after_sec = seconds,
+                message = (
+                    "Waiting for GitHub secondary rate limit. "
+                    "Studio will resume automatically."
+                ),
+            ),
+        )
+
+    m = _RE_GITHUB_REST_RATE_LIMIT.search(msg)
+    if m:
+        seconds = int(m.group("seconds"))
+        return ParsedUpdate(
+            stage = STAGE_SOURCE,
+            source_progress = SourceProgress(
+                source = "github",
+                status = "rate_limited",
+                retry_after_sec = seconds,
+                message = (
+                    "Waiting for GitHub rate limit. "
+                    "Studio will resume automatically."
+                ),
+            ),
+        )
+
+    m = _RE_GITHUB_TRIAL_LIMIT.search(msg)
+    if m:
+        resource_raw = m.group("resource")
+        resource = "pulls" if resource_raw.lower() == "prs" else resource_raw.lower()
+        items = int(m.group("items"))
+        return ParsedUpdate(
+            stage = STAGE_SOURCE,
+            source_progress = SourceProgress(
+                source = "github",
+                status = "fetching",
+                resource = resource,
+                message = f"GitHub {resource} trial limit reached ({items}).",
+            ),
+        )
+
+    m = _RE_GITHUB_TRANSIENT.search(msg)
+    if m:
+        api = m.group("api")
+        code = m.group("code")
+        return ParsedUpdate(
+            stage = STAGE_SOURCE,
+            source_progress = SourceProgress(
+                source = "github",
+                status = "retrying",
+                message = f"GitHub {api} returned {code}; retrying automatically.",
+            ),
+        )
+
+    m = _RE_GITHUB_NETWORK_RETRY.search(msg)
+    if m:
+        api = m.group("api")
+        return ParsedUpdate(
+            stage = STAGE_SOURCE,
+            source_progress = SourceProgress(
+                source = "github",
+                status = "retrying",
+                message = f"GitHub {api} request failed; retrying automatically.",
+            ),
+        )
+
+    if _RE_GITHUB_COMPLETE.search(msg):
+        return ParsedUpdate(
+            stage = STAGE_SOURCE,
+            source_progress = SourceProgress(
+                source = "github",
+                status = "completed",
+                message = "GitHub source scrape complete.",
+            ),
+        )
+
     m = _RE_SAMPLERS.search(msg)
     if m:
         return ParsedUpdate(
@@ -172,6 +331,8 @@ def apply_update(job: Job, update: ParsedUpdate) -> None:
         job.batch.idx = update.batch_idx
     if update.batch_total is not None:
         job.batch.total = update.batch_total
+    if update.source_progress is not None:
+        _apply_source_progress(job, update.source_progress)
 
     if update.stage in USAGE_RESET_STAGES:
         # usage summary is a short block so we reset once we move into the next stage.
@@ -216,6 +377,67 @@ def apply_update(job: Job, update: ParsedUpdate) -> None:
         usage.rpm = update.usage_rpm
 
 
+def _apply_source_progress(job: Job, progress: SourceProgress) -> None:
+    previous = job.source_progress
+    now = time.time()
+
+    page_items = progress.page_items
+    if progress.repo and progress.resource and progress.page is not None:
+        page_key = f"{progress.repo}:{progress.resource}:{progress.page}"
+        count_key = f"{progress.repo}:{progress.resource}"
+        if page_key not in job._source_seen_pages:
+            job._source_seen_pages.add(page_key)
+            job._source_counts[count_key] = int(
+                job._source_counts.get(count_key, 0)
+            ) + int(page_items or 0)
+
+    fetched_items = sum(job._source_counts.values())
+    if fetched_items <= 0:
+        fetched_items = progress.fetched_items or (
+            previous.fetched_items if previous else None
+        )
+
+    estimated_total = (
+        progress.estimated_total
+        or job.source_progress_estimated_total
+        or (previous.estimated_total if previous else None)
+    )
+    percent: float | None = progress.percent
+    if percent is None and estimated_total and fetched_items is not None:
+        raw_percent = (float(fetched_items) / float(max(1, estimated_total))) * 100.0
+        percent = 100.0 if progress.status == "completed" else min(99.0, raw_percent)
+    if percent is None and previous is not None:
+        percent = previous.percent
+
+    job.source_progress = SourceProgress(
+        source = "github",
+        status = progress.status or (previous.status if previous else None),
+        repo = progress.repo or (previous.repo if previous else None),
+        resource = progress.resource or (previous.resource if previous else None),
+        page = (
+            progress.page
+            if progress.page is not None
+            else (previous.page if previous else None)
+        ),
+        page_items = (
+            page_items
+            if page_items is not None
+            else (previous.page_items if previous else None)
+        ),
+        fetched_items = fetched_items,
+        estimated_total = estimated_total,
+        percent = percent,
+        rate_remaining = (
+            progress.rate_remaining
+            if progress.rate_remaining is not None
+            else (previous.rate_remaining if previous else None)
+        ),
+        retry_after_sec = progress.retry_after_sec,
+        message = progress.message or (previous.message if previous else None),
+        updated_at = now,
+    )
+
+
 def _compute_overall_progress(job: Job, column_progress: Progress) -> Progress:
     if not job.rows:
         return column_progress
diff --git a/studio/backend/core/data_recipe/jobs/types.py b/studio/backend/core/data_recipe/jobs/types.py
index 8d77903238..3d3ddb974e 100644
--- a/studio/backend/core/data_recipe/jobs/types.py
+++ b/studio/backend/core/data_recipe/jobs/types.py
@@ -35,6 +35,23 @@ class BatchProgress:
     total: int | None = None
 
 
+@dataclass
+class SourceProgress:
+    source: str = "github"
+    status: str | None = None
+    repo: str | None = None
+    resource: str | None = None
+    page: int | None = None
+    page_items: int | None = None
+    fetched_items: int | None = None
+    estimated_total: int | None = None
+    percent: float | None = None
+    rate_remaining: int | None = None
+    retry_after_sec: int | None = None
+    message: str | None = None
+    updated_at: float | None = None
+
+
 @dataclass
 class ModelUsage:
     model: str
@@ -57,6 +74,7 @@ class Job:
     progress: Progress = field(default_factory = Progress)
     column_progress: Progress = field(default_factory = Progress)
     batch: BatchProgress = field(default_factory = BatchProgress)
+    source_progress: SourceProgress | None = None
     rows: int | None = None
     cols: int | None = None
     error: str | None = None
@@ -70,8 +88,15 @@ class Job:
     processor_artifacts: dict[str, Any] | None = None
     model_usage: dict[str, ModelUsage] = field(default_factory = dict)
     progress_columns_total: int | None = None
+    source_progress_estimated_total: int | None = None
     completed_columns: list[str] = field(default_factory = list)
+    # Id of the internal sk-unsloth-* API key minted for a local-model
+    # workflow. Revoked when the job terminates so the key's live window
+    # matches the run rather than its 24h TTL.
+    internal_api_key_id: int | None = None
     _current_usage_model: str | None = None
     _in_usage_summary: bool = False
     _seen_generation_columns: list[str] = field(default_factory = list)
     _column_done: dict[str, int] = field(default_factory = dict)
+    _source_counts: dict[str, int] = field(default_factory = dict)
+    _source_seen_pages: set[str] = field(default_factory = set)
diff --git a/studio/backend/core/data_recipe/jobs/worker.py b/studio/backend/core/data_recipe/jobs/worker.py
index 63e38bd18d..8c5c7fe657 100644
--- a/studio/backend/core/data_recipe/jobs/worker.py
+++ b/studio/backend/core/data_recipe/jobs/worker.py
@@ -21,6 +21,15 @@ from ..service import build_config_builder, create_data_designer
 from utils.paths import ensure_dir, recipe_datasets_root
 
 _ARTIFACT_ROOT = recipe_datasets_root()
+_RE_GITHUB_CURSOR = re.compile(r"\bcursor=[^\s,]+")
+_RE_SECRET_TOKEN = re.compile(
+    r"\b(?:(?:ghp|gho|ghu|ghs|ghr|github_pat)_[A-Za-z0-9_]+|sk-unsloth-[A-Za-z0-9]+)"
+)
+
+
+def _sanitize_log_message(message: str) -> str:
+    message = _RE_GITHUB_CURSOR.sub("cursor=<redacted>", message)
+    return _RE_SECRET_TOKEN.sub("<redacted-token>", message)
 
 
 class _QueueLogHandler(logging.Handler):
@@ -35,7 +44,7 @@ class _QueueLogHandler(logging.Handler):
                 "ts": record.created,
                 "level": record.levelname,
                 "logger": record.name,
-                "message": record.getMessage(),
+                "message": _sanitize_log_message(record.getMessage()),
             }
             self._q.put(event)
         except (OSError, RuntimeError, ValueError):
@@ -119,10 +128,16 @@ def run_job_process(
         # Attach queue logger directly to `data_designer` so parser events survive root resets.
         handler = _QueueLogHandler(event_queue)
         handler.setLevel(logging.INFO)
-        data_designer_logger = logging.getLogger("data_designer")
-        data_designer_logger.addHandler(handler)
-        data_designer_logger.setLevel(logging.INFO)
-        data_designer_logger.propagate = True
+        for logger_name in (
+            "data_designer",
+            "scraper",
+            "gh_client",
+            "data_designer_github_repo_seed",
+        ):
+            logger = logging.getLogger(logger_name)
+            logger.addHandler(handler)
+            logger.setLevel(logging.INFO)
+            logger.propagate = True
 
         if run_config_raw:
             designer.set_run_config(RunConfig.model_validate(run_config_raw))
@@ -180,8 +195,8 @@ def run_job_process(
             {
                 "type": EVENT_JOB_ERROR,
                 "ts": time.time(),
-                "error": str(exc),
-                "stack": traceback.format_exc(limit = 20),
+                "error": _sanitize_log_message(str(exc)),
+                "stack": _sanitize_log_message(traceback.format_exc(limit = 20)),
             }
         )
 
diff --git a/studio/backend/core/data_recipe/local_callable_validators.py b/studio/backend/core/data_recipe/local_callable_validators.py
index afd10b02d1..44459e88c5 100644
--- a/studio/backend/core/data_recipe/local_callable_validators.py
+++ b/studio/backend/core/data_recipe/local_callable_validators.py
@@ -33,6 +33,7 @@ _OXC_TOOL_DIR = Path(__file__).resolve().parent / "oxc-validator"
 _OXC_RUNNER_PATH = _OXC_TOOL_DIR / "validate.mjs"
 
 
+from utils.native_path_leases import child_env_without_native_path_secret
 from utils.subprocess_compat import (
     windows_hidden_subprocess_kwargs as _windows_hidden_subprocess_kwargs,
 )
@@ -248,7 +249,7 @@ def _run_oxc_batch(
     }
     try:
         tmp_dir = ensure_dir(oxc_validator_tmp_root())
-        env = dict(os.environ)
+        env = child_env_without_native_path_secret()
         tmp_dir_str = str(tmp_dir)
         env["TMPDIR"] = tmp_dir_str
         env["TMP"] = tmp_dir_str
diff --git a/studio/backend/core/export/export.py b/studio/backend/core/export/export.py
index d8f2e8fa37..6fee5a38f7 100644
--- a/studio/backend/core/export/export.py
+++ b/studio/backend/core/export/export.py
@@ -28,6 +28,8 @@ from core.inference import get_inference_backend
 
 logger = get_logger(__name__)
 
+_LLAMA_CPP_SCRIPTS_WARNING_EMITTED = False
+
 
 def _is_wsl():
     """Detect if running under Windows Subsystem for Linux."""
@@ -529,6 +531,31 @@ class ExportBackend:
             # Convert quantization method to lowercase for unsloth
             quant_method = quantization_method.lower()
 
+            # Pin convert_hf_to_gguf.py to the same llama.cpp ref as the
+            # llama-quantize binary (Studio installs at a tagged ref via
+            # setup.sh) so it can't drift past the pinned binary's gguf API.
+            # Set before both branches; hub-only export has save_directory == "".
+            global _LLAMA_CPP_SCRIPTS_WARNING_EMITTED
+            try:
+                from unsloth_zoo.llama_cpp import (
+                    LLAMA_CPP_DEFAULT_DIR,
+                    _resolve_local_convert_script,  # noqa: F401
+                )
+
+                os.environ.setdefault(
+                    "UNSLOTH_LLAMA_CPP_SCRIPTS_DIR", LLAMA_CPP_DEFAULT_DIR
+                )
+            except ImportError:
+                if not _LLAMA_CPP_SCRIPTS_WARNING_EMITTED:
+                    logger.warning(
+                        "Unsloth: installed unsloth_zoo does not honor "
+                        "UNSLOTH_LLAMA_CPP_SCRIPTS_DIR; convert_hf_to_gguf.py will "
+                        "still be downloaded from llama.cpp master and may drift "
+                        "past the pinned llama-quantize binary. Upgrade unsloth_zoo "
+                        "to activate the local script pin."
+                    )
+                    _LLAMA_CPP_SCRIPTS_WARNING_EMITTED = True
+
             # Save locally if requested
             if save_directory:
                 save_directory = str(resolve_export_dir(save_directory))
diff --git a/studio/backend/core/export/orchestrator.py b/studio/backend/core/export/orchestrator.py
index 206dbd6dbb..82de925592 100644
--- a/studio/backend/core/export/orchestrator.py
+++ b/studio/backend/core/export/orchestrator.py
@@ -163,21 +163,28 @@ class ExportOrchestrator:
 
     def _spawn_subprocess(self, config: dict) -> None:
         """Spawn a new export subprocess."""
+        from utils.native_path_leases import (
+            native_path_secret_removed_for_child_start,
+            run_without_native_path_secret,
+        )
+
         from .worker import run_export_process
 
-        self._cmd_queue = _CTX.Queue()
-        self._resp_queue = _CTX.Queue()
+        with native_path_secret_removed_for_child_start():
+            self._cmd_queue = _CTX.Queue()
+            self._resp_queue = _CTX.Queue()
 
-        self._proc = _CTX.Process(
-            target = run_export_process,
-            kwargs = {
-                "cmd_queue": self._cmd_queue,
-                "resp_queue": self._resp_queue,
-                "config": config,
-            },
-            daemon = True,
-        )
-        self._proc.start()
+            self._proc = _CTX.Process(
+                target = run_without_native_path_secret,
+                args = (run_export_process,),
+                kwargs = {
+                    "cmd_queue": self._cmd_queue,
+                    "resp_queue": self._resp_queue,
+                    "config": config,
+                },
+                daemon = True,
+            )
+            self._proc.start()
         logger.info("Export subprocess started (pid=%s)", self._proc.pid)
 
     def _shutdown_subprocess(self, timeout: float = 10.0) -> None:
diff --git a/studio/backend/core/inference/audio_codecs.py b/studio/backend/core/inference/audio_codecs.py
index 895b112e85..df3bf27c16 100644
--- a/studio/backend/core/inference/audio_codecs.py
+++ b/studio/backend/core/inference/audio_codecs.py
@@ -17,6 +17,7 @@ from typing import Optional, Tuple
 import numpy as np
 import torch
 
+from utils.native_path_leases import child_env_without_native_path_secret
 from utils.subprocess_compat import (
     windows_hidden_subprocess_kwargs as _windows_hidden_subprocess_kwargs,
 )
@@ -105,6 +106,7 @@ class AudioCodecManager:
                     spark_code_dir,
                 ],
                 check = True,
+                env = child_env_without_native_path_secret(),
                 **_windows_hidden_subprocess_kwargs(),
             )
 
@@ -143,6 +145,7 @@ class AudioCodecManager:
                     outetts_code_dir,
                 ],
                 check = True,
+                env = child_env_without_native_path_secret(),
                 **_windows_hidden_subprocess_kwargs(),
             )
             # Remove files that pull in heavy / incompatible dependencies
diff --git a/studio/backend/core/inference/llama_cpp.py b/studio/backend/core/inference/llama_cpp.py
index c320f03b2c..f768764c22 100644
--- a/studio/backend/core/inference/llama_cpp.py
+++ b/studio/backend/core/inference/llama_cpp.py
@@ -11,6 +11,7 @@ through its OpenAI-compatible /v1/chat/completions endpoint.
 import atexit
 import contextlib
 import json
+import os
 import re
 import struct
 import structlog
@@ -22,11 +23,12 @@ import sys
 import threading
 import time
 from pathlib import Path
-from typing import Generator, Optional
+from typing import Generator, List, Optional
 from urllib.parse import urlparse
 
 import httpx
 
+from utils.native_path_leases import child_env_without_native_path_secret
 from utils.subprocess_compat import (
     windows_hidden_subprocess_kwargs as _windows_hidden_subprocess_kwargs,
 )
@@ -53,6 +55,21 @@ _INTENT_SIGNAL = re.compile(
     r")"
 )
 _MAX_REPROMPTS = 3
+
+# Without max_tokens, llama-server defaults to n_predict = n_ctx (up to
+# 262144 for Qwen3.5), producing many-minute zombie decodes when cancel
+# fails. t_max_predict_ms is a wall-clock backstop applied unconditionally,
+# but the llama.cpp README notes it ONLY fires after a newline has been
+# generated -- a model stuck in a long unbroken non-newline sequence is
+# unbounded by it. So we still want a token cap as the front-line limiter.
+#
+# The cap is the model's effective context length when we know it,
+# falling back to a generous floor when metadata is unavailable. 4096 was
+# too low: Qwen3 / gpt-oss reasoning traces routinely exceed it, and any
+# OpenAI-API caller that omits max_tokens (langchain, llama-index, raw
+# curl) sees responses silently truncated mid-sentence.
+_DEFAULT_MAX_TOKENS_FLOOR = 32768
+_DEFAULT_T_MAX_PREDICT_MS = 600_000  # 10 min
 _REPROMPT_MAX_CHARS = 2000
 
 # ── Pre-compiled patterns for GGUF shard detection ───────────
@@ -60,6 +77,238 @@ _SHARD_FULL_RE = re.compile(r"^(.*)-(\d{5})-of-(\d{5})\.gguf$")
 _SHARD_RE = re.compile(r"^(.*)-\d{5}-of-\d{5}\.gguf$")
 
 
+# ── Sliding-window-pattern resolver ───────────────────────────
+# Resolves the per-layer SWA mask when a GGUF reports a sliding window
+# but no `sliding_window_pattern` field. Tier order in
+# `_resolve_swa_pattern`: GGUF metadata, on-disk cache, bootstrap dict
+# below, transformers introspection, HF Hub config.json, legacy 1/4
+# fallback. Period N means layer i is SWA iff `(i + 1) % N != 0`,
+# matching transformers. Skipped on purpose: phi3 (no key/val length
+# in GGUF, window >= ctx anyway), qwen2 family (converter strips
+# sliding_window when use_sliding_window=False), mistral v0.1/v0.2
+# (all-SWA can't be expressed as a period).
+_BOOTSTRAP_SWA_DEFAULTS: dict[str, int] = {
+    "gemma2": 2,  # Gemma2Config.sliding_window_pattern
+    "gemma3": 6,  # Gemma3TextConfig.sliding_window_pattern
+    "gemma3n": 5,  # text_config.layer_types: SWA*4 + FULL
+    "gpt_oss": 2,  # text_config.layer_types: alternating
+    "cohere2": 4,  # Cohere2Config.sliding_window_pattern
+}
+
+# Process-wide cache backed by JSON on disk. Values are int period or
+# list[bool] mask. Lazy-loaded.
+_SWA_CACHE: Optional[dict] = None
+_SWA_CACHE_LOCK = threading.Lock()
+
+
+def _swa_cache_path() -> Path:
+    home = os.environ.get("UNSLOTH_STUDIO_HOME") or os.environ.get("STUDIO_HOME")
+    base = Path(home) if home else Path.home() / ".unsloth" / "studio"
+    return base / "swa_cache.json"
+
+
+def _load_swa_cache() -> dict:
+    global _SWA_CACHE
+    with _SWA_CACHE_LOCK:
+        if _SWA_CACHE is not None:
+            return _SWA_CACHE
+        try:
+            with open(_swa_cache_path()) as f:
+                _SWA_CACHE = json.load(f)
+                if not isinstance(_SWA_CACHE, dict):
+                    _SWA_CACHE = {}
+        except (FileNotFoundError, json.JSONDecodeError, OSError):
+            _SWA_CACHE = {}
+        return _SWA_CACHE
+
+
+def _save_swa_cache(cache: dict) -> None:
+    try:
+        path = _swa_cache_path()
+        path.parent.mkdir(parents = True, exist_ok = True)
+        tmp = path.with_suffix(".json.tmp")
+        with open(tmp, "w") as f:
+            json.dump(cache, f, indent = 2, sort_keys = True)
+        tmp.replace(path)
+    except OSError:
+        pass
+
+
+def _period_from_layer_types(layer_types: list) -> Optional[int]:
+    """Smallest period N where `(i+1) % N != 0` matches the SWA mask,
+    or None if no fixed period fits."""
+    if not layer_types:
+        return None
+    is_swa = ["full" not in str(t).lower() for t in layer_types]
+    n = len(is_swa)
+    for N in range(1, n + 1):
+        if all(((i + 1) % N != 0) == is_swa[i] for i in range(n)):
+            return N
+    return None
+
+
+def _fetch_swa_entry_from_hf(repo_id: str) -> Optional[object]:
+    try:
+        from huggingface_hub import hf_hub_download
+
+        cfg_path = hf_hub_download(repo_id, "config.json", repo_type = "model")
+        with open(cfg_path) as f:
+            cfg = json.load(f)
+    except Exception:
+        return None
+
+    src = cfg.get("text_config") if isinstance(cfg.get("text_config"), dict) else cfg
+    period = src.get("sliding_window_pattern")
+    if isinstance(period, int) and period > 0:
+        return period
+    lt = src.get("layer_types")
+    if isinstance(lt, list) and lt:
+        return _period_from_layer_types(lt) or [
+            "full" not in str(t).lower() for t in lt
+        ]
+    return None
+
+
+def _arch_aliases(arch: str) -> tuple:
+    # GGUF emits `falcon-h1`; HF model_type is `falcon_h1`. Normalise both ways.
+    seen = []
+    for a in (arch, arch.replace("-", "_"), arch.replace("_", "-")):
+        if a and a not in seen:
+            seen.append(a)
+    return tuple(seen)
+
+
+def _swa_entry_from_config_obj(cfg) -> Optional[object]:
+    src = getattr(cfg, "text_config", None) or cfg
+    period = getattr(src, "sliding_window_pattern", None)
+    if isinstance(period, int) and period > 0:
+        return period
+    lt = getattr(src, "layer_types", None)
+    if isinstance(lt, list) and lt:
+        return _period_from_layer_types(lt) or [
+            "full" not in str(t).lower() for t in lt
+        ]
+    return None
+
+
+_SWA_PATTERN_SOURCE_RE = re.compile(
+    r"sliding_window_pattern\s*(?::\s*[\w\[\], ]*)?\s*=\s*(\d+)"
+)
+
+
+def _resolve_swa_entry_from_transformers(arch: str) -> Optional[object]:
+    """Default-instantiate the matching Config; on failure, regex-parse
+    its source for `sliding_window_pattern = N`."""
+    try:
+        from transformers.models.auto.configuration_auto import (
+            CONFIG_MAPPING,
+            CONFIG_MAPPING_NAMES,
+        )
+    except Exception:
+        return None
+
+    cfg_class = None
+    for alias in _arch_aliases(arch):
+        if alias in CONFIG_MAPPING_NAMES:
+            try:
+                cfg_class = CONFIG_MAPPING[alias]
+                break
+            except Exception:
+                cfg_class = None
+    if cfg_class is None:
+        return None
+
+    try:
+        if (entry := _swa_entry_from_config_obj(cfg_class())) is not None:
+            return entry
+    except Exception:
+        pass
+
+    import inspect
+
+    candidates = [cfg_class]
+    text_cfg_class = getattr(cfg_class, "sub_configs", {}).get("text_config")
+    if text_cfg_class is not None:
+        candidates.append(text_cfg_class)
+    for cls in candidates:
+        try:
+            src = inspect.getsource(cls)
+        except (OSError, TypeError):
+            continue
+        if m := _SWA_PATTERN_SOURCE_RE.search(src):
+            period = int(m.group(1))
+            if period > 0:
+                return period
+    return None
+
+
+def _resolve_swa_pattern(
+    arch: Optional[str],
+    n_layers: Optional[int],
+    source_repo_candidates: tuple = (),
+    *,
+    allow_network: Optional[bool] = None,
+) -> Optional[list]:
+    if not arch or not n_layers:
+        return None
+    if allow_network is None:
+        allow_network = os.environ.get("UNSLOTH_STUDIO_OFFLINE", "0") not in (
+            "1",
+            "true",
+            "True",
+            "yes",
+        )
+
+    cache = _load_swa_cache()
+
+    def _entry_to_mask(entry):
+        if isinstance(entry, int) and entry > 0:
+            return [(i + 1) % entry != 0 for i in range(n_layers)]
+        if isinstance(entry, list) and entry:
+            return [bool(entry[i % len(entry)]) for i in range(n_layers)]
+        return None
+
+    def _persist(entry):
+        with _SWA_CACHE_LOCK:
+            cache[arch] = entry
+        _save_swa_cache(cache)
+
+    if (entry := cache.get(arch)) is not None:
+        if (mask := _entry_to_mask(entry)) is not None:
+            return mask
+
+    if (entry := _BOOTSTRAP_SWA_DEFAULTS.get(arch)) is not None:
+        return _entry_to_mask(entry)
+
+    entry = _resolve_swa_entry_from_transformers(arch)
+    if entry is not None:
+        _persist(entry)
+        return _entry_to_mask(entry)
+
+    # Tier 3: live HF fetch (with persistent caching of the result)
+    if allow_network:
+        for repo_id in source_repo_candidates:
+            if not repo_id:
+                continue
+            entry = _fetch_swa_entry_from_hf(repo_id)
+            if entry is not None:
+                _persist(entry)
+                return _entry_to_mask(entry)
+
+    return None
+
+
+def _hf_repo_from_url(url: Optional[str]) -> Optional[str]:
+    """Strip `https://huggingface.co/owner/name(/...)` to `owner/name`."""
+    if not url or "huggingface.co/" not in url:
+        return None
+    tail = url.split("huggingface.co/", 1)[1].rstrip("/")
+    parts = tail.split("/")
+    if len(parts) < 2:
+        return None
+    return f"{parts[0]}/{parts[1]}"
+
+
 # Model size extraction — lazy import to avoid pulling in transformers
 # at module level.  See PR description for the full explanation.
 def _extract_model_size_b(model_id: str):
@@ -199,17 +448,24 @@ class LlamaCppBackend:
         # KV-cache estimation fields (populated by _read_gguf_metadata)
         self._n_layers: Optional[int] = None
         self._n_kv_heads: Optional[int] = None
+        self._n_kv_heads_by_layer: Optional[list[int]] = None
         self._n_heads: Optional[int] = None
         self._embedding_length: Optional[int] = None
-        # Architecture-aware KV fields (8 new fields for 5-path estimation)
+        # Architecture-aware KV fields for 5-path estimation
         self._kv_key_length: Optional[int] = None
         self._kv_value_length: Optional[int] = None
         self._sliding_window: Optional[int] = None
+        self._sliding_window_pattern: Optional[list[bool]] = None
         self._full_attention_interval: Optional[int] = None
         self._kv_lora_rank: Optional[int] = None
         self._key_length_mla: Optional[int] = None
+        self._kv_key_length_swa: Optional[int] = None
+        self._kv_value_length_swa: Optional[int] = None
         self._ssm_inner_size: Optional[int] = None
         self._ssm_state_size: Optional[int] = None
+        # Last N layers reuse KV from earlier layers and don't allocate
+        # their own cache (Gemma 3n / Gemma 4: <arch>.attention.shared_kv_layers).
+        self._shared_kv_layers: Optional[int] = None
         self._lock = threading.Lock()
         self._stdout_lines: list[str] = []
         self._stdout_thread: Optional[threading.Thread] = None
@@ -549,14 +805,24 @@ class LlamaCppBackend:
 
     @staticmethod
     def _get_gpu_free_memory() -> list[tuple[int, int]]:
-        """Query free memory per GPU via nvidia-smi.
+        """Query free memory per GPU.
 
-        Returns list of (gpu_index, free_mib) sorted by index.
-        Respects CUDA_VISIBLE_DEVICES if set.
-        Returns empty list if nvidia-smi is not available.
+        Order:
+          1. ``nvidia-smi`` (NVIDIA CUDA hosts) -- respects
+             ``CUDA_VISIBLE_DEVICES``.
+          2. ``torch.cuda.mem_get_info`` -- universal fallback that
+             works on AMD ROCm too because the HIP runtime
+             reuses the entire ``torch.cuda.*`` namespace. Covers the
+             AMD case for issue #5106 (nvidia-smi-only probe silently
+             returned [] on AMD hosts) and also rescues NVIDIA hosts
+             where ``nvidia-smi`` is missing from PATH.
+
+        Returns list of (gpu_index, free_mib) sorted by index. Empty
+        list if no supported GPU is reachable.
         """
         import os
 
+        # ── NVIDIA via nvidia-smi ────────────────────────────────────
         try:
             result = subprocess.run(
                 [
@@ -567,32 +833,98 @@ class LlamaCppBackend:
                 capture_output = True,
                 text = True,
                 timeout = 10,
+                env = child_env_without_native_path_secret(),
                 **_windows_hidden_subprocess_kwargs(),
             )
-            if result.returncode != 0:
-                return []
-
-            # Parse which GPUs are allowed by existing CUDA_VISIBLE_DEVICES
-            allowed = None
-            cvd = os.environ.get("CUDA_VISIBLE_DEVICES")
-            if cvd is not None and cvd.strip():
-                try:
-                    allowed = set(int(x.strip()) for x in cvd.split(","))
-                except ValueError:
-                    pass  # Non-numeric (e.g., "GPU-uuid"), ignore filter
-
-            gpus = []
-            for line in result.stdout.strip().splitlines():
-                parts = line.split(",")
-                if len(parts) == 2:
-                    idx = int(parts[0].strip())
-                    free_mib = int(parts[1].strip())
-                    if allowed is not None and idx not in allowed:
-                        continue
-                    gpus.append((idx, free_mib))
-            return gpus
+            if result.returncode == 0:
+                allowed: Optional[set[int]] = None
+                cvd = os.environ.get("CUDA_VISIBLE_DEVICES")
+                if cvd is not None:
+                    try:
+                        # `if x.strip()` filters trailing-comma masks like
+                        # "0,1," which would otherwise raise ValueError on
+                        # an empty token. An explicitly empty mask (CVD="")
+                        # yields an empty `allowed` set so all GPUs are
+                        # filtered out, matching the codebase convention.
+                        allowed = set(
+                            int(x.strip()) for x in cvd.split(",") if x.strip()
+                        )
+                    except ValueError:
+                        pass
+                gpus: list[tuple[int, int]] = []
+                for line in result.stdout.strip().splitlines():
+                    parts = line.split(",")
+                    if len(parts) == 2:
+                        idx = int(parts[0].strip())
+                        free_mib = int(parts[1].strip())
+                        if allowed is not None and idx not in allowed:
+                            continue
+                        gpus.append((idx, free_mib))
+                # Match the docstring's sort-by-id guarantee. nvidia-smi
+                # almost always returns sorted output, but driver order
+                # is not formally guaranteed.
+                gpus.sort(key = lambda g: g[0])
+                if gpus:
+                    return gpus
         except Exception as e:
-            logger.debug(f"Failed to query GPU free memory via nvidia-smi: {e}")
+            logger.debug(f"nvidia-smi probe failed: {e}")
+
+        # ── Torch fallback (covers AMD ROCm and missing nvidia-smi) ──
+        try:
+            import torch
+
+            if not hasattr(torch, "cuda") or not torch.cuda.is_available():
+                return []
+            if not hasattr(torch.cuda, "mem_get_info"):
+                return []
+            # torch.cuda enumerates GPUs RELATIVE to the visibility mask.
+            # On NVIDIA builds the mask is CUDA_VISIBLE_DEVICES; on AMD
+            # ROCm builds it is HIP_VISIBLE_DEVICES (or ROCR_VISIBLE_DEVICES
+            # if HIP is unset). Downstream we feed these IDs back into the
+            # llama-server subprocess as CVD, so we must translate visible
+            # ordinals back to physical indices first; otherwise launching
+            # with ``CUDA_VISIBLE_DEVICES=2,3`` would get rewritten to
+            # ``CUDA_VISIBLE_DEVICES=0,1`` and target the wrong GPUs.
+            physical_ids: Optional[list[int]] = None
+            # Match the codebase convention in
+            # ``utils/hardware/hardware.py::_get_parent_visible_gpu_spec``:
+            # treat an explicitly empty mask (``HIP_VISIBLE_DEVICES=""``)
+            # as "set to no GPUs" rather than falling through to the next
+            # var. ``or`` would coerce empty string to falsy and silently
+            # promote the wrong source.
+            if getattr(torch.version, "hip", None) is not None:
+                hip_v = os.environ.get("HIP_VISIBLE_DEVICES")
+                rocr_v = os.environ.get("ROCR_VISIBLE_DEVICES")
+                cvd = (
+                    hip_v
+                    if hip_v is not None
+                    else rocr_v
+                    if rocr_v is not None
+                    else os.environ.get("CUDA_VISIBLE_DEVICES")
+                )
+            else:
+                cvd = os.environ.get("CUDA_VISIBLE_DEVICES")
+            if cvd is not None:
+                try:
+                    # Empty mask (CVD="") yields an empty list so the
+                    # below loop produces no GPUs, consistent with the
+                    # nvidia-smi path and utils/hardware/hardware.py.
+                    physical_ids = [int(x.strip()) for x in cvd.split(",") if x.strip()]
+                except ValueError:
+                    physical_ids = None
+            gpus = []
+            for ordinal in range(torch.cuda.device_count()):
+                free_bytes, _total_bytes = torch.cuda.mem_get_info(ordinal)
+                idx = (
+                    physical_ids[ordinal]
+                    if physical_ids is not None and ordinal < len(physical_ids)
+                    else ordinal
+                )
+                gpus.append((idx, free_bytes // (1024 * 1024)))
+            # Match the nvidia-smi path's docstring guarantee of sorted-by-id.
+            return sorted(gpus, key = lambda g: g[0])
+        except Exception as e:
+            logger.debug(f"torch GPU probe failed: {e}")
             return []
 
     @staticmethod
@@ -652,13 +984,29 @@ class LlamaCppBackend:
         # New-style: need both explicit key AND value dimensions
         if self._kv_key_length is not None and self._kv_value_length is not None:
             return True
-        # Legacy: need embedding_length + head count
+        # Legacy: need embedding_length + a head count (scalar or per-layer).
         return self._embedding_length is not None and (
-            self._n_kv_heads is not None or self._n_heads is not None
+            self._n_kv_heads is not None
+            or self._n_heads is not None
+            or self._n_kv_heads_by_layer is not None
         )
 
+    def _kv_heads_for_layer(self, layer_idx: int, fallback: int) -> int:
+        if self._n_kv_heads_by_layer is not None and layer_idx < len(
+            self._n_kv_heads_by_layer
+        ):
+            return self._n_kv_heads_by_layer[layer_idx]
+        return fallback
+
     def _estimate_kv_cache_bytes(
-        self, n_ctx: int, cache_type_kv: Optional[str] = None
+        self,
+        n_ctx: int,
+        cache_type_kv: Optional[str] = None,
+        *,
+        swa_full: bool = False,
+        n_parallel: int = 1,
+        kv_unified: bool = True,
+        ctx_checkpoints: int = 0,
     ) -> int:
         """Estimate KV cache VRAM for a given context length.
 
@@ -669,12 +1017,34 @@ class LlamaCppBackend:
           4. GQA      -- standard full KV with explicit key/value dimensions
           5. Legacy   -- fallback using embed // n_heads
 
+        Server-flag knobs (mirror llama-server's CLI):
+          swa_full        -- ``--swa-full``: force SWA layers to cache the
+                             full ``n_ctx`` (collapses path 3 to path 4
+                             sizing for the SWA layers).
+          n_parallel      -- ``--parallel``: number of server slots.
+                             Verified empirically against llama-server:
+                             non-SWA layers stay constant (cells split
+                             across slots), SWA layers scale linearly
+                             (per-slot window).
+          kv_unified      -- ``--kv-unified`` (default on): retained for
+                             API forward-compat. Currently a no-op for
+                             memory math because the unified buffer total
+                             matches per-slot buffers in measured cases.
+          ctx_checkpoints -- ``--ctx-checkpoints``: SWA snapshot count per
+                             slot (PR #15293). Each snapshot stores one
+                             sliding-window of state per SWA layer.
+
         Returns 0 if metadata is insufficient for estimation.
         """
         if not self._can_estimate_kv() or n_ctx <= 0:
             return 0
 
         n_layers = self._n_layers  # type: ignore[assignment]
+        # Gemma 3n / Gemma 4 reuse KV from earlier layers in the last
+        # ``shared_kv_layers`` blocks -- those don't allocate their own
+        # cache.  Floor at 1 so a misconfigured GGUF can't zero out KV.
+        shared = self._shared_kv_layers or 0
+        n_layers_kv = max(1, n_layers - shared)
         n_kv = self._n_kv_heads or self._n_heads or 1  # type: ignore[assignment]
 
         # Bytes per element depends on KV cache quantization
@@ -690,6 +1060,8 @@ class LlamaCppBackend:
             "iq4_nl": 0.5625,
         }.get(cache_type_kv or "f16", 2.0)
 
+        slots = max(1, n_parallel)
+
         # Path 1: MLA (DeepSeek-V2/V3, GLM-4.7, GLM-5, Kimi-K2.5)
         # MLA stores one compressed KV latent per token/layer (shared across heads).
         # V is reconstructed from the latent on the fly -- no separate V cache.
@@ -700,7 +1072,7 @@ class LlamaCppBackend:
             n_kv_mla = self._n_kv_heads or 1
             rope_dim = self._key_length_mla or 64
             key_len = self._kv_key_length or (self._kv_lora_rank + rope_dim)
-            return int(n_layers * n_ctx * n_kv_mla * key_len * bpe)
+            return int(n_layers_kv * n_ctx * n_kv_mla * key_len * bpe)
 
         key_len = self._kv_key_length
         val_len = self._kv_value_length
@@ -718,11 +1090,19 @@ class LlamaCppBackend:
             head_dim = self._embedding_length // self._n_heads if self._n_heads else 128  # type: ignore[operator]
             return int(n_attn * n_ctx * n_kv * 2 * head_dim * bpe)
 
-        # Path 3: Sliding Window (Gemma-3, gpt-oss)
-        # SWA layers only cache min(ctx, window) tokens; global layers cache full ctx.
-        # Most SWA architectures use few global layers (e.g., Gemma-3 uses 1 in 6).
-        # Without an explicit field, we conservatively assume 1/4 of layers are global
-        # which is still far more accurate than the legacy formula (which ignores SWA).
+        # Path 3: Sliding window (Gemma 2/3/3n/4, gpt-oss, Cohere2 ...).
+        # Pattern is filled in by the resolver at parse time; if absent,
+        # falls through to the legacy 1/4-global heuristic below.
+        # Per-layer-type ``--parallel N`` accounting (verified empirically
+        # against ``llama-server``):
+        #   * non-SWA layers:    total cells = n_ctx, partitioned across
+        #                         slots -> total memory CONSTANT in slots.
+        #   * SWA layers:         per-slot cells = 2 * sliding_window
+        #                         (capped at n_ctx and at per_slot_ctx
+        #                         when ctx is split among many slots) ->
+        #                         total memory grows LINEARLY in slots.
+        # ``--swa-full`` forces full n_ctx for SWA layers instead.
+        # ``--ctx-checkpoints N`` adds N snapshots per SWA layer per slot.
         if (
             self._sliding_window is not None
             and self._sliding_window > 0
@@ -730,20 +1110,72 @@ class LlamaCppBackend:
             and val_len is not None
         ):
             swa = self._sliding_window
-            n_global = max(1, n_layers // 4)
-            n_swa = n_layers - n_global
+            per_slot_ctx = max(1, n_ctx // slots)
+            # ``--swa-full`` makes SWA layers cache the full context just
+            # like non-SWA: cells get partitioned across slots, so per-slot
+            # cells = per_slot_ctx and the slots*per-slot product collapses
+            # back to the constant ``n_ctx`` total.  Otherwise SWA caches
+            # 2*sliding_window per slot, clamped at the per-slot ctx.
+            swa_cells_per_slot = (
+                per_slot_ctx if swa_full else min(n_ctx, 2 * swa, per_slot_ctx)
+            )
+            key_len_swa = self._kv_key_length_swa or key_len
+            val_len_swa = self._kv_value_length_swa or val_len
+            if self._sliding_window_pattern is not None:
+                global_bytes = 0.0  # constant across slots
+                swa_bytes_per_slot = 0.0  # multiplied by slots
+                checkpoint_extra_per_slot = 0.0
+                # Iterate only over layers that allocate their own KV;
+                # the trailing ``shared`` layers reuse earlier caches.
+                for layer_idx in range(n_layers_kv):
+                    layer_n_kv = self._kv_heads_for_layer(layer_idx, n_kv)
+                    is_swa = (
+                        layer_idx < len(self._sliding_window_pattern)
+                        and self._sliding_window_pattern[layer_idx]
+                    )
+                    if is_swa:
+                        swa_bytes_per_slot += (
+                            swa_cells_per_slot
+                            * layer_n_kv
+                            * (key_len_swa + val_len_swa)
+                            * bpe
+                        )
+                        if ctx_checkpoints > 0 and not swa_full:
+                            checkpoint_extra_per_slot += (
+                                ctx_checkpoints
+                                * swa
+                                * layer_n_kv
+                                * (key_len_swa + val_len_swa)
+                                * bpe
+                            )
+                    else:
+                        global_bytes += n_ctx * layer_n_kv * (key_len + val_len) * bpe
+                return int(
+                    global_bytes
+                    + slots * (swa_bytes_per_slot + checkpoint_extra_per_slot)
+                )
+            n_global = max(1, n_layers_kv // 4)
+            n_swa = n_layers_kv - n_global
             kv_per_token = n_kv * (key_len + val_len) * bpe
+            kv_per_token_swa = n_kv * (key_len_swa + val_len_swa) * bpe
+            global_bytes = n_global * n_ctx * kv_per_token
+            swa_bytes_per_slot = n_swa * swa_cells_per_slot * kv_per_token_swa
+            checkpoint_extra_per_slot = (
+                ctx_checkpoints * n_swa * swa * kv_per_token_swa
+                if ctx_checkpoints > 0 and not swa_full
+                else 0.0
+            )
             return int(
-                n_global * n_ctx * kv_per_token + n_swa * min(n_ctx, swa) * kv_per_token
+                global_bytes + slots * (swa_bytes_per_slot + checkpoint_extra_per_slot)
             )
 
         # Path 4: Standard GQA with explicit key/value dimensions
         if key_len is not None and val_len is not None:
-            return int(n_layers * n_ctx * n_kv * (key_len + val_len) * bpe)
+            return int(n_layers_kv * n_ctx * n_kv * (key_len + val_len) * bpe)
 
         # Path 5: Legacy fallback (old GGUFs without explicit dimensions)
         head_dim = self._embedding_length // self._n_heads if self._n_heads else 128  # type: ignore[operator]
-        return int(2 * n_kv * head_dim * n_layers * n_ctx * bpe)
+        return int(2 * n_kv * head_dim * n_layers_kv * n_ctx * bpe)
 
     def _fit_context_to_vram(
         self,
@@ -752,6 +1184,12 @@ class LlamaCppBackend:
         model_size_bytes: int,
         cache_type_kv: Optional[str] = None,
         min_ctx: int = 4096,
+        *,
+        swa_full: bool = False,
+        n_parallel: int = 1,
+        kv_unified: bool = True,
+        ctx_checkpoints: int = 0,
+        kv_on_gpu: bool = True,
     ) -> int:
         """Return the largest context length that fits in GPU VRAM.
 
@@ -759,6 +1197,11 @@ class LlamaCppBackend:
         threshold -- 10% reserved for compute buffers, CUDA context,
         scratch space, flash-attn workspace, etc.).
         If the model weights alone don't fit, returns min_ctx unchanged.
+
+        ``kv_on_gpu`` mirrors ``--kv-offload`` (default on). When False
+        the KV cache lives in CPU RAM and doesn't compete with weights
+        for VRAM; the requested context is honored verbatim. The other
+        keyword args mirror ``_estimate_kv_cache_bytes``.
         """
         if not self._can_estimate_kv():
             logger.debug(
@@ -768,11 +1211,22 @@ class LlamaCppBackend:
             )
             return requested_ctx
 
+        # KV lives off-GPU: no VRAM accounting needed for the cache itself.
+        if not kv_on_gpu:
+            return requested_ctx
+
+        kv_kwargs = dict(
+            swa_full = swa_full,
+            n_parallel = n_parallel,
+            kv_unified = kv_unified,
+            ctx_checkpoints = ctx_checkpoints,
+        )
+
         budget_bytes = available_mib * 1024 * 1024 * 0.90
         model_footprint = model_size_bytes
 
         # Check if requested context already fits
-        kv = self._estimate_kv_cache_bytes(requested_ctx, cache_type_kv)
+        kv = self._estimate_kv_cache_bytes(requested_ctx, cache_type_kv, **kv_kwargs)
         if model_footprint + kv <= budget_bytes:
             return requested_ctx
 
@@ -794,7 +1248,7 @@ class LlamaCppBackend:
         best = effective_min
         while lo <= hi:
             mid = (lo + hi) // 2
-            kv = self._estimate_kv_cache_bytes(mid, cache_type_kv)
+            kv = self._estimate_kv_cache_bytes(mid, cache_type_kv, **kv_kwargs)
             if kv <= remaining:
                 best = mid
                 lo = mid + 1
@@ -927,6 +1381,19 @@ class LlamaCppBackend:
                 for _ in range(alen):
                     LlamaCppBackend._gguf_skip_value(f, atype)
 
+    @staticmethod
+    def _gguf_read_array_value(f, atype: int, alen: int) -> Optional[list]:
+        if atype == 4:  # UINT32
+            return [struct.unpack("<I", f.read(4))[0] for _ in range(alen)]
+        if atype == 5:  # INT32
+            return [struct.unpack("<i", f.read(4))[0] for _ in range(alen)]
+        if atype == 7:  # BOOL
+            return [struct.unpack("<?", f.read(1))[0] for _ in range(alen)]
+
+        for _ in range(alen):
+            LlamaCppBackend._gguf_skip_value(f, atype)
+        return None
+
     def _read_gguf_metadata(self, gguf_path: str) -> None:
         """Read context_length, architecture params, and chat_template from a GGUF header.
 
@@ -945,23 +1412,44 @@ class LlamaCppBackend:
         self._supports_tools = False
         self._n_layers = None
         self._n_kv_heads = None
+        self._n_kv_heads_by_layer = None
         self._n_heads = None
         self._embedding_length = None
         self._kv_key_length = None
         self._kv_value_length = None
         self._sliding_window = None
+        self._sliding_window_pattern = None
         self._full_attention_interval = None
         self._kv_lora_rank = None
         self._key_length_mla = None
+        self._kv_key_length_swa = None
+        self._kv_value_length_swa = None
         self._ssm_inner_size = None
         self._ssm_state_size = None
+        self._shared_kv_layers = None
 
         try:
-            WANTED = {"general.architecture", "tokenizer.chat_template"}
+            WANTED = {
+                "general.architecture",
+                "tokenizer.chat_template",
+                # Source-repo hints for the SWA resolver's HF fallback.
+                "general.source.huggingface.repository",
+                "general.source.url",
+                "general.source.repo_url",
+                "general.base_model.0.repo_url",
+                "general.base_model.0.organization",
+                "general.base_model.0.name",
+                "general.basename",
+                "general.organization",
+                "general.size_label",
+                "general.finetune",
+            }
             # Additional arch-specific keys are added dynamically once
             # we know the architecture name.
             arch_keys: dict[str, str] = {}  # gguf_key -> attribute name
             arch = None
+            sliding_window_pattern_period: Optional[int] = None
+            general: dict[str, str] = {}
 
             with open(gguf_path, "rb") as f:
                 magic = struct.unpack("<I", f.read(4))[0]
@@ -971,49 +1459,141 @@ class LlamaCppBackend:
                 _tensor_count, kv_count = struct.unpack("<QQ", f.read(16))
 
                 for _ in range(kv_count):
-                    key_len = struct.unpack("<Q", f.read(8))[0]
-                    key = f.read(key_len).decode("utf-8")
-                    vtype = struct.unpack("<I", f.read(4))[0]
+                    # Tolerate truncated input (e.g., a partial header
+                    # fetched via HTTP byte-range): bail out gracefully
+                    # so the resolver fallback still runs on whatever
+                    # we did manage to parse.
+                    try:
+                        key_len_bytes = f.read(8)
+                        if len(key_len_bytes) < 8:
+                            break
+                        key_len = struct.unpack("<Q", key_len_bytes)[0]
+                        key_bytes = f.read(key_len)
+                        if len(key_bytes) < key_len:
+                            break
+                        key = key_bytes.decode("utf-8")
+                        vtype_bytes = f.read(4)
+                        if len(vtype_bytes) < 4:
+                            break
+                        vtype = struct.unpack("<I", vtype_bytes)[0]
+                    except (struct.error, UnicodeDecodeError):
+                        break
 
-                    if key in WANTED or key in arch_keys:
-                        # Read this value
-                        if vtype == 8:  # STRING
-                            slen = struct.unpack("<Q", f.read(8))[0]
-                            val_s = f.read(slen).decode("utf-8")
-                            if key == "general.architecture":
-                                arch = val_s
-                                # Register arch-specific keys to look for
-                                arch_keys = {
-                                    f"{arch}.context_length": "context_length",
-                                    f"{arch}.block_count": "n_layers",
-                                    f"{arch}.attention.head_count_kv": "n_kv_heads",
-                                    f"{arch}.attention.head_count": "n_heads",
-                                    f"{arch}.embedding_length": "embedding_length",
-                                    # Architecture-aware KV cache fields
-                                    f"{arch}.attention.key_length": "kv_key_length",
-                                    f"{arch}.attention.value_length": "kv_value_length",
-                                    f"{arch}.attention.sliding_window": "sliding_window",
-                                    f"{arch}.full_attention_interval": "full_attention_interval",
-                                    f"{arch}.attention.kv_lora_rank": "kv_lora_rank",
-                                    f"{arch}.attention.key_length_mla": "key_length_mla",
-                                    f"{arch}.ssm.inner_size": "ssm_inner_size",
-                                    f"{arch}.ssm.state_size": "ssm_state_size",
-                                }
-                            elif key == "tokenizer.chat_template":
-                                self._chat_template = val_s
-                        elif vtype in (4, 10):  # UINT32 or UINT64
-                            val_i = (
-                                struct.unpack("<I", f.read(4))[0]
-                                if vtype == 4
-                                else struct.unpack("<Q", f.read(8))[0]
-                            )
-                            attr = arch_keys.get(key)
-                            if attr:
-                                setattr(self, f"_{attr}", val_i)
+                    try:
+                        if key in WANTED or key in arch_keys:
+                            if vtype == 8:  # STRING
+                                slen = struct.unpack("<Q", f.read(8))[0]
+                                val_s = f.read(slen).decode("utf-8")
+                                if (
+                                    key.startswith("general.")
+                                    and key != "general.architecture"
+                                ):
+                                    general[key] = val_s
+                                if key == "general.architecture":
+                                    arch = val_s
+                                    arch_keys = {
+                                        f"{arch}.context_length": "context_length",
+                                        f"{arch}.block_count": "n_layers",
+                                        f"{arch}.attention.head_count_kv": "n_kv_heads",
+                                        f"{arch}.attention.head_count": "n_heads",
+                                        f"{arch}.embedding_length": "embedding_length",
+                                        f"{arch}.attention.key_length": "kv_key_length",
+                                        f"{arch}.attention.value_length": "kv_value_length",
+                                        f"{arch}.attention.sliding_window": "sliding_window",
+                                        f"{arch}.attention.sliding_window_pattern": "sliding_window_pattern",
+                                        f"{arch}.full_attention_interval": "full_attention_interval",
+                                        f"{arch}.attention.kv_lora_rank": "kv_lora_rank",
+                                        f"{arch}.attention.key_length_mla": "key_length_mla",
+                                        f"{arch}.attention.key_length_swa": "kv_key_length_swa",
+                                        f"{arch}.attention.value_length_swa": "kv_value_length_swa",
+                                        f"{arch}.attention.shared_kv_layers": "shared_kv_layers",
+                                        f"{arch}.ssm.inner_size": "ssm_inner_size",
+                                        f"{arch}.ssm.state_size": "ssm_state_size",
+                                    }
+                                elif key == "tokenizer.chat_template":
+                                    self._chat_template = val_s
+                            elif vtype in (4, 10):  # UINT32 or UINT64
+                                val_i = (
+                                    struct.unpack("<I", f.read(4))[0]
+                                    if vtype == 4
+                                    else struct.unpack("<Q", f.read(8))[0]
+                                )
+                                attr = arch_keys.get(key)
+                                if attr:
+                                    if attr == "sliding_window_pattern":
+                                        sliding_window_pattern_period = val_i
+                                    else:
+                                        setattr(self, f"_{attr}", val_i)
+                            elif vtype == 9:  # ARRAY
+                                atype = struct.unpack("<I", f.read(4))[0]
+                                alen = struct.unpack("<Q", f.read(8))[0]
+                                val_a = self._gguf_read_array_value(f, atype, alen)
+                                attr = arch_keys.get(key)
+                                if attr == "n_kv_heads" and val_a is not None:
+                                    self._n_kv_heads_by_layer = [int(x) for x in val_a]
+                                    if self._n_kv_heads is None and val_a:
+                                        self._n_kv_heads = max(int(x) for x in val_a)
+                                elif (
+                                    attr == "sliding_window_pattern"
+                                    and val_a is not None
+                                ):
+                                    self._sliding_window_pattern = [
+                                        bool(x) for x in val_a
+                                    ]
+                                    sliding_window_pattern_period = None
+                            else:
+                                self._gguf_skip_value(f, vtype)
                         else:
                             self._gguf_skip_value(f, vtype)
-                    else:
-                        self._gguf_skip_value(f, vtype)
+                    except (struct.error, UnicodeDecodeError):
+                        # Truncated input (e.g., HTTP byte-range fetch
+                        # of just the GGUF header); break so the
+                        # resolver fallback still runs on what we have.
+                        break
+
+            # Expand a scalar period straight from the GGUF first.
+            if (
+                self._sliding_window_pattern is None
+                and sliding_window_pattern_period
+                and self._n_layers
+            ):
+                self._sliding_window_pattern = [
+                    (i + 1) % sliding_window_pattern_period != 0
+                    for i in range(self._n_layers)
+                ]
+
+            # Otherwise hand off to the resolver (cache / bootstrap /
+            # transformers / HF). See `_resolve_swa_pattern`.
+            if (
+                self._sliding_window_pattern is None
+                and self._sliding_window
+                and self._n_layers
+            ):
+                hf_repo_candidates = (
+                    general.get("general.source.huggingface.repository"),
+                    _hf_repo_from_url(general.get("general.source.url")),
+                    _hf_repo_from_url(general.get("general.source.repo_url")),
+                    _hf_repo_from_url(general.get("general.base_model.0.repo_url")),
+                    (
+                        f"{general['general.base_model.0.organization']}/"
+                        f"{general['general.base_model.0.name']}".replace(" ", "-")
+                        if general.get("general.base_model.0.organization")
+                        and general.get("general.base_model.0.name")
+                        else None
+                    ),
+                    (
+                        f"{general['general.organization']}/"
+                        f"{general['general.basename']}".replace(" ", "-")
+                        if general.get("general.organization")
+                        and general.get("general.basename")
+                        else None
+                    ),
+                )
+                self._sliding_window_pattern = _resolve_swa_pattern(
+                    arch,
+                    self._n_layers,
+                    hf_repo_candidates,
+                )
 
             if self._context_length:
                 logger.info(f"GGUF metadata: context_length={self._context_length}")
@@ -1249,7 +1829,7 @@ class LlamaCppBackend:
             # Prefer F16 variant
             target = None
             for f in mmproj_files:
-                if "f16" in f.lower():
+                if f.lower().endswith("-f16.gguf"):
                     target = f
                     break
             if target is None:
@@ -1289,6 +1869,7 @@ class LlamaCppBackend:
         n_threads: Optional[int] = None,
         n_gpu_layers: Optional[int] = None,  # Accepted for caller compat, unused
         n_parallel: int = 1,
+        extra_args: Optional[List[str]] = None,
     ) -> bool:
         """
         Start llama-server with a GGUF model.
@@ -1411,8 +1992,11 @@ class LlamaCppBackend:
                                 pool_mib,
                                 model_size,
                                 cache_type_kv,
+                                n_parallel = n_parallel,
+                            )
+                            kv = self._estimate_kv_cache_bytes(
+                                capped, cache_type_kv, n_parallel = n_parallel
                             )
-                            kv = self._estimate_kv_cache_bytes(capped, cache_type_kv)
                             total_mib = (model_size + kv) / (1024 * 1024)
                             if total_mib <= pool_mib * 0.90:
                                 best_cap = max(best_cap, capped)
@@ -1436,7 +2020,7 @@ class LlamaCppBackend:
                         # have surfaced the "might be slower" warning before
                         # the user submitted a ctx above the fit ceiling.
                         requested_total = model_size + self._estimate_kv_cache_bytes(
-                            effective_ctx, cache_type_kv
+                            effective_ctx, cache_type_kv, n_parallel = n_parallel
                         )
                         gpu_indices, use_fit = self._select_gpus(requested_total, gpus)
                         # No silent shrink: effective_ctx stays == n_ctx.
@@ -1451,8 +2035,11 @@ class LlamaCppBackend:
                                 pool_mib,
                                 model_size,
                                 cache_type_kv,
+                                n_parallel = n_parallel,
+                            )
+                            kv = self._estimate_kv_cache_bytes(
+                                capped, cache_type_kv, n_parallel = n_parallel
                             )
-                            kv = self._estimate_kv_cache_bytes(capped, cache_type_kv)
                             total_mib = (model_size + kv) / (1024 * 1024)
                             if total_mib <= pool_mib * 0.90:
                                 effective_ctx = capped
@@ -1485,7 +2072,9 @@ class LlamaCppBackend:
                         )
 
                 if effective_ctx < original_ctx:
-                    kv_est = self._estimate_kv_cache_bytes(effective_ctx, cache_type_kv)
+                    kv_est = self._estimate_kv_cache_bytes(
+                        effective_ctx, cache_type_kv, n_parallel = n_parallel
+                    )
                     logger.info(
                         f"Context auto-reduced: {original_ctx} -> {effective_ctx} "
                         f"(model: {model_size / (1024**3):.1f} GB, "
@@ -1493,7 +2082,7 @@ class LlamaCppBackend:
                     )
 
                 kv_cache_bytes = self._estimate_kv_cache_bytes(
-                    effective_ctx, cache_type_kv
+                    effective_ctx, cache_type_kv, n_parallel = n_parallel
                 )
                 logger.info(
                     f"GGUF size: {model_size / (1024**3):.1f} GB, "
@@ -1528,8 +2117,10 @@ class LlamaCppBackend:
                 # Model fits on selected GPU(s) -- offload all layers
                 cmd.extend(["-ngl", "-1"])
 
-            if n_threads is not None:
-                cmd.extend(["--threads", str(n_threads)])
+            # -1 = llama.cpp auto-detect (physical cores). Pass explicitly so we
+            # do not inherit llama-server's internal default, which has historically
+            # varied (hardware concurrency incl. hyperthreads on some builds).
+            cmd.extend(["--threads", str(n_threads if n_threads is not None else -1)])
 
             # Always enable Jinja chat template rendering for proper template support
             cmd.extend(["--jinja"])
@@ -1561,7 +2152,7 @@ class LlamaCppBackend:
             # existing text (code refactoring, summarization, reasoning).
             # For general chat with low repetition, overhead is ~5 ms.
             #
-            # Benchmarks from llama.cpp PRs #18471, #19164:
+            # Benchmarks from upstream llama.cpp speculative-decoding PRs:
             #   Scenario                        | Without | With    | Speedup
             #   gpt-oss-120b code refactor      | 181 t/s | 446 t/s | 2.5x
             #   Qwen3-235B offloaded            |  12 t/s |  21 t/s | 1.8x
@@ -1574,11 +2165,21 @@ class LlamaCppBackend:
             # ref: https://github.com/ggml-org/llama.cpp/blob/master/docs/speculative.md
             # ref: https://github.com/ggml-org/llama.cpp/pull/19164
             # ref: https://github.com/ggml-org/llama.cpp/pull/18471
+            # ``"default"`` -> let llama-server pick a sensible spec
+            # config via ``--spec-default``. Explicit type names are
+            # passed through with the manual draft tuning we've shipped
+            # historically so power users keep their overrides.
             _valid_spec_types = {"ngram-simple", "ngram-mod"}
-            if speculative_type and speculative_type in _valid_spec_types:
-                if not is_vision:  # spec decoding disabled for vision models
-                    cmd.extend(["--spec-type", speculative_type])
-                    if speculative_type == "ngram-mod":
+            normalized_spec = (
+                speculative_type.lower().strip() if speculative_type else None
+            )
+            if normalized_spec and normalized_spec != "off" and not is_vision:
+                if normalized_spec == "default":
+                    cmd.append("--spec-default")
+                    self._speculative_type = "default"
+                elif normalized_spec in _valid_spec_types:
+                    cmd.extend(["--spec-type", normalized_spec])
+                    if normalized_spec == "ngram-mod":
                         cmd.extend(
                             [
                                 "--spec-ngram-size-n",
@@ -1589,7 +2190,7 @@ class LlamaCppBackend:
                                 "64",
                             ]
                         )
-                    self._speculative_type = speculative_type
+                    self._speculative_type = normalized_spec
                 else:
                     self._speculative_type = None
             else:
@@ -1599,6 +2200,18 @@ class LlamaCppBackend:
             if chat_template_override:
                 import tempfile
 
+                self._chat_template = chat_template_override
+                flags = detect_reasoning_flags(
+                    self._chat_template,
+                    self._model_identifier,
+                    log_source = "GGUF chat template override",
+                )
+                self._supports_reasoning = flags["supports_reasoning"]
+                self._reasoning_style = flags["reasoning_style"]
+                self._reasoning_always_on = flags["reasoning_always_on"]
+                self._supports_preserve_thinking = flags["supports_preserve_thinking"]
+                self._supports_tools = flags["supports_tools"]
+
                 self._chat_template_file = tempfile.NamedTemporaryFile(
                     mode = "w",
                     suffix = ".jinja",
@@ -1651,6 +2264,17 @@ class LlamaCppBackend:
             else:
                 self._api_key = None
 
+            # User-supplied pass-through args go last so llama.cpp's
+            # last-wins flag parsing lets the user override Studio's
+            # auto-set tier-2 flags (e.g. --cache-type-k, --spec-type).
+            # The route layer has already validated this list against
+            # the managed-flag denylist via validate_extra_args().
+            if extra_args:
+                cmd.extend(str(a) for a in extra_args)
+                logger.info(
+                    f"Appending user extra args to llama-server: {list(extra_args)}"
+                )
+
             _log_cmd = list(cmd)
             if "--api-key" in _log_cmd:
                 _ki = _log_cmd.index("--api-key") + 1
@@ -1662,7 +2286,7 @@ class LlamaCppBackend:
             import os
             import sys
 
-            env = os.environ.copy()
+            env = child_env_without_native_path_secret()
             binary_dir = str(Path(binary).parent)
 
             if sys.platform == "win32":
@@ -1746,9 +2370,29 @@ class LlamaCppBackend:
                     f"{new_ld}:{existing_ld}" if existing_ld else new_ld
                 )
 
-            # Pin to selected GPU(s) via CUDA_VISIBLE_DEVICES
+            # Pin to selected GPU(s). On ROCm, llama-server (and any torch
+            # in the subprocess) honors HIP_VISIBLE_DEVICES / ROCR_VISIBLE_DEVICES;
+            # narrowing only CUDA_VISIBLE_DEVICES leaves an AMD child seeing
+            # the full HIP/ROCR set the parent inherited.
             if gpu_indices is not None:
-                env["CUDA_VISIBLE_DEVICES"] = ",".join(str(i) for i in gpu_indices)
+                pinned = ",".join(str(i) for i in gpu_indices)
+                env["CUDA_VISIBLE_DEVICES"] = pinned
+                try:
+                    import torch as _torch
+
+                    if getattr(_torch.version, "hip", None) is not None:
+                        env["HIP_VISIBLE_DEVICES"] = pinned
+                        env["ROCR_VISIBLE_DEVICES"] = pinned
+                except Exception as e:
+                    logger.debug(
+                        "Failed to set ROCm visibility env vars for child: %s", e
+                    )
+
+            # Defensive kill: if a concurrent load slipped past Phase 1
+            # (because its `self._process` was None at the time) and
+            # already stored a Popen handle here, drop that orphan
+            # before we overwrite the reference. See issue #5161.
+            self._kill_process()
 
             self._stdout_lines = []
             self._process = subprocess.Popen(
@@ -1867,16 +2511,21 @@ class LlamaCppBackend:
             self._speculative_type = None
             self._n_layers = None
             self._n_kv_heads = None
+            self._n_kv_heads_by_layer = None
             self._n_heads = None
             self._embedding_length = None
             self._kv_key_length = None
             self._kv_value_length = None
             self._sliding_window = None
+            self._sliding_window_pattern = None
             self._full_attention_interval = None
             self._kv_lora_rank = None
             self._key_length_mla = None
+            self._kv_key_length_swa = None
+            self._kv_value_length_swa = None
             self._ssm_inner_size = None
             self._ssm_state_size = None
+            self._shared_kv_layers = None
             # Clean up temp chat template file
             if hasattr(self, "_chat_template_file") and self._chat_template_file:
                 try:
@@ -2032,6 +2681,7 @@ class LlamaCppBackend:
                     capture_output = True,
                     text = True,
                     timeout = 5,
+                    env = child_env_without_native_path_secret(),
                 )
                 if result.returncode != 0:
                     return
@@ -2444,8 +3094,15 @@ class LlamaCppBackend:
         )
         if _reasoning_kw is not None:
             payload["chat_template_kwargs"] = _reasoning_kw
-        if max_tokens is not None:
-            payload["max_tokens"] = max_tokens
+        # Default cap to the model's effective context length when known,
+        # otherwise the conservative floor. The wall-clock backstop below
+        # keeps a stuck model from running indefinitely either way.
+        payload["max_tokens"] = (
+            max_tokens
+            if max_tokens is not None
+            else (self._effective_context_length or _DEFAULT_MAX_TOKENS_FLOOR)
+        )
+        payload["t_max_predict_ms"] = _DEFAULT_T_MAX_PREDICT_MS
         if stop:
             payload["stop"] = stop
         payload["stream_options"] = {"include_usage": True}
@@ -2465,7 +3122,9 @@ class LlamaCppBackend:
             _auth_headers = (
                 {"Authorization": f"Bearer {self._api_key}"} if self._api_key else None
             )
-            with httpx.Client(timeout = stream_timeout) as client:
+            with httpx.Client(
+                timeout = stream_timeout, limits = httpx.Limits(max_keepalive_connections = 0)
+            ) as client:
                 with self._stream_with_retry(
                     client,
                     url,
@@ -2664,8 +3323,12 @@ class LlamaCppBackend:
             )
             if _reasoning_kw is not None:
                 payload["chat_template_kwargs"] = _reasoning_kw
-            if max_tokens is not None:
-                payload["max_tokens"] = max_tokens
+            payload["max_tokens"] = (
+                max_tokens
+                if max_tokens is not None
+                else (self._effective_context_length or _DEFAULT_MAX_TOKENS_FLOOR)
+            )
+            payload["t_max_predict_ms"] = _DEFAULT_T_MAX_PREDICT_MS
             if stop:
                 payload["stop"] = stop
 
@@ -2704,7 +3367,10 @@ class LlamaCppBackend:
                     write = 10,
                     pool = 10,
                 )
-                with httpx.Client(timeout = stream_timeout) as client:
+                with httpx.Client(
+                    timeout = stream_timeout,
+                    limits = httpx.Limits(max_keepalive_connections = 0),
+                ) as client:
                     with self._stream_with_retry(
                         client,
                         url,
@@ -3317,8 +3983,12 @@ class LlamaCppBackend:
         )
         if _reasoning_kw is not None:
             stream_payload["chat_template_kwargs"] = _reasoning_kw
-        if max_tokens is not None:
-            stream_payload["max_tokens"] = max_tokens
+        stream_payload["max_tokens"] = (
+            max_tokens
+            if max_tokens is not None
+            else (self._effective_context_length or _DEFAULT_MAX_TOKENS_FLOOR)
+        )
+        stream_payload["t_max_predict_ms"] = _DEFAULT_T_MAX_PREDICT_MS
         if stop:
             stream_payload["stop"] = stop
         stream_payload["stream_options"] = {"include_usage": True}
@@ -3337,7 +4007,9 @@ class LlamaCppBackend:
             _auth_headers = (
                 {"Authorization": f"Bearer {self._api_key}"} if self._api_key else None
             )
-            with httpx.Client(timeout = stream_timeout) as client:
+            with httpx.Client(
+                timeout = stream_timeout, limits = httpx.Limits(max_keepalive_connections = 0)
+            ) as client:
                 with self._stream_with_retry(
                     client,
                     url,
diff --git a/studio/backend/core/inference/llama_server_args.py b/studio/backend/core/inference/llama_server_args.py
new file mode 100644
index 0000000000..44c7d542c7
--- /dev/null
+++ b/studio/backend/core/inference/llama_server_args.py
@@ -0,0 +1,120 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+"""Validator for user-supplied llama-server pass-through args.
+
+Studio runs llama-server as a managed subprocess and lets callers pass
+extra flags directly (CLI: ``unsloth run ... --top-k 20``; HTTP:
+``LoadRequest.llama_extra_args``). This module is the boundary that
+rejects only flags Studio fundamentally cannot share with the user --
+model identity, the auth key, and the network endpoint Studio's HTTP
+proxy targets. Anything else passes through.
+
+User-supplied args are appended to ``cmd`` after Studio's auto-set
+flags, so llama.cpp's last-wins CLI parsing makes the user's value
+override the auto-set one. That covers tunable knobs the user might
+reasonably want to override -- ``-c``/``--ctx-size``,
+``-np``/``--parallel``, ``-fa``/``--flash-attn``,
+``-ngl``/``--gpu-layers``, ``-t``/``--threads``, ``-fit``/``--fit*``,
+``--cache-type-k/v``, ``--chat-template-file/-kwargs``,
+``--spec-*``, ``--jinja``/``--no-jinja``,
+``--no-context-shift``/``--context-shift``, sampling params, etc.
+
+Reference: https://github.com/ggml-org/llama.cpp/blob/master/tools/server/README.md
+"""
+
+from __future__ import annotations
+
+from typing import Iterable, Optional
+
+# Each group is the full set of aliases (short + long) for one
+# hard-denied flag, taken from the llama-server README. If llama.cpp
+# adds a new alias for an existing denied flag, extend the relevant
+# group.
+#
+# Flags NOT in this list (e.g. -c, --parallel, --flash-attn, -ngl,
+# -t/--threads, --jinja, --no-context-shift, --fit*, --cache-type-*,
+# --chat-template-*, --spec-*) pass through and override Studio's
+# auto-set version via llama.cpp's last-wins CLI parsing.
+_DENYLIST_GROUPS: tuple[frozenset[str], ...] = (
+    # Model identity -- Studio resolves the model from LoadRequest and
+    # passes -m / mmproj after downloading from HF if needed. A second
+    # -m would point at a different model than the one Studio thinks
+    # is loaded.
+    frozenset({"-m", "--model"}),
+    frozenset({"-mu", "--model-url"}),
+    frozenset({"-dr", "--docker-repo"}),
+    frozenset({"-hf", "-hfr", "--hf-repo"}),
+    frozenset({"-hff", "--hf-file"}),
+    frozenset({"-hfv", "-hfrv", "--hf-repo-v"}),
+    frozenset({"-hffv", "--hf-file-v"}),
+    frozenset({"-hft", "--hf-token"}),
+    frozenset({"-mm", "--mmproj"}),
+    frozenset({"-mmu", "--mmproj-url"}),
+    # Networking -- Studio binds llama-server's port and reverse-proxies
+    # HTTP traffic to it. Retargeting host/port/path/prefix would
+    # orphan Studio's proxy and the UI would lose the server.
+    frozenset({"--host"}),
+    frozenset({"--port"}),
+    frozenset({"--path"}),
+    frozenset({"--api-prefix"}),
+    frozenset({"--reuse-port"}),
+    # Auth / TLS -- Studio terminates auth at its own layer; an
+    # upstream --api-key would shadow Studio's UNSLOTH_DIRECT_STREAM
+    # key, and TLS on llama-server would break the local proxy hop.
+    frozenset({"--api-key"}),
+    frozenset({"--api-key-file"}),
+    frozenset({"--ssl-key-file"}),
+    frozenset({"--ssl-cert-file"}),
+    # Single-model server -- Studio runs one model per llama-server
+    # process and serves its own UI. Enabling multi-model loading or
+    # llama-server's built-in web UI changes the surface clients see.
+    frozenset({"--webui", "--no-webui"}),
+    frozenset({"--models-dir"}),
+    frozenset({"--models-preset"}),
+    frozenset({"--models-max"}),
+    frozenset({"--models-autoload", "--no-models-autoload"}),
+)
+
+_DENYLIST: frozenset[str] = frozenset().union(*_DENYLIST_GROUPS)
+
+
+def _flag_name(token: str) -> Optional[str]:
+    """Return the flag name for a token, or None if it isn't a flag.
+
+    Peels ``--key=value`` to the bare ``--key``. Plain numeric values
+    like ``-1`` or ``-0.5`` (e.g. ``--seed -1``) are values, not flags;
+    llama-server short-form flags always start with a letter.
+    """
+    if not token.startswith("-") or token in {"-", "--"}:
+        return None
+    if len(token) >= 2 and (token[1].isdigit() or token[1] == "."):
+        return None
+    return token.split("=", 1)[0]
+
+
+def validate_extra_args(args: Optional[Iterable[str]]) -> list[str]:
+    """Validate user-supplied llama-server args.
+
+    Returns the args as a flat list ready to extend the llama-server
+    command. Raises ``ValueError`` (with the offending flag in the
+    message) the moment a token resolves to a Studio-managed flag.
+    """
+    if not args:
+        return []
+    out: list[str] = []
+    for raw in args:
+        token = str(raw)
+        flag = _flag_name(token)
+        if flag is not None and flag in _DENYLIST:
+            raise ValueError(
+                f"llama-server flag '{flag}' is managed by Unsloth Studio "
+                f"and cannot be passed as an extra arg"
+            )
+        out.append(token)
+    return out
+
+
+def is_managed_flag(flag: str) -> bool:
+    """True if ``flag`` is a Studio-managed llama-server flag."""
+    return flag in _DENYLIST
diff --git a/studio/backend/core/inference/orchestrator.py b/studio/backend/core/inference/orchestrator.py
index cb5d9da34a..5562820f49 100644
--- a/studio/backend/core/inference/orchestrator.py
+++ b/studio/backend/core/inference/orchestrator.py
@@ -166,23 +166,30 @@ class InferenceOrchestrator:
 
     def _spawn_subprocess(self, config: dict) -> None:
         """Spawn a new inference subprocess."""
+        from utils.native_path_leases import (
+            native_path_secret_removed_for_child_start,
+            run_without_native_path_secret,
+        )
+
         from .worker import run_inference_process
 
-        self._cmd_queue = _CTX.Queue()
-        self._resp_queue = _CTX.Queue()
-        self._cancel_event = _CTX.Event()
+        with native_path_secret_removed_for_child_start():
+            self._cmd_queue = _CTX.Queue()
+            self._resp_queue = _CTX.Queue()
+            self._cancel_event = _CTX.Event()
 
-        self._proc = _CTX.Process(
-            target = run_inference_process,
-            kwargs = {
-                "cmd_queue": self._cmd_queue,
-                "resp_queue": self._resp_queue,
-                "cancel_event": self._cancel_event,
-                "config": config,
-            },
-            daemon = True,
-        )
-        self._proc.start()
+            self._proc = _CTX.Process(
+                target = run_without_native_path_secret,
+                args = (run_inference_process,),
+                kwargs = {
+                    "cmd_queue": self._cmd_queue,
+                    "resp_queue": self._resp_queue,
+                    "cancel_event": self._cancel_event,
+                    "config": config,
+                },
+                daemon = True,
+            )
+            self._proc.start()
         logger.info("Inference subprocess started (pid=%s)", self._proc.pid)
 
     def _cancel_generation(self) -> None:
@@ -708,6 +715,17 @@ class InferenceOrchestrator:
 
     def unload_model(self, model_name: str) -> bool:
         """Unload a model from the subprocess."""
+        if model_name in self.loading_models:
+            logger.info(
+                "Cancelling in-flight load for model '%s' by terminating subprocess",
+                model_name,
+            )
+            self._shutdown_subprocess(timeout = 0.5)
+            self.loading_models.discard(model_name)
+            self.active_model_name = None
+            self.models.clear()
+            return True
+
         if not self._ensure_subprocess_alive():
             # No subprocess — just clear local state
             self.models.pop(model_name, None)
diff --git a/studio/backend/core/training/resume.py b/studio/backend/core/training/resume.py
new file mode 100644
index 0000000000..165c1c2cf1
--- /dev/null
+++ b/studio/backend/core/training/resume.py
@@ -0,0 +1,75 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+"""Helpers for validating resumable training outputs."""
+
+from pathlib import Path
+from typing import Optional
+
+from utils.paths import outputs_root, resolve_output_dir
+
+
+def _is_under_outputs(path: Path) -> bool:
+    resolved = path.resolve(strict = False)
+    root = outputs_root().resolve(strict = False)
+    try:
+        resolved.relative_to(root)
+        return True
+    except ValueError:
+        return False
+
+
+def has_resume_state(path_value: Optional[str]) -> bool:
+    if not path_value:
+        return False
+    return get_resume_checkpoint_path(path_value) is not None
+
+
+def _checkpoint_step(path: Path) -> int:
+    try:
+        return int(path.name.removeprefix("checkpoint-"))
+    except ValueError:
+        return -1
+
+
+def get_resume_checkpoint_path(path_value: str) -> Optional[str]:
+    path = resolve_output_dir(path_value)
+    if not _is_under_outputs(path) or not path.is_dir():
+        return None
+    if (path / "trainer_state.json").is_file():
+        return str(path)
+
+    checkpoints = [
+        child
+        for child in path.glob("checkpoint-*")
+        if child.is_dir() and (child / "trainer_state.json").is_file()
+    ]
+    if not checkpoints:
+        return None
+    return str(max(checkpoints, key = _checkpoint_step))
+
+
+def normalize_resume_output_dir(path_value: str) -> str:
+    path = resolve_output_dir(path_value)
+    if not _is_under_outputs(path):
+        raise ValueError("Resume checkpoint must be inside Studio outputs.")
+    return str(path)
+
+
+def can_resume_run(run: dict) -> bool:
+    if run.get("resumed_later"):
+        return False
+
+    final_step = run.get("final_step")
+    total_steps = run.get("total_steps")
+    has_remaining_steps = (
+        not isinstance(final_step, int)
+        or not isinstance(total_steps, int)
+        or total_steps <= 0
+        or final_step < total_steps
+    )
+    return (
+        run.get("status") == "stopped"
+        and has_remaining_steps
+        and has_resume_state(run.get("output_dir"))
+    )
diff --git a/studio/backend/core/training/trainer.py b/studio/backend/core/training/trainer.py
index c1e2ac4a85..fe8d277ac0 100644
--- a/studio/backend/core/training/trainer.py
+++ b/studio/backend/core/training/trainer.py
@@ -70,6 +70,7 @@ from utils.paths import (
 )
 from trl import SFTTrainer, SFTConfig
 
+from utils.native_path_leases import child_env_without_native_path_secret
 from utils.subprocess_compat import (
     windows_hidden_subprocess_kwargs as _windows_hidden_subprocess_kwargs,
 )
@@ -376,6 +377,7 @@ class UnslothTrainer:
     def _finalize_training(self, output_dir, label = ""):
         """Save model after training and update progress. Used by all training branches."""
         if self.should_stop and self.save_on_stop:
+            self.trainer._save_checkpoint(self.trainer.model, trial = None)
             self.trainer.save_model()
             self.tokenizer.save_pretrained(output_dir)
             self._patch_adapter_config(output_dir)
@@ -1770,6 +1772,7 @@ class UnslothTrainer:
                     spark_code_dir,
                 ],
                 check = True,
+                env = child_env_without_native_path_secret(),
                 **_windows_hidden_subprocess_kwargs(),
             )
 
@@ -2004,6 +2007,7 @@ class UnslothTrainer:
                     outetts_code_dir,
                 ],
                 check = True,
+                env = child_env_without_native_path_secret(),
                 **_windows_hidden_subprocess_kwargs(),
             )
             for fpath in [
@@ -2828,7 +2832,9 @@ class UnslothTrainer:
                     total_steps = total, status_message = "Starting CSM training..."
                 )
                 logger.info(f"CSM training config: {config}\n")
-                self.trainer.train()
+                self.trainer.train(
+                    resume_from_checkpoint = training_args.get("resume_from_checkpoint")
+                )
                 self._finalize_training(output_dir, "CSM")
                 return
 
@@ -2867,7 +2873,9 @@ class UnslothTrainer:
                     total_steps = total, status_message = "Starting SNAC training..."
                 )
                 logger.info(f"SNAC training config: {config}\n")
-                self.trainer.train()
+                self.trainer.train(
+                    resume_from_checkpoint = training_args.get("resume_from_checkpoint")
+                )
                 self._finalize_training(output_dir, "SNAC")
                 return
 
@@ -2913,7 +2921,9 @@ class UnslothTrainer:
                     total_steps = total, status_message = "Starting Whisper training..."
                 )
                 logger.info(f"Whisper training config: {config}\n")
-                self.trainer.train()
+                self.trainer.train(
+                    resume_from_checkpoint = training_args.get("resume_from_checkpoint")
+                )
                 self._finalize_training(output_dir, "Whisper")
                 return
 
@@ -3408,7 +3418,9 @@ class UnslothTrainer:
             # ========== START TRAINING ==========
             self._update_progress(status_message = "Starting training...")
             logger.info("Starting training...\n")
-            self.trainer.train()
+            self.trainer.train(
+                resume_from_checkpoint = training_args.get("resume_from_checkpoint")
+            )
 
             # ========== SAVE MODEL ==========
             self._finalize_training(output_dir)
diff --git a/studio/backend/core/training/training.py b/studio/backend/core/training/training.py
index f35c7e8ad3..5642faa189 100644
--- a/studio/backend/core/training/training.py
+++ b/studio/backend/core/training/training.py
@@ -29,6 +29,10 @@ from typing import Optional, Tuple, Any
 
 import matplotlib.pyplot as plt
 from utils.hardware import prepare_gpu_selection
+from utils.native_path_leases import (
+    native_path_secret_removed_for_child_start,
+    run_without_native_path_secret,
+)
 
 logger = get_logger(__name__)
 
@@ -185,6 +189,7 @@ class TrainingBackend:
             "wandb_project": kwargs.get("wandb_project", "unsloth-training"),
             "enable_tensorboard": kwargs.get("enable_tensorboard", False),
             "tensorboard_dir": kwargs.get("tensorboard_dir", "runs"),
+            "resume_from_checkpoint": kwargs.get("resume_from_checkpoint"),
             "trust_remote_code": kwargs.get("trust_remote_code", False),
             "gpu_ids": kwargs.get("gpu_ids"),
         }
@@ -212,20 +217,22 @@ class TrainingBackend:
 
         from .worker import run_training_process
 
-        event_queue = _CTX.Queue()
-        stop_queue = _CTX.Queue()
-
-        proc = _CTX.Process(
-            target = run_training_process,
-            kwargs = {
-                "event_queue": event_queue,
-                "stop_queue": stop_queue,
-                "config": config,
-            },
-            daemon = True,
-        )
         try:
-            proc.start()
+            with native_path_secret_removed_for_child_start():
+                event_queue = _CTX.Queue()
+                stop_queue = _CTX.Queue()
+
+                proc = _CTX.Process(
+                    target = run_without_native_path_secret,
+                    args = (run_training_process,),
+                    kwargs = {
+                        "event_queue": event_queue,
+                        "stop_queue": stop_queue,
+                        "config": config,
+                    },
+                    daemon = True,
+                )
+                proc.start()
         except Exception:
             logger.error("Failed to start training subprocess", exc_info = True)
             return False
diff --git a/studio/backend/core/training/worker.py b/studio/backend/core/training/worker.py
index 8ab2b5b2be..60b9e994ab 100644
--- a/studio/backend/core/training/worker.py
+++ b/studio/backend/core/training/worker.py
@@ -35,6 +35,15 @@ from utils.wheel_utils import (
 )
 
 
+def _output_dir_from_resume_checkpoint(
+    resume_from_checkpoint: str | None,
+) -> str | None:
+    if not resume_from_checkpoint:
+        return None
+    path = Path(resume_from_checkpoint)
+    return str(path.parent if path.name.startswith("checkpoint-") else path)
+
+
 _CAUSAL_CONV1D_RELEASE_TAG = "v1.6.1.post4"
 _CAUSAL_CONV1D_PACKAGE_VERSION = "1.6.1"
 _MAMBA_SSM_RELEASE_TAG = "v2.3.1"
@@ -50,6 +59,8 @@ def _model_wants_causal_conv1d(model_name: str) -> bool:
         for key in (
             "qwen3.5",
             "qwen3_5",
+            "qwen3.6",
+            "qwen3_6",
             "qwen3-next",
             "qwen3_next",
             "nemotron_h",
@@ -755,7 +766,10 @@ def run_training_process(
             return
 
         # Generate output dir
-        output_dir = config.get("output_dir")
+        resume_from_checkpoint = config.get("resume_from_checkpoint")
+        output_dir = config.get("output_dir") or _output_dir_from_resume_checkpoint(
+            resume_from_checkpoint
+        )
         if not output_dir:
             output_dir = f"{model_name.replace('/', '_')}_{int(time.time())}"
         output_dir = str(resolve_output_dir(output_dir))
@@ -803,6 +817,7 @@ def run_training_process(
             max_seq_length = config.get("max_seq_length", 2048),
             optim = config.get("optim", "adamw_8bit"),
             lr_scheduler_type = config.get("lr_scheduler_type", "linear"),
+            resume_from_checkpoint = resume_from_checkpoint,
         )
 
         _tqdm_stop.set()
@@ -819,10 +834,13 @@ def run_training_process(
                 }
             )
         else:
+            saved_output_dir = (
+                None if trainer.should_stop and not trainer.save_on_stop else output_dir
+            )
             event_queue.put(
                 {
                     "type": "complete",
-                    "output_dir": output_dir,
+                    "output_dir": saved_output_dir,
                     "status_message": progress.status_message or "Training completed",
                     "ts": time.time(),
                 }
@@ -1107,11 +1125,15 @@ def _run_embedding_training(event_queue: Any, stop_queue: Any, config: dict) ->
         )
         return
 
-    output_dir = config.get("output_dir")
+    resume_from_checkpoint = config.get("resume_from_checkpoint")
+    output_dir = config.get("output_dir") or _output_dir_from_resume_checkpoint(
+        resume_from_checkpoint
+    )
     if not output_dir:
         output_dir = str(
             resolve_output_dir(f"{model_name.replace('/', '_')}_{int(time.time())}")
         )
+    output_dir = str(resolve_output_dir(output_dir))
 
     num_epochs = config.get("num_epochs", 2)
     batch_size = config.get("batch_size", 256)
@@ -1219,7 +1241,7 @@ def _run_embedding_training(event_queue: Any, stop_queue: Any, config: dict) ->
             callbacks = [_EmbeddingProgressCallback()],
         )
 
-        trainer.train()
+        trainer.train(resume_from_checkpoint = resume_from_checkpoint)
     except Exception as e:
         event_queue.put(
             {
@@ -1245,6 +1267,8 @@ def _run_embedding_training(event_queue: Any, stop_queue: Any, config: dict) ->
 
     _send_status(event_queue, "Saving model...")
     try:
+        if _should_stop and _save_on_stop:
+            trainer._save_checkpoint(trainer.model, trial = None)
         model.save_pretrained(output_dir)
         model.tokenizer.save_pretrained(output_dir)
         logger.info("Embedding model saved to %s", output_dir)
diff --git a/studio/backend/loggers/config.py b/studio/backend/loggers/config.py
index 4c0d8ade28..4a27f13d38 100644
--- a/studio/backend/loggers/config.py
+++ b/studio/backend/loggers/config.py
@@ -22,6 +22,8 @@ from typing import Optional
 
 import structlog
 
+from loggers.handlers import filter_sensitive_data
+
 
 class LogConfig:
     """Structured logging configuration for the application.
@@ -58,6 +60,8 @@ class LogConfig:
                 structlog.processors.TimeStamper(fmt = "iso"),  # timestamp first
                 structlog.processors.add_log_level,  # level second
                 structlog.contextvars.merge_contextvars,
+                structlog.processors.format_exc_info,
+                filter_sensitive_data,
                 # Custom processor to flatten the extra field
                 lambda logger, method_name, event_dict: {
                     "timestamp": event_dict.get("timestamp"),
diff --git a/studio/backend/loggers/handlers.py b/studio/backend/loggers/handlers.py
index 3add92ea1e..ddd404cdf3 100644
--- a/studio/backend/loggers/handlers.py
+++ b/studio/backend/loggers/handlers.py
@@ -15,6 +15,7 @@ Key Components:
 - get_logger: Factory function for structured loggers
 """
 
+import re
 import time
 from typing import Callable
 
@@ -22,7 +23,12 @@ import structlog
 from fastapi import Request, Response
 from starlette.middleware.base import BaseHTTPMiddleware
 
+from utils.native_path_leases import redact_native_paths
+
 logger = structlog.get_logger(__name__)
+_NATIVE_PATH_LEASE_RE = re.compile(
+    r"(?i)(\b(?:native_path_lease|nativePathLease)[\"']?\s*[:=]\s*[\"']?)[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+"
+)
 
 
 class LoggingMiddleware(BaseHTTPMiddleware):
@@ -75,6 +81,12 @@ def filter_sensitive_data(logger, method_name, event_dict):
     """Structlog processor to filter out base64 data from logs."""
 
     def filter_value(value):
+        if isinstance(value, str):
+            try:
+                value = redact_native_paths(value)
+            except Exception:
+                pass
+            value = _NATIVE_PATH_LEASE_RE.sub(r"\1<redacted native path lease>", value)
         if (
             isinstance(value, str)
             and len(value) > 100
@@ -83,12 +95,22 @@ def filter_sensitive_data(logger, method_name, event_dict):
             # Likely base64 data, truncate it
             return value[:20] + "..."
         elif isinstance(value, dict):
-            return {k: filter_value(v) for k, v in value.items()}
+            return {
+                k: "<redacted native path lease>"
+                if str(k).replace("_", "").lower() == "nativepathlease"
+                else filter_value(v)
+                for k, v in value.items()
+            }
         elif isinstance(value, list):
             return [filter_value(item) for item in value]
         return value
 
-    return {k: filter_value(v) for k, v in event_dict.items()}
+    return {
+        k: "<redacted native path lease>"
+        if str(k).replace("_", "").lower() == "nativepathlease"
+        else filter_value(v)
+        for k, v in event_dict.items()
+    }
 
 
 def get_logger(name: str) -> structlog.BoundLogger:
diff --git a/studio/backend/main.py b/studio/backend/main.py
index 05adcaa2ea..0958094ff0 100644
--- a/studio/backend/main.py
+++ b/studio/backend/main.py
@@ -62,6 +62,7 @@ from routes import (
     datasets_router,
     export_router,
     inference_router,
+    inference_studio_router,
     models_router,
     training_history_router,
     training_router,
@@ -77,6 +78,7 @@ from utils.hardware import (
 import utils.hardware.hardware as _hw_module
 
 from utils.cache_cleanup import clear_unsloth_compiled_cache
+from utils.native_path_leases import native_path_leases_supported
 
 
 def get_unsloth_version() -> str:
@@ -186,6 +188,8 @@ if _api_only:
         "tauri://localhost",  # Linux/macOS Tauri webview
         "http://tauri.localhost",  # Windows Tauri webview
         "http://localhost",  # dev fallback
+        "http://localhost:5173",  # Tauri dev/Vite
+        "http://127.0.0.1:5173",  # Tauri dev/Vite fallback
     ]
     _cors_origin_regex = None
 else:
@@ -207,6 +211,9 @@ app.include_router(auth_router, prefix = "/api/auth", tags = ["auth"])
 app.include_router(training_router, prefix = "/api/train", tags = ["training"])
 app.include_router(models_router, prefix = "/api/models", tags = ["models"])
 app.include_router(inference_router, prefix = "/api/inference", tags = ["inference"])
+# Studio-only inference endpoints (cancel, etc.) are intentionally NOT
+# exposed on the /v1 OpenAI-compat prefix below.
+app.include_router(inference_studio_router, prefix = "/api/inference", tags = ["inference"])
 
 # OpenAI-compatible endpoints: mount the same inference router at /v1
 # so external tools (Open WebUI, SillyTavern, etc.) can use the
@@ -238,6 +245,7 @@ async def health_check():
         "chat_only": _hw_module.CHAT_ONLY,
         "desktop_protocol_version": 1,
         "supports_desktop_auth": True,
+        "native_path_leases_supported": native_path_leases_supported(),
     }
 
 
diff --git a/studio/backend/models/inference.py b/studio/backend/models/inference.py
index e5b037755d..43087cc5bf 100644
--- a/studio/backend/models/inference.py
+++ b/studio/backend/models/inference.py
@@ -18,6 +18,9 @@ class LoadRequest(BaseModel):
     """Request to load a model for inference"""
 
     model_path: str = Field(..., description = "Model identifier or local path")
+    native_path_lease: Optional[str] = Field(
+        None, description = "Frontend-visible signed native path grant"
+    )
     hf_token: Optional[str] = Field(
         None, description = "HuggingFace token for gated models"
     )
@@ -52,6 +55,16 @@ class LoadRequest(BaseModel):
         None,
         description = "Speculative decoding mode for GGUF models (e.g. 'ngram-simple', 'ngram-mod'). Ignored for non-GGUF and vision models.",
     )
+    llama_extra_args: Optional[List[str]] = Field(
+        None,
+        description = (
+            "Extra arguments forwarded verbatim to llama-server for GGUF models. "
+            "One token per list entry, e.g. ['--top-k', '20', '--seed', '42']. "
+            "Studio-managed flags (model identity, port, context length, GPU placement, "
+            "auth, --flash-attn, --no-context-shift, --jinja) are rejected. Ignored for "
+            "non-GGUF models."
+        ),
+    )
 
 
 class UnloadRequest(BaseModel):
@@ -69,6 +82,9 @@ class ValidateModelRequest(BaseModel):
     """
 
     model_path: str = Field(..., description = "Model identifier or local path")
+    native_path_lease: Optional[str] = Field(
+        None, description = "Frontend-visible signed native path grant"
+    )
     hf_token: Optional[str] = Field(
         None, description = "HuggingFace token for gated models"
     )
@@ -283,6 +299,10 @@ class InferenceStatusResponse(BaseModel):
     supports_tools: bool = Field(
         False, description = "Whether the active model supports tool calling"
     )
+    chat_template: Optional[str] = Field(
+        None,
+        description = "Jinja2 chat template string for the active model",
+    )
     context_length: Optional[int] = Field(
         None, description = "Context length of the active model"
     )
@@ -396,7 +416,10 @@ class ChatMessage(BaseModel):
         if self.name is not None and self.role != "tool":
             raise ValueError('"name" is only valid on role="tool" messages.')
 
-        # Per-role content requirements.
+        # Per-role content requirements. OpenAI-compatible clients may send
+        # ``content=""`` for image-only turns when the image travels in a
+        # companion field such as Studio's ``image_base64`` extension, so treat
+        # empty strings as present content for user/system messages.
         if self.role == "tool":
             if not self.tool_call_id:
                 raise ValueError(
@@ -411,10 +434,8 @@ class ChatMessage(BaseModel):
                     'role="assistant" messages require either "content" or "tool_calls".'
                 )
         else:  # "user" | "system"
-            if not self.content:
-                raise ValueError(
-                    f'role="{self.role}" messages require non-empty "content".'
-                )
+            if self.content is None or self.content == []:
+                raise ValueError(f'role="{self.role}" messages require "content".')
         return self
 
 
@@ -531,6 +552,10 @@ class ChatCompletionRequest(BaseModel):
         None,
         description = "[x-unsloth] Session/thread ID for scoping tool execution sandbox.",
     )
+    cancel_id: Optional[str] = Field(
+        None,
+        description = "[x-unsloth] Per-request cancellation token. Frontend sends a fresh UUID per run so /inference/cancel matches one specific generation.",
+    )
 
 
 # ── Streaming response chunks ────────────────────────────────────
@@ -992,6 +1017,7 @@ class AnthropicMessagesRequest(BaseModel):
     enable_tools: Optional[bool] = None
     enabled_tools: Optional[list[str]] = None
     session_id: Optional[str] = None
+    cancel_id: Optional[str] = None
     model_config = {"extra": "allow"}
 
 
diff --git a/studio/backend/models/training.py b/studio/backend/models/training.py
index 07a306ca39..a9f4caa1bb 100644
--- a/studio/backend/models/training.py
+++ b/studio/backend/models/training.py
@@ -127,6 +127,9 @@ class TrainingStartRequest(BaseModel):
     wandb_project: Optional[str] = Field(None, description = "W&B project name")
     enable_tensorboard: bool = Field(False, description = "Enable TensorBoard logging")
     tensorboard_dir: Optional[str] = Field(None, description = "TensorBoard directory")
+    resume_from_checkpoint: Optional[str] = Field(
+        None, description = "Saved training output directory to resume from"
+    )
 
     # GPU selection
     gpu_ids: Optional[List[int]] = Field(
@@ -220,6 +223,8 @@ class TrainingRunSummary(BaseModel):
     duration_seconds: Optional[float] = None
     error_message: Optional[str] = None
     loss_sparkline: Optional[List[float]] = None
+    can_resume: bool = False
+    resumed_later: bool = False
 
 
 class TrainingRunListResponse(BaseModel):
diff --git a/studio/backend/plugins/data-designer-github-repo-seed/README.md b/studio/backend/plugins/data-designer-github-repo-seed/README.md
new file mode 100644
index 0000000000..346d94b305
--- /dev/null
+++ b/studio/backend/plugins/data-designer-github-repo-seed/README.md
@@ -0,0 +1,73 @@
+# data-designer-github-repo-seed
+
+A Data Designer seed-reader plugin for **Unsloth Studio** that scrapes real
+GitHub data (issues, pull requests, commits) from one or more repositories
+and hands it to the recipe pipeline as a seed dataset.
+
+Designed to ship with Studio as a default seed source so any user with a
+GitHub token can build training datasets straight from live repos.
+
+## What it does
+
+Given a list of `owner/name` repos, a GitHub token, and a per-resource
+`limit`, the plugin uses GitHub's GraphQL API to fetch issues, pull
+requests, and/or commits, with labels, state, authors, and the first N
+comments of each item, and materialises a single JSONL with uniform
+columns so the rest of the recipe (LLM text / LLM structured / processors)
+can treat it like any other seed table.
+
+| Column        | Description                                    |
+|---------------|------------------------------------------------|
+| `item_type`   | `issue` / `pull` / `commit`                    |
+| `repo`        | `owner/name`                                   |
+| `number`      | Issue/PR number, or commit SHA                 |
+| `title`       | Title (or commit message headline)             |
+| `body`        | Issue/PR body (or full commit message)         |
+| `state`       | `OPEN` / `CLOSED` / `MERGED` (empty for commit)|
+| `author`      | GitHub login of the author                     |
+| `created_at`  | ISO8601                                        |
+| `closed_at`   | ISO8601 (empty for commits)                    |
+| `url`         | Permalink                                      |
+| `labels`      | List of label names                            |
+| `comments`    | First N comments concatenated                  |
+
+## Usage in a recipe
+
+```json
+{
+  "seed_config": {
+    "source": {
+      "seed_type": "github_repo",
+      "repos": ["unslothai/unsloth", "unslothai/unsloth-zoo"],
+      "token": "",
+      "item_types": ["issues", "pulls"],
+      "limit": 100,
+      "include_comments": true,
+      "max_comments_per_item": 30
+    },
+    "sampling_strategy": "shuffle",
+    "selection_strategy": null
+  }
+}
+```
+
+Leave `token` empty to fall back to the server's `GH_TOKEN` / `GITHUB_TOKEN`
+environment variable, useful when the recipe is published and shouldn't
+carry a secret.
+
+## Auth
+
+A GitHub personal access token with `public_repo` scope is enough for public
+repositories; `repo` scope is required for private ones. GraphQL requests
+are rate-limit aware: the client inspects `x-ratelimit-*` headers and
+sleeps until reset when the budget drops below a safety threshold.
+
+## Install
+
+Shipped as a default Studio plugin. For development:
+
+```bash
+pip install -e .
+```
+
+Registered automatically via the `data_designer.plugins` entry point.
diff --git a/studio/backend/plugins/data-designer-github-repo-seed/pyproject.toml b/studio/backend/plugins/data-designer-github-repo-seed/pyproject.toml
new file mode 100644
index 0000000000..e232adc60c
--- /dev/null
+++ b/studio/backend/plugins/data-designer-github-repo-seed/pyproject.toml
@@ -0,0 +1,25 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "data-designer-github-repo-seed"
+version = "0.1.0"
+description = "Unsloth Studio seed plugin that scrapes GitHub issues, PRs, and commits."
+requires-python = ">=3.11"
+dependencies = [
+  "data-designer-engine>=0.5.4,<0.6",
+  "requests>=2.31",
+]
+
+[project.entry-points."data_designer.plugins"]
+github_repo_seed = "data_designer_github_repo_seed.plugin:github_repo_seed_plugin"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
diff --git a/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/__init__.py b/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/__init__.py
new file mode 100644
index 0000000000..f57af4c6c3
--- /dev/null
+++ b/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/__init__.py
@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+# Intentionally empty. Data-designer loads submodules lazily via qualified names
+# (impl_qualified_name / config_qualified_name in plugin.py), so importing this
+# package must NOT touch modules that depend on data_designer.engine.* during
+# Studio's bootstrap (circular import).
diff --git a/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/config.py b/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/config.py
new file mode 100644
index 0000000000..6b347c4f83
--- /dev/null
+++ b/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/config.py
@@ -0,0 +1,64 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import Field, field_validator, model_validator
+
+from data_designer.config.seed_source import SeedSource
+
+
+class GitHubRepoSeedSource(SeedSource):
+    seed_type: Literal["github_repo"] = "github_repo"
+
+    repos: list[str] = Field(
+        default_factory = list,
+        description = "List of GitHub repositories to scrape, each in `owner/name` form.",
+    )
+    token: str = Field(
+        default = "",
+        description = "Personal access token. Leave blank to read GH_TOKEN / GITHUB_TOKEN from env at run time.",
+    )
+    item_types: list[Literal["issues", "pulls", "commits"]] = Field(
+        default = ["issues", "pulls"],
+        description = "Which GitHub item types to fetch per repo.",
+    )
+    limit: int = Field(
+        default = 100,
+        ge = 1,
+        le = 5000,
+        description = "Maximum items per repo per item type (e.g. limit=100 + ['issues','pulls'] => up to 200 items per repo).",
+    )
+    include_comments: bool = Field(
+        default = True,
+        description = "Fetch the first N comments of each issue/PR and include them in the `comments` column.",
+    )
+    max_comments_per_item: int = Field(default = 30, ge = 0, le = 200)
+
+    @field_validator("repos")
+    @classmethod
+    def _validate_repos(cls, v: list[str]) -> list[str]:
+        out: list[str] = []
+        for r in v or []:
+            r = r.strip()
+            if not r:
+                continue
+            if r.count("/") != 1 or not all(r.split("/")):
+                raise ValueError(f"Each repo must be `owner/name`; got {r!r}")
+            out.append(r)
+        return out
+
+    @field_validator("item_types")
+    @classmethod
+    def _validate_item_types(cls, v: list[str]) -> list[str]:
+        if not v:
+            raise ValueError("item_types must not be empty")
+        return list(dict.fromkeys(v))
+
+    @model_validator(mode = "after")
+    def _ensure_repos(self) -> "GitHubRepoSeedSource":
+        if not self.repos:
+            raise ValueError("At least one repo is required")
+        return self
diff --git a/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/impl.py b/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/impl.py
new file mode 100644
index 0000000000..5a38e26d6b
--- /dev/null
+++ b/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/impl.py
@@ -0,0 +1,83 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+from __future__ import annotations
+
+import hashlib
+import tempfile
+import threading
+from pathlib import Path
+from typing import Optional
+
+import data_designer.lazy_heavy_imports as lazy
+from data_designer.engine.resources.seed_reader import SeedReader
+
+from .config import GitHubRepoSeedSource
+from .scraper import ScrapeConfig, materialize_to_jsonl
+
+
+# In-process cache mapping a stable config signature to the JSONL materialization
+# path. A single recipe job invokes the seed reader multiple times (validation,
+# preview, per-column sampling), and the default flow re-scrapes the repo on
+# every call: for a 2-repo preview that is ~15s of redundant GitHub GraphQL
+# traffic before any generation fires. Memoize the materialization so the second
+# and third passes reuse the file the first pass wrote. Cache key excludes the
+# raw token and uses a short SHA-256 digest so token values never hit memory
+# twice and token rotation invalidates cleanly.
+_SCRAPE_CACHE: dict[tuple, str] = {}
+_SCRAPE_CACHE_LOCK = threading.Lock()
+
+
+def _scrape_cache_key(cfg: ScrapeConfig) -> tuple:
+    token_digest = hashlib.sha256(
+        (cfg.token or "").encode("utf-8"),
+    ).hexdigest()[:16]
+    return (
+        tuple(cfg.repos),
+        tuple(cfg.item_types),
+        cfg.limit,
+        bool(cfg.include_comments),
+        cfg.max_comments_per_item,
+        token_digest,
+    )
+
+
+def _lookup_cached_scrape(key: tuple) -> Optional[str]:
+    with _SCRAPE_CACHE_LOCK:
+        path = _SCRAPE_CACHE.get(key)
+    if path and Path(path).exists():
+        return path
+    # Stale entry (tmp cleanup, user restarted, ...); drop it so the caller
+    # materializes a fresh file rather than returning a dangling path.
+    if path:
+        with _SCRAPE_CACHE_LOCK:
+            _SCRAPE_CACHE.pop(key, None)
+    return None
+
+
+def _store_cached_scrape(key: tuple, path: str) -> None:
+    with _SCRAPE_CACHE_LOCK:
+        _SCRAPE_CACHE[key] = path
+
+
+class GitHubRepoSeedReader(SeedReader[GitHubRepoSeedSource]):
+    def create_duckdb_connection(self):
+        return lazy.duckdb.connect()
+
+    def get_dataset_uri(self) -> str:
+        out_dir = Path(tempfile.gettempdir()) / "studio-github-repo-seed"
+        cfg = ScrapeConfig(
+            repos = list(self.source.repos),
+            token = self.source.token,
+            item_types = list(self.source.item_types),
+            limit = self.source.limit,
+            include_comments = self.source.include_comments,
+            max_comments_per_item = self.source.max_comments_per_item,
+        )
+        cache_key = _scrape_cache_key(cfg)
+        cached_path = _lookup_cached_scrape(cache_key)
+        if cached_path is not None:
+            return cached_path
+        path = materialize_to_jsonl(cfg, out_dir)
+        _store_cached_scrape(cache_key, str(path))
+        return str(path)
diff --git a/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/plugin.py b/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/plugin.py
new file mode 100644
index 0000000000..f87dbd0507
--- /dev/null
+++ b/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/plugin.py
@@ -0,0 +1,10 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+from data_designer.plugins.plugin import Plugin, PluginType
+
+github_repo_seed_plugin = Plugin(
+    impl_qualified_name = "data_designer_github_repo_seed.impl.GitHubRepoSeedReader",
+    config_qualified_name = "data_designer_github_repo_seed.config.GitHubRepoSeedSource",
+    plugin_type = PluginType.SEED_READER,
+)
diff --git a/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/scraper.py b/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/scraper.py
new file mode 100644
index 0000000000..d768fe37be
--- /dev/null
+++ b/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/scraper.py
@@ -0,0 +1,236 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+"""Multi-repo GitHub scraper for the Studio seed plugin.
+
+Drives the GraphQL-based scraper in `scraper_impl/` per repo. Each repo is
+scraped with a trial_limits cap so we stop at `limit` items per resource.
+After scraping, we read the per-resource JSONL shards and flatten them into
+a single unified JSONL with stable columns (`item_type`, `repo`, `number`,
+`title`, `body`, ...).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import time
+import uuid
+from dataclasses import dataclass
+from pathlib import Path
+
+# Defer scraper_impl imports until `scrape()` runs with a resolved token.
+_IMPL_DIR = Path(__file__).parent / "scraper_impl"
+
+
+def _ensure_impl_on_path() -> None:
+    if str(_IMPL_DIR) not in sys.path:
+        sys.path.insert(0, str(_IMPL_DIR))
+
+
+def _load_impl():
+    _ensure_impl_on_path()
+    import importlib
+
+    gh_client = importlib.import_module("gh_client")  # type: ignore
+    scraper_mod = importlib.import_module("scraper")  # type: ignore
+    return gh_client.GitHubClient, scraper_mod.RepoScraper
+
+
+@dataclass
+class ScrapeConfig:
+    repos: list[str]
+    token: str
+    item_types: list[str]
+    limit: int
+    include_comments: bool
+    max_comments_per_item: int
+
+
+def _resolve_token(token: str) -> str:
+    tok = token or os.environ.get("GH_TOKEN", "") or os.environ.get("GITHUB_TOKEN", "")
+    if not tok:
+        raise ValueError(
+            "GitHub token is required. Set it in the recipe config or the GH_TOKEN / GITHUB_TOKEN env var."
+        )
+    return tok
+
+
+def _read_jsonl(path: Path, max_rows: int | None = None):
+    if not path.exists():
+        return
+    with path.open(encoding = "utf-8") as f:
+        for i, line in enumerate(f):
+            if not line.strip():
+                continue
+            if max_rows is not None and i >= max_rows:
+                return
+            try:
+                yield json.loads(line)
+            except json.JSONDecodeError:
+                continue
+
+
+def _flatten_issue_row(r: dict, repo: str, include_comments: bool, max_c: int) -> dict:
+    labels = [
+        l.get("name")
+        for l in (r.get("labels", {}) or {}).get("nodes", [])
+        if l.get("name")
+    ]
+    comments_nodes = (r.get("comments") or {}).get("nodes") or []
+    comments_text = ""
+    if include_comments and comments_nodes:
+        kept = comments_nodes[:max_c]
+        comments_text = "\n\n".join(
+            f"[{(c.get('author') or {}).get('login', '?')}]: {c.get('body') or ''}"
+            for c in kept
+        )
+    return {
+        "item_type": "issue",
+        "repo": repo,
+        "number": r.get("number"),
+        "title": r.get("title") or "",
+        "body": r.get("body") or "",
+        "state": r.get("state") or "",
+        "author": (r.get("author") or {}).get("login", ""),
+        "created_at": r.get("createdAt") or "",
+        "closed_at": r.get("closedAt") or "",
+        "url": r.get("url") or r.get("permalink") or "",
+        "labels": labels,
+        "comments": comments_text,
+    }
+
+
+def _flatten_pr_row(r: dict, repo: str, include_comments: bool, max_c: int) -> dict:
+    labels = [
+        l.get("name")
+        for l in (r.get("labels", {}) or {}).get("nodes", [])
+        if l.get("name")
+    ]
+    comments_nodes = (r.get("comments") or {}).get("nodes") or []
+    comments_text = ""
+    if include_comments and comments_nodes:
+        kept = comments_nodes[:max_c]
+        comments_text = "\n\n".join(
+            f"[{(c.get('author') or {}).get('login', '?')}]: {c.get('body') or ''}"
+            for c in kept
+        )
+    return {
+        "item_type": "pull",
+        "repo": repo,
+        "number": r.get("number"),
+        "title": r.get("title") or "",
+        "body": r.get("body") or "",
+        "state": r.get("state") or "",
+        "author": (r.get("author") or {}).get("login", ""),
+        "created_at": r.get("createdAt") or "",
+        "closed_at": r.get("closedAt") or "",
+        "url": r.get("url") or r.get("permalink") or "",
+        "labels": labels,
+        "comments": comments_text,
+    }
+
+
+def _flatten_commit_row(r: dict, repo: str) -> dict:
+    msg = r.get("messageHeadline") or r.get("message") or ""
+    body = r.get("messageBody") or r.get("message") or msg
+    author = r.get("author") or {}
+    return {
+        "item_type": "commit",
+        "repo": repo,
+        "number": r.get("oid") or r.get("sha") or "",
+        "title": msg,
+        "body": body,
+        "state": "",
+        "author": (author.get("user") or {}).get("login") or author.get("name", ""),
+        "created_at": (author.get("date") or r.get("committedDate") or ""),
+        "closed_at": "",
+        "url": r.get("url") or "",
+        "labels": [],
+        "comments": "",
+    }
+
+
+def scrape(cfg: ScrapeConfig, base_dir: Path):
+    token = _resolve_token(cfg.token)
+    GitHubClient, RepoScraper = _load_impl()
+    client = GitHubClient(token = token)
+    base_dir.mkdir(parents = True, exist_ok = True)
+
+    # Per-resource trial limits. limit <= 0 means "all": use a very large cap.
+    effective_limit = cfg.limit if cfg.limit and cfg.limit > 0 else 1_000_000
+    trial_limits: dict[str, int] = {}
+    if "issues" in cfg.item_types:
+        trial_limits["issues"] = effective_limit
+    if "pulls" in cfg.item_types:
+        trial_limits["pull_requests"] = effective_limit
+    if "commits" in cfg.item_types:
+        trial_limits["commits"] = effective_limit
+
+    all_rows: list[dict] = []
+    for repo in cfg.repos:
+        owner, name = repo.split("/", 1)
+        scraper = RepoScraper(
+            owner = owner,
+            name = name,
+            base_dir = base_dir,
+            client = client,
+            trial_limits = trial_limits,
+            light = True,
+        )
+        try:
+            repo_meta = scraper.scrape_repo_meta()
+            if "issues" in cfg.item_types:
+                scraper.scrape_issues()
+            if "pulls" in cfg.item_types:
+                scraper.scrape_prs()
+            if "commits" in cfg.item_types:
+                default_ref = repo_meta.get("defaultBranchRef") or {}
+                default_branch = (
+                    default_ref.get("name") if isinstance(default_ref, dict) else None
+                )
+                branch = (
+                    f"refs/heads/{default_branch}"
+                    if default_branch
+                    else "refs/heads/main"
+                )
+                scraper.scrape_commits(branch = branch)
+        finally:
+            scraper.close()
+
+        read_cap = cfg.limit if cfg.limit and cfg.limit > 0 else None
+        repo_dir = base_dir / f"{owner}__{name}"
+        if "issues" in cfg.item_types:
+            for row in _read_jsonl(repo_dir / "issues.jsonl", read_cap):
+                all_rows.append(
+                    _flatten_issue_row(
+                        row, repo, cfg.include_comments, cfg.max_comments_per_item
+                    )
+                )
+        if "pulls" in cfg.item_types:
+            for row in _read_jsonl(repo_dir / "pull_requests.jsonl", read_cap):
+                all_rows.append(
+                    _flatten_pr_row(
+                        row, repo, cfg.include_comments, cfg.max_comments_per_item
+                    )
+                )
+        if "commits" in cfg.item_types:
+            for row in _read_jsonl(repo_dir / "commits.jsonl", read_cap):
+                all_rows.append(_flatten_commit_row(row, repo))
+
+    return all_rows
+
+
+def materialize_to_jsonl(cfg: ScrapeConfig, out_dir: Path) -> Path:
+    out_dir.mkdir(parents = True, exist_ok = True)
+    tag = "-".join(r.replace("/", "__") for r in cfg.repos)[:120]
+    kinds = "-".join(cfg.item_types)
+    run_id = f"{int(time.time())}-{uuid.uuid4().hex[:12]}"
+    fname = f"github_{tag}__{kinds}__{cfg.limit}_{run_id}.jsonl"
+    out = out_dir / fname
+    rows = scrape(cfg, out_dir / "raw-runs" / run_id)
+    with out.open("w", encoding = "utf-8") as f:
+        for r in rows:
+            f.write(json.dumps(r, ensure_ascii = False) + "\n")
+    return out
diff --git a/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/scraper_impl/__init__.py b/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/scraper_impl/__init__.py
new file mode 100644
index 0000000000..32014236c6
--- /dev/null
+++ b/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/scraper_impl/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
diff --git a/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/scraper_impl/gh_client.py b/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/scraper_impl/gh_client.py
new file mode 100644
index 0000000000..dd2de2f5ce
--- /dev/null
+++ b/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/scraper_impl/gh_client.py
@@ -0,0 +1,248 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+"""GitHub API client with rate-limit awareness, retry, and dual REST/GraphQL support."""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+import logging
+from typing import Any, Dict, Iterable, Iterator, List, Optional
+
+import requests
+
+log = logging.getLogger("gh_client")
+
+GRAPHQL_URL = "https://api.github.com/graphql"
+REST_BASE = "https://api.github.com"
+
+BASE_HEADERS = {
+    "Accept": "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2022-11-28",
+    "User-Agent": "github-data-gatherer/1.0",
+}
+
+
+class RateLimitError(Exception):
+    pass
+
+
+class GitHubClient:
+    def __init__(
+        self,
+        min_remaining_graphql: int = 100,
+        min_remaining_rest: int = 100,
+        token: str | None = None,
+    ):
+        token = token or os.environ.get("GH_TOKEN") or os.environ.get("GITHUB_TOKEN")
+        if not token:
+            raise RuntimeError("GH_TOKEN not set in environment")
+        self.session = requests.Session()
+        self.session.headers.update(
+            {**BASE_HEADERS, "Authorization": f"Bearer {token}"}
+        )
+        self.min_remaining_graphql = min_remaining_graphql
+        self.min_remaining_rest = min_remaining_rest
+        self.graphql_remaining: Optional[int] = None
+        self.graphql_reset: Optional[int] = None
+        self.rest_remaining: Optional[int] = None
+        self.rest_reset: Optional[int] = None
+        self.calls_graphql = 0
+        self.calls_rest = 0
+        self.retry_count = 0
+
+    def _sleep_until(self, reset_ts: int, buffer_s: int = 10) -> None:
+        now = int(time.time())
+        wait = max(0, reset_ts - now) + buffer_s
+        log.warning("Rate limit hit. Sleeping %ds until reset.", wait)
+        time.sleep(wait)
+
+    def _check_rate_and_wait(self, kind: str) -> None:
+        if kind == "graphql":
+            remaining = self.graphql_remaining
+            reset = self.graphql_reset
+            min_remaining = self.min_remaining_graphql
+        else:
+            remaining = self.rest_remaining
+            reset = self.rest_reset
+            min_remaining = self.min_remaining_rest
+        if remaining is not None and remaining < min_remaining:
+            if reset:
+                self._sleep_until(reset)
+                # Reset remaining so we don't spin
+                if kind == "graphql":
+                    self.graphql_remaining = None
+                else:
+                    self.rest_remaining = None
+
+    def graphql(
+        self,
+        query: str,
+        variables: Optional[Dict[str, Any]] = None,
+        max_retries: int = 20,
+    ) -> Dict[str, Any]:
+        self._check_rate_and_wait("graphql")
+        backoff = 2
+        last_err = None
+        for attempt in range(max_retries):
+            try:
+                r = self.session.post(
+                    GRAPHQL_URL,
+                    json = {"query": query, "variables": variables or {}},
+                    timeout = 120,
+                )
+                self.calls_graphql += 1
+                # Update rate info from response headers
+                rem = r.headers.get("X-RateLimit-Remaining")
+                rst = r.headers.get("X-RateLimit-Reset")
+                if rem is not None:
+                    try:
+                        self.graphql_remaining = int(rem)
+                    except ValueError:
+                        pass
+                if rst is not None:
+                    try:
+                        self.graphql_reset = int(rst)
+                    except ValueError:
+                        pass
+                if r.status_code in (502, 503, 504):
+                    log.warning("GraphQL %s transient, retrying", r.status_code)
+                    time.sleep(backoff)
+                    backoff = min(backoff * 2, 60)
+                    continue
+                if r.status_code == 403 or r.status_code == 429:
+                    # Check for secondary/abuse
+                    retry_after = r.headers.get("Retry-After")
+                    if retry_after:
+                        t = int(retry_after)
+                        log.warning("Secondary rate limit. Sleep %ds.", t)
+                        time.sleep(t + 2)
+                        continue
+                    if self.graphql_reset:
+                        self._sleep_until(self.graphql_reset)
+                        continue
+                    time.sleep(60)
+                    continue
+                r.raise_for_status()
+                data = r.json()
+                if "errors" in data and data["errors"]:
+                    # Surface errors but allow partial data
+                    errs = data["errors"]
+                    # Retry on RATE_LIMITED
+                    for e in errs:
+                        if e.get("type") == "RATE_LIMITED":
+                            self._sleep_until(
+                                (self.graphql_reset or int(time.time()) + 60)
+                            )
+                            break
+                    else:
+                        # No rate-limit error, log and return partial
+                        log.warning("GraphQL errors: %s", json.dumps(errs)[:400])
+                        return data
+                    continue
+                return data
+            except requests.RequestException as e:
+                last_err = e
+                log.warning("GraphQL network error: %s. Retry.", e)
+                time.sleep(backoff)
+                backoff = min(backoff * 2, 60)
+        raise RuntimeError(f"GraphQL failed after {max_retries} retries: {last_err}")
+
+    def rest(
+        self,
+        method: str,
+        path: str,
+        params: Optional[Dict[str, Any]] = None,
+        json_body: Optional[Dict[str, Any]] = None,
+        max_retries: int = 6,
+    ) -> requests.Response:
+        self._check_rate_and_wait("rest")
+        if path.startswith("http"):
+            url = path
+        else:
+            url = REST_BASE + path
+        backoff = 2
+        last_err = None
+        for attempt in range(max_retries):
+            try:
+                r = self.session.request(
+                    method, url, params = params, json = json_body, timeout = 120
+                )
+                self.calls_rest += 1
+                rem = r.headers.get("X-RateLimit-Remaining")
+                rst = r.headers.get("X-RateLimit-Reset")
+                if rem is not None:
+                    try:
+                        self.rest_remaining = int(rem)
+                    except ValueError:
+                        pass
+                if rst is not None:
+                    try:
+                        self.rest_reset = int(rst)
+                    except ValueError:
+                        pass
+                if r.status_code in (502, 503, 504):
+                    log.warning("REST %s transient, retrying", r.status_code)
+                    time.sleep(backoff)
+                    backoff = min(backoff * 2, 60)
+                    continue
+                if r.status_code in (403, 429):
+                    retry_after = r.headers.get("Retry-After")
+                    if retry_after:
+                        t = int(retry_after)
+                        log.warning("Secondary rate limit on REST. Sleep %ds.", t)
+                        time.sleep(t + 2)
+                        continue
+                    # Check if primary rate
+                    if self.rest_remaining == 0 and self.rest_reset:
+                        self._sleep_until(self.rest_reset)
+                        continue
+                    log.warning("REST 403/429, sleep 60")
+                    time.sleep(60)
+                    continue
+                return r
+            except requests.RequestException as e:
+                last_err = e
+                log.warning("REST network error: %s. Retry.", e)
+                time.sleep(backoff)
+                backoff = min(backoff * 2, 60)
+        raise RuntimeError(f"REST failed after {max_retries} retries: {last_err}")
+
+    def rest_paginate(
+        self, path: str, params: Optional[Dict[str, Any]] = None, per_page: int = 100
+    ) -> Iterator[dict]:
+        params = dict(params or {})
+        params.setdefault("per_page", per_page)
+        url = path
+        while True:
+            r = self.rest("GET", url, params = params if url == path else None)
+            if r.status_code != 200:
+                log.error(
+                    "REST paginate got %s at %s: %s", r.status_code, url, r.text[:200]
+                )
+                return
+            items = r.json()
+            if isinstance(items, dict):
+                # Some endpoints return dict with list field
+                items = items.get("items", [])
+            for it in items:
+                yield it
+            # Follow link header
+            link = r.headers.get("Link", "")
+            nxt = None
+            for part in link.split(","):
+                if 'rel="next"' in part:
+                    nxt = part.split(";")[0].strip().strip("<>")
+                    break
+            if not nxt:
+                return
+            url = nxt
+            params = None
+
+    def rate_snapshot(self) -> Dict[str, Any]:
+        r = self.rest("GET", "/rate_limit")
+        if r.status_code == 200:
+            return r.json()
+        return {}
diff --git a/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/scraper_impl/queries.py b/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/scraper_impl/queries.py
new file mode 100644
index 0000000000..9dc7613db5
--- /dev/null
+++ b/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/scraper_impl/queries.py
@@ -0,0 +1,685 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+"""GraphQL queries for GitHub data scraping.
+
+GitHub's GraphQL rejects queries that define unused fragments, so each query
+only includes the fragments it actually references.
+"""
+
+# ---- Fragments (kept as raw strings, composed per query) ----
+F_ACTOR = """
+fragment ActorFields on Actor {
+  __typename
+  login
+  url
+  avatarUrl
+  ... on User { id databaseId name }
+  ... on Bot { id databaseId }
+  ... on Organization { id databaseId name }
+}
+"""
+
+F_LABEL = """
+fragment LabelFields on Label {
+  id
+  name
+  color
+  description
+  createdAt
+}
+"""
+
+F_TIMELINE = """
+fragment TimelineItem on IssueTimelineItems {
+  __typename
+  ... on Node { id }
+  ... on AddedToProjectEvent { createdAt actor { ...ActorFields } }
+  ... on AssignedEvent { createdAt actor { ...ActorFields } assignee { __typename ... on User { login } ... on Bot { login } } }
+  ... on ClosedEvent { createdAt actor { ...ActorFields } stateReason closer { __typename ... on Commit { oid url } ... on PullRequest { number url } } }
+  ... on CommentDeletedEvent { createdAt actor { ...ActorFields } }
+  ... on ConnectedEvent { createdAt actor { ...ActorFields } source { __typename ... on Issue { number url repository { nameWithOwner } } ... on PullRequest { number url repository { nameWithOwner } } } subject { __typename ... on Issue { number url } ... on PullRequest { number url } } }
+  ... on ConvertedNoteToIssueEvent { createdAt actor { ...ActorFields } }
+  ... on CrossReferencedEvent { createdAt actor { ...ActorFields } isCrossRepository willCloseTarget source { __typename ... on Issue { number url repository { nameWithOwner } title } ... on PullRequest { number url repository { nameWithOwner } title } } }
+  ... on DemilestonedEvent { createdAt actor { ...ActorFields } milestoneTitle }
+  ... on DisconnectedEvent { createdAt actor { ...ActorFields } subject { __typename ... on Issue { number url } ... on PullRequest { number url } } source { __typename ... on Issue { number url } ... on PullRequest { number url } } }
+  ... on IssueComment { id databaseId createdAt updatedAt author { ...ActorFields } body url reactionGroups { content reactors { totalCount } } }
+  ... on LabeledEvent { createdAt actor { ...ActorFields } label { name color } }
+  ... on LockedEvent { createdAt actor { ...ActorFields } lockReason }
+  ... on MarkedAsDuplicateEvent { createdAt actor { ...ActorFields } canonical { __typename ... on Issue { number url } ... on PullRequest { number url } } }
+  ... on MentionedEvent { createdAt actor { ...ActorFields } }
+  ... on MilestonedEvent { createdAt actor { ...ActorFields } milestoneTitle }
+  ... on MovedColumnsInProjectEvent { createdAt actor { ...ActorFields } }
+  ... on PinnedEvent { createdAt actor { ...ActorFields } }
+  ... on ReferencedEvent { createdAt actor { ...ActorFields } commit { oid url } commitRepository { nameWithOwner } }
+  ... on RemovedFromProjectEvent { createdAt actor { ...ActorFields } }
+  ... on RenamedTitleEvent { createdAt actor { ...ActorFields } previousTitle currentTitle }
+  ... on ReopenedEvent { createdAt actor { ...ActorFields } }
+  ... on SubscribedEvent { createdAt actor { ...ActorFields } }
+  ... on TransferredEvent { createdAt actor { ...ActorFields } fromRepository { nameWithOwner } }
+  ... on UnassignedEvent { createdAt actor { ...ActorFields } assignee { __typename ... on User { login } ... on Bot { login } } }
+  ... on UnlabeledEvent { createdAt actor { ...ActorFields } label { name color } }
+  ... on UnlockedEvent { createdAt actor { ...ActorFields } }
+  ... on UnmarkedAsDuplicateEvent { createdAt actor { ...ActorFields } }
+  ... on UnpinnedEvent { createdAt actor { ...ActorFields } }
+  ... on UnsubscribedEvent { createdAt actor { ...ActorFields } }
+  ... on UserBlockedEvent { createdAt actor { ...ActorFields } blockDuration }
+}
+"""
+
+F_PR_TIMELINE = """
+fragment PRTimelineItem on PullRequestTimelineItems {
+  __typename
+  ... on Node { id }
+  ... on AssignedEvent { createdAt actor { ...ActorFields } assignee { __typename ... on User { login } ... on Bot { login } } }
+  ... on AutoMergeDisabledEvent { createdAt actor { ...ActorFields } reason }
+  ... on AutoMergeEnabledEvent { createdAt actor { ...ActorFields } }
+  ... on AutoRebaseEnabledEvent { createdAt actor { ...ActorFields } }
+  ... on AutoSquashEnabledEvent { createdAt actor { ...ActorFields } }
+  ... on AutomaticBaseChangeFailedEvent { createdAt actor { ...ActorFields } oldBase newBase }
+  ... on AutomaticBaseChangeSucceededEvent { createdAt actor { ...ActorFields } oldBase newBase }
+  ... on BaseRefChangedEvent { createdAt actor { ...ActorFields } previousRefName currentRefName }
+  ... on BaseRefDeletedEvent { createdAt actor { ...ActorFields } baseRefName }
+  ... on BaseRefForcePushedEvent { createdAt actor { ...ActorFields } beforeCommit { oid } afterCommit { oid } ref { name } }
+  ... on ClosedEvent { createdAt actor { ...ActorFields } stateReason }
+  ... on CommentDeletedEvent { createdAt actor { ...ActorFields } }
+  ... on ConnectedEvent { createdAt actor { ...ActorFields } source { __typename ... on Issue { number url } ... on PullRequest { number url } } subject { __typename ... on Issue { number url } ... on PullRequest { number url } } }
+  ... on ConvertToDraftEvent { createdAt actor { ...ActorFields } }
+  ... on CrossReferencedEvent { createdAt actor { ...ActorFields } isCrossRepository willCloseTarget source { __typename ... on Issue { number url repository { nameWithOwner } title } ... on PullRequest { number url repository { nameWithOwner } title } } }
+  ... on DemilestonedEvent { createdAt actor { ...ActorFields } milestoneTitle }
+  ... on DeployedEvent { createdAt actor { ...ActorFields } }
+  ... on DeploymentEnvironmentChangedEvent { createdAt actor { ...ActorFields } }
+  ... on DisconnectedEvent { createdAt actor { ...ActorFields } subject { __typename ... on Issue { number url } ... on PullRequest { number url } } source { __typename ... on Issue { number url } ... on PullRequest { number url } } }
+  ... on HeadRefDeletedEvent { createdAt actor { ...ActorFields } headRefName }
+  ... on HeadRefForcePushedEvent { createdAt actor { ...ActorFields } beforeCommit { oid } afterCommit { oid } ref { name } }
+  ... on HeadRefRestoredEvent { createdAt actor { ...ActorFields } }
+  ... on IssueComment { id databaseId createdAt updatedAt author { ...ActorFields } body url reactionGroups { content reactors { totalCount } } }
+  ... on LabeledEvent { createdAt actor { ...ActorFields } label { name color } }
+  ... on LockedEvent { createdAt actor { ...ActorFields } lockReason }
+  ... on MarkedAsDuplicateEvent { createdAt actor { ...ActorFields } canonical { __typename ... on Issue { number url } ... on PullRequest { number url } } }
+  ... on MentionedEvent { createdAt actor { ...ActorFields } }
+  ... on MergedEvent { createdAt actor { ...ActorFields } commit { oid url } mergeRefName }
+  ... on MilestonedEvent { createdAt actor { ...ActorFields } milestoneTitle }
+  ... on MovedColumnsInProjectEvent { createdAt actor { ...ActorFields } }
+  ... on PinnedEvent { createdAt actor { ...ActorFields } }
+  ... on PullRequestCommit { commit { oid url message author { user { login } date } committedDate } }
+  ... on PullRequestCommitCommentThread { commit { oid } }
+  ... on PullRequestReview { id databaseId createdAt submittedAt author { ...ActorFields } body state url reactionGroups { content reactors { totalCount } } }
+  ... on PullRequestReviewThread { id isResolved isOutdated path line diffSide }
+  ... on PullRequestRevisionMarker { createdAt lastSeenCommit { oid } }
+  ... on ReadyForReviewEvent { createdAt actor { ...ActorFields } }
+  ... on ReferencedEvent { createdAt actor { ...ActorFields } commit { oid url } commitRepository { nameWithOwner } }
+  ... on RenamedTitleEvent { createdAt actor { ...ActorFields } previousTitle currentTitle }
+  ... on ReopenedEvent { createdAt actor { ...ActorFields } }
+  ... on ReviewDismissedEvent { createdAt actor { ...ActorFields } dismissalMessage previousReviewState }
+  ... on ReviewRequestRemovedEvent { createdAt actor { ...ActorFields } requestedReviewer { __typename ... on User { login } ... on Team { name } } }
+  ... on ReviewRequestedEvent { createdAt actor { ...ActorFields } requestedReviewer { __typename ... on User { login } ... on Team { name } } }
+  ... on SubscribedEvent { createdAt actor { ...ActorFields } }
+  ... on TransferredEvent { createdAt actor { ...ActorFields } fromRepository { nameWithOwner } }
+  ... on UnassignedEvent { createdAt actor { ...ActorFields } assignee { __typename ... on User { login } ... on Bot { login } } }
+  ... on UnlabeledEvent { createdAt actor { ...ActorFields } label { name color } }
+  ... on UnlockedEvent { createdAt actor { ...ActorFields } }
+  ... on UnmarkedAsDuplicateEvent { createdAt actor { ...ActorFields } }
+  ... on UnpinnedEvent { createdAt actor { ...ActorFields } }
+  ... on UnsubscribedEvent { createdAt actor { ...ActorFields } }
+  ... on UserBlockedEvent { createdAt actor { ...ActorFields } blockDuration }
+}
+"""
+
+
+def _q(parts: list[str], body: str) -> str:
+    return "\n".join(parts + [body])
+
+
+ISSUES_PAGE_QUERY = _q(
+    [F_ACTOR, F_LABEL, F_TIMELINE],
+    """
+query IssuesPage($owner: String!, $name: String!, $first: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    issues(first: $first, after: $after, orderBy: {field: CREATED_AT, direction: ASC}) {
+      pageInfo { hasNextPage endCursor }
+      totalCount
+      nodes {
+        id databaseId number title body state stateReason
+        createdAt updatedAt closedAt
+        url
+        author { ...ActorFields }
+        editor { ...ActorFields }
+        labels(first: 50) { nodes { ...LabelFields } }
+        assignees(first: 20) { nodes { login id } }
+        milestone { title number state dueOn }
+        reactionGroups { content reactors { totalCount } }
+        comments(first: 100) {
+          totalCount
+          pageInfo { hasNextPage endCursor }
+          nodes {
+            id databaseId createdAt updatedAt url body
+            author { ...ActorFields }
+            editor { ...ActorFields }
+            reactionGroups { content reactors { totalCount } }
+          }
+        }
+        timelineItems(first: 100) {
+          totalCount
+          pageInfo { hasNextPage endCursor }
+          nodes { ...TimelineItem }
+        }
+        trackedInIssues(first: 20) { totalCount nodes { number url repository { nameWithOwner } } }
+        trackedIssues(first: 20) { totalCount nodes { number url repository { nameWithOwner } } }
+      }
+    }
+  }
+  rateLimit { cost remaining resetAt }
+}
+""",
+)
+
+PRS_PAGE_QUERY = _q(
+    [F_ACTOR, F_LABEL, F_PR_TIMELINE],
+    """
+query PRsPage($owner: String!, $name: String!, $first: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    pullRequests(first: $first, after: $after, orderBy: {field: CREATED_AT, direction: ASC}) {
+      pageInfo { hasNextPage endCursor }
+      totalCount
+      nodes {
+        id databaseId number title body state isDraft
+        createdAt updatedAt closedAt mergedAt
+        url
+        headRefName headRefOid
+        baseRefName baseRefOid
+        additions deletions changedFiles
+        mergeable merged mergeStateStatus
+        author { ...ActorFields }
+        editor { ...ActorFields }
+        mergedBy { ...ActorFields }
+        labels(first: 50) { nodes { ...LabelFields } }
+        assignees(first: 20) { nodes { login id } }
+        milestone { title number state dueOn }
+        reactionGroups { content reactors { totalCount } }
+        closingIssuesReferences(first: 20) { totalCount nodes { number url repository { nameWithOwner } title } }
+        comments(first: 100) {
+          totalCount
+          pageInfo { hasNextPage endCursor }
+          nodes {
+            id databaseId createdAt updatedAt url body
+            author { ...ActorFields }
+            editor { ...ActorFields }
+            reactionGroups { content reactors { totalCount } }
+          }
+        }
+        reviewThreads(first: 50) {
+          totalCount
+          pageInfo { hasNextPage endCursor }
+          nodes {
+            id isResolved isOutdated path line diffSide
+            comments(first: 50) {
+              totalCount
+              pageInfo { hasNextPage endCursor }
+              nodes {
+                id databaseId createdAt updatedAt url body path diffHunk
+                author { ...ActorFields }
+                editor { ...ActorFields }
+                position originalPosition line originalLine
+                commit { oid }
+                reactionGroups { content reactors { totalCount } }
+              }
+            }
+          }
+        }
+        reviews(first: 50) {
+          totalCount
+          pageInfo { hasNextPage endCursor }
+          nodes {
+            id databaseId state createdAt submittedAt body url
+            author { ...ActorFields }
+            reactionGroups { content reactors { totalCount } }
+          }
+        }
+        commits(first: 100) {
+          totalCount
+          pageInfo { hasNextPage endCursor }
+          nodes {
+            commit {
+              oid
+              message
+              messageHeadline
+              committedDate
+              authoredDate
+              author { name email user { login } date }
+              committer { name email user { login } date }
+              additions deletions changedFilesIfAvailable
+              parents(first: 3) { nodes { oid } }
+            }
+          }
+        }
+        files(first: 100) {
+          totalCount
+          pageInfo { hasNextPage endCursor }
+          nodes {
+            path additions deletions changeType
+          }
+        }
+        timelineItems(first: 100) {
+          totalCount
+          pageInfo { hasNextPage endCursor }
+          nodes { ...PRTimelineItem }
+        }
+      }
+    }
+  }
+  rateLimit { cost remaining resetAt }
+}
+""",
+)
+
+PRS_PAGE_QUERY_LIGHT = _q(
+    [F_ACTOR, F_LABEL],
+    """
+query PRsPageLight($owner: String!, $name: String!, $first: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    pullRequests(first: $first, after: $after, orderBy: {field: CREATED_AT, direction: ASC}) {
+      pageInfo { hasNextPage endCursor }
+      totalCount
+      nodes {
+        id databaseId number title body state isDraft
+        createdAt updatedAt closedAt mergedAt
+        url
+        author { ...ActorFields }
+        labels(first: 50) { nodes { ...LabelFields } }
+        comments(first: 30) {
+          totalCount
+          pageInfo { hasNextPage endCursor }
+          nodes {
+            id databaseId createdAt updatedAt url body
+            author { ...ActorFields }
+          }
+        }
+      }
+    }
+  }
+  rateLimit { cost remaining resetAt }
+}
+""",
+)
+
+ISSUES_PAGE_QUERY_LIGHT = _q(
+    [F_ACTOR, F_LABEL],
+    """
+query IssuesPageLight($owner: String!, $name: String!, $first: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    issues(first: $first, after: $after, orderBy: {field: CREATED_AT, direction: ASC}) {
+      pageInfo { hasNextPage endCursor }
+      totalCount
+      nodes {
+        id databaseId number title body state
+        createdAt updatedAt closedAt
+        url
+        author { ...ActorFields }
+        labels(first: 50) { nodes { ...LabelFields } }
+        comments(first: 30) {
+          totalCount
+          pageInfo { hasNextPage endCursor }
+          nodes {
+            id databaseId createdAt updatedAt url body
+            author { ...ActorFields }
+          }
+        }
+      }
+    }
+  }
+  rateLimit { cost remaining resetAt }
+}
+""",
+)
+
+ISSUE_COMMENTS_QUERY = _q(
+    [F_ACTOR],
+    """
+query IssueComments($owner: String!, $name: String!, $number: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    issueOrPullRequest(number: $number) {
+      __typename
+      ... on Issue {
+        comments(first: 100, after: $after) {
+          pageInfo { hasNextPage endCursor }
+          nodes {
+            id databaseId createdAt updatedAt url body
+            author { ...ActorFields }
+            editor { ...ActorFields }
+            reactionGroups { content reactors { totalCount } }
+          }
+        }
+      }
+      ... on PullRequest {
+        comments(first: 100, after: $after) {
+          pageInfo { hasNextPage endCursor }
+          nodes {
+            id databaseId createdAt updatedAt url body
+            author { ...ActorFields }
+            editor { ...ActorFields }
+            reactionGroups { content reactors { totalCount } }
+          }
+        }
+      }
+    }
+  }
+  rateLimit { cost remaining resetAt }
+}
+""",
+)
+
+ISSUE_TIMELINE_QUERY = _q(
+    [F_ACTOR, F_TIMELINE],
+    """
+query IssueTimeline($owner: String!, $name: String!, $number: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    issue(number: $number) {
+      timelineItems(first: 100, after: $after) {
+        pageInfo { hasNextPage endCursor }
+        nodes { ...TimelineItem }
+      }
+    }
+  }
+  rateLimit { cost remaining resetAt }
+}
+""",
+)
+
+PR_TIMELINE_QUERY = _q(
+    [F_ACTOR, F_PR_TIMELINE],
+    """
+query PRTimeline($owner: String!, $name: String!, $number: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $number) {
+      timelineItems(first: 100, after: $after) {
+        pageInfo { hasNextPage endCursor }
+        nodes { ...PRTimelineItem }
+      }
+    }
+  }
+  rateLimit { cost remaining resetAt }
+}
+""",
+)
+
+PR_COMMITS_QUERY = """
+query PRCommits($owner: String!, $name: String!, $number: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $number) {
+      commits(first: 100, after: $after) {
+        pageInfo { hasNextPage endCursor }
+        nodes {
+          commit {
+            oid message messageHeadline committedDate authoredDate
+            author { name email user { login } date }
+            committer { name email user { login } date }
+            additions deletions changedFilesIfAvailable
+            parents(first: 3) { nodes { oid } }
+          }
+        }
+      }
+    }
+  }
+  rateLimit { cost remaining resetAt }
+}
+"""
+
+PR_FILES_QUERY = """
+query PRFiles($owner: String!, $name: String!, $number: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $number) {
+      files(first: 100, after: $after) {
+        pageInfo { hasNextPage endCursor }
+        nodes { path additions deletions changeType }
+      }
+    }
+  }
+  rateLimit { cost remaining resetAt }
+}
+"""
+
+PR_REVIEW_THREADS_QUERY = _q(
+    [F_ACTOR],
+    """
+query PRReviewThreads($owner: String!, $name: String!, $number: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $number) {
+      reviewThreads(first: 50, after: $after) {
+        pageInfo { hasNextPage endCursor }
+        nodes {
+          id isResolved isOutdated path line diffSide
+          comments(first: 50) {
+            totalCount
+            nodes {
+              id databaseId createdAt updatedAt url body path diffHunk
+              author { ...ActorFields }
+              editor { ...ActorFields }
+              position originalPosition line originalLine
+              commit { oid }
+              reactionGroups { content reactors { totalCount } }
+            }
+          }
+        }
+      }
+    }
+  }
+  rateLimit { cost remaining resetAt }
+}
+""",
+)
+
+DISCUSSIONS_PAGE_QUERY = _q(
+    [F_ACTOR, F_LABEL],
+    """
+query DiscussionsPage($owner: String!, $name: String!, $first: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    discussions(first: $first, after: $after, orderBy: {field: CREATED_AT, direction: ASC}) {
+      pageInfo { hasNextPage endCursor }
+      totalCount
+      nodes {
+        id databaseId number title body
+        createdAt updatedAt url
+        author { ...ActorFields }
+        editor { ...ActorFields }
+        locked
+        answerChosenAt
+        closed closedAt
+        category { id name emoji description isAnswerable }
+        labels(first: 30) { nodes { ...LabelFields } }
+        upvoteCount
+        answer { id databaseId body author { ...ActorFields } createdAt url }
+        reactionGroups { content reactors { totalCount } }
+        comments(first: 50) {
+          totalCount
+          pageInfo { hasNextPage endCursor }
+          nodes {
+            id databaseId body createdAt updatedAt url
+            author { ...ActorFields }
+            editor { ...ActorFields }
+            upvoteCount
+            isAnswer
+            reactionGroups { content reactors { totalCount } }
+            replies(first: 50) {
+              totalCount
+              pageInfo { hasNextPage endCursor }
+              nodes {
+                id databaseId body createdAt updatedAt url
+                author { ...ActorFields }
+                editor { ...ActorFields }
+                reactionGroups { content reactors { totalCount } }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  rateLimit { cost remaining resetAt }
+}
+""",
+)
+
+DISCUSSION_COMMENTS_QUERY = _q(
+    [F_ACTOR],
+    """
+query DiscussionComments($owner: String!, $name: String!, $number: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    discussion(number: $number) {
+      comments(first: 50, after: $after) {
+        pageInfo { hasNextPage endCursor }
+        nodes {
+          id databaseId body createdAt updatedAt url
+          author { ...ActorFields }
+          editor { ...ActorFields }
+          upvoteCount
+          isAnswer
+          reactionGroups { content reactors { totalCount } }
+          replies(first: 50) {
+            totalCount
+            nodes {
+              id databaseId body createdAt updatedAt url
+              author { ...ActorFields }
+              editor { ...ActorFields }
+              reactionGroups { content reactors { totalCount } }
+            }
+          }
+        }
+      }
+    }
+  }
+  rateLimit { cost remaining resetAt }
+}
+""",
+)
+
+DISCUSSION_REPLIES_QUERY = _q(
+    [F_ACTOR],
+    """
+query DiscussionReplies($commentId: ID!, $after: String) {
+  node(id: $commentId) {
+    ... on DiscussionComment {
+      replies(first: 50, after: $after) {
+        pageInfo { hasNextPage endCursor }
+        nodes {
+          id databaseId body createdAt updatedAt url
+          author { ...ActorFields }
+          editor { ...ActorFields }
+          reactionGroups { content reactors { totalCount } }
+        }
+      }
+    }
+  }
+  rateLimit { cost remaining resetAt }
+}
+""",
+)
+
+COMMITS_PAGE_QUERY = """
+query CommitsPage($owner: String!, $name: String!, $first: Int!, $after: String, $branch: String!) {
+  repository(owner: $owner, name: $name) {
+    ref(qualifiedName: $branch) {
+      target {
+        ... on Commit {
+          history(first: $first, after: $after) {
+            pageInfo { hasNextPage endCursor }
+            totalCount
+            nodes {
+              oid
+              message
+              messageHeadline
+              committedDate
+              authoredDate
+              url
+              additions deletions changedFilesIfAvailable
+              author { name email date user { login id } }
+              committer { name email date user { login id } }
+              parents(first: 3) { nodes { oid } }
+              associatedPullRequests(first: 5) { nodes { number url state } }
+            }
+          }
+        }
+      }
+    }
+  }
+  rateLimit { cost remaining resetAt }
+}
+"""
+
+RELEASES_QUERY = _q(
+    [F_ACTOR],
+    """
+query Releases($owner: String!, $name: String!, $first: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    releases(first: $first, after: $after, orderBy: {field: CREATED_AT, direction: ASC}) {
+      pageInfo { hasNextPage endCursor }
+      nodes {
+        id databaseId name tagName description
+        createdAt publishedAt updatedAt
+        isDraft isPrerelease isLatest
+        url
+        author { ...ActorFields }
+        tagCommit { oid url }
+        reactionGroups { content reactors { totalCount } }
+        releaseAssets(first: 50) {
+          nodes { name contentType size downloadUrl createdAt updatedAt }
+        }
+      }
+    }
+  }
+  rateLimit { cost remaining resetAt }
+}
+""",
+)
+
+LABELS_QUERY = _q(
+    [F_LABEL],
+    """
+query LabelsList($owner: String!, $name: String!, $first: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    labels(first: $first, after: $after) {
+      pageInfo { hasNextPage endCursor }
+      nodes { ...LabelFields }
+    }
+  }
+  rateLimit { cost remaining resetAt }
+}
+""",
+)
+
+MILESTONES_QUERY = """
+query Milestones($owner: String!, $name: String!, $first: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    milestones(first: $first, after: $after) {
+      pageInfo { hasNextPage endCursor }
+      nodes {
+        id number title description state
+        createdAt updatedAt closedAt dueOn
+        creator { login }
+      }
+    }
+  }
+  rateLimit { cost remaining resetAt }
+}
+"""
+
+REPO_META_QUERY = """
+query RepoMeta($owner: String!, $name: String!) {
+  repository(owner: $owner, name: $name) {
+    id databaseId name nameWithOwner description url
+    createdAt updatedAt pushedAt
+    isArchived isDisabled isFork isPrivate
+    primaryLanguage { name }
+    languages(first: 20, orderBy: {field: SIZE, direction: DESC}) {
+      edges { size node { name } }
+      totalSize
+    }
+    stargazerCount forkCount watchers { totalCount }
+    diskUsage
+    licenseInfo { key name }
+    homepageUrl
+    defaultBranchRef { name }
+  }
+  rateLimit { cost remaining resetAt }
+}
+"""
diff --git a/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/scraper_impl/scraper.py b/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/scraper_impl/scraper.py
new file mode 100644
index 0000000000..127129e18b
--- /dev/null
+++ b/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/scraper_impl/scraper.py
@@ -0,0 +1,756 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+"""Main scraper orchestration. Collects issues, PRs, discussions, commits, releases, etc.
+
+Resumable via state file. Writes JSONL shards under data/{repo}/{resource}.jsonl.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Optional, Tuple
+
+# Allow running as a module or script
+THIS_DIR = Path(__file__).resolve().parent
+if str(THIS_DIR) not in sys.path:
+    sys.path.insert(0, str(THIS_DIR))
+
+from gh_client import GitHubClient
+from state_store import JsonlWriter, StateStore
+import queries as Q
+
+log = logging.getLogger("scraper")
+
+
+def ts() -> str:
+    return time.strftime("%Y-%m-%d %H:%M:%S")
+
+
+class RepoScraper:
+    def __init__(
+        self,
+        owner: str,
+        name: str,
+        base_dir: Path,
+        client: GitHubClient,
+        trial_limits: Optional[Dict[str, int]] = None,
+        light: bool = False,
+    ):
+        self.owner = owner
+        self.name = name
+        self.base_dir = base_dir
+        self.client = client
+        self.trial_limits = trial_limits or {}
+        # When light=True, use trimmed GraphQL queries (no reviewThreads,
+        # reviews, commits, timelineItems, files) so PR pages can be much
+        # larger without blowing GitHub's node-count ceiling.
+        self.light = light
+        self.repo_dir = base_dir / f"{owner}__{name}"
+        self.repo_dir.mkdir(parents = True, exist_ok = True)
+        self.state = StateStore(base_dir / "state" / f"{owner}__{name}.json")
+
+        # Writers
+        self.writers: Dict[str, JsonlWriter] = {}
+        for key in (
+            "issues",
+            "pull_requests",
+            "discussions",
+            "commits",
+            "releases",
+            "labels",
+            "milestones",
+            "pr_extra_comments",
+            "pr_extra_timeline",
+            "pr_extra_reviews",
+            "issue_extra_comments",
+            "issue_extra_timeline",
+            "discussion_extra_comments",
+            "discussion_extra_replies",
+            "repo_meta",
+        ):
+            self.writers[key] = JsonlWriter(self.repo_dir / f"{key}.jsonl")
+
+    # ----- helpers -----
+    def _trial_stop(self, key: str, counter: int) -> bool:
+        lim = self.trial_limits.get(key)
+        if lim is None:
+            return False
+        return counter >= lim
+
+    def _log_rate(self, where: str, data: Dict[str, Any]) -> None:
+        rl = (
+            data.get("data", {}).get("rateLimit")
+            if isinstance(data.get("data"), dict)
+            else None
+        )
+        if rl:
+            log.debug(
+                "[%s] rate cost=%s remaining=%s resetAt=%s",
+                where,
+                rl.get("cost"),
+                rl.get("remaining"),
+                rl.get("resetAt"),
+            )
+
+    # ----- repo meta -----
+    def scrape_repo_meta(self) -> Dict[str, Any]:
+        data = self.client.graphql(
+            Q.REPO_META_QUERY, {"owner": self.owner, "name": self.name}
+        )
+        self._log_rate("repo_meta", data)
+        repo = data.get("data", {}).get("repository") or {}
+        repo["_fetchedAt"] = ts()
+        self.writers["repo_meta"].write(repo)
+        return repo
+
+    # ----- issues -----
+    def scrape_issues(self) -> int:
+        key = "issues"
+        cursor = self.state.get(f"{key}_cursor")
+        done = self.state.get(f"{key}_done", False)
+        if done:
+            log.info("%s/%s issues already complete", self.owner, self.name)
+            return 0
+        total_new = 0
+        page = 0
+        # Light query skips heavy nested fields; safe at 50 per page.
+        # Clamp by trial_limit so e.g. limit=1 asks GitHub for first:1
+        # instead of fetching a full 50-item page and discarding 49.
+        page_cap = 50 if self.light else 15
+        trial_cap = self.trial_limits.get(key)
+        per_page = min(page_cap, trial_cap) if trial_cap and trial_cap > 0 else page_cap
+        while True:
+            page += 1
+            vars_ = {
+                "owner": self.owner,
+                "name": self.name,
+                "first": per_page,
+                "after": cursor,
+            }
+            query = Q.ISSUES_PAGE_QUERY_LIGHT if self.light else Q.ISSUES_PAGE_QUERY
+            data = self.client.graphql(query, vars_)
+            self._log_rate("issues", data)
+            repo = (data.get("data") or {}).get("repository") or {}
+            issues = repo.get("issues") or {}
+            nodes = issues.get("nodes") or []
+            for it in nodes:
+                it["_owner"] = self.owner
+                it["_repo"] = self.name
+                it["_fetchedAt"] = ts()
+                if not self.light:
+                    if it.get("comments", {}).get("pageInfo", {}).get("hasNextPage"):
+                        self._paginate_issue_comments(
+                            it["number"], it["comments"]["pageInfo"]["endCursor"]
+                        )
+                    if (
+                        it.get("timelineItems", {})
+                        .get("pageInfo", {})
+                        .get("hasNextPage")
+                    ):
+                        self._paginate_issue_timeline(
+                            it["number"],
+                            it["timelineItems"]["pageInfo"]["endCursor"],
+                        )
+                if self.writers[key].write(it):
+                    total_new += 1
+            info = issues.get("pageInfo") or {}
+            cursor = info.get("endCursor")
+            self.state.set(f"{key}_cursor", cursor)
+            log.info(
+                "[%s/%s] issues page %d (+%d) cursor=%s remaining=%s",
+                self.owner,
+                self.name,
+                page,
+                len(nodes),
+                str(cursor)[:20],
+                self.client.graphql_remaining,
+            )
+            if self._trial_stop(key, total_new):
+                log.info("Trial limit reached for issues (%d)", total_new)
+                return total_new
+            if not info.get("hasNextPage"):
+                self.state.set(f"{key}_done", True)
+                break
+        return total_new
+
+    def _paginate_issue_comments(self, number: int, after: str) -> None:
+        cur = after
+        while cur:
+            vars_ = {
+                "owner": self.owner,
+                "name": self.name,
+                "number": number,
+                "after": cur,
+            }
+            data = self.client.graphql(Q.ISSUE_COMMENTS_QUERY, vars_)
+            item = ((data.get("data") or {}).get("repository") or {}).get(
+                "issueOrPullRequest"
+            ) or {}
+            comments = item.get("comments") or {}
+            for c in comments.get("nodes") or []:
+                c["_owner"] = self.owner
+                c["_repo"] = self.name
+                c["_issueNumber"] = number
+                self.writers["issue_extra_comments"].write(c)
+            info = comments.get("pageInfo") or {}
+            cur = info.get("endCursor") if info.get("hasNextPage") else None
+
+    def _paginate_issue_timeline(self, number: int, after: str) -> None:
+        cur = after
+        while cur:
+            vars_ = {
+                "owner": self.owner,
+                "name": self.name,
+                "number": number,
+                "after": cur,
+            }
+            data = self.client.graphql(Q.ISSUE_TIMELINE_QUERY, vars_)
+            item = ((data.get("data") or {}).get("repository") or {}).get("issue") or {}
+            tl = item.get("timelineItems") or {}
+            for ev in tl.get("nodes") or []:
+                ev["_owner"] = self.owner
+                ev["_repo"] = self.name
+                ev["_issueNumber"] = number
+                self.writers["issue_extra_timeline"].write(ev)
+            info = tl.get("pageInfo") or {}
+            cur = info.get("endCursor") if info.get("hasNextPage") else None
+
+    # ----- PRs -----
+    def scrape_prs(self) -> int:
+        key = "pull_requests"
+        cursor = self.state.get(f"{key}_cursor")
+        done = self.state.get(f"{key}_done", False)
+        if done:
+            log.info("%s/%s PRs already complete", self.owner, self.name)
+            return 0
+        total_new = 0
+        page = 0
+        # Heavy nested PR query is capped at 3 per page (GitHub node-count
+        # ceiling); light query skips reviewThreads/reviews/commits/etc and
+        # can safely go to 25 per page. Clamp by trial_limit for small
+        # previews so limit=1 does not fetch a whole 25-item page.
+        page_cap = 25 if self.light else 3
+        trial_cap = self.trial_limits.get(key)
+        per_page = min(page_cap, trial_cap) if trial_cap and trial_cap > 0 else page_cap
+        while True:
+            page += 1
+            vars_ = {
+                "owner": self.owner,
+                "name": self.name,
+                "first": per_page,
+                "after": cursor,
+            }
+            query = Q.PRS_PAGE_QUERY_LIGHT if self.light else Q.PRS_PAGE_QUERY
+            data = self.client.graphql(query, vars_)
+            self._log_rate("prs", data)
+            repo = (data.get("data") or {}).get("repository") or {}
+            prs = repo.get("pullRequests") or {}
+            nodes = prs.get("nodes") or []
+            for pr in nodes:
+                pr["_owner"] = self.owner
+                pr["_repo"] = self.name
+                pr["_fetchedAt"] = ts()
+                num = pr["number"]
+                if not self.light:
+                    if pr.get("comments", {}).get("pageInfo", {}).get("hasNextPage"):
+                        self._paginate_pr_comments(
+                            num, pr["comments"]["pageInfo"]["endCursor"]
+                        )
+                    if (
+                        pr.get("timelineItems", {})
+                        .get("pageInfo", {})
+                        .get("hasNextPage")
+                    ):
+                        self._paginate_pr_timeline(
+                            num, pr["timelineItems"]["pageInfo"]["endCursor"]
+                        )
+                    if pr.get("commits", {}).get("pageInfo", {}).get("hasNextPage"):
+                        self._paginate_pr_commits(
+                            num, pr["commits"]["pageInfo"]["endCursor"]
+                        )
+                    if pr.get("files", {}).get("pageInfo", {}).get("hasNextPage"):
+                        self._paginate_pr_files(
+                            num, pr["files"]["pageInfo"]["endCursor"]
+                        )
+                    if (
+                        pr.get("reviewThreads", {})
+                        .get("pageInfo", {})
+                        .get("hasNextPage")
+                    ):
+                        self._paginate_pr_review_threads(
+                            num, pr["reviewThreads"]["pageInfo"]["endCursor"]
+                        )
+                if self.writers[key].write(pr):
+                    total_new += 1
+            info = prs.get("pageInfo") or {}
+            cursor = info.get("endCursor")
+            self.state.set(f"{key}_cursor", cursor)
+            log.info(
+                "[%s/%s] PRs page %d (+%d) cursor=%s remaining=%s",
+                self.owner,
+                self.name,
+                page,
+                len(nodes),
+                str(cursor)[:20],
+                self.client.graphql_remaining,
+            )
+            if self._trial_stop(key, total_new):
+                log.info("Trial limit reached for PRs (%d)", total_new)
+                return total_new
+            if not info.get("hasNextPage"):
+                self.state.set(f"{key}_done", True)
+                break
+        return total_new
+
+    def _paginate_pr_comments(self, number: int, after: str) -> None:
+        cur = after
+        while cur:
+            vars_ = {
+                "owner": self.owner,
+                "name": self.name,
+                "number": number,
+                "after": cur,
+            }
+            data = self.client.graphql(Q.ISSUE_COMMENTS_QUERY, vars_)
+            item = ((data.get("data") or {}).get("repository") or {}).get(
+                "issueOrPullRequest"
+            ) or {}
+            comments = item.get("comments") or {}
+            for c in comments.get("nodes") or []:
+                c["_owner"] = self.owner
+                c["_repo"] = self.name
+                c["_prNumber"] = number
+                self.writers["pr_extra_comments"].write(c)
+            info = comments.get("pageInfo") or {}
+            cur = info.get("endCursor") if info.get("hasNextPage") else None
+
+    def _paginate_pr_timeline(self, number: int, after: str) -> None:
+        cur = after
+        while cur:
+            vars_ = {
+                "owner": self.owner,
+                "name": self.name,
+                "number": number,
+                "after": cur,
+            }
+            data = self.client.graphql(Q.PR_TIMELINE_QUERY, vars_)
+            item = ((data.get("data") or {}).get("repository") or {}).get(
+                "pullRequest"
+            ) or {}
+            tl = item.get("timelineItems") or {}
+            for ev in tl.get("nodes") or []:
+                ev["_owner"] = self.owner
+                ev["_repo"] = self.name
+                ev["_prNumber"] = number
+                self.writers["pr_extra_timeline"].write(ev)
+            info = tl.get("pageInfo") or {}
+            cur = info.get("endCursor") if info.get("hasNextPage") else None
+
+    def _paginate_pr_commits(self, number: int, after: str) -> None:
+        cur = after
+        out_key = "pr_extra_commits"
+        if out_key not in self.writers:
+            self.writers[out_key] = JsonlWriter(self.repo_dir / f"{out_key}.jsonl")
+        while cur:
+            vars_ = {
+                "owner": self.owner,
+                "name": self.name,
+                "number": number,
+                "after": cur,
+            }
+            data = self.client.graphql(Q.PR_COMMITS_QUERY, vars_)
+            item = ((data.get("data") or {}).get("repository") or {}).get(
+                "pullRequest"
+            ) or {}
+            cc = item.get("commits") or {}
+            for c in cc.get("nodes") or []:
+                c["_owner"] = self.owner
+                c["_repo"] = self.name
+                c["_prNumber"] = number
+                self.writers[out_key].write(c)
+            info = cc.get("pageInfo") or {}
+            cur = info.get("endCursor") if info.get("hasNextPage") else None
+
+    def _paginate_pr_files(self, number: int, after: str) -> None:
+        cur = after
+        out_key = "pr_extra_files"
+        if out_key not in self.writers:
+            self.writers[out_key] = JsonlWriter(self.repo_dir / f"{out_key}.jsonl")
+        while cur:
+            vars_ = {
+                "owner": self.owner,
+                "name": self.name,
+                "number": number,
+                "after": cur,
+            }
+            data = self.client.graphql(Q.PR_FILES_QUERY, vars_)
+            item = ((data.get("data") or {}).get("repository") or {}).get(
+                "pullRequest"
+            ) or {}
+            ff = item.get("files") or {}
+            for f in ff.get("nodes") or []:
+                f["_owner"] = self.owner
+                f["_repo"] = self.name
+                f["_prNumber"] = number
+                # files don't have id, synthesize one
+                f["_syntheticId"] = f"{self.owner}/{self.name}#{number}:{f.get('path')}"
+                self.writers[out_key].write(f)
+            info = ff.get("pageInfo") or {}
+            cur = info.get("endCursor") if info.get("hasNextPage") else None
+
+    def _paginate_pr_review_threads(self, number: int, after: str) -> None:
+        cur = after
+        out_key = "pr_extra_review_threads"
+        if out_key not in self.writers:
+            self.writers[out_key] = JsonlWriter(self.repo_dir / f"{out_key}.jsonl")
+        while cur:
+            vars_ = {
+                "owner": self.owner,
+                "name": self.name,
+                "number": number,
+                "after": cur,
+            }
+            data = self.client.graphql(Q.PR_REVIEW_THREADS_QUERY, vars_)
+            item = ((data.get("data") or {}).get("repository") or {}).get(
+                "pullRequest"
+            ) or {}
+            rt = item.get("reviewThreads") or {}
+            for th in rt.get("nodes") or []:
+                th["_owner"] = self.owner
+                th["_repo"] = self.name
+                th["_prNumber"] = number
+                self.writers[out_key].write(th)
+            info = rt.get("pageInfo") or {}
+            cur = info.get("endCursor") if info.get("hasNextPage") else None
+
+    # ----- Discussions -----
+    def scrape_discussions(self) -> int:
+        key = "discussions"
+        cursor = self.state.get(f"{key}_cursor")
+        done = self.state.get(f"{key}_done", False)
+        if done:
+            log.info("%s/%s discussions already complete", self.owner, self.name)
+            return 0
+        total_new = 0
+        page = 0
+        per_page = 15
+        while True:
+            page += 1
+            vars_ = {
+                "owner": self.owner,
+                "name": self.name,
+                "first": per_page,
+                "after": cursor,
+            }
+            data = self.client.graphql(Q.DISCUSSIONS_PAGE_QUERY, vars_)
+            self._log_rate("discussions", data)
+            repo = (data.get("data") or {}).get("repository") or {}
+            dd = repo.get("discussions") or {}
+            nodes = dd.get("nodes") or []
+            for d in nodes:
+                d["_owner"] = self.owner
+                d["_repo"] = self.name
+                d["_fetchedAt"] = ts()
+                num = d["number"]
+                if d.get("comments", {}).get("pageInfo", {}).get("hasNextPage"):
+                    self._paginate_discussion_comments(
+                        num, d["comments"]["pageInfo"]["endCursor"]
+                    )
+                # paginate replies per comment if needed
+                for c in d.get("comments", {}).get("nodes", []) or []:
+                    if c.get("replies", {}).get("pageInfo", {}).get("hasNextPage"):
+                        self._paginate_discussion_replies(
+                            c["id"], c["replies"]["pageInfo"]["endCursor"], num
+                        )
+                if self.writers[key].write(d):
+                    total_new += 1
+            info = dd.get("pageInfo") or {}
+            cursor = info.get("endCursor")
+            self.state.set(f"{key}_cursor", cursor)
+            log.info(
+                "[%s/%s] discussions page %d (+%d) cursor=%s remaining=%s",
+                self.owner,
+                self.name,
+                page,
+                len(nodes),
+                str(cursor)[:20],
+                self.client.graphql_remaining,
+            )
+            if self._trial_stop(key, total_new):
+                return total_new
+            if not info.get("hasNextPage"):
+                self.state.set(f"{key}_done", True)
+                break
+        return total_new
+
+    def _paginate_discussion_comments(self, number: int, after: str) -> None:
+        cur = after
+        while cur:
+            vars_ = {
+                "owner": self.owner,
+                "name": self.name,
+                "number": number,
+                "after": cur,
+            }
+            data = self.client.graphql(Q.DISCUSSION_COMMENTS_QUERY, vars_)
+            disc = ((data.get("data") or {}).get("repository") or {}).get(
+                "discussion"
+            ) or {}
+            cc = disc.get("comments") or {}
+            for c in cc.get("nodes") or []:
+                c["_owner"] = self.owner
+                c["_repo"] = self.name
+                c["_discussionNumber"] = number
+                self.writers["discussion_extra_comments"].write(c)
+            info = cc.get("pageInfo") or {}
+            cur = info.get("endCursor") if info.get("hasNextPage") else None
+
+    def _paginate_discussion_replies(
+        self, comment_id: str, after: str, disc_number: int
+    ) -> None:
+        cur = after
+        while cur:
+            vars_ = {
+                "owner": self.owner,
+                "name": self.name,
+                "commentId": comment_id,
+                "after": cur,
+            }
+            data = self.client.graphql(Q.DISCUSSION_REPLIES_QUERY, vars_)
+            node = (data.get("data") or {}).get("node") or {}
+            replies = node.get("replies") or {}
+            for r in replies.get("nodes") or []:
+                r["_owner"] = self.owner
+                r["_repo"] = self.name
+                r["_discussionNumber"] = disc_number
+                r["_commentId"] = comment_id
+                self.writers["discussion_extra_replies"].write(r)
+            info = replies.get("pageInfo") or {}
+            cur = info.get("endCursor") if info.get("hasNextPage") else None
+
+    # ----- Commits -----
+    def scrape_commits(self, branch: str = "refs/heads/main") -> int:
+        key = "commits"
+        cursor = self.state.get(f"{key}_cursor")
+        done = self.state.get(f"{key}_done", False)
+        if done:
+            return 0
+        total_new = 0
+        page = 0
+        page_cap = 100
+        trial_cap = self.trial_limits.get(key)
+        per_page = min(page_cap, trial_cap) if trial_cap and trial_cap > 0 else page_cap
+        while True:
+            page += 1
+            vars_ = {
+                "owner": self.owner,
+                "name": self.name,
+                "first": per_page,
+                "after": cursor,
+                "branch": branch,
+            }
+            data = self.client.graphql(Q.COMMITS_PAGE_QUERY, vars_)
+            self._log_rate("commits", data)
+            ref = ((data.get("data") or {}).get("repository") or {}).get("ref") or {}
+            tgt = ref.get("target") or {}
+            hist = tgt.get("history") or {}
+            nodes = hist.get("nodes") or []
+            for c in nodes:
+                c["_owner"] = self.owner
+                c["_repo"] = self.name
+                c["_fetchedAt"] = ts()
+                if self.writers[key].write(c):
+                    total_new += 1
+            info = hist.get("pageInfo") or {}
+            cursor = info.get("endCursor")
+            self.state.set(f"{key}_cursor", cursor)
+            log.info(
+                "[%s/%s] commits page %d (+%d) remaining=%s",
+                self.owner,
+                self.name,
+                page,
+                len(nodes),
+                self.client.graphql_remaining,
+            )
+            if self._trial_stop(key, total_new):
+                return total_new
+            if not info.get("hasNextPage"):
+                self.state.set(f"{key}_done", True)
+                break
+        return total_new
+
+    # ----- Releases/Labels/Milestones -----
+    def scrape_releases(self) -> int:
+        return self._scrape_simple("releases", Q.RELEASES_QUERY, "releases")
+
+    def scrape_labels(self) -> int:
+        return self._scrape_simple("labels", Q.LABELS_QUERY, "labels")
+
+    def scrape_milestones(self) -> int:
+        return self._scrape_simple("milestones", Q.MILESTONES_QUERY, "milestones")
+
+    def _scrape_simple(self, key: str, query: str, field: str) -> int:
+        cursor = self.state.get(f"{key}_cursor")
+        done = self.state.get(f"{key}_done", False)
+        if done:
+            return 0
+        total_new = 0
+        while True:
+            vars_ = {
+                "owner": self.owner,
+                "name": self.name,
+                "first": 50,
+                "after": cursor,
+            }
+            data = self.client.graphql(query, vars_)
+            repo = (data.get("data") or {}).get("repository") or {}
+            col = repo.get(field) or {}
+            for it in col.get("nodes") or []:
+                it["_owner"] = self.owner
+                it["_repo"] = self.name
+                it["_fetchedAt"] = ts()
+                if self.writers[key].write(it):
+                    total_new += 1
+            info = col.get("pageInfo") or {}
+            cursor = info.get("endCursor")
+            self.state.set(f"{key}_cursor", cursor)
+            if self._trial_stop(key, total_new):
+                return total_new
+            if not info.get("hasNextPage"):
+                self.state.set(f"{key}_done", True)
+                break
+        log.info("[%s/%s] %s done +%d", self.owner, self.name, key, total_new)
+        return total_new
+
+    def close(self) -> None:
+        for w in self.writers.values():
+            try:
+                w.close()
+            except Exception:
+                pass
+
+
+def setup_logging(log_file: Path) -> None:
+    log_file.parent.mkdir(parents = True, exist_ok = True)
+    fmt = "%(asctime)s %(levelname)s [%(name)s] %(message)s"
+    handlers = [
+        logging.StreamHandler(sys.stdout),
+        logging.FileHandler(log_file, mode = "a", encoding = "utf-8"),
+    ]
+    logging.basicConfig(level = logging.INFO, format = fmt, handlers = handlers, force = True)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument(
+        "--base-dir", default = "/mnt/disks/unslothai/ubuntu/workspace_34/github_scraper"
+    )
+    ap.add_argument(
+        "--repos", nargs = "+", default = ["unslothai/unsloth", "unslothai/unsloth-zoo"]
+    )
+    ap.add_argument("--trial", action = "store_true", help = "Small trial run")
+    ap.add_argument(
+        "--only",
+        nargs = "+",
+        default = None,
+        help = "Only run these resource keys: issues,pulls,discussions,commits,releases,labels,milestones,meta",
+    )
+    ap.add_argument(
+        "--hf-upload-interval",
+        type = int,
+        default = 900,
+        help = "Seconds between HF uploads (0 to disable)",
+    )
+    args = ap.parse_args()
+
+    base = Path(args.base_dir)
+    data_dir = base / "data"
+    data_dir.mkdir(parents = True, exist_ok = True)
+    setup_logging(base / "logs" / f"scraper_{time.strftime('%Y%m%d_%H%M%S')}.log")
+    log.info("Scraper starting: repos=%s trial=%s", args.repos, args.trial)
+
+    client = GitHubClient(min_remaining_graphql = 80, min_remaining_rest = 80)
+    rl = client.rate_snapshot()
+    log.info(
+        "Rate limit snapshot: %s",
+        json.dumps(rl.get("resources", {}), default = str)[:400],
+    )
+
+    # Start HF uploader in background if requested
+    uploader = None
+    if args.hf_upload_interval > 0:
+        from hf_uploader import HFUploader
+
+        uploader = HFUploader(data_dir, interval_s = args.hf_upload_interval)
+        uploader.start()
+
+    trial_limits = None
+    if args.trial:
+        trial_limits = {
+            "issues": 5,
+            "pull_requests": 5,
+            "discussions": 3,
+            "commits": 20,
+            "releases": 3,
+            "labels": 20,
+            "milestones": 20,
+        }
+
+    only = set(args.only or [])
+
+    try:
+        for repo_spec in args.repos:
+            owner, name = repo_spec.split("/")
+            scraper = RepoScraper(owner, name, data_dir, client, trial_limits)
+            try:
+                repo_meta: Dict[str, Any] = {}
+                if not only or "meta" in only or "commits" in only:
+                    repo_meta = scraper.scrape_repo_meta()
+                if not only or "labels" in only:
+                    scraper.scrape_labels()
+                if not only or "milestones" in only:
+                    scraper.scrape_milestones()
+                if not only or "releases" in only:
+                    scraper.scrape_releases()
+                if not only or "discussions" in only:
+                    scraper.scrape_discussions()
+                if not only or "issues" in only:
+                    scraper.scrape_issues()
+                if not only or "pulls" in only:
+                    scraper.scrape_prs()
+                if not only or "commits" in only:
+                    default_ref = repo_meta.get("defaultBranchRef") or {}
+                    default_branch = (
+                        default_ref.get("name")
+                        if isinstance(default_ref, dict)
+                        else None
+                    )
+                    branch = (
+                        f"refs/heads/{default_branch}"
+                        if default_branch
+                        else "refs/heads/main"
+                    )
+                    scraper.scrape_commits(branch = branch)
+            finally:
+                scraper.close()
+    finally:
+        if uploader:
+            log.info("Stopping uploader and final sync...")
+            uploader.stop(final_upload = True)
+    log.info(
+        "Scraper complete. GraphQL calls=%d REST calls=%d",
+        client.calls_graphql,
+        client.calls_rest,
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/scraper_impl/state_store.py b/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/scraper_impl/state_store.py
new file mode 100644
index 0000000000..efa663db2f
--- /dev/null
+++ b/studio/backend/plugins/data-designer-github-repo-seed/src/data_designer_github_repo_seed/scraper_impl/state_store.py
@@ -0,0 +1,105 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+"""Checkpoint state management for resumable scraping."""
+
+from __future__ import annotations
+
+import json
+import os
+import threading
+from pathlib import Path
+from typing import Any, Dict
+
+
+class StateStore:
+    def __init__(self, path: str | Path):
+        self.path = Path(path)
+        self.path.parent.mkdir(parents = True, exist_ok = True)
+        self._lock = threading.Lock()
+        self._data: Dict[str, Any] = {}
+        if self.path.exists():
+            try:
+                with self.path.open() as f:
+                    self._data = json.load(f)
+            except Exception:
+                self._data = {}
+
+    def get(self, key: str, default: Any = None) -> Any:
+        with self._lock:
+            return self._data.get(key, default)
+
+    def set(self, key: str, value: Any) -> None:
+        with self._lock:
+            self._data[key] = value
+            self._flush()
+
+    def update(self, key: str, **kwargs) -> None:
+        with self._lock:
+            sub = dict(self._data.get(key, {}))
+            sub.update(kwargs)
+            self._data[key] = sub
+            self._flush()
+
+    def all(self) -> Dict[str, Any]:
+        with self._lock:
+            return dict(self._data)
+
+    def _flush(self) -> None:
+        tmp = self.path.with_suffix(self.path.suffix + ".tmp")
+        with tmp.open("w") as f:
+            json.dump(self._data, f, indent = 2, default = str)
+        os.replace(tmp, self.path)
+
+
+class JsonlWriter:
+    """Append-only JSONL writer, thread-safe, with line buffering."""
+
+    def __init__(self, path: str | Path):
+        self.path = Path(path)
+        self.path.parent.mkdir(parents = True, exist_ok = True)
+        self._lock = threading.Lock()
+        self._fh = self.path.open("a", buffering = 1)
+        self._count_seen_keys: set[str] = set()
+        # Preload seen keys if file exists (for dedup across resumes)
+        if self.path.exists() and self.path.stat().st_size > 0:
+            try:
+                with self.path.open() as f:
+                    for line in f:
+                        try:
+                            obj = json.loads(line)
+                            k = self._key(obj)
+                            if k is not None:
+                                self._count_seen_keys.add(k)
+                        except Exception:
+                            pass
+            except Exception:
+                pass
+
+    def _key(self, obj: dict) -> str | None:
+        for k in ("id", "node_id", "number", "sha", "url"):
+            if k in obj:
+                return f"{k}:{obj[k]}"
+        return None
+
+    def has(self, key: str) -> bool:
+        return key in self._count_seen_keys
+
+    def write(self, obj: dict) -> bool:
+        """Return True if newly written, False if already present."""
+        k = self._key(obj)
+        with self._lock:
+            if k is not None and k in self._count_seen_keys:
+                return False
+            if k is not None:
+                self._count_seen_keys.add(k)
+            self._fh.write(json.dumps(obj, default = str, ensure_ascii = False))
+            self._fh.write("\n")
+            self._fh.flush()
+        return True
+
+    def close(self) -> None:
+        try:
+            self._fh.close()
+        except Exception:
+            pass
diff --git a/studio/backend/requirements/single-env/data-designer-deps.txt b/studio/backend/requirements/single-env/data-designer-deps.txt
index fc63230922..f63c076621 100644
--- a/studio/backend/requirements/single-env/data-designer-deps.txt
+++ b/studio/backend/requirements/single-env/data-designer-deps.txt
@@ -19,7 +19,8 @@ ruff<1,>=0.14.10
 scipy<2,>=1.11.0
 sqlfluff<4,>=3.2.0
 tiktoken<1,>=0.8.0
-# Unstructured-seed plugin deps (plugin installed with --no-deps)
+# Local seed plugin deps (plugins installed with --no-deps)
+requests>=2.31
 pymupdf>=1.24.0
 pymupdf4llm>=0.0.17
 mammoth>=1.8.0
diff --git a/studio/backend/routes/__init__.py b/studio/backend/routes/__init__.py
index e79f6553f9..cf4586281b 100644
--- a/studio/backend/routes/__init__.py
+++ b/studio/backend/routes/__init__.py
@@ -8,6 +8,7 @@ API Routes
 from routes.training import router as training_router
 from routes.models import router as models_router
 from routes.inference import router as inference_router
+from routes.inference import studio_router as inference_studio_router
 from routes.datasets import router as datasets_router
 from routes.auth import router as auth_router
 from routes.data_recipe import router as data_recipe_router
@@ -18,6 +19,7 @@ __all__ = [
     "training_router",
     "models_router",
     "inference_router",
+    "inference_studio_router",
     "datasets_router",
     "auth_router",
     "data_recipe_router",
diff --git a/studio/backend/routes/data_recipe/jobs.py b/studio/backend/routes/data_recipe/jobs.py
index 606ef1832c..da6416e324 100644
--- a/studio/backend/routes/data_recipe/jobs.py
+++ b/studio/backend/routes/data_recipe/jobs.py
@@ -5,8 +5,9 @@
 
 from __future__ import annotations
 
-from datetime import timedelta
-from typing import Any
+import copy
+from datetime import datetime, timedelta, timezone
+from typing import Any, Optional
 from urllib.parse import urlparse
 
 from fastapi import APIRouter, HTTPException, Query, Request
@@ -94,14 +95,111 @@ def _used_llm_model_aliases(recipe: dict[str, Any]) -> set[str]:
     return aliases
 
 
-def _inject_local_providers(recipe: dict[str, Any], request: Request) -> None:
+def _inject_local_structured_response_format(
+    recipe: dict[str, Any], local_provider_names: set[str]
+) -> None:
+    """For each llm-structured column that targets a local-provider model_config,
+    clone the model_config and inject an OpenAI ``response_format`` with the
+    column's ``output_format`` JSON schema. The column is rewritten to point at
+    the clone so llm-text / llm-judge columns that share the same alias keep
+    free-form sampling.
+
+    Without this, data_designer only injects a prompt-level "return JSON in a
+    ```json fence" instruction. Small GGUF models frequently break format,
+    wasting the full ``max_tokens`` budget per row and then failing to parse.
+    Forwarding ``response_format`` lets llama-server apply grammar-constrained
+    sampling from the JSON schema, which guarantees a parseable response and
+    terminates early.
+    """
+    columns = recipe.get("columns")
+    model_configs = recipe.get("model_configs")
+    if not isinstance(columns, list) or not isinstance(model_configs, list):
+        return
+
+    # alias -> model_config (only configs referencing a local provider qualify).
+    alias_to_local_mc: dict[str, dict[str, Any]] = {}
+    for mc in model_configs:
+        if not isinstance(mc, dict):
+            continue
+        if mc.get("provider") in local_provider_names and isinstance(
+            mc.get("alias"), str
+        ):
+            alias_to_local_mc[mc["alias"]] = mc
+
+    if not alias_to_local_mc:
+        return
+
+    # Clone per (alias, column) so each llm-structured column gets its own
+    # schema without leaking response_format onto other columns that share the
+    # same base alias.
+    seen_clone_aliases: set[str] = {
+        mc.get("alias") for mc in model_configs if isinstance(mc.get("alias"), str)
+    }
+    new_configs: list[dict[str, Any]] = []
+    for column in columns:
+        if not isinstance(column, dict):
+            continue
+        if column.get("column_type") != "llm-structured":
+            continue
+        alias = column.get("model_alias")
+        if not isinstance(alias, str) or alias not in alias_to_local_mc:
+            continue
+        output_format = column.get("output_format")
+        if not isinstance(output_format, dict) or not output_format:
+            continue
+        base_mc = alias_to_local_mc[alias]
+        column_name = column.get("name") or "structured"
+        clone_alias_base = f"{alias}__{column_name}_structured"
+        clone_alias = clone_alias_base
+        counter = 1
+        while clone_alias in seen_clone_aliases:
+            counter += 1
+            clone_alias = f"{clone_alias_base}_{counter}"
+        seen_clone_aliases.add(clone_alias)
+
+        clone = copy.deepcopy(base_mc)
+        clone["alias"] = clone_alias
+        params = clone.get("inference_parameters")
+        if not isinstance(params, dict):
+            params = {}
+            clone["inference_parameters"] = params
+        # data_designer's BaseInferenceParams is a pydantic model with
+        # extra="forbid", so response_format cannot sit at the top level of
+        # inference_parameters. It does expose an `extra_body: dict` pass-
+        # through that the OpenAI client spreads into the request body at the
+        # top level, which is where llama-server reads response_format from.
+        # llama.cpp server shape (tools/server/README.md): the schema sits
+        # directly under response_format, not nested in a json_schema object
+        # the way OpenAI's Chat Completions API expects. llama-server converts
+        # the schema to a GBNF grammar and applies it during sampling.
+        extra_body = params.get("extra_body")
+        if not isinstance(extra_body, dict):
+            extra_body = {}
+        extra_body["response_format"] = {
+            "type": "json_schema",
+            "schema": output_format,
+        }
+        params["extra_body"] = extra_body
+        new_configs.append(clone)
+        column["model_alias"] = clone_alias
+
+    if new_configs:
+        model_configs.extend(new_configs)
+
+
+def _inject_local_providers(recipe: dict[str, Any], request: Request) -> Optional[int]:
     """
     Mutate recipe dict in-place: for any provider with is_local=True,
-    generate a JWT and fill in the endpoint pointing at this server.
+    fill in the endpoint pointing at this server and inject a short-lived
+    internal sk-unsloth-* API key for workflow auth.
+
+    Returns the row id of the minted internal key (so the caller can
+    revoke it on job completion) or ``None`` when no local provider is
+    actually reachable from an LLM column.
     """
     providers = recipe.get("model_providers")
     if not providers:
-        return
+        return None
 
     # Collect local providers and pop is_local from ALL dicts unconditionally.
     # Strict `is True` guard so malformed payloads (is_local: 1,
@@ -115,7 +213,7 @@ def _inject_local_providers(recipe: dict[str, Any], request: Request) -> None:
             local_indices.append(i)
 
     if not local_indices:
-        return
+        return None
 
     endpoint = _resolve_local_v1_endpoint(request)
 
@@ -138,6 +236,7 @@ def _inject_local_providers(recipe: dict[str, Any], request: Request) -> None:
     }
 
     token = ""
+    internal_key_id: Optional[int] = None
     if local_names & referenced_providers:
         # Verify a model is loaded.
         # NOTE: This is a point-in-time check (TOCTOU). The model could be unloaded
@@ -158,18 +257,21 @@ def _inject_local_providers(recipe: dict[str, Any], request: Request) -> None:
                 "No model loaded in Chat. Load a model first, then run the recipe."
             )
 
-        from auth.authentication import (
-            create_access_token,
-        )  # deferred: avoids circular import
+        from auth import storage  # deferred: avoids circular import
 
-        # Uses the "unsloth" admin subject. If the user changes their password,
-        # the JWT secret rotates and this token becomes invalid mid-run.
-        # Acceptable for v1 - recipes typically finish well within one session.
-        token = create_access_token(
-            subject = "unsloth",
-            expires_delta = timedelta(hours = 24),
-            desktop = _request_has_desktop_access_token(request),
+        # Mint an internal sk-unsloth-* key scoped to this workflow run.
+        # Uses the unified API-key issuance path (one mint/revoke/verify
+        # surface instead of a second JWT code path). The key is marked
+        # internal so it is hidden from the user's API-key list, and the
+        # caller revokes it when the job terminates.
+        expires_at = (datetime.now(timezone.utc) + timedelta(hours = 24)).isoformat()
+        token, row = storage.create_api_key(
+            username = "unsloth",
+            name = "data-recipe workflow",
+            expires_at = expires_at,
+            internal = True,
         )
+        internal_key_id = int(row["id"])
 
     # Defensively strip any stale "external"-only fields the frontend may
     # have left on the dict (extra_headers/extra_body/api_key_env). The UI
@@ -196,6 +298,37 @@ def _inject_local_providers(recipe: dict[str, Any], request: Request) -> None:
             continue
         if mc.get("provider") in local_names:
             mc["skip_health_check"] = True
+            # Disable thinking for data-recipe inference on local providers.
+            # Reasoning models emit a <think>...</think> preamble before the
+            # answer, which roughly doubles generated token count per row and
+            # pushes the visible answer past data_designer's json-fence
+            # regex. Forward chat_template_kwargs={enable_thinking: False}
+            # through the OpenAI SDK's extra_body passthrough so llama-server
+            # renders the template without the reasoning preamble. Free-form
+            # llm-text columns benefit from the latency cut, and structured
+            # columns also stop leaking think tags into the grammar-
+            # constrained JSON (llama-server's GBNF path still enforces the
+            # schema either way).
+            params = mc.get("inference_parameters")
+            if not isinstance(params, dict):
+                params = {}
+                mc["inference_parameters"] = params
+            extra_body = params.get("extra_body")
+            if not isinstance(extra_body, dict):
+                extra_body = {}
+            tpl_kwargs = extra_body.get("chat_template_kwargs")
+            if not isinstance(tpl_kwargs, dict):
+                tpl_kwargs = {}
+            tpl_kwargs.setdefault("enable_thinking", False)
+            extra_body["chat_template_kwargs"] = tpl_kwargs
+            params["extra_body"] = extra_body
+
+    # Forward each llm-structured column's output_format as an OpenAI
+    # response_format so llama-server uses grammar-constrained sampling and
+    # small GGUFs stop wasting the full max_tokens budget on broken JSON.
+    _inject_local_structured_response_format(recipe, local_names)
+
+    return internal_key_id
 
 
 def _normalize_run_name(value: Any) -> str | None:
@@ -240,21 +373,49 @@ def create_job(payload: RecipePayload, request: Request):
             ) from exc
 
     try:
-        _inject_local_providers(recipe, request)
+        internal_api_key_id = _inject_local_providers(recipe, request)
     except ValueError as exc:
         raise HTTPException(status_code = 400, detail = str(exc)) from exc
 
-    mgr = get_job_manager()
+    # Single try block covers get_job_manager() AND mgr.start() so a workflow
+    # key minted above never outlives the request even when an unexpected
+    # exception type (TypeError from a stale kwarg, OSError from a queue
+    # write, etc.) bubbles up. Without the bare except, such exceptions let
+    # the sk-unsloth-* key live until its 24h TTL.
     try:
-        job_id = mgr.start(recipe = recipe, run = run)
+        mgr = get_job_manager()
+        job_id = mgr.start(
+            recipe = recipe,
+            run = run,
+            internal_api_key_id = internal_api_key_id,
+        )
     except RuntimeError as exc:
+        if internal_api_key_id is not None:
+            _revoke_internal_api_key_safe(internal_api_key_id)
         raise HTTPException(status_code = 409, detail = str(exc)) from exc
     except ValueError as exc:
+        if internal_api_key_id is not None:
+            _revoke_internal_api_key_safe(internal_api_key_id)
         raise HTTPException(status_code = 400, detail = str(exc)) from exc
+    except Exception:
+        if internal_api_key_id is not None:
+            _revoke_internal_api_key_safe(internal_api_key_id)
+        raise
 
     return {"job_id": job_id}
 
 
+def _revoke_internal_api_key_safe(key_id: int) -> None:
+    """Best-effort revoke of a workflow-minted key; swallow any error so
+    that revocation failures never mask the caller's own error path."""
+    try:
+        from auth import storage  # deferred: avoids circular import
+
+        storage.revoke_internal_api_key(key_id)
+    except Exception:
+        pass
+
+
 @router.get("/jobs/{job_id}/status")
 def job_status(job_id: str):
     mgr = get_job_manager()
diff --git a/studio/backend/routes/data_recipe/seed.py b/studio/backend/routes/data_recipe/seed.py
index e9cf828610..91cf718e6e 100644
--- a/studio/backend/routes/data_recipe/seed.py
+++ b/studio/backend/routes/data_recipe/seed.py
@@ -8,6 +8,7 @@ from __future__ import annotations
 import base64
 import binascii
 import json
+import os
 import re
 from itertools import islice
 from pathlib import Path
@@ -627,3 +628,14 @@ def inspect_seed_upload(payload: SeedInspectUploadRequest) -> SeedInspectRespons
         split = None,
         subset = None,
     )
+
+
+@router.get("/seed/github/env-token")
+def get_github_env_token_status() -> dict:
+    """Report whether the server has a GH_TOKEN / GITHUB_TOKEN env var.
+
+    The value is never returned; the UI uses this to tell the user they
+    can leave the token field blank.
+    """
+    has_token = bool(os.environ.get("GH_TOKEN") or os.environ.get("GITHUB_TOKEN"))
+    return {"has_token": has_token}
diff --git a/studio/backend/routes/data_recipe/validate.py b/studio/backend/routes/data_recipe/validate.py
index 555e3eaa06..e794d68e54 100644
--- a/studio/backend/routes/data_recipe/validate.py
+++ b/studio/backend/routes/data_recipe/validate.py
@@ -14,10 +14,63 @@ from core.data_recipe.service import (
     create_data_designer,
     validate_recipe,
 )
+from loggers import get_logger
 from models.data_recipe import RecipePayload, ValidateError, ValidateResponse
 
+logger = get_logger(__name__)
 router = APIRouter()
 
+_GITHUB_VALIDATE_NOTE = "Recipe shape is valid. GitHub access and rate limits are checked when the run starts."
+_GITHUB_ITEM_TYPES = {"issues", "pulls", "commits"}
+
+
+def _github_seed_source(recipe: dict[str, Any]) -> dict[str, Any] | None:
+    seed_config = recipe.get("seed_config")
+    if not isinstance(seed_config, dict):
+        return None
+    source = seed_config.get("source")
+    if not isinstance(source, dict) or source.get("seed_type") != "github_repo":
+        return None
+    return source
+
+
+def _validate_github_seed_static(source: dict[str, Any]) -> list[ValidateError]:
+    errors: list[ValidateError] = []
+
+    repos = source.get("repos")
+    if not isinstance(repos, list) or not repos:
+        errors.append(ValidateError(message = "GitHub seed requires at least one repo."))
+    else:
+        for repo in repos:
+            if not isinstance(repo, str) or not repo.strip() or "/" not in repo:
+                errors.append(
+                    ValidateError(message = "GitHub repos must be owner/name strings.")
+                )
+                break
+
+    item_types = source.get("item_types")
+    if not isinstance(item_types, list) or not item_types:
+        errors.append(
+            ValidateError(message = "GitHub seed requires at least one item type.")
+        )
+    else:
+        invalid_items = [item for item in item_types if item not in _GITHUB_ITEM_TYPES]
+        if invalid_items:
+            errors.append(
+                ValidateError(
+                    message = "GitHub item types must be issues, pulls, or commits."
+                )
+            )
+
+    try:
+        limit = int(source.get("limit"))
+    except (TypeError, ValueError):
+        limit = 0
+    if limit < 1 or limit > 5000:
+        errors.append(ValidateError(message = "GitHub limit must be from 1 to 5000."))
+
+    return errors
+
 
 def _collect_validation_errors(recipe: dict[str, Any]) -> list[ValidateError]:
     try:
@@ -93,6 +146,38 @@ def validate(payload: RecipePayload) -> ValidateResponse:
 
     _patch_local_providers(recipe)
 
+    github_source = _github_seed_source(recipe)
+    if github_source is not None:
+        static_errors = _validate_github_seed_static(github_source)
+        if static_errors:
+            return ValidateResponse(valid = False, errors = static_errors)
+        try:
+            build_config_builder(recipe)
+        except ModuleNotFoundError as exc:
+            # data_designer is an optional runtime dep. Static validation
+            # already passed; live access + full config validation are
+            # deferred to run start (per _GITHUB_VALIDATE_NOTE), so a missing
+            # optional import at validate time should not block the recipe.
+            # Restrict the bypass to the data_designer module specifically so
+            # other ImportErrors (e.g. broken internal imports or missing
+            # transitive deps after a package upgrade) still surface as
+            # validation failures instead of being silently swallowed.
+            if not (exc.name or "").startswith("data_designer"):
+                raise
+            logger.debug(
+                "data_designer not installed; deferring full config "
+                "validation to run start",
+                missing_module = exc.name,
+            )
+        except Exception as exc:
+            detail = str(exc).strip() or "Validation failed."
+            return ValidateResponse(
+                valid = False,
+                errors = [ValidateError(message = detail)],
+                raw_detail = detail,
+            )
+        return ValidateResponse(valid = True, raw_detail = _GITHUB_VALIDATE_NOTE)
+
     try:
         validate_recipe(recipe)
     except RuntimeError as exc:
diff --git a/studio/backend/routes/inference.py b/studio/backend/routes/inference.py
index ed331a5660..a6b00360af 100644
--- a/studio/backend/routes/inference.py
+++ b/studio/backend/routes/inference.py
@@ -113,19 +113,45 @@ if str(backend_path) not in sys.path:
 # Import backend functions
 try:
     from core.inference import get_inference_backend
-    from core.inference.llama_cpp import LlamaCppBackend, detect_reasoning_flags
+    from core.inference.llama_cpp import (
+        LlamaCppBackend,
+        _DEFAULT_MAX_TOKENS_FLOOR,
+        _DEFAULT_T_MAX_PREDICT_MS,
+        detect_reasoning_flags,
+    )
+    from core.inference.llama_server_args import validate_extra_args
     from utils.models import ModelConfig
     from utils.inference import load_inference_config
     from utils.models.model_config import load_model_defaults
+    from utils.native_path_leases import (
+        NativePathLeaseError,
+        display_label_for_native_path,
+        is_registered_native_path_label,
+        redact_native_paths,
+        verify_native_path_lease,
+    )
 except ImportError:
     parent_backend = backend_path.parent / "backend"
     if str(parent_backend) not in sys.path:
         sys.path.insert(0, str(parent_backend))
     from core.inference import get_inference_backend
-    from core.inference.llama_cpp import LlamaCppBackend, detect_reasoning_flags
+    from core.inference.llama_cpp import (
+        LlamaCppBackend,
+        _DEFAULT_MAX_TOKENS_FLOOR,
+        _DEFAULT_T_MAX_PREDICT_MS,
+        detect_reasoning_flags,
+    )
+    from core.inference.llama_server_args import validate_extra_args
     from utils.models import ModelConfig
     from utils.inference import load_inference_config
     from utils.models.model_config import load_model_defaults
+    from utils.native_path_leases import (
+        NativePathLeaseError,
+        display_label_for_native_path,
+        is_registered_native_path_label,
+        redact_native_paths,
+        verify_native_path_lease,
+    )
 
 from models.inference import (
     LoadRequest,
@@ -185,6 +211,138 @@ import numpy as np
 from datetime import date as _date
 
 router = APIRouter()
+# Studio-only router (not mounted on /v1 OpenAI-compat).
+studio_router = APIRouter()
+
+
+def _effective_enable_tools(payload) -> Optional[bool]:
+    """Resolve `payload.enable_tools` against the process-level tool policy.
+
+    Returns the policy value when set (CLI hard-override from `unsloth run`),
+    otherwise the per-request value.
+    """
+    from state.tool_policy import get_tool_policy
+
+    policy = get_tool_policy()
+    return policy if policy is not None else payload.enable_tools
+
+
+# Cancel registry. Proxies (e.g. Colab) can swallow client fetch aborts
+# so is_disconnected() never fires. POST /inference/cancel looks up
+# in-flight cancel_events here by cancel_id (per-run) or session_id /
+# completion_id (fallbacks).
+_CANCEL_REGISTRY: dict[str, set[threading.Event]] = {}
+_CANCEL_LOCK = threading.Lock()
+
+# Cancel POSTs that arrive before registration are stashed; the next
+# matching __enter__ replays set() within the TTL.
+_PENDING_CANCELS: dict[str, float] = {}
+_PENDING_CANCEL_TTL_S = 30.0
+
+
+def _prune_pending(now: float) -> None:
+    for k in [
+        k for k, ts in _PENDING_CANCELS.items() if now - ts > _PENDING_CANCEL_TTL_S
+    ]:
+        _PENDING_CANCELS.pop(k, None)
+
+
+class _TrackedCancel:
+    """Register cancel_event in _CANCEL_REGISTRY for the block's duration."""
+
+    def __init__(self, event: threading.Event, *keys):
+        self.event = event
+        self.keys = tuple(k for k in keys if k)
+
+    def __enter__(self):
+        # Register + consume-pending must be one critical section to close
+        # the TOCTOU race against a concurrent cancel POST.
+        should_cancel = False
+        with _CANCEL_LOCK:
+            for k in self.keys:
+                _CANCEL_REGISTRY.setdefault(k, set()).add(self.event)
+            now = time.monotonic()
+            _prune_pending(now)
+            for k in self.keys:
+                if k and _PENDING_CANCELS.pop(k, None) is not None:
+                    should_cancel = True
+        if should_cancel:
+            self.event.set()
+        return self.event
+
+    def __exit__(self, *exc):
+        with _CANCEL_LOCK:
+            for k in self.keys:
+                bucket = _CANCEL_REGISTRY.get(k)
+                if bucket is None:
+                    continue
+                bucket.discard(self.event)
+                if not bucket:
+                    _CANCEL_REGISTRY.pop(k, None)
+        return False
+
+
+def _cancel_by_keys(keys) -> int:
+    """Set cancel_event for matching registry entries; no stash.
+    session_id/completion_id are shared across runs on the same thread,
+    so stashing them would ghost-cancel the user's next request. Only
+    cancel_id is per-run unique (see _cancel_by_cancel_id_or_stash)."""
+    if not keys:
+        return 0
+    events: set[threading.Event] = set()
+    with _CANCEL_LOCK:
+        _prune_pending(time.monotonic())
+        for k in keys:
+            bucket = _CANCEL_REGISTRY.get(k)
+            if bucket:
+                events.update(bucket)
+    for ev in events:
+        ev.set()
+    return len(events)
+
+
+def _cancel_by_cancel_id_or_stash(cancel_id: str) -> int:
+    """Atomic lookup-or-stash; pairs with _TrackedCancel.__enter__ to
+    close the TOCTOU race."""
+    now = time.monotonic()
+    events: set[threading.Event] = set()
+    with _CANCEL_LOCK:
+        _prune_pending(now)
+        bucket = _CANCEL_REGISTRY.get(cancel_id)
+        if bucket:
+            events.update(bucket)
+        else:
+            _PENDING_CANCELS[cancel_id] = now
+    for ev in events:
+        ev.set()
+    return len(events)
+
+
+async def _await_cancel_then_close(cancel_event, resp) -> None:
+    """Watch a threading.Event from asyncio and close ``resp`` when it fires.
+
+    Used by the passthrough streamers so a /cancel POST can interrupt
+    while the async iterator is blocked waiting for llama-server prefill.
+    Without this watcher the in-loop ``cancel_event.is_set()`` check is
+    unreachable until the first SSE chunk arrives, which is exactly the
+    proxy/Colab scenario the cancel POST exists to handle.
+
+    Polls a threading.Event because the cancel registry is keyed by
+    threading.Event so the synchronous /cancel handler can call .set().
+    50ms cadence adds at most that much latency to a prefill cancel; the
+    common-case streaming cancel path still observes the event in the
+    iterator's first iteration after the next chunk.
+    """
+    try:
+        while not cancel_event.is_set():
+            await asyncio.sleep(0.05)
+        try:
+            await resp.aclose()
+        except Exception:
+            pass
+    except asyncio.CancelledError:
+        return
+
 
 # Appended to tool-use nudge to discourage plan-without-action
 _TOOL_ACTION_NUDGE = (
@@ -202,6 +360,65 @@ _TOOL_XML_RE = _re.compile(
 logger = get_logger(__name__)
 
 
+def _validate_native_mmproj_companion(
+    mmproj_path: str | None, gguf_path: str | None
+) -> None:
+    if not mmproj_path or not gguf_path:
+        return
+    import stat as _stat_module
+
+    mm = Path(mmproj_path)
+    gguf = Path(gguf_path)
+    try:
+        mm_lstat = os.lstat(mm)
+    except OSError as exc:
+        raise HTTPException(
+            status_code = 400,
+            detail = "Native vision companion is no longer accessible.",
+        ) from exc
+    if _stat_module.S_ISLNK(mm_lstat.st_mode) or not _stat_module.S_ISREG(
+        mm_lstat.st_mode
+    ):
+        raise HTTPException(
+            status_code = 400,
+            detail = "Native vision companion must be a regular file.",
+        )
+    try:
+        if mm.resolve(strict = True).parent != gguf.resolve(strict = True).parent:
+            raise HTTPException(
+                status_code = 400,
+                detail = "Native vision companion must live next to the selected GGUF.",
+            )
+    except OSError as exc:
+        raise HTTPException(
+            status_code = 400,
+            detail = "Native vision companion is no longer accessible.",
+        ) from exc
+
+
+def _resolve_model_identifier_for_request(
+    request: LoadRequest | ValidateModelRequest,
+    *,
+    operation: str,
+) -> tuple[str, str, bool]:
+    if not request.native_path_lease:
+        return request.model_path, request.model_path, False
+    try:
+        grant = verify_native_path_lease(
+            request.native_path_lease,
+            operation = operation,
+            expected_kind = "model",
+            expected_path_type = "file",
+            allowed_suffixes = (".gguf",),
+        )
+    except NativePathLeaseError as exc:
+        raise HTTPException(status_code = 400, detail = str(exc)) from exc
+    display_label = (
+        grant.display_label or Path(request.model_path).name or "Native model"
+    )
+    return str(grant.canonical_path), display_label, True
+
+
 # GGUF inference backend (llama-server)
 _llama_cpp_backend = LlamaCppBackend()
 
@@ -225,7 +442,19 @@ async def load_model(
 
     GGUF models are loaded via llama-server (llama.cpp) instead of Unsloth.
     """
+    native_grant_backed = False
+    model_log_label = request.model_path
     try:
+        # Validate user-supplied llama-server pass-through args up front
+        # so a managed-flag collision returns 400 before any model work.
+        try:
+            extra_llama_args = validate_extra_args(request.llama_extra_args)
+        except ValueError as exc:
+            raise HTTPException(status_code = 400, detail = str(exc))
+
+        model_identifier, model_log_label, native_grant_backed = (
+            _resolve_model_identifier_for_request(request, operation = "load-model")
+        )
         # Version switching is handled automatically by the subprocess-based
         # inference backend — no need for ensure_transformers_version() here.
 
@@ -239,10 +468,10 @@ async def load_model(
                 and llama_backend.hf_variant
                 and llama_backend.hf_variant.lower() == request.gguf_variant.lower()
                 and llama_backend.model_identifier
-                and llama_backend.model_identifier.lower() == request.model_path.lower()
+                and llama_backend.model_identifier.lower() == model_identifier.lower()
             ):
                 logger.info(
-                    f"Model already loaded (GGUF): {request.model_path} variant={request.gguf_variant}, skipping reload"
+                    f"Model already loaded (GGUF): {model_log_label} variant={request.gguf_variant}, skipping reload"
                 )
                 inference_config = load_inference_config(llama_backend.model_identifier)
                 from utils.models import is_audio_input_type
@@ -255,8 +484,12 @@ async def load_model(
                 _gguf_is_audio = getattr(llama_backend, "_is_audio", False)
                 return LoadResponse(
                     status = "already_loaded",
-                    model = llama_backend.model_identifier,
-                    display_name = llama_backend.model_identifier,
+                    model = model_log_label
+                    if native_grant_backed
+                    else llama_backend.model_identifier,
+                    display_name = model_log_label
+                    if native_grant_backed
+                    else llama_backend.model_identifier,
                     is_vision = llama_backend._is_vision,
                     is_lora = False,
                     is_gguf = True,
@@ -282,10 +515,10 @@ async def load_model(
         else:
             if (
                 backend.active_model_name
-                and backend.active_model_name.lower() == request.model_path.lower()
+                and backend.active_model_name.lower() == model_identifier.lower()
             ):
                 logger.info(
-                    f"Model already loaded (Unsloth): {request.model_path}, skipping reload"
+                    f"Model already loaded (Unsloth): {model_log_label}, skipping reload"
                 )
                 inference_config = load_inference_config(backend.active_model_name)
                 _model_info = backend.models.get(backend.active_model_name, {})
@@ -314,8 +547,12 @@ async def load_model(
                         pass
                 return LoadResponse(
                     status = "already_loaded",
-                    model = backend.active_model_name,
-                    display_name = backend.active_model_name,
+                    model = model_log_label
+                    if native_grant_backed
+                    else backend.active_model_name,
+                    display_name = model_log_label
+                    if native_grant_backed
+                    else backend.active_model_name,
                     is_vision = _model_info.get("is_vision", False),
                     is_lora = _model_info.get("is_lora", False),
                     is_gguf = False,
@@ -337,7 +574,7 @@ async def load_model(
         # Create config using clean factory method
         # is_lora is auto-detected from adapter_config.json on disk/HF
         config = ModelConfig.from_identifier(
-            model_id = request.model_path,
+            model_id = model_identifier,
             hf_token = request.hf_token,
             gguf_variant = request.gguf_variant,
         )
@@ -345,7 +582,7 @@ async def load_model(
         if not config:
             raise HTTPException(
                 status_code = 400,
-                detail = f"Invalid model identifier: {request.model_path}",
+                detail = f"Invalid model identifier: {model_log_label}",
             )
 
         # Normalize gpu_ids: empty list means auto-selection, same as None
@@ -389,9 +626,14 @@ async def load_model(
                     cache_type_kv = request.cache_type_kv,
                     speculative_type = request.speculative_type,
                     n_parallel = _n_parallel,
+                    extra_args = extra_llama_args,
                 )
             else:
                 # Local mode: llama-server loads via -m <path>
+                if native_grant_backed and config.gguf_mmproj_file:
+                    _validate_native_mmproj_companion(
+                        config.gguf_mmproj_file, config.gguf_file
+                    )
                 success = await asyncio.to_thread(
                     llama_backend.load_model,
                     gguf_path = config.gguf_file,
@@ -403,15 +645,18 @@ async def load_model(
                     cache_type_kv = request.cache_type_kv,
                     speculative_type = request.speculative_type,
                     n_parallel = _n_parallel,
+                    extra_args = extra_llama_args,
                 )
 
             if not success:
                 raise HTTPException(
                     status_code = 500,
-                    detail = f"Failed to load GGUF model: {config.display_name}",
+                    detail = f"Failed to load GGUF model: {model_log_label if native_grant_backed else config.display_name}",
                 )
 
-            logger.info(f"Loaded GGUF model via llama-server: {config.identifier}")
+            logger.info(
+                f"Loaded GGUF model via llama-server: {model_log_label if native_grant_backed else config.identifier}"
+            )
 
             # Detect TTS audio by probing the loaded model's vocabulary
             from utils.models import is_audio_input_type
@@ -420,6 +665,10 @@ async def load_model(
             _gguf_is_audio = _gguf_audio in ("snac", "bicodec", "dac")
             llama_backend._is_audio = _gguf_is_audio
             llama_backend._audio_type = _gguf_audio
+            llama_backend._native_display_label = (
+                model_log_label if native_grant_backed else None
+            )
+            llama_backend._native_grant_backed = bool(native_grant_backed)
             if _gguf_is_audio:
                 logger.info(f"GGUF model detected as audio: audio_type={_gguf_audio}")
                 await asyncio.to_thread(llama_backend.init_audio_codec, _gguf_audio)
@@ -428,8 +677,10 @@ async def load_model(
 
             return LoadResponse(
                 status = "loaded",
-                model = config.identifier,
-                display_name = config.display_name,
+                model = model_log_label if native_grant_backed else config.identifier,
+                display_name = model_log_label
+                if native_grant_backed
+                else config.display_name,
                 is_vision = config.is_vision,
                 is_lora = False,
                 is_gguf = True,
@@ -552,10 +803,13 @@ async def load_model(
                         ),
                     )
             raise HTTPException(
-                status_code = 500, detail = f"Failed to load model: {config.display_name}"
+                status_code = 500,
+                detail = f"Failed to load model: {model_log_label if native_grant_backed else config.display_name}",
             )
 
-        logger.info(f"Loaded model: {config.identifier}")
+        logger.info(
+            f"Loaded model: {model_log_label if native_grant_backed else config.identifier}"
+        )
 
         # Load inference configuration parameters
         inference_config = load_inference_config(config.identifier)
@@ -585,8 +839,10 @@ async def load_model(
 
         return LoadResponse(
             status = "loaded",
-            model = config.identifier,
-            display_name = config.display_name,
+            model = model_log_label if native_grant_backed else config.identifier,
+            display_name = model_log_label
+            if native_grant_backed
+            else config.display_name,
             is_vision = config.is_vision,
             is_lora = config.is_lora,
             is_gguf = False,
@@ -608,11 +864,17 @@ async def load_model(
     except HTTPException:
         raise
     except ValueError as e:
+        if native_grant_backed:
+            redacted_msg = redact_native_paths(str(e))
+            logger.warning(
+                "Rejected inference selection for native model %s: %s",
+                model_log_label,
+                redacted_msg,
+            )
+            raise HTTPException(status_code = 400, detail = redacted_msg)
         logger.warning("Rejected inference GPU selection: %s", e)
         raise HTTPException(status_code = 400, detail = str(e))
     except Exception as e:
-        logger.error(f"Error loading model: {e}", exc_info = True)
-        msg = str(e)
         # Surface a friendlier message for models that Unsloth cannot load
         not_supported_hints = [
             "No config file found",
@@ -620,6 +882,22 @@ async def load_model(
             "is not supported",
             "does not support",
         ]
+        if native_grant_backed:
+            redacted_msg = redact_native_paths(str(e))
+            logger.error(
+                "Error loading native model %s: %s",
+                model_log_label,
+                redacted_msg,
+            )
+            msg = redacted_msg
+            if any(h.lower() in msg.lower() for h in not_supported_hints):
+                msg = f"This model is not supported yet. Try a different model. (Original error: {msg})"
+            raise HTTPException(
+                status_code = 500,
+                detail = f"Failed to load native model {model_log_label}: {msg}",
+            )
+        logger.error(f"Error loading model: {e}", exc_info = True)
+        msg = str(e)
         if any(h.lower() in msg.lower() for h in not_supported_hints):
             msg = f"This model is not supported yet. Try a different model. (Original error: {msg})"
         raise HTTPException(status_code = 500, detail = f"Failed to load model: {msg}")
@@ -636,9 +914,14 @@ async def validate_model(
     This checks that ModelConfig.from_identifier() can resolve the given
     model_path, but it does NOT actually load model weights into GPU memory.
     """
+    native_grant_backed = False
+    model_log_label = request.model_path
     try:
+        model_identifier, model_log_label, native_grant_backed = (
+            _resolve_model_identifier_for_request(request, operation = "validate-model")
+        )
         config = ModelConfig.from_identifier(
-            model_id = request.model_path,
+            model_id = model_identifier,
             hf_token = request.hf_token,
             gguf_variant = request.gguf_variant,
         )
@@ -646,14 +929,16 @@ async def validate_model(
         if not config:
             raise HTTPException(
                 status_code = 400,
-                detail = f"Invalid model identifier: {request.model_path}",
+                detail = f"Invalid model identifier: {model_log_label}",
             )
 
         return ValidateModelResponse(
             valid = True,
             message = "Model identifier is valid.",
-            identifier = config.identifier,
-            display_name = getattr(config, "display_name", config.identifier),
+            identifier = model_log_label if native_grant_backed else config.identifier,
+            display_name = model_log_label
+            if native_grant_backed
+            else getattr(config, "display_name", config.identifier),
             is_gguf = getattr(config, "is_gguf", False),
             is_lora = getattr(config, "is_lora", False),
             is_vision = getattr(config, "is_vision", False),
@@ -665,6 +950,26 @@ async def validate_model(
     except HTTPException:
         raise
     except Exception as e:
+        not_supported_hints = [
+            "No config file found",
+            "not yet supported",
+            "is not supported",
+            "does not support",
+        ]
+        if native_grant_backed:
+            redacted_msg = redact_native_paths(str(e))
+            logger.error(
+                "Error validating native model %s: %s",
+                model_log_label,
+                redacted_msg,
+            )
+            msg = redacted_msg
+            if any(h.lower() in msg.lower() for h in not_supported_hints):
+                msg = f"This model is not supported yet. Try a different model. (Original error: {msg})"
+            raise HTTPException(
+                status_code = 400,
+                detail = f"Invalid native model {model_log_label}: {msg}",
+            )
         logger.error(
             f"Error validating model identifier '{request.model_path}': {e}",
             exc_info = True,
@@ -689,6 +994,9 @@ async def unload_model(
         llama_backend = get_llama_cpp_backend()
         if llama_backend.is_active and (
             llama_backend.model_identifier == request.model_path
+            or is_registered_native_path_label(
+                llama_backend.model_identifier, request.model_path
+            )
             or not llama_backend.is_loaded
         ):
             llama_backend.unload_model()
@@ -706,6 +1014,48 @@ async def unload_model(
         raise HTTPException(status_code = 500, detail = f"Failed to unload model: {str(e)}")
 
 
+@studio_router.post("/cancel")
+async def cancel_inference(
+    request: Request,
+    current_subject: str = Depends(get_current_subject),
+):
+    """Cancel in-flight inference requests.
+
+    Body (JSON, at least one key required):
+      cancel_id    - preferred: per-run UUID, matched exclusively.
+      session_id   - fallback when cancel_id is absent.
+      completion_id - fallback when cancel_id is absent.
+
+    A cancel_id arriving before its stream registers is stashed briefly
+    and replayed on registration. Returns {"cancelled": N}.
+    """
+    try:
+        body = await request.json()
+        if not isinstance(body, dict):
+            body = {}
+    except Exception as e:
+        logger.debug("Failed to parse cancel request body: %s", e)
+        body = {}
+
+    cancel_id = body.get("cancel_id")
+    if isinstance(cancel_id, str) and cancel_id:
+        return {"cancelled": _cancel_by_cancel_id_or_stash(cancel_id)}
+
+    keys = []
+    # `message_id` is the Anthropic passthrough's per-run identifier --
+    # included so /v1/messages clients can cancel by their native id.
+    for k in ("completion_id", "session_id", "message_id"):
+        v = body.get(k)
+        if isinstance(v, str) and v:
+            keys.append(v)
+
+    if not keys:
+        return {"cancelled": 0}
+
+    n = _cancel_by_keys(keys)
+    return {"cancelled": n}
+
+
 @router.post("/generate/stream")
 async def generate_stream(
     request: GenerateRequest,
@@ -794,16 +1144,27 @@ async def get_status(
         # If a GGUF model is loaded via llama-server, report that
         if llama_backend.is_loaded:
             _model_id = llama_backend.model_identifier
+            _native_grant_backed = getattr(llama_backend, "_native_grant_backed", False)
+            _display_model_id = getattr(
+                llama_backend, "_native_display_label", None
+            ) or display_label_for_native_path(_model_id)
+            if (
+                _native_grant_backed
+                and _model_id
+                and _display_model_id == _model_id
+                and os.path.isabs(_model_id)
+            ):
+                _display_model_id = os.path.basename(_model_id)
             _inference_cfg = load_inference_config(_model_id) if _model_id else None
             return InferenceStatusResponse(
-                active_model = _model_id,
+                active_model = _display_model_id,
                 is_vision = llama_backend.is_vision,
                 is_gguf = True,
                 gguf_variant = llama_backend.hf_variant,
                 is_audio = getattr(llama_backend, "_is_audio", False),
                 audio_type = getattr(llama_backend, "_audio_type", None),
                 loading = [],
-                loaded = [_model_id],
+                loaded = [_display_model_id] if _display_model_id else [],
                 inference = _inference_cfg,
                 requires_trust_remote_code = bool(
                     (_inference_cfg or {}).get("trust_remote_code", False)
@@ -813,6 +1174,7 @@ async def get_status(
                 reasoning_always_on = llama_backend.reasoning_always_on,
                 supports_preserve_thinking = llama_backend.supports_preserve_thinking,
                 supports_tools = llama_backend.supports_tools,
+                chat_template = llama_backend.chat_template,
                 context_length = llama_backend.context_length,
                 max_context_length = llama_backend.max_context_length,
                 native_context_length = llama_backend.native_context_length,
@@ -826,12 +1188,19 @@ async def get_status(
         is_audio = False
         audio_type = None
         has_audio_input = False
+        model_info = {}
         if backend.active_model_name:
             model_info = backend.models.get(backend.active_model_name, {})
             is_vision = model_info.get("is_vision", False)
             is_audio = model_info.get("is_audio", False)
             audio_type = model_info.get("audio_type")
             has_audio_input = model_info.get("has_audio_input", False)
+        chat_template_info = model_info.get("chat_template_info", {})
+        chat_template = (
+            chat_template_info.get("template")
+            if isinstance(chat_template_info, dict)
+            else None
+        )
 
         # Non-GGUF: only gpt-oss Harmony is wired through the transformers
         # generation path. Other template-level reasoning / tool kwargs
@@ -869,6 +1238,7 @@ async def get_status(
             reasoning_always_on = False,
             supports_preserve_thinking = False,
             supports_tools = False,
+            chat_template = chat_template,
         )
 
     except Exception as e:
@@ -1114,6 +1484,20 @@ async def openai_chat_completions(
     llama_backend = get_llama_cpp_backend()
     using_gguf = llama_backend.is_loaded
 
+    # OpenAI-SDK clients send ``chat_template_kwargs`` via ``extra_body``,
+    # which the SDK spreads into the request body at the top level. Studio's
+    # ChatCompletionRequest has ``extra="allow"`` so pydantic stashes them in
+    # ``model_extra``, but the typed ``payload.enable_thinking`` path is what
+    # downstream generators actually consume. Lift ``enable_thinking`` from
+    # the extra-body chat_template_kwargs onto the typed field so clients
+    # that only know the OpenAI shape (data_designer recipe runs, etc.)
+    # can still control the reasoning preamble.
+    _extra = getattr(payload, "model_extra", None)
+    if payload.enable_thinking is None and isinstance(_extra, dict):
+        _tpl_kw = _extra.get("chat_template_kwargs")
+        if isinstance(_tpl_kw, dict) and "enable_thinking" in _tpl_kw:
+            payload.enable_thinking = bool(_tpl_kw["enable_thinking"])
+
     # ── Determine which backend is active ─────────────────────
     if using_gguf:
         model_name = llama_backend.model_identifier or payload.model
@@ -1169,6 +1553,9 @@ async def openai_chat_completions(
                 )
 
             if payload.stream:
+                _cancel_keys = (payload.cancel_id, payload.session_id, completion_id)
+                _tracker = _TrackedCancel(cancel_event, *_cancel_keys)
+                _tracker.__enter__()
 
                 async def audio_input_stream():
                     try:
@@ -1185,10 +1572,17 @@ async def openai_chat_completions(
                         )
                         yield f"data: {first_chunk.model_dump_json(exclude_none = True)}\n\n"
 
-                        for chunk_text in audio_input_generate():
+                        gen = audio_input_generate()
+                        _DONE = object()
+                        while True:
+                            if cancel_event.is_set():
+                                break
                             if await request.is_disconnected():
                                 cancel_event.set()
                                 return
+                            chunk_text = await asyncio.to_thread(next, gen, _DONE)
+                            if chunk_text is _DONE:
+                                break
                             if chunk_text:
                                 chunk = ChatCompletionChunk(
                                     id = completion_id,
@@ -1221,6 +1615,8 @@ async def openai_chat_completions(
                             f"Error during audio input streaming: {e}", exc_info = True
                         )
                         yield f"data: {json.dumps({'error': {'message': _friendly_error(e), 'type': 'server_error'}})}\n\n"
+                    finally:
+                        _tracker.__exit__(None, None, None)
 
                 return StreamingResponse(
                     audio_input_stream(),
@@ -1256,11 +1652,22 @@ async def openai_chat_completions(
     # carry `tool_calls` (content=None) — both of which are valid in
     # multi-turn client-side tool loops.
     _has_tool_messages = any(m.role == "tool" or m.tool_calls for m in payload.messages)
+    # Route guided-decoding requests through the verbatim passthrough so
+    # ``response_format`` (JSON schema) actually reaches llama-server and
+    # the model's GBNF-constrained output comes back unmodified. The
+    # non-passthrough GGUF path below calls ``generate_chat_completion``
+    # which has no response_format kwarg, so the schema gets silently
+    # dropped and data_designer falls back to free-form sampling. Guided
+    # decoding does not require ``supports_tools`` - the grammar machinery
+    # is independent of tool-call parsing.
+    _has_response_format = _extract_response_format(payload) is not None
+    _tools_passthrough = llama_backend.supports_tools and (
+        (payload.tools and len(payload.tools) > 0) or _has_tool_messages
+    )
     if (
         using_gguf
-        and llama_backend.supports_tools
-        and not payload.enable_tools
-        and ((payload.tools and len(payload.tools) > 0) or _has_tool_messages)
+        and not _effective_enable_tools(payload)
+        and (_tools_passthrough or _has_response_format)
     ):
         # Preserve the vision guard that would otherwise run in the
         # non-passthrough path below: text-only tool-capable GGUFs
@@ -1350,8 +1757,13 @@ async def openai_chat_completions(
         created = int(time.time())
 
         # ── Tool-calling path (agentic loop) ──────────────────
+        # `_effective_enable_tools` lets `unsloth run --enable-tools/--disable-tools`
+        # hard-override the per-request value. Without a CLI override, falls
+        # back to `payload.enable_tools` (existing behavior).
         use_tools = (
-            payload.enable_tools and llama_backend.supports_tools and not image_b64
+            _effective_enable_tools(payload)
+            and llama_backend.supports_tools
+            and not image_b64
         )
 
         if use_tools:
@@ -1466,6 +1878,10 @@ async def openai_chat_completions(
 
             _tool_sentinel = object()
 
+            _cancel_keys = (payload.cancel_id, payload.session_id, completion_id)
+            _tracker = _TrackedCancel(cancel_event, *_cancel_keys)
+            _tracker.__enter__()
+
             async def gguf_tool_stream():
                 try:
                     first_chunk = ChatCompletionChunk(
@@ -1488,6 +1904,8 @@ async def openai_chat_completions(
                     _stream_usage = None
                     _stream_timings = None
                     while True:
+                        if cancel_event.is_set():
+                            break
                         if await request.is_disconnected():
                             cancel_event.set()
                             return
@@ -1595,6 +2013,8 @@ async def openai_chat_completions(
                         },
                     }
                     yield f"data: {json.dumps(error_chunk)}\n\n"
+                finally:
+                    _tracker.__exit__(None, None, None)
 
             return StreamingResponse(
                 gguf_tool_stream(),
@@ -1628,6 +2048,9 @@ async def openai_chat_completions(
         _gguf_sentinel = object()
 
         if payload.stream:
+            _cancel_keys = (payload.cancel_id, payload.session_id, completion_id)
+            _tracker = _TrackedCancel(cancel_event, *_cancel_keys)
+            _tracker.__enter__()
 
             async def gguf_stream_chunks():
                 try:
@@ -1652,6 +2075,8 @@ async def openai_chat_completions(
                     _stream_usage = None
                     _stream_timings = None
                     while True:
+                        if cancel_event.is_set():
+                            break
                         if await request.is_disconnected():
                             cancel_event.set()
                             return
@@ -1735,6 +2160,8 @@ async def openai_chat_completions(
                         },
                     }
                     yield f"data: {json.dumps(error_chunk)}\n\n"
+                finally:
+                    _tracker.__exit__(None, None, None)
 
             return StreamingResponse(
                 gguf_stream_chunks(),
@@ -1834,6 +2261,9 @@ async def openai_chat_completions(
 
     # ── Streaming response ────────────────────────────────────────
     if payload.stream:
+        _cancel_keys = (payload.cancel_id, payload.session_id, completion_id)
+        _tracker = _TrackedCancel(cancel_event, *_cancel_keys)
+        _tracker.__enter__()
 
         async def stream_chunks():
             try:
@@ -1861,6 +2291,9 @@ async def openai_chat_completions(
                 loop = asyncio.get_event_loop()
                 gen = generate()
                 while True:
+                    if cancel_event.is_set():
+                        backend.reset_generation_state()
+                        break
                     # next(gen, _DONE) returns _DONE instead of raising
                     # StopIteration — StopIteration cannot propagate
                     # through asyncio futures (Python limitation).
@@ -1916,6 +2349,8 @@ async def openai_chat_completions(
                     },
                 }
                 yield f"data: {json.dumps(error_chunk)}\n\n"
+            finally:
+                _tracker.__exit__(None, None, None)
 
         return StreamingResponse(
             stream_chunks(),
@@ -2596,7 +3031,9 @@ async def _responses_stream(
             ),
         )
 
-    body = _build_openai_passthrough_body(chat_req)
+    body = _build_openai_passthrough_body(
+        chat_req, backend_ctx = llama_backend.context_length
+    )
     target_url = f"{llama_backend.base_url}/v1/chat/completions"
 
     async def event_generator():
@@ -3050,7 +3487,9 @@ async def anthropic_messages(
     # Server-side agentic loop doesn't support multimodal input — matches
     # the `not image_b64` gate in /v1/chat/completions.
     server_tools = (
-        payload.enable_tools and llama_backend.supports_tools and not _has_image
+        _effective_enable_tools(payload)
+        and llama_backend.supports_tools
+        and not _has_image
     )
     client_tools = (
         not server_tools
@@ -3081,6 +3520,8 @@ async def anthropic_messages(
                 repetition_penalty = repetition_penalty,
                 presence_penalty = presence_penalty,
                 tool_choice = openai_tool_choice,
+                session_id = payload.session_id,
+                cancel_id = payload.cancel_id,
             )
         return await _anthropic_passthrough_non_streaming(
             llama_backend,
@@ -3441,6 +3882,9 @@ def _build_passthrough_payload(
     repetition_penalty = None,
     presence_penalty = None,
     tool_choice = "auto",
+    response_format = None,
+    chat_template_kwargs = None,
+    backend_ctx = None,
 ):
     body = {
         "messages": openai_messages,
@@ -3453,8 +3897,12 @@ def _build_passthrough_payload(
     }
     if stream:
         body["stream_options"] = {"include_usage": True}
-    if max_tokens is not None:
-        body["max_tokens"] = max_tokens
+    body["max_tokens"] = (
+        max_tokens
+        if max_tokens is not None
+        else (backend_ctx or _DEFAULT_MAX_TOKENS_FLOOR)
+    )
+    body["t_max_predict_ms"] = _DEFAULT_T_MAX_PREDICT_MS
     if stop:
         body["stop"] = stop
     if min_p is not None:
@@ -3464,6 +3912,17 @@ def _build_passthrough_payload(
         body["repeat_penalty"] = repetition_penalty
     if presence_penalty is not None:
         body["presence_penalty"] = presence_penalty
+    if response_format is not None:
+        # llama-server applies a GBNF grammar derived from the JSON schema
+        # when response_format is present. Field is documented flat at the
+        # request root (tools/server/README.md), which is also what the
+        # OpenAI SDK produces by spreading extra_body into the body top.
+        body["response_format"] = response_format
+    if chat_template_kwargs is not None:
+        # Propagate reasoning / template overrides (e.g. enable_thinking)
+        # so llama-server renders the Jinja template in the mode the caller
+        # asked for instead of whatever default the model was loaded with.
+        body["chat_template_kwargs"] = chat_template_kwargs
     return body
 
 
@@ -3484,6 +3943,8 @@ async def _anthropic_passthrough_stream(
     repetition_penalty = None,
     presence_penalty = None,
     tool_choice = "auto",
+    session_id = None,
+    cancel_id = None,
 ):
     """Streaming client-side pass-through: forward tools to llama-server and
     translate its streaming response to Anthropic SSE without executing anything."""
@@ -3501,8 +3962,14 @@ async def _anthropic_passthrough_stream(
         repetition_penalty = repetition_penalty,
         presence_penalty = presence_penalty,
         tool_choice = tool_choice,
+        backend_ctx = llama_backend.context_length,
     )
 
+    # cancel_id mirrors the OpenAI passthrough so a per-run cancel POST
+    # works without the caller having to know the local message_id.
+    _tracker = _TrackedCancel(cancel_event, cancel_id, session_id, message_id)
+    _tracker.__enter__()
+
     async def _stream():
         emitter = AnthropicPassthroughEmitter()
         for line in emitter.start(message_id, model_name):
@@ -3535,15 +4002,28 @@ async def _anthropic_passthrough_stream(
         # has anything orphaned to finalize. Each aclose is wrapped in
         # `try: ... except Exception: pass` so anyio cleanup noise from
         # nested aclose paths can't bubble out.
-        client = httpx.AsyncClient(timeout = 600)
+        client = httpx.AsyncClient(
+            timeout = 600,
+            limits = httpx.Limits(max_keepalive_connections = 0),
+        )
         resp = None
         lines_iter = None
+        cancel_watcher = None
         try:
             req = client.build_request("POST", target_url, json = body)
             resp = await client.send(req, stream = True)
 
+            # See _openai_passthrough_stream for rationale: aiter_lines()
+            # blocks during llama-server prefill, so the in-loop cancel
+            # check is unreachable until the first SSE chunk arrives.
+            # The watcher closes `resp` on cancel, raising in aiter_lines.
+            cancel_watcher = asyncio.create_task(
+                _await_cancel_then_close(cancel_event, resp)
+            )
             lines_iter = resp.aiter_lines()
             async for raw_line in lines_iter:
+                if cancel_event.is_set():
+                    break
                 if await request.is_disconnected():
                     cancel_event.set()
                     break
@@ -3558,9 +4038,18 @@ async def _anthropic_passthrough_stream(
                     continue
                 for line in emitter.feed_chunk(chunk):
                     yield line
+        except (httpx.RemoteProtocolError, httpx.ReadError, httpx.CloseError):
+            if not cancel_event.is_set():
+                raise
         except Exception as e:
             logger.error("anthropic_messages passthrough stream error: %s", e)
         finally:
+            if cancel_watcher is not None:
+                cancel_watcher.cancel()
+                try:
+                    await cancel_watcher
+                except (asyncio.CancelledError, Exception):
+                    pass
             if lines_iter is not None:
                 try:
                     await lines_iter.aclose()
@@ -3575,6 +4064,7 @@ async def _anthropic_passthrough_stream(
                 await client.aclose()
             except Exception:
                 pass
+            _tracker.__exit__(None, None, None)
 
         for line in emitter.finish():
             yield line
@@ -3621,6 +4111,7 @@ async def _anthropic_passthrough_non_streaming(
         repetition_penalty = repetition_penalty,
         presence_penalty = presence_penalty,
         tool_choice = tool_choice,
+        backend_ctx = llama_backend.context_length,
     )
 
     async with httpx.AsyncClient() as client:
@@ -3742,7 +4233,21 @@ def _openai_messages_for_passthrough(payload) -> list[dict]:
     return messages
 
 
-def _build_openai_passthrough_body(payload) -> dict:
+def _extract_response_format(payload):
+    """Return the ``response_format`` field on an incoming ChatCompletionRequest
+    (or None). The model is declared with ``extra="allow"`` so pydantic stashes
+    unknown top-level fields in ``model_extra``; OpenAI-SDK clients spread
+    ``extra_body`` into the request body top level, which is where guided-
+    decoding recipes park their JSON-schema response_format.
+    """
+    extra = getattr(payload, "model_extra", None)
+    if not isinstance(extra, dict):
+        return None
+    rf = extra.get("response_format")
+    return rf if isinstance(rf, dict) else None
+
+
+def _build_openai_passthrough_body(payload, backend_ctx = None) -> dict:
     """Assemble the llama-server request body from a ChatCompletionRequest.
 
     Only explicitly-known OpenAI / llama-server fields are forwarded so that
@@ -3751,6 +4256,12 @@ def _build_openai_passthrough_body(payload) -> dict:
     """
     messages = _openai_messages_for_passthrough(payload)
     tool_choice = payload.tool_choice if payload.tool_choice is not None else "auto"
+    # When the caller asked for a specific reasoning mode, forward it to
+    # llama-server via chat_template_kwargs so the Jinja template renders
+    # with (or without) the reasoning preamble.
+    tpl_kwargs = None
+    if payload.enable_thinking is not None:
+        tpl_kwargs = {"enable_thinking": bool(payload.enable_thinking)}
     return _build_passthrough_payload(
         messages,
         payload.tools,
@@ -3764,6 +4275,9 @@ def _build_openai_passthrough_body(payload) -> dict:
         repetition_penalty = payload.repetition_penalty,
         presence_penalty = payload.presence_penalty,
         tool_choice = tool_choice,
+        response_format = _extract_response_format(payload),
+        chat_template_kwargs = tpl_kwargs,
+        backend_ctx = backend_ctx,
     )
 
 
@@ -3784,103 +4298,56 @@ async def _openai_passthrough_stream(
     observes a standard OpenAI response.
     """
     target_url = f"{llama_backend.base_url}/v1/chat/completions"
-    body = _build_openai_passthrough_body(payload)
+    body = _build_openai_passthrough_body(
+        payload, backend_ctx = llama_backend.context_length
+    )
 
-    # Dispatch the upstream request BEFORE returning StreamingResponse so
-    # transport errors and non-200 upstream statuses surface as real HTTP
-    # errors to the client. OpenAI SDKs rely on status codes to raise
-    # ``APIError``/``BadRequestError``/...; burying the failure inside a
-    # 200 SSE ``error`` frame silently breaks their error handling.
-    client = httpx.AsyncClient(timeout = 600)
-    resp = None
+    _cancel_keys = (payload.cancel_id, payload.session_id, completion_id)
+    _tracker = _TrackedCancel(cancel_event, *_cancel_keys)
+    _tracker.__enter__()
+
+    # Outer guard: asyncio.CancelledError at `await client.send(...)` is
+    # a BaseException that bypasses `except httpx.RequestError`; without
+    # this the tracker leaks. The generator's finally only runs once
+    # iteration starts.
     try:
-        req = client.build_request("POST", target_url, json = body)
-        resp = await client.send(req, stream = True)
-    except httpx.RequestError as e:
-        # llama-server subprocess crashed / still starting / unreachable.
-        logger.error("openai passthrough stream: upstream unreachable: %s", e)
-        if resp is not None:
-            try:
-                await resp.aclose()
-            except Exception:
-                pass
-        try:
-            await client.aclose()
-        except Exception:
-            pass
-        raise HTTPException(
-            status_code = 502,
-            detail = _friendly_error(e),
+        # Dispatch BEFORE returning StreamingResponse so transport errors
+        # and non-200 upstream statuses surface as real HTTP errors --
+        # OpenAI SDKs rely on status codes to raise APIError/BadRequestError.
+        client = httpx.AsyncClient(
+            timeout = 600,
+            limits = httpx.Limits(max_keepalive_connections = 0),
         )
-
-    if resp.status_code != 200:
-        err_bytes = await resp.aread()
-        err_text = err_bytes.decode("utf-8", errors = "replace")
-        logger.error(
-            "openai passthrough upstream error: status=%s body=%s",
-            resp.status_code,
-            err_text[:500],
-        )
-        upstream_status = resp.status_code
+        resp = None
         try:
-            await resp.aclose()
-        except Exception:
-            pass
-        try:
-            await client.aclose()
-        except Exception:
-            pass
-        raise HTTPException(
-            status_code = upstream_status,
-            detail = f"llama-server error: {err_text[:500]}",
-        )
-
-    async def _stream():
-        # Same httpx lifecycle pattern as _anthropic_passthrough_stream:
-        # avoid `async with` on the client/response AND explicitly save
-        # resp.aiter_lines() so we can close it ourselves in the finally
-        # block. See the long comment there for the full rationale on
-        # why the anonymous `async for raw_line in resp.aiter_lines():`
-        # pattern leaks an unclosed async generator that Python's
-        # asyncgen GC hook then finalizes in a different asyncio task,
-        # producing "Exception ignored in:" / "async generator ignored
-        # GeneratorExit" / anyio cancel-scope traces on Python 3.13 +
-        # httpcore 1.0.x.
-        lines_iter = None
-        try:
-            lines_iter = resp.aiter_lines()
-            async for raw_line in lines_iter:
-                if await request.is_disconnected():
-                    cancel_event.set()
-                    break
-                if not raw_line:
-                    continue
-                if not raw_line.startswith("data: "):
-                    continue
-                # Relay the llama-server SSE chunk verbatim so the client
-                # sees its native `id`, `finish_reason`, `delta.tool_calls`,
-                # and final `usage` unchanged.
-                yield raw_line + "\n\n"
-                if raw_line[6:].strip() == "[DONE]":
-                    break
-        except Exception as e:
-            # Mid-stream failures still have to be reported inside the SSE
-            # body because the 200 response headers have already been
-            # committed by the time the first chunk flushes.
-            logger.error("openai passthrough stream error: %s", e)
-            err = {
-                "error": {
-                    "message": _friendly_error(e),
-                    "type": "server_error",
-                },
-            }
-            yield f"data: {json.dumps(err)}\n\n"
-        finally:
-            if lines_iter is not None:
+            req = client.build_request("POST", target_url, json = body)
+            resp = await client.send(req, stream = True)
+        except httpx.RequestError as e:
+            # llama-server subprocess crashed / still starting / unreachable.
+            logger.error("openai passthrough stream: upstream unreachable: %s", e)
+            if resp is not None:
                 try:
-                    await lines_iter.aclose()
+                    await resp.aclose()
                 except Exception:
                     pass
+            try:
+                await client.aclose()
+            except Exception:
+                pass
+            raise HTTPException(
+                status_code = 502,
+                detail = _friendly_error(e),
+            )
+
+        if resp.status_code != 200:
+            err_bytes = await resp.aread()
+            err_text = err_bytes.decode("utf-8", errors = "replace")
+            logger.error(
+                "openai passthrough upstream error: status=%s body=%s",
+                resp.status_code,
+                err_text[:500],
+            )
+            upstream_status = resp.status_code
             try:
                 await resp.aclose()
             except Exception:
@@ -3889,16 +4356,91 @@ async def _openai_passthrough_stream(
                 await client.aclose()
             except Exception:
                 pass
+            raise HTTPException(
+                status_code = upstream_status,
+                detail = f"llama-server error: {err_text[:500]}",
+            )
 
-    return StreamingResponse(
-        _stream(),
-        media_type = "text/event-stream",
-        headers = {
-            "Cache-Control": "no-cache",
-            "Connection": "keep-alive",
-            "X-Accel-Buffering": "no",
-        },
-    )
+        async def _stream():
+            # Same httpx lifecycle pattern as _anthropic_passthrough_stream:
+            # save resp.aiter_lines() so the finally block can aclose() it
+            # on our task. See that function for full rationale.
+            lines_iter = None
+            # During llama-server prefill, `aiter_lines()` blocks until the
+            # first SSE chunk arrives. The in-loop `cancel_event` check
+            # cannot fire until then, which is the exact proxy/Colab
+            # scenario the cancel POST is meant to recover from. Run a
+            # tiny watcher that closes `resp` as soon as cancel fires,
+            # unblocking the iterator with a RemoteProtocolError caught
+            # in the except clause below.
+            cancel_watcher = asyncio.create_task(
+                _await_cancel_then_close(cancel_event, resp)
+            )
+            try:
+                lines_iter = resp.aiter_lines()
+                async for raw_line in lines_iter:
+                    if cancel_event.is_set():
+                        break
+                    if await request.is_disconnected():
+                        cancel_event.set()
+                        break
+                    if not raw_line:
+                        continue
+                    if not raw_line.startswith("data: "):
+                        continue
+                    # Relay verbatim to preserve llama-server's native id,
+                    # finish_reason, delta.tool_calls, and usage chunks.
+                    yield raw_line + "\n\n"
+                    if raw_line[6:].strip() == "[DONE]":
+                        break
+            except (httpx.RemoteProtocolError, httpx.ReadError, httpx.CloseError):
+                # Watcher closed resp on cancel. Emit nothing extra; the
+                # client either initiated the cancel or already disconnected.
+                if not cancel_event.is_set():
+                    raise
+            except Exception as e:
+                # 200 headers are already flushed; errors must be in the SSE body.
+                logger.error("openai passthrough stream error: %s", e)
+                err = {
+                    "error": {
+                        "message": _friendly_error(e),
+                        "type": "server_error",
+                    },
+                }
+                yield f"data: {json.dumps(err)}\n\n"
+            finally:
+                cancel_watcher.cancel()
+                try:
+                    await cancel_watcher
+                except (asyncio.CancelledError, Exception):
+                    pass
+                if lines_iter is not None:
+                    try:
+                        await lines_iter.aclose()
+                    except Exception:
+                        pass
+                try:
+                    await resp.aclose()
+                except Exception:
+                    pass
+                try:
+                    await client.aclose()
+                except Exception:
+                    pass
+                _tracker.__exit__(None, None, None)
+
+        return StreamingResponse(
+            _stream(),
+            media_type = "text/event-stream",
+            headers = {
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "X-Accel-Buffering": "no",
+            },
+        )
+    except BaseException:
+        _tracker.__exit__(None, None, None)
+        raise
 
 
 async def _openai_passthrough_non_streaming(
@@ -3914,7 +4456,9 @@ async def _openai_passthrough_non_streaming(
     token counts.
     """
     target_url = f"{llama_backend.base_url}/v1/chat/completions"
-    body = _build_openai_passthrough_body(payload)
+    body = _build_openai_passthrough_body(
+        payload, backend_ctx = llama_backend.context_length
+    )
 
     try:
         async with httpx.AsyncClient() as client:
@@ -3935,6 +4479,41 @@ async def _openai_passthrough_non_streaming(
             detail = f"llama-server error: {resp.text[:500]}",
         )
 
+    # Guided-decoding fence wrap. llama-server returns raw JSON that matches
+    # the schema (no surrounding markdown) because the GBNF grammar only
+    # emits the JSON object itself. data_designer's llm-structured parser
+    # looks for a ```json ... ``` markdown fence and discards unfenced
+    # output, which collapses a 100%-valid guided-decoding run to 0/N.
+    # Wrap each choice's content in the expected fence when the caller
+    # asked for guided decoding, leaving already-fenced content alone.
+    if _extract_response_format(payload) is not None:
+        try:
+            data = resp.json()
+            changed = False
+            for choice in data.get("choices", []):
+                if not isinstance(choice, dict):
+                    continue
+                msg = choice.get("message")
+                if not isinstance(msg, dict):
+                    continue
+                content = msg.get("content")
+                if not isinstance(content, str):
+                    continue
+                stripped = content.strip()
+                if not stripped or stripped.startswith("```"):
+                    continue
+                msg["content"] = f"```json\n{stripped}\n```"
+                changed = True
+            if changed:
+                return JSONResponse(content = data)
+        except Exception as exc:
+            # Wrap is best-effort; fall through to the verbatim body if
+            # the response is not JSON-shaped or the structure is unusual.
+            logger.warning(
+                "response_format fence wrap skipped: %s",
+                exc,
+            )
+
     # Pass the upstream body through as raw bytes — skips a redundant
     # parse+re-serialize round-trip and keeps the response truly
     # verbatim (matches the docstring). Status is guaranteed 200 by
diff --git a/studio/backend/routes/models.py b/studio/backend/routes/models.py
index db27ce1907..d01e94b0c9 100644
--- a/studio/backend/routes/models.py
+++ b/studio/backend/routes/models.py
@@ -8,6 +8,7 @@ Model Management API routes
 import hashlib
 import json
 import os
+import shutil
 import sys
 import uuid
 from pathlib import Path
@@ -623,7 +624,7 @@ def _scan_ollama_dir(
             gguf_link_path: Optional[str] = None
             quant = f"-{file_type}" if file_type else ""
             safe_name = repo_name.replace("/", "-")
-            for layer in manifest.get("layers", []):
+            for layer in manifest.get("layers") or []:
                 media = layer.get("mediaType", "")
                 digest = layer.get("digest", "")
                 if not digest:
@@ -1684,6 +1685,338 @@ async def scan_loras(
         )
 
 
+def _is_path_under(path: Path, root: Path) -> bool:
+    try:
+        path.resolve().relative_to(root.resolve())
+        return True
+    except ValueError:
+        return False
+
+
+def _is_path_under_lexically(path: Path, root: Path) -> bool:
+    """Check containment without resolving the final path's symlink target."""
+    try:
+        absolute_path = Path(os.path.abspath(str(path)))
+        absolute_root = Path(os.path.abspath(str(root)))
+        absolute_path.relative_to(absolute_root)
+        return True
+    except ValueError:
+        return False
+
+
+def _loaded_model_matches_deleted_path(active_model: str, deleted_path: Path) -> bool:
+    try:
+        active = Path(active_model).expanduser().resolve()
+        target = deleted_path.resolve()
+        return active == target or (target.is_dir() and active.is_relative_to(target))
+    except (OSError, RuntimeError, ValueError) as e:
+        logger.debug(
+            "Could not resolve loaded/deleted model paths; falling back to string comparison: %s",
+            e,
+        )
+        active_lower = active_model.lower()
+        target_lower = str(deleted_path).lower()
+        return active_lower == target_lower or active_lower.startswith(
+            f"{target_lower}{os.sep}"
+        )
+
+
+def _loading_model_matches_deleted_path(
+    loading_model: object,
+    deleted_path: Path,
+) -> bool:
+    if not loading_model:
+        return False
+    return _loaded_model_matches_deleted_path(str(loading_model), deleted_path)
+
+
+def _prune_empty_parents(start: Path, stop_at: Path) -> None:
+    """Remove empty ancestor directories of ``start`` up to (but not including) ``stop_at``.
+
+    Used after deleting a model checkpoint so the enclosing run directory does
+    not linger as an empty entry in scan results.
+    """
+    try:
+        stop_resolved = stop_at.resolve()
+    except OSError:
+        return
+    parent = start.parent
+    while True:
+        try:
+            parent_resolved = parent.resolve()
+        except OSError:
+            return
+        if parent_resolved == stop_resolved:
+            return
+        try:
+            parent_resolved.relative_to(stop_resolved)
+        except ValueError:
+            return
+        try:
+            parent.rmdir()
+        except OSError:
+            return
+        parent = parent.parent
+
+
+def _delete_gguf_variant_files(root: Path, variant: str) -> tuple[int, int]:
+    deleted_count = 0
+    deleted_bytes = 0
+    for path in root.rglob("*"):
+        if not path.is_file() or not _is_main_gguf_filename(path.name):
+            continue
+        if _extract_quant_label(path.name).lower() != variant.lower():
+            continue
+        try:
+            deleted_bytes += path.stat().st_size
+        except OSError:
+            pass
+        path.unlink()
+        deleted_count += 1
+    return deleted_count, deleted_bytes
+
+
+@router.delete("/delete-finetuned")
+async def delete_finetuned_model(
+    model_path: str = Body(...),
+    source: str = Body(...),
+    export_type: Optional[str] = Body(None),
+    gguf_variant: Optional[str] = Body(None),
+    current_subject: str = Depends(get_current_subject),
+):
+    """Delete a Studio-trained or exported model from disk.
+
+    Only paths under Studio's outputs/exports roots are accepted.  Exported
+    GGUF entries can delete one quantization variant at a time.
+    """
+    if source not in {"training", "exported"}:
+        raise HTTPException(
+            status_code = 400,
+            detail = "Only trained or exported Studio models can be deleted",
+        )
+
+    if not model_path or not model_path.strip():
+        raise HTTPException(status_code = 400, detail = "model_path is required")
+
+    if export_type == "gguf" and not gguf_variant:
+        raise HTTPException(
+            status_code = 400,
+            detail = "gguf_variant is required when export_type is 'gguf'",
+        )
+
+    raw_path = Path(model_path).expanduser()
+    if source == "training":
+        target_path = raw_path
+        allowed_root = outputs_root()
+    else:
+        allowed_root = exports_root()
+        target_path = (
+            raw_path.parent
+            if export_type == "gguf" and raw_path.suffix.lower() == ".gguf"
+            else raw_path
+        )
+
+    allowed_root = allowed_root.resolve()
+    delete_path = Path(os.path.abspath(str(target_path)))
+    delete_path_is_symlink = delete_path.is_symlink()
+
+    if delete_path_is_symlink:
+        if not _is_path_under_lexically(delete_path, allowed_root):
+            raise HTTPException(
+                status_code = 400,
+                detail = "Model path is outside Studio storage",
+            )
+        if export_type == "gguf" and gguf_variant:
+            target_path = delete_path.resolve()
+            if not _is_path_under(target_path, allowed_root):
+                raise HTTPException(
+                    status_code = 400,
+                    detail = "Model path is outside Studio storage",
+                )
+        else:
+            target_path = delete_path
+    else:
+        target_path = target_path.resolve()
+
+    should_check_resolved_path = not delete_path_is_symlink or (
+        export_type == "gguf" and gguf_variant
+    )
+    if should_check_resolved_path and not _is_path_under(target_path, allowed_root):
+        raise HTTPException(
+            status_code = 400,
+            detail = "Model path is outside Studio storage",
+        )
+    if target_path == allowed_root:
+        raise HTTPException(
+            status_code = 400,
+            detail = "Refusing to delete storage root",
+        )
+    if not target_path.exists() and not target_path.is_symlink():
+        raise HTTPException(status_code = 404, detail = "Model not found on disk")
+
+    if source == "training":
+        try:
+            from core.training import get_training_backend
+
+            training_backend = get_training_backend()
+            if training_backend.is_training_active():
+                raise HTTPException(
+                    status_code = 409,
+                    detail = "Cannot delete trained models while training is running",
+                )
+        except HTTPException:
+            raise
+        except Exception as e:
+            logger.warning("Could not check training status before delete: %s", e)
+            raise HTTPException(
+                status_code = 500,
+                detail = "Could not verify training status before deleting",
+            ) from e
+
+    try:
+        from routes.inference import get_llama_cpp_backend
+
+        llama_backend = get_llama_cpp_backend()
+        if (
+            llama_backend.is_active
+            and not llama_backend.is_loaded
+            and llama_backend.model_identifier
+            and _loaded_model_matches_deleted_path(
+                llama_backend.model_identifier,
+                target_path,
+            )
+            and (
+                not gguf_variant
+                or not llama_backend.hf_variant
+                or llama_backend.hf_variant.lower() == gguf_variant.lower()
+            )
+        ):
+            raise HTTPException(
+                status_code = 409,
+                detail = "Cannot delete a model while it is loading",
+            )
+        if (
+            llama_backend.is_loaded
+            and llama_backend.model_identifier
+            and _loaded_model_matches_deleted_path(
+                llama_backend.model_identifier,
+                target_path,
+            )
+            and (
+                not gguf_variant
+                or not llama_backend.hf_variant
+                or llama_backend.hf_variant.lower() == gguf_variant.lower()
+            )
+        ):
+            raise HTTPException(
+                status_code = 400,
+                detail = "Unload the model before deleting",
+            )
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.warning("Could not check llama.cpp loaded model before delete: %s", e)
+        raise HTTPException(
+            status_code = 503,
+            detail = "Could not verify model load status before deleting",
+        ) from e
+
+    try:
+        inference_backend = get_inference_backend()
+        loading_models = getattr(inference_backend, "loading_models", set())
+        if any(
+            _loading_model_matches_deleted_path(loading_model, target_path)
+            for loading_model in loading_models
+        ):
+            raise HTTPException(
+                status_code = 409,
+                detail = "Cannot delete a model while it is loading",
+            )
+        if inference_backend.active_model_name:
+            if _loaded_model_matches_deleted_path(
+                inference_backend.active_model_name,
+                target_path,
+            ):
+                raise HTTPException(
+                    status_code = 400,
+                    detail = "Unload the model before deleting",
+                )
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.warning(
+            "Could not check inference backend loaded model before delete: %s", e
+        )
+        raise HTTPException(
+            status_code = 503,
+            detail = "Could not verify model load status before deleting",
+        ) from e
+
+    try:
+        if export_type == "gguf" and gguf_variant:
+            if not target_path.is_dir():
+                raise HTTPException(
+                    status_code = 400,
+                    detail = "GGUF variant deletion requires an export directory",
+                )
+            deleted_count, deleted_bytes = _delete_gguf_variant_files(
+                target_path,
+                gguf_variant,
+            )
+            if deleted_count == 0:
+                raise HTTPException(
+                    status_code = 404,
+                    detail = f"Variant {gguf_variant} not found on disk",
+                )
+            try:
+                if not any(target_path.iterdir()):
+                    target_path.rmdir()
+                    _prune_empty_parents(target_path, allowed_root)
+            except OSError:
+                pass
+            logger.info(
+                "Deleted %s GGUF file(s) for exported model at %s variant %s (%0.1f MB freed)",
+                deleted_count,
+                target_path,
+                gguf_variant,
+                deleted_bytes / (1024 * 1024),
+            )
+            return {
+                "status": "deleted",
+                "path": str(target_path),
+                "gguf_variant": gguf_variant,
+            }
+
+        if target_path.is_symlink() or target_path.is_file():
+            target_path.unlink()
+        else:
+            shutil.rmtree(target_path)
+
+        if target_path.exists() or target_path.is_symlink():
+            raise HTTPException(
+                status_code = 500,
+                detail = "Deletion incomplete; some files could not be removed",
+            )
+
+        _prune_empty_parents(target_path, allowed_root)
+
+        logger.info("Deleted fine-tuned model at %s", target_path)
+        return {"status": "deleted", "path": str(target_path)}
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(
+            "Error deleting fine-tuned model %s: %s",
+            target_path,
+            e,
+            exc_info = True,
+        )
+        raise HTTPException(
+            status_code = 500,
+            detail = f"Failed to delete fine-tuned model: {str(e)}",
+        )
+
+
 @router.get("/loras/{lora_path:path}/base-model", response_model = LoRABaseModelResponse)
 async def get_lora_base_model(
     lora_path: str,
diff --git a/studio/backend/routes/training.py b/studio/backend/routes/training.py
index e625408bad..e5195bb337 100644
--- a/studio/backend/routes/training.py
+++ b/studio/backend/routes/training.py
@@ -25,6 +25,12 @@ if str(backend_path) not in sys.path:
 # Import backend functions
 try:
     from core.training import get_training_backend
+    from core.training.resume import (
+        can_resume_run,
+        get_resume_checkpoint_path,
+        normalize_resume_output_dir,
+    )
+    from storage.studio_db import get_resumable_run_by_output_dir
     from utils.models.model_config import load_model_defaults
     from utils.paths import resolve_dataset_path
 except ImportError:
@@ -33,6 +39,12 @@ except ImportError:
     if str(parent_backend) not in sys.path:
         sys.path.insert(0, str(parent_backend))
     from core.training import get_training_backend
+    from core.training.resume import (
+        can_resume_run,
+        get_resume_checkpoint_path,
+        normalize_resume_output_dir,
+    )
+    from storage.studio_db import get_resumable_run_by_output_dir
     from utils.models.model_config import load_model_defaults
     from utils.paths import resolve_dataset_path
 
@@ -152,6 +164,28 @@ async def start_training(
             request.local_eval_datasets = _validate_local_dataset_paths(
                 request.local_eval_datasets, "Local eval dataset"
             )
+        resume_output_dir: Optional[str] = None
+        if request.resume_from_checkpoint:
+            try:
+                resume_output_dir = normalize_resume_output_dir(
+                    request.resume_from_checkpoint
+                )
+            except ValueError as e:
+                raise HTTPException(status_code = 400, detail = str(e))
+
+            resume_run = get_resumable_run_by_output_dir(resume_output_dir)
+            if not resume_run or not can_resume_run(resume_run):
+                raise HTTPException(
+                    status_code = 400,
+                    detail = "Resume checkpoint must belong to a stopped run with saved trainer state.",
+                )
+            resume_checkpoint = get_resume_checkpoint_path(resume_output_dir)
+            if not resume_checkpoint:
+                raise HTTPException(
+                    status_code = 400,
+                    detail = "Resume checkpoint must include saved trainer state.",
+                )
+            request.resume_from_checkpoint = resume_checkpoint
 
         # Convert request to kwargs for backend
         training_kwargs = {
@@ -209,6 +243,8 @@ async def start_training(
             "wandb_project": request.wandb_project or "",
             "enable_tensorboard": request.enable_tensorboard,
             "tensorboard_dir": request.tensorboard_dir or "",
+            "output_dir": resume_output_dir,
+            "resume_from_checkpoint": request.resume_from_checkpoint,
             "trust_remote_code": request.trust_remote_code,
             "gpu_ids": request.gpu_ids,
         }
@@ -437,6 +473,9 @@ async def get_training_status(
                 "loss": getattr(progress, "loss", None),
                 "learning_rate": getattr(progress, "learning_rate", None),
             }
+            output_dir = getattr(backend, "_output_dir", None)
+            if output_dir:
+                details["output_dir"] = output_dir
 
         # Build metric history for chart recovery after SSE reconnection
         metric_history = None
diff --git a/studio/backend/routes/training_history.py b/studio/backend/routes/training_history.py
index 597c4424c0..6f34321959 100644
--- a/studio/backend/routes/training_history.py
+++ b/studio/backend/routes/training_history.py
@@ -11,6 +11,7 @@ from fastapi import APIRouter, Depends, HTTPException, Query
 from loggers import get_logger
 
 from auth.authentication import get_current_subject
+from core.training.resume import can_resume_run
 from models import (
     TrainingRunDeleteResponse,
     TrainingRunDetailResponse,
@@ -34,7 +35,10 @@ async def list_training_runs(
     """List training runs, newest first."""
     result = list_runs(limit = limit, offset = offset)
     return TrainingRunListResponse(
-        runs = [TrainingRunSummary(**r) for r in result["runs"]],
+        runs = [
+            TrainingRunSummary(**{**r, "can_resume": can_resume_run(r)})
+            for r in result["runs"]
+        ],
         total = result["total"],
     )
 
@@ -58,7 +62,12 @@ async def get_training_run_detail(
     metrics_data = get_run_metrics(run_id)
 
     return TrainingRunDetailResponse(
-        run = TrainingRunSummary(**{k: v for k, v in run.items() if k != "config_json"}),
+        run = TrainingRunSummary(
+            **{
+                **{k: v for k, v in run.items() if k != "config_json"},
+                "can_resume": can_resume_run(run),
+            }
+        ),
         config = config,
         metrics = TrainingRunMetrics(**metrics_data),
     )
diff --git a/studio/backend/run.py b/studio/backend/run.py
index 7590ef1067..c5b103ff70 100644
--- a/studio/backend/run.py
+++ b/studio/backend/run.py
@@ -244,7 +244,7 @@ _shutdown_event = None
 
 
 def run_server(
-    host: str = "0.0.0.0",
+    host: str = "127.0.0.1",
     port: int = 8888,
     frontend_path: Path = Path(__file__).resolve().parent.parent / "frontend" / "dist",
     silent: bool = False,
@@ -392,7 +392,11 @@ if __name__ == "__main__":
             pass
 
     parser = argparse.ArgumentParser(description = "Run Unsloth UI Backend server")
-    parser.add_argument("--host", default = "0.0.0.0", help = "Host to bind to")
+    parser.add_argument(
+        "--host",
+        default = "127.0.0.1",
+        help = "Host to bind to (default: 127.0.0.1; use 0.0.0.0 for network/cloud access)",
+    )
     parser.add_argument("--port", type = int, default = 8888, help = "Port to bind to")
     parser.add_argument(
         "--frontend",
diff --git a/studio/backend/state/tool_policy.py b/studio/backend/state/tool_policy.py
new file mode 100644
index 0000000000..9343a39806
--- /dev/null
+++ b/studio/backend/state/tool_policy.py
@@ -0,0 +1,33 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved.
+
+"""Process-level server-side tool policy.
+
+Set by `unsloth run` at startup; consulted by the inference route gates.
+
+  None  -> no CLI override (default). Per-request `enable_tools` is honored.
+  True  -> CLI forced tools on for every request.
+  False -> CLI forced tools off for every request.
+"""
+
+from typing import Optional
+
+_tool_policy: Optional[bool] = None
+
+
+def get_tool_policy() -> Optional[bool]:
+    return _tool_policy
+
+
+def set_tool_policy(value: Optional[bool]) -> None:
+    if value is not None and not isinstance(value, bool):
+        raise TypeError(
+            f"tool_policy must be Optional[bool], got {type(value).__name__}"
+        )
+    global _tool_policy
+    _tool_policy = value
+
+
+def reset_tool_policy() -> None:
+    global _tool_policy
+    _tool_policy = None
diff --git a/studio/backend/storage/studio_db.py b/studio/backend/storage/studio_db.py
index 89f75632ef..29e787c196 100644
--- a/studio/backend/storage/studio_db.py
+++ b/studio/backend/storage/studio_db.py
@@ -267,10 +267,23 @@ def list_runs(limit: int = 50, offset: int = 0) -> dict:
         total = conn.execute("SELECT COUNT(*) FROM training_runs").fetchone()[0]
         rows = conn.execute(
             """
-            SELECT id, status, model_name, dataset_name, started_at, ended_at,
-                   total_steps, final_step, final_loss, output_dir,
-                   duration_seconds, error_message, loss_sparkline
-            FROM training_runs
+            SELECT r.id, r.status, r.model_name, r.dataset_name, r.started_at,
+                   r.ended_at, r.total_steps, r.final_step, r.final_loss,
+                   r.output_dir, r.duration_seconds, r.error_message,
+                   r.loss_sparkline,
+                   CASE
+                       WHEN r.status = 'stopped'
+                            AND r.output_dir IS NOT NULL
+                            AND EXISTS (
+                                SELECT 1
+                                FROM training_runs newer
+                                WHERE newer.output_dir = r.output_dir
+                                  AND newer.status IN ('stopped', 'completed')
+                                  AND newer.started_at > r.started_at
+                            )
+                       THEN 1 ELSE 0
+                   END AS resumed_later
+            FROM training_runs r
             ORDER BY started_at DESC
             LIMIT ? OFFSET ?
             """,
@@ -297,7 +310,26 @@ def list_runs(limit: int = 50, offset: int = 0) -> dict:
 def get_run(id: str) -> Optional[dict]:
     conn = get_connection()
     try:
-        row = conn.execute("SELECT * FROM training_runs WHERE id = ?", (id,)).fetchone()
+        row = conn.execute(
+            """
+            SELECT r.*,
+                   CASE
+                       WHEN r.status = 'stopped'
+                            AND r.output_dir IS NOT NULL
+                            AND EXISTS (
+                                SELECT 1
+                                FROM training_runs newer
+                                WHERE newer.output_dir = r.output_dir
+                                  AND newer.status IN ('stopped', 'completed')
+                                  AND newer.started_at > r.started_at
+                            )
+                       THEN 1 ELSE 0
+                   END AS resumed_later
+            FROM training_runs r
+            WHERE r.id = ?
+            """,
+            (id,),
+        ).fetchone()
         if row is None:
             return None
         run = dict(row)
@@ -313,6 +345,45 @@ def get_run(id: str) -> Optional[dict]:
         conn.close()
 
 
+def get_resumable_run_by_output_dir(output_dir: str) -> Optional[dict]:
+    conn = get_connection()
+    try:
+        row = conn.execute(
+            """
+            SELECT r.*,
+                   0 AS resumed_later
+            FROM training_runs r
+            WHERE r.output_dir = ?
+              AND r.status = 'stopped'
+              AND NOT EXISTS (
+                  SELECT 1
+                  FROM training_runs newer
+                  WHERE newer.output_dir = r.output_dir
+                    AND newer.status IN ('stopped', 'completed')
+                    AND newer.started_at > r.started_at
+              )
+            ORDER BY r.started_at DESC
+            LIMIT 1
+            """,
+            (output_dir,),
+        ).fetchone()
+        if row is None:
+            return None
+        run = dict(row)
+        sparkline = run.get("loss_sparkline")
+        if sparkline:
+            try:
+                run["loss_sparkline"] = json.loads(sparkline)
+            except (json.JSONDecodeError, TypeError):
+                logger.debug(
+                    "Failed to parse loss_sparkline for output_dir %s", output_dir
+                )
+                run["loss_sparkline"] = None
+        return run
+    finally:
+        conn.close()
+
+
 def get_run_metrics(id: str) -> dict:
     """Return metric arrays for a run, using paired step arrays per metric."""
     conn = get_connection()
diff --git a/studio/backend/tests/test_data_recipe_github_progress.py b/studio/backend/tests/test_data_recipe_github_progress.py
new file mode 100644
index 0000000000..8e8c3995f4
--- /dev/null
+++ b/studio/backend/tests/test_data_recipe_github_progress.py
@@ -0,0 +1,91 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+from core.data_recipe.jobs.parse import apply_update, parse_log_message
+from core.data_recipe.jobs.types import Job
+from routes.data_recipe.validate import _GITHUB_VALIDATE_NOTE, validate
+from models.data_recipe import RecipePayload
+
+
+def test_github_page_log_updates_source_progress_without_cursor():
+    job = Job(job_id = "job-1")
+    job.source_progress_estimated_total = 200
+
+    update = parse_log_message(
+        "[unslothai/unsloth] issues page 2 (+15) cursor=abc123 remaining=2960"
+    )
+
+    assert update is not None
+    apply_update(job, update)
+
+    progress = job.source_progress
+    assert progress is not None
+    assert progress.source == "github"
+    assert progress.status == "fetching"
+    assert progress.repo == "unslothai/unsloth"
+    assert progress.resource == "issues"
+    assert progress.page == 2
+    assert progress.page_items == 15
+    assert progress.fetched_items == 15
+    assert progress.estimated_total == 200
+    assert progress.rate_remaining == 2960
+    assert progress.message is not None
+    assert "cursor" not in progress.message
+    assert "abc123" not in progress.message
+
+
+def test_github_rate_limit_log_updates_source_progress():
+    job = Job(job_id = "job-1")
+
+    update = parse_log_message("Rate limit hit. Sleeping 123s until reset.")
+
+    assert update is not None
+    apply_update(job, update)
+
+    progress = job.source_progress
+    assert progress is not None
+    assert progress.status == "rate_limited"
+    assert progress.retry_after_sec == 123
+    assert "resume automatically" in (progress.message or "")
+
+
+def test_github_real_sample_prs_and_trial_limit_are_parsed():
+    job = Job(job_id = "job-1")
+
+    for message in (
+        "[unslothai/unsloth] PRs page 4 (+25) cursor=abc123 remaining=4983",
+        "Trial limit reached for PRs (100)",
+    ):
+        update = parse_log_message(message)
+        assert update is not None
+        apply_update(job, update)
+
+    progress = job.source_progress
+    assert progress is not None
+    assert progress.repo == "unslothai/unsloth"
+    assert progress.resource == "pulls"
+    assert progress.page == 4
+    assert progress.fetched_items == 25
+    assert progress.rate_remaining == 4983
+    assert progress.message == "GitHub pulls trial limit reached (100)."
+
+
+def test_github_validate_skips_live_access_with_honest_note():
+    response = validate(
+        RecipePayload(
+            recipe = {
+                "seed_config": {
+                    "source": {
+                        "seed_type": "github_repo",
+                        "repos": ["unslothai/unsloth"],
+                        "item_types": ["issues"],
+                        "limit": 1,
+                    }
+                },
+                "columns": [{"column_type": "expression", "name": "x", "expr": "1"}],
+            }
+        )
+    )
+
+    assert response.valid is True
+    assert response.raw_detail == _GITHUB_VALIDATE_NOTE
diff --git a/studio/backend/tests/test_desktop_auth.py b/studio/backend/tests/test_desktop_auth.py
index c8cf1c7081..a5508c1c8b 100644
--- a/studio/backend/tests/test_desktop_auth.py
+++ b/studio/backend/tests/test_desktop_auth.py
@@ -246,7 +246,10 @@ def test_desktop_session_uses_real_admin_identity_for_api_keys():
     assert [row["name"] for row in rows] == ["desktop"]
 
 
-def test_local_recipe_token_preserves_desktop_marker(loaded_local_model):
+def test_local_recipe_token_authenticates_as_admin_for_desktop_user(loaded_local_model):
+    # _inject_local_providers mints an internal sk-unsloth-* API key (not a
+    # forwarded JWT). The unified API-key path validates as the real admin
+    # user regardless of whether the incoming session was desktop or web.
     from auth.authentication import create_access_token, get_current_subject
 
     seed_user(must_change_password = True)
@@ -260,13 +263,7 @@ def test_local_recipe_token_preserves_desktop_marker(loaded_local_model):
     jobs_route._inject_local_providers(recipe, local_recipe_request(incoming_token))
 
     local_token = recipe["model_providers"][0]["api_key"]
-    payload = jwt.decode(
-        local_token,
-        storage.get_jwt_secret(storage.DEFAULT_ADMIN_USERNAME),
-        algorithms = ["HS256"],
-    )
-    assert payload["sub"] == storage.DEFAULT_ADMIN_USERNAME
-    assert payload["desktop"] is True
+    assert local_token.startswith(storage.API_KEY_PREFIX)
     credentials = HTTPAuthorizationCredentials(
         scheme = "Bearer",
         credentials = local_token,
@@ -276,8 +273,10 @@ def test_local_recipe_token_preserves_desktop_marker(loaded_local_model):
     )
 
 
-def test_local_recipe_token_keeps_web_marker_absent(loaded_local_model):
-    from auth.authentication import create_access_token
+def test_local_recipe_token_authenticates_as_admin_for_web_user(loaded_local_model):
+    # Mirror of the desktop variant: API-key issuance is identical for web
+    # and desktop incoming tokens; auth via get_current_subject works the same.
+    from auth.authentication import create_access_token, get_current_subject
 
     seed_user(must_change_password = False)
     jobs_route = data_recipe_jobs_module()
@@ -287,13 +286,14 @@ def test_local_recipe_token_keeps_web_marker_absent(loaded_local_model):
     jobs_route._inject_local_providers(recipe, local_recipe_request(incoming_token))
 
     local_token = recipe["model_providers"][0]["api_key"]
-    payload = jwt.decode(
-        local_token,
-        storage.get_jwt_secret(storage.DEFAULT_ADMIN_USERNAME),
-        algorithms = ["HS256"],
+    assert local_token.startswith(storage.API_KEY_PREFIX)
+    credentials = HTTPAuthorizationCredentials(
+        scheme = "Bearer",
+        credentials = local_token,
+    )
+    assert (
+        asyncio.run(get_current_subject(credentials)) == storage.DEFAULT_ADMIN_USERNAME
     )
-    assert payload["sub"] == storage.DEFAULT_ADMIN_USERNAME
-    assert "desktop" not in payload
 
 
 def test_desktop_login_rejects_invalid_secret():
@@ -381,6 +381,7 @@ def test_health_response_reports_desktop_capability_fields(monkeypatch):
         datasets_router = APIRouter(),
         export_router = APIRouter(),
         inference_router = APIRouter(),
+        inference_studio_router = APIRouter(),
         models_router = APIRouter(),
         training_history_router = APIRouter(),
         training_router = APIRouter(),
diff --git a/studio/backend/tests/test_gpu_selection.py b/studio/backend/tests/test_gpu_selection.py
index c6f26037af..a1fe5653ef 100644
--- a/studio/backend/tests/test_gpu_selection.py
+++ b/studio/backend/tests/test_gpu_selection.py
@@ -746,7 +746,15 @@ class TestRouteErrors(unittest.TestCase):
         ):
             with self.assertRaises(HTTPException) as exc_info:
                 asyncio.run(
-                    inference_route.load_model(request, current_subject = "test-user")
+                    inference_route.load_model(
+                        request,
+                        SimpleNamespace(
+                            app = SimpleNamespace(
+                                state = SimpleNamespace(llama_parallel_slots = 1),
+                            ),
+                        ),
+                        current_subject = "test-user",
+                    )
                 )
 
         self.assertEqual(exc_info.exception.status_code, 400)
@@ -886,7 +894,15 @@ class TestRouteErrors(unittest.TestCase):
         ):
             with self.assertRaises(HTTPException) as exc_info:
                 asyncio.run(
-                    inference_route.load_model(request, current_subject = "test-user")
+                    inference_route.load_model(
+                        request,
+                        SimpleNamespace(
+                            app = SimpleNamespace(
+                                state = SimpleNamespace(llama_parallel_slots = 1),
+                            ),
+                        ),
+                        current_subject = "test-user",
+                    )
                 )
 
         self.assertEqual(exc_info.exception.status_code, 400)
@@ -942,7 +958,15 @@ class TestRouteErrors(unittest.TestCase):
         ):
             with self.assertRaises(HTTPException) as exc_info:
                 asyncio.run(
-                    inference_route.load_model(request, current_subject = "test-user")
+                    inference_route.load_model(
+                        request,
+                        SimpleNamespace(
+                            app = SimpleNamespace(
+                                state = SimpleNamespace(llama_parallel_slots = 1),
+                            ),
+                        ),
+                        current_subject = "test-user",
+                    )
                 )
 
         self.assertEqual(exc_info.exception.status_code, 400)
@@ -1025,6 +1049,182 @@ class TestMinGpuVram(unittest.TestCase):
 
 
 class TestPerGpuFitGuardAllCounts(unittest.TestCase):
+    def test_training_estimate_resolves_attention_without_raising(self):
+        with (
+            patch("utils.hardware.hardware.get_device", return_value = DeviceType.CUDA),
+            patch(
+                "utils.hardware.hardware.estimate_fp16_model_size_bytes",
+                return_value = (8 * (1024**3), "config"),
+            ),
+            patch(
+                "utils.hardware.hardware._resolve_model_identifier_for_gpu_estimate",
+                return_value = "unsloth/test",
+            ),
+            patch(
+                "utils.hardware.hardware._load_config_for_gpu_estimate",
+                return_value = SimpleNamespace(
+                    hidden_size = 4096,
+                    num_hidden_layers = 32,
+                    num_attention_heads = 32,
+                    num_key_value_heads = 8,
+                    intermediate_size = 14336,
+                    vocab_size = 128256,
+                    tie_word_embeddings = False,
+                ),
+            ),
+            patch(
+                "utils.hardware.hardware._determine_attention_impl_for_gpu_estimate",
+                return_value = "eager",
+            ),
+            patch("utils.hardware.hardware.get_visible_gpu_count", return_value = 1),
+        ):
+            _, metadata = estimate_required_model_memory_gb(
+                "unsloth/test",
+                training_type = "LoRA/QLoRA",
+                load_in_4bit = True,
+            )
+
+        self.assertEqual(metadata.get("estimation_mode"), "detailed")
+        self.assertEqual(metadata.get("attention_implementation"), "eager")
+
+    def test_training_estimate_falls_back_when_attention_resolution_fails(self):
+        with (
+            patch("utils.hardware.hardware.get_device", return_value = DeviceType.CUDA),
+            patch(
+                "utils.hardware.hardware.estimate_fp16_model_size_bytes",
+                return_value = (8 * (1024**3), "config"),
+            ),
+            patch(
+                "utils.hardware.hardware._resolve_model_identifier_for_gpu_estimate",
+                return_value = "unsloth/test",
+            ),
+            patch(
+                "utils.hardware.hardware._load_config_for_gpu_estimate",
+                return_value = SimpleNamespace(
+                    hidden_size = 4096,
+                    num_hidden_layers = 32,
+                    num_attention_heads = 32,
+                    num_key_value_heads = 8,
+                    intermediate_size = 14336,
+                    vocab_size = 128256,
+                    tie_word_embeddings = False,
+                ),
+            ),
+            patch(
+                "utils.hardware.hardware._determine_attention_impl_for_gpu_estimate",
+                side_effect = RuntimeError("attention unavailable"),
+            ),
+            patch("utils.hardware.hardware.get_visible_gpu_count", return_value = 1),
+        ):
+            _, metadata = estimate_required_model_memory_gb(
+                "unsloth/test",
+                training_type = "LoRA/QLoRA",
+                load_in_4bit = True,
+            )
+
+        self.assertEqual(metadata.get("estimation_mode"), "detailed")
+        self.assertEqual(
+            metadata.get("attention_implementation"),
+            "eager",
+        )
+
+    def test_attention_resolver_does_not_mutate_loaded_config(self):
+        from utils.hardware import hardware as hardware_module
+
+        config = SimpleNamespace(
+            hidden_size = 1024,
+            num_hidden_layers = 2,
+            num_attention_heads = 8,
+            num_key_value_heads = 8,
+            intermediate_size = 2048,
+            vocab_size = 1024,
+            tie_word_embeddings = True,
+        )
+
+        def _stub_resolver(model_class, cfg):
+            cfg._attn_implementation = "eager"
+            return "eager"
+
+        with patch(
+            "unsloth.models._utils.resolve_attention_implementation",
+            side_effect = _stub_resolver,
+        ):
+            hardware_module._determine_attention_impl_for_gpu_estimate(config)
+
+        self.assertFalse(hasattr(config, "_attn_implementation"))
+
+    def test_attention_resolver_handles_missing_model_mapping(self):
+        from utils.hardware import hardware as hardware_module
+
+        config = SimpleNamespace(
+            hidden_size = 1024,
+            num_hidden_layers = 2,
+            num_attention_heads = 8,
+            num_key_value_heads = 8,
+            intermediate_size = 2048,
+            vocab_size = 1024,
+            tie_word_embeddings = True,
+        )
+        captured = {}
+
+        def _stub_resolver(model_class, cfg):
+            captured["model_class"] = model_class
+            return "eager"
+
+        from transformers import AutoModel, AutoModelForCausalLM
+
+        with (
+            patch.object(AutoModelForCausalLM, "_model_mapping", new = None),
+            patch.object(AutoModel, "_model_mapping", new = None),
+            patch(
+                "unsloth.models._utils.resolve_attention_implementation",
+                side_effect = _stub_resolver,
+            ),
+        ):
+            result = hardware_module._determine_attention_impl_for_gpu_estimate(config)
+
+        self.assertEqual(result, "eager")
+        self.assertIsNone(captured["model_class"])
+
+    def test_attention_resolver_does_not_mutate_nested_text_config(self):
+        from utils.hardware import hardware as hardware_module
+
+        text_config = SimpleNamespace(
+            hidden_size = 1024,
+            num_hidden_layers = 2,
+            num_attention_heads = 8,
+            num_key_value_heads = 8,
+            intermediate_size = 2048,
+            vocab_size = 1024,
+            tie_word_embeddings = True,
+        )
+        config = SimpleNamespace(
+            hidden_size = 1024,
+            num_hidden_layers = 2,
+            num_attention_heads = 8,
+            num_key_value_heads = 8,
+            intermediate_size = 2048,
+            vocab_size = 1024,
+            tie_word_embeddings = True,
+            text_config = text_config,
+        )
+
+        def _stub_resolver(model_class, cfg):
+            cfg._attn_implementation = "eager"
+            inner = getattr(cfg, "text_config", None)
+            if inner is not None:
+                inner._attn_implementation = "eager"
+            return "eager"
+
+        with patch(
+            "unsloth.models._utils.resolve_attention_implementation",
+            side_effect = _stub_resolver,
+        ):
+            hardware_module._determine_attention_impl_for_gpu_estimate(config)
+
+        self.assertFalse(hasattr(config, "_attn_implementation"))
+        self.assertFalse(hasattr(text_config, "_attn_implementation"))
+
     def test_min_per_gpu_generated_for_all_visible_counts(self):
         with (
             patch("utils.hardware.hardware.get_device", return_value = DeviceType.CUDA),
@@ -1101,3 +1301,123 @@ class TestXpuRejection(_GpuCacheResetMixin, unittest.TestCase):
         with patch("utils.hardware.hardware.get_device", return_value = DeviceType.XPU):
             with self.assertRaisesRegex(ValueError, "only supported on CUDA"):
                 prepare_gpu_selection([0], model_name = "unsloth/test")
+
+
+class TestEstimateFp16ModelSizeBytesPrefersLocalWeights(unittest.TestCase):
+    def _run(
+        self,
+        model_path,
+        *,
+        config_bytes,
+        local_bytes,
+        safetensors_params = None,
+        config = object(),
+    ):
+        from utils.hardware import hardware as hardware_module
+
+        with (
+            patch.object(
+                hardware_module,
+                "_resolve_model_identifier_for_gpu_estimate",
+                return_value = model_path,
+            ),
+            patch.object(
+                hardware_module,
+                "_get_hf_safetensors_total_params",
+                return_value = safetensors_params,
+            ),
+            patch.object(
+                hardware_module,
+                "_load_config_for_gpu_estimate",
+                return_value = config,
+            ),
+            patch.object(
+                hardware_module,
+                "_estimate_fp16_model_size_bytes_from_config",
+                return_value = config_bytes,
+            ),
+            patch.object(
+                hardware_module,
+                "_get_local_weight_size_bytes",
+                return_value = local_bytes,
+            ),
+        ):
+            return hardware_module.estimate_fp16_model_size_bytes(model_path)
+
+    def test_local_weight_bytes_preferred_when_larger_than_config(self):
+        bytes_, src = self._run(
+            "/local/vlm",
+            config_bytes = 2 * (1 << 30),
+            local_bytes = 20 * (1 << 30),
+        )
+        self.assertEqual(bytes_, 20 * (1 << 30))
+        self.assertEqual(src, "weight_bytes")
+
+    def test_config_bytes_preferred_when_larger_than_local(self):
+        bytes_, src = self._run(
+            "/local/text-only",
+            config_bytes = 20 * (1 << 30),
+            local_bytes = 2 * (1 << 30),
+        )
+        self.assertEqual(bytes_, 20 * (1 << 30))
+        self.assertEqual(src, "config")
+
+    def test_config_bytes_returned_when_no_local_weights(self):
+        bytes_, src = self._run(
+            "/local/no-weights",
+            config_bytes = 5 * (1 << 30),
+            local_bytes = None,
+        )
+        self.assertEqual(bytes_, 5 * (1 << 30))
+        self.assertEqual(src, "config")
+
+    def test_local_bytes_returned_when_config_resolution_fails(self):
+        bytes_, src = self._run(
+            "/local/no-config",
+            config_bytes = None,
+            local_bytes = 7 * (1 << 30),
+            config = None,
+        )
+        self.assertEqual(bytes_, 7 * (1 << 30))
+        self.assertEqual(src, "weight_bytes")
+
+    def test_equal_local_and_config_keeps_config_label(self):
+        # why: tie-breaker is "local must be strictly larger" so an exact
+        # match keeps the config-derived path.
+        same = 8 * (1 << 30)
+        bytes_, src = self._run(
+            "/local/equal",
+            config_bytes = same,
+            local_bytes = same,
+        )
+        self.assertEqual(bytes_, same)
+        self.assertEqual(src, "config")
+
+    def test_remote_safetensors_path_unaffected_by_local_weights(self):
+        from utils.hardware import hardware as hardware_module
+
+        with (
+            patch.object(
+                hardware_module,
+                "_resolve_model_identifier_for_gpu_estimate",
+                return_value = "owner/repo",
+            ),
+            patch.object(
+                hardware_module,
+                "_get_hf_safetensors_total_params",
+                return_value = 1_000_000_000,
+            ),
+            patch.object(
+                hardware_module,
+                "_load_config_for_gpu_estimate",
+            ) as mock_load,
+            patch.object(
+                hardware_module,
+                "_get_local_weight_size_bytes",
+            ) as mock_local,
+        ):
+            bytes_, src = hardware_module.estimate_fp16_model_size_bytes("owner/repo")
+            self.assertEqual(bytes_, 2 * 1_000_000_000)
+            self.assertEqual(src, "safetensors")
+            mock_load.assert_not_called()
+            mock_local.assert_not_called()
diff --git a/studio/backend/tests/test_host_defaults.py b/studio/backend/tests/test_host_defaults.py
new file mode 100644
index 0000000000..8b81474e92
--- /dev/null
+++ b/studio/backend/tests/test_host_defaults.py
@@ -0,0 +1,98 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+"""Tests that Unsloth Studio defaults to 127.0.0.1 (loopback) not 0.0.0.0.
+
+Uses AST parsing to inspect source-level defaults without requiring the
+full studio venv (run.py has heavy dependencies like structlog/uvicorn).
+"""
+
+import ast
+from pathlib import Path
+
+_RUN_PY = Path(__file__).resolve().parent.parent / "run.py"
+
+
+def _parse_function_param_defaults(source: str, func_name: str) -> dict:
+    """Return {param_name: default_value} for a named function in *source*.
+
+    Only handles ast.Constant defaults (strings, ints, bools).
+    """
+    tree = ast.parse(source)
+    for node in ast.walk(tree):
+        if (
+            isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
+            and node.name == func_name
+        ):
+            result = {}
+            all_args = node.args.args
+            defaults = node.args.defaults
+            # Defaults are right-aligned against the args list
+            offset = len(all_args) - len(defaults)
+            for i, default in enumerate(defaults):
+                arg_name = all_args[offset + i].arg
+                if isinstance(default, ast.Constant):
+                    result[arg_name] = default.value
+            return result
+    return {}
+
+
+def _parse_argparse_add_argument_default(source: str, option_name: str):
+    """Return the 'default' kwarg value for add_argument(option_name, ...) in *source*.
+
+    Walks the entire module so the call can live in __main__ or in a helper
+    function — only handles ast.Constant defaults.
+    """
+    tree = ast.parse(source)
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.Call):
+            continue
+        func = node.func
+        if not (isinstance(func, ast.Attribute) and func.attr == "add_argument"):
+            continue
+        if not node.args:
+            continue
+        first_arg = node.args[0]
+        if not (isinstance(first_arg, ast.Constant) and first_arg.value == option_name):
+            continue
+        for kw in node.keywords:
+            if kw.arg == "default" and isinstance(kw.value, ast.Constant):
+                return kw.value.value
+    return None
+
+
+def test_run_server_default_host_is_loopback():
+    """run_server() parameter default for 'host' must be 127.0.0.1, not 0.0.0.0.
+
+    Binding to 0.0.0.0 by default exposes the service on all network
+    interfaces, contradicting the documented "privacy first / 100% local"
+    guarantee.  Loopback (127.0.0.1) is the least-permissive default;
+    users who need network access can pass -H 0.0.0.0 explicitly.
+    """
+    source = _RUN_PY.read_text()
+    defaults = _parse_function_param_defaults(source, "run_server")
+    assert (
+        "host" in defaults
+    ), "run_server() must have a 'host' parameter with a default"
+    host_default = defaults["host"]
+    assert host_default == "127.0.0.1", (
+        f"run_server() host default must be '127.0.0.1' (loopback) "
+        f"but got '{host_default}'. Binding to '{host_default}' by default "
+        f"exposes the service beyond localhost."
+    )
+
+
+def test_argparse_default_host_is_loopback():
+    """argparse --host add_argument default must be 127.0.0.1.
+
+    When run.py is invoked directly (python run.py), the argparse default
+    should match the function default so direct execution is equally safe.
+    """
+    source = _RUN_PY.read_text()
+    host_default = _parse_argparse_add_argument_default(source, "--host")
+    assert (
+        host_default is not None
+    ), "Could not find add_argument('--host', ...) in run.py"
+    assert (
+        host_default == "127.0.0.1"
+    ), f"run.py argparse --host default must be '127.0.0.1', got '{host_default}'"
diff --git a/studio/backend/tests/test_kv_cache_estimation.py b/studio/backend/tests/test_kv_cache_estimation.py
index 2640ded90d..29d87804ff 100644
--- a/studio/backend/tests/test_kv_cache_estimation.py
+++ b/studio/backend/tests/test_kv_cache_estimation.py
@@ -12,6 +12,7 @@ Cross-platform: Linux, macOS, Windows, WSL.
 """
 
 import io
+import json
 import struct
 import sys
 import types as _types
@@ -37,35 +38,43 @@ sys.modules.setdefault("loggers", _loggers_stub)
 _structlog_stub = _types.ModuleType("structlog")
 sys.modules.setdefault("structlog", _structlog_stub)
 
-# httpx
-_httpx_stub = _types.ModuleType("httpx")
-for _exc_name in (
-    "ConnectError",
-    "TimeoutException",
-    "ReadTimeout",
-    "ReadError",
-    "RemoteProtocolError",
-    "CloseError",
-):
-    setattr(_httpx_stub, _exc_name, type(_exc_name, (Exception,), {}))
+# httpx -- only stub when the real library isn't installed.  Stubbing
+# unconditionally would shadow ``HTTPError`` / ``Response`` etc. that
+# ``huggingface_hub.errors`` imports at module load time, which causes
+# the transformers introspection tier to silently return None inside
+# the test process.
+try:
+    import httpx as _httpx_real  # noqa: F401
+except ImportError:
+    _httpx_stub = _types.ModuleType("httpx")
+    for _exc_name in (
+        "ConnectError",
+        "TimeoutException",
+        "ReadTimeout",
+        "ReadError",
+        "RemoteProtocolError",
+        "CloseError",
+        "HTTPError",
+        "RequestError",
+    ):
+        setattr(_httpx_stub, _exc_name, type(_exc_name, (Exception,), {}))
 
+    class _FakeTimeout:
+        def __init__(self, *a, **kw):
+            pass
 
-class _FakeTimeout:
-    def __init__(self, *a, **kw):
-        pass
-
-
-_httpx_stub.Timeout = _FakeTimeout
-_httpx_stub.Client = type(
-    "Client",
-    (),
-    {
-        "__init__": lambda self, **kw: None,
-        "__enter__": lambda self: self,
-        "__exit__": lambda self, *a: None,
-    },
-)
-sys.modules.setdefault("httpx", _httpx_stub)
+    _httpx_stub.Timeout = _FakeTimeout
+    _httpx_stub.Response = type("Response", (), {})
+    _httpx_stub.Client = type(
+        "Client",
+        (),
+        {
+            "__init__": lambda self, **kw: None,
+            "__enter__": lambda self: self,
+            "__exit__": lambda self, *a: None,
+        },
+    )
+    sys.modules["httpx"] = _httpx_stub
 
 from core.inference.llama_cpp import LlamaCppBackend
 
@@ -77,8 +86,7 @@ from core.inference.llama_cpp import LlamaCppBackend
 def _make_gguf_bytes(arch: str, kv_pairs: dict) -> bytes:
     """Build a minimal GGUF v3 binary blob with the given KV metadata.
 
-    Only supports UINT32 (type 4), UINT64 (type 10), and STRING (type 8)
-    values, which is all the metadata parser reads.
+    Supports the scalar and simple array metadata used by the parser.
     """
     buf = io.BytesIO()
     # Header: magic, version, tensor_count, kv_count
@@ -96,6 +104,17 @@ def _make_gguf_bytes(arch: str, kv_pairs: dict) -> bytes:
             val_bytes = val.encode("utf-8")
             buf.write(struct.pack("<Q", len(val_bytes)))
             buf.write(val_bytes)
+        elif isinstance(val, list):
+            buf.write(struct.pack("<I", 9))  # ARRAY
+            is_bool_array = all(isinstance(x, bool) for x in val)
+            buf.write(struct.pack("<I", 7 if is_bool_array else 5))
+            buf.write(struct.pack("<Q", len(val)))
+            if is_bool_array:
+                for item in val:
+                    buf.write(struct.pack("<?", item))
+            else:
+                for item in val:
+                    buf.write(struct.pack("<i", item))
         elif isinstance(val, int):
             if val <= 0xFFFFFFFF:
                 buf.write(struct.pack("<I", 4))  # UINT32
@@ -108,9 +127,18 @@ def _make_gguf_bytes(arch: str, kv_pairs: dict) -> bytes:
     return buf.getvalue()
 
 
-def _backend_from_gguf(arch: str, fields: dict) -> LlamaCppBackend:
-    """Create a LlamaCppBackend with parsed GGUF metadata from given fields."""
+def _backend_from_gguf(
+    arch: str, fields: dict, general: dict | None = None
+) -> LlamaCppBackend:
+    """Create a LlamaCppBackend with parsed GGUF metadata from given fields.
+
+    `general` lets a test inject extra `general.*` metadata (used to
+    verify the dynamic SWA resolver picks up source-repo hints from
+    GGUFs that ship them).
+    """
     kv = {"general.architecture": arch}
+    for k, v in (general or {}).items():
+        kv[k] = v
     for k, v in fields.items():
         kv[f"{arch}.{k}"] = v
     import tempfile, os
@@ -133,7 +161,7 @@ def _backend_from_gguf(arch: str, fields: dict) -> LlamaCppBackend:
 
 
 class TestGGUFParserNewFields:
-    """Verify that the 8 new architecture-aware fields are correctly parsed."""
+    """Verify that architecture-aware fields are correctly parsed."""
 
     @pytest.mark.parametrize(
         "field,gguf_key,value",
@@ -158,15 +186,189 @@ class TestGGUFParserNewFields:
             "_kv_key_length",
             "_kv_value_length",
             "_sliding_window",
+            "_sliding_window_pattern",
             "_full_attention_interval",
             "_kv_lora_rank",
             "_key_length_mla",
+            "_kv_key_length_swa",
+            "_kv_value_length_swa",
             "_ssm_inner_size",
             "_ssm_state_size",
         ]:
             assert getattr(b, attr) is None
 
-    def test_all_13_fields_parsed_together(self):
+    def test_array_fields_parsed(self):
+        b = _backend_from_gguf(
+            "gemma4",
+            {
+                "block_count": 6,
+                "attention.head_count_kv": [8, 8, 8, 8, 8, 2],
+                "attention.sliding_window_pattern": [
+                    True,
+                    True,
+                    True,
+                    True,
+                    True,
+                    False,
+                ],
+            },
+        )
+        # Per-layer KV head count is preserved exactly...
+        assert b._n_kv_heads_by_layer == [8, 8, 8, 8, 8, 2]
+        # ...and mirrored into the scalar field as a conservative max so
+        # non-SWA estimator paths and any caller using
+        # `n_kv = self._n_kv_heads or ...` get a safe upper bound.
+        assert b._n_kv_heads == 8
+        assert b._sliding_window_pattern == [True, True, True, True, True, False]
+
+
+class TestArchSwaPatternDefaults:
+    """Bootstrap arch table fires when GGUF reports `sliding_window` but
+    no per-layer pattern (true for every Gemma 2/3/3n/gpt-oss GGUF today)."""
+
+    @pytest.mark.parametrize(
+        "arch,n_layers,expected_period",
+        [
+            ("gemma2", 26, 2),
+            ("gemma3", 18, 6),
+            ("gemma3n", 35, 5),
+            ("gpt_oss", 24, 2),
+            ("cohere2", 32, 4),
+        ],
+    )
+    def test_arch_default_pattern_applied(self, arch, n_layers, expected_period):
+        b = _backend_from_gguf(
+            arch,
+            {
+                "block_count": n_layers,
+                "attention.head_count": 4,
+                "attention.head_count_kv": 1,
+                "attention.key_length": 256,
+                "attention.value_length": 256,
+                "attention.sliding_window": 512,
+            },
+        )
+        expected_pattern = [(i + 1) % expected_period != 0 for i in range(n_layers)]
+        assert (
+            b._sliding_window_pattern == expected_pattern
+        ), f"{arch} should expand to period={expected_period}"
+
+    def test_unknown_arch_no_default(self):
+        b = _backend_from_gguf(
+            "totallymadeupv7",
+            {
+                "block_count": 24,
+                "attention.head_count": 4,
+                "attention.head_count_kv": 1,
+                "attention.key_length": 128,
+                "attention.value_length": 128,
+                "attention.sliding_window": 1024,
+            },
+        )
+        assert b._sliding_window_pattern is None
+
+    def test_explicit_pattern_overrides_arch_default(self):
+        # Period=6 is the gemma3 default; the explicit array must win.
+        b = _backend_from_gguf(
+            "gemma3",
+            {
+                "block_count": 6,
+                "attention.head_count": 4,
+                "attention.head_count_kv": 1,
+                "attention.key_length": 256,
+                "attention.value_length": 256,
+                "attention.sliding_window": 512,
+                "attention.sliding_window_pattern": [
+                    True,
+                    False,
+                    True,
+                    False,
+                    True,
+                    False,
+                ],
+            },
+        )
+        assert b._sliding_window_pattern == [True, False, True, False, True, False]
+
+    def test_no_sliding_window_no_pattern(self):
+        b = _backend_from_gguf(
+            "gemma3",
+            {
+                "block_count": 18,
+                "attention.head_count": 4,
+                "attention.head_count_kv": 1,
+                "attention.key_length": 256,
+                "attention.value_length": 256,
+                # no sliding_window key
+            },
+        )
+        assert b._sliding_window_pattern is None
+
+    @pytest.mark.parametrize(
+        "arch", ["llama", "qwen2", "qwen3", "mistral", "mistral3", "glm4", "llama4"]
+    )
+    def test_non_swa_arch_uses_full_attention_path(self, arch):
+        # Pure-GQA arches: GGUF has no sliding_window, no synthetic
+        # pattern, estimator hits Path 4.
+        b = _backend_from_gguf(
+            arch,
+            {
+                "block_count": 32,
+                "attention.head_count": 32,
+                "attention.head_count_kv": 8,
+                "attention.key_length": 128,
+                "attention.value_length": 128,
+                "embedding_length": 4096,
+            },
+        )
+        assert b._sliding_window_pattern is None
+        assert b._sliding_window is None
+        kv = b._estimate_kv_cache_bytes(8192, "f16")
+        gqa_expected = 32 * 8192 * 8 * (128 + 128) * 2
+        assert kv == gqa_expected
+
+    def test_arch_default_reduces_kv_estimate_vs_legacy(self):
+        common = {
+            "block_count": 62,
+            "attention.head_count": 32,
+            "attention.head_count_kv": 16,
+            "attention.key_length": 128,
+            "attention.value_length": 128,
+            "attention.sliding_window": 1024,
+            "embedding_length": 5376,
+        }
+        with_default = _backend_from_gguf("gemma3", common)
+        # Arch not in the table -> legacy 1/4 path.
+        without_default = _backend_from_gguf("totallymadeupv7", common)
+
+        kv_default = with_default._estimate_kv_cache_bytes(131072, "f16")
+        kv_legacy = without_default._estimate_kv_cache_bytes(131072, "f16")
+        assert kv_default > 0
+        assert kv_legacy > 0
+        assert kv_default < kv_legacy, (
+            f"arch fallback should under-shoot legacy estimate: "
+            f"{kv_default} >= {kv_legacy}"
+        )
+
+    def test_scalar_sliding_window_pattern_expanded(self):
+        block_count = 8
+        b = _backend_from_gguf(
+            "gemma3",
+            {
+                "attention.sliding_window_pattern": 4,
+                "block_count": block_count,
+                "attention.head_count_kv": 4,
+                "attention.key_length": 256,
+                "attention.value_length": 256,
+                "attention.sliding_window": 1024,
+            },
+        )
+        expected = [(i + 1) % 4 != 0 for i in range(block_count)]
+        assert isinstance(b._sliding_window_pattern, list)
+        assert b._sliding_window_pattern == expected
+        assert b._estimate_kv_cache_bytes(4096, "f16") > 0
+
+    def test_all_fields_parsed_together(self):
         fields = {
             "context_length": 131072,
             "block_count": 62,
@@ -176,9 +378,12 @@ class TestGGUFParserNewFields:
             "attention.key_length": 128,
             "attention.value_length": 128,
             "attention.sliding_window": 1024,
+            "attention.sliding_window_pattern": [True, False],
             "full_attention_interval": 6,
             "attention.kv_lora_rank": 512,
             "attention.key_length_mla": 256,
+            "attention.key_length_swa": 64,
+            "attention.value_length_swa": 64,
             "ssm.inner_size": 4096,
             "ssm.state_size": 128,
         }
@@ -191,13 +396,294 @@ class TestGGUFParserNewFields:
         assert b._kv_key_length == 128
         assert b._kv_value_length == 128
         assert b._sliding_window == 1024
+        assert b._sliding_window_pattern == [True, False]
         assert b._full_attention_interval == 6
         assert b._kv_lora_rank == 512
         assert b._key_length_mla == 256
+        assert b._kv_key_length_swa == 64
+        assert b._kv_value_length_swa == 64
         assert b._ssm_inner_size == 4096
         assert b._ssm_state_size == 128
 
 
+_SWA_FIELDS = {
+    "block_count": 12,
+    "attention.head_count": 4,
+    "attention.head_count_kv": 1,
+    "attention.key_length": 256,
+    "attention.value_length": 256,
+    "attention.sliding_window": 512,
+}
+
+
+class TestDynamicSwaResolver:
+    """4-tier resolver: GGUF metadata, on-disk cache, bootstrap, HF fetch."""
+
+    def _isolate_cache(self, monkeypatch, tmp_path):
+        from core.inference import llama_cpp as lc
+
+        monkeypatch.setenv("UNSLOTH_STUDIO_HOME", str(tmp_path))
+        monkeypatch.setattr(lc, "_SWA_CACHE", None)
+        return tmp_path
+
+    def test_period_from_layer_types_finds_smallest_period(self):
+        from core.inference.llama_cpp import _period_from_layer_types
+
+        # gemma3 (1 global per 6), gpt-oss (alternating), gemma3n (1 per 5).
+        assert (
+            _period_from_layer_types(
+                (["sliding_attention"] * 5 + ["full_attention"]) * 4
+            )
+            == 6
+        )
+        assert (
+            _period_from_layer_types(["sliding_attention", "full_attention"] * 12) == 2
+        )
+        assert (
+            _period_from_layer_types(
+                (["sliding_attention"] * 4 + ["full_attention"]) * 7
+            )
+            == 5
+        )
+
+    def test_period_from_layer_types_returns_none_for_aperiodic(self):
+        from core.inference.llama_cpp import _period_from_layer_types
+
+        lt = [
+            "sliding_attention",
+            "full_attention",
+            "sliding_attention",
+            "sliding_attention",
+            "full_attention",
+            "sliding_attention",
+            "sliding_attention",
+            "sliding_attention",
+        ]
+        assert _period_from_layer_types(lt) is None
+
+    def test_hf_repo_from_url(self):
+        from core.inference.llama_cpp import _hf_repo_from_url
+
+        assert (
+            _hf_repo_from_url("https://huggingface.co/google/gemma-3-1b-it")
+            == "google/gemma-3-1b-it"
+        )
+        assert (
+            _hf_repo_from_url(
+                "https://huggingface.co/google/gemma-3-1b-it/blob/main/config.json"
+            )
+            == "google/gemma-3-1b-it"
+        )
+        for bad in [
+            "https://huggingface.co/google",
+            "https://example.com/foo/bar",
+            None,
+            "",
+        ]:
+            assert _hf_repo_from_url(bad) is None
+
+    def test_bootstrap_tier_used_when_no_cache(self, monkeypatch, tmp_path):
+        self._isolate_cache(monkeypatch, tmp_path)
+        from core.inference import llama_cpp as lc
+
+        def boom(*a, **kw):
+            raise AssertionError("HF fetch must not run when bootstrap covers the arch")
+
+        monkeypatch.setattr(lc, "_fetch_swa_entry_from_hf", boom)
+        b = _backend_from_gguf("gemma3", dict(_SWA_FIELDS, block_count = 18))
+        assert b._sliding_window_pattern == [(i + 1) % 6 != 0 for i in range(18)]
+
+    def test_disk_cache_takes_precedence_over_bootstrap(self, monkeypatch, tmp_path):
+        self._isolate_cache(monkeypatch, tmp_path)
+        # Override bootstrap=6 with a cached period=3.
+        with open(tmp_path / "swa_cache.json", "w") as f:
+            json.dump({"gemma3": 3}, f)
+        b = _backend_from_gguf("gemma3", dict(_SWA_FIELDS, block_count = 18))
+        assert b._sliding_window_pattern == [(i + 1) % 3 != 0 for i in range(18)]
+
+    def test_disk_cache_supports_array_entries(self, monkeypatch, tmp_path):
+        # Aperiodic mask gets tiled across n_layers.
+        self._isolate_cache(monkeypatch, tmp_path)
+        mask = [True, False, True, True, False, True, False, False]
+        with open(tmp_path / "swa_cache.json", "w") as f:
+            json.dump({"customarch": mask}, f)
+        b = _backend_from_gguf("customarch", dict(_SWA_FIELDS, block_count = 16))
+        assert b._sliding_window_pattern == [bool(mask[i % 8]) for i in range(16)]
+
+    def test_hf_fetch_populates_cache(self, monkeypatch, tmp_path):
+        self._isolate_cache(monkeypatch, tmp_path)
+        from core.inference import llama_cpp as lc
+
+        calls = []
+
+        def fake_fetch(repo_id):
+            calls.append(repo_id)
+            return 4 if repo_id == "vendor/newmodel-1b-instruct" else None
+
+        monkeypatch.setattr(lc, "_fetch_swa_entry_from_hf", fake_fetch)
+        b = _backend_from_gguf(
+            "newmodel",
+            _SWA_FIELDS,
+            general = {
+                "general.source.huggingface.repository": "vendor/newmodel-1b-instruct"
+            },
+        )
+        assert b._sliding_window_pattern == [(i + 1) % 4 != 0 for i in range(12)]
+        assert calls == ["vendor/newmodel-1b-instruct"]
+        with open(tmp_path / "swa_cache.json") as f:
+            assert json.load(f) == {"newmodel": 4}
+
+    def test_hf_fetch_falls_back_to_other_candidates(self, monkeypatch, tmp_path):
+        self._isolate_cache(monkeypatch, tmp_path)
+        from core.inference import llama_cpp as lc
+
+        monkeypatch.setattr(
+            lc,
+            "_fetch_swa_entry_from_hf",
+            lambda r: 6 if r == "vendor/newmodel-base" else None,
+        )
+        b = _backend_from_gguf(
+            "newmodel",
+            _SWA_FIELDS,
+            general = {
+                "general.base_model.0.repo_url": "https://huggingface.co/vendor/newmodel-base"
+            },
+        )
+        assert b._sliding_window_pattern == [(i + 1) % 6 != 0 for i in range(12)]
+
+    def test_offline_env_skips_network(self, monkeypatch, tmp_path):
+        self._isolate_cache(monkeypatch, tmp_path)
+        monkeypatch.setenv("UNSLOTH_STUDIO_OFFLINE", "1")
+        from core.inference import llama_cpp as lc
+
+        def boom(*a, **kw):
+            raise AssertionError("HF fetch must not run when offline=1")
+
+        monkeypatch.setattr(lc, "_fetch_swa_entry_from_hf", boom)
+        b = _backend_from_gguf(
+            "newmodel",
+            _SWA_FIELDS,
+            general = {"general.source.huggingface.repository": "vendor/newmodel"},
+        )
+        assert b._sliding_window_pattern is None
+
+    def test_hf_fetch_failure_falls_through_silently(self, monkeypatch, tmp_path):
+        self._isolate_cache(monkeypatch, tmp_path)
+        from core.inference import llama_cpp as lc
+
+        monkeypatch.setattr(lc, "_fetch_swa_entry_from_hf", lambda repo_id: None)
+        # Force the failure into the Tier 3 path; bypass Tier 2.5.
+        monkeypatch.setattr(
+            lc, "_resolve_swa_entry_from_transformers", lambda arch: None
+        )
+        b = _backend_from_gguf(
+            "newmodel",
+            _SWA_FIELDS,
+            general = {"general.source.huggingface.repository": "vendor/does-not-exist"},
+        )
+        assert b._sliding_window_pattern is None
+        assert not (tmp_path / "swa_cache.json").exists()
+
+
+class TestTransformersIntrospection:
+    """Tier 2.5: default-init the matching Config; on failure, parse via inspect."""
+
+    def _isolate_cache(self, monkeypatch, tmp_path):
+        from core.inference import llama_cpp as lc
+
+        monkeypatch.setenv("UNSLOTH_STUDIO_HOME", str(tmp_path))
+        monkeypatch.setattr(lc, "_SWA_CACHE", None)
+        return tmp_path
+
+    def test_arch_aliases_normalises_hyphen_underscore(self):
+        from core.inference.llama_cpp import _arch_aliases
+
+        aliases = _arch_aliases("falcon-h1")
+        assert aliases[0] == "falcon-h1" and "falcon_h1" in aliases
+        assert _arch_aliases("gemma3") == ("gemma3",)
+        assert _arch_aliases("") == ()
+
+    def test_resolves_real_transformers_arches(self):
+        from core.inference.llama_cpp import _resolve_swa_entry_from_transformers
+
+        assert _resolve_swa_entry_from_transformers("gemma3") == 6
+        assert _resolve_swa_entry_from_transformers("gemma2") == 2
+        assert _resolve_swa_entry_from_transformers("cohere2") == 4
+
+    def test_falls_back_to_inspect_when_default_init_raises(self, monkeypatch):
+        from core.inference import llama_cpp as lc
+
+        class _FakeBrokenConfig:
+            """Class with sliding_window_pattern: int = 7 in its docstring."""
+
+            def __init__(self, required_arg):
+                raise TypeError("requires an argument")
+
+        class _FakeLazyMapping(dict):
+            def __getitem__(self, k):
+                return (
+                    _FakeBrokenConfig if k == "brokenarch" else super().__getitem__(k)
+                )
+
+        import sys, types as _types
+
+        fake_auto = _types.ModuleType("transformers.models.auto.configuration_auto")
+        fake_auto.CONFIG_MAPPING_NAMES = {"brokenarch": "FakeBroken"}
+        fake_auto.CONFIG_MAPPING = _FakeLazyMapping({"brokenarch": "FakeBroken"})
+        monkeypatch.setitem(
+            sys.modules, "transformers.models.auto.configuration_auto", fake_auto
+        )
+        assert lc._resolve_swa_entry_from_transformers("brokenarch") == 7
+
+    def test_returns_none_when_transformers_unavailable(self, monkeypatch):
+        from core.inference import llama_cpp as lc
+        import sys
+
+        orig_import = (
+            __builtins__["__import__"]
+            if isinstance(__builtins__, dict)
+            else __builtins__.__import__
+        )
+
+        def fake_import(name, *a, **kw):
+            if name.startswith("transformers"):
+                raise ImportError("transformers not installed")
+            return orig_import(name, *a, **kw)
+
+        monkeypatch.setattr("builtins.__import__", fake_import)
+        for k in list(sys.modules):
+            if k.startswith("transformers"):
+                monkeypatch.delitem(sys.modules, k, raising = False)
+        assert lc._resolve_swa_entry_from_transformers("gemma3") is None
+
+    def test_returns_none_for_arch_unknown_to_transformers(self):
+        from core.inference.llama_cpp import _resolve_swa_entry_from_transformers
+
+        assert _resolve_swa_entry_from_transformers("totally-fake-arch-xyz") is None
+
+    def test_full_resolver_uses_transformers_before_hf_fetch(
+        self, monkeypatch, tmp_path
+    ):
+        # With bootstrap empty, Tier 2.5 must answer before Tier 3 fires.
+        self._isolate_cache(monkeypatch, tmp_path)
+        from core.inference import llama_cpp as lc
+
+        monkeypatch.setattr(lc, "_BOOTSTRAP_SWA_DEFAULTS", {})
+
+        def boom(repo_id):
+            raise AssertionError("Tier 3 must not run when Tier 2.5 has the answer")
+
+        monkeypatch.setattr(lc, "_fetch_swa_entry_from_hf", boom)
+        b = _backend_from_gguf(
+            "gemma3",
+            dict(_SWA_FIELDS, block_count = 18),
+            general = {"general.source.huggingface.repository": "google/gemma-3-1b-it"},
+        )
+        assert b._sliding_window_pattern == [(i + 1) % 6 != 0 for i in range(18)]
+        with open(tmp_path / "swa_cache.json") as f:
+            assert json.load(f) == {"gemma3": 6}
+
+
 class TestGGUFParserReset:
     """Verify that fields are properly reset between parses."""
 
@@ -209,11 +695,19 @@ class TestGGUFParserReset:
                 "block_count": 32,
                 "attention.key_length": 128,
                 "attention.kv_lora_rank": 512,
+                "attention.head_count_kv": [8, 2],
+                "attention.sliding_window_pattern": [True, False],
+                "attention.key_length_swa": 64,
+                "attention.value_length_swa": 64,
                 "ssm.inner_size": 4096,
             },
         )
         assert b._kv_key_length == 128
         assert b._kv_lora_rank == 512
+        assert b._n_kv_heads_by_layer == [8, 2]
+        assert b._sliding_window_pattern == [True, False]
+        assert b._kv_key_length_swa == 64
+        assert b._kv_value_length_swa == 64
         assert b._ssm_inner_size == 4096
 
         # Second parse without those fields -- they should be None
@@ -230,6 +724,10 @@ class TestGGUFParserReset:
             os.unlink(path)
         assert b._kv_key_length is None
         assert b._kv_lora_rank is None
+        assert b._n_kv_heads_by_layer is None
+        assert b._sliding_window_pattern is None
+        assert b._kv_key_length_swa is None
+        assert b._kv_value_length_swa is None
         assert b._ssm_inner_size is None
         assert b._n_layers == 64
 
@@ -455,7 +953,9 @@ class TestSlidingWindowEstimation:
         n_global = max(1, 62 // 4)  # 15
         n_swa = 62 - n_global  # 47
         kv_per = 16 * (128 + 128) * 2
-        expected = int(n_global * 131072 * kv_per + n_swa * min(131072, 1024) * kv_per)
+        # SWA cache is double-buffered: 2 * sliding_window cells, capped at n_ctx.
+        swa_cells = min(131072, 2 * 1024)
+        expected = int(n_global * 131072 * kv_per + n_swa * swa_cells * kv_per)
         assert b._estimate_kv_cache_bytes(131072, "f16") == expected
 
     def test_gpt_oss(self):
@@ -472,27 +972,52 @@ class TestSlidingWindowEstimation:
         n_global = max(1, 24 // 4)  # 6
         n_swa = 24 - n_global  # 18
         kv_per = 8 * (64 + 64) * 2
-        expected = int(n_global * 131072 * kv_per + n_swa * min(131072, 128) * kv_per)
+        swa_cells = min(131072, 2 * 128)
+        expected = int(n_global * 131072 * kv_per + n_swa * swa_cells * kv_per)
         assert b._estimate_kv_cache_bytes(131072, "f16") == expected
 
+    def test_gemma4_per_layer_swa_metadata(self):
+        b = self._swa_backend(
+            _n_layers = 30,
+            _n_kv_heads = None,
+            _n_kv_heads_by_layer = [8, 8, 8, 8, 8, 2] * 5,
+            _n_heads = 16,
+            _embedding_length = 2816,
+            _kv_key_length = 512,
+            _kv_value_length = 512,
+            _sliding_window = 1024,
+            _sliding_window_pattern = [True, True, True, True, True, False] * 5,
+            _kv_key_length_swa = 256,
+            _kv_value_length_swa = 256,
+        )
+
+        full_layers = 5
+        sliding_layers = 25
+
+        def expected(ctx):
+            full = full_layers * ctx * 2 * (512 + 512) * 2
+            sliding = sliding_layers * min(ctx, 2 * 1024) * 8 * (256 + 256) * 2
+            return int(full + sliding)
+
+        for ctx in (4096, 46500, 262144):
+            assert b._estimate_kv_cache_bytes(ctx, "f16") == expected(ctx)
+
     def test_ctx_smaller_than_window(self):
-        """When context < sliding_window, SWA layers use full context anyway."""
+        """When context < 2 * sliding_window, SWA cache caps at ctx."""
         b = self._swa_backend(_sliding_window = 8192)
         n_global = max(1, 62 // 4)  # 15
         n_swa = 62 - n_global  # 47
         kv_per = 16 * (128 + 128) * 2
         ctx = 4096
-        expected = int(n_global * ctx * kv_per + n_swa * min(ctx, 8192) * kv_per)
-        # min(4096, 8192) = 4096, so both pools use full ctx
+        expected = int(n_global * ctx * kv_per + n_swa * min(ctx, 2 * 8192) * kv_per)
         assert b._estimate_kv_cache_bytes(ctx, "f16") == expected
 
     def test_odd_layer_count(self):
-        """Odd layer count: n_global = max(1, n//4), n_swa = n - n_global."""
         b = self._swa_backend(_n_layers = 63)
         n_global = max(1, 63 // 4)  # 15
         n_swa = 63 - n_global  # 48
         kv_per = 16 * (128 + 128) * 2
-        expected = int(n_global * 1000 * kv_per + n_swa * min(1000, 1024) * kv_per)
+        expected = int(n_global * 1000 * kv_per + n_swa * min(1000, 2 * 1024) * kv_per)
         assert b._estimate_kv_cache_bytes(1000, "f16") == expected
 
 
@@ -785,6 +1310,686 @@ class TestEdgeCases:
         assert result == expected
 
 
+# ---------------------------------------------------------------------------
+# J2. Server-flag knobs (--swa-full, --kv-unified/--parallel,
+#     --ctx-checkpoints, --kv-offload)
+# ---------------------------------------------------------------------------
+
+
+class TestServerFlags:
+    """Estimator should mirror llama-server CLI flags that change KV size."""
+
+    def _swa_backend(self, **overrides):
+        defaults = {
+            "_n_layers": 26,
+            "_n_kv_heads": 4,
+            "_n_heads": 8,
+            "_embedding_length": 1152,
+            "_kv_key_length": 256,
+            "_kv_value_length": 256,
+            "_sliding_window": 512,
+            "_sliding_window_pattern": [True, True, True, True, True, False] * 4
+            + [True, True],
+        }
+        defaults.update(overrides)
+        b = LlamaCppBackend()
+        for k, v in defaults.items():
+            setattr(b, k, v)
+        return b
+
+    def _gqa_backend(self, **overrides):
+        defaults = {
+            "_n_layers": 28,
+            "_n_kv_heads": 8,
+            "_n_heads": 16,
+            "_embedding_length": 1024,
+            "_kv_key_length": 128,
+            "_kv_value_length": 128,
+        }
+        defaults.update(overrides)
+        b = LlamaCppBackend()
+        for k, v in defaults.items():
+            setattr(b, k, v)
+        return b
+
+    # ── --swa-full ──────────────────────────────────────────────────
+
+    def test_swa_full_collapses_pattern_path_to_full_ctx(self):
+        b = self._swa_backend()
+        ctx = 32_768
+        flagged = b._estimate_kv_cache_bytes(ctx, "f16", swa_full = True)
+        # With swa_full, every layer caches n_ctx -- equals path 4 sizing.
+        kv_per_token = 4 * (256 + 256) * 2  # n_kv_heads * (k+v) * f16
+        expected = 26 * ctx * kv_per_token
+        assert flagged == expected
+        assert flagged > b._estimate_kv_cache_bytes(ctx, "f16")
+
+    def test_swa_full_collapses_legacy_path_to_full_ctx(self):
+        # No per-layer pattern -> 1/4-global heuristic; swa_full overrides.
+        b = self._swa_backend(_sliding_window_pattern = None)
+        ctx = 16_384
+        flagged = b._estimate_kv_cache_bytes(ctx, "f16", swa_full = True)
+        n_global = max(1, 26 // 4)
+        n_swa = 26 - n_global
+        kv_per = 4 * (256 + 256) * 2
+        # swa_cells == n_ctx when swa_full=True
+        expected = n_global * ctx * kv_per + n_swa * ctx * kv_per
+        assert flagged == expected
+
+    def test_swa_full_no_op_for_non_swa_model(self):
+        b = self._gqa_backend()
+        baseline = b._estimate_kv_cache_bytes(8192, "f16")
+        flagged = b._estimate_kv_cache_bytes(8192, "f16", swa_full = True)
+        assert flagged == baseline
+
+    def test_swa_full_suppresses_checkpoint_term(self):
+        b = self._swa_backend()
+        with_cp = b._estimate_kv_cache_bytes(8192, "f16", ctx_checkpoints = 8)
+        with_cp_full = b._estimate_kv_cache_bytes(
+            8192, "f16", ctx_checkpoints = 8, swa_full = True
+        )
+        no_cp_full = b._estimate_kv_cache_bytes(8192, "f16", swa_full = True)
+        # Checkpoints only matter when SWA layers don't already keep n_ctx.
+        assert with_cp_full == no_cp_full
+        assert with_cp > b._estimate_kv_cache_bytes(8192, "f16")
+
+    # ── --parallel + --kv-unified ──────────────────────────────────
+    # Empirically verified against llama-server: non-SWA caches partition
+    # n_ctx across slots (total memory constant); SWA layers are the only
+    # portion that scales with --parallel.  --kv-unified is currently a
+    # no-op for memory math (kept for API forward-compat).
+
+    def test_gqa_kv_constant_across_parallel(self):
+        b = self._gqa_backend()
+        baseline = b._estimate_kv_cache_bytes(4096, "f16")
+        for slots in (1, 2, 4, 8):
+            for unified in (True, False):
+                assert (
+                    b._estimate_kv_cache_bytes(
+                        4096, "f16", n_parallel = slots, kv_unified = unified
+                    )
+                    == baseline
+                )
+
+    def test_zero_parallel_floors_at_one(self):
+        b = self._gqa_backend()
+        baseline = b._estimate_kv_cache_bytes(4096, "f16")
+        for unified in (True, False):
+            assert (
+                b._estimate_kv_cache_bytes(
+                    4096, "f16", n_parallel = 0, kv_unified = unified
+                )
+                == baseline
+            )
+
+    def test_swa_path_scales_only_swa_portion(self):
+        b = self._swa_backend()
+        ctx = 8192
+        baseline = b._estimate_kv_cache_bytes(ctx, "f16")
+        # Decompose baseline by walking the same loop the estimator does.
+        swa = b._sliding_window
+        per_token_global = 4 * (256 + 256) * 2  # n_kv * (k+v) * f16
+        per_token_swa = 4 * (256 + 256) * 2  # k_swa/val_swa fall back
+        per_slot_swa_cells = min(ctx, 2 * swa)  # not clamped at parallel=1
+        global_bytes = sum(
+            ctx * per_token_global
+            for f in b._sliding_window_pattern[: b._n_layers]
+            if not f
+        )
+        swa_bytes_per_slot = sum(
+            per_slot_swa_cells * per_token_swa
+            for f in b._sliding_window_pattern[: b._n_layers]
+            if f
+        )
+        # Sanity: parallel=1 reproduces baseline exactly
+        assert global_bytes + swa_bytes_per_slot == baseline
+        # Only SWA portion scales by parallel
+        for slots in (1, 2, 3, 4):
+            scaled = b._estimate_kv_cache_bytes(
+                ctx, "f16", n_parallel = slots, kv_unified = False
+            )
+            # SWA cells get clamped to per_slot_ctx when ctx/slots < 2*swa
+            per_slot_ctx = max(1, ctx // slots)
+            cells = min(ctx, 2 * swa, per_slot_ctx)
+            swa_bps = sum(
+                cells * per_token_swa
+                for f in b._sliding_window_pattern[: b._n_layers]
+                if f
+            )
+            assert scaled == global_bytes + slots * swa_bps
+
+    def test_mla_kv_constant_across_parallel(self):
+        b = LlamaCppBackend()
+        b._n_layers = 60
+        b._n_kv_heads = 1
+        b._kv_lora_rank = 512
+        b._key_length_mla = 64
+        b._kv_key_length = 576
+        baseline = b._estimate_kv_cache_bytes(8192, "f16")
+        for slots in (1, 2, 4, 8):
+            for unified in (True, False):
+                assert (
+                    b._estimate_kv_cache_bytes(
+                        8192, "f16", n_parallel = slots, kv_unified = unified
+                    )
+                    == baseline
+                )
+
+    # ── --ctx-checkpoints ──────────────────────────────────────────
+
+    def test_ctx_checkpoints_zero_is_no_op(self):
+        b = self._swa_backend()
+        baseline = b._estimate_kv_cache_bytes(8192, "f16")
+        assert b._estimate_kv_cache_bytes(8192, "f16", ctx_checkpoints = 0) == baseline
+
+    def test_ctx_checkpoints_no_op_for_non_swa(self):
+        b = self._gqa_backend()
+        baseline = b._estimate_kv_cache_bytes(8192, "f16")
+        assert b._estimate_kv_cache_bytes(8192, "f16", ctx_checkpoints = 32) == baseline
+
+    def test_ctx_checkpoints_pattern_path_adds_known_bytes(self):
+        b = self._swa_backend()
+        ctx = 8192
+        baseline = b._estimate_kv_cache_bytes(ctx, "f16")
+        flagged = b._estimate_kv_cache_bytes(ctx, "f16", ctx_checkpoints = 4)
+        # 22 SWA layers * 4 checkpoints * 512 cells * 4 heads * (256+256) * 2 bytes
+        n_swa_layers = sum(
+            1 for f in [True, True, True, True, True, False] * 4 + [True, True] if f
+        )
+        per_layer = 4 * 512 * 4 * (256 + 256) * 2
+        assert flagged == baseline + n_swa_layers * per_layer
+
+    def test_ctx_checkpoints_legacy_path_adds_known_bytes(self):
+        b = self._swa_backend(_sliding_window_pattern = None)
+        ctx = 8192
+        baseline = b._estimate_kv_cache_bytes(ctx, "f16")
+        flagged = b._estimate_kv_cache_bytes(ctx, "f16", ctx_checkpoints = 4)
+        n_global = max(1, 26 // 4)
+        n_swa = 26 - n_global
+        kv_per = 4 * (256 + 256) * 2
+        extra = 4 * n_swa * 512 * kv_per  # ctx_checkpoints * n_swa * sliding * kv_per
+        assert flagged == baseline + extra
+
+    def test_ctx_checkpoints_compose_with_n_parallel(self):
+        # Only the SWA + checkpoint portion scales by n_parallel; the
+        # global-layer portion stays constant.
+        b = self._swa_backend()
+        ctx = 8192
+        swa = b._sliding_window
+        per_token = 4 * (256 + 256) * 2
+        global_bytes = sum(
+            ctx * per_token for f in b._sliding_window_pattern[: b._n_layers] if not f
+        )
+        n_swa_layers = sum(1 for f in b._sliding_window_pattern[: b._n_layers] if f)
+        slots = 3
+        per_slot_ctx = max(1, ctx // slots)
+        swa_cells = min(ctx, 2 * swa, per_slot_ctx)
+        swa_bytes_per_slot = n_swa_layers * swa_cells * per_token
+        cp_extra_per_slot = n_swa_layers * 4 * swa * per_token  # 4 checkpoints
+        flagged = b._estimate_kv_cache_bytes(
+            ctx, "f16", ctx_checkpoints = 4, n_parallel = slots, kv_unified = False
+        )
+        assert flagged == global_bytes + slots * (
+            swa_bytes_per_slot + cp_extra_per_slot
+        )
+
+    # ── --kv-offload (kv_on_gpu) ───────────────────────────────────
+
+    def test_fit_returns_requested_when_kv_off_gpu(self):
+        b = self._gqa_backend()
+        # Tiny VRAM budget -- normally would force a reduction.
+        fitted = b._fit_context_to_vram(
+            requested_ctx = 32_768,
+            available_mib = 1,
+            model_size_bytes = 100,
+            cache_type_kv = "f16",
+            kv_on_gpu = False,
+        )
+        assert fitted == 32_768
+
+    def test_fit_reduces_when_kv_on_gpu(self):
+        b = self._gqa_backend()
+        fitted = b._fit_context_to_vram(
+            requested_ctx = 32_768,
+            available_mib = 64,
+            model_size_bytes = 1024 * 1024,  # 1 MiB
+            cache_type_kv = "f16",
+            kv_on_gpu = True,
+        )
+        assert fitted < 32_768
+
+    def test_fit_threads_swa_full_through_estimator(self):
+        # SWA model, generous budget; both should fit but cache size differs.
+        b = self._swa_backend()
+        ctx = 8192
+        kv_default = b._estimate_kv_cache_bytes(ctx, "f16")
+        kv_full = b._estimate_kv_cache_bytes(ctx, "f16", swa_full = True)
+        assert kv_full > kv_default
+        # Budget = model + kv_default (rounded up) -- swa_full should not fit.
+        budget_mib = (1024 * 1024 + kv_default) / (1024 * 1024) / 0.90 + 1
+        fitted_default = b._fit_context_to_vram(
+            requested_ctx = ctx,
+            available_mib = int(budget_mib),
+            model_size_bytes = 1024 * 1024,
+            cache_type_kv = "f16",
+        )
+        fitted_full = b._fit_context_to_vram(
+            requested_ctx = ctx,
+            available_mib = int(budget_mib),
+            model_size_bytes = 1024 * 1024,
+            cache_type_kv = "f16",
+            swa_full = True,
+        )
+        assert fitted_default == ctx
+        assert fitted_full < ctx
+
+
+# ---------------------------------------------------------------------------
+# J2.5. --parallel N memory accounting (per-layer-type scaling rule)
+# ---------------------------------------------------------------------------
+
+
+class TestParallelSWAScaling:
+    """Verifies the per-layer-type scaling rule against the closed form
+    measured from llama-server. Empirical formula on Gemma-3 270m at
+    ctx=8192: total_kv = 24 + parallel * 15 (MiB).
+
+    Rule (verified vs ``llama-server`` log on real GGUFs):
+      * non-SWA layers: total cells = n_ctx, partitioned across slots,
+        memory CONSTANT in n_parallel.
+      * SWA layers: per-slot cells = 2 * sliding_window (clamped at
+        n_ctx and at per_slot_ctx); memory LINEAR in n_parallel.
+      * --kv-unified is a no-op for memory math; both modes yield the
+        same total in measured cases.
+    """
+
+    def _gqa_backend(self, **overrides):
+        defaults = {
+            "_n_layers": 28,
+            "_n_kv_heads": 8,
+            "_n_heads": 16,
+            "_embedding_length": 1024,
+            "_kv_key_length": 128,
+            "_kv_value_length": 128,
+        }
+        defaults.update(overrides)
+        b = LlamaCppBackend()
+        for k, v in defaults.items():
+            setattr(b, k, v)
+        return b
+
+    def _swa_backend(self, **overrides):
+        defaults = {
+            "_n_layers": 18,
+            "_n_kv_heads": 1,
+            "_n_heads": 4,
+            "_embedding_length": 1024,
+            "_kv_key_length": 256,
+            "_kv_value_length": 256,
+            "_sliding_window": 512,
+            # 15 SWA + 3 global, mirrors gemma-3-270m
+            "_sliding_window_pattern": [
+                t == "swa" for t in (["swa"] * 5 + ["global"]) * 3
+            ],
+        }
+        defaults.update(overrides)
+        b = LlamaCppBackend()
+        for k, v in defaults.items():
+            setattr(b, k, v)
+        return b
+
+    # ── non-SWA paths: constant ────────────────────────────────────
+
+    def test_pure_gqa_constant_across_parallel(self):
+        b = self._gqa_backend()
+        baseline = b._estimate_kv_cache_bytes(8192, "f16")
+        for slots in (1, 2, 4, 8):
+            for unified in (True, False):
+                assert (
+                    b._estimate_kv_cache_bytes(
+                        8192, "f16", n_parallel = slots, kv_unified = unified
+                    )
+                    == baseline
+                )
+
+    def test_mla_constant_across_parallel(self):
+        b = LlamaCppBackend()
+        b._n_layers = 60
+        b._n_kv_heads = 1
+        b._kv_lora_rank = 512
+        b._key_length_mla = 64
+        b._kv_key_length = 576
+        baseline = b._estimate_kv_cache_bytes(8192, "f16")
+        for slots in (1, 2, 4, 8):
+            assert b._estimate_kv_cache_bytes(8192, "f16", n_parallel = slots) == baseline
+
+    def test_hybrid_constant_across_parallel(self):
+        b = LlamaCppBackend()
+        b._n_layers = 64
+        b._n_kv_heads = 16
+        b._n_heads = 32
+        b._embedding_length = 4096
+        b._kv_key_length = 128
+        b._kv_value_length = 128
+        b._ssm_inner_size = 4096
+        b._full_attention_interval = 4
+        baseline = b._estimate_kv_cache_bytes(8192, "f16")
+        for slots in (1, 2, 4, 8):
+            assert b._estimate_kv_cache_bytes(8192, "f16", n_parallel = slots) == baseline
+
+    def test_legacy_constant_across_parallel(self):
+        b = LlamaCppBackend()
+        b._n_layers = 32
+        b._n_kv_heads = 8
+        b._n_heads = 8
+        b._embedding_length = 4096
+        baseline = b._estimate_kv_cache_bytes(8192, "f16")
+        for slots in (1, 2, 4, 8):
+            assert b._estimate_kv_cache_bytes(8192, "f16", n_parallel = slots) == baseline
+
+    # ── SWA paths: scale only the SWA portion ──────────────────────
+
+    def test_swa_pattern_scales_only_swa_portion(self):
+        b = self._swa_backend()
+        ctx = 8192
+        swa = b._sliding_window
+        per_token = 1 * (256 + 256) * 2  # n_kv * (k+v) * f16
+        n_global = sum(1 for f in b._sliding_window_pattern if not f)
+        n_swa = sum(1 for f in b._sliding_window_pattern if f)
+        global_bytes = n_global * ctx * per_token
+        for slots in (1, 2, 4, 8):
+            per_slot_ctx = max(1, ctx // slots)
+            cells = min(ctx, 2 * swa, per_slot_ctx)
+            swa_bps = n_swa * cells * per_token
+            for unified in (True, False):
+                got = b._estimate_kv_cache_bytes(
+                    ctx, "f16", n_parallel = slots, kv_unified = unified
+                )
+                assert got == global_bytes + slots * swa_bps
+
+    def test_swa_fallback_scales_only_swa_portion(self):
+        # No per-layer pattern -> 1/4-global heuristic.
+        b = self._swa_backend(_sliding_window_pattern = None)
+        ctx = 8192
+        swa = b._sliding_window
+        n_layers = 18
+        n_global = max(1, n_layers // 4)
+        n_swa = n_layers - n_global
+        per_token = 1 * (256 + 256) * 2
+        global_bytes = n_global * ctx * per_token
+        for slots in (1, 2, 4, 8):
+            per_slot_ctx = max(1, ctx // slots)
+            cells = min(ctx, 2 * swa, per_slot_ctx)
+            swa_bps = n_swa * cells * per_token
+            got = b._estimate_kv_cache_bytes(ctx, "f16", n_parallel = slots)
+            assert got == global_bytes + slots * swa_bps
+
+    def test_swa_per_slot_clamped_when_ctx_lt_slots_x_2window(self):
+        # ctx=4096 / slots=8 -> per_slot_ctx=512, but 2*sliding=1024.
+        # SWA cells should clamp at per_slot_ctx (512), not 2*sliding.
+        b = self._swa_backend()
+        ctx = 4096
+        per_slot_ctx_at_8 = ctx // 8
+        assert per_slot_ctx_at_8 < 2 * b._sliding_window
+        # Build expected with the clamped formula
+        n_swa = sum(1 for f in b._sliding_window_pattern if f)
+        n_global = sum(1 for f in b._sliding_window_pattern if not f)
+        per_token = 1 * (256 + 256) * 2
+        global_bytes = n_global * ctx * per_token
+        cells = min(ctx, 2 * b._sliding_window, per_slot_ctx_at_8)
+        assert cells == per_slot_ctx_at_8
+        expected = global_bytes + 8 * (n_swa * cells * per_token)
+        assert b._estimate_kv_cache_bytes(ctx, "f16", n_parallel = 8) == expected
+
+    def test_swa_full_does_not_scale_under_parallel(self):
+        # swa_full forces every layer to n_ctx; result is the all-global
+        # GQA-style total, which is constant in parallel.
+        b = self._swa_backend()
+        ctx = 8192
+        baseline = b._estimate_kv_cache_bytes(ctx, "f16", swa_full = True)
+        for slots in (1, 2, 4, 8):
+            assert (
+                b._estimate_kv_cache_bytes(ctx, "f16", swa_full = True, n_parallel = slots)
+                == baseline
+            )
+
+    # ── kv_unified: no-op for memory math ──────────────────────────
+
+    def test_kv_unified_is_no_op_for_memory_math(self):
+        # Both unified=True and unified=False must produce the same
+        # total bytes for every backend type and every parallel value.
+        backends = [
+            ("gqa", self._gqa_backend()),
+            ("swa", self._swa_backend()),
+        ]
+        for label, b in backends:
+            for slots in (1, 2, 4, 8):
+                u = b._estimate_kv_cache_bytes(
+                    8192, "f16", n_parallel = slots, kv_unified = True
+                )
+                nu = b._estimate_kv_cache_bytes(
+                    8192, "f16", n_parallel = slots, kv_unified = False
+                )
+                assert u == nu, f"{label} parallel={slots} unified-mismatch"
+
+    # ── Empirical Gemma-3 270m formula ─────────────────────────────
+
+    def test_matches_empirical_gemma3_270m_formula(self):
+        """Exact match against the formula measured from llama-server:
+        total_kv = 24 + parallel * 15 (MiB) at ctx=8192.
+
+        Geometry: 18 layers (3 global + 15 SWA), n_kv=1, head_dim=256,
+        sliding=512, f16.
+        """
+        b = LlamaCppBackend()
+        b._n_layers = 18
+        b._n_kv_heads = 1
+        b._n_heads = 4
+        b._embedding_length = 1024
+        b._kv_key_length = 256
+        b._kv_value_length = 256
+        b._sliding_window = 512
+        # 5-period [swa,swa,swa,swa,full] * 3 + [swa,swa,swa]: mirrors the
+        # bootstrap-resolved pattern for gemma3 (period 6) on an 18-layer
+        # model (15 SWA, 3 global).
+        b._sliding_window_pattern = [(i + 1) % 6 != 0 for i in range(18)]
+        n_global = 3
+        n_swa = 15
+        # Confirm pattern shape
+        assert sum(b._sliding_window_pattern) == n_swa
+        for slots, expected_mib in [(1, 39), (2, 54), (4, 84)]:
+            got_bytes = b._estimate_kv_cache_bytes(8192, "f16", n_parallel = slots)
+            got_mib = got_bytes / (1024 * 1024)
+            assert (
+                got_mib == expected_mib
+            ), f"slots={slots}: got {got_mib} MiB, expected {expected_mib} MiB"
+
+
+# ---------------------------------------------------------------------------
+# J3. shared_kv_layers (Gemma 3n / Gemma 4)
+# ---------------------------------------------------------------------------
+
+
+class TestSharedKVLayers:
+    """``<arch>.attention.shared_kv_layers`` reduces the layer count that
+    actually allocates KV.  The trailing ``shared_kv_layers`` blocks reuse
+    earlier caches (Gemma 3n: 35 layers, 15 shared -> 20 allocate; Gemma 4
+    same field).  Unset on every other arch -> no behavioural change."""
+
+    def _gemma3n_backend(self, **overrides):
+        # Mirrors google/gemma-3n-E4B-it: 35 layers, 15 shared,
+        # SWA window 1024, period 5 (4 sliding + 1 full repeating).
+        defaults = {
+            "_n_layers": 35,
+            "_n_kv_heads": 4,
+            "_n_heads": 8,
+            "_embedding_length": 2048,
+            "_kv_key_length": 256,
+            "_kv_value_length": 256,
+            "_sliding_window": 1024,
+            "_sliding_window_pattern": [
+                t == "sliding_attention"
+                for t in (["sliding_attention"] * 4 + ["full_attention"]) * 7
+            ],
+            "_shared_kv_layers": 15,
+        }
+        defaults.update(overrides)
+        b = LlamaCppBackend()
+        for k, v in defaults.items():
+            setattr(b, k, v)
+        return b
+
+    def _gqa_backend(self, **overrides):
+        defaults = {
+            "_n_layers": 28,
+            "_n_kv_heads": 8,
+            "_n_heads": 16,
+            "_embedding_length": 1024,
+            "_kv_key_length": 128,
+            "_kv_value_length": 128,
+        }
+        defaults.update(overrides)
+        b = LlamaCppBackend()
+        for k, v in defaults.items():
+            setattr(b, k, v)
+        return b
+
+    def test_field_initialises_to_none(self):
+        b = LlamaCppBackend()
+        assert b._shared_kv_layers is None
+
+    def test_unset_field_is_noop(self):
+        b = self._gqa_backend()
+        baseline = b._estimate_kv_cache_bytes(8192, "f16")
+        b._shared_kv_layers = None
+        assert b._estimate_kv_cache_bytes(8192, "f16") == baseline
+        b._shared_kv_layers = 0
+        assert b._estimate_kv_cache_bytes(8192, "f16") == baseline
+
+    def test_path4_drops_shared_layers(self):
+        b = self._gqa_backend(_shared_kv_layers = 4)
+        ctx = 4096
+        kv_per = 8 * (128 + 128) * 2
+        # 28 - 4 = 24 layers actually allocate
+        assert b._estimate_kv_cache_bytes(ctx, "f16") == 24 * ctx * kv_per
+
+    def test_path5_drops_shared_layers(self):
+        b = LlamaCppBackend()
+        b._n_layers = 32
+        b._n_kv_heads = 8
+        b._n_heads = 8
+        b._embedding_length = 4096
+        b._shared_kv_layers = 8
+        ctx = 4096
+        head_dim = 4096 // 8  # 512
+        # 32 - 8 = 24 layers
+        expected = 2 * 8 * head_dim * 24 * ctx * 2
+        assert b._estimate_kv_cache_bytes(ctx, "f16") == expected
+
+    def test_path1_mla_drops_shared_layers(self):
+        b = LlamaCppBackend()
+        b._n_layers = 60
+        b._n_kv_heads = 1
+        b._kv_lora_rank = 512
+        b._key_length_mla = 64
+        b._kv_key_length = 576
+        b._shared_kv_layers = 10
+        ctx = 8192
+        # 60 - 10 = 50
+        assert b._estimate_kv_cache_bytes(ctx, "f16") == 50 * ctx * 1 * 576 * 2
+
+    def test_path3_pattern_loops_only_unshared_layers(self):
+        b = self._gemma3n_backend()
+        ctx = 8192
+        # First 20 layers contribute; layers 20..34 are skipped.
+        # Pattern: [s,s,s,s,F] repeated.  In layers 0..19:
+        #   sliding: 16, full: 4
+        sliding_in_unshared = sum(b._sliding_window_pattern[:20])
+        full_in_unshared = 20 - sliding_in_unshared
+        assert sliding_in_unshared == 16
+        assert full_in_unshared == 4
+        kv_per = 4 * (256 + 256) * 2
+        swa_cells = min(ctx, 2 * 1024)
+        expected = (
+            full_in_unshared * ctx * kv_per + sliding_in_unshared * swa_cells * kv_per
+        )
+        assert b._estimate_kv_cache_bytes(ctx, "f16") == expected
+
+    def test_shared_layers_reduces_estimate(self):
+        b = self._gemma3n_backend()
+        with_shared = b._estimate_kv_cache_bytes(8192, "f16")
+        b._shared_kv_layers = 0
+        without_shared = b._estimate_kv_cache_bytes(8192, "f16")
+        # 20/35 = 0.571 of the work; expect ~43% reduction.
+        ratio = with_shared / without_shared
+        assert 0.5 < ratio < 0.65
+
+    def test_path3_pattern_with_swa_full_and_shared(self):
+        b = self._gemma3n_backend()
+        ctx = 8192
+        flagged = b._estimate_kv_cache_bytes(ctx, "f16", swa_full = True)
+        # Every unshared layer caches n_ctx; equals path-4-style sizing
+        # over only the 20 unshared layers.
+        kv_per = 4 * (256 + 256) * 2
+        assert flagged == 20 * ctx * kv_per
+
+    def test_path3_fallback_uses_unshared_count(self):
+        # No per-layer pattern -> 1/4-global heuristic over n_layers_kv,
+        # not n_layers.
+        b = self._gemma3n_backend(_sliding_window_pattern = None)
+        ctx = 8192
+        n_layers_kv = 35 - 15  # 20
+        n_global = max(1, n_layers_kv // 4)  # 5
+        n_swa = n_layers_kv - n_global  # 15
+        kv_per = 4 * (256 + 256) * 2
+        swa_cells = min(ctx, 2 * 1024)
+        expected = n_global * ctx * kv_per + n_swa * swa_cells * kv_per
+        assert b._estimate_kv_cache_bytes(ctx, "f16") == expected
+
+    def test_shared_floors_at_one_layer(self):
+        # Pathological: shared >= n_layers should not zero out the cache.
+        b = self._gqa_backend(_shared_kv_layers = 99)
+        ctx = 4096
+        kv_per = 8 * (128 + 128) * 2
+        assert b._estimate_kv_cache_bytes(ctx, "f16") == 1 * ctx * kv_per
+
+    def test_composes_with_n_parallel(self):
+        # Only the SWA portion of the unshared layers scales by n_parallel;
+        # the global portion stays constant.
+        b = self._gemma3n_backend()
+        ctx = 8192
+        swa = b._sliding_window
+        per_token = 4 * (256 + 256) * 2
+        unshared_pattern = b._sliding_window_pattern[:20]  # 35 - 15 shared
+        sliding_in_unshared = sum(unshared_pattern)
+        global_in_unshared = len(unshared_pattern) - sliding_in_unshared
+        global_bytes = global_in_unshared * ctx * per_token
+        slots = 3
+        per_slot_ctx = max(1, ctx // slots)
+        swa_cells = min(ctx, 2 * swa, per_slot_ctx)
+        swa_bytes_per_slot = sliding_in_unshared * swa_cells * per_token
+        flagged = b._estimate_kv_cache_bytes(
+            ctx, "f16", n_parallel = slots, kv_unified = False
+        )
+        assert flagged == global_bytes + slots * swa_bytes_per_slot
+
+    def test_composes_with_ctx_checkpoints(self):
+        b = self._gemma3n_backend()
+        ctx = 8192
+        baseline = b._estimate_kv_cache_bytes(ctx, "f16")
+        with_cp = b._estimate_kv_cache_bytes(ctx, "f16", ctx_checkpoints = 4)
+        # Checkpoints only count over UNSHARED SWA layers (16 of them).
+        sliding_in_unshared = sum(b._sliding_window_pattern[:20])
+        per_cp_layer = 4 * 1024 * 4 * (256 + 256) * 2  # cps * swa * heads * (k+v) * bpe
+        assert with_cp == baseline + sliding_in_unshared * per_cp_layer
+
+    def test_unload_resets_shared_kv_layers(self):
+        b = LlamaCppBackend()
+        b._shared_kv_layers = 12
+        b.unload_model()
+        assert b._shared_kv_layers is None
+
+
 # ---------------------------------------------------------------------------
 # K. Lifecycle Tests
 # ---------------------------------------------------------------------------
@@ -799,13 +2004,18 @@ class TestLifecycle:
             "_kv_key_length",
             "_kv_value_length",
             "_sliding_window",
+            "_sliding_window_pattern",
             "_full_attention_interval",
             "_kv_lora_rank",
             "_key_length_mla",
+            "_kv_key_length_swa",
+            "_kv_value_length_swa",
             "_ssm_inner_size",
             "_ssm_state_size",
+            "_shared_kv_layers",
         ]:
             assert getattr(b, attr) is None
+        assert b._n_kv_heads_by_layer is None
 
     def test_unload_resets_fields(self):
         b = LlamaCppBackend()
@@ -813,20 +2023,30 @@ class TestLifecycle:
         b._kv_key_length = 128
         b._kv_lora_rank = 512
         b._sliding_window = 1024
+        b._sliding_window_pattern = [True, False]
+        b._n_kv_heads_by_layer = [8, 2]
+        b._kv_key_length_swa = 64
+        b._kv_value_length_swa = 64
         b._ssm_inner_size = 4096
         b._full_attention_interval = 4
+        b._shared_kv_layers = 8
         b.unload_model()
         for attr in [
             "_kv_key_length",
             "_kv_value_length",
             "_sliding_window",
+            "_sliding_window_pattern",
             "_full_attention_interval",
             "_kv_lora_rank",
             "_key_length_mla",
+            "_kv_key_length_swa",
+            "_kv_value_length_swa",
             "_ssm_inner_size",
             "_ssm_state_size",
+            "_shared_kv_layers",
         ]:
             assert getattr(b, attr) is None
+        assert b._n_kv_heads_by_layer is None
 
     def test_end_to_end_synthetic_mla(self):
         """Full round-trip: write GGUF -> parse -> estimate."""
@@ -887,12 +2107,46 @@ class TestLifecycle:
         )
         assert b._can_estimate_kv()
         result = b._estimate_kv_cache_bytes(131072, "f16")
-        n_global = max(1, 62 // 4)  # 15
-        n_swa = 62 - n_global  # 47
+        # gemma3 -> period 6 from the bootstrap table, SWA cache
+        # double-buffered to 2 * sliding_window cells.
+        period = 6
         kv_per = 16 * 256 * 2
-        expected = int(n_global * 131072 * kv_per + n_swa * 1024 * kv_per)
+        expected = 0
+        for i in range(62):
+            is_swa = (i + 1) % period != 0
+            layer_ctx = min(131072, 2 * 1024) if is_swa else 131072
+            expected += layer_ctx * kv_per
         assert result == expected
 
+    def test_end_to_end_synthetic_shared_kv_round_trip(self):
+        # Mirrors gemma3n_text: 35 layers, 15 shared, sliding_window=1024.
+        b = _backend_from_gguf(
+            "gemma3n_text",
+            {
+                "context_length": 32768,
+                "block_count": 35,
+                "attention.head_count_kv": 4,
+                "attention.head_count": 8,
+                "embedding_length": 2048,
+                "attention.key_length": 256,
+                "attention.value_length": 256,
+                "attention.sliding_window": 1024,
+                "attention.shared_kv_layers": 15,
+            },
+        )
+        assert b._can_estimate_kv()
+        assert b._shared_kv_layers == 15
+        # Bootstrap table for gemma3n_text -> period 5; the resolver
+        # synthesises a 35-entry bool array.  The first 20 entries
+        # (n_layers - shared) are the only ones that allocate KV.
+        result = b._estimate_kv_cache_bytes(8192, "f16")
+        assert result > 0
+        # Sanity: setting shared back to 0 must produce a strictly larger
+        # estimate (more layers allocate).
+        b._shared_kv_layers = 0
+        unshared = b._estimate_kv_cache_bytes(8192, "f16")
+        assert unshared > result
+
     def test_end_to_end_synthetic_gqa(self):
         b = _backend_from_gguf(
             "qwen3",
diff --git a/studio/backend/tests/test_llama_cpp_context_fit.py b/studio/backend/tests/test_llama_cpp_context_fit.py
index f498655347..caa6397901 100644
--- a/studio/backend/tests/test_llama_cpp_context_fit.py
+++ b/studio/backend/tests/test_llama_cpp_context_fit.py
@@ -114,9 +114,13 @@ def _make_backend(
     inst._kv_value_length = kv_value_length
     inst._kv_lora_rank = None
     inst._sliding_window = None
+    inst._sliding_window_pattern = None
     inst._ssm_inner_size = None
     inst._full_attention_interval = None
     inst._key_length_mla = None
+    inst._n_kv_heads_by_layer = None
+    inst._kv_key_length_swa = None
+    inst._kv_value_length_swa = None
     return inst
 
 
@@ -137,7 +141,7 @@ def _drive(
     model_size = int(model_gib * GIB)
     cache_type_kv = None
 
-    def fake_estimate(n_ctx_, _type = None):
+    def fake_estimate(n_ctx_, _type = None, **_kwargs):
         return 0 if n_ctx_ <= 0 else n_ctx_ * kv_per_token_bytes
 
     inst._estimate_kv_cache_bytes = fake_estimate
diff --git a/studio/backend/tests/test_llama_cpp_max_context_threshold.py b/studio/backend/tests/test_llama_cpp_max_context_threshold.py
index 5fd0243c9f..22e4cda7d1 100644
--- a/studio/backend/tests/test_llama_cpp_max_context_threshold.py
+++ b/studio/backend/tests/test_llama_cpp_max_context_threshold.py
@@ -99,9 +99,13 @@ def _make_backend(native_ctx = 131072):
     inst._kv_value_length = 128
     inst._kv_lora_rank = None
     inst._sliding_window = None
+    inst._sliding_window_pattern = None
     inst._ssm_inner_size = None
     inst._full_attention_interval = None
     inst._key_length_mla = None
+    inst._n_kv_heads_by_layer = None
+    inst._kv_key_length_swa = None
+    inst._kv_value_length_swa = None
     return inst
 
 
@@ -114,7 +118,7 @@ def _compute_max_available_ctx(native_ctx, model_gib, gpus, kv_per_token_bytes =
     model_size = int(model_gib * GIB)
 
     inst._estimate_kv_cache_bytes = (
-        lambda n, _t = None: 0 if n <= 0 else n * kv_per_token_bytes
+        lambda n, _t = None, **_kw: 0 if n <= 0 else n * kv_per_token_bytes
     )
     inst._can_estimate_kv = lambda: True
 
diff --git a/studio/backend/tests/test_llama_server_args.py b/studio/backend/tests/test_llama_server_args.py
new file mode 100644
index 0000000000..351fbd014d
--- /dev/null
+++ b/studio/backend/tests/test_llama_server_args.py
@@ -0,0 +1,189 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+"""Unit tests for the llama-server pass-through args validator.
+
+The validator is the security boundary between user-supplied CLI / HTTP
+input and the llama-server subprocess command. These tests pin the
+denylist behavior so the boundary doesn't quietly regress when new
+managed flags are added.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from core.inference.llama_server_args import (
+    is_managed_flag,
+    validate_extra_args,
+)
+
+
+# ── Pass-through (allowed) ───────────────────────────────────────────
+
+
+@pytest.mark.parametrize(
+    "args",
+    [
+        # Sampling
+        ["--top-k", "20"],
+        ["--top-p", "0.9", "--min-p", "0.05"],
+        ["--seed", "-1"],  # negative value, not a flag
+        ["--temp", "0.0"],
+        ["--repeat-penalty", "1.05"],
+        ["--mirostat", "2", "--mirostat-lr", "0.1"],
+        ["--xtc-probability", "0.05", "--xtc-threshold", "0.1"],
+        ["--dry-multiplier", "0.5"],
+        # Tier-2 knobs that map to LoadRequest fields
+        ["--cache-type-k", "q8_0"],
+        ["--cache-type-v", "q8_0"],
+        ["--chat-template-file", "/tmp/tpl.jinja"],
+        ["--chat-template-kwargs", '{"reasoning_effort":"high"}'],
+        ["--spec-type", "ngram-mod"],
+        ["--spec-default"],
+        # Reasoning controls
+        ["--reasoning-format", "deepseek"],
+        ["-rea", "auto"],
+        # Soft-managed flags the user may want to override on the CLI;
+        # llama.cpp's last-wins parsing means these win over Studio's
+        # auto-set version.
+        ["-c", "131072"],
+        ["--ctx-size", "8192"],
+        ["--parallel", "1"],
+        ["-np", "8"],
+        ["--flash-attn", "off"],
+        ["-fa", "on"],
+        ["--no-context-shift"],
+        ["--context-shift"],
+        ["--jinja"],
+        ["--no-jinja"],
+        ["-ngl", "-1"],
+        ["--gpu-layers", "32"],
+        ["-t", "16"],
+        ["--threads", "32"],
+        ["-fit", "off"],
+        ["--fit", "on"],
+        ["--fit-ctx", "8192"],
+    ],
+)
+def test_pass_through_allowed(args):
+    assert validate_extra_args(args) == args
+
+
+def test_none_returns_empty_list():
+    assert validate_extra_args(None) == []
+
+
+def test_empty_list_returns_empty_list():
+    assert validate_extra_args([]) == []
+
+
+def test_value_with_equals_form_passes_through():
+    assert validate_extra_args(["--top-k=20"]) == ["--top-k=20"]
+
+
+def test_non_flag_token_passes_through():
+    # A bare positional value (not preceded by a flag) is preserved
+    # verbatim. llama-server may reject it, but that's not our job.
+    assert validate_extra_args(["foo"]) == ["foo"]
+
+
+# ── Denylist (rejected) ──────────────────────────────────────────────
+
+
+@pytest.mark.parametrize(
+    "denied",
+    [
+        # Model identity
+        "-m",
+        "--model",
+        "-hf",
+        "-hfr",
+        "--hf-repo",
+        "-hff",
+        "--hf-file",
+        "-hft",
+        "--hf-token",
+        "-mm",
+        "--mmproj",
+        "--mmproj-url",
+        # Networking (Studio binds + proxies)
+        "--host",
+        "--port",
+        "--path",
+        "--api-prefix",
+        "--reuse-port",
+        # Auth / TLS
+        "--api-key",
+        "--api-key-file",
+        "--ssl-key-file",
+        "--ssl-cert-file",
+        # Single-model server
+        "--webui",
+        "--no-webui",
+        "--models-dir",
+        "--models-max",
+    ],
+)
+def test_denylist_rejects_all_aliases(denied):
+    with pytest.raises(ValueError, match = denied):
+        validate_extra_args([denied, "value"])
+
+
+def test_denylist_rejects_equals_form():
+    with pytest.raises(ValueError, match = "--port"):
+        validate_extra_args(["--port=9000"])
+
+
+def test_denylist_rejects_short_form_when_long_is_denied():
+    # -m is the short form of the hard-denied --model; rejecting only
+    # the long form would leave a trivial bypass.
+    with pytest.raises(ValueError, match = "-m"):
+        validate_extra_args(["-m", "/some/other/path.gguf"])
+
+
+def test_denylist_message_names_offending_flag():
+    with pytest.raises(ValueError) as excinfo:
+        validate_extra_args(["--top-k", "20", "--api-key", "secret"])
+    assert "--api-key" in str(excinfo.value)
+
+
+def test_first_denied_flag_short_circuits():
+    # Validation stops at the first denied flag; later denied flags
+    # in the same call don't matter for behaviour, but the message
+    # should name the first one we hit.
+    with pytest.raises(ValueError, match = "--port"):
+        validate_extra_args(["--port", "1", "--host", "x"])
+
+
+# ── Numeric values that look flag-ish ─────────────────────────────────
+
+
+@pytest.mark.parametrize("value", ["-1", "-0.5", "-42", "-.5"])
+def test_negative_number_value_is_not_flag(value):
+    # ``--seed -1`` is a value, not a flag. Validator must not try
+    # to look up "-1" in the denylist.
+    assert validate_extra_args(["--seed", value]) == ["--seed", value]
+
+
+# ── is_managed_flag helper ───────────────────────────────────────────
+
+
+def test_is_managed_flag_true_for_denied():
+    assert is_managed_flag("--port") is True
+    assert is_managed_flag("--api-key") is True
+    assert is_managed_flag("-m") is True
+    assert is_managed_flag("--model") is True
+
+
+def test_is_managed_flag_false_for_pass_through():
+    assert is_managed_flag("--top-k") is False
+    assert is_managed_flag("--cache-type-k") is False
+    assert is_managed_flag("--chat-template-file") is False
+    # Soft-managed flags pass through (last-wins override)
+    assert is_managed_flag("-c") is False
+    assert is_managed_flag("--ctx-size") is False
+    assert is_managed_flag("--parallel") is False
+    assert is_managed_flag("--flash-attn") is False
+    assert is_managed_flag("-ngl") is False
+    assert is_managed_flag("--threads") is False
diff --git a/studio/backend/tests/test_native_context_length.py b/studio/backend/tests/test_native_context_length.py
index 7c69e56f89..60622c776d 100644
--- a/studio/backend/tests/test_native_context_length.py
+++ b/studio/backend/tests/test_native_context_length.py
@@ -320,11 +320,23 @@ class TestPydanticModels:
         """Field exists in InferenceStatusResponse.model_fields."""
         assert "native_context_length" in InferenceStatusResponse.model_fields
 
+    def test_status_response_has_chat_template_field(self):
+        """Status includes chat_template so the UI can rehydrate after refresh."""
+        assert "chat_template" in InferenceStatusResponse.model_fields
+
     def test_status_response_defaults_none(self):
         """Omitting native_context_length defaults to None."""
         resp = InferenceStatusResponse()
         assert resp.native_context_length is None
 
+    def test_status_response_chat_template_roundtrip(self):
+        """chat_template serializes and validates as part of status."""
+        resp = InferenceStatusResponse(chat_template = "{{ messages }}")
+        roundtripped = InferenceStatusResponse.model_validate_json(
+            resp.model_dump_json()
+        )
+        assert roundtripped.chat_template == "{{ messages }}"
+
     def test_roundtrip_preserves_value(self):
         """model_validate_json(model_dump_json()) round-trips."""
         resp = LoadResponse(
diff --git a/studio/backend/tests/test_openai_tool_passthrough.py b/studio/backend/tests/test_openai_tool_passthrough.py
index ccb0dba325..cdb7f5d270 100644
--- a/studio/backend/tests/test_openai_tool_passthrough.py
+++ b/studio/backend/tests/test_openai_tool_passthrough.py
@@ -144,13 +144,14 @@ class TestChatMessageToolRoles:
 
     # ── Role-aware content requirements ────────────────────────────
 
-    def test_user_empty_content_rejected(self):
-        with pytest.raises(ValidationError):
-            ChatMessage(role = "user", content = "")
+    @pytest.mark.parametrize("role", ["user", "system"])
+    def test_empty_string_content_allowed(self, role):
+        msg = ChatMessage(role = role, content = "")
+        assert msg.content == ""
 
-    def test_system_empty_content_rejected(self):
+    def test_user_missing_content_rejected(self):
         with pytest.raises(ValidationError):
-            ChatMessage(role = "system", content = "")
+            ChatMessage(role = "user")
 
     def test_user_empty_list_content_rejected(self):
         with pytest.raises(ValidationError):
@@ -226,6 +227,14 @@ class TestChatCompletionRequestToolFields:
         assert len(req.tools) == 1
         assert req.tools[0]["function"]["name"] == "get_weather"
 
+    def test_image_base64_allows_empty_user_text(self):
+        req = ChatCompletionRequest(
+            messages = [{"role": "user", "content": ""}],
+            image_base64 = "aW1hZ2U=",
+        )
+        assert req.messages[0].content == ""
+        assert req.image_base64 == "aW1hZ2U="
+
     def test_tool_choice_string_auto(self):
         assert self._make(tool_choice = "auto").tool_choice == "auto"
 
diff --git a/studio/backend/tests/test_tool_policy_gates.py b/studio/backend/tests/test_tool_policy_gates.py
new file mode 100644
index 0000000000..01f6bbbc3f
--- /dev/null
+++ b/studio/backend/tests/test_tool_policy_gates.py
@@ -0,0 +1,56 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved.
+
+"""
+Tests for `_effective_enable_tools` -- the helper that folds the
+process-level `tool_policy` over a request's `enable_tools` field.
+
+Truth table (policy x payload.enable_tools -> effective):
+  policy=None  + payload=None  -> None
+  policy=None  + payload=True  -> True
+  policy=None  + payload=False -> False
+  policy=True  + payload=*     -> True
+  policy=False + payload=*     -> False
+"""
+
+import os
+import sys
+from types import SimpleNamespace
+
+_backend = os.path.join(os.path.dirname(__file__), "..")
+sys.path.insert(0, _backend)
+
+import pytest
+
+from routes.inference import _effective_enable_tools
+from state.tool_policy import reset_tool_policy, set_tool_policy
+
+
+@pytest.fixture(autouse = True)
+def _reset():
+    reset_tool_policy()
+    yield
+    reset_tool_policy()
+
+
+def _payload(value):
+    return SimpleNamespace(enable_tools = value)
+
+
+class TestEffectiveEnableTools:
+    @pytest.mark.parametrize(
+        "payload_value,expected",
+        [(None, None), (True, True), (False, False)],
+    )
+    def test_no_policy_falls_through_to_payload(self, payload_value, expected):
+        assert _effective_enable_tools(_payload(payload_value)) == expected
+
+    @pytest.mark.parametrize("payload_value", [None, True, False])
+    def test_policy_true_overrides_any_payload(self, payload_value):
+        set_tool_policy(True)
+        assert _effective_enable_tools(_payload(payload_value)) is True
+
+    @pytest.mark.parametrize("payload_value", [None, True, False])
+    def test_policy_false_overrides_any_payload(self, payload_value):
+        set_tool_policy(False)
+        assert _effective_enable_tools(_payload(payload_value)) is False
diff --git a/studio/backend/tests/test_tool_policy_state.py b/studio/backend/tests/test_tool_policy_state.py
new file mode 100644
index 0000000000..5f6b228281
--- /dev/null
+++ b/studio/backend/tests/test_tool_policy_state.py
@@ -0,0 +1,59 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved.
+
+"""
+Tests for the process-level server-side tool policy used by `unsloth run`.
+
+The policy has three states:
+  None  -> no CLI override (default; honor per-request enable_tools)
+  True  -> CLI forced tools on
+  False -> CLI forced tools off
+"""
+
+import os
+import sys
+
+_backend = os.path.join(os.path.dirname(__file__), "..")
+sys.path.insert(0, _backend)
+
+import pytest
+
+from state.tool_policy import (
+    get_tool_policy,
+    reset_tool_policy,
+    set_tool_policy,
+)
+
+
+@pytest.fixture(autouse = True)
+def _reset():
+    reset_tool_policy()
+    yield
+    reset_tool_policy()
+
+
+class TestToolPolicy:
+    def test_default_is_none(self):
+        assert get_tool_policy() is None
+
+    def test_set_true_then_get(self):
+        set_tool_policy(True)
+        assert get_tool_policy() is True
+
+    def test_set_false_then_get(self):
+        set_tool_policy(False)
+        assert get_tool_policy() is False
+
+    def test_set_none_clears(self):
+        set_tool_policy(True)
+        set_tool_policy(None)
+        assert get_tool_policy() is None
+
+    def test_reset_clears(self):
+        set_tool_policy(False)
+        reset_tool_policy()
+        assert get_tool_policy() is None
+
+    def test_rejects_non_optional_bool(self):
+        with pytest.raises(TypeError):
+            set_tool_policy("true")  # type: ignore[arg-type]
diff --git a/studio/backend/tests/test_training_worker_flash_attn.py b/studio/backend/tests/test_training_worker_flash_attn.py
index 986958408e..41a7c87df1 100644
--- a/studio/backend/tests/test_training_worker_flash_attn.py
+++ b/studio/backend/tests/test_training_worker_flash_attn.py
@@ -133,6 +133,22 @@ def test_causal_conv1d_fast_path_preserves_wheel_first_install_args(monkeypatch)
     )
 
 
+def test_causal_conv1d_fast_path_includes_qwen3_6_variants(monkeypatch):
+    install_mock = mock.Mock(return_value = True)
+    monkeypatch.setattr(worker, "_install_package_wheel_first", install_mock)
+
+    worker._ensure_causal_conv1d_fast_path(
+        event_queue = [],
+        model_name = "unsloth/Qwen3.6-4B",
+    )
+    worker._ensure_causal_conv1d_fast_path(
+        event_queue = [],
+        model_name = "unsloth/Qwen3_6-4B",
+    )
+
+    assert install_mock.call_count == 2
+
+
 def test_mamba_ssm_path_preserves_wheel_first_install_args(monkeypatch):
     install_mock = mock.Mock(return_value = True)
     monkeypatch.setattr(worker, "_install_package_wheel_first", install_mock)
diff --git a/studio/backend/tests/test_vram_estimation.py b/studio/backend/tests/test_vram_estimation.py
index 0be067310d..e54ae6dcf8 100644
--- a/studio/backend/tests/test_vram_estimation.py
+++ b/studio/backend/tests/test_vram_estimation.py
@@ -2,7 +2,9 @@
 # Copyright 2026-present the Unsloth AI Inc. team. All rights reserved.
 
 import unittest
+from dataclasses import replace
 from types import SimpleNamespace
+from unittest.mock import patch
 
 from utils.hardware.vram_estimation import (
     ModelArchConfig,
@@ -116,6 +118,55 @@ GPT_OSS = ModelArchConfig(
     num_dense_layers = 0,
 )
 
+STRUCTURED_MIXED = ModelArchConfig(
+    hidden_size = 256,
+    num_hidden_layers = 6,
+    num_attention_heads = 4,
+    num_key_value_heads = 2,
+    intermediate_size = 512,
+    vocab_size = 1024,
+    tie_word_embeddings = True,
+    head_dim = 80,
+    global_head_dim = 96,
+    num_global_key_value_heads = 1,
+    attention_k_eq_v = True,
+    layer_types = [
+        "sliding_attention",
+        "full_attention",
+        "sliding_attention",
+        "full_attention",
+        "sliding_attention",
+        "full_attention",
+    ],
+)
+
+STRUCTURED_SHARED = ModelArchConfig(
+    hidden_size = 192,
+    num_hidden_layers = 4,
+    num_attention_heads = 6,
+    num_key_value_heads = 2,
+    intermediate_size = 384,
+    vocab_size = 512,
+    tie_word_embeddings = True,
+    head_dim = 32,
+    num_kv_shared_layers = 2,
+    use_double_wide_mlp = True,
+    vocab_size_per_layer_input = 128,
+    hidden_size_per_layer_input = 48,
+    quant_4bit_factor = 3.6,
+)
+
+QUANT_SKIP_STRUCTURED = replace(
+    STRUCTURED_SHARED,
+    quantization_skip_modules = [
+        "model.layers.0.self_attn.q_proj",
+        "language_model.model.layers.1.mlp",
+        "layers.2",
+        "vision_tower",
+        "embed_tokens",
+    ],
+)
+
 
 class TestExtractArchConfig(unittest.TestCase):
     def test_basic_config(self):
@@ -182,6 +233,42 @@ class TestExtractArchConfig(unittest.TestCase):
         arch = extract_arch_config(hf_config)
         self.assertEqual(arch.intermediate_size, 8192)
 
+    def test_structural_and_quantization_fields_are_config_derived(self):
+        hf_config = SimpleNamespace(
+            hidden_size = 256,
+            num_hidden_layers = 2,
+            num_attention_heads = 4,
+            num_key_value_heads = 2,
+            intermediate_size = 512,
+            vocab_size = 1024,
+            tie_word_embeddings = True,
+            head_dim = 80,
+            global_head_dim = 96,
+            num_global_key_value_heads = 1,
+            attention_k_eq_v = True,
+            layer_types = ["sliding_attention", "full_attention"],
+            num_kv_shared_layers = 1,
+            use_double_wide_mlp = True,
+            vocab_size_per_layer_input = 128,
+            hidden_size_per_layer_input = 48,
+            quantization_config = {
+                "bnb_4bit_use_double_quant": True,
+                "llm_int8_skip_modules": ["model.layers.0.self_attn"],
+            },
+        )
+        arch = extract_arch_config(hf_config)
+        self.assertEqual(arch.head_dim, 80)
+        self.assertEqual(arch.global_head_dim, 96)
+        self.assertEqual(arch.num_global_key_value_heads, 1)
+        self.assertTrue(arch.attention_k_eq_v)
+        self.assertEqual(arch.layer_types, ["sliding_attention", "full_attention"])
+        self.assertEqual(arch.num_kv_shared_layers, 1)
+        self.assertTrue(arch.use_double_wide_mlp)
+        self.assertEqual(arch.vocab_size_per_layer_input, 128)
+        self.assertEqual(arch.hidden_size_per_layer_input, 48)
+        self.assertEqual(arch.quantization_skip_modules, ["model.layers.0.self_attn"])
+        self.assertEqual(arch.quant_4bit_factor, 3.6)
+
 
 class TestModelWeightsBytes(unittest.TestCase):
     def test_llama_8b_fp16(self):
@@ -238,6 +325,18 @@ class TestLoraParams(unittest.TestCase):
         ratio = moe_lora / dense_lora
         self.assertAlmostEqual(ratio, 8.0, delta = 0.5)
 
+    def test_structured_moe_mlp_modules_scale_with_experts(self):
+        structured_moe = replace(QWEN3_MOE_30B, head_dim = 128)
+        dense_like = replace(
+            structured_moe,
+            num_experts = None,
+            moe_intermediate_size = None,
+        )
+        target_modules = ["gate_proj", "up_proj", "down_proj"]
+        dense_lora = compute_lora_params(dense_like, 16, target_modules)
+        moe_lora = compute_lora_params(structured_moe, 16, target_modules)
+        self.assertGreater(moe_lora, dense_lora * 20)
+
     def test_attention_modules_same_for_moe(self):
         dense_attn = compute_lora_params(
             LLAMA_8B, 16, ["q_proj", "k_proj", "v_proj", "o_proj"]
@@ -247,6 +346,41 @@ class TestLoraParams(unittest.TestCase):
         )
         self.assertEqual(dense_attn, moe_attn)
 
+    def test_all_linear_uses_default_text_modules(self):
+        text_only = compute_lora_params(STRUCTURED_MIXED, 16, DEFAULT_TARGET_MODULES)
+        all_linear = compute_lora_params(STRUCTURED_MIXED, 16, ["all-linear"])
+        self.assertEqual(all_linear, text_only)
+
+    def test_structural_layer_shapes_are_config_driven(self):
+        unstructured_arch = replace(
+            STRUCTURED_MIXED,
+            head_dim = None,
+            global_head_dim = None,
+            num_global_key_value_heads = None,
+            attention_k_eq_v = False,
+            layer_types = None,
+        )
+        self.assertNotEqual(
+            compute_lora_params(unstructured_arch, 16, ["all-linear"]),
+            compute_lora_params(STRUCTURED_MIXED, 16, ["all-linear"]),
+        )
+        self.assertNotEqual(
+            compute_model_weights_bytes(unstructured_arch, "qlora", True),
+            compute_model_weights_bytes(STRUCTURED_MIXED, "qlora", True),
+        )
+
+    def test_shared_kv_and_per_layer_inputs_change_weight_count(self):
+        unstructured_arch = replace(
+            STRUCTURED_SHARED,
+            head_dim = None,
+            num_kv_shared_layers = 0,
+            use_double_wide_mlp = False,
+        )
+        self.assertNotEqual(
+            compute_model_weights_bytes(unstructured_arch, "qlora", True),
+            compute_model_weights_bytes(STRUCTURED_SHARED, "qlora", True),
+        )
+
 
 class TestOptimizerBytes(unittest.TestCase):
     def test_adamw_8bit(self):
@@ -293,6 +427,163 @@ class TestActivationBytes(unittest.TestCase):
         act_4k = compute_activation_bytes(LLAMA_8B, 2, 4096, "unsloth")
         self.assertAlmostEqual(act_4k / act_2k, 2.0, delta = 0.1)
 
+    def test_flash_attention_uses_linear_path(self):
+        flash = compute_activation_bytes(
+            STRUCTURED_MIXED,
+            1,
+            4096,
+            "unsloth",
+            is_lora = True,
+            attention_implementation = "flash_attention_2",
+        )
+        default = compute_activation_bytes(
+            STRUCTURED_MIXED,
+            1,
+            4096,
+            "unsloth",
+            is_lora = True,
+        )
+        self.assertEqual(flash, default)
+
+    def test_sdpa_attention_uses_linear_path(self):
+        flash = compute_activation_bytes(
+            STRUCTURED_MIXED,
+            1,
+            4096,
+            "unsloth",
+            is_lora = True,
+            attention_implementation = "flash_attention_2",
+        )
+        sdpa = compute_activation_bytes(
+            STRUCTURED_MIXED,
+            1,
+            4096,
+            "unsloth",
+            is_lora = True,
+            attention_implementation = "sdpa",
+        )
+        self.assertEqual(sdpa, flash)
+
+    def test_non_flash_attention_uses_quadratic_path(self):
+        seq_len = 4096
+        expected_quadratic = (
+            1 * STRUCTURED_MIXED.num_attention_heads * seq_len * seq_len * 2 * 12.0
+        )
+        for attention_implementation in ("eager", "unknown_impl", None):
+            with self.subTest(attention_implementation = attention_implementation):
+                non_flash = compute_activation_bytes(
+                    STRUCTURED_MIXED,
+                    1,
+                    seq_len,
+                    "unsloth",
+                    is_lora = True,
+                    attention_implementation = attention_implementation,
+                )
+                self.assertEqual(non_flash, int(expected_quadratic))
+
+    def test_non_flash_attention_without_gc_scales_quadratic_path_by_layers(self):
+        seq_len = 4096
+        one_layer = (
+            1 * STRUCTURED_MIXED.num_attention_heads * seq_len * seq_len * 2 * 12.0
+        )
+        non_flash = compute_activation_bytes(
+            STRUCTURED_MIXED,
+            1,
+            seq_len,
+            "none",
+            is_lora = True,
+            attention_implementation = "eager",
+        )
+        self.assertEqual(non_flash, int(one_layer * STRUCTURED_MIXED.num_hidden_layers))
+        self.assertGreater(non_flash, int(one_layer))
+
+
+class TestQuantizationSkips(unittest.TestCase):
+    def test_skipped_language_layers_stay_fp16(self):
+        no_skips = replace(QUANT_SKIP_STRUCTURED, quantization_skip_modules = [])
+        skipped = compute_model_weights_bytes(QUANT_SKIP_STRUCTURED, "qlora", True)
+        quantized = compute_model_weights_bytes(no_skips, "qlora", True)
+        self.assertGreater(skipped, quantized)
+
+    def test_non_language_skips_do_not_double_count_text_weights(self):
+        arch = replace(
+            QUANT_SKIP_STRUCTURED,
+            quantization_skip_modules = ["vision_tower", "embed_tokens"],
+        )
+        no_skips = replace(QUANT_SKIP_STRUCTURED, quantization_skip_modules = [])
+        self.assertEqual(
+            compute_model_weights_bytes(arch, "qlora", True),
+            compute_model_weights_bytes(no_skips, "qlora", True),
+        )
+
+    def test_double_quant_factor_reduces_quantized_weight_storage(self):
+        default_quant = replace(STRUCTURED_MIXED, quant_4bit_factor = 16 / 5)
+        double_quant = replace(STRUCTURED_MIXED, quant_4bit_factor = 3.6)
+        self.assertLess(
+            compute_model_weights_bytes(double_quant, "qlora", True),
+            compute_model_weights_bytes(default_quant, "qlora", True),
+        )
+
+    def test_prefixed_parent_and_child_skips_do_not_double_count(self):
+        parent_only = replace(
+            QUANT_SKIP_STRUCTURED,
+            quantization_skip_modules = ["language_model.model.layers.1.mlp"],
+        )
+        parent_and_child = replace(
+            QUANT_SKIP_STRUCTURED,
+            quantization_skip_modules = [
+                "language_model.model.layers.1.mlp",
+                "language_model.model.layers.1.mlp.gate_proj",
+                "model.layers.1.mlp.up_proj",
+            ],
+        )
+        self.assertEqual(
+            compute_model_weights_bytes(parent_and_child, "qlora", True),
+            compute_model_weights_bytes(parent_only, "qlora", True),
+        )
+
+    def test_vlm_prefix_skip_module_does_not_match_text_alias(self):
+        # vision_tower-prefixed skips must not shadow text aliases sharing the
+        # same suffix.
+        baseline = replace(QUANT_SKIP_STRUCTURED, quantization_skip_modules = [])
+        vlm_skip = replace(
+            QUANT_SKIP_STRUCTURED,
+            quantization_skip_modules = [
+                "vision_tower.model.layers.0.self_attn.q_proj",
+                "vision_tower.model.layers.1.mlp",
+            ],
+        )
+        self.assertEqual(
+            compute_model_weights_bytes(vlm_skip, "qlora", True),
+            compute_model_weights_bytes(baseline, "qlora", True),
+        )
+
+    def test_mla_skip_module_uses_authoritative_attn_total(self):
+        from utils.hardware.vram_estimation import (
+            _build_text_module_elements,
+            _compute_attn_elements,
+        )
+
+        mla = ModelArchConfig(
+            hidden_size = 2048,
+            num_hidden_layers = 4,
+            num_attention_heads = 16,
+            num_key_value_heads = 16,
+            intermediate_size = 8192,
+            vocab_size = 32000,
+            tie_word_embeddings = False,
+            q_lora_rank = 512,
+            kv_lora_rank = 128,
+            qk_nope_head_dim = 64,
+            qk_rope_head_dim = 32,
+            v_head_dim = 64,
+        )
+        elements, _ = _build_text_module_elements(mla)
+        self.assertEqual(
+            elements["text.layers.0.self_attn"],
+            _compute_attn_elements(mla),
+        )
+
 
 class TestEstimateTrainingVram(unittest.TestCase):
     def test_llama_8b_qlora_reasonable_total(self):
@@ -430,6 +721,90 @@ class TestEstimateTrainingVram(unittest.TestCase):
             v32.optimizer_states / v8.optimizer_states, 1.5, delta = 0.1
         )
 
+    def test_min_gpu_vram_treats_activations_as_per_gpu_fixed(self):
+        config = TrainingVramConfig(training_method = "qlora", load_in_4bit = True)
+        breakdown = estimate_training_vram(LLAMA_8B, config)
+        shardable = (
+            breakdown.model_weights
+            + breakdown.lora_adapters
+            + breakdown.optimizer_states
+            + breakdown.gradients
+        )
+        per_gpu_fixed = breakdown.activations + breakdown.cuda_overhead
+        for n_gpus in (1, 2, 4):
+            self.assertEqual(
+                breakdown.min_gpu_vram(n_gpus),
+                shardable // n_gpus + per_gpu_fixed,
+            )
+
+    def test_qlora_gradient_floor_is_capped_by_trainable_scale(self):
+        config = TrainingVramConfig(
+            training_method = "qlora",
+            batch_size = 1,
+            max_seq_length = 512,
+            lora_rank = 16,
+            target_modules = ["all-linear"],
+            gradient_checkpointing = "unsloth",
+            optimizer = "adamw_8bit",
+            load_in_4bit = True,
+        )
+        breakdown = estimate_training_vram(LLAMA_8B, config)
+        lora_params = compute_lora_params(LLAMA_8B, 16, DEFAULT_TARGET_MODULES)
+        optimizer_bytes = compute_optimizer_bytes(lora_params, "adamw_8bit")
+        weight_floor = int(breakdown.model_weights * 0.15)
+
+        self.assertEqual(
+            breakdown.gradients,
+            max(breakdown.activations_computed, optimizer_bytes),
+        )
+        self.assertLess(breakdown.gradients, weight_floor)
+        self.assertEqual(breakdown.activations, breakdown.activations_computed)
+
+    def test_full_finetuning_gradient_floor_remains_uncapped(self):
+        config = TrainingVramConfig(
+            training_method = "full",
+            batch_size = 1,
+            max_seq_length = 512,
+            gradient_checkpointing = "unsloth",
+            optimizer = "adamw_8bit",
+            load_in_4bit = False,
+        )
+        expected_floor = int(
+            compute_model_weights_bytes(LLAMA_8B, "full", False) * 0.15
+        )
+        with patch(
+            "utils.hardware.vram_estimation.compute_gradient_bytes",
+            return_value = 1,
+        ):
+            breakdown = estimate_training_vram(LLAMA_8B, config)
+        self.assertEqual(breakdown.gradients, expected_floor)
+
+    def test_non_flash_attention_flows_into_training_estimate(self):
+        config = TrainingVramConfig(
+            training_method = "qlora",
+            batch_size = 1,
+            max_seq_length = 4096,
+            lora_rank = 16,
+            target_modules = ["all-linear"],
+            gradient_checkpointing = "unsloth",
+            optimizer = "adamw_8bit",
+            load_in_4bit = True,
+            attention_implementation = "eager",
+        )
+        breakdown = estimate_training_vram(STRUCTURED_MIXED, config)
+        self.assertEqual(breakdown.activations, breakdown.activations_computed)
+        self.assertGreater(
+            breakdown.activations,
+            compute_activation_bytes(
+                STRUCTURED_MIXED,
+                1,
+                4096,
+                "unsloth",
+                is_lora = True,
+                attention_implementation = "flash_attention_2",
+            ),
+        )
+
 
 class TestExtractArchConfigMoE(unittest.TestCase):
     def test_deepseek_v3_shared_experts(self):
@@ -471,11 +846,16 @@ class TestExtractArchConfigMoE(unittest.TestCase):
             moe_intermediate_size = 768,
             decoder_sparse_step = 1,
             mlp_only_layers = [],
+            head_dim = 128,
         )
         arch = extract_arch_config(hf_config)
         self.assertEqual(arch.num_experts, 128)
         self.assertEqual(arch.num_dense_layers, 0)
+        self.assertEqual(arch.head_dim, 128)
         self.assertIsNone(arch.q_lora_rank)
+        total_b = compute_total_params(arch) / 1e9
+        self.assertGreater(total_b, 20)
+        self.assertLess(total_b, 50)
 
     def test_qwen3_moe_with_mlp_only_layers(self):
         hf_config = SimpleNamespace(
@@ -542,6 +922,343 @@ class TestExtractArchConfigMoE(unittest.TestCase):
         self.assertEqual(arch.n_shared_experts, 0)
         self.assertEqual(arch.num_dense_layers, 0)
         self.assertIsNone(arch.q_lora_rank)
+        self.assertFalse(arch.moe_has_dense_mlp)
+
+    def test_enable_moe_block_extracted_as_moe_has_dense_mlp(self):
+        hf_config = SimpleNamespace(
+            hidden_size = 2048,
+            num_hidden_layers = 8,
+            num_attention_heads = 16,
+            num_key_value_heads = 4,
+            intermediate_size = 4096,
+            vocab_size = 32000,
+            tie_word_embeddings = True,
+            num_experts = 8,
+            moe_intermediate_size = 1024,
+            head_dim = 128,
+            layer_types = ["full_attention"] * 8,
+            enable_moe_block = True,
+        )
+        arch = extract_arch_config(hf_config)
+        self.assertTrue(arch.moe_has_dense_mlp)
+
+
+class TestParallelDenseMoE(unittest.TestCase):
+    def _arch(self, **overrides):
+        base = ModelArchConfig(
+            hidden_size = 512,
+            num_hidden_layers = 4,
+            num_attention_heads = 8,
+            num_key_value_heads = 2,
+            intermediate_size = 1024,
+            vocab_size = 1024,
+            tie_word_embeddings = True,
+            num_experts = 8,
+            moe_intermediate_size = 512,
+            num_dense_layers = 0,
+            head_dim = 64,
+            layer_types = ["full_attention"] * 4,
+        )
+        return replace(base, **overrides)
+
+    def test_total_params_includes_parallel_dense_when_enable_moe_block(self):
+        without_parallel = self._arch(moe_has_dense_mlp = False)
+        with_parallel = self._arch(moe_has_dense_mlp = True)
+        self.assertGreater(
+            compute_total_params(with_parallel),
+            compute_total_params(without_parallel),
+        )
+
+    def test_lora_params_includes_parallel_dense_when_enable_moe_block(self):
+        without_parallel = self._arch(moe_has_dense_mlp = False)
+        with_parallel = self._arch(moe_has_dense_mlp = True)
+        target = ["gate_proj", "up_proj", "down_proj"]
+        self.assertGreater(
+            compute_lora_params(with_parallel, 16, target),
+            compute_lora_params(without_parallel, 16, target),
+        )
+
+    def test_activation_bytes_includes_parallel_dense_when_enable_moe_block(self):
+        without_parallel = self._arch(moe_has_dense_mlp = False)
+        with_parallel = self._arch(moe_has_dense_mlp = True)
+        self.assertGreater(
+            compute_activation_bytes(
+                with_parallel,
+                1,
+                2048,
+                "unsloth",
+                is_lora = True,
+            ),
+            compute_activation_bytes(
+                without_parallel,
+                1,
+                2048,
+                "unsloth",
+                is_lora = True,
+            ),
+        )
+
+    def test_layer_aggregates_split_dense_mlp_from_experts(self):
+        from utils.hardware.vram_estimation import _build_text_module_elements
+
+        with_parallel = self._arch(moe_has_dense_mlp = True)
+        elements, _ = _build_text_module_elements(with_parallel)
+        moe_only = (
+            with_parallel.hidden_size
+            * with_parallel.moe_intermediate_size
+            * 3
+            * with_parallel.num_experts
+            + with_parallel.num_experts * with_parallel.hidden_size
+        )
+        dense_only = with_parallel.hidden_size * with_parallel.intermediate_size * 3
+        # why: under gemma4 enable_moe_block, the layer's `self.experts` is a
+        # sibling of `self.mlp`; the `text.layers.<i>.mlp` aggregate must
+        # cover the dense path only, with experts in their own aggregate.
+        self.assertEqual(elements["text.layers.0.mlp"], dense_only)
+        self.assertEqual(elements["text.layers.0.experts"], moe_only)
+
+
+class TestDenseLayerIndices(unittest.TestCase):
+    def test_non_prefix_mlp_only_layers_preserve_position(self):
+        hf_config = SimpleNamespace(
+            hidden_size = 1024,
+            num_hidden_layers = 8,
+            num_attention_heads = 16,
+            num_key_value_heads = 4,
+            intermediate_size = 2048,
+            vocab_size = 32000,
+            tie_word_embeddings = True,
+            num_local_experts = 4,
+            moe_intermediate_size = 512,
+            decoder_sparse_step = 1,
+            mlp_only_layers = [3, 5],
+        )
+        arch = extract_arch_config(hf_config)
+        self.assertEqual(arch.num_dense_layers, 2)
+        self.assertIn(3, arch.dense_layer_indices)
+        self.assertIn(5, arch.dense_layer_indices)
+        self.assertNotIn(0, arch.dense_layer_indices)
+
+    def test_first_k_dense_replace_indices_are_prefix(self):
+        hf_config = SimpleNamespace(
+            hidden_size = 1024,
+            num_hidden_layers = 6,
+            num_attention_heads = 16,
+            num_key_value_heads = 4,
+            intermediate_size = 2048,
+            vocab_size = 32000,
+            tie_word_embeddings = False,
+            n_routed_experts = 8,
+            moe_intermediate_size = 512,
+            first_k_dense_replace = 2,
+        )
+        arch = extract_arch_config(hf_config)
+        self.assertEqual(tuple(arch.dense_layer_indices), (0, 1))
+
+
+class TestKvSharedLayer(unittest.TestCase):
+    def test_fully_shared_kv_returns_false_matching_upstream(self):
+        from utils.hardware.vram_estimation import _is_kv_shared_layer
+
+        arch = ModelArchConfig(
+            hidden_size = 512,
+            num_hidden_layers = 4,
+            num_attention_heads = 8,
+            num_key_value_heads = 2,
+            intermediate_size = 1024,
+            vocab_size = 1024,
+            num_kv_shared_layers = 4,
+        )
+        for i in range(arch.num_hidden_layers):
+            self.assertFalse(_is_kv_shared_layer(arch, i))
+
+    def test_partial_share_returns_true_for_tail_layers(self):
+        from utils.hardware.vram_estimation import _is_kv_shared_layer
+
+        arch = ModelArchConfig(
+            hidden_size = 512,
+            num_hidden_layers = 4,
+            num_attention_heads = 8,
+            num_key_value_heads = 2,
+            intermediate_size = 1024,
+            vocab_size = 1024,
+            num_kv_shared_layers = 2,
+        )
+        self.assertFalse(_is_kv_shared_layer(arch, 0))
+        self.assertFalse(_is_kv_shared_layer(arch, 1))
+        self.assertTrue(_is_kv_shared_layer(arch, 2))
+        self.assertTrue(_is_kv_shared_layer(arch, 3))
+
+
+class TestFlexAttentionLinear(unittest.TestCase):
+    def test_flex_attention_treated_as_linear(self):
+        flash = compute_activation_bytes(
+            STRUCTURED_MIXED,
+            1,
+            4096,
+            "unsloth",
+            is_lora = True,
+            attention_implementation = "flash_attention_2",
+        )
+        flex = compute_activation_bytes(
+            STRUCTURED_MIXED,
+            1,
+            4096,
+            "unsloth",
+            is_lora = True,
+            attention_implementation = "flex_attention",
+        )
+        self.assertEqual(flex, flash)
+
+
+class TestNonStructuredParallelDense(unittest.TestCase):
+    def _arch(self, **overrides):
+        base = ModelArchConfig(
+            hidden_size = 1024,
+            num_hidden_layers = 4,
+            num_attention_heads = 16,
+            num_key_value_heads = 4,
+            intermediate_size = 4096,
+            vocab_size = 32000,
+            tie_word_embeddings = False,
+            num_experts = 8,
+            moe_intermediate_size = 768,
+            num_dense_layers = 0,
+            moe_has_dense_mlp = True,
+        )
+        return replace(base, **overrides)
+
+    def test_skip_module_uses_intermediate_size_for_parallel_dense(self):
+        from utils.hardware.vram_estimation import _build_text_module_elements
+
+        arch = self._arch()
+        elements, _ = _build_text_module_elements(arch)
+        gate_proj = elements["text.layers.0.mlp.gate_proj"]
+        self.assertEqual(gate_proj, arch.hidden_size * arch.intermediate_size)
+
+
+class TestPerLayerInputAccounting(unittest.TestCase):
+    def _arch(self, **overrides):
+        base = ModelArchConfig(
+            hidden_size = 1024,
+            num_hidden_layers = 4,
+            num_attention_heads = 16,
+            num_key_value_heads = 4,
+            intermediate_size = 2048,
+            vocab_size = 32000,
+            tie_word_embeddings = False,
+            head_dim = 64,
+            layer_types = ["full_attention"] * 4,
+            vocab_size_per_layer_input = 256,
+            hidden_size_per_layer_input = 96,
+        )
+        return replace(base, **overrides)
+
+    def test_per_layer_input_increases_total_params(self):
+        with_ple = self._arch()
+        without_ple = replace(with_ple, hidden_size_per_layer_input = 0)
+        self.assertGreater(
+            compute_total_params(with_ple),
+            compute_total_params(without_ple),
+        )
+
+    def test_per_layer_input_modules_count_quantizable_block(self):
+        with_ple = self._arch()
+        without_ple = replace(with_ple, hidden_size_per_layer_input = 0)
+        # The PLE block adds: model_projection (hd*nl*pli), per_layer_input_gate
+        # (hd*pli per layer) + per_layer_projection (pli*hd per layer) as
+        # quantizable text linears.
+        n_layers = with_ple.num_hidden_layers
+        hd = with_ple.hidden_size
+        pli = with_ple.hidden_size_per_layer_input
+        expected_quantizable_extra = (
+            hd * (n_layers * pli) + (hd * pli) * n_layers + (pli * hd) * n_layers
+        )
+        delta = compute_total_params(with_ple) - compute_total_params(without_ple)
+        self.assertGreaterEqual(delta, expected_quantizable_extra)
+
+    def test_all_linear_lora_excludes_per_layer_input_modules(self):
+        # why: Unsloth's get_peft_regex requires module names to contain a
+        # component tag (mlp/attn/...); PLE module names (per_layer_input_gate,
+        # per_layer_projection, per_layer_model_projection) lack any tag, so
+        # all-linear training does NOT attach LoRA to them.
+        arch = self._arch()
+        without_ple = replace(arch, hidden_size_per_layer_input = 0)
+        self.assertEqual(
+            compute_lora_params(arch, 16, ["all-linear"]),
+            compute_lora_params(without_ple, 16, ["all-linear"]),
+        )
+
+    def test_explicit_target_modules_does_not_add_per_layer_input(self):
+        arch = self._arch()
+        without_ple = replace(arch, hidden_size_per_layer_input = 0)
+        self.assertEqual(
+            compute_lora_params(arch, 16, ["q_proj", "v_proj"]),
+            compute_lora_params(without_ple, 16, ["q_proj", "v_proj"]),
+        )
+
+
+class TestDenseMlpLayerFallback(unittest.TestCase):
+    def test_falls_back_to_count_when_indices_empty(self):
+        from utils.hardware.vram_estimation import _is_dense_mlp_layer
+
+        arch = ModelArchConfig(
+            hidden_size = 512,
+            num_hidden_layers = 4,
+            num_attention_heads = 8,
+            num_key_value_heads = 2,
+            intermediate_size = 1024,
+            vocab_size = 1024,
+            num_experts = 4,
+            moe_intermediate_size = 256,
+            num_dense_layers = 2,
+        )
+        self.assertTrue(_is_dense_mlp_layer(arch, 0))
+        self.assertTrue(_is_dense_mlp_layer(arch, 1))
+        self.assertFalse(_is_dense_mlp_layer(arch, 2))
+        self.assertFalse(_is_dense_mlp_layer(arch, 3))
+
+
+class TestExpertsSkipGranularity(unittest.TestCase):
+    def _arch(self):
+        return ModelArchConfig(
+            hidden_size = 512,
+            num_hidden_layers = 4,
+            num_attention_heads = 8,
+            num_key_value_heads = 2,
+            intermediate_size = 1024,
+            vocab_size = 1024,
+            tie_word_embeddings = True,
+            num_experts = 8,
+            moe_intermediate_size = 512,
+            num_dense_layers = 0,
+            head_dim = 64,
+            layer_types = ["full_attention"] * 4,
+            moe_has_dense_mlp = True,
+        )
+
+    def test_experts_skip_excludes_parallel_dense_projections(self):
+        no_skip = self._arch()
+        skip_experts = replace(
+            no_skip,
+            quantization_skip_modules = ["model.layers.0.mlp.experts"],
+        )
+        skip_full_mlp = replace(
+            no_skip,
+            quantization_skip_modules = ["model.layers.0.mlp"],
+        )
+        bytes_no_skip = compute_model_weights_bytes(no_skip, "qlora", True)
+        bytes_skip_experts = compute_model_weights_bytes(skip_experts, "qlora", True)
+        bytes_skip_mlp = compute_model_weights_bytes(skip_full_mlp, "qlora", True)
+        # why: under gemma4 enable_moe_block, `self.experts` is a sibling of
+        # `self.mlp`; skipping `model.layers.0.mlp` should cover only the
+        # dense MLP, while `model.layers.0.mlp.experts` covers the routed
+        # experts. Routed experts have far more params than the dense MLP,
+        # so skipping experts must add more bytes than skipping the dense
+        # path.
+        self.assertGreater(bytes_skip_experts, bytes_no_skip)
+        self.assertGreater(bytes_skip_mlp, bytes_no_skip)
+        self.assertGreater(bytes_skip_experts, bytes_skip_mlp)
 
 
 class TestSharedExperts(unittest.TestCase):
@@ -608,6 +1325,16 @@ class TestMLA(unittest.TestCase):
         lora_p = compute_lora_params(DEEPSEEK_V3, 16, ["q_proj", "v_proj", "o_proj"])
         self.assertGreater(lora_p, 0)
 
+    def test_mla_with_head_dim_does_not_route_through_structured(self):
+        from utils.hardware.vram_estimation import _uses_structured_layer_shapes
+
+        mla_with_head_dim = replace(DEEPSEEK_V3, head_dim = 128)
+        self.assertFalse(_uses_structured_layer_shapes(mla_with_head_dim))
+        self.assertEqual(
+            compute_lora_params(DEEPSEEK_V3, 16, ["q_proj", "v_proj", "o_proj"]),
+            compute_lora_params(mla_with_head_dim, 16, ["q_proj", "v_proj", "o_proj"]),
+        )
+
 
 class TestDenseMoEMix(unittest.TestCase):
     def test_dense_layers_change_total(self):
@@ -691,5 +1418,952 @@ class TestDenseMoEMix(unittest.TestCase):
         self.assertNotEqual(lora_all, lora_mix)
 
 
+class TestMlpLayerTypesDispatch(unittest.TestCase):
+    def _hf(self, **fields):
+        text_config = SimpleNamespace(
+            hidden_size = 64,
+            num_hidden_layers = 4,
+            num_attention_heads = 4,
+            num_key_value_heads = 4,
+            intermediate_size = 128,
+            vocab_size = 1000,
+            tie_word_embeddings = True,
+            num_local_experts = 4,
+            moe_intermediate_size = 32,
+            **fields,
+        )
+        return SimpleNamespace(text_config = text_config, quantization_config = {})
+
+    def test_mlp_layer_types_drives_dense_indices(self):
+        hf = self._hf(mlp_layer_types = ["sparse", "dense", "sparse", "dense"])
+        arch = extract_arch_config(hf)
+        self.assertIsNotNone(arch)
+        self.assertEqual(arch.dense_layer_indices, (1, 3))
+        self.assertEqual(arch.num_dense_layers, 2)
+
+    def test_mlp_layer_types_takes_priority_over_first_k_dense_replace(self):
+        hf = self._hf(
+            mlp_layer_types = ["dense", "sparse", "dense", "sparse"],
+            first_k_dense_replace = 3,
+        )
+        arch = extract_arch_config(hf)
+        self.assertEqual(arch.dense_layer_indices, (0, 2))
+
+    def test_mlp_layer_types_ignores_unknown_entries(self):
+        hf = self._hf(mlp_layer_types = ["dense", "moe", "dense", "linear"])
+        arch = extract_arch_config(hf)
+        self.assertEqual(arch.dense_layer_indices, (0, 2))
+
+    def test_mlp_layer_types_shorter_than_layers_only_marks_present(self):
+        hf = self._hf(mlp_layer_types = ["dense", "sparse"])
+        arch = extract_arch_config(hf)
+        self.assertEqual(arch.dense_layer_indices, (0,))
+
+    def test_empty_mlp_layer_types_falls_through_to_first_k(self):
+        hf = self._hf(mlp_layer_types = [], first_k_dense_replace = 2)
+        arch = extract_arch_config(hf)
+        self.assertEqual(arch.dense_layer_indices, (0, 1))
+
+
+class TestPerLayerInputSkipAlias(unittest.TestCase):
+    def _hf(self, skip):
+        text_config = SimpleNamespace(
+            hidden_size = 64,
+            num_hidden_layers = 2,
+            num_attention_heads = 4,
+            num_key_value_heads = 4,
+            intermediate_size = 128,
+            vocab_size = 1000,
+            tie_word_embeddings = True,
+            hidden_size_per_layer_input = 8,
+            vocab_size_per_layer_input = 256,
+        )
+        return SimpleNamespace(
+            text_config = text_config,
+            quantization_config = {"llm_int8_skip_modules": list(skip)},
+        )
+
+    def test_per_layer_input_gate_skip_pulls_nonzero_delta(self):
+        from utils.hardware.vram_estimation import _compute_skipped_quantizable_elements
+
+        arch = extract_arch_config(self._hf(["model.layers.0.per_layer_input_gate"]))
+        delta = _compute_skipped_quantizable_elements(arch)
+        self.assertEqual(delta, arch.hidden_size * arch.hidden_size_per_layer_input)
+
+    def test_per_layer_model_projection_skip_pulls_global_delta(self):
+        from utils.hardware.vram_estimation import _compute_skipped_quantizable_elements
+
+        arch = extract_arch_config(self._hf(["model.per_layer_model_projection"]))
+        delta = _compute_skipped_quantizable_elements(arch)
+        self.assertEqual(
+            delta,
+            arch.hidden_size
+            * arch.num_hidden_layers
+            * arch.hidden_size_per_layer_input,
+        )
+
+    def test_layer_aggregate_skip_includes_per_layer_input_modules(self):
+        from utils.hardware.vram_estimation import (
+            _compute_skipped_quantizable_elements,
+        )
+
+        arch_with = extract_arch_config(self._hf(["model.layers.0"]))
+        # The text.layers.0 aggregate must include the PLE per-layer modules,
+        # so the same skip on a config without PLE produces a smaller value.
+        arch_without = extract_arch_config(
+            SimpleNamespace(
+                text_config = SimpleNamespace(
+                    hidden_size = 64,
+                    num_hidden_layers = 2,
+                    num_attention_heads = 4,
+                    num_key_value_heads = 4,
+                    intermediate_size = 128,
+                    vocab_size = 1000,
+                    tie_word_embeddings = True,
+                    hidden_size_per_layer_input = 0,
+                    vocab_size_per_layer_input = 0,
+                ),
+                quantization_config = {"llm_int8_skip_modules": ["model.layers.0"]},
+            )
+        )
+        self.assertGreater(
+            _compute_skipped_quantizable_elements(arch_with),
+            _compute_skipped_quantizable_elements(arch_without),
+        )
+
+
+class TestAllLinearStringHandling(unittest.TestCase):
+    def test_compute_lora_params_accepts_bare_all_linear_string(self):
+        list_form = compute_lora_params(LLAMA_8B, 16, ["all-linear"])
+        str_form = compute_lora_params(LLAMA_8B, 16, "all-linear")
+        self.assertEqual(list_form, str_form)
+        self.assertGreater(list_form, 0)
+
+    def test_compute_lora_params_string_with_underscores_normalized(self):
+        list_form = compute_lora_params(LLAMA_8B, 16, ["all_linear"])
+        str_form = compute_lora_params(LLAMA_8B, 16, "all_linear")
+        self.assertEqual(list_form, str_form)
+        self.assertGreater(str_form, 0)
+
+
+class TestSharedExpertVariants(unittest.TestCase):
+    def _hf(self, **fields):
+        text_config = SimpleNamespace(
+            hidden_size = 256,
+            num_hidden_layers = 4,
+            num_attention_heads = 8,
+            num_key_value_heads = 4,
+            intermediate_size = 1024,
+            vocab_size = 1000,
+            tie_word_embeddings = False,
+            num_local_experts = 8,
+            moe_intermediate_size = 128,
+            **fields,
+        )
+        return SimpleNamespace(text_config = text_config, quantization_config = {})
+
+    def test_shared_expert_intermediate_size_extracted_and_infers_count(self):
+        arch = extract_arch_config(self._hf(shared_expert_intermediate_size = 64))
+        self.assertEqual(arch.shared_expert_intermediate_size, 64)
+        self.assertEqual(arch.n_shared_experts, 1)
+
+    def test_num_shared_experts_alias_extracted(self):
+        arch = extract_arch_config(self._hf(num_shared_experts = 2))
+        self.assertEqual(arch.n_shared_experts, 2)
+
+    def test_n_shared_experts_takes_priority_over_alias(self):
+        arch = extract_arch_config(self._hf(n_shared_experts = 3, num_shared_experts = 99))
+        self.assertEqual(arch.n_shared_experts, 3)
+
+    def test_shared_expert_size_separate_from_routed_changes_weight_count(self):
+        from utils.hardware.vram_estimation import _compute_moe_mlp_elements
+
+        arch_separate = extract_arch_config(
+            self._hf(shared_expert_intermediate_size = 64)
+        )
+        arch_implicit = extract_arch_config(self._hf(n_shared_experts = 1))
+        # Different shared sizes (64 vs default moe_intermediate_size=128) must
+        # produce different MoE element counts.
+        self.assertNotEqual(
+            _compute_moe_mlp_elements(arch_separate),
+            _compute_moe_mlp_elements(arch_implicit),
+        )
+
+    def test_shared_expert_gate_counted_only_for_qwen_style(self):
+        from utils.hardware.vram_estimation import _compute_moe_mlp_elements
+
+        # Qwen-style: shared_expert_intermediate_size set -> shared_expert_gate counted.
+        qwen_arch = extract_arch_config(self._hf(shared_expert_intermediate_size = 64))
+        hd = qwen_arch.hidden_size
+        ms = qwen_arch.moe_intermediate_size
+        ne = qwen_arch.num_experts
+        ss = qwen_arch.shared_expert_intermediate_size
+        expected = hd * ms * 3 * ne + ne * hd + hd * ss * 3 * 1 + 1 * hd
+        self.assertEqual(_compute_moe_mlp_elements(qwen_arch), expected)
+
+        # Non-Qwen shared experts (e.g. Exaone-MoE) -> no shared_expert_gate.
+        plain_arch = extract_arch_config(self._hf(n_shared_experts = 1))
+        hd = plain_arch.hidden_size
+        ms = plain_arch.moe_intermediate_size
+        ne = plain_arch.num_experts
+        expected_plain = hd * ms * 3 * ne + ne * hd + hd * ms * 3 * 1
+        self.assertEqual(_compute_moe_mlp_elements(plain_arch), expected_plain)
+
+
+class TestSharedExpertActivation(unittest.TestCase):
+    def _make(self, **fields):
+        text_config = SimpleNamespace(
+            hidden_size = 512,
+            num_hidden_layers = 4,
+            num_attention_heads = 8,
+            num_key_value_heads = 4,
+            intermediate_size = 1024,
+            vocab_size = 1000,
+            tie_word_embeddings = False,
+            num_local_experts = 4,
+            moe_intermediate_size = 64,
+            **fields,
+        )
+        return extract_arch_config(
+            SimpleNamespace(text_config = text_config, quantization_config = {})
+        )
+
+    def test_shared_expert_increases_activation_bytes(self):
+        with_shared = self._make(shared_expert_intermediate_size = 64)
+        without = self._make()
+        self.assertGreater(
+            compute_activation_bytes(
+                with_shared,
+                2,
+                1024,
+                "none",
+                is_lora = True,
+                attention_implementation = "flash_attention_2",
+            ),
+            compute_activation_bytes(
+                without,
+                2,
+                1024,
+                "none",
+                is_lora = True,
+                attention_implementation = "flash_attention_2",
+            ),
+        )
+
+    def test_shared_expert_plus_dense_block_compose(self):
+        # gemma4 enable_moe_block with hypothetical shared expert: dense + routed
+        # + shared all live per layer; mlp_size should sum all three terms.
+        from utils.hardware.vram_estimation import _layer_qkv_mlp_sizes
+
+        arch = self._make(
+            enable_moe_block = True,
+            shared_expert_intermediate_size = 32,
+            head_dim = 64,
+            layer_types = ["full_attention"] * 4,
+        )
+        _, mlp_size = _layer_qkv_mlp_sizes(arch, 0)
+        # routed (64) + shared (32) + parallel dense intermediate (1024)
+        self.assertEqual(mlp_size, 64 + 32 + 1024)
+
+
+class TestPerLayerInputActivation(unittest.TestCase):
+    def _make(self, **fields):
+        text_config = SimpleNamespace(
+            hidden_size = 512,
+            num_hidden_layers = 4,
+            num_attention_heads = 8,
+            num_key_value_heads = 4,
+            intermediate_size = 1024,
+            vocab_size = 1000,
+            tie_word_embeddings = False,
+            **fields,
+        )
+        return extract_arch_config(
+            SimpleNamespace(text_config = text_config, quantization_config = {})
+        )
+
+    def test_ple_increases_activation_bytes(self):
+        with_ple = self._make(
+            hidden_size_per_layer_input = 64,
+            vocab_size_per_layer_input = 256,
+        )
+        without = self._make()
+        self.assertGreater(
+            compute_activation_bytes(
+                with_ple,
+                2,
+                1024,
+                "none",
+                is_lora = True,
+                attention_implementation = "flash_attention_2",
+            ),
+            compute_activation_bytes(
+                without,
+                2,
+                1024,
+                "none",
+                is_lora = True,
+                attention_implementation = "flash_attention_2",
+            ),
+        )
+
+    def test_ple_zero_does_not_inflate_activations(self):
+        without = self._make(hidden_size_per_layer_input = 0)
+        baseline = self._make()
+        self.assertEqual(
+            compute_activation_bytes(
+                without,
+                2,
+                512,
+                "none",
+                is_lora = True,
+                attention_implementation = "flash_attention_2",
+            ),
+            compute_activation_bytes(
+                baseline,
+                2,
+                512,
+                "none",
+                is_lora = True,
+                attention_implementation = "flash_attention_2",
+            ),
+        )
+
+
+class TestKvSharedActivation(unittest.TestCase):
+    def _make(self, kv_shared):
+        text_config = SimpleNamespace(
+            hidden_size = 512,
+            num_hidden_layers = 4,
+            num_attention_heads = 8,
+            num_key_value_heads = 4,
+            intermediate_size = 1024,
+            vocab_size = 1000,
+            tie_word_embeddings = False,
+            head_dim = 64,
+            num_kv_shared_layers = kv_shared,
+            layer_types = ["full_attention"] * 4,
+        )
+        return extract_arch_config(
+            SimpleNamespace(text_config = text_config, quantization_config = {})
+        )
+
+    def test_kv_shared_layers_keep_activation_bytes(self):
+        shared = self._make(kv_shared = 2)
+        full = self._make(kv_shared = 0)
+        self.assertEqual(
+            compute_activation_bytes(
+                shared,
+                2,
+                1024,
+                "none",
+                is_lora = True,
+                attention_implementation = "flash_attention_2",
+            ),
+            compute_activation_bytes(
+                full,
+                2,
+                1024,
+                "none",
+                is_lora = True,
+                attention_implementation = "flash_attention_2",
+            ),
+        )
+
+
+class TestSparseMoeSkipAliases(unittest.TestCase):
+    def _hf(self, skip, **fields):
+        text_config = SimpleNamespace(
+            hidden_size = 128,
+            num_hidden_layers = 2,
+            num_attention_heads = 4,
+            num_key_value_heads = 4,
+            intermediate_size = 256,
+            vocab_size = 1000,
+            tie_word_embeddings = False,
+            num_local_experts = 4,
+            moe_intermediate_size = 64,
+            **fields,
+        )
+        return SimpleNamespace(
+            text_config = text_config,
+            quantization_config = {"llm_int8_skip_modules": list(skip)},
+        )
+
+    def test_gemma4_layers_experts_alias_pulls_routed(self):
+        from utils.hardware.vram_estimation import _compute_skipped_quantizable_elements
+
+        arch = extract_arch_config(
+            self._hf(["model.layers.0.experts"], enable_moe_block = True)
+        )
+        self.assertGreater(_compute_skipped_quantizable_elements(arch), 0)
+
+    def test_qwen_shared_expert_skip_pulls_only_shared(self):
+        from utils.hardware.vram_estimation import _compute_skipped_quantizable_elements
+
+        arch = extract_arch_config(
+            self._hf(
+                ["model.layers.0.mlp.shared_expert"],
+                shared_expert_intermediate_size = 32,
+            )
+        )
+        # shared_expert delta only -- routed mlp.experts is NOT skipped.
+        delta = _compute_skipped_quantizable_elements(arch)
+        self.assertGreater(delta, 0)
+        full_layer = extract_arch_config(
+            self._hf(
+                ["model.layers.0.mlp"],
+                shared_expert_intermediate_size = 32,
+            )
+        )
+        self.assertGreater(
+            _compute_skipped_quantizable_elements(full_layer),
+            delta,
+        )
+
+    def test_exaone_shared_experts_plural_alias(self):
+        from utils.hardware.vram_estimation import _compute_skipped_quantizable_elements
+
+        arch = extract_arch_config(
+            self._hf(
+                ["model.layers.0.mlp.shared_experts"],
+                num_shared_experts = 1,
+            )
+        )
+        self.assertGreater(_compute_skipped_quantizable_elements(arch), 0)
+
+
+class TestAllLinearMoELoraExclusion(unittest.TestCase):
+    def _arch(self, **fields):
+        text_config = SimpleNamespace(
+            hidden_size = 256,
+            num_hidden_layers = 2,
+            num_attention_heads = 4,
+            num_key_value_heads = 4,
+            intermediate_size = 512,
+            vocab_size = 1000,
+            tie_word_embeddings = False,
+            num_local_experts = 8,
+            moe_intermediate_size = 64,
+            **fields,
+        )
+        return extract_arch_config(
+            SimpleNamespace(text_config = text_config, quantization_config = {})
+        )
+
+    def test_all_linear_drops_routed_moe_expert_lora(self):
+        arch = self._arch()
+        all_linear = compute_lora_params(arch, 8, "all-linear")
+        explicit = compute_lora_params(arch, 8, ["gate_proj", "up_proj", "down_proj"])
+        self.assertLess(all_linear, explicit)
+
+    def test_all_linear_drops_shared_expert_lora(self):
+        arch = self._arch(shared_expert_intermediate_size = 32)
+        all_linear = compute_lora_params(arch, 8, "all-linear")
+        explicit = compute_lora_params(arch, 8, ["gate_proj", "up_proj", "down_proj"])
+        # explicit includes routed + shared MoE; all-linear includes neither.
+        self.assertLess(all_linear, explicit)
+
+    def test_all_linear_includes_attention_lora(self):
+        arch = self._arch()
+        all_linear = compute_lora_params(arch, 8, "all-linear")
+        attn_only = compute_lora_params(
+            arch, 8, ["q_proj", "k_proj", "v_proj", "o_proj"]
+        )
+        # all-linear still attaches to attention nn.Linear modules.
+        self.assertGreaterEqual(all_linear, attn_only)
+
+
+class TestExplicitPerLayerInputLora(unittest.TestCase):
+    def _arch(self):
+        text_config = SimpleNamespace(
+            hidden_size = 256,
+            num_hidden_layers = 3,
+            num_attention_heads = 4,
+            num_key_value_heads = 4,
+            intermediate_size = 512,
+            vocab_size = 1000,
+            tie_word_embeddings = False,
+            hidden_size_per_layer_input = 32,
+            vocab_size_per_layer_input = 128,
+        )
+        return extract_arch_config(
+            SimpleNamespace(text_config = text_config, quantization_config = {})
+        )
+
+    def test_explicit_per_layer_input_gate_returns_nonzero(self):
+        arch = self._arch()
+        result = compute_lora_params(arch, 16, ["per_layer_input_gate"])
+        self.assertGreater(result, 0)
+
+    def test_explicit_per_layer_projection_returns_nonzero(self):
+        arch = self._arch()
+        result = compute_lora_params(arch, 16, ["per_layer_projection"])
+        self.assertGreater(result, 0)
+
+    def test_explicit_per_layer_model_projection_returns_nonzero(self):
+        arch = self._arch()
+        result = compute_lora_params(arch, 16, ["per_layer_model_projection"])
+        self.assertGreater(result, 0)
+
+    def test_explicit_ple_string_target_handled(self):
+        # Bare-string target with a PLE name should not be iterated char-by-char.
+        arch = self._arch()
+        list_form = compute_lora_params(arch, 16, ["per_layer_input_gate"])
+        str_form = compute_lora_params(arch, 16, "per_layer_input_gate")
+        self.assertEqual(list_form, str_form)
+
+
+class TestTopKExpertActivation(unittest.TestCase):
+    def _make(self, **fields):
+        text_config = SimpleNamespace(
+            hidden_size = 512,
+            num_hidden_layers = 4,
+            num_attention_heads = 8,
+            num_key_value_heads = 4,
+            intermediate_size = 1024,
+            vocab_size = 1000,
+            tie_word_embeddings = False,
+            num_local_experts = 8,
+            moe_intermediate_size = 64,
+            **fields,
+        )
+        return extract_arch_config(
+            SimpleNamespace(text_config = text_config, quantization_config = {})
+        )
+
+    def test_num_experts_per_tok_extracted(self):
+        arch = self._make(num_experts_per_tok = 4)
+        self.assertEqual(arch.num_experts_per_tok, 4)
+
+    def test_top_k_experts_alias_extracted(self):
+        arch = self._make(top_k_experts = 8)
+        self.assertEqual(arch.num_experts_per_tok, 8)
+
+    def test_default_top_k_one_unchanged(self):
+        arch = self._make()
+        self.assertEqual(arch.num_experts_per_tok, 1)
+
+    def test_top_k_scales_moe_activation(self):
+        single = self._make()
+        multi = self._make(num_experts_per_tok = 8)
+        single_act = compute_activation_bytes(
+            single,
+            2,
+            512,
+            "none",
+            is_lora = True,
+            attention_implementation = "flash_attention_2",
+        )
+        multi_act = compute_activation_bytes(
+            multi,
+            2,
+            512,
+            "none",
+            is_lora = True,
+            attention_implementation = "flash_attention_2",
+        )
+        self.assertGreater(multi_act, single_act)
+
+
+class TestErnieMoEListConfig(unittest.TestCase):
+    def _hf(self, **fields):
+        text_config = SimpleNamespace(
+            hidden_size = 256,
+            num_hidden_layers = 4,
+            num_attention_heads = 4,
+            num_key_value_heads = 4,
+            intermediate_size = 1024,
+            vocab_size = 1000,
+            tie_word_embeddings = False,
+            **fields,
+        )
+        return SimpleNamespace(text_config = text_config, quantization_config = {})
+
+    def test_list_moe_intermediate_size_scalarized(self):
+        arch = extract_arch_config(
+            self._hf(
+                moe_num_experts = 32,
+                moe_intermediate_size = [1536, 512],
+            )
+        )
+        # why: ERNIE 4.5 VL MoE encodes [text_routed, vision_routed]; the
+        # second element is the vision-routed expert width, not the shared
+        # expert width. Shared experts are sized from the text-routed width
+        # (= moe_intermediate_size[0]) when moe_num_shared_experts is set.
+        self.assertEqual(arch.moe_intermediate_size, 1536)
+        self.assertIsNone(arch.shared_expert_intermediate_size)
+        self.assertEqual(arch.n_shared_experts, 0)
+
+    def test_moe_num_experts_alias_extracted(self):
+        arch = extract_arch_config(
+            self._hf(
+                moe_num_experts = 64,
+                moe_intermediate_size = 1024,
+            )
+        )
+        self.assertEqual(arch.num_experts, 64)
+
+    def test_moe_num_shared_experts_alias_extracted(self):
+        arch = extract_arch_config(
+            self._hf(
+                moe_num_experts = 16,
+                moe_num_shared_experts = 2,
+                moe_intermediate_size = 1024,
+            )
+        )
+        self.assertEqual(arch.n_shared_experts, 2)
+
+    def test_explicit_shared_size_overrides_list_second_element(self):
+        arch = extract_arch_config(
+            self._hf(
+                moe_num_experts = 8,
+                moe_intermediate_size = [1536, 512],
+                shared_expert_intermediate_size = 256,
+            )
+        )
+        # Explicit shared size wins over moe_intermediate_size[1].
+        self.assertEqual(arch.shared_expert_intermediate_size, 256)
+
+
+class TestSuffixSkipModuleMatch(unittest.TestCase):
+    def _hf(self, skip):
+        text_config = SimpleNamespace(
+            hidden_size = 128,
+            num_hidden_layers = 2,
+            num_attention_heads = 4,
+            num_key_value_heads = 4,
+            intermediate_size = 256,
+            vocab_size = 1000,
+            tie_word_embeddings = False,
+        )
+        return SimpleNamespace(
+            text_config = text_config,
+            quantization_config = {"llm_int8_skip_modules": list(skip)},
+        )
+
+    def test_q_proj_suffix_skip_matches_all_layers(self):
+        from utils.hardware.vram_estimation import _compute_skipped_quantizable_elements
+
+        arch = extract_arch_config(self._hf(["q_proj"]))
+        delta = _compute_skipped_quantizable_elements(arch)
+        # 2 layers * hd * hd of q_proj weight elements.
+        self.assertEqual(delta, 2 * arch.hidden_size * arch.hidden_size)
+
+    def test_self_attn_aggregate_skip_matches_aggregate(self):
+        from utils.hardware.vram_estimation import _compute_skipped_quantizable_elements
+
+        arch = extract_arch_config(self._hf(["self_attn"]))
+        # The aggregate text.layers.<i>.self_attn matches; total covers both layers.
+        delta = _compute_skipped_quantizable_elements(arch)
+        self.assertGreater(delta, 0)
+
+    def test_vision_prefix_skip_does_not_match_text_alias(self):
+        from utils.hardware.vram_estimation import _module_path_matches
+
+        # vision_tower-prefixed full path must NOT match text-tower aliases.
+        self.assertFalse(
+            _module_path_matches(
+                "vision_tower.model.layers.0.self_attn.q_proj",
+                "model.layers.0.self_attn.q_proj",
+            )
+        )
+
+
+class TestMultimodalFullModelBytes(unittest.TestCase):
+    def test_extra_bytes_added_when_safetensors_exceeds_text_arch(self):
+        from utils.hardware import hardware as hardware_module
+
+        config = SimpleNamespace(
+            hidden_size = 1024,
+            num_hidden_layers = 4,
+            num_attention_heads = 8,
+            num_key_value_heads = 4,
+            intermediate_size = 2048,
+            vocab_size = 32000,
+            tie_word_embeddings = False,
+        )
+        # Force safetensors size >>> arch text-only bytes.
+        big_safetensors = 20 * 1024**3
+        with (
+            patch.object(
+                hardware_module,
+                "_load_config_for_gpu_estimate",
+                return_value = config,
+            ),
+            patch.object(
+                hardware_module,
+                "estimate_fp16_model_size_bytes",
+                return_value = (big_safetensors, "safetensors"),
+            ),
+            patch.object(
+                hardware_module,
+                "_determine_attention_impl_for_gpu_estimate",
+                return_value = "flash_attention_2",
+            ),
+            patch.object(
+                hardware_module,
+                "get_visible_gpu_count",
+                return_value = 1,
+            ),
+        ):
+            _, metadata = hardware_module.estimate_required_model_memory_gb(
+                "fake/model",
+                training_type = "LoRA/QLoRA",
+                load_in_4bit = True,
+            )
+        self.assertEqual(metadata.get("estimation_mode"), "detailed")
+        # model_weights_gb must reflect the extra non-text bytes (>5 GB
+        # since text-only arch_fp16 is small for these dims).
+        self.assertGreater(metadata["vram_breakdown"]["model_weights_gb"], 5.0)
+
+    def test_no_extra_when_safetensors_smaller_than_text_arch(self):
+        from utils.hardware import hardware as hardware_module
+
+        config = SimpleNamespace(
+            hidden_size = 4096,
+            num_hidden_layers = 32,
+            num_attention_heads = 32,
+            num_key_value_heads = 8,
+            intermediate_size = 11008,
+            vocab_size = 32000,
+            tie_word_embeddings = False,
+        )
+        tiny_safetensors = 100  # bytes, deliberately absurdly small
+        with (
+            patch.object(
+                hardware_module,
+                "_load_config_for_gpu_estimate",
+                return_value = config,
+            ),
+            patch.object(
+                hardware_module,
+                "estimate_fp16_model_size_bytes",
+                return_value = (tiny_safetensors, "safetensors"),
+            ),
+            patch.object(
+                hardware_module,
+                "_determine_attention_impl_for_gpu_estimate",
+                return_value = "flash_attention_2",
+            ),
+            patch.object(
+                hardware_module,
+                "get_visible_gpu_count",
+                return_value = 1,
+            ),
+        ):
+            required, metadata = hardware_module.estimate_required_model_memory_gb(
+                "fake/model",
+                training_type = "LoRA/QLoRA",
+                load_in_4bit = True,
+            )
+        # No negative extra; required_gb stays a positive finite number.
+        self.assertGreater(required, 0)
+
+
+class TestLlama4ArchExtraction(unittest.TestCase):
+    def _llama4_text_config(self, **fields):
+        base = dict(
+            hidden_size = 2048,
+            num_hidden_layers = 4,
+            num_attention_heads = 16,
+            num_key_value_heads = 4,
+            intermediate_size = 8192,
+            intermediate_size_mlp = 16384,
+            vocab_size = 32000,
+            tie_word_embeddings = True,
+            num_local_experts = 4,
+            num_experts_per_tok = 2,
+        )
+        base.update(fields)
+        return SimpleNamespace(**base)
+
+    def test_llama4_moe_layers_dispatch_uses_explicit_indices(self):
+        from utils.hardware.vram_estimation import _compute_dense_layer_indices
+
+        cfg = SimpleNamespace(num_hidden_layers = 4, moe_layers = [1, 3])
+        self.assertEqual(_compute_dense_layer_indices(cfg, 4), (0, 2))
+
+    def test_llama4_moe_layers_takes_priority_over_first_k_dense_replace(self):
+        from utils.hardware.vram_estimation import _compute_dense_layer_indices
+
+        cfg = SimpleNamespace(
+            num_hidden_layers = 6,
+            moe_layers = [2, 4],
+            first_k_dense_replace = 4,
+        )
+        self.assertEqual(_compute_dense_layer_indices(cfg, 6), (0, 1, 3, 5))
+
+    def test_dense_intermediate_size_picks_up_intermediate_size_mlp(self):
+        from utils.hardware.vram_estimation import _dense_mlp_size
+
+        arch = extract_arch_config(self._llama4_text_config(moe_layers = [1, 3]))
+        self.assertIsNotNone(arch)
+        self.assertEqual(arch.intermediate_size, 8192)
+        self.assertEqual(arch.dense_intermediate_size, 16384)
+        self.assertEqual(_dense_mlp_size(arch), 16384)
+
+    def test_auto_attaches_one_shared_expert_at_routed_width(self):
+        from utils.hardware.vram_estimation import _shared_expert_size
+
+        arch = extract_arch_config(self._llama4_text_config(moe_layers = [1, 3]))
+        self.assertIsNotNone(arch)
+        self.assertEqual(arch.n_shared_experts, 1)
+        self.assertIsNone(arch.shared_expert_intermediate_size)
+        self.assertEqual(_shared_expert_size(arch), arch.intermediate_size)
+
+    def test_non_llama4_config_leaves_dense_intermediate_size_none(self):
+        from utils.hardware.vram_estimation import _dense_mlp_size
+
+        cfg = SimpleNamespace(
+            hidden_size = 1024,
+            num_hidden_layers = 4,
+            num_attention_heads = 8,
+            num_key_value_heads = 2,
+            intermediate_size = 4096,
+            vocab_size = 32000,
+            tie_word_embeddings = True,
+        )
+        arch = extract_arch_config(cfg)
+        self.assertIsNotNone(arch)
+        self.assertIsNone(arch.dense_intermediate_size)
+        self.assertEqual(_dense_mlp_size(arch), 4096)
+
+    def test_intermediate_size_mlp_without_moe_does_not_force_shared_expert(self):
+        cfg = SimpleNamespace(
+            hidden_size = 2048,
+            num_hidden_layers = 4,
+            num_attention_heads = 16,
+            num_key_value_heads = 4,
+            intermediate_size = 8192,
+            intermediate_size_mlp = 16384,
+            vocab_size = 32000,
+            tie_word_embeddings = True,
+        )
+        arch = extract_arch_config(cfg)
+        self.assertIsNotNone(arch)
+        self.assertEqual(arch.dense_intermediate_size, 16384)
+        self.assertEqual(arch.n_shared_experts, 0)
+
+
+class TestDbrxFfnConfigExtraction(unittest.TestCase):
+    def test_extracts_moe_fields_from_ffn_subconfig(self):
+        ffn = SimpleNamespace(moe_num_experts = 4, moe_top_k = 2, ffn_hidden_size = 1024)
+        cfg = SimpleNamespace(
+            hidden_size = 2048,
+            num_hidden_layers = 4,
+            num_attention_heads = 16,
+            num_key_value_heads = 4,
+            intermediate_size = 2048,
+            vocab_size = 32000,
+            tie_word_embeddings = False,
+            ffn_config = ffn,
+        )
+        arch = extract_arch_config(cfg)
+        self.assertIsNotNone(arch)
+        self.assertEqual(arch.num_experts, 4)
+        self.assertEqual(arch.num_experts_per_tok, 2)
+        self.assertEqual(arch.moe_intermediate_size, 1024)
+
+    def test_top_level_attrs_take_precedence_over_ffn_config(self):
+        ffn = SimpleNamespace(moe_num_experts = 4, moe_top_k = 2, ffn_hidden_size = 1024)
+        cfg = SimpleNamespace(
+            hidden_size = 2048,
+            num_hidden_layers = 4,
+            num_attention_heads = 16,
+            num_key_value_heads = 4,
+            intermediate_size = 2048,
+            vocab_size = 32000,
+            tie_word_embeddings = False,
+            ffn_config = ffn,
+            num_local_experts = 16,
+            num_experts_per_tok = 8,
+        )
+        arch = extract_arch_config(cfg)
+        self.assertIsNotNone(arch)
+        self.assertEqual(arch.num_experts, 16)
+        self.assertEqual(arch.num_experts_per_tok, 8)
+
+
+class TestErniePhaseModuloDispatch(unittest.TestCase):
+    def test_phase_modulo_with_interval_two_matches_decoder(self):
+        from utils.hardware.vram_estimation import _compute_dense_layer_indices
+
+        cfg = SimpleNamespace(
+            num_hidden_layers = 10,
+            moe_layer_start_index = 2,
+            moe_layer_end_index = 8,
+            moe_layer_interval = 2,
+        )
+        # Decoder gates by ((i + 1) % 2 == 0) AND 2 <= i <= 8 -> MoE = {3, 5, 7}.
+        self.assertEqual(_compute_dense_layer_indices(cfg, 10), (0, 1, 2, 4, 6, 8, 9))
+
+    def test_phase_modulo_with_interval_three(self):
+        from utils.hardware.vram_estimation import _compute_dense_layer_indices
+
+        cfg = SimpleNamespace(
+            num_hidden_layers = 9,
+            moe_layer_start_index = 0,
+            moe_layer_end_index = -1,
+            moe_layer_interval = 3,
+        )
+        self.assertEqual(_compute_dense_layer_indices(cfg, 9), (0, 1, 3, 4, 6, 7))
+
+
+class TestErnieVlSharedExpertWidth(unittest.TestCase):
+    def test_shared_expert_width_uses_text_routed_not_vision(self):
+        from utils.hardware.vram_estimation import (
+            _compute_shared_moe_elements,
+            _shared_expert_size,
+        )
+
+        cfg = SimpleNamespace(
+            text_config = SimpleNamespace(
+                hidden_size = 1024,
+                num_hidden_layers = 4,
+                num_attention_heads = 8,
+                num_key_value_heads = 4,
+                intermediate_size = 2048,
+                vocab_size = 32000,
+                tie_word_embeddings = False,
+                moe_num_experts = 8,
+                moe_num_shared_experts = 2,
+                moe_intermediate_size = [1536, 512],
+            ),
+            quantization_config = {},
+        )
+        arch = extract_arch_config(cfg)
+        self.assertIsNotNone(arch)
+        self.assertIsNone(arch.shared_expert_intermediate_size)
+        self.assertEqual(arch.moe_intermediate_size, 1536)
+        self.assertEqual(arch.n_shared_experts, 2)
+        self.assertEqual(_shared_expert_size(arch), 1536)
+        self.assertEqual(_compute_shared_moe_elements(arch), 1024 * 1536 * 3 * 2)
+
+    def test_qwen_style_explicit_shared_expert_size_still_adds_gate(self):
+        from utils.hardware.vram_estimation import _compute_shared_moe_elements
+
+        cfg = SimpleNamespace(
+            hidden_size = 1024,
+            num_hidden_layers = 4,
+            num_attention_heads = 8,
+            num_key_value_heads = 4,
+            intermediate_size = 2048,
+            vocab_size = 32000,
+            tie_word_embeddings = False,
+            num_local_experts = 8,
+            moe_intermediate_size = 256,
+            shared_expert_intermediate_size = 768,
+        )
+        arch = extract_arch_config(cfg)
+        self.assertIsNotNone(arch)
+        self.assertEqual(arch.shared_expert_intermediate_size, 768)
+        self.assertEqual(arch.n_shared_experts, 1)
+        self.assertEqual(
+            _compute_shared_moe_elements(arch),
+            1024 * 768 * 3 + 1 * 1024,
+        )
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/studio/backend/utils/datasets/model_mappings.py b/studio/backend/utils/datasets/model_mappings.py
index 36f6886ef6..21e8566ac5 100644
--- a/studio/backend/utils/datasets/model_mappings.py
+++ b/studio/backend/utils/datasets/model_mappings.py
@@ -364,6 +364,10 @@ TEMPLATE_TO_MODEL_MAPPER = {
         "unsloth/Qwen3-4B-Thinking-2507-bnb-4bit",
         "unsloth/Qwen3-30B-A3B-Thinking-2507",
         "Qwen/Qwen3-30B-A3B-Thinking-2507",
+        "Qwen/Qwen3.6-35B-A3B",
+        "unsloth/Qwen3.6-35B-A3B",
+        "Qwen/Qwen3.6-27B",
+        "unsloth/Qwen3.6-27B",
     ),
     "qwen3.5": (
         "unsloth/Qwen3.5-0.8B",
diff --git a/studio/backend/utils/hardware/VRAM_ESTIMATION.md b/studio/backend/utils/hardware/VRAM_ESTIMATION.md
index 26072b208f..a6b4de29d2 100644
--- a/studio/backend/utils/hardware/VRAM_ESTIMATION.md
+++ b/studio/backend/utils/hardware/VRAM_ESTIMATION.md
@@ -33,7 +33,13 @@ Non-quantizable = 2*H*L + V*H + (V*H if not tie_embeddings else 0)
 | QLoRA 4-bit | `Quantizable * 2 / 3.2 + Non-quantizable * 2` |
 | LoRA / Full fp16 | `(Quantizable + Non-quantizable) * 2` |
 
-The 3.2 factor (`16/5`) accounts for BNB NF4 blockwise scales.
+The 3.2 factor (`16/5`) accounts for BNB NF4 blockwise scales. Repos whose
+quantization config enables `bnb_4bit_use_double_quant` use a tighter, still
+conservative 3.6 factor for the quantized portion of the weights.
+When a 4-bit config has `llm_int8_skip_modules` entries that point to language
+model layers or submodules, those quantizable weights are charged at fp16
+instead of NF4. Generic embedding and multimodal skip names are already covered
+by non-quantizable terms or excluded from text training weights.
 
 ## 2. LoRA Adapters
 
@@ -53,6 +59,18 @@ MLP modules multiply by `E` for MoE.
 LoRA_bytes = sum(A + B per selected module) * L * 2
 ```
 
+`all-linear` is treated as all known text linear modules in the table above.
+The estimator deliberately does not infer multimodal or vision-tower LoRA
+modules from config shapes; those modules vary too much across VLM families for
+a generic config formula.
+
+Some decoder configs expose layer-shape fields such as `layer_types`,
+`head_dim`, `global_head_dim`, `num_global_key_value_heads`, `attention_k_eq_v`,
+`num_kv_shared_layers`, `use_double_wide_mlp`, `vocab_size_per_layer_input`, and
+`hidden_size_per_layer_input`. When those fields are present, the estimator
+derives text weight and LoRA counts from the per-layer shapes instead of
+assuming every layer has the same seven projection modules.
+
 ## 3. Optimizer States (calibrated)
 
 | Optimizer | Bytes/param | Notes |
@@ -77,6 +95,21 @@ Per-layer (from `unsloth_zoo/vllm_utils.py`):
 Per_layer = (S*B*(H+K+K) + S*B*2 + S*B*(M+M)) * 2 * 1.25
 ```
 
+When the resolved attention implementation is none of `flash_attention_2`,
+`sdpa`, or `flex_attention` (PyTorch SDPA dispatches to flash or
+memory-efficient kernels and FlexAttention is also a memory-efficient
+kernel, all of which are O(n) in memory), activation memory also includes
+a quadratic attention-score/workspace estimate:
+
+```
+Non_flash_attention = B * num_attention_heads * S^2 * 2 * 12.0 * effective_layers
+Activations = max(Per_layer_with_gc, Non_flash_attention)
+```
+
+Studio resolves the attention implementation with Unsloth's
+`resolve_attention_implementation` helper and uses that result directly. The
+estimator does not duplicate model-family attention policy.
+
 | GC Mode | Full FT | LoRA/QLoRA |
 |---------|---------|------------|
 | none | `L` layers | `L` layers |
@@ -85,13 +118,33 @@ Per_layer = (S*B*(H+K+K) + S*B*2 + S*B*(M+M)) * 2 * 1.25
 
 ## 6. Floors
 
-Gradients and activations have minimum floors at **15% of model weight memory** to account for autograd overhead, attention score matrices, NCCL buffers, mixed-precision scaling, and PyTorch fragmentation.
+Activations use the computed formula directly:
 
 ```
-gradient_bytes  = max(computed, weights * 0.15)
-activation_bytes = max(computed, weights * 0.15 * B/2)
+activation_bytes = computed_activation_bytes
 ```
 
+Full fine-tuning keeps the gradient floor at **15% of model weight memory** to
+account for autograd overhead, NCCL buffers, mixed-precision scaling, and
+PyTorch fragmentation:
+
+```
+gradient_bytes = max(computed_gradient_bytes, weights * 0.15)
+```
+
+For LoRA/QLoRA, the base model is frozen, so the weight-derived gradient floor
+is capped by trainable-state and live-activation scale:
+
+```
+raw_gradient_bytes = trainable_params * 2
+gradient_floor = min(weights * 0.15, max(computed_activation_bytes, optimizer_bytes))
+gradient_bytes = max(raw_gradient_bytes, gradient_floor)
+```
+
+This prevents frozen quantized model size from dominating gradient/state
+overhead when the measured runtime footprint is governed by LoRA optimizer
+states and live activations.
+
 ## 7. CUDA Overhead
 
 **1.4 GB** fixed — CUDA driver + PyTorch runtime, calibrated on RTX 5070 Ti.
@@ -106,34 +159,6 @@ usable_gb = free[gpu_0] + sum(free[gpu_i] * 0.85 for i in 1..N)
 
 ---
 
-## Reference Table (bsz=2, seq=2048, rank=16, GC=unsloth, adamw_8bit)
-
-| Model | Weights | LoRA | Optim | Grad | Act | CUDA | Total |
-|-------|---------|------|-------|------|-----|------|-------|
-| 0.5B QLoRA | 0.5 | 0.0 | 0.0 | 0.1 | 0.1 | 1.4 | **2.1** |
-| 1B QLoRA | 1.1 | 0.0 | 0.0 | 0.2 | 0.2 | 1.4 | **2.9** |
-| 3B QLoRA | 2.4 | 0.0 | 0.1 | 0.5 | 0.5 | 1.4 | **4.9** |
-| 8B QLoRA | 6.0 | 0.1 | 0.2 | 1.2 | 1.2 | 1.4 | **10.1** |
-| 8B LoRA fp16 | 15.0 | 0.1 | 0.2 | 3.0 | 3.0 | 1.4 | **22.6** |
-| 8B Full FT | 15.0 | — | 29.9 | 15.0 | 3.0 | 1.4 | **64.2** |
-| 32B LoRA fp16 | 61.0 | 0.2 | 0.5 | 12.2 | 12.2 | 1.4 | **87.6** |
-| 72B QLoRA | 45.5 | 0.4 | 0.8 | 9.1 | 9.1 | 1.4 | **66.3** |
-
-## E2E Validation (Llama-3.2-1B, B200 emulating 24GB)
-
-| Config | Estimated | Actual (nvsmi) | Error |
-|--------|----------|----------------|-------|
-| QLoRA bsz=2 seq=512 | 2.55 GB | 2.65 GB | -3.7% |
-| QLoRA bsz=2 seq=2048 | 2.60 GB | 2.65 GB | -1.8% |
-| QLoRA bsz=4 seq=2048 | 2.65 GB | 2.65 GB | +0.0% |
-| LoRA fp16 bsz=2 | 3.84 GB | 3.88 GB | -1.0% |
-| Full FT adamw_8bit | 10.89 GB | 10.80 GB | +0.8% |
-| Full FT adamw_torch | 13.19 GB | 12.93 GB | +2.0% |
-
-*Note: e2e numbers predate the 15% floors, which add safety margin on top.*
-
----
-
 ## Parameter Flow
 
 ```
diff --git a/studio/backend/utils/hardware/amd.py b/studio/backend/utils/hardware/amd.py
index 755314ca3a..fdb1ab4520 100644
--- a/studio/backend/utils/hardware/amd.py
+++ b/studio/backend/utils/hardware/amd.py
@@ -16,6 +16,7 @@ import subprocess
 from typing import Any, Optional
 
 from loggers import get_logger
+from utils.native_path_leases import child_env_without_native_path_secret
 
 logger = get_logger(__name__)
 
@@ -28,6 +29,7 @@ def _run_amd_smi(*args: str, timeout: int = 5) -> Optional[Any]:
             capture_output = True,
             text = True,
             timeout = timeout,
+            env = child_env_without_native_path_secret(),
         )
     except (OSError, subprocess.TimeoutExpired) as e:
         logger.warning("amd-smi query failed: %s", e)
diff --git a/studio/backend/utils/hardware/hardware.py b/studio/backend/utils/hardware/hardware.py
index be31c00a78..c218b7b4b9 100644
--- a/studio/backend/utils/hardware/hardware.py
+++ b/studio/backend/utils/hardware/hardware.py
@@ -774,6 +774,34 @@ def _load_config_for_gpu_estimate(model_name: str, hf_token: Optional[str] = Non
         return None
 
 
+def _determine_attention_impl_for_gpu_estimate(config) -> str:
+    import copy as _copy
+
+    from unsloth.models._utils import resolve_attention_implementation
+    from transformers import AutoModel, AutoModelForCausalLM
+
+    # why: resolve_attention_implementation calls _set_attn_impl which writes
+    # _attn_implementation onto the config; PreTrainedConfig's setter walks
+    # `sub_configs` and propagates to nested text_config / sub-configs, so a
+    # shallow copy still mutates those shared inner objects on the cached
+    # config returned by _load_config_for_gpu_estimate. Deepcopy isolates them.
+    config_copy = _copy.deepcopy(config)
+
+    model_class = None
+    for auto_model in (AutoModelForCausalLM, AutoModel):
+        mapping = getattr(auto_model, "_model_mapping", None)
+        if mapping is None:
+            continue
+        try:
+            if config_copy.__class__ in mapping:
+                model_class = mapping[config_copy.__class__]
+                break
+        except Exception:
+            continue
+
+    return resolve_attention_implementation(model_class, config_copy)
+
+
 def _estimate_fp16_model_size_bytes_from_config(config) -> Optional[int]:
     from .vram_estimation import extract_arch_config, compute_total_params
 
@@ -844,12 +872,21 @@ def estimate_fp16_model_size_bytes(
         return int(total_params * 2), "safetensors"
 
     config = _load_config_for_gpu_estimate(estimate_model, hf_token = hf_token)
+    config_bytes: Optional[int] = None
     if config is not None:
         config_bytes = _estimate_fp16_model_size_bytes_from_config(config)
-        if config_bytes is not None:
-            return config_bytes, "config"
 
     local_bytes = _get_local_weight_size_bytes(estimate_model)
+
+    # why: config-derived bytes cover only the text tower; local safetensors
+    # include vision/audio towers. Take the larger so the multimodal
+    # extra_bytes correction can fire.
+    if config_bytes is not None and local_bytes is not None:
+        if local_bytes > config_bytes:
+            return local_bytes, "weight_bytes"
+        return config_bytes, "config"
+    if config_bytes is not None:
+        return config_bytes, "config"
     if local_bytes is not None:
         return local_bytes, "weight_bytes"
 
@@ -877,6 +914,9 @@ def estimate_required_model_memory_gb(
         TrainingVramConfig,
         extract_arch_config,
         estimate_training_vram,
+        compute_total_params,
+        compute_optimizer_bytes,
+        compute_gradient_bytes,
         CUDA_OVERHEAD_BYTES,
         QUANT_4BIT_FACTOR,
         DEFAULT_TARGET_MODULES,
@@ -926,13 +966,44 @@ def estimate_required_model_memory_gb(
         model_name, hf_token = hf_token
     )
     config = _load_config_for_gpu_estimate(estimate_model, hf_token = hf_token)
+    if config is not None:
+        try:
+            vram_config.attention_implementation = (
+                _determine_attention_impl_for_gpu_estimate(config)
+            )
+        except Exception as e:
+            logger.warning(
+                "Could not resolve attention implementation for '%s': %s",
+                estimate_model,
+                e,
+            )
+            # why: if we cannot prove flash attention is usable, charge the
+            # quadratic non-flash activation path so GPU selection stays
+            # conservative.
+            vram_config.attention_implementation = "eager"
     arch = extract_arch_config(config) if config is not None else None
 
     if arch is not None:
         breakdown = estimate_training_vram(arch, vram_config)
+        # why: extract_arch_config only sees text_config; safetensors include
+        # vision/audio tower bytes that the text-arch fp16 total misses.
+        arch_fp16_bytes = compute_total_params(arch) * 2
+        extra_bytes = max(0, int(model_size_bytes) - arch_fp16_bytes)
+        if extra_bytes > 0:
+            breakdown.model_weights += extra_bytes
+            if training_method == "full":
+                # why: full fine-tuning makes the extra (vision/audio) params
+                # trainable; optimizer + gradient bytes scale with them too.
+                extra_params = extra_bytes // 2
+                breakdown.optimizer_states += compute_optimizer_bytes(
+                    extra_params,
+                    vram_config.optimizer,
+                )
+                breakdown.gradients += compute_gradient_bytes(extra_params)
         required_gb = breakdown.total / (1024**3)
         metadata["required_gb"] = round(required_gb, 3)
         metadata["estimation_mode"] = "detailed"
+        metadata["attention_implementation"] = vram_config.attention_implementation
         metadata["vram_breakdown"] = breakdown.to_gb_dict()
         max_gpus = max(1, get_visible_gpu_count())
         for n_gpus in range(1, max_gpus + 1):
diff --git a/studio/backend/utils/hardware/nvidia.py b/studio/backend/utils/hardware/nvidia.py
index 274d9beb48..099c5fa3a5 100644
--- a/studio/backend/utils/hardware/nvidia.py
+++ b/studio/backend/utils/hardware/nvidia.py
@@ -6,6 +6,7 @@ from typing import Any, Optional
 
 from loggers import get_logger
 
+from utils.native_path_leases import child_env_without_native_path_secret
 from utils.subprocess_compat import (
     windows_hidden_subprocess_kwargs as _windows_hidden_subprocess_kwargs,
 )
@@ -65,6 +66,7 @@ def get_physical_gpu_count() -> Optional[int]:
             capture_output = True,
             text = True,
             timeout = 5,
+            env = child_env_without_native_path_secret(),
             **_windows_hidden_subprocess_kwargs(),
         )
         if result.returncode == 0 and result.stdout.strip():
@@ -90,6 +92,7 @@ def get_primary_gpu_utilization() -> dict[str, Any]:
             capture_output = True,
             text = True,
             timeout = 5,
+            env = child_env_without_native_path_secret(),
             **_windows_hidden_subprocess_kwargs(),
         )
     except (OSError, subprocess.TimeoutExpired) as e:
@@ -141,6 +144,7 @@ def get_visible_gpu_utilization(
             capture_output = True,
             text = True,
             timeout = 5,
+            env = child_env_without_native_path_secret(),
             **_windows_hidden_subprocess_kwargs(),
         )
     except (OSError, subprocess.TimeoutExpired) as e:
@@ -227,6 +231,7 @@ def get_backend_visible_gpu_info(
             capture_output = True,
             text = True,
             timeout = 10,
+            env = child_env_without_native_path_secret(),
             **_windows_hidden_subprocess_kwargs(),
         )
     except (OSError, subprocess.TimeoutExpired) as e:
diff --git a/studio/backend/utils/hardware/vram_estimation.py b/studio/backend/utils/hardware/vram_estimation.py
index e03665374d..ba1b1dfe61 100644
--- a/studio/backend/utils/hardware/vram_estimation.py
+++ b/studio/backend/utils/hardware/vram_estimation.py
@@ -16,7 +16,26 @@ from dataclasses import dataclass, field
 from typing import Dict, Optional
 
 QUANT_4BIT_FACTOR = 16 / 5
+DOUBLE_QUANT_4BIT_FACTOR = (
+    3.6  # bnb_4bit_use_double_quant; see VRAM_ESTIMATION.md section 1
+)
 CUDA_OVERHEAD_BYTES = int(1.4 * 1024**3)  # calibrated on RTX 5070 Ti
+NON_FLASH_ATTENTION_FACTOR = (
+    12.0  # eager attention score+workspace overhead; see VRAM_ESTIMATION.md section 5
+)
+
+LINEAR_ATTENTION_IMPLS = frozenset({"flash_attention_2", "sdpa", "flex_attention"})
+
+_SKIP_MODULE_TEXT_PREFIXES = frozenset(
+    {
+        "model",
+        "model.model",
+        "language_model",
+        "language_model.model",
+        "model.language_model",
+        "model.language_model.model",
+    }
+)
 
 DEFAULT_TARGET_MODULES = [
     "q_proj",
@@ -27,6 +46,8 @@ DEFAULT_TARGET_MODULES = [
     "up_proj",
     "down_proj",
 ]
+ATTENTION_TARGET_MODULES = {"q_proj", "k_proj", "v_proj", "o_proj"}
+MLP_TARGET_MODULES = {"gate_proj", "up_proj", "down_proj"}
 
 # Empirically calibrated bytes/param — see VRAM_ESTIMATION.md for rationale.
 OPTIMIZER_BYTES_PER_PARAM: Dict[str, int] = {
@@ -61,12 +82,28 @@ class ModelArchConfig:
     num_experts: Optional[int] = None
     moe_intermediate_size: Optional[int] = None
     n_shared_experts: int = 0
+    shared_expert_intermediate_size: Optional[int] = None
+    num_experts_per_tok: int = 1
     num_dense_layers: int = 0
     q_lora_rank: Optional[int] = None
     kv_lora_rank: Optional[int] = None
     qk_nope_head_dim: Optional[int] = None
     qk_rope_head_dim: Optional[int] = None
     v_head_dim: Optional[int] = None
+    head_dim: Optional[int] = None
+    global_head_dim: Optional[int] = None
+    num_global_key_value_heads: Optional[int] = None
+    attention_k_eq_v: bool = False
+    layer_types: Optional[list] = None
+    num_kv_shared_layers: int = 0
+    use_double_wide_mlp: bool = False
+    vocab_size_per_layer_input: int = 0
+    hidden_size_per_layer_input: int = 0
+    quantization_skip_modules: list = field(default_factory = list)
+    quant_4bit_factor: float = QUANT_4BIT_FACTOR
+    moe_has_dense_mlp: bool = False
+    dense_layer_indices: tuple = ()
+    dense_intermediate_size: Optional[int] = None
 
 
 @dataclass
@@ -79,6 +116,7 @@ class TrainingVramConfig:
     gradient_checkpointing: str = "unsloth"
     optimizer: str = "adamw_8bit"
     load_in_4bit: bool = True
+    attention_implementation: str = "flash_attention_2"
 
 
 @dataclass
@@ -89,8 +127,8 @@ class VramBreakdown:
     gradients: int
     activations: int
     cuda_overhead: int
-    # The computed (formula-based) activation cost before floors.
-    # This is the true per-layer cost that doesn't shard across GPUs.
+    # Equals `activations`; retained for backward compatibility with
+    # consumers that read this field.
     activations_computed: int = 0
 
     @property
@@ -108,17 +146,15 @@ class VramBreakdown:
         """Minimum VRAM a single GPU needs: its shard + non-shardable costs.
 
         Weights/LoRA/optimizer/gradients shard across GPUs.
-        The computed activation cost does NOT shard (one GPU runs the layer).
-        The floor portion (activations - computed) is overhead that shards.
+        Activations do NOT shard (the GPU running a layer holds them).
         """
         shardable = (
             self.model_weights
             + self.lora_adapters
             + self.optimizer_states
             + self.gradients
-            + (self.activations - self.activations_computed)  # floor overhead shards
         )
-        per_gpu_fixed = self.activations_computed + self.cuda_overhead
+        per_gpu_fixed = self.activations + self.cuda_overhead
         return shardable // max(n_gpus, 1) + per_gpu_fixed
 
     def to_gb_dict(self) -> Dict[str, float]:
@@ -133,28 +169,88 @@ class VramBreakdown:
         }
 
 
-def _compute_num_dense_layers(text_config, total_layers: int) -> int:
-    """Count how many layers use dense MLP instead of MoE."""
+def _first_scalar(value):
+    # why: ERNIE MoE configs ship moe_intermediate_size / moe_num_experts as
+    # [routed, shared] lists; downstream arithmetic needs the routed scalar.
+    if isinstance(value, (list, tuple)):
+        return value[0] if value else None
+    return value
+
+
+def _max_scalar(value):
+    # why: Hunyuan-V1-MoE moe_topk can be a per-layer list; activation
+    # accounting uses the max top-k as a conservative upper bound.
+    if isinstance(value, (list, tuple)):
+        items = [v for v in value if v is not None]
+        return max(items) if items else None
+    return value
+
+
+def _compute_dense_layer_indices(text_config, total_layers: int) -> tuple:
+    """Layer indices that use dense MLP instead of MoE. Position matters."""
+    # why: transformers Exaone-MoE / Laguna / Hy_v3 / GLM-MoE-DSA / GLM4-MoE-Lite /
+    # Ernie4_5_VL_MoE prefer per-position `mlp_layer_types` over the prefix-style
+    # `first_k_dense_replace` and may omit `decoder_sparse_step` entirely.
+    layer_types = getattr(text_config, "mlp_layer_types", None)
+    if layer_types:
+        return tuple(
+            i
+            for i, t in enumerate(layer_types[:total_layers])
+            if str(t).lower() == "dense"
+        )
+
+    # why: Llama4TextConfig.__init__ auto-populates self.moe_layers from
+    # interleave_moe_layer_step; Llama4TextDecoderLayer dispatches via
+    # `layer_idx in config.moe_layers` (modeling_llama4.py).
+    llama4_moe_layers = getattr(text_config, "moe_layers", None)
+    if llama4_moe_layers is not None:
+        moe_indices = {int(i) for i in llama4_moe_layers}
+        return tuple(i for i in range(total_layers) if i not in moe_indices)
+
+    # why: transformers ERNIE 4.5 MoE / ERNIE 4.5 VL MoE declare MoE layers
+    # via moe_layer_start_index / moe_layer_end_index / moe_layer_interval;
+    # the model's per-layer guard is `(layer_idx + 1) % interval == 0` with
+    # start <= layer_idx <= end (modeling_ernie4_5_moe.py).
+    moe_start = getattr(text_config, "moe_layer_start_index", None)
+    moe_interval = getattr(text_config, "moe_layer_interval", None)
+    if moe_start is not None and moe_interval is not None and int(moe_interval) > 0:
+        moe_end_raw = getattr(text_config, "moe_layer_end_index", None)
+        end = (
+            total_layers
+            if moe_end_raw is None or int(moe_end_raw) == -1
+            else min(int(moe_end_raw) + 1, total_layers)
+        )
+        start = max(0, int(moe_start))
+        interval = int(moe_interval)
+        moe_indices = {i for i in range(start, end) if (i + 1) % interval == 0}
+        return tuple(i for i in range(total_layers) if i not in moe_indices)
+
     first_k = getattr(text_config, "first_k_dense_replace", None)
     if first_k is not None:
-        return min(int(first_k), total_layers)
+        return tuple(range(min(int(first_k), total_layers)))
 
     sparse_step = getattr(text_config, "decoder_sparse_step", None)
     mlp_only = getattr(text_config, "mlp_only_layers", None) or []
     if sparse_step is not None and sparse_step > 0:
-        mlp_only_set = set(mlp_only)
-        moe_count = sum(
-            1
+        mlp_only_set = {int(i) for i in mlp_only}
+        return tuple(
+            i
             for i in range(total_layers)
-            if i not in mlp_only_set and (i + 1) % sparse_step == 0
+            if i in mlp_only_set or (i + 1) % sparse_step != 0
         )
-        return total_layers - moe_count
-
-    return 0
+    return ()
 
 
 def extract_arch_config(hf_config) -> Optional[ModelArchConfig]:
     text_config = getattr(hf_config, "text_config", None) or hf_config
+    quantization_config = getattr(hf_config, "quantization_config", None) or {}
+    if not isinstance(quantization_config, dict):
+        quantization_config = getattr(quantization_config, "to_dict", lambda: {})()
+    quant_4bit_factor = (
+        DOUBLE_QUANT_4BIT_FACTOR
+        if quantization_config.get("bnb_4bit_use_double_quant", False)
+        else QUANT_4BIT_FACTOR
+    )
 
     hidden_size = getattr(text_config, "hidden_size", None)
     num_layers = getattr(text_config, "num_hidden_layers", None)
@@ -177,18 +273,75 @@ def extract_arch_config(hf_config) -> Optional[ModelArchConfig]:
 
     num_kv_heads = getattr(text_config, "num_key_value_heads", num_heads)
 
+    # why: DBRX places its MoE attrs on the DbrxFFNConfig sub-config; probe
+    # ffn_config as a secondary source so DBRX is not misclassified as dense.
+    ffn_config = getattr(text_config, "ffn_config", None)
+
+    def _moe_attr(name):
+        value = getattr(text_config, name, None)
+        if value is None and ffn_config is not None:
+            value = getattr(ffn_config, name, None)
+        return value
+
     num_experts = None
-    for attr in ("num_local_experts", "num_experts", "n_routed_experts"):
-        num_experts = getattr(text_config, attr, None)
+    for attr in (
+        "num_local_experts",
+        "num_experts",
+        "n_routed_experts",
+        "moe_num_experts",
+    ):
+        num_experts = _first_scalar(_moe_attr(attr))
         if num_experts is not None:
             break
 
-    moe_intermediate = getattr(text_config, "moe_intermediate_size", None)
-    n_shared_experts = getattr(text_config, "n_shared_experts", None) or 0
+    moe_intermediate_raw = _moe_attr("moe_intermediate_size")
+    if moe_intermediate_raw is None:
+        moe_intermediate_raw = _moe_attr("ffn_hidden_size")
+    moe_intermediate = _first_scalar(moe_intermediate_raw)
+    # why: Exaone-MoE / ERNIE families alias num_shared_experts /
+    # moe_num_shared_experts to the canonical n_shared_experts.
+    n_shared_experts = (
+        _first_scalar(_moe_attr("n_shared_experts"))
+        or _first_scalar(_moe_attr("num_shared_experts"))
+        or _first_scalar(_moe_attr("moe_num_shared_experts"))
+        or 0
+    )
+    shared_expert_intermediate_size = _moe_attr("shared_expert_intermediate_size")
+    if shared_expert_intermediate_size and n_shared_experts == 0:
+        n_shared_experts = 1
+    # why: DBRX exposes moe_top_k, Hunyuan-V1-MoE exposes moe_topk (which can
+    # be a per-layer list); _max_scalar normalizes list values to the worst
+    # case so int(...) below cannot crash on the canonical attribute_map path.
+    num_experts_per_tok = (
+        _max_scalar(_moe_attr("num_experts_per_tok"))
+        or _max_scalar(_moe_attr("top_k_experts"))
+        or _max_scalar(_moe_attr("moe_top_k"))
+        or _max_scalar(_moe_attr("moe_topk"))
+        or 1
+    )
 
-    num_dense_layers = 0
+    dense_layer_indices: tuple = ()
     if num_experts is not None and num_experts > 1:
-        num_dense_layers = _compute_num_dense_layers(text_config, num_layers)
+        dense_layer_indices = _compute_dense_layer_indices(text_config, num_layers)
+    num_dense_layers = len(dense_layer_indices)
+
+    # why: Llama4 dense layers use intermediate_size_mlp; routed and shared
+    # experts use intermediate_size. Llama4TextMoe builds one shared_expert
+    # per MoE layer (modeling_llama4.py).
+    intermediate_size_mlp_raw = _first_scalar(_moe_attr("intermediate_size_mlp"))
+    dense_intermediate_size = (
+        int(intermediate_size_mlp_raw)
+        if intermediate_size_mlp_raw is not None
+        else None
+    )
+    if (
+        intermediate_size_mlp_raw is not None
+        and num_experts is not None
+        and num_experts > 1
+        and shared_expert_intermediate_size is None
+        and n_shared_experts == 0
+    ):
+        n_shared_experts = 1
 
     q_lora_rank = getattr(text_config, "q_lora_rank", None)
     kv_lora_rank = getattr(text_config, "kv_lora_rank", None)
@@ -207,15 +360,418 @@ def extract_arch_config(hf_config) -> Optional[ModelArchConfig]:
         num_experts = num_experts,
         moe_intermediate_size = moe_intermediate,
         n_shared_experts = n_shared_experts,
+        shared_expert_intermediate_size = shared_expert_intermediate_size,
+        num_experts_per_tok = int(num_experts_per_tok),
         num_dense_layers = num_dense_layers,
         q_lora_rank = q_lora_rank,
         kv_lora_rank = kv_lora_rank,
         qk_nope_head_dim = qk_nope_head_dim,
         qk_rope_head_dim = qk_rope_head_dim,
         v_head_dim = v_head_dim,
+        head_dim = getattr(text_config, "head_dim", None),
+        global_head_dim = getattr(text_config, "global_head_dim", None),
+        num_global_key_value_heads = getattr(
+            text_config,
+            "num_global_key_value_heads",
+            None,
+        ),
+        attention_k_eq_v = bool(getattr(text_config, "attention_k_eq_v", False)),
+        layer_types = getattr(text_config, "layer_types", None),
+        num_kv_shared_layers = getattr(text_config, "num_kv_shared_layers", None) or 0,
+        use_double_wide_mlp = bool(getattr(text_config, "use_double_wide_mlp", False)),
+        vocab_size_per_layer_input = getattr(
+            text_config,
+            "vocab_size_per_layer_input",
+            None,
+        )
+        or 0,
+        hidden_size_per_layer_input = getattr(
+            text_config,
+            "hidden_size_per_layer_input",
+            None,
+        )
+        or 0,
+        quantization_skip_modules = list(
+            quantization_config.get("llm_int8_skip_modules", []) or []
+        ),
+        quant_4bit_factor = quant_4bit_factor,
+        moe_has_dense_mlp = bool(getattr(text_config, "enable_moe_block", False)),
+        dense_layer_indices = dense_layer_indices,
+        dense_intermediate_size = dense_intermediate_size,
     )
 
 
+def _targets_all_linear(target_modules) -> bool:
+    # why: peft LoraConfig accepts target_modules="all-linear" as a bare
+    # string; iterating a string yields chars and never matches the set.
+    if isinstance(target_modules, str):
+        target_modules = [target_modules]
+    normalized = {str(module).lower().replace("_", "-") for module in target_modules}
+    return normalized == {"all-linear"}
+
+
+def _head_dim(arch: ModelArchConfig) -> int:
+    return arch.head_dim or arch.hidden_size // arch.num_attention_heads
+
+
+def _layer_types(arch: ModelArchConfig) -> list:
+    if arch.layer_types and len(arch.layer_types) == arch.num_hidden_layers:
+        return arch.layer_types
+    return ["full_attention"] * arch.num_hidden_layers
+
+
+def _uses_structured_layer_shapes(arch: ModelArchConfig) -> bool:
+    # MLA configs have their own q/kv low-rank projection shape formulas in
+    # _compute_attn_elements / _lora_attn_elements; do not let head_dim or
+    # other structured fields override that path.
+    if arch.q_lora_rank is not None:
+        return False
+    return bool(
+        arch.layer_types
+        or arch.head_dim is not None
+        or arch.global_head_dim is not None
+        or arch.num_global_key_value_heads is not None
+        or arch.attention_k_eq_v
+        or arch.num_kv_shared_layers > 0
+        or arch.use_double_wide_mlp
+    )
+
+
+def _is_kv_shared_layer(arch: ModelArchConfig, layer_idx: int) -> bool:
+    if arch.num_kv_shared_layers <= 0:
+        return False
+    first_shared = arch.num_hidden_layers - arch.num_kv_shared_layers
+    # why: transformers Gemma4 (modeling_gemma4.py:1031, modular_gemma4.py:863)
+    # uses the same `> 0` guard so a fully-shared config raises during model
+    # construction; matching upstream avoids producing a detailed estimate
+    # for a shape the actual model code rejects.
+    return layer_idx >= first_shared > 0
+
+
+def _is_dense_mlp_layer(arch: ModelArchConfig, layer_idx: int) -> bool:
+    if arch.dense_layer_indices:
+        return layer_idx in arch.dense_layer_indices
+    return layer_idx < arch.num_dense_layers
+
+
+def _per_layer_input_quantizable(arch: ModelArchConfig) -> int:
+    # why: Gemma4 PLE block adds per_layer_model_projection (single Linear),
+    # per_layer_input_gate (per layer), and per_layer_projection (per layer);
+    # see transformers gemma4/modular_gemma4.py:1077-1083 and :1247-1253.
+    pli = arch.hidden_size_per_layer_input
+    if pli <= 0:
+        return 0
+    n_layers = arch.num_hidden_layers
+    hd = arch.hidden_size
+    return hd * (n_layers * pli) + (hd * pli) * n_layers + (pli * hd) * n_layers
+
+
+def _per_layer_input_norm_elements(arch: ModelArchConfig) -> int:
+    pli = arch.hidden_size_per_layer_input
+    if pli <= 0:
+        return 0
+    n_layers = arch.num_hidden_layers
+    hd = arch.hidden_size
+    return hd * n_layers + pli
+
+
+def _per_layer_input_lora_params(
+    arch: ModelArchConfig,
+    r: int,
+    target_modules,
+) -> int:
+    # why: Unsloth's get_peft_regex (unsloth_zoo/peft_utils.py) requires module
+    # names to contain a component tag (mlp/attn/...); PLE module names lack
+    # any tag, so all-linear training does NOT attach LoRA to them. Only count
+    # PLE LoRA when the user explicitly names PLE modules.
+    pli = arch.hidden_size_per_layer_input
+    if pli <= 0:
+        return 0
+    targets = (
+        {target_modules}
+        if isinstance(target_modules, str)
+        else set(target_modules or [])
+    )
+    n_layers = arch.num_hidden_layers
+    hd = arch.hidden_size
+    total = 0
+    if "per_layer_model_projection" in targets:
+        total += hd * r + r * (n_layers * pli)
+    if "per_layer_input_gate" in targets:
+        total += (hd * r + r * pli) * n_layers
+    if "per_layer_projection" in targets:
+        total += (pli * r + r * hd) * n_layers
+    return total
+
+
+def _layer_attention_dims(arch: ModelArchConfig, layer_idx: int) -> tuple:
+    layer_types = _layer_types(arch)
+    layer_type = layer_types[layer_idx]
+    is_sliding = layer_type == "sliding_attention"
+    head_dim = (
+        arch.global_head_dim
+        if not is_sliding and arch.global_head_dim
+        else _head_dim(arch)
+    )
+    use_alt_attention = arch.attention_k_eq_v and not is_sliding
+    num_kv_heads = (
+        arch.num_global_key_value_heads
+        if use_alt_attention and arch.num_global_key_value_heads
+        else arch.num_key_value_heads
+    )
+    q_size = arch.num_attention_heads * head_dim
+    kv_size = num_kv_heads * head_dim
+    has_k = not _is_kv_shared_layer(arch, layer_idx)
+    has_v = has_k and not use_alt_attention
+    return q_size, kv_size, has_k, has_v
+
+
+def _layer_mlp_size(arch: ModelArchConfig, layer_idx: int) -> int:
+    if arch.use_double_wide_mlp and _is_kv_shared_layer(arch, layer_idx):
+        return _dense_mlp_size(arch) * 2
+    return _dense_mlp_size(arch)
+
+
+def _text_linear_dims(
+    arch: ModelArchConfig,
+    layer_idx: int,
+) -> Dict[str, tuple[int, int]]:
+    hd = arch.hidden_size
+    if _uses_structured_layer_shapes(arch):
+        q_size, kv_size, has_k, has_v = _layer_attention_dims(arch, layer_idx)
+        mlp_size = _layer_mlp_size(arch, layer_idx)
+    else:
+        q_size = hd
+        kv_size = _get_kv_size(arch)
+        has_k = True
+        has_v = True
+        mlp_size = _get_mlp_size(arch)
+
+    dims = {
+        "q_proj": (hd, q_size),
+        "o_proj": (q_size, hd),
+    }
+    if has_k:
+        dims["k_proj"] = (hd, kv_size)
+    if has_v:
+        dims["v_proj"] = (hd, kv_size)
+
+    dims.update(
+        {
+            "gate_proj": (hd, mlp_size),
+            "up_proj": (hd, mlp_size),
+            "down_proj": (mlp_size, hd),
+        }
+    )
+    return dims
+
+
+def _module_path_matches(skip_module: str, alias: str) -> bool:
+    skip_parts = [part for part in skip_module.split(".") if part]
+    alias_parts = [part for part in alias.split(".") if part]
+    if not skip_parts or not alias_parts:
+        return False
+    if alias_parts[0] == "layers":
+        return skip_parts == alias_parts
+    if len(skip_parts) <= len(alias_parts):
+        # why: transformers BNB quantizer suffix-matches short skip entries
+        # like ["q_proj"] / ["lm_head"] against full module paths, so a skip
+        # shorter than the alias is a tail match.
+        return alias_parts[-len(skip_parts) :] == skip_parts
+    if skip_parts[-len(alias_parts) :] != alias_parts:
+        return False
+    prefix_parts = skip_parts[: len(skip_parts) - len(alias_parts)]
+    if not prefix_parts:
+        return True
+    # why: bound the prefix to known text-tower roots so VLM skip names like
+    # vision_tower.model.layers.<i>.self_attn.q_proj do not shadow the text
+    # alias model.layers.<i>.self_attn.q_proj.
+    return ".".join(prefix_parts) in _SKIP_MODULE_TEXT_PREFIXES
+
+
+def _add_module_aliases(
+    aliases: Dict[str, str],
+    canonical: str,
+    suffix: str,
+) -> None:
+    for prefix in (
+        "",
+        "model",
+        "model.model",
+        "language_model",
+        "language_model.model",
+        "model.language_model",
+        "model.language_model.model",
+    ):
+        alias = f"{prefix}.{suffix}" if prefix else suffix
+        aliases[alias] = canonical
+
+
+def _build_text_module_elements(
+    arch: ModelArchConfig,
+) -> tuple[Dict[str, int], Dict[str, str]]:
+    elements: Dict[str, int] = {}
+    aliases: Dict[str, str] = {}
+
+    is_mla = arch.q_lora_rank is not None and not _uses_structured_layer_shapes(arch)
+    pli = arch.hidden_size_per_layer_input
+    hd_global = arch.hidden_size
+
+    for layer_idx in range(arch.num_hidden_layers):
+        layer_modules: Dict[str, int] = {}
+        dims = _text_linear_dims(arch, layer_idx)
+        attn_dims = {
+            name: dim for name, dim in dims.items() if name in ATTENTION_TARGET_MODULES
+        }
+        mlp_dims = {
+            name: dim for name, dim in dims.items() if name in MLP_TARGET_MODULES
+        }
+
+        if is_mla:
+            # why: _text_linear_dims uses (hd, hd) for q/o; MLA actually splits
+            # into q_a/q_b/kv_a/kv_b, so emit a single self_attn aggregate at
+            # the authoritative MLA per-layer total.
+            layer_modules["self_attn"] = _compute_attn_elements(arch)
+        else:
+            for name, (in_dim, out_dim) in attn_dims.items():
+                layer_modules[f"self_attn.{name}"] = in_dim * out_dim
+
+        if arch.num_experts and arch.num_experts > 1:
+            if _is_dense_mlp_layer(arch, layer_idx):
+                layer_modules.update(
+                    {
+                        f"mlp.{name}": in_dim * out_dim
+                        for name, (in_dim, out_dim) in mlp_dims.items()
+                    }
+                )
+            else:
+                layer_modules["mlp.experts"] = _compute_routed_moe_elements(arch)
+                shared_moe = _compute_shared_moe_elements(arch)
+                if shared_moe:
+                    # why: Qwen3.5-MoE exposes shared expert as
+                    # mlp.shared_expert; Exaone-MoE/Laguna/GLM-style configs use
+                    # mlp.shared_experts. Register both names so child-path
+                    # llm_int8_skip_modules entries match the right shared block.
+                    layer_modules["mlp.shared_expert"] = shared_moe
+                if arch.moe_has_dense_mlp:
+                    # why: enable_moe_block runs the dense MLP and the MoE
+                    # experts in parallel; register both for skip matching.
+                    # Non-structured _text_linear_dims returns mlp_size from
+                    # _get_mlp_size which prefers moe_intermediate_size, so
+                    # rebuild dense dims from arch.intermediate_size directly.
+                    if _uses_structured_layer_shapes(arch):
+                        dense_dims = mlp_dims
+                    else:
+                        hd = arch.hidden_size
+                        inter = arch.intermediate_size
+                        dense_dims = {
+                            "gate_proj": (hd, inter),
+                            "up_proj": (hd, inter),
+                            "down_proj": (inter, hd),
+                        }
+                    layer_modules.update(
+                        {
+                            f"mlp.{name}": in_dim * out_dim
+                            for name, (in_dim, out_dim) in dense_dims.items()
+                        }
+                    )
+        else:
+            layer_modules.update(
+                {
+                    f"mlp.{name}": in_dim * out_dim
+                    for name, (in_dim, out_dim) in mlp_dims.items()
+                }
+            )
+
+        if pli > 0:
+            # why: register PLE per-layer linears so llm_int8_skip_modules
+            # entries like model.layers.0.per_layer_input_gate match.
+            layer_modules["per_layer_input_gate"] = hd_global * pli
+            layer_modules["per_layer_projection"] = pli * hd_global
+
+        attn_total = sum(
+            value
+            for name, value in layer_modules.items()
+            if name == "self_attn" or name.startswith("self_attn.")
+        )
+        # why: gemma4 enable_moe_block puts routed experts at the sibling
+        # layers.<i>.experts attribute, not under self.mlp; the layer's "mlp"
+        # aggregate must reflect only the dense MLP path so a skip module
+        # `model.layers.0.mlp` does not over-skip into the experts block.
+        is_sibling_experts = bool(arch.moe_has_dense_mlp)
+        mlp_total = sum(
+            value
+            for name, value in layer_modules.items()
+            if (
+                name == "mlp"
+                or (
+                    name.startswith("mlp.")
+                    and not (is_sibling_experts and name == "mlp.experts")
+                )
+            )
+        )
+        experts_total = layer_modules.get("mlp.experts", 0) if is_sibling_experts else 0
+        layer_total = sum(layer_modules.values())
+
+        aggregate_modules = {
+            f"text.layers.{layer_idx}": layer_total,
+            f"text.layers.{layer_idx}.self_attn": attn_total,
+            f"text.layers.{layer_idx}.mlp": mlp_total,
+        }
+        if experts_total:
+            aggregate_modules[f"text.layers.{layer_idx}.experts"] = experts_total
+        elements.update(aggregate_modules)
+        for canonical in aggregate_modules:
+            suffix = canonical.removeprefix("text.")
+            _add_module_aliases(aliases, canonical, suffix)
+
+        for name, value in layer_modules.items():
+            canonical = f"text.layers.{layer_idx}.{name}"
+            elements[canonical] = value
+            _add_module_aliases(aliases, canonical, canonical.removeprefix("text."))
+            if name == "mlp.experts" and arch.moe_has_dense_mlp:
+                # why: gemma4 enable_moe_block exposes routed experts at
+                # layers.<i>.experts (sibling of self.mlp), not under mlp.
+                _add_module_aliases(aliases, canonical, f"layers.{layer_idx}.experts")
+            elif name == "mlp.shared_expert":
+                # why: Exaone-MoE / Laguna / GLM-style configs use the plural
+                # `shared_experts` attribute name; register both spellings.
+                _add_module_aliases(
+                    aliases,
+                    canonical,
+                    f"layers.{layer_idx}.mlp.shared_experts",
+                )
+
+    if pli > 0:
+        canonical = "text.per_layer_model_projection"
+        elements[canonical] = hd_global * (arch.num_hidden_layers * pli)
+        _add_module_aliases(aliases, canonical, canonical.removeprefix("text."))
+
+    return elements, aliases
+
+
+def _compute_skipped_quantizable_elements(arch: ModelArchConfig) -> int:
+    if not arch.quantization_skip_modules:
+        return 0
+
+    module_elements, aliases = _build_text_module_elements(arch)
+    matched = set()
+    for skip_module in arch.quantization_skip_modules:
+        for alias, canonical in aliases.items():
+            if _module_path_matches(skip_module, alias):
+                matched.add(canonical)
+
+    pruned = {
+        canonical
+        for canonical in matched
+        if not any(
+            canonical != parent and canonical.startswith(f"{parent}.")
+            for parent in matched
+        )
+    }
+    return sum(module_elements[canonical] for canonical in pruned)
+
+
 def _get_kv_size(arch: ModelArchConfig) -> int:
     return (arch.hidden_size // arch.num_attention_heads) * arch.num_key_value_heads
 
@@ -226,6 +782,12 @@ def _get_mlp_size(arch: ModelArchConfig) -> int:
     return arch.intermediate_size
 
 
+def _dense_mlp_size(arch: ModelArchConfig) -> int:
+    # why: Llama4 dense layers use intermediate_size_mlp; routed/shared
+    # experts use intermediate_size. Other configs leave the field None.
+    return arch.dense_intermediate_size or arch.intermediate_size
+
+
 def _get_num_experts(arch: ModelArchConfig) -> int:
     return arch.num_experts if arch.num_experts and arch.num_experts > 1 else 1
 
@@ -248,14 +810,39 @@ def _compute_attn_elements(arch: ModelArchConfig) -> int:
 
 
 def _compute_dense_mlp_elements(arch: ModelArchConfig) -> int:
-    return arch.hidden_size * arch.intermediate_size * 3
+    return arch.hidden_size * _dense_mlp_size(arch) * 3
+
+
+def _shared_expert_size(arch: ModelArchConfig) -> int:
+    # why: Qwen3.5-MoE shared expert has its own intermediate_size (default 512)
+    # distinct from moe_intermediate_size; fall back to routed mlp_size for
+    # families that share it (deepseek-style configs).
+    return arch.shared_expert_intermediate_size or _get_mlp_size(arch)
+
+
+def _compute_routed_moe_elements(arch: ModelArchConfig) -> int:
+    hd = arch.hidden_size
+    n_experts = _get_num_experts(arch)
+    return hd * _get_mlp_size(arch) * 3 * n_experts + n_experts * hd
+
+
+def _compute_shared_moe_elements(arch: ModelArchConfig) -> int:
+    if not arch.n_shared_experts:
+        return 0
+    hd = arch.hidden_size
+    shared_size = _shared_expert_size(arch)
+    total = hd * shared_size * 3 * arch.n_shared_experts
+    # why: only Qwen2-MoE / Qwen3.5-MoE define a shared_expert_gate Linear
+    # (hidden_size→1); other families (Exaone-MoE, HY-V3, GLM4-MoE-Lite, Laguna)
+    # have shared_experts without a gate. shared_expert_intermediate_size is the
+    # Qwen-style discriminator.
+    if arch.shared_expert_intermediate_size:
+        total += arch.n_shared_experts * hd
+    return total
 
 
 def _compute_moe_mlp_elements(arch: ModelArchConfig) -> int:
-    hd = arch.hidden_size
-    mlp_size = _get_mlp_size(arch)
-    n_experts = _get_num_experts(arch)
-    return hd * mlp_size * 3 * (n_experts + arch.n_shared_experts) + n_experts * hd
+    return _compute_routed_moe_elements(arch) + _compute_shared_moe_elements(arch)
 
 
 def _compute_layer_elements(arch: ModelArchConfig):
@@ -267,22 +854,60 @@ def _compute_layer_elements(arch: ModelArchConfig):
     n_layers = arch.num_hidden_layers
     n_experts = _get_num_experts(arch)
 
-    attn_total = _compute_attn_elements(arch) * n_layers
-
-    if n_experts > 1:
+    if _uses_structured_layer_shapes(arch):
+        attn_total = 0
+        per_layer_dense_mlp = []
+        for layer_idx in range(n_layers):
+            layer_dense_mlp = 0
+            for name, (in_dim, out_dim) in _text_linear_dims(
+                arch,
+                layer_idx,
+            ).items():
+                elements = in_dim * out_dim
+                if name in ATTENTION_TARGET_MODULES:
+                    attn_total += elements
+                elif name in MLP_TARGET_MODULES:
+                    layer_dense_mlp += elements
+            per_layer_dense_mlp.append(layer_dense_mlp)
+        if n_experts > 1:
+            n_dense = arch.num_dense_layers
+            n_moe = n_layers - n_dense
+            moe_mlp_total = _compute_moe_mlp_elements(arch) * n_moe
+            if arch.moe_has_dense_mlp:
+                # why: enable_moe_block runs dense MLP and MoE experts in
+                # parallel; count dense for every layer alongside MoE.
+                mlp_total = sum(per_layer_dense_mlp) + moe_mlp_total
+            else:
+                dense_only_total = sum(
+                    value
+                    for i, value in enumerate(per_layer_dense_mlp)
+                    if _is_dense_mlp_layer(arch, i)
+                )
+                mlp_total = moe_mlp_total + dense_only_total
+        else:
+            mlp_total = sum(per_layer_dense_mlp)
+    elif n_experts > 1:
+        attn_total = _compute_attn_elements(arch) * n_layers
         n_dense = arch.num_dense_layers
         n_moe = n_layers - n_dense
-        mlp_total = (
-            _compute_moe_mlp_elements(arch) * n_moe
-            + _compute_dense_mlp_elements(arch) * n_dense
-        )
+        moe_mlp_total = _compute_moe_mlp_elements(arch) * n_moe
+        if arch.moe_has_dense_mlp:
+            mlp_total = _compute_dense_mlp_elements(arch) * n_layers + moe_mlp_total
+        else:
+            mlp_total = moe_mlp_total + _compute_dense_mlp_elements(arch) * n_dense
     else:
+        attn_total = _compute_attn_elements(arch) * n_layers
         mlp_total = _compute_dense_mlp_elements(arch) * n_layers
 
     layernorms = 2 * hd
-    embed_tokens = arch.vocab_size * hd
+    per_layer_embed = (
+        arch.vocab_size_per_layer_input * arch.hidden_size_per_layer_input * n_layers
+    )
+    ple_text_linear = _per_layer_input_quantizable(arch)
+    ple_norms = _per_layer_input_norm_elements(arch)
+    embed_tokens = arch.vocab_size * hd + per_layer_embed + ple_norms
     lm_head = 0 if arch.tie_word_embeddings else arch.vocab_size * hd
-    return attn_total + mlp_total, layernorms, embed_tokens, lm_head
+    return attn_total + mlp_total + ple_text_linear, layernorms, embed_tokens, lm_head
 
 
 def compute_model_weights_bytes(
@@ -295,7 +920,16 @@ def compute_model_weights_bytes(
     non_quantizable = layernorms * n_layers + embed_tokens + lm_head
 
     if training_method == "qlora" and load_in_4bit:
-        return int(total_quantizable * 2 / QUANT_4BIT_FACTOR + non_quantizable * 2)
+        skipped_quantizable = min(
+            _compute_skipped_quantizable_elements(arch),
+            total_quantizable,
+        )
+        quantized = total_quantizable - skipped_quantizable
+        return int(
+            quantized * 2 / arch.quant_4bit_factor
+            + skipped_quantizable * 2
+            + non_quantizable * 2
+        )
 
     return int((total_quantizable + non_quantizable) * 2)
 
@@ -363,46 +997,130 @@ def compute_lora_params(
     lora_rank: int,
     target_modules: list,
 ) -> int:
+    all_linear = _targets_all_linear(target_modules)
+    selected_modules = list(DEFAULT_TARGET_MODULES) if all_linear else target_modules
     hd = arch.hidden_size
     r = lora_rank
     n_layers = arch.num_hidden_layers
     n_experts = _get_num_experts(arch)
 
-    attn_total = _lora_attn_elements(arch, r, target_modules) * n_layers
-
-    if n_experts > 1:
+    use_structured_shapes = _uses_structured_layer_shapes(arch)
+    if use_structured_shapes:
+        attn_total = 0
+        structured_dense_mlp = 0
+        per_layer_dense_mlp = []
+        for layer_idx in range(n_layers):
+            layer_dense = 0
+            for name, (in_dim, out_dim) in _text_linear_dims(
+                arch,
+                layer_idx,
+            ).items():
+                if name not in selected_modules:
+                    continue
+                if name in ATTENTION_TARGET_MODULES:
+                    attn_total += in_dim * r + r * out_dim
+                elif name in MLP_TARGET_MODULES:
+                    layer_dense += in_dim * r + r * out_dim
+            per_layer_dense_mlp.append(layer_dense)
+            structured_dense_mlp += layer_dense
+        if n_experts > 1:
+            n_dense = arch.num_dense_layers
+            n_moe = n_layers - n_dense
+            # why: peft "all-linear" attaches LoRA to nn.Linear only;
+            # routed experts are nn.Parameter and need explicit
+            # gate_proj/up_proj/down_proj naming via Unsloth's
+            # get_moe_target_parameters. Shared experts are nn.Linear and
+            # are picked up by get_peft_regex.
+            routed_moe = (
+                0
+                if all_linear
+                else _lora_mlp_elements(
+                    hd,
+                    _get_mlp_size(arch),
+                    r,
+                    selected_modules,
+                    n_experts,
+                )
+            )
+            shared_moe = _lora_mlp_elements(
+                hd,
+                _shared_expert_size(arch),
+                r,
+                selected_modules,
+                arch.n_shared_experts,
+            )
+            moe_mlp = routed_moe + shared_moe
+            if arch.moe_has_dense_mlp:
+                # why: parallel dense MLP coexists with MoE on every layer.
+                mlp_total = structured_dense_mlp + moe_mlp * n_moe
+            else:
+                dense_only = sum(
+                    value
+                    for i, value in enumerate(per_layer_dense_mlp)
+                    if _is_dense_mlp_layer(arch, i)
+                )
+                mlp_total = moe_mlp * n_moe + dense_only
+        else:
+            mlp_total = structured_dense_mlp
+        return (
+            attn_total
+            + mlp_total
+            + _per_layer_input_lora_params(arch, r, target_modules)
+        )
+    elif n_experts > 1:
+        attn_total = _lora_attn_elements(arch, r, selected_modules) * n_layers
         n_dense = arch.num_dense_layers
         n_moe = n_layers - n_dense
-        # Include shared experts alongside routed experts
-        moe_expert_mult = n_experts + arch.n_shared_experts
-        moe_mlp = _lora_mlp_elements(
-            hd,
-            _get_mlp_size(arch),
-            r,
-            target_modules,
-            moe_expert_mult,
+        # why: routed and shared experts may use different intermediate sizes
+        # (Qwen3.5-MoE: routed mlp_size != shared_expert_intermediate_size).
+        # See structured branch for the all-linear exclusion rationale; only
+        # routed (nn.Parameter) experts are excluded under all-linear.
+        routed_moe = (
+            0
+            if all_linear
+            else _lora_mlp_elements(
+                hd,
+                _get_mlp_size(arch),
+                r,
+                selected_modules,
+                n_experts,
+            )
         )
+        shared_moe = _lora_mlp_elements(
+            hd,
+            _shared_expert_size(arch),
+            r,
+            selected_modules,
+            arch.n_shared_experts,
+        )
+        moe_mlp = routed_moe + shared_moe
         dense_mlp = _lora_mlp_elements(
             hd,
-            arch.intermediate_size,
+            _dense_mlp_size(arch),
             r,
-            target_modules,
+            selected_modules,
             1,
         )
-        mlp_total = moe_mlp * n_moe + dense_mlp * n_dense
+        if arch.moe_has_dense_mlp:
+            mlp_total = moe_mlp * n_moe + dense_mlp * n_layers
+        else:
+            mlp_total = moe_mlp * n_moe + dense_mlp * n_dense
     else:
+        attn_total = _lora_attn_elements(arch, r, selected_modules) * n_layers
         mlp_total = (
             _lora_mlp_elements(
                 hd,
-                arch.intermediate_size,
+                _dense_mlp_size(arch),
                 r,
-                target_modules,
+                selected_modules,
                 1,
             )
             * n_layers
         )
 
-    return attn_total + mlp_total
+    return (
+        attn_total + mlp_total + _per_layer_input_lora_params(arch, r, target_modules)
+    )
 
 
 def compute_lora_adapter_bytes(lora_params: int) -> int:
@@ -419,26 +1137,88 @@ def compute_gradient_bytes(trainable_params: int) -> int:
     return trainable_params * 2
 
 
+def _is_linear_attention(attention_implementation: Optional[str]) -> bool:
+    # why: PyTorch SDPA dispatches to flash/memory-efficient O(n) backends; only
+    # eager (and other non-flash impls) need the quadratic correction.
+    return attention_implementation in LINEAR_ATTENTION_IMPLS
+
+
+def _compute_non_flash_attention_bytes(
+    arch: ModelArchConfig,
+    batch_size: int,
+    seq_len: int,
+    effective_layers: float,
+) -> int:
+    score_elements = batch_size * arch.num_attention_heads * seq_len * seq_len
+    return int(score_elements * 2 * NON_FLASH_ATTENTION_FACTOR * effective_layers)
+
+
+def _layer_qkv_mlp_sizes(arch: ModelArchConfig, layer_idx: int) -> tuple:
+    n_experts = _get_num_experts(arch)
+    is_moe_layer = n_experts > 1 and not _is_dense_mlp_layer(arch, layer_idx)
+    if _uses_structured_layer_shapes(arch):
+        q_size, kv_size, _has_k, _has_v = _layer_attention_dims(arch, layer_idx)
+        # why: KV-shared layers (Gemma4/Gemma3n) drop k_proj/v_proj WEIGHTS but
+        # the donor layer's K/V tensors stay alive across the shared range, so
+        # activation memory still pays for kv_size; only the weight path uses
+        # has_k/has_v.
+        layer_type = _layer_types(arch)[layer_idx]
+        use_alt_attention = arch.attention_k_eq_v and layer_type != "sliding_attention"
+        kv_count = 1 if use_alt_attention else 2
+        qkv_size = q_size + kv_size * kv_count
+        if is_moe_layer:
+            # why: each token routes through `num_experts_per_tok` experts; their
+            # gate/up/down intermediates are all live during MLP forward.
+            mlp_size = _get_mlp_size(arch) * arch.num_experts_per_tok
+            if arch.n_shared_experts:
+                mlp_size += _shared_expert_size(arch) * arch.n_shared_experts
+            if arch.moe_has_dense_mlp:
+                mlp_size += _layer_mlp_size(arch, layer_idx)
+        else:
+            mlp_size = _layer_mlp_size(arch, layer_idx)
+        return qkv_size, mlp_size
+    kv_size = _get_kv_size(arch)
+    if is_moe_layer:
+        mlp_size = _get_mlp_size(arch) * arch.num_experts_per_tok
+        if arch.n_shared_experts:
+            mlp_size += _shared_expert_size(arch) * arch.n_shared_experts
+        if arch.moe_has_dense_mlp:
+            mlp_size += arch.intermediate_size
+    else:
+        mlp_size = _get_mlp_size(arch)
+    return arch.hidden_size + kv_size + kv_size, mlp_size
+
+
+def _per_layer_activation_bytes(
+    arch: ModelArchConfig,
+    layer_idx: int,
+    batch_size: int,
+    seq_len: int,
+) -> int:
+    qkv_size, mlp_size = _layer_qkv_mlp_sizes(arch, layer_idx)
+    activation_qkv = seq_len * batch_size * qkv_size
+    residual_memory = (seq_len * batch_size) * 2
+    activation_mlp = seq_len * batch_size * (mlp_size + mlp_size)
+    # why: per_layer_input_gate (hd-sized) and per_layer_projection (pli-sized)
+    # outputs materialize once per decoder layer when hidden_size_per_layer_input
+    # is set; see gemma4/modular_gemma4.py:1141-1145.
+    pli = arch.hidden_size_per_layer_input
+    activation_ple = seq_len * batch_size * (arch.hidden_size + pli) if pli > 0 else 0
+    return int(
+        (activation_qkv + residual_memory + activation_mlp + activation_ple) * 2 * 1.25
+    )
+
+
 def compute_activation_bytes(
     arch: ModelArchConfig,
     batch_size: int,
     seq_len: int,
     gradient_checkpointing: str,
     is_lora: bool = False,
+    attention_implementation: Optional[str] = "flash_attention_2",
 ) -> int:
-    hd = arch.hidden_size
-    kv_size = _get_kv_size(arch)
-    mlp_size = _get_mlp_size(arch)
-    bsz = batch_size
     n_layers = arch.num_hidden_layers
 
-    activation_qkv = seq_len * bsz * (hd + kv_size + kv_size)
-    residual_memory = (seq_len * bsz) * 2
-    activation_mlp = seq_len * bsz * (mlp_size + mlp_size)
-
-    per_layer_bytes = (activation_qkv + residual_memory + activation_mlp) * 2
-    per_layer_bytes = int(per_layer_bytes * 1.25)
-
     gc_key = gradient_checkpointing.lower()
     gc_entry = GC_LAYER_MULTIPLIERS.get(gc_key, (None, None))
     full_ft_mult, lora_mult = gc_entry
@@ -446,10 +1226,35 @@ def compute_activation_bytes(
 
     if gc_multiplier is None:
         effective_layers = n_layers
+        linear_bytes = sum(
+            _per_layer_activation_bytes(arch, i, batch_size, seq_len)
+            for i in range(n_layers)
+        )
     else:
         effective_layers = gc_multiplier
+        max_layer_bytes = max(
+            _per_layer_activation_bytes(arch, i, batch_size, seq_len)
+            for i in range(n_layers)
+        )
+        linear_bytes = int(max_layer_bytes * effective_layers)
 
-    return int(per_layer_bytes * effective_layers)
+    # why: gemma4 per_layer_model_projection runs once outside the per-decoder
+    # loop and materializes a [B, S, L, PLI] tensor; see modular_gemma4.py:1247.
+    pli = arch.hidden_size_per_layer_input
+    if pli > 0:
+        linear_bytes += int(seq_len * batch_size * n_layers * pli * 2 * 1.25)
+
+    if _is_linear_attention(attention_implementation):
+        return linear_bytes
+    return max(
+        linear_bytes,
+        _compute_non_flash_attention_bytes(
+            arch,
+            batch_size,
+            seq_len,
+            effective_layers,
+        ),
+    )
 
 
 def estimate_training_vram(
@@ -474,21 +1279,23 @@ def estimate_training_vram(
 
     trainable_params = lora_params if is_lora else compute_total_params(arch)
     optimizer_bytes = compute_optimizer_bytes(trainable_params, config.optimizer)
-    gradient_bytes = max(
-        compute_gradient_bytes(trainable_params),
-        int(model_weights * 0.15),
-    )
     activations_computed = compute_activation_bytes(
         arch,
         config.batch_size,
         config.max_seq_length,
         config.gradient_checkpointing,
         is_lora = is_lora,
+        attention_implementation = config.attention_implementation,
     )
-    activation_bytes = max(
-        activations_computed,
-        int(model_weights * 0.15 * (config.batch_size / 2)),
-    )
+    raw_gradient_bytes = compute_gradient_bytes(trainable_params)
+    gradient_floor = int(model_weights * 0.15)
+    if is_lora:
+        gradient_floor = min(
+            gradient_floor,
+            max(activations_computed, optimizer_bytes),
+        )
+    gradient_bytes = max(raw_gradient_bytes, gradient_floor)
+    activation_bytes = activations_computed
 
     return VramBreakdown(
         model_weights = model_weights,
diff --git a/studio/backend/utils/models/model_config.py b/studio/backend/utils/models/model_config.py
index a2b0c90e59..16f6d21edb 100644
--- a/studio/backend/utils/models/model_config.py
+++ b/studio/backend/utils/models/model_config.py
@@ -32,6 +32,7 @@ import threading
 import yaml
 
 
+from utils.native_path_leases import child_env_without_native_path_secret
 from utils.subprocess_compat import (
     windows_hidden_subprocess_kwargs as _windows_hidden_subprocess_kwargs,
 )
@@ -583,6 +584,7 @@ def _is_vision_model_subprocess(
             capture_output = True,
             text = True,
             timeout = 60,
+            env = child_env_without_native_path_secret(),
             **_windows_hidden_subprocess_kwargs(),
         )
 
@@ -1227,9 +1229,11 @@ def _resolve_gguf_dir(p: Path) -> Optional[Path]:
         return p
     if p.is_file() and p.suffix.lower() == ".gguf":
         parent = p.parent
-        if (parent / "config.json").exists() or (
-            parent / "adapter_config.json"
-        ).exists():
+        if (
+            (parent / "config.json").exists()
+            or (parent / "adapter_config.json").exists()
+            or (parent / "export_metadata.json").exists()
+        ):
             return parent
     return None
 
diff --git a/studio/backend/utils/native_path_leases.py b/studio/backend/utils/native_path_leases.py
new file mode 100644
index 0000000000..a69dfab532
--- /dev/null
+++ b/studio/backend/utils/native_path_leases.py
@@ -0,0 +1,406 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+"""Verification for Tauri native path signed grants.
+
+Rust signs compact ``base64url(payload_json).base64url(hmac)`` grants. The
+frontend can see and forward the grant, but cannot change it without breaking
+the HMAC. The backend verifies the original payload segment bytes, then
+re-stats the path before any native read.
+"""
+
+from __future__ import annotations
+
+import base64
+import binascii
+import hashlib
+import hmac
+import json
+import os
+import stat as _stat_module
+import threading
+import time
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable, Iterable, Iterator, Mapping
+
+LEASE_SECRET_ENV = "UNSLOTH_STUDIO_NATIVE_PATH_LEASE_SECRET"
+_MAX_NATIVE_PATH_REDACTIONS = 100
+_MAX_NATIVE_PATH_LABELS = 10_000
+_MIN_LEASE_SECRET_BYTES = 32
+
+_REPLAY_LOCK = threading.Lock()
+_USED_NONCES: dict[str, int] = {}
+_REDACTION_LOCK = threading.Lock()
+_NATIVE_PATH_REDACTIONS: list[str] = []
+_NATIVE_PATH_LABELS: dict[str, str] = {}
+_NATIVE_PATH_ENV_LOCK = threading.Lock()
+_SECRET_INIT_LOCK = threading.Lock()
+_CACHED_LEASE_SECRET: bytes | None = None
+_SCRUB_REFCOUNT = 0
+_SCRUB_SAVED_SECRET: str | None = None
+
+
+class NativePathLeaseError(ValueError):
+    """Raised when a native path grant is missing, invalid, or unsafe."""
+
+
+@dataclass(frozen = True)
+class NativePathGrant:
+    operation: str
+    canonical_path: Path
+    path_kind: str
+    path_type: str
+    source_kind: str
+    token_id_hash: str
+    display_label: str
+    expires_at_ms: int
+    size_bytes: int | None
+    modified_ms: int | None
+
+
+def native_path_leases_supported() -> bool:
+    try:
+        _decode_secret()
+    except NativePathLeaseError:
+        return False
+    return True
+
+
+def child_env_without_native_path_secret(
+    env: Mapping[str, str] | None = None,
+) -> dict[str, str]:
+    """Return a child-process env with the native path lease secret removed."""
+
+    if env is None:
+        with _NATIVE_PATH_ENV_LOCK:
+            cleaned = dict(os.environ)
+    else:
+        cleaned = dict(env)
+    cleaned.pop(LEASE_SECRET_ENV, None)
+    return cleaned
+
+
+def run_without_native_path_secret(
+    target: Callable[..., Any],
+    *args: Any,
+    **kwargs: Any,
+) -> Any:
+    """Run a multiprocessing child target without the native path lease secret."""
+
+    global _CACHED_LEASE_SECRET, _SCRUB_SAVED_SECRET
+    os.environ.pop(LEASE_SECRET_ENV, None)
+    _CACHED_LEASE_SECRET = None
+    _SCRUB_SAVED_SECRET = None
+    return target(*args, **kwargs)
+
+
+@contextmanager
+def native_path_secret_removed_for_child_start() -> Iterator[None]:
+    global _SCRUB_REFCOUNT, _SCRUB_SAVED_SECRET, _CACHED_LEASE_SECRET
+    with _NATIVE_PATH_ENV_LOCK:
+        if _SCRUB_REFCOUNT == 0:
+            _SCRUB_SAVED_SECRET = os.environ.pop(LEASE_SECRET_ENV, None)
+            _CACHED_LEASE_SECRET = None
+        _SCRUB_REFCOUNT += 1
+    try:
+        yield
+    finally:
+        with _NATIVE_PATH_ENV_LOCK:
+            _SCRUB_REFCOUNT -= 1
+            if _SCRUB_REFCOUNT == 0 and _SCRUB_SAVED_SECRET is not None:
+                os.environ[LEASE_SECRET_ENV] = _SCRUB_SAVED_SECRET
+                _SCRUB_SAVED_SECRET = None
+
+
+def verify_native_path_lease(
+    lease: str | None,
+    *,
+    operation: str,
+    expected_kind: str | None = None,
+    expected_path_type: str | None = None,
+    allowed_suffixes: Iterable[str] | None = None,
+) -> NativePathGrant:
+    if not lease:
+        raise NativePathLeaseError("Native path grant is required.")
+
+    secret = _decode_secret()
+    payload_b64, signature_b64 = _split_lease(lease)
+    expected_signature = hmac.new(
+        secret,
+        payload_b64.encode("ascii"),
+        hashlib.sha256,
+    ).digest()
+    supplied_signature = _b64decode(signature_b64)
+    if not hmac.compare_digest(expected_signature, supplied_signature):
+        raise NativePathLeaseError("Native path grant signature is invalid.")
+
+    payload = _decode_payload(payload_b64)
+    _validate_payload(payload, operation = operation, expected_kind = expected_kind)
+
+    path = Path(str(payload["canonical_path"]))
+    _reject_network_or_device_path(path)
+    try:
+        signed_lstat = os.lstat(path)
+    except OSError as exc:
+        raise NativePathLeaseError("Native path is no longer accessible.") from exc
+    if _stat_module.S_ISLNK(signed_lstat.st_mode):
+        raise NativePathLeaseError("Native path is no longer a regular file.")
+    try:
+        resolved = path.resolve(strict = True)
+    except OSError as exc:
+        raise NativePathLeaseError("Native path is no longer accessible.") from exc
+    _reject_network_or_device_path(resolved)
+    if not _same_native_path(resolved, path):
+        raise NativePathLeaseError(
+            "Native path grant no longer resolves to the selected path."
+        )
+
+    grant = NativePathGrant(
+        operation = str(payload["operation"]),
+        canonical_path = resolved,
+        path_kind = str(payload["path_kind"]),
+        path_type = str(payload["path_type"]),
+        source_kind = str(payload["source_kind"]),
+        token_id_hash = str(payload["token_id_hash"]),
+        display_label = str(payload.get("display_label") or resolved.name),
+        expires_at_ms = _required_int(payload, "expires_at_ms"),
+        size_bytes = _optional_int(payload.get("size_bytes")),
+        modified_ms = _optional_int(payload.get("modified_ms")),
+    )
+
+    if expected_path_type and grant.path_type != expected_path_type:
+        raise NativePathLeaseError("Native path grant has the wrong path type.")
+    suffixes = tuple(s.lower() for s in (allowed_suffixes or ()))
+    if suffixes and resolved.suffix.lower() not in suffixes:
+        raise NativePathLeaseError("Native path grant has an unsupported file type.")
+
+    _validate_current_stat(grant)
+    _consume_nonce(str(payload["nonce"]), grant.expires_at_ms)
+    _remember_native_path_for_redaction(str(resolved), grant.display_label)
+    return grant
+
+
+def display_label_for_native_path(value: str | None) -> str | None:
+    if not value:
+        return value
+    with _REDACTION_LOCK:
+        return _NATIVE_PATH_LABELS.get(value, value)
+
+
+def is_registered_native_path_label(path_value: str | None, label: str | None) -> bool:
+    if not path_value or not label:
+        return False
+    with _REDACTION_LOCK:
+        return _NATIVE_PATH_LABELS.get(path_value) == label
+
+
+def redact_native_paths(value: str) -> str:
+    with _REDACTION_LOCK:
+        paths = sorted(_NATIVE_PATH_REDACTIONS, key = len, reverse = True)
+    redacted = value
+    for path in paths:
+        for variant in {path, path.replace("/", "\\"), path.replace("\\", "/")}:
+            if variant:
+                redacted = redacted.replace(variant, "<native_path>")
+    return redacted
+
+
+def _decode_secret() -> bytes:
+    global _CACHED_LEASE_SECRET
+    if _CACHED_LEASE_SECRET is not None:
+        return _CACHED_LEASE_SECRET
+    with _SECRET_INIT_LOCK:
+        if _CACHED_LEASE_SECRET is not None:
+            return _CACHED_LEASE_SECRET
+        with _NATIVE_PATH_ENV_LOCK:
+            encoded = os.environ.get(LEASE_SECRET_ENV)
+            if encoded is None and _SCRUB_SAVED_SECRET is not None:
+                encoded = _SCRUB_SAVED_SECRET
+        if not encoded:
+            raise NativePathLeaseError(
+                "Native path grants require the managed desktop backend."
+            )
+        try:
+            secret = _b64decode(encoded)
+        except Exception as exc:
+            raise NativePathLeaseError("Native path grant secret is invalid.") from exc
+        if len(secret) < _MIN_LEASE_SECRET_BYTES:
+            raise NativePathLeaseError("Native path grant secret is invalid.")
+        _CACHED_LEASE_SECRET = secret
+        return secret
+
+
+def _split_lease(lease: str) -> tuple[str, str]:
+    if not isinstance(lease, str):
+        raise NativePathLeaseError("Native path grant has an invalid format.")
+    try:
+        lease.encode("ascii")
+    except UnicodeEncodeError as exc:
+        raise NativePathLeaseError("Native path grant has an invalid format.") from exc
+    parts = lease.split(".")
+    if len(parts) != 2 or not parts[0] or not parts[1]:
+        raise NativePathLeaseError("Native path grant has an invalid format.")
+    return parts[0], parts[1]
+
+
+def _decode_payload(payload_b64: str) -> dict[str, Any]:
+    try:
+        payload = json.loads(_b64decode(payload_b64).decode("utf-8"))
+    except Exception as exc:
+        raise NativePathLeaseError("Native path grant payload is invalid.") from exc
+    if not isinstance(payload, dict):
+        raise NativePathLeaseError("Native path grant payload is invalid.")
+    return payload
+
+
+def _validate_payload(
+    payload: dict[str, Any], *, operation: str, expected_kind: str | None
+) -> None:
+    required = (
+        "version",
+        "operation",
+        "canonical_path",
+        "path_kind",
+        "path_type",
+        "source_kind",
+        "token_id_hash",
+        "issued_at_ms",
+        "expires_at_ms",
+        "nonce",
+    )
+    missing = [key for key in required if key not in payload]
+    if missing:
+        raise NativePathLeaseError(
+            "Native path grant payload is missing required fields."
+        )
+    if _required_int(payload, "version") != 1:
+        raise NativePathLeaseError("Native path grant version is unsupported.")
+    if payload["operation"] != operation:
+        raise NativePathLeaseError("Native path grant operation is invalid.")
+    if expected_kind and payload["path_kind"] != expected_kind:
+        raise NativePathLeaseError("Native path grant kind is invalid.")
+    now_ms = int(time.time() * 1000)
+    issued_at_ms = _required_int(payload, "issued_at_ms")
+    expires_at_ms = _required_int(payload, "expires_at_ms")
+    if issued_at_ms >= expires_at_ms:
+        raise NativePathLeaseError("Native path grant timestamps are inconsistent.")
+    if expires_at_ms <= now_ms:
+        raise NativePathLeaseError("Native path grant has expired.")
+    if issued_at_ms > now_ms + 30_000:
+        raise NativePathLeaseError("Native path grant issue time is invalid.")
+    for key in ("canonical_path", "nonce", "token_id_hash", "display_label"):
+        raw = payload.get(key)
+        if raw is None:
+            continue
+        if "\x00" in str(raw):
+            raise NativePathLeaseError("Native path grant contains invalid characters.")
+
+
+def _validate_current_stat(grant: NativePathGrant) -> None:
+    try:
+        st = os.lstat(grant.canonical_path)
+    except OSError as exc:
+        raise NativePathLeaseError("Native path is no longer accessible.") from exc
+    if _stat_module.S_ISLNK(st.st_mode):
+        raise NativePathLeaseError("Native path is no longer a regular file.")
+    if grant.path_type == "file":
+        if not _stat_module.S_ISREG(st.st_mode):
+            raise NativePathLeaseError("Native path is no longer a regular file.")
+    elif grant.path_type == "directory":
+        if not _stat_module.S_ISDIR(st.st_mode):
+            raise NativePathLeaseError("Native path is no longer a directory.")
+    else:
+        raise NativePathLeaseError("Native path grant has an unsupported path type.")
+
+    if grant.size_bytes is not None and st.st_size != grant.size_bytes:
+        raise NativePathLeaseError("Native path changed after it was selected.")
+    current_modified_ms = int(st.st_mtime_ns // 1_000_000)
+    if grant.modified_ms is not None and current_modified_ms != grant.modified_ms:
+        raise NativePathLeaseError("Native path changed after it was selected.")
+
+
+def _consume_nonce(nonce: str, expires_at_ms: int) -> None:
+    now_ms = int(time.time() * 1000)
+    with _REPLAY_LOCK:
+        for key, expiry in list(_USED_NONCES.items()):
+            if expiry <= now_ms:
+                _USED_NONCES.pop(key, None)
+        if nonce in _USED_NONCES:
+            raise NativePathLeaseError("Native path grant was already used.")
+        _USED_NONCES[nonce] = expires_at_ms
+
+
+def _remember_native_path_for_redaction(path: str, display_label: str) -> None:
+    with _REDACTION_LOCK:
+        _NATIVE_PATH_LABELS[path] = display_label
+        if len(_NATIVE_PATH_LABELS) > _MAX_NATIVE_PATH_LABELS:
+            excess = len(_NATIVE_PATH_LABELS) - _MAX_NATIVE_PATH_LABELS
+            for stale_path in list(_NATIVE_PATH_LABELS.keys())[:excess]:
+                _NATIVE_PATH_LABELS.pop(stale_path, None)
+        if path in _NATIVE_PATH_REDACTIONS:
+            return
+        _NATIVE_PATH_REDACTIONS.append(path)
+        del _NATIVE_PATH_REDACTIONS[:-_MAX_NATIVE_PATH_REDACTIONS]
+
+
+def _reject_network_or_device_path(path: Path) -> None:
+    text = str(path)
+    if os.name == "nt":
+        normalized = text.replace("/", "\\").lower()
+        if normalized.startswith("\\\\?\\"):
+            rest = normalized[4:]
+            is_local_drive = len(rest) >= 3 and rest[0].isalpha() and rest[1:3] == ":\\"
+            if not is_local_drive:
+                raise NativePathLeaseError(
+                    "Network paths are not supported for native grants."
+                )
+        elif normalized.startswith("\\\\"):
+            raise NativePathLeaseError(
+                "Network paths are not supported for native grants."
+            )
+    if os.name != "nt":
+        for root in ("/dev", "/proc", "/sys"):
+            if path.is_relative_to(root):
+                raise NativePathLeaseError(
+                    "Device and virtual filesystem paths are not supported."
+                )
+    if "\x00" in text:
+        raise NativePathLeaseError("Native path contains invalid characters.")
+
+
+def _b64decode(value: str) -> bytes:
+    try:
+        padding = "=" * (-len(value) % 4)
+        return base64.urlsafe_b64decode((value + padding).encode("ascii"))
+    except (UnicodeEncodeError, binascii.Error, ValueError) as exc:
+        raise NativePathLeaseError("Native path grant has an invalid format.") from exc
+
+
+def _same_native_path(resolved: Path, signed: Path) -> bool:
+    try:
+        return resolved.samefile(signed)
+    except OSError:
+        return os.path.normcase(str(resolved)) == os.path.normcase(str(signed))
+
+
+def _optional_int(value: Any) -> int | None:
+    if value is None:
+        return None
+    try:
+        return int(value)
+    except (TypeError, ValueError) as exc:
+        raise NativePathLeaseError("Native path grant payload is invalid.") from exc
+
+
+def _required_int(payload: dict[str, Any], key: str) -> int:
+    raw = payload.get(key)
+    if raw is None:
+        raise NativePathLeaseError(
+            "Native path grant payload is missing required fields."
+        )
+    try:
+        return int(raw)
+    except (TypeError, ValueError) as exc:
+        raise NativePathLeaseError("Native path grant payload is invalid.") from exc
diff --git a/studio/backend/utils/transformers_version.py b/studio/backend/utils/transformers_version.py
index f36bdcd6e8..17af40f663 100644
--- a/studio/backend/utils/transformers_version.py
+++ b/studio/backend/utils/transformers_version.py
@@ -36,6 +36,7 @@ import subprocess
 import sys
 from pathlib import Path
 
+from utils.native_path_leases import child_env_without_native_path_secret
 from utils.subprocess_compat import (
     windows_hidden_subprocess_kwargs as _windows_hidden_subprocess_kwargs,
 )
@@ -63,6 +64,7 @@ TRANSFORMERS_5_MODEL_SUBSTRINGS: tuple[str, ...] = (
 TRANSFORMERS_550_MODEL_SUBSTRINGS: tuple[str, ...] = (
     "gemma-4",  # Gemma-4 (E2B-it, E4B-it, 31B-it, 26B-A4B-it)
     "gemma4",  # Gemma-4 alternate naming
+    "qwen3.6",
 )
 
 # Architecture classes / model_type values that require transformers 5.5.0.
@@ -503,6 +505,7 @@ def _install_to_dir(pkg: str, target_dir: str) -> bool:
             stdout = subprocess.PIPE,
             stderr = subprocess.STDOUT,
             text = True,
+            env = child_env_without_native_path_secret(),
             **_windows_hidden_subprocess_kwargs(),
         )
         if result.returncode == 0:
@@ -525,6 +528,7 @@ def _install_to_dir(pkg: str, target_dir: str) -> bool:
         stdout = subprocess.PIPE,
         stderr = subprocess.STDOUT,
         text = True,
+        env = child_env_without_native_path_secret(),
         **_windows_hidden_subprocess_kwargs(),
     )
     if result.returncode != 0:
diff --git a/studio/backend/utils/wheel_utils.py b/studio/backend/utils/wheel_utils.py
index 00240f1e69..3ed9bda827 100644
--- a/studio/backend/utils/wheel_utils.py
+++ b/studio/backend/utils/wheel_utils.py
@@ -13,6 +13,8 @@ import urllib.error
 import urllib.request
 from typing import Callable
 
+from utils.native_path_leases import child_env_without_native_path_secret
+
 _logger = logging.getLogger(__name__)
 
 FLASH_ATTN_RELEASE_BASE_URL = (
@@ -59,6 +61,7 @@ def probe_torch_wheel_env(*, timeout: int | None = None) -> dict[str, str] | Non
             stderr = subprocess.PIPE,
             text = True,
             timeout = timeout,
+            env = child_env_without_native_path_secret(),
         )
     except subprocess.TimeoutExpired:
         return None
@@ -142,6 +145,7 @@ def install_wheel(
             stdout = subprocess.PIPE,
             stderr = subprocess.STDOUT,
             text = True,
+            env = child_env_without_native_path_secret(),
         )
         attempts.append(("uv", result))
         if result.returncode == 0:
@@ -153,6 +157,7 @@ def install_wheel(
         stdout = subprocess.PIPE,
         stderr = subprocess.STDOUT,
         text = True,
+        env = child_env_without_native_path_secret(),
     )
     attempts.append(("pip", result))
     return attempts
diff --git a/studio/frontend/package.json b/studio/frontend/package.json
index c5cb949ccd..6b24440964 100644
--- a/studio/frontend/package.json
+++ b/studio/frontend/package.json
@@ -16,6 +16,7 @@
     "biome:fix": "biome check . --write"
   },
   "dependencies": {
+    "@assistant-ui/core": "0.1.17",
     "@assistant-ui/react": "^0.12.19",
     "@assistant-ui/react-markdown": "^0.12.3",
     "@assistant-ui/react-streamdown": "^0.1.2",
@@ -42,6 +43,8 @@
     "@tanstack/react-router": "^1.159.10",
     "@tanstack/react-table": "^8.21.3",
     "@tauri-apps/api": "^2.10.1",
+    "@tauri-apps/plugin-clipboard-manager": "^2.3.2",
+    "@tauri-apps/plugin-notification": "^2.3.3",
     "@tauri-apps/plugin-opener": "^2.5.3",
     "@tauri-apps/plugin-process": "^2.3.1",
     "@tauri-apps/plugin-updater": "^2.10.1",
diff --git a/studio/frontend/src/app/auth-guards.ts b/studio/frontend/src/app/auth-guards.ts
index 509b8f61af..52230f0b6f 100644
--- a/studio/frontend/src/app/auth-guards.ts
+++ b/studio/frontend/src/app/auth-guards.ts
@@ -9,7 +9,6 @@ import {
   hasRefreshToken,
   mustChangePassword,
   refreshSession,
-  tauriAutoAuth,
 } from "@/features/auth";
 
 async function hasActiveSession(): Promise<boolean> {
@@ -39,7 +38,7 @@ function authRedirect(to: "/login" | "/change-password"): never {
 
 export async function requireAuth(): Promise<void> {
   if (isTauri) {
-    await tauriAutoAuth();
+    // AppProvider owns backend startup + desktop auth; route guards run before it mounts.
     return;
   }
 
@@ -59,7 +58,6 @@ export async function requireAuth(): Promise<void> {
 
 export async function requireGuest(): Promise<void> {
   if (isTauri) {
-    await tauriAutoAuth();
     throw redirect({ to: "/chat" });
   }
   if (!(await hasActiveSession())) return;
@@ -68,7 +66,6 @@ export async function requireGuest(): Promise<void> {
 
 export async function requirePasswordChangeFlow(): Promise<void> {
   if (isTauri) {
-    await tauriAutoAuth();
     throw redirect({ to: "/chat" });
   }
 
diff --git a/studio/frontend/src/app/provider.tsx b/studio/frontend/src/app/provider.tsx
index b75998a169..62e78b809a 100644
--- a/studio/frontend/src/app/provider.tsx
+++ b/studio/frontend/src/app/provider.tsx
@@ -4,12 +4,19 @@
 import { StartupScreen } from "@/components/tauri/startup-screen";
 import { UpdateBanner } from "@/components/tauri/update-banner";
 import { UpdateScreen } from "@/components/tauri/update-screen";
+import {
+  WindowTitlebar,
+  shouldUseCustomWindowTitlebar,
+} from "@/components/tauri/window-titlebar";
 import { Toaster } from "@/components/ui/sonner";
-import { useTauriBackend } from "@/hooks/use-tauri-backend";
+import { getTauriAuthFailure, tauriAutoAuth } from "@/features/auth";
+import { NativeIntentDrain } from "@/features/native-intents/native-intent-drain";
+import { useTauriBackend, type BackendStatus } from "@/hooks/use-tauri-backend";
 import { useTauriUpdate } from "@/hooks/use-tauri-update";
 import { isTauri } from "@/lib/api-base";
+import { useRouterState } from "@tanstack/react-router";
 import { ThemeProvider } from "next-themes";
-import { useEffect, useRef, type ReactNode } from "react";
+import { useEffect, useRef, useState, type ReactNode } from "react";
 
 interface AppProviderProps {
   children: ReactNode;
@@ -19,67 +26,85 @@ interface AppProviderProps {
 // Tauri window helpers (only imported in Tauri mode)
 // ---------------------------------------------------------------------------
 
-async function showWindow(): Promise<void> {
+type TauriWindowMode = "setup" | "app";
+type WindowLayoutGuard = () => boolean;
+
+async function showSetupWindow(isCurrent: WindowLayoutGuard): Promise<void> {
   const { getCurrentWindow } = await import("@tauri-apps/api/window");
-  await getCurrentWindow().show();
-}
+  if (!isCurrent()) return;
 
-function easeOutQuart(t: number): number {
-  return 1 - (1 - t) ** 4;
-}
-
-async function animateToGoldenRatio(abortRef: { current: boolean }): Promise<void> {
-  const { getCurrentWindow, currentMonitor, LogicalSize } = await import("@tauri-apps/api/window");
   const win = getCurrentWindow();
-
-  // Ensure window is visible before resizing
+  if (!isCurrent()) return;
+  await win.center();
+  if (!isCurrent()) return;
   await win.show();
+}
 
+async function applyAppWindowLayout(isCurrent: WindowLayoutGuard): Promise<void> {
+  const { getCurrentWindow, currentMonitor, LogicalSize } = await import("@tauri-apps/api/window");
+  if (!isCurrent()) return;
+
+  const win = getCurrentWindow();
   const monitor = await currentMonitor();
-  if (!monitor) return;
+  if (!isCurrent()) return;
 
-  // Convert physical pixels to logical using scale factor
-  const scale = monitor.scaleFactor;
-  const screenW = monitor.size.width / scale;
-  const screenH = monitor.size.height / scale;
+  let finalW = 900;
+  let finalH = 600;
 
-  // Target: 75% of screen width, golden ratio height, capped at min 900x600
-  const targetW = Math.max(900, Math.round(screenW * 0.75));
-  const targetH = Math.max(600, Math.round(targetW / 1.618));
-  // Don't exceed screen height
-  const finalH = Math.min(targetH, Math.round(screenH * 0.85));
-  const finalW = targetW;
+  if (monitor) {
+    // Convert physical pixels to logical using scale factor
+    const scale = monitor.scaleFactor;
+    const screenW = monitor.size.width / scale;
+    const screenH = monitor.size.height / scale;
 
-  // Check reduced motion preference
-  const prefersReducedMotion = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
-
-  if (prefersReducedMotion) {
-    await win.setSize(new LogicalSize(finalW, finalH));
-  } else {
-    // Read current size instead of hardcoding — stays correct if tauri.conf.json changes
-    const inner = await win.innerSize();
-    const factor = await win.scaleFactor();
-    const startW = Math.round(inner.width / factor);
-    const startH = Math.round(inner.height / factor);
-    const steps = 15;
-    const stepDuration = 23; // ~350ms total
-
-    for (let i = 1; i <= steps; i++) {
-      if (abortRef.current) return;
-      const t = easeOutQuart(i / steps);
-      const w = Math.round(startW + (finalW - startW) * t);
-      const h = Math.round(startH + (finalH - startH) * t);
-      await win.setSize(new LogicalSize(w, h));
-      await new Promise((r) => setTimeout(r, stepDuration));
-    }
+    // Target: 75% of screen width, golden ratio height, capped at min 900x600
+    finalW = Math.max(900, Math.round(screenW * 0.75));
+    const targetH = Math.max(600, Math.round(finalW / 1.618));
+    // Don't exceed screen height
+    finalH = Math.min(targetH, Math.round(screenH * 0.85));
   }
 
-  if (abortRef.current) return;
-
-  // Apply constraints and finalize
-  await win.setResizable(true);
+  // Apply constraints and finalize without animating through intermediate sizes
+  if (!isCurrent()) return;
+  await win.setSize(new LogicalSize(finalW, finalH));
+  if (!isCurrent()) return;
   await win.setSizeConstraints({ minWidth: 900, minHeight: 600 });
+  if (!isCurrent()) return;
+  await win.setResizable(true);
+  if (!isCurrent()) return;
   await win.center();
+  if (!isCurrent()) return;
+  await win.show();
+}
+
+async function showWindowFallback(): Promise<void> {
+  const { getCurrentWindow } = await import("@tauri-apps/api/window");
+  const win = getCurrentWindow();
+  await win.setResizable(true);
+  await win.show();
+}
+
+function getTauriWindowMode(
+  status: BackendStatus,
+  hasEnteredAppMode: boolean,
+): TauriWindowMode | null {
+  switch (status) {
+    case "checking":
+      return null;
+    case "not-installed":
+    case "installing":
+    case "install-error":
+    case "needs-elevation":
+    case "repairing":
+    case "repair-error":
+      return "setup";
+    case "starting":
+    case "running":
+    case "stopped":
+      return "app";
+    case "error":
+      return hasEnteredAppMode ? "app" : "setup";
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -103,6 +128,7 @@ function TauriUpdateLayer({ isExternalServer }: { isExternalServer: boolean }) {
         error={update.error}
         onRetry={update.retryUpdate}
         onSkipRestart={update.skipAndRestart}
+        onCopyDiagnostics={update.copyDiagnostics}
       />
     );
   }
@@ -112,62 +138,147 @@ function TauriUpdateLayer({ isExternalServer }: { isExternalServer: boolean }) {
       status={update.status}
       info={update.info}
       dismissed={update.dismissed}
+      lastFailure={update.lastFailure}
       isExternalServer={isExternalServer}
       onInstall={update.installUpdate}
       onDismiss={update.dismiss}
+      onCopyDiagnostics={update.copyDiagnostics}
     />
   );
 }
 
+const HIDDEN_TITLEBAR_SIDEBAR_ROUTES = new Set([
+  "/onboarding",
+  "/login",
+  "/change-password",
+  "/signup",
+]);
+
 function TauriWrapper({ children }: { children: ReactNode }) {
+  const pathname = useRouterState({ select: (s) => s.location.pathname });
   const {
     status, logs, error, isExternalServer,
     currentStepIndex, progressDetail, elevationPackages,
-    startInstall, retry, retryInstall, approveElevation,
+    startInstall, retry, retryInstall, approveElevation, copyDiagnostics,
   } = useTauriBackend();
 
-  const hasResized = useRef(false);
-  const abortRef = useRef(false);
+  const appliedWindowModeRef = useRef<TauriWindowMode | null>(null);
+  const hasEnteredAppModeRef = useRef(false);
+  const windowLayoutGenerationRef = useRef(0);
+  const [desktopAuthReady, setDesktopAuthReady] = useState(!isTauri);
+  const [desktopAuthRetry, setDesktopAuthRetry] = useState(0);
 
-  // Show the window once the frontend mounts (for pre-running states)
   useEffect(() => {
-    if (isTauri) void showWindow();
+    if (!isTauri) return;
+    return () => {
+      windowLayoutGenerationRef.current += 1;
+      appliedWindowModeRef.current = null;
+    };
   }, []);
 
-  // Animate resize when backend becomes ready
+  // Keep the Tauri window hidden during preflight, then show it centered in setup
+  // mode or apply the final app layout in one instant step.
   useEffect(() => {
-    if (status === "running" && !hasResized.current) {
-      hasResized.current = true;
-      abortRef.current = false;
-      animateToGoldenRatio(abortRef).catch(async () => {
-        // On failure, at minimum make the window resizable so user can fix manually
-        try {
-          const { getCurrentWindow } = await import("@tauri-apps/api/window");
-          await getCurrentWindow().setResizable(true);
-        } catch { /* swallow — window may still be functional */ }
-      });
+    if (!isTauri) return;
+
+    const nextMode = getTauriWindowMode(status, hasEnteredAppModeRef.current);
+    if (!nextMode) {
+      appliedWindowModeRef.current = null;
+      windowLayoutGenerationRef.current += 1;
+      return;
     }
-    return () => { abortRef.current = true; };
+    if (appliedWindowModeRef.current === nextMode) return;
+
+    appliedWindowModeRef.current = nextMode;
+    if (nextMode === "app") hasEnteredAppModeRef.current = true;
+
+    const layoutGeneration = windowLayoutGenerationRef.current + 1;
+    windowLayoutGenerationRef.current = layoutGeneration;
+    const isCurrent = () => windowLayoutGenerationRef.current === layoutGeneration;
+    const applyWindowMode = nextMode === "setup" ? showSetupWindow : applyAppWindowLayout;
+    applyWindowMode(isCurrent).catch(async () => {
+      if (!isCurrent()) return;
+      // On failure, at minimum make the window visible and resizable so user can fix manually.
+      try {
+        await showWindowFallback();
+      } catch { /* swallow — window may still be functional */ }
+    });
   }, [status]);
 
-  if (!isTauri) return <>{children}</>;
-  if (status === "running") return <><TauriUpdateLayer isExternalServer={isExternalServer} />{children}</>;
+  useEffect(() => {
+    if (!isTauri) {
+      setDesktopAuthReady(true);
+      return;
+    }
+    if (status !== "running") {
+      setDesktopAuthReady(false);
+      setDesktopAuthRetry(0);
+      return;
+    }
 
-  return (
+    let disposed = false;
+    setDesktopAuthReady(false);
+    tauriAutoAuth({ force: true }).then((authenticated) => {
+      if (disposed) return;
+      if (authenticated) {
+        setDesktopAuthReady(true);
+        return;
+      }
+      if (!getTauriAuthFailure()) {
+        window.setTimeout(() => {
+          if (!disposed) setDesktopAuthRetry((value) => value + 1);
+        }, 500);
+      }
+    });
+
+    return () => { disposed = true; };
+  }, [status, desktopAuthRetry]);
+
+  if (!isTauri) return <>{children}</>;
+
+  const showApp = status === "running" && desktopAuthReady;
+  const startupStatus = status === "running" ? "starting" : status;
+  const startupProgressDetail =
+    status === "running" && !desktopAuthReady
+      ? "Signing in to desktop session..."
+      : progressDetail;
+
+  const content = showApp ? (
+    <>
+      <TauriUpdateLayer isExternalServer={isExternalServer} />
+      <NativeIntentDrain />
+      {children}
+    </>
+  ) : (
     <StartupScreen
-      status={status}
+      status={startupStatus}
       logs={logs}
       error={error}
       currentStepIndex={currentStepIndex}
-      progressDetail={progressDetail}
+      progressDetail={startupProgressDetail}
       elevationPackages={elevationPackages}
       onInstall={startInstall}
       onRetry={retry}
       onRetryInstall={retryInstall}
       onApproveElevation={approveElevation}
       onStartServer={retry}
+      onCopyDiagnostics={copyDiagnostics}
     />
   );
+
+  if (!shouldUseCustomWindowTitlebar()) return content;
+
+  const showSidebarSurface =
+    showApp && !HIDDEN_TITLEBAR_SIDEBAR_ROUTES.has(pathname);
+
+  return (
+    <div className="flex h-dvh min-h-0 flex-col overflow-hidden bg-background [--studio-titlebar-height:34px]">
+      <WindowTitlebar showSidebarSurface={showSidebarSurface} />
+      <div className="min-h-0 flex-1 overflow-hidden">
+        {content}
+      </div>
+    </div>
+  );
 }
 
 export function AppProvider({ children }: AppProviderProps) {
diff --git a/studio/frontend/src/app/routes/__root.tsx b/studio/frontend/src/app/routes/__root.tsx
index 19b5763557..22d149473c 100644
--- a/studio/frontend/src/app/routes/__root.tsx
+++ b/studio/frontend/src/app/routes/__root.tsx
@@ -81,7 +81,7 @@ function RootLayout() {
           pinned={pinned}
           setPinned={setPinned}
           togglePinned={togglePinned}
-          className="!min-h-0 h-dvh overflow-hidden"
+          className="!min-h-0 h-[calc(100dvh-var(--studio-titlebar-height,0px))] overflow-hidden"
         >
           <AppSidebar />
           <SidebarInset className={isChatRoute ? "overflow-hidden" : "overflow-y-auto"}>
diff --git a/studio/frontend/src/components/app-sidebar.tsx b/studio/frontend/src/components/app-sidebar.tsx
index 6d029a59bd..edcd5120eb 100644
--- a/studio/frontend/src/components/app-sidebar.tsx
+++ b/studio/frontend/src/components/app-sidebar.tsx
@@ -31,19 +31,18 @@ import {
 import { useAnimatedThemeToggle } from "@/components/ui/animated-theme-toggler";
 import { cn } from "@/lib/utils";
 import {
-  Book03Icon,
   ChefHatIcon,
   ColumnInsertIcon,
   CursorInfo02Icon,
   Delete02Icon,
   Download03Icon,
   GemIcon,
-  MessageSearch01Icon,
+  Globe02Icon,
   Search01Icon,
-  NewReleasesIcon,
   PowerIcon,
   PencilEdit02Icon,
   LayoutAlignLeftIcon,
+  HelpCircleIcon,
   Settings02Icon,
   ZapIcon,
 } from "@hugeicons/core-free-icons";
@@ -527,9 +526,9 @@ export function AppSidebar() {
                       className="!size-8"
                     />
                   </div>
-                  <div className="flex flex-col gap-0.5 leading-none group-data-[collapsible=icon]:hidden">
+                  <div className="flex flex-col gap-0.5 leading-tight group-data-[collapsible=icon]:hidden">
                     <span className="truncate font-heading text-[13px] tracking-[0.02em] font-semibold text-[#383835] dark:text-[#c7c7c4]">{displayTitle}</span>
-                    <span className="truncate text-[11px] tracking-[0.01em] text-muted-foreground">Studio</span>
+                    <span className="truncate text-[11px] tracking-[0.01em] text-muted-foreground">Unsloth</span>
                   </div>
                   <ChevronsUpDown strokeWidth={1.25} className="ml-auto size-4 text-muted-foreground group-data-[collapsible=icon]:hidden" />
                 </SidebarMenuButton>
@@ -547,6 +546,15 @@ export function AppSidebar() {
                     <span>Settings</span>
                     <DropdownMenuShortcut>⌘,</DropdownMenuShortcut>
                   </DropdownMenuItem>
+                  <DropdownMenuItem
+                    onSelect={() => useSettingsDialogStore.getState().openDialog("api-keys")}
+                  >
+                    <HugeiconsIcon icon={Globe02Icon} strokeWidth={1.75} className="size-[18px]" />
+                    <span>API</span>
+                    <span className="ml-auto rounded-[6px] border border-emerald-500/25 bg-emerald-500/10 px-1.5 py-0.5 text-[10px] leading-none font-semibold text-emerald-700 dark:text-emerald-300">
+                      New
+                    </span>
+                  </DropdownMenuItem>
                   <DropdownMenuItem
                     ref={anchorRef as React.Ref<HTMLDivElement>}
                     onSelect={(e) => { e.preventDefault(); toggleTheme(); }}
@@ -571,47 +579,12 @@ export function AppSidebar() {
                   </DropdownMenuItem>
                 </DropdownMenuGroup>
                 <DropdownMenuSeparator className="mx-2.5! my-2.5! h-0! border-t border-border/70 bg-transparent!" />
-                <DropdownMenuGroup>
-                  <DropdownMenuItem asChild>
-                    <a
-                      href="https://unsloth.ai/docs"
-                      target="_blank"
-                      rel="noopener noreferrer"
-                    >
-                      <HugeiconsIcon icon={Book03Icon} strokeWidth={1.75} className="size-[18px]" />
-                      <span>Learn More</span>
-                    </a>
-                  </DropdownMenuItem>
-                  <DropdownMenuItem asChild>
-                    <a
-                      href="https://unsloth.ai/docs/new/changelog"
-                      target="_blank"
-                      rel="noopener noreferrer"
-                    >
-                      <HugeiconsIcon
-                        icon={NewReleasesIcon}
-                        strokeWidth={1.75}
-                        className="size-[18px]"
-                      />
-                      <span>What's New</span>
-                    </a>
-                  </DropdownMenuItem>
-                  <DropdownMenuItem asChild>
-                    <a
-                      href="https://github.com/unslothai/unsloth/issues"
-                      target="_blank"
-                      rel="noopener noreferrer"
-                    >
-                      <HugeiconsIcon
-                        icon={MessageSearch01Icon}
-                        strokeWidth={1.75}
-                        className="size-[18px]"
-                      />
-                      <span>Feedback</span>
-                    </a>
-                  </DropdownMenuItem>
-                </DropdownMenuGroup>
-                <DropdownMenuSeparator className="mx-2.5! my-2.5! h-0! border-t border-border/70 bg-transparent!" />
+                <DropdownMenuItem
+                  onSelect={() => useSettingsDialogStore.getState().openDialog("about")}
+                >
+                  <HugeiconsIcon icon={HelpCircleIcon} strokeWidth={1.75} className="size-[18px]" />
+                  <span>Help</span>
+                </DropdownMenuItem>
                 <DropdownMenuItem onSelect={() => setShutdownOpen(true)}>
                   <HugeiconsIcon icon={PowerIcon} strokeWidth={1.75} className="size-[18px]" />
                   <span>Shutdown</span>
diff --git a/studio/frontend/src/components/assistant-ui/model-selector.tsx b/studio/frontend/src/components/assistant-ui/model-selector.tsx
index 3628252177..795bcb6d08 100644
--- a/studio/frontend/src/components/assistant-ui/model-selector.tsx
+++ b/studio/frontend/src/components/assistant-ui/model-selector.tsx
@@ -13,18 +13,25 @@ import { usePlatformStore } from "@/config/env";
 import { cn } from "@/lib/utils";
 import {
   ArrowDown01Icon,
+  FolderSearchIcon,
   Logout01Icon,
 } from "@hugeicons/core-free-icons";
 import { HugeiconsIcon } from "@hugeicons/react";
 import { useMemo, useState } from "react";
 import type {
+  DeletedModelRef,
   LoraModelOption,
   ModelOption,
   ModelSelectorChangeMeta,
 } from "./model-selector/types";
 import { HubModelPicker, LoraModelPicker } from "./model-selector/pickers";
 
-export type { LoraModelOption, ModelOption, ModelSelectorChangeMeta } from "./model-selector/types";
+export type {
+  DeletedModelRef,
+  LoraModelOption,
+  ModelOption,
+  ModelSelectorChangeMeta,
+} from "./model-selector/types";
 
 interface ModelSelectorProps {
   models: ModelOption[];
@@ -35,6 +42,9 @@ interface ModelSelectorProps {
   onValueChange?: (value: string, meta: ModelSelectorChangeMeta) => void;
   onEject?: () => void;
   onFoldersChange?: () => void;
+  onPickLocalModel?: () => void | Promise<void>;
+  onModelsChange?: (deletedModel?: DeletedModelRef) => void;
+  deleteDisabled?: boolean;
   variant?: "outline" | "ghost" | "muted";
   size?: "sm" | "default" | "lg";
   className?: string;
@@ -66,7 +76,7 @@ function ModelSelectorTrigger({
         type="button"
         data-tour={dataTour}
         className={cn(
-          "flex items-center gap-2 transition-colors",
+          "flex min-w-0 items-center gap-2 transition-colors",
           variant === "outline" &&
           "rounded-[8px] border border-border/60 hover:bg-[#ececec] dark:hover:bg-[#2e3035]",
           variant === "ghost" && "rounded-[8px] hover:bg-[#ececec] dark:hover:bg-[#2e3035]",
@@ -80,17 +90,23 @@ function ModelSelectorTrigger({
         {isLoaded && (
           <span className="size-2 shrink-0 rounded-full bg-emerald-500" />
         )}
-        <span className="font-heading font-medium text-[16px] text-black dark:text-white">
-          {currentModel?.name ?? "Select model"}
+        <span className="flex min-w-0 flex-1 items-baseline gap-2">
+          <span className="min-w-0 flex-1 truncate font-heading text-[16px] font-medium leading-tight text-black dark:text-white">
+            {currentModel?.name ?? "Select model"}
+          </span>
+          {currentModel?.description && (
+            <span className="shrink-0 text-xs leading-none text-muted-foreground">
+              {currentModel.description}
+            </span>
+          )}
+        </span>
+        <span className="flex size-4 shrink-0 items-center justify-center">
+          <HugeiconsIcon
+            icon={ArrowDown01Icon}
+            strokeWidth={1.75}
+            className="relative top-0.5 size-3.5 text-muted-foreground"
+          />
         </span>
-        {currentModel?.description && (
-          <span className="text-muted-foreground text-xs">{currentModel.description}</span>
-        )}
-        <HugeiconsIcon
-          icon={ArrowDown01Icon}
-          strokeWidth={1.75}
-          className="size-3.5 shrink-0 text-muted-foreground"
-        />
       </button>
     </PopoverTrigger>
   );
@@ -103,6 +119,9 @@ function ModelSelectorContent({
   onSelect,
   onEject,
   onFoldersChange,
+  onPickLocalModel,
+  onModelsChange,
+  deleteDisabled,
   className,
   dataTour,
 }: {
@@ -112,6 +131,9 @@ function ModelSelectorContent({
   onSelect: (id: string, meta: ModelSelectorChangeMeta) => void;
   onEject?: () => void;
   onFoldersChange?: () => void;
+  onPickLocalModel?: () => void;
+  onModelsChange?: (deletedModel?: DeletedModelRef) => void;
+  deleteDisabled?: boolean;
   className?: string;
   dataTour?: string;
 }) {
@@ -145,11 +167,26 @@ function ModelSelectorContent({
               loraModels={loraModels}
               value={value}
               onSelect={onSelect}
+              onModelsChange={onModelsChange}
+              deleteDisabled={deleteDisabled}
             />
           </TabsContent>
         </Tabs>
       )}
 
+      {onPickLocalModel ? (
+        <div className="mt-2 border-t border-border/70 pt-2">
+          <button
+            type="button"
+            onClick={onPickLocalModel}
+            className="flex w-full items-center justify-center gap-1.5 rounded-md px-2 py-1.5 text-xs text-muted-foreground transition-colors hover:bg-muted/60"
+            title="Pick a model file from disk"
+          >
+            <HugeiconsIcon icon={FolderSearchIcon} className="size-3.5" />
+            Pick a model file from disk
+          </button>
+        </div>
+      ) : null}
       {hasSelection && onEject ? (
         <div className="mt-2 border-t border-border/70 pt-2">
           <button
@@ -176,6 +213,9 @@ export function ModelSelector({
   onValueChange,
   onEject,
   onFoldersChange,
+  onPickLocalModel,
+  onModelsChange,
+  deleteDisabled,
   variant = "outline",
   size = "default",
   className,
@@ -253,6 +293,11 @@ export function ModelSelector({
     setOpen(false);
   }
 
+  function handlePickLocalModel() {
+    setOpen(false);
+    void onPickLocalModel?.();
+  }
+
   return (
     <Popover open={open} onOpenChange={setOpen}>
       <ModelSelectorTrigger
@@ -270,6 +315,9 @@ export function ModelSelector({
         onSelect={handleSelect}
         onEject={onEject ? handleEject : undefined}
         onFoldersChange={onFoldersChange}
+        onPickLocalModel={onPickLocalModel ? handlePickLocalModel : undefined}
+        onModelsChange={onModelsChange}
+        deleteDisabled={deleteDisabled}
         className={contentClassName}
         dataTour={contentDataTour}
       />
diff --git a/studio/frontend/src/components/assistant-ui/model-selector/model-delete-action.tsx b/studio/frontend/src/components/assistant-ui/model-selector/model-delete-action.tsx
new file mode 100644
index 0000000000..58a6235454
--- /dev/null
+++ b/studio/frontend/src/components/assistant-ui/model-selector/model-delete-action.tsx
@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+} from "@/components/ui/alert-dialog";
+import { cn } from "@/lib/utils";
+import { Trash2Icon } from "lucide-react";
+import { useCallback, useState, type ReactNode } from "react";
+import { toast } from "sonner";
+
+interface ModelDeleteActionProps {
+  ariaLabel: string;
+  title: string;
+  description: ReactNode;
+  successMessage: string;
+  loadingLabel?: string;
+  buttonClassName?: string;
+  iconClassName?: string;
+  disabled?: boolean;
+  onConfirm: () => Promise<void> | void;
+  onDeleted?: () => void;
+}
+
+export function ModelDeleteAction({
+  ariaLabel,
+  title,
+  description,
+  successMessage,
+  loadingLabel = "Deleting...",
+  buttonClassName,
+  iconClassName,
+  disabled = false,
+  onConfirm,
+  onDeleted,
+}: ModelDeleteActionProps) {
+  const [open, setOpen] = useState(false);
+  const [deleting, setDeleting] = useState(false);
+
+  const handleConfirm = useCallback(async () => {
+    setDeleting(true);
+    try {
+      await onConfirm();
+      toast.success(successMessage);
+      onDeleted?.();
+      setOpen(false);
+    } catch (err) {
+      toast.error(
+        err instanceof Error ? err.message : "Failed to delete model",
+      );
+    } finally {
+      setDeleting(false);
+    }
+  }, [onConfirm, onDeleted, successMessage]);
+
+  return (
+    <>
+      <button
+        type="button"
+        onClick={(e) => {
+          e.stopPropagation();
+          if (disabled) return;
+          setOpen(true);
+        }}
+        aria-label={ariaLabel}
+        disabled={disabled}
+        className={cn(
+          "shrink-0 rounded-md p-1.5 text-muted-foreground/60 transition-colors hover:bg-destructive/10 hover:text-destructive",
+          disabled && "cursor-not-allowed opacity-40 hover:bg-transparent hover:text-muted-foreground/60",
+          buttonClassName,
+        )}
+      >
+        <Trash2Icon className={cn("size-3.5", iconClassName)} />
+      </button>
+
+      <AlertDialog
+        open={open}
+        onOpenChange={(nextOpen) => {
+          if (!nextOpen && deleting) return;
+          setOpen(nextOpen);
+        }}
+      >
+        <AlertDialogContent size="sm">
+          <AlertDialogHeader>
+            <AlertDialogTitle>{title}</AlertDialogTitle>
+            <AlertDialogDescription>{description}</AlertDialogDescription>
+          </AlertDialogHeader>
+          <AlertDialogFooter>
+            <AlertDialogCancel disabled={deleting}>No</AlertDialogCancel>
+            <AlertDialogAction
+              variant="destructive"
+              disabled={deleting}
+              onClick={(e) => {
+                e.preventDefault();
+                handleConfirm();
+              }}
+            >
+              {deleting ? loadingLabel : "Yes"}
+            </AlertDialogAction>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
+    </>
+  );
+}
diff --git a/studio/frontend/src/components/assistant-ui/model-selector/pickers.tsx b/studio/frontend/src/components/assistant-ui/model-selector/pickers.tsx
index 30b8fdecb8..fae3c22caf 100644
--- a/studio/frontend/src/components/assistant-ui/model-selector/pickers.tsx
+++ b/studio/frontend/src/components/assistant-ui/model-selector/pickers.tsx
@@ -1,16 +1,6 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 // Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
 
-import {
-  AlertDialog,
-  AlertDialogAction,
-  AlertDialogCancel,
-  AlertDialogContent,
-  AlertDialogDescription,
-  AlertDialogFooter,
-  AlertDialogHeader,
-  AlertDialogTitle,
-} from "@/components/ui/alert-dialog";
 import { Input } from "@/components/ui/input";
 import { Spinner } from "@/components/ui/spinner";
 import {
@@ -23,6 +13,7 @@ import {
   type ScanFolderInfo,
   addScanFolder,
   deleteCachedModel,
+  deleteFineTunedModel,
   listCachedGguf,
   listCachedModels,
   listGgufVariants,
@@ -50,7 +41,8 @@ import { checkVramFit, estimateLoadingVram } from "@/lib/vram";
 import { Add01Icon, Cancel01Icon, Folder02Icon, Search01Icon } from "@hugeicons/core-free-icons";
 import { HugeiconsIcon } from "@hugeicons/react";
 import { FolderBrowser } from "./folder-browser";
-import { ChevronDownIcon, ChevronRightIcon, DownloadIcon, StarIcon, Trash2Icon } from "lucide-react";
+import { ModelDeleteAction } from "./model-delete-action";
+import { ChevronDownIcon, ChevronRightIcon, DownloadIcon, StarIcon } from "lucide-react";
 import {
   type ReactNode,
   useCallback,
@@ -60,6 +52,7 @@ import {
 } from "react";
 import { toast } from "sonner";
 import type {
+  DeletedModelRef,
   LoraModelOption,
   ModelOption,
   ModelSelectorChangeMeta,
@@ -211,12 +204,22 @@ function GgufVariantExpander({
   gpuGb,
   systemRamGb,
   onDeleteVariant,
+  sourceOverride,
+  deleteVariantTitle = "Delete cached model?",
+  renderDeleteVariantDescription,
+  getDeleteVariantSuccessMessage,
+  deleteDisabled = false,
 }: {
   repoId: string;
   onSelect: (id: string, meta: ModelSelectorChangeMeta) => void;
   gpuGb?: number;
   systemRamGb?: number;
-  onDeleteVariant?: (quant: string) => void;
+  onDeleteVariant?: (quant: string) => Promise<void> | void;
+  sourceOverride?: ModelSelectorChangeMeta["source"];
+  deleteVariantTitle?: string;
+  renderDeleteVariantDescription?: (quant: string) => ReactNode;
+  getDeleteVariantSuccessMessage?: (quant: string) => string;
+  deleteDisabled?: boolean;
 }) {
   const [variants, setVariants] = useState<GgufVariantDetail[] | null>(null);
   const [defaultVariant, setDefaultVariant] = useState<string | null>(null);
@@ -259,14 +262,14 @@ function GgufVariantExpander({
   const handleVariantClick = useCallback(
     (quant: string, downloaded?: boolean, sizeBytes?: number) => {
       onSelect(repoId, {
-        source: isLocalPath ? "local" : "hub",
+        source: sourceOverride ?? (isLocalPath ? "local" : "hub"),
         isLora: false,
         ggufVariant: quant,
         isDownloaded: isLocalPath ? true : downloaded,
         expectedBytes: sizeBytes,
       });
     },
-    [repoId, isLocalPath, onSelect],
+    [repoId, isLocalPath, onSelect, sourceOverride],
   );
 
   // GGUF fit classification matching llama-server's _select_gpus logic:
@@ -408,16 +411,29 @@ function GgufVariantExpander({
               </span>
             </button>
             {v.downloaded && onDeleteVariant && (
-              <button
-                type="button"
-                onClick={(e) => {
-                  e.stopPropagation();
-                  onDeleteVariant(v.quant);
-                }}
-                className="shrink-0 rounded-md p-1 text-muted-foreground/60 transition-colors hover:bg-destructive/10 hover:text-destructive"
-              >
-                <Trash2Icon className="size-3" />
-              </button>
+              <ModelDeleteAction
+                ariaLabel={`Delete ${repoId} ${v.quant}`}
+                title={deleteVariantTitle}
+                description={
+                  renderDeleteVariantDescription?.(v.quant) ?? (
+                    <>
+                      This will remove{" "}
+                      <span className="font-medium text-foreground">
+                        {repoId} ({v.quant})
+                      </span>{" "}
+                      from disk. You can re-download it later.
+                    </>
+                  )
+                }
+                successMessage={
+                  getDeleteVariantSuccessMessage?.(v.quant) ??
+                  `Deleted ${repoId} ${v.quant}`
+                }
+                buttonClassName="p-1"
+                iconClassName="size-3"
+                disabled={deleteDisabled}
+                onConfirm={() => onDeleteVariant(v.quant)}
+              />
             )}
           </div>
         );
@@ -512,9 +528,6 @@ export function HubModelPicker({
   // Track which GGUF repo is expanded for variant selection
   const [expandedGguf, setExpandedGguf] = useState<string | null>(null);
 
-  // Delete confirmation dialog state
-  const [deleteTarget, setDeleteTarget] = useState<string | null>(null);
-  const [deleting, setDeleting] = useState(false);
   const [downloadedCollapsed, setDownloadedCollapsed] = useState(false);
   const [customFoldersCollapsed, setCustomFoldersCollapsed] = useState(false);
   const [recommendedCollapsed, setRecommendedCollapsed] = useState(false);
@@ -675,27 +688,6 @@ export function HubModelPicker({
       .finally(check);
   }, [refreshLocalModelsList, refreshScanFolders]);
 
-  const handleDeleteConfirm = useCallback(async () => {
-    if (!deleteTarget) return;
-    setDeleting(true);
-    try {
-      // deleteTarget is "repo_id" or "repo_id::variant"
-      const sepIdx = deleteTarget.indexOf("::");
-      const repoId = sepIdx >= 0 ? deleteTarget.slice(0, sepIdx) : deleteTarget;
-      const variant = sepIdx >= 0 ? deleteTarget.slice(sepIdx + 2) : undefined;
-      await deleteCachedModel(repoId, variant);
-      toast.success(`Deleted ${variant ? `${repoId} ${variant}` : repoId}`);
-      refreshCachedLists();
-    } catch (err) {
-      toast.error(
-        err instanceof Error ? err.message : "Failed to delete model",
-      );
-    } finally {
-      setDeleting(false);
-      setDeleteTarget(null);
-    }
-  }, [deleteTarget, refreshCachedLists]);
-
   // Deduplicate: don't show downloaded models in the recommended list.
   // Compare case-insensitively since HF cache lowercases repo IDs.
   const downloadedSet = useMemo(() => {
@@ -952,9 +944,10 @@ export function HubModelPicker({
                       systemRamGb={
                         gpu.available ? gpu.systemRamAvailableGb : undefined
                       }
-                      onDeleteVariant={(quant) =>
-                        setDeleteTarget(`${c.repo_id}::${quant}`)
-                      }
+                      onDeleteVariant={async (quant) => {
+                        await deleteCachedModel(c.repo_id, quant);
+                        refreshCachedLists();
+                      }}
                     />
                   )}
                 </div>
@@ -977,16 +970,22 @@ export function HubModelPicker({
                         vramStatus={null}
                       />
                     </div>
-                    <button
-                      type="button"
-                      onClick={(e) => {
-                        e.stopPropagation();
-                        setDeleteTarget(c.repo_id);
-                      }}
-                      className="shrink-0 rounded-md p-1.5 text-muted-foreground/60 transition-colors hover:bg-destructive/10 hover:text-destructive"
-                    >
-                      <Trash2Icon className="size-3.5" />
-                    </button>
+                    <ModelDeleteAction
+                      ariaLabel={`Delete ${c.repo_id}`}
+                      title="Delete cached model?"
+                      description={
+                        <>
+                          This will remove{" "}
+                          <span className="font-medium text-foreground">
+                            {c.repo_id}
+                          </span>{" "}
+                          from disk. You can re-download it later.
+                        </>
+                      }
+                      successMessage={`Deleted ${c.repo_id}`}
+                      onConfirm={() => deleteCachedModel(c.repo_id)}
+                      onDeleted={refreshCachedLists}
+                    />
                   </div>
                 ))}
             </>
@@ -1409,40 +1408,6 @@ export function HubModelPicker({
         </div>
       </div>
 
-      <AlertDialog
-        open={deleteTarget !== null}
-        onOpenChange={(open) => {
-          if (!open && !deleting) setDeleteTarget(null);
-        }}
-      >
-        <AlertDialogContent size="sm">
-          <AlertDialogHeader>
-            <AlertDialogTitle>Delete cached model?</AlertDialogTitle>
-            <AlertDialogDescription>
-              This will remove{" "}
-              <span className="font-medium text-foreground">
-                {deleteTarget?.includes("::")
-                  ? `${deleteTarget.split("::")[0]} (${deleteTarget.split("::")[1]})`
-                  : deleteTarget}
-              </span>{" "}
-              from disk. You can re-download it later.
-            </AlertDialogDescription>
-          </AlertDialogHeader>
-          <AlertDialogFooter>
-            <AlertDialogCancel disabled={deleting}>No</AlertDialogCancel>
-            <AlertDialogAction
-              variant="destructive"
-              disabled={deleting}
-              onClick={(e) => {
-                e.preventDefault();
-                handleDeleteConfirm();
-              }}
-            >
-              {deleting ? "Deleting..." : "Yes"}
-            </AlertDialogAction>
-          </AlertDialogFooter>
-        </AlertDialogContent>
-      </AlertDialog>
     </div>
   );
 }
@@ -1451,10 +1416,14 @@ export function LoraModelPicker({
   loraModels,
   value,
   onSelect,
+  onModelsChange,
+  deleteDisabled = false,
 }: {
   loraModels: LoraModelOption[];
   value?: string;
   onSelect: (id: string, meta: ModelSelectorChangeMeta) => void;
+  onModelsChange?: (deletedModel?: DeletedModelRef) => void;
+  deleteDisabled?: boolean;
 }) {
   const [query, setQuery] = useState("");
   const [expandedGguf, setExpandedGguf] = useState<string | null>(null);
@@ -1541,6 +1510,8 @@ export function LoraModelPicker({
                   const isExported = adapter.source === "exported";
                   const isMerged = adapter.exportType === "merged";
                   const isGguf = adapter.exportType === "gguf";
+                  const isExportedGguf = isExported && isGguf;
+                  const canDelete = (isTraining || isExported) && !isExportedGguf;
                   const isTrainingFull = isTraining && isMerged;
                   const isLocalGgufDir =
                     isLocal &&
@@ -1569,38 +1540,69 @@ export function LoraModelPicker({
                       : tag;
                   return (
                     <div key={adapter.id}>
-                      <ModelRow
-                        label={adapter.name}
-                        meta={meta}
-                        selected={value === adapter.id}
-                        onClick={() => {
-                          if (isLocalGgufDir) {
-                            setExpandedGguf((prev) =>
-                              prev === adapter.id ? null : adapter.id,
-                            );
-                          } else {
-                            onSelect(adapter.id, {
-                              source: isLocal
-                                ? "local"
-                                : isExported
-                                  ? "exported"
-                                  : "lora",
-                              isLora: !isLocal && !isMerged && !isGguf,
-                              isDownloaded: true,
-                            });
-                          }
-                        }}
-                        tooltipText={
-                          <>
-                            <span className="block break-words">
-                              {adapter.name}
-                            </span>
-                            <span className="block mt-1 text-[10px] text-muted-foreground break-all">
-                              {adapter.id}
-                            </span>
-                          </>
-                        }
-                      />
+                      <div className="flex items-center gap-0.5">
+                        <div className="min-w-0 flex-1">
+                          <ModelRow
+                            label={adapter.name}
+                            meta={meta}
+                            selected={value === adapter.id}
+                            onClick={() => {
+                              if (isLocalGgufDir || isExportedGguf) {
+                                setExpandedGguf((prev) =>
+                                  prev === adapter.id ? null : adapter.id,
+                                );
+                              } else {
+                                onSelect(adapter.id, {
+                                  source: isLocal
+                                    ? "local"
+                                    : isExported
+                                      ? "exported"
+                                      : "lora",
+                                  isLora: !isLocal && !isMerged && !isGguf,
+                                  isDownloaded: true,
+                                });
+                              }
+                            }}
+                            tooltipText={
+                              <>
+                                <span className="block break-words">
+                                  {adapter.name}
+                                </span>
+                                <span className="block mt-1 text-[10px] text-muted-foreground break-all">
+                                  {adapter.id}
+                                </span>
+                              </>
+                            }
+                          />
+                        </div>
+                        {canDelete && (
+                          <ModelDeleteAction
+                            ariaLabel={`Delete ${adapter.name}`}
+                            title="Delete fine-tuned model?"
+                            description={
+                              <>
+                                This will remove{" "}
+                                <span className="font-medium text-foreground">
+                                  {adapter.name}
+                                </span>{" "}
+                                from disk. This cannot be undone.
+                              </>
+                            }
+                            successMessage={`Deleted ${adapter.name}`}
+                            disabled={deleteDisabled}
+                            onConfirm={() =>
+                              deleteFineTunedModel({
+                                modelPath: adapter.id,
+                                source: isExported ? "exported" : "training",
+                                exportType: adapter.exportType,
+                              })
+                            }
+                            onDeleted={() =>
+                              onModelsChange?.({ id: adapter.id })
+                            }
+                          />
+                        )}
+                      </div>
                       {expandedGguf === adapter.id && (
                         <GgufVariantExpander
                           repoId={adapter.id}
@@ -1609,6 +1611,37 @@ export function LoraModelPicker({
                           systemRamGb={
                             gpu.available ? gpu.systemRamAvailableGb : undefined
                           }
+                          sourceOverride={isExportedGguf ? "exported" : undefined}
+                          deleteVariantTitle="Delete exported GGUF variant?"
+                          renderDeleteVariantDescription={(quant) => (
+                            <>
+                              This will remove{" "}
+                              <span className="font-medium text-foreground">
+                                {adapter.name} ({quant})
+                              </span>{" "}
+                              from disk. This cannot be undone.
+                            </>
+                          )}
+                          getDeleteVariantSuccessMessage={(quant) =>
+                            `Deleted ${adapter.name} ${quant}`
+                          }
+                          deleteDisabled={deleteDisabled}
+                          onDeleteVariant={
+                            isExportedGguf
+                              ? async (quant) => {
+                                  await deleteFineTunedModel({
+                                    modelPath: adapter.id,
+                                    source: "exported",
+                                    exportType: "gguf",
+                                    ggufVariant: quant,
+                                  });
+                                  onModelsChange?.({
+                                    id: adapter.id,
+                                    ggufVariant: quant,
+                                  });
+                                }
+                              : undefined
+                          }
                         />
                       )}
                     </div>
@@ -1619,6 +1652,7 @@ export function LoraModelPicker({
           )}
         </div>
       </div>
+
     </div>
   );
 }
diff --git a/studio/frontend/src/components/assistant-ui/model-selector/types.ts b/studio/frontend/src/components/assistant-ui/model-selector/types.ts
index 215dd2b38e..3da75b4d4e 100644
--- a/studio/frontend/src/components/assistant-ui/model-selector/types.ts
+++ b/studio/frontend/src/components/assistant-ui/model-selector/types.ts
@@ -25,3 +25,8 @@ export interface ModelSelectorChangeMeta {
   isDownloaded?: boolean;
   expectedBytes?: number;
 }
+
+export interface DeletedModelRef {
+  id: string;
+  ggufVariant?: string;
+}
diff --git a/studio/frontend/src/components/assistant-ui/thread.tsx b/studio/frontend/src/components/assistant-ui/thread.tsx
index 3f67b11b51..0d6cd3bbf9 100644
--- a/studio/frontend/src/components/assistant-ui/thread.tsx
+++ b/studio/frontend/src/components/assistant-ui/thread.tsx
@@ -33,6 +33,7 @@ import {
 import { sentAudioNames } from "@/features/chat/api/chat-adapter";
 import { useChatRuntimeStore } from "@/features/chat/stores/chat-runtime-store";
 import { applyQwenThinkingParams } from "@/features/chat/utils/qwen-params";
+import { isTauri } from "@/lib/api-base";
 import { deleteThreadMessage } from "@/features/chat/utils/delete-thread-message";
 import { AUDIO_ACCEPT, MAX_AUDIO_SIZE, fileToBase64 } from "@/lib/audio-utils";
 import { copyToClipboard } from "@/lib/copy-to-clipboard";
@@ -298,27 +299,41 @@ const Composer: FC<{ disabled?: boolean }> = ({ disabled }) => {
     [disabled],
   );
 
+  const composerContent = (
+    <>
+      <ComposerAttachments />
+      <PendingAudioChip />
+      <ToolStatusDisplay />
+      <ComposerPrimitive.Input
+        placeholder="Send a message..."
+        className="aui-composer-input mb-1 min-h-12 w-full resize-none overflow-y-auto bg-transparent pl-5 pr-4 pt-2 pb-3 text-sm font-[450] outline-none placeholder:text-muted-foreground focus-visible:ring-0"
+        minRows={1}
+        maxRows={6}
+        autoFocus={!disabled}
+        disabled={disabled}
+        aria-label="Message input"
+      />
+      <ComposerAction disabled={disabled} />
+    </>
+  );
+
   return (
     <ComposerPrimitive.Root
       className="aui-composer-root relative flex w-full flex-col"
       aria-disabled={disabled}
       onSubmit={handleSubmit}
     >
-      <ComposerPrimitive.AttachmentDropzone className="aui-composer-attachment-dropzone chat-composer-surface flex w-full flex-col rounded-3xl bg-background dark:bg-card px-1 pt-2 outline-none transition-shadow data-[dragging=true]:border-ring data-[dragging=true]:bg-accent/50">
-        <ComposerAttachments />
-        <PendingAudioChip />
-        <ToolStatusDisplay />
-        <ComposerPrimitive.Input
-          placeholder="Send a message..."
-          className="aui-composer-input mb-1 min-h-12 w-full resize-none overflow-y-auto bg-transparent pl-5 pr-4 pt-2 pb-3 text-sm font-[450] outline-none placeholder:text-muted-foreground focus-visible:ring-0"
-          minRows={1}
-          maxRows={6}
-          autoFocus={!disabled}
-          disabled={disabled}
-          aria-label="Message input"
-        />
-        <ComposerAction disabled={disabled} />
-      </ComposerPrimitive.AttachmentDropzone>
+      {isTauri ? (
+        // Phase 1 native model drops own Tauri local-path drops. Restore browser
+        // attachment drops in Tauri when Phase 1d adds attachment-token bridging.
+        <div className="aui-composer-attachment-dropzone chat-composer-surface flex w-full flex-col rounded-3xl bg-background dark:bg-card px-1 pt-2 outline-none transition-shadow">
+          {composerContent}
+        </div>
+      ) : (
+        <ComposerPrimitive.AttachmentDropzone className="aui-composer-attachment-dropzone chat-composer-surface flex w-full flex-col rounded-3xl bg-background dark:bg-card px-1 pt-2 outline-none transition-shadow data-[dragging=true]:border-ring data-[dragging=true]:bg-accent/50">
+          {composerContent}
+        </ComposerPrimitive.AttachmentDropzone>
+      )}
     </ComposerPrimitive.Root>
   );
 };
@@ -485,7 +500,7 @@ const PreserveThinkingToggle: FC = () => {
             : "bg-muted text-muted-foreground hover:bg-muted-foreground/15",
       )}
       aria-label={
-        preserveThinking ? "Disable preserve thinking" : "Enable preserve thinking"
+        preserveThinking ? "Disable preserve think" : "Enable preserve think"
       }
     >
       {preserveThinking && !disabled ? (
@@ -493,7 +508,7 @@ const PreserveThinkingToggle: FC = () => {
       ) : (
         <LightbulbOffIcon className="size-3.5" />
       )}
-      <span>Preserve Thinking</span>
+      <span>Preserve Think</span>
     </button>
   );
 };
diff --git a/studio/frontend/src/components/tauri/startup-screen.tsx b/studio/frontend/src/components/tauri/startup-screen.tsx
index af5f241416..1eb3f81d10 100644
--- a/studio/frontend/src/components/tauri/startup-screen.tsx
+++ b/studio/frontend/src/components/tauri/startup-screen.tsx
@@ -3,7 +3,9 @@
 
 import { ShimmerButton } from "@/components/ui/shimmer-button";
 import type { BackendStatus } from "@/hooks/use-tauri-backend";
+import type { CopySupportDiagnosticsResult } from "@/lib/tauri-diagnostics";
 import { AnimatePresence, motion } from "motion/react";
+import { useState } from "react";
 
 interface StartupScreenProps {
   status: BackendStatus;
@@ -17,6 +19,63 @@ interface StartupScreenProps {
   onRetryInstall: () => void;
   onApproveElevation: () => void;
   onStartServer: () => void;
+  onCopyDiagnostics: () => Promise<CopySupportDiagnosticsResult>;
+}
+
+function DiagnosticsCopyActions({
+  onCopyDiagnostics,
+  children,
+}: {
+  onCopyDiagnostics: () => Promise<CopySupportDiagnosticsResult>;
+  children: React.ReactNode;
+}) {
+  const [copying, setCopying] = useState(false);
+  const [manualReport, setManualReport] = useState<string | null>(null);
+  const [manualMessage, setManualMessage] = useState<string | null>(null);
+
+  async function handleCopyDiagnostics() {
+    setCopying(true);
+    try {
+      const result = await onCopyDiagnostics();
+      if (result.ok) {
+        setManualReport(null);
+        setManualMessage(null);
+      } else {
+        setManualReport(result.report);
+        setManualMessage(result.error ?? "Clipboard copy failed. Select and copy the diagnostics below.");
+      }
+    } catch (error) {
+      setManualReport(null);
+      setManualMessage(`Diagnostics copy failed: ${String(error)}`);
+    } finally {
+      setCopying(false);
+    }
+  }
+
+  return (
+    <div className="mt-4 flex w-full flex-col items-center gap-3">
+      <div className="flex gap-3">
+        <ActionButton
+          variant="secondary"
+          onClick={() => void handleCopyDiagnostics()}
+        >
+          {copying ? "Copying..." : "Copy Diagnostics"}
+        </ActionButton>
+        {children}
+      </div>
+      {manualMessage && (
+        <p className="max-w-md text-center text-xs text-destructive">{manualMessage}</p>
+      )}
+      {manualReport && (
+        <textarea
+          readOnly
+          value={manualReport}
+          onFocus={(event) => event.currentTarget.select()}
+          className="h-32 w-full max-w-md resize-none rounded-lg border border-border/50 bg-muted/30 p-2 font-mono text-[10px] text-muted-foreground"
+        />
+      )}
+    </div>
+  );
 }
 
 // ---------------------------------------------------------------------------
@@ -180,12 +239,12 @@ function RepairingContent({
 
 function InstallErrorContent({
   error,
-  logs,
   onRetryInstall,
+  onCopyDiagnostics,
 }: {
   error: string | null;
-  logs: string[];
   onRetryInstall: () => void;
+  onCopyDiagnostics: () => Promise<CopySupportDiagnosticsResult>;
 }) {
   return (
     <>
@@ -195,15 +254,9 @@ function InstallErrorContent({
         {error && (
           <p className="max-w-xs text-center text-xs text-muted-foreground">{error}</p>
         )}
-        <div className="mt-4 flex gap-3">
-          <ActionButton
-            variant="secondary"
-            onClick={() => void navigator.clipboard.writeText(logs.join("\n"))}
-          >
-            Copy Logs
-          </ActionButton>
+        <DiagnosticsCopyActions onCopyDiagnostics={onCopyDiagnostics}>
           <ActionButton onClick={onRetryInstall}>Try Again</ActionButton>
-        </div>
+        </DiagnosticsCopyActions>
       </div>
     </>
   );
@@ -211,12 +264,12 @@ function InstallErrorContent({
 
 function RepairErrorContent({
   error,
-  logs,
   onRetry,
+  onCopyDiagnostics,
 }: {
   error: string | null;
-  logs: string[];
   onRetry: () => void;
+  onCopyDiagnostics: () => Promise<CopySupportDiagnosticsResult>;
 }) {
   return (
     <>
@@ -226,15 +279,9 @@ function RepairErrorContent({
         {error && (
           <p className="max-w-md text-center text-xs text-muted-foreground">{error}</p>
         )}
-        <div className="mt-4 flex gap-3">
-          <ActionButton
-            variant="secondary"
-            onClick={() => void navigator.clipboard.writeText(logs.join("\n"))}
-          >
-            Copy Logs
-          </ActionButton>
+        <DiagnosticsCopyActions onCopyDiagnostics={onCopyDiagnostics}>
           <ActionButton onClick={onRetry}>Retry</ActionButton>
-        </div>
+        </DiagnosticsCopyActions>
       </div>
     </>
   );
@@ -301,12 +348,12 @@ function StoppedContent({ onStartServer }: { onStartServer: () => void }) {
 
 function ErrorContent({
   error,
-  logs,
   onRetry,
+  onCopyDiagnostics,
 }: {
   error: string | null;
-  logs: string[];
   onRetry: () => void;
+  onCopyDiagnostics: () => Promise<CopySupportDiagnosticsResult>;
 }) {
   return (
     <>
@@ -316,15 +363,9 @@ function ErrorContent({
         {error && (
           <p className="max-w-md text-center text-xs text-muted-foreground">{error}</p>
         )}
-        <div className="mt-4 flex gap-3">
-          <ActionButton
-            variant="secondary"
-            onClick={() => void navigator.clipboard.writeText(logs.join("\n"))}
-          >
-            Copy Logs
-          </ActionButton>
+        <DiagnosticsCopyActions onCopyDiagnostics={onCopyDiagnostics}>
           <ActionButton onClick={onRetry}>Retry</ActionButton>
-        </div>
+        </DiagnosticsCopyActions>
       </div>
     </>
   );
@@ -346,6 +387,7 @@ export function StartupScreen({
   onRetryInstall,
   onApproveElevation,
   onStartServer,
+  onCopyDiagnostics,
 }: StartupScreenProps) {
   function renderContent() {
     switch (status) {
@@ -356,11 +398,23 @@ export function StartupScreen({
       case "installing":
         return <InstallingContent currentStepIndex={currentStepIndex} progressDetail={progressDetail} />;
       case "install-error":
-        return <InstallErrorContent error={error} logs={logs} onRetryInstall={onRetryInstall} />;
+        return (
+          <InstallErrorContent
+            error={error}
+            onRetryInstall={onRetryInstall}
+            onCopyDiagnostics={onCopyDiagnostics}
+          />
+        );
       case "repairing":
         return <RepairingContent logs={logs} progressDetail={progressDetail} />;
       case "repair-error":
-        return <RepairErrorContent error={error} logs={logs} onRetry={onRetry} />;
+        return (
+          <RepairErrorContent
+            error={error}
+            onRetry={onRetry}
+            onCopyDiagnostics={onCopyDiagnostics}
+          />
+        );
       case "needs-elevation":
         return (
           <NeedsElevationContent
@@ -376,12 +430,18 @@ export function StartupScreen({
       case "stopped":
         return <StoppedContent onStartServer={onStartServer} />;
       case "error":
-        return <ErrorContent error={error} logs={logs} onRetry={onRetry} />;
+        return (
+          <ErrorContent
+            error={error}
+            onRetry={onRetry}
+            onCopyDiagnostics={onCopyDiagnostics}
+          />
+        );
     }
   }
 
   return (
-    <div className="flex h-screen w-full flex-col items-center bg-background">
+    <div className="flex h-full w-full flex-col items-center bg-background">
       <div className="flex flex-1 w-full max-w-md items-center justify-center px-6">
         <AnimatePresence mode="wait">
           <motion.div
diff --git a/studio/frontend/src/components/tauri/update-banner.tsx b/studio/frontend/src/components/tauri/update-banner.tsx
index 98652c4db1..79fbae6bb7 100644
--- a/studio/frontend/src/components/tauri/update-banner.tsx
+++ b/studio/frontend/src/components/tauri/update-banner.tsx
@@ -2,16 +2,20 @@
 // Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
 
 import { Button } from "@/components/ui/button";
-import type { UpdateInfo, UpdateStatus } from "@/hooks/use-tauri-update";
+import type { RetainedUpdateFailure, UpdateInfo, UpdateStatus } from "@/hooks/use-tauri-update";
+import type { CopySupportDiagnosticsResult } from "@/lib/tauri-diagnostics";
 import { AnimatePresence, motion } from "motion/react";
+import { useState } from "react";
 
 interface UpdateBannerProps {
   status: UpdateStatus;
   info: UpdateInfo | null;
   dismissed: boolean;
+  lastFailure: RetainedUpdateFailure | null;
   isExternalServer?: boolean;
   onInstall: () => void;
   onDismiss: () => void;
+  onCopyDiagnostics: () => Promise<CopySupportDiagnosticsResult>;
 }
 
 const EASE_OUT_QUART: [number, number, number, number] = [0.165, 0.84, 0.44, 1];
@@ -20,16 +24,41 @@ export function UpdateBanner({
   status,
   info,
   dismissed,
+  lastFailure,
   isExternalServer = false,
   onInstall,
   onDismiss,
+  onCopyDiagnostics,
 }: UpdateBannerProps) {
-  const visible = status === "available";
-  const show = visible && !dismissed;
+  const [copying, setCopying] = useState(false);
+  const [manualReport, setManualReport] = useState<string | null>(null);
+  const [manualMessage, setManualMessage] = useState<string | null>(null);
+  const showFailure = Boolean(lastFailure) && !dismissed;
+  const showAvailable = status === "available" && !dismissed && !showFailure;
+  const show = showFailure || (showAvailable && Boolean(info));
+
+  async function handleCopyDiagnostics() {
+    setCopying(true);
+    try {
+      const result = await onCopyDiagnostics();
+      if (result.ok) {
+        setManualReport(null);
+        setManualMessage(null);
+      } else {
+        setManualReport(result.report);
+        setManualMessage(result.error ?? "Clipboard copy failed. Select and copy the diagnostics below.");
+      }
+    } catch (error) {
+      setManualReport(null);
+      setManualMessage(`Diagnostics copy failed: ${String(error)}`);
+    } finally {
+      setCopying(false);
+    }
+  }
 
   return (
     <AnimatePresence>
-      {show && info && (
+      {show && (
         <motion.div
           initial={{ opacity: 0, y: -12, scale: 0.96 }}
           animate={{ opacity: 1, y: 0, scale: 1 }}
@@ -54,28 +83,61 @@ export function UpdateBanner({
               <span className="text-lg">🦥</span>
               <div>
                 <p className="text-sm font-semibold text-foreground">
-                  New version: v{info.version}
+                  {showFailure ? "App update failed" : `New version: v${info?.version}`}
                 </p>
                 <p className="text-xs text-muted-foreground">
-                  {isExternalServer
-                    ? "Run `unsloth studio update` from your terminal"
-                    : "A new app update is available"}
+                  {showFailure
+                    ? "Backend recovered. Diagnostics are still available."
+                    : isExternalServer
+                      ? "Run `unsloth studio update` from your terminal"
+                      : "A new app update is available"}
                 </p>
               </div>
             </div>
 
+            {/* Retained failure */}
+            {showFailure && lastFailure && (
+              <p className="mt-3 line-clamp-2 text-xs text-destructive">
+                {lastFailure.error}
+              </p>
+            )}
+
             {/* Actions */}
             <div className="mt-3 flex items-center gap-2">
-              <Button size="sm" className="corner-squircle" onClick={onInstall} disabled={isExternalServer}>
-                Update Now
-              </Button>
-              <Button size="sm" variant="outline" className="corner-squircle" disabled>
-                Release Notes
-              </Button>
+              {showFailure ? (
+                <>
+                  <Button size="sm" variant="outline" className="corner-squircle" onClick={() => void handleCopyDiagnostics()}>
+                    {copying ? "Copying..." : "Copy Diagnostics"}
+                  </Button>
+                  <Button size="sm" className="corner-squircle" onClick={onInstall} disabled={isExternalServer}>
+                    Retry Update
+                  </Button>
+                </>
+              ) : (
+                <>
+                  <Button size="sm" className="corner-squircle" onClick={onInstall} disabled={isExternalServer}>
+                    Update Now
+                  </Button>
+                  <Button size="sm" variant="outline" className="corner-squircle" disabled>
+                    Release Notes
+                  </Button>
+                </>
+              )}
               <Button size="sm" variant="ghost" className="corner-squircle" onClick={onDismiss}>
                 Later
               </Button>
             </div>
+            {manualMessage && (
+              <p className="mt-3 text-xs text-destructive">{manualMessage}</p>
+            )}
+            {manualReport && (
+              <textarea
+                readOnly
+                value={manualReport}
+                onFocus={(event) => event.currentTarget.select()}
+                className="mt-2 h-28 w-full resize-none rounded-lg border border-border/50 bg-muted/30 p-2 font-mono text-[10px] text-muted-foreground"
+              />
+            )}
           </div>
         </motion.div>
       )}
diff --git a/studio/frontend/src/components/tauri/update-screen.tsx b/studio/frontend/src/components/tauri/update-screen.tsx
index a8b77ab1fa..53e39612c0 100644
--- a/studio/frontend/src/components/tauri/update-screen.tsx
+++ b/studio/frontend/src/components/tauri/update-screen.tsx
@@ -2,8 +2,9 @@
 // Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
 
 import type { UpdateStatus } from "@/hooks/use-tauri-update";
+import type { CopySupportDiagnosticsResult } from "@/lib/tauri-diagnostics";
 import { AnimatePresence, motion } from "motion/react";
-import { useEffect, useRef } from "react";
+import { useEffect, useRef, useState } from "react";
 
 interface UpdateScreenProps {
   status: UpdateStatus;
@@ -12,6 +13,7 @@ interface UpdateScreenProps {
   error: string | null;
   onRetry: () => void;
   onSkipRestart: () => void;
+  onCopyDiagnostics: () => Promise<CopySupportDiagnosticsResult>;
 }
 
 const EASE_OUT_QUART: [number, number, number, number] = [0.165, 0.84, 0.44, 1];
@@ -96,11 +98,34 @@ export function UpdateScreen({
   error,
   onRetry,
   onSkipRestart,
+  onCopyDiagnostics,
 }: UpdateScreenProps) {
   const isError = status === "error";
+  const [copying, setCopying] = useState(false);
+  const [manualReport, setManualReport] = useState<string | null>(null);
+  const [manualMessage, setManualMessage] = useState<string | null>(null);
+
+  async function handleCopyDiagnostics() {
+    setCopying(true);
+    try {
+      const result = await onCopyDiagnostics();
+      if (result.ok) {
+        setManualReport(null);
+        setManualMessage(null);
+      } else {
+        setManualReport(result.report);
+        setManualMessage(result.error ?? "Clipboard copy failed. Select and copy the diagnostics below.");
+      }
+    } catch (copyError) {
+      setManualReport(null);
+      setManualMessage(`Diagnostics copy failed: ${String(copyError)}`);
+    } finally {
+      setCopying(false);
+    }
+  }
 
   return (
-    <div className="flex h-screen w-full items-center justify-center bg-background">
+    <div className="flex h-full w-full items-center justify-center bg-background">
       <motion.div
         initial={{ opacity: 0, y: 8 }}
         animate={{ opacity: 1, y: 0 }}
@@ -148,6 +173,13 @@ export function UpdateScreen({
         {/* Error actions */}
         {isError && (
           <div className="mt-4 flex items-center gap-2">
+            <button
+              type="button"
+              className="rounded-lg bg-muted px-5 py-2.5 text-sm font-medium text-foreground transition-colors hover:bg-muted/80"
+              onClick={() => void handleCopyDiagnostics()}
+            >
+              {copying ? "Copying..." : "Copy Diagnostics"}
+            </button>
             <button
               type="button"
               className="rounded-lg bg-primary px-5 py-2.5 text-sm font-medium text-primary-foreground transition-colors hover:bg-primary/80"
@@ -165,6 +197,18 @@ export function UpdateScreen({
           </div>
         )}
 
+        {manualMessage && (
+          <p className="mt-3 max-w-xl text-center text-xs text-destructive">{manualMessage}</p>
+        )}
+        {manualReport && (
+          <textarea
+            readOnly
+            value={manualReport}
+            onFocus={(event) => event.currentTarget.select()}
+            className="mt-2 h-32 w-full max-w-xl resize-none rounded-lg border border-border/50 bg-muted/30 p-2 font-mono text-[10px] text-muted-foreground"
+          />
+        )}
+
         {/* Log viewer */}
         <LogViewer logs={logs} />
       </motion.div>
diff --git a/studio/frontend/src/components/tauri/window-titlebar.tsx b/studio/frontend/src/components/tauri/window-titlebar.tsx
new file mode 100644
index 0000000000..b3180e6663
--- /dev/null
+++ b/studio/frontend/src/components/tauri/window-titlebar.tsx
@@ -0,0 +1,329 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+import { useSidebarPin } from "@/hooks/use-sidebar-pin";
+import { isTauri } from "@/lib/api-base";
+import { cn } from "@/lib/utils";
+import type { Window as TauriWindow } from "@tauri-apps/api/window";
+import {
+  type MouseEvent,
+  type ReactElement,
+  type ReactNode,
+  useCallback,
+  useEffect,
+  useState,
+} from "react";
+
+const CUSTOM_TITLEBAR_PLATFORMS = ["win", "linux", "x11"] as const;
+
+type WindowResizeDirection =
+  | "East"
+  | "North"
+  | "NorthEast"
+  | "NorthWest"
+  | "South"
+  | "SouthEast"
+  | "SouthWest"
+  | "West";
+
+type NavigatorWithUserAgentData = Navigator & {
+  userAgentData?: {
+    platform?: string;
+  };
+};
+
+function getClientPlatform(): string {
+  if (typeof navigator === "undefined") {
+    return "";
+  }
+  const nav = navigator as NavigatorWithUserAgentData;
+  return (
+    nav.userAgentData?.platform ??
+    navigator.platform ??
+    navigator.userAgent
+  ).toLowerCase();
+}
+
+export function shouldUseCustomWindowTitlebar(): boolean {
+  if (!isTauri) {
+    return false;
+  }
+  const platform = getClientPlatform();
+  if (!platform || platform.includes("mac")) {
+    return false;
+  }
+  return CUSTOM_TITLEBAR_PLATFORMS.some((token) => platform.includes(token));
+}
+
+async function getAppWindow(): Promise<TauriWindow> {
+  const { getCurrentWindow } = await import("@tauri-apps/api/window");
+  return getCurrentWindow();
+}
+
+function WindowControlButton({
+  label,
+  className,
+  onClick,
+  children,
+}: {
+  label: string;
+  className?: string;
+  onClick: () => void;
+  children: ReactNode;
+}): ReactElement {
+  return (
+    <button
+      type="button"
+      aria-label={label}
+      title={label}
+      onClick={onClick}
+      className={cn(
+        "relative z-[80] inline-flex size-8 items-center justify-center rounded-md text-muted-foreground transition-colors hover:bg-muted/80 hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
+        className,
+      )}
+    >
+      {children}
+    </button>
+  );
+}
+
+function MinimizeGlyph(): ReactElement {
+  return (
+    <span aria-hidden="true" className="h-px w-3.5 rounded-full bg-current" />
+  );
+}
+
+function MaximizeGlyph(): ReactElement {
+  return (
+    <span
+      aria-hidden="true"
+      className="size-3 rounded-[2px] border border-current"
+    />
+  );
+}
+
+function RestoreGlyph(): ReactElement {
+  return (
+    <span aria-hidden="true" className="relative size-3.5">
+      <span className="absolute left-0.5 top-0 size-2.5 rounded-[2px] border border-current" />
+      <span className="absolute bottom-0 right-0 size-2.5 rounded-[2px] border border-current bg-muted" />
+    </span>
+  );
+}
+
+function CloseGlyph(): ReactElement {
+  return (
+    <span aria-hidden="true" className="relative size-3.5">
+      <span className="absolute left-1/2 top-0 h-3.5 w-px -translate-x-1/2 rotate-45 rounded-full bg-current" />
+      <span className="absolute left-1/2 top-0 h-3.5 w-px -translate-x-1/2 -rotate-45 rounded-full bg-current" />
+    </span>
+  );
+}
+
+export function WindowTitlebar({
+  showSidebarSurface = false,
+}: {
+  showSidebarSurface?: boolean;
+}): ReactElement | null {
+  const [enabled] = useState(shouldUseCustomWindowTitlebar);
+  const [maximized, setMaximized] = useState(false);
+  const { pinned } = useSidebarPin();
+
+  const refreshMaximized = useCallback(async () => {
+    if (!enabled) {
+      return;
+    }
+    try {
+      const appWindow = await getAppWindow();
+      setMaximized(await appWindow.isMaximized());
+    } catch {
+      // If a window permission is not ready yet, keep the previous visual state.
+    }
+  }, [enabled]);
+
+  useEffect(() => {
+    if (!enabled) {
+      return;
+    }
+    let mounted = true;
+    let unlistenResize: (() => void) | undefined;
+    let unlistenFocus: (() => void) | undefined;
+
+    const setupWindowListeners = async () => {
+      try {
+        const appWindow = await getAppWindow();
+        if (!mounted) {
+          return;
+        }
+        setMaximized(await appWindow.isMaximized());
+        unlistenResize = await appWindow.onResized(() => {
+          refreshMaximized().catch(() => undefined);
+        });
+        unlistenFocus = await appWindow.onFocusChanged(() => {
+          refreshMaximized().catch(() => undefined);
+        });
+      } catch {
+        // Missing capabilities should not break the rest of the app shell.
+      }
+    };
+
+    setupWindowListeners().catch(() => undefined);
+
+    return () => {
+      mounted = false;
+      unlistenResize?.();
+      unlistenFocus?.();
+    };
+  }, [enabled, refreshMaximized]);
+
+  const runWindowAction = useCallback(
+    (action: (appWindow: TauriWindow) => Promise<void>) => {
+      const runAction = async () => {
+        try {
+          const appWindow = await getAppWindow();
+          await action(appWindow);
+          await refreshMaximized();
+        } catch {
+          // Keep custom chrome inert rather than throwing into React on denied commands.
+        }
+      };
+
+      runAction().catch(() => undefined);
+    },
+    [refreshMaximized],
+  );
+
+  const handleDragMouseDown = useCallback(
+    (event: MouseEvent<HTMLDivElement>) => {
+      if (event.button !== 0 || event.detail > 1) {
+        return;
+      }
+      runWindowAction((appWindow) => appWindow.startDragging());
+    },
+    [runWindowAction],
+  );
+
+  const handleDragDoubleClick = useCallback(
+    (event: MouseEvent<HTMLDivElement>) => {
+      if (event.button !== 0) {
+        return;
+      }
+      runWindowAction((appWindow) => appWindow.toggleMaximize());
+    },
+    [runWindowAction],
+  );
+
+  const handleResizeMouseDown = useCallback(
+    (direction: WindowResizeDirection) =>
+      (event: MouseEvent<HTMLDivElement>) => {
+        if (event.button !== 0) {
+          return;
+        }
+        event.preventDefault();
+        event.stopPropagation();
+        runWindowAction(async (appWindow) => {
+          if (!(await appWindow.isResizable())) {
+            return;
+          }
+          await appWindow.startResizeDragging(direction);
+        });
+      },
+    [runWindowAction],
+  );
+
+  if (!enabled) {
+    return null;
+  }
+
+  return (
+    <>
+      <header
+        className="relative z-[60] flex h-[var(--studio-titlebar-height)] shrink-0 select-none items-center text-foreground"
+        aria-label="Window titlebar"
+      >
+        {showSidebarSurface && (
+          <div
+            className="h-full shrink-0 border-r border-sidebar-border bg-sidebar"
+            style={{ width: pinned ? "16rem" : "3rem" }}
+            onMouseDown={handleDragMouseDown}
+            onDoubleClick={handleDragDoubleClick}
+            aria-hidden="true"
+          />
+        )}
+        <div
+          className="h-full min-w-0 flex-1 border-b border-border/35 bg-muted/35"
+          onMouseDown={handleDragMouseDown}
+          onDoubleClick={handleDragDoubleClick}
+          aria-hidden="true"
+        />
+        <div
+          className="flex h-full shrink-0 items-center gap-0.5 border-b border-border/35 bg-muted/35 px-1"
+          role="toolbar"
+          aria-label="Window controls"
+        >
+          <WindowControlButton
+            label="Minimize window"
+            onClick={() => runWindowAction((appWindow) => appWindow.minimize())}
+          >
+            <MinimizeGlyph />
+          </WindowControlButton>
+          <WindowControlButton
+            label={maximized ? "Restore window" : "Maximize window"}
+            onClick={() =>
+              runWindowAction((appWindow) => appWindow.toggleMaximize())
+            }
+          >
+            {maximized ? <RestoreGlyph /> : <MaximizeGlyph />}
+          </WindowControlButton>
+          <WindowControlButton
+            label="Close window"
+            onClick={() => runWindowAction((appWindow) => appWindow.close())}
+            className="hover:bg-destructive hover:text-destructive-foreground focus-visible:ring-destructive/70"
+          >
+            <CloseGlyph />
+          </WindowControlButton>
+        </div>
+      </header>
+      <div
+        aria-hidden="true"
+        className="fixed inset-x-2 top-0 z-[70] h-1 cursor-n-resize"
+        onMouseDown={handleResizeMouseDown("North")}
+      />
+      <div
+        aria-hidden="true"
+        className="fixed inset-x-2 bottom-0 z-[70] h-1 cursor-s-resize"
+        onMouseDown={handleResizeMouseDown("South")}
+      />
+      <div
+        aria-hidden="true"
+        className="fixed inset-y-2 left-0 z-[70] w-1 cursor-w-resize"
+        onMouseDown={handleResizeMouseDown("West")}
+      />
+      <div
+        aria-hidden="true"
+        className="fixed inset-y-2 right-0 z-[70] w-1 cursor-e-resize"
+        onMouseDown={handleResizeMouseDown("East")}
+      />
+      <div
+        aria-hidden="true"
+        className="fixed left-0 top-0 z-[70] size-3 cursor-nw-resize"
+        onMouseDown={handleResizeMouseDown("NorthWest")}
+      />
+      <div
+        aria-hidden="true"
+        className="fixed right-0 top-0 z-[70] size-3 cursor-ne-resize"
+        onMouseDown={handleResizeMouseDown("NorthEast")}
+      />
+      <div
+        aria-hidden="true"
+        className="fixed bottom-0 left-0 z-[70] size-3 cursor-sw-resize"
+        onMouseDown={handleResizeMouseDown("SouthWest")}
+      />
+      <div
+        aria-hidden="true"
+        className="fixed bottom-0 right-0 z-[70] size-3 cursor-se-resize"
+        onMouseDown={handleResizeMouseDown("SouthEast")}
+      />
+    </>
+  );
+}
diff --git a/studio/frontend/src/features/auth/api.ts b/studio/frontend/src/features/auth/api.ts
index 97d815950d..8f52c2187c 100644
--- a/studio/frontend/src/features/auth/api.ts
+++ b/studio/frontend/src/features/auth/api.ts
@@ -18,6 +18,32 @@ type RefreshResponse = {
 
 let isRedirecting = false;
 
+const TAURI_FETCH_RETRY_DELAYS_MS = [250, 750, 1500] as const;
+
+function wait(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function fetchWithTauriNetworkRetry(
+  input: RequestInfo | URL,
+  init?: RequestInit,
+): Promise<Response> {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await fetch(input, init);
+    } catch (error) {
+      if (
+        !isTauri ||
+        !(error instanceof TypeError) ||
+        attempt >= TAURI_FETCH_RETRY_DELAYS_MS.length
+      ) {
+        throw error;
+      }
+      await wait(TAURI_FETCH_RETRY_DELAYS_MS[attempt]);
+    }
+  }
+}
+
 async function isPasswordChangeRequiredResponse(response: Response): Promise<boolean> {
   if (response.status !== 403) return false;
 
@@ -54,7 +80,7 @@ async function retryWithCurrentToken(
   const retryHeaders = new Headers(init?.headers);
   const token = getAuthToken();
   if (token) retryHeaders.set("Authorization", `Bearer ${token}`);
-  return fetch(input, { ...init, headers: retryHeaders });
+  return fetchWithTauriNetworkRetry(input, { ...init, headers: retryHeaders });
 }
 
 async function retryWithTauriAutoAuth(
@@ -72,11 +98,14 @@ export async function refreshSession(): Promise<boolean> {
   if (!refreshToken) return false;
 
   try {
-    const response = await fetch(apiUrl("/api/auth/refresh"), {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ refresh_token: refreshToken }),
-    });
+    const response = await fetchWithTauriNetworkRetry(
+      apiUrl("/api/auth/refresh"),
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ refresh_token: refreshToken }),
+      },
+    );
 
     if (!response.ok) {
       clearAuthTokens();
@@ -108,7 +137,10 @@ export async function authFetch(
 
   let response: Response;
   try {
-    response = await fetch(resolvedInput, { ...init, headers });
+    response = await fetchWithTauriNetworkRetry(resolvedInput, {
+      ...init,
+      headers,
+    });
   } catch (err) {
     if (err instanceof TypeError) {
       throw new Error("Studio isn't running -- please relaunch it.");
diff --git a/studio/frontend/src/features/auth/change-password-page.tsx b/studio/frontend/src/features/auth/change-password-page.tsx
index dd4ba711e0..96ee8dd1a8 100644
--- a/studio/frontend/src/features/auth/change-password-page.tsx
+++ b/studio/frontend/src/features/auth/change-password-page.tsx
@@ -7,7 +7,7 @@ import { AuthForm } from "./components/auth-form";
 
 export function ChangePasswordPage() {
   return (
-    <div className="relative flex min-h-screen items-center justify-center overflow-hidden bg-background px-4 py-8 sm:px-6 sm:py-10 md:px-10">
+    <div className="relative flex min-h-[calc(100dvh-var(--studio-titlebar-height,0px))] items-center justify-center overflow-hidden bg-background px-4 py-8 sm:px-6 sm:py-10 md:px-10">
       <LightRays
         count={6}
         color="rgba(34, 197, 94, 0.25)"
diff --git a/studio/frontend/src/features/auth/login-page.tsx b/studio/frontend/src/features/auth/login-page.tsx
index 502b35d22a..6f4d03f1a1 100644
--- a/studio/frontend/src/features/auth/login-page.tsx
+++ b/studio/frontend/src/features/auth/login-page.tsx
@@ -7,7 +7,7 @@ import { AuthForm } from "./components/auth-form";
 
 export function LoginPage() {
   return (
-    <div className="relative flex min-h-screen items-center justify-center overflow-hidden bg-background px-4 py-8 sm:px-6 sm:py-10 md:px-10">
+    <div className="relative flex min-h-[calc(100dvh-var(--studio-titlebar-height,0px))] items-center justify-center overflow-hidden bg-background px-4 py-8 sm:px-6 sm:py-10 md:px-10">
       <LightRays
         count={6}
         color="rgba(34, 197, 94, 0.25)"
diff --git a/studio/frontend/src/features/auth/tauri-auto-auth.ts b/studio/frontend/src/features/auth/tauri-auto-auth.ts
index d67730d2d6..a0199f9ac3 100644
--- a/studio/frontend/src/features/auth/tauri-auto-auth.ts
+++ b/studio/frontend/src/features/auth/tauri-auto-auth.ts
@@ -15,9 +15,13 @@ type DesktopAuthResponse = {
   refresh_token: string;
 };
 
+type TauriAutoAuthOptions = {
+  force?: boolean;
+};
+
 // Concurrency guard: multiple route guards can call tauriAutoAuth simultaneously.
 // Without this, the first-launch password-change could race with itself.
-let pending: Promise<boolean> | null = null;
+let pending: { promise: Promise<boolean>; force: boolean } | null = null;
 let lastTauriAuthFailure: string | null = null;
 
 const TAURI_AUTH_FAILURE_FALLBACK =
@@ -49,15 +53,15 @@ function isBackendNotReady(error: unknown): boolean {
   return authFailureMessage(error).includes(BACKEND_NOT_READY_MESSAGE);
 }
 
-async function doTauriAutoAuth(): Promise<boolean> {
+async function doTauriAutoAuth(options: TauriAutoAuthOptions): Promise<boolean> {
   // Desktop must handle password-change state internally in Rust.
-  if (hasAuthToken() && !mustChangePassword()) {
+  if (!options.force && hasAuthToken() && !mustChangePassword()) {
     clearTauriAuthFailure();
     return true;
   }
 
   // Try refreshing existing session
-  if (hasRefreshToken()) {
+  if (!options.force && hasRefreshToken()) {
     const refreshed = await refreshSession();
     if (refreshed && hasAuthToken() && !mustChangePassword()) {
       clearTauriAuthFailure();
@@ -86,10 +90,17 @@ async function doTauriAutoAuth(): Promise<boolean> {
  * Returns true if authentication succeeded.
  * Concurrent calls are coalesced into a single in-flight attempt.
  */
-export function tauriAutoAuth(): Promise<boolean> {
+export function tauriAutoAuth(
+  options: TauriAutoAuthOptions = {},
+): Promise<boolean> {
   if (!isTauri) return Promise.resolve(false);
-  if (!pending) {
-    pending = doTauriAutoAuth().finally(() => { pending = null; });
+  const force = options.force === true;
+  if (!pending || (force && !pending.force)) {
+    let promise: Promise<boolean>;
+    promise = doTauriAutoAuth({ force }).finally(() => {
+      if (pending?.promise === promise) pending = null;
+    });
+    pending = { promise, force };
   }
-  return pending;
+  return pending.promise;
 }
diff --git a/studio/frontend/src/features/chat/api/chat-adapter.ts b/studio/frontend/src/features/chat/api/chat-adapter.ts
index a93120397e..dde597ca11 100644
--- a/studio/frontend/src/features/chat/api/chat-adapter.ts
+++ b/studio/frontend/src/features/chat/api/chat-adapter.ts
@@ -4,6 +4,8 @@
 import type { ChatModelAdapter } from "@assistant-ui/react";
 import type { MessageTiming, ToolCallMessagePart } from "@assistant-ui/core";
 import { toast } from "sonner";
+import { getAuthToken } from "@/features/auth/session";
+import { apiUrl } from "@/lib/api-base";
 import {
   generateAudio,
   listCachedGguf,
@@ -707,7 +709,42 @@ export function createOpenAIStreamAdapter(): ChatModelAdapter {
       const toolCallParts: ToolCallMessagePart[] = [];
       let serverMetadata: { usage?: ServerUsage; timings?: ServerTimings } | null = null;
 
+      // Per-run cancellation token so a delayed stop POST cannot match
+      // the next run on the same thread.
+      const cancelId =
+        typeof crypto !== "undefined" && "randomUUID" in crypto
+          ? crypto.randomUUID()
+          : `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+
+      // Colab-style proxies can swallow fetch aborts, so also POST
+      // /inference/cancel explicitly on abort.
+      const onAbortCancel = () => {
+        const body: Record<string, string> = { cancel_id: cancelId };
+        if (resolvedThreadId) body.session_id = resolvedThreadId;
+        // Plain fetch, not authFetch: authFetch redirects to login on
+        // 401, which would kick the user out mid-stop.
+        const token = getAuthToken();
+        // Use apiUrl so the cancel POST reaches the right origin in
+        // Tauri production builds (where the webview origin is not the
+        // backend at 127.0.0.1:<port>). Browser/dev builds get the empty
+        // base, so the path is unchanged there.
+        void fetch(apiUrl("/api/inference/cancel"), {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...(token ? { Authorization: `Bearer ${token}` } : {}),
+          },
+          body: JSON.stringify(body),
+          keepalive: true,
+        }).catch(() => {});
+      };
       try {
+        if (abortSignal.aborted) {
+          onAbortCancel();
+        } else {
+          abortSignal.addEventListener("abort", onAbortCancel, { once: true });
+        }
+
         const {
           supportsReasoning,
           reasoningEnabled,
@@ -730,6 +767,8 @@ export function createOpenAIStreamAdapter(): ChatModelAdapter {
             presence_penalty: params.presencePenalty,
             image_base64: imageBase64,
             audio_base64: audioBase64,
+            cancel_id: cancelId,
+            ...(resolvedThreadId ? { session_id: resolvedThreadId } : {}),
             ...(useAdapter === undefined ? {} : { use_adapter: useAdapter }),
             ...(supportsReasoning
               ? reasoningStyle === "reasoning_effort"
@@ -750,7 +789,6 @@ export function createOpenAIStreamAdapter(): ChatModelAdapter {
                     const mins = useChatRuntimeStore.getState().toolCallTimeout;
                     return mins >= 9999 ? 9999 : mins * 60;
                   })(),
-                  session_id: resolvedThreadId,
                 }
               : {}),
           },
@@ -948,6 +986,7 @@ export function createOpenAIStreamAdapter(): ChatModelAdapter {
         }
         throw err;
       } finally {
+        abortSignal.removeEventListener("abort", onAbortCancel);
         runtime.setGeneratingStatus(null);
         runtime.setToolStatus(null);
         clearTimeout(warmupTimer);
diff --git a/studio/frontend/src/features/chat/api/chat-api.ts b/studio/frontend/src/features/chat/api/chat-api.ts
index 15ac8748f0..ec50a3a8d5 100644
--- a/studio/frontend/src/features/chat/api/chat-api.ts
+++ b/studio/frontend/src/features/chat/api/chat-api.ts
@@ -68,7 +68,11 @@ export async function loadModel(
   const response = await authFetch("/api/inference/load", {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(payload),
+    body: JSON.stringify({
+      ...payload,
+      native_path_lease: payload.nativePathLease ?? null,
+      nativePathLease: undefined,
+    }),
   });
   return parseJsonOrThrow<LoadModelResponse>(response);
 }
@@ -81,6 +85,7 @@ export async function validateModel(
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({
       model_path: payload.model_path,
+      native_path_lease: payload.nativePathLease ?? null,
       hf_token: payload.hf_token,
       gguf_variant: payload.gguf_variant ?? null,
     }),
@@ -219,6 +224,25 @@ export async function deleteCachedModel(repoId: string, variant?: string): Promi
   await parseJsonOrThrow<unknown>(response);
 }
 
+export async function deleteFineTunedModel(args: {
+  modelPath: string;
+  source: "training" | "exported";
+  exportType?: "lora" | "merged" | "gguf";
+  ggufVariant?: string;
+}): Promise<void> {
+  const response = await authFetch("/api/models/delete-finetuned", {
+    method: "DELETE",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model_path: args.modelPath,
+      source: args.source,
+      export_type: args.exportType ?? null,
+      gguf_variant: args.ggufVariant ?? null,
+    }),
+  });
+  await parseJsonOrThrow<unknown>(response);
+}
+
 export interface ScanFolderInfo {
   id: number;
   path: string;
diff --git a/studio/frontend/src/features/chat/chat-page.tsx b/studio/frontend/src/features/chat/chat-page.tsx
index 9987af230b..fac9a94d30 100644
--- a/studio/frontend/src/features/chat/chat-page.tsx
+++ b/studio/frontend/src/features/chat/chat-page.tsx
@@ -2,11 +2,20 @@
 // Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
 
 import {
+  type DeletedModelRef,
   type LoraModelOption,
   type ModelOption,
   ModelSelector,
 } from "@/components/assistant-ui/model-selector";
 import { Thread } from "@/components/assistant-ui/thread";
+import { NativeModelChip } from "@/features/native-intents/components/native-model-chip";
+import { NativeModelDropOverlay } from "@/features/native-intents/components/native-model-drop-overlay";
+import { useChooseNativeModel } from "@/features/native-intents/use-native-dialogs";
+import { useNativeModelDrop } from "@/features/native-intents/use-native-drop";
+import { useNativePathLeasesSupported } from "@/features/native-intents/use-native-readiness";
+import { useNativeIntentStore } from "@/features/native-intents/store";
+import type { NativeIntent } from "@/features/native-intents/types";
+import { isTauri } from "@/lib/api-base";
 import { cn } from "@/lib/utils";
 import { GuidedTour, useGuidedTourController } from "@/features/tour";
 import { useSidebar } from "@/components/ui/sidebar";
@@ -129,6 +138,17 @@ type CompareModelSelection = {
   ggufVariant?: string;
 };
 
+function modelMatchesDeleted(
+  model: { id: string; ggufVariant?: string | null },
+  deletedModel?: DeletedModelRef,
+): boolean {
+  if (!deletedModel || model.id !== deletedModel.id) return false;
+  return (
+    deletedModel.ggufVariant == null ||
+    (model.ggufVariant ?? null) === deletedModel.ggufVariant
+  );
+}
+
 /**
  * Detect if this is a LoRA base-vs-fine-tuned compare.
  * Returns true when the loaded checkpoint is a LoRA — in that case
@@ -147,11 +167,15 @@ const CompareContent = memo(function CompareContent({
   models,
   loraModels,
   onFoldersChange,
+  onModelsChange,
+  deleteDisabled,
 }: {
   pairId: string;
   models: ModelOption[];
   loraModels: LoraModelOption[];
   onFoldersChange?: () => void;
+  onModelsChange?: (deletedModel?: DeletedModelRef) => void;
+  deleteDisabled?: boolean;
 }): ReactElement {
   const isLoraCompare = useIsLoraCompare();
 
@@ -163,6 +187,8 @@ const CompareContent = memo(function CompareContent({
       models={models}
       loraModels={loraModels}
       onFoldersChange={onFoldersChange}
+      onModelsChange={onModelsChange}
+      deleteDisabled={deleteDisabled}
     />
   );
 });
@@ -331,6 +357,8 @@ function GeneralCompareHeader({
   value,
   onValueChange,
   onFoldersChange,
+  onModelsChange,
+  deleteDisabled,
   side,
 }: {
   models: ModelOption[];
@@ -341,6 +369,8 @@ function GeneralCompareHeader({
     meta: { isLora: boolean; ggufVariant?: string },
   ) => void;
   onFoldersChange?: () => void;
+  onModelsChange?: (deletedModel?: DeletedModelRef) => void;
+  deleteDisabled?: boolean;
   side: "left" | "right";
 }): ReactElement {
   return (
@@ -356,6 +386,8 @@ function GeneralCompareHeader({
         value={value}
         onValueChange={onValueChange}
         onFoldersChange={onFoldersChange}
+        onModelsChange={onModelsChange}
+        deleteDisabled={deleteDisabled}
         variant="ghost"
         className="max-w-[80%] !h-[34px]"
       />
@@ -369,11 +401,15 @@ const GeneralCompareContent = memo(function GeneralCompareContent({
   models,
   loraModels,
   onFoldersChange,
+  onModelsChange,
+  deleteDisabled,
 }: {
   pairId: string;
   models: ModelOption[];
   loraModels: LoraModelOption[];
   onFoldersChange?: () => void;
+  onModelsChange?: (deletedModel?: DeletedModelRef) => void;
+  deleteDisabled?: boolean;
 }): ReactElement {
   const handlesRef = useRef<Record<string, CompareHandle>>({});
   const [model1ThreadId, setModel1ThreadId] = useState<string>();
@@ -391,6 +427,19 @@ const GeneralCompareContent = memo(function GeneralCompareContent({
     isLora: false,
   });
 
+  const handleModelsChange = useCallback(
+    (deletedModel?: DeletedModelRef) => {
+      if (modelMatchesDeleted(model1, deletedModel)) {
+        setModel1({ id: "", isLora: false });
+      }
+      if (modelMatchesDeleted(model2, deletedModel)) {
+        setModel2({ id: "", isLora: false });
+      }
+      onModelsChange?.(deletedModel);
+    },
+    [model1, model2, onModelsChange],
+  );
+
   useEffect(() => {
     let isActive = true;
     db.threads
@@ -446,6 +495,8 @@ const GeneralCompareContent = memo(function GeneralCompareContent({
                 })
               }
               onFoldersChange={onFoldersChange}
+              onModelsChange={handleModelsChange}
+              deleteDisabled={deleteDisabled}
             />
           }
         />
@@ -469,6 +520,8 @@ const GeneralCompareContent = memo(function GeneralCompareContent({
                 })
               }
               onFoldersChange={onFoldersChange}
+              onModelsChange={handleModelsChange}
+              deleteDisabled={deleteDisabled}
             />
           }
         />
@@ -484,10 +537,6 @@ export function ChatPage(): ReactElement {
   const settingsOpen = useChatRuntimeStore((s) => s.settingsPanelOpen);
   const setSettingsOpen = useChatRuntimeStore((s) => s.setSettingsPanelOpen);
 
-  useEffect(() => {
-    return () => setSettingsOpen(false);
-  }, [setSettingsOpen]);
-
   useEffect(() => {
     const threadId = search.thread;
     if (!threadId) return;
@@ -533,7 +582,11 @@ export function ChatPage(): ReactElement {
   const modelsFromStore = useChatRuntimeStore((state) => state.models);
   const lorasFromStore = useChatRuntimeStore((state) => state.loras);
   const modelsError = useChatRuntimeStore((state) => state.modelsError);
+  const modelLoading = useChatRuntimeStore((state) => state.modelLoading);
   const activeThreadId = useChatRuntimeStore((state) => state.activeThreadId);
+  const modelOperationInProgress = useChatRuntimeStore(
+    (state) => state.modelLoading,
+  );
   const {
     refresh,
     selectModel,
@@ -543,6 +596,8 @@ export function ChatPage(): ReactElement {
     loadProgress,
     loadToastDismissed,
   } = useChatModelRuntime();
+  const pendingNativeModelIntent = useNativeIntentStore((state) => state.pendingModelIntent);
+  const nativePathLeasesSupported = useNativePathLeasesSupported();
   const refreshRef = useRef(refresh);
   const selectModelRef = useRef(selectModel);
 
@@ -574,6 +629,60 @@ export function ChatPage(): ReactElement {
     return { mode: "single" };
   }, [search.thread, search.compare, search.new, activeThreadId]);
 
+  const hasActiveModel = Boolean(inferenceParams.checkpoint);
+  const loadNativeModelIntent = useCallback(
+    async (intent: NativeIntent, loadingDescription: string) => {
+      const label = intent.path.displayLabel || intent.displayLabel || "Local GGUF model";
+      await selectModel({
+        id: label,
+        nativePathToken: intent.path.token,
+        isDownloaded: true,
+        loadingDescription,
+        forceReload: true,
+        throwOnError: true,
+      });
+      useNativeIntentStore.getState().clearModelIntent(intent.id);
+    },
+    [selectModel],
+  );
+  const handleNativeModelDropAutoLoad = useCallback(
+    (intent: NativeIntent) =>
+      loadNativeModelIntent(
+        intent,
+        hasActiveModel
+          ? "Replacing with dropped local GGUF model."
+          : "Loading dropped local GGUF model.",
+      ),
+    [hasActiveModel, loadNativeModelIntent],
+  );
+  const handleNativeModelPickerAutoLoad = useCallback(
+    (intent: NativeIntent) =>
+      loadNativeModelIntent(intent, "Loading chosen local GGUF model."),
+    [loadNativeModelIntent],
+  );
+  const canAutoLoadPickedNativeModel = useCallback(() => {
+    const store = useChatRuntimeStore.getState();
+    return (
+      view.mode === "single" &&
+      nativePathLeasesSupported &&
+      !loadingModel &&
+      !modelLoading &&
+      !store.modelLoading &&
+      !store.params.checkpoint
+    );
+  }, [loadingModel, modelLoading, nativePathLeasesSupported, view.mode]);
+  const chooseNativeModel = useChooseNativeModel({
+    shouldAutoLoad: canAutoLoadPickedNativeModel,
+    onAutoLoad: handleNativeModelPickerAutoLoad,
+  });
+  const nativeModelDropState = useNativeModelDrop({
+    enabled: view.mode === "single",
+    nativePathLeasesSupported,
+    hasActiveModel,
+    isModelLoading: Boolean(loadingModel) || modelLoading,
+    onAutoLoad: handleNativeModelDropAutoLoad,
+  });
+
   const handleCheckpointChange = useCallback(
     (
       value: string,
@@ -738,6 +847,21 @@ export function ChatPage(): ReactElement {
       .catch(() => {});
   }, [navigate]);
 
+  const refreshModelLists = useCallback((deletedModel?: DeletedModelRef) => {
+    const { checkpoint } = useChatRuntimeStore.getState().params;
+    const activeGgufVariant = useChatRuntimeStore.getState().activeGgufVariant;
+    if (
+      modelMatchesDeleted(
+        { id: checkpoint, ggufVariant: activeGgufVariant },
+        deletedModel,
+      )
+    ) {
+      useChatRuntimeStore.getState().clearCheckpoint();
+    }
+    void refresh();
+    refreshLocalModels();
+  }, [refresh, refreshLocalModels]);
+
   const loraModels = useMemo<LoraModelOption[]>(() => {
     const fromLoras = lorasFromStore.map((lora) => ({
       id: lora.id,
@@ -863,6 +987,7 @@ export function ChatPage(): ReactElement {
     <div className="flex min-h-0 min-w-0 flex-1 basis-0 bg-background overflow-hidden">
       <GuidedTour {...tour.tourProps} />
       <div className="relative flex min-h-0 min-w-0 flex-1 basis-0 flex-col overflow-hidden">
+        <NativeModelDropOverlay state={nativeModelDropState} />
         <div
           className={cn(
             "absolute top-0 left-0 right-[10px] z-30 flex h-[48px] shrink-0 items-start pt-[11px] pr-2 bg-background",
@@ -881,14 +1006,24 @@ export function ChatPage(): ReactElement {
                 onValueChange={handleCheckpointChange}
                 onEject={handleEject}
                 onFoldersChange={refreshLocalModels}
+                onPickLocalModel={isTauri ? chooseNativeModel : undefined}
+                onModelsChange={refreshModelLists}
+                deleteDisabled={modelOperationInProgress}
                 variant="ghost"
                 open={modelSelectorOpen}
                 onOpenChange={handleModelSelectorOpenChange}
                 triggerDataTour="chat-model-selector"
                 contentDataTour="chat-model-selector-popover"
-                className="max-w-[62vw] sm:max-w-none !h-[34px]"
+                className="max-w-[62vw] !pr-3 sm:max-w-none !h-[34px]"
               />
             )}
+            {pendingNativeModelIntent && view.mode !== "compare" ? (
+              <NativeModelChip
+                intent={pendingNativeModelIntent}
+                nativeReadsDisabled={!nativePathLeasesSupported}
+                onLoad={(selection) => selectModel(selection)}
+              />
+            ) : null}
             {loadingModel && loadToastDismissed ? (
               <ModelLoadInlineStatus
                 label={
@@ -910,12 +1045,17 @@ export function ChatPage(): ReactElement {
                 onStop={cancelLoading}
               />
             ) : null}
+            {!loadingModel && modelsError ? (
+              <div
+                className="relative top-0.5 max-w-[28rem] truncate pl-0.5 text-xs text-destructive"
+                title={modelsError}
+                role="status"
+                aria-live="polite"
+              >
+                {modelsError}
+              </div>
+            ) : null}
           </div>
-          {modelsError && (
-            <div className="ml-2 text-xs text-destructive truncate max-w-[28rem]">
-              {modelsError}
-            </div>
-          )}
           <div className="ml-auto flex items-center gap-2">
             {view.mode === "single" && ggufContextLength && contextUsage ? (
               <ContextUsageBar
@@ -961,6 +1101,8 @@ export function ChatPage(): ReactElement {
             models={models}
             loraModels={loraModels}
             onFoldersChange={refreshLocalModels}
+            onModelsChange={refreshModelLists}
+            deleteDisabled={modelOperationInProgress}
           />
         )}
       </div>
diff --git a/studio/frontend/src/features/chat/chat-settings-sheet.tsx b/studio/frontend/src/features/chat/chat-settings-sheet.tsx
index e4574dab74..08c5ef4080 100644
--- a/studio/frontend/src/features/chat/chat-settings-sheet.tsx
+++ b/studio/frontend/src/features/chat/chat-settings-sheet.tsx
@@ -19,6 +19,7 @@ import {
   DropdownMenu,
   DropdownMenuContent,
   DropdownMenuItem,
+  DropdownMenuSeparator,
   DropdownMenuTrigger,
 } from "@/components/ui/dropdown-menu";
 import { Input } from "@/components/ui/input";
@@ -64,54 +65,36 @@ import {
 } from "@/components/ui/tooltip";
 import { Tooltip as TooltipPrimitive } from "radix-ui";
 import { AnimatePresence, motion } from "motion/react";
-import type { ReactNode } from "react";
+import { Fragment, type ReactNode } from "react";
 import { useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
 import { toast } from "sonner";
 import { useChatRuntimeStore } from "./stores/chat-runtime-store";
 import {
-  DEFAULT_INFERENCE_PARAMS,
-  type InferenceParams,
-} from "./types/runtime";
+  applyPresetParams,
+  BUILTIN_PRESET_NAMES,
+  BUILTIN_PRESETS,
+  defaultInferenceParams,
+  getBuiltinVariantName,
+  getOrderedPresets,
+  getPresetOwnedConfigKey,
+  getPresetSaveState,
+  getPresetSource,
+  getUniquePresetName,
+  isSamePresetConfig,
+  normalizeCustomPresets,
+  toPresetParams,
+  type Preset,
+} from "./presets/preset-policy";
+import type { InferenceParams } from "./types/runtime";
 
-export const defaultInferenceParams = DEFAULT_INFERENCE_PARAMS;
+export { defaultInferenceParams, type Preset } from "./presets/preset-policy";
 export type { InferenceParams } from "./types/runtime";
 
-export interface Preset {
-  name: string;
-  params: InferenceParams;
-}
-
 interface LegacySystemPromptTemplate {
   name: string;
   content: string;
 }
 
-const BUILTIN_PRESETS: Preset[] = [
-  { name: "Default", params: { ...defaultInferenceParams } },
-  {
-    name: "Creative",
-    params: {
-      ...defaultInferenceParams,
-      temperature: 1.5,
-      topP: 1.0,
-      topK: 0,
-      minP: 0.1,
-      repetitionPenalty: 1.0,
-    },
-  },
-  {
-    name: "Precise",
-    params: {
-      ...defaultInferenceParams,
-      temperature: 0.1,
-      topP: 0.95,
-      topK: 80,
-      minP: 0.01,
-      repetitionPenalty: 1.0,
-    },
-  },
-];
-
 const CHAT_PRESETS_KEY = "unsloth_chat_custom_presets";
 const CHAT_ACTIVE_PRESET_KEY = "unsloth_chat_active_preset";
 const LEGACY_CHAT_SYSTEM_PROMPTS_KEY = "unsloth_chat_system_prompts";
@@ -122,16 +105,13 @@ function canUseStorage(): boolean {
   return typeof window !== "undefined";
 }
 
-function getUniquePresetName(baseName: string, usedNames: Set<string>): string {
-  const normalizedBase = baseName.trim() || "Imported Prompt";
-  let nextName = normalizedBase;
-  let suffix = 2;
-  while (usedNames.has(nextName)) {
-    nextName = `${normalizedBase} ${suffix}`;
-    suffix += 1;
+function saveCustomPresets(presets: Preset[]): void {
+  if (!canUseStorage()) return;
+  try {
+    localStorage.setItem(CHAT_PRESETS_KEY, JSON.stringify(presets));
+  } catch {
+    // ignore
   }
-  usedNames.add(nextName);
-  return nextName;
 }
 
 function migrateLegacySystemPromptTemplates(presets: Preset[]): Preset[] {
@@ -161,18 +141,7 @@ function migrateLegacySystemPromptTemplates(presets: Preset[]): Preset[] {
     ]);
     const seenImportedConfigKeys = new Set(
       [...BUILTIN_PRESETS, ...presets].map((preset) =>
-        JSON.stringify({
-          temperature: preset.params.temperature,
-          topP: preset.params.topP,
-          topK: preset.params.topK,
-          minP: preset.params.minP,
-          repetitionPenalty: preset.params.repetitionPenalty,
-          presencePenalty: preset.params.presencePenalty,
-          maxSeqLength: preset.params.maxSeqLength,
-          maxTokens: preset.params.maxTokens,
-          systemPrompt: preset.params.systemPrompt,
-          trustRemoteCode: preset.params.trustRemoteCode ?? false,
-        }),
+        getPresetOwnedConfigKey(preset.params),
       ),
     );
     const importedPresets = parsed
@@ -191,18 +160,7 @@ function migrateLegacySystemPromptTemplates(presets: Preset[]): Preset[] {
         },
       }))
       .filter(({ importedParams }) => {
-        const configKey = JSON.stringify({
-          temperature: importedParams.temperature,
-          topP: importedParams.topP,
-          topK: importedParams.topK,
-          minP: importedParams.minP,
-          repetitionPenalty: importedParams.repetitionPenalty,
-          presencePenalty: importedParams.presencePenalty,
-          maxSeqLength: importedParams.maxSeqLength,
-          maxTokens: importedParams.maxTokens,
-          systemPrompt: importedParams.systemPrompt,
-          trustRemoteCode: importedParams.trustRemoteCode ?? false,
-        });
+        const configKey = getPresetOwnedConfigKey(importedParams);
         if (seenImportedConfigKeys.has(configKey)) return false;
         seenImportedConfigKeys.add(configKey);
         return true;
@@ -216,8 +174,8 @@ function migrateLegacySystemPromptTemplates(presets: Preset[]): Preset[] {
       localStorage.setItem(LEGACY_CHAT_SYSTEM_PROMPTS_MIGRATED_KEY, raw);
       return presets;
     }
-    const mergedPresets = [...presets, ...importedPresets];
-    localStorage.setItem(CHAT_PRESETS_KEY, JSON.stringify(mergedPresets));
+    const mergedPresets = normalizeCustomPresets([...presets, ...importedPresets]);
+    saveCustomPresets(mergedPresets);
     try {
       localStorage.setItem(LEGACY_CHAT_SYSTEM_PROMPTS_MIGRATED_KEY, raw);
       localStorage.removeItem(LEGACY_CHAT_SYSTEM_PROMPTS_KEY);
@@ -255,7 +213,11 @@ function loadSavedCustomPresets(): Preset[] {
         },
       }))
       .filter((preset) => preset.name.length > 0);
-    return migrateLegacySystemPromptTemplates(presets);
+    const normalized = normalizeCustomPresets(presets);
+    if (JSON.stringify(normalized) !== JSON.stringify(presets)) {
+      saveCustomPresets(normalized);
+    }
+    return migrateLegacySystemPromptTemplates(normalized);
   } catch {
     return migrateLegacySystemPromptTemplates([]);
   }
@@ -270,82 +232,6 @@ function loadSavedActivePreset(): string {
   }
 }
 
-type PresetSaveMode =
-  | "disabled"
-  | "overwrite-active"
-  | "overwrite-other"
-  | "create";
-
-interface PresetSaveState {
-  mode: PresetSaveMode;
-  canSubmit: boolean;
-  isSaveReady: boolean;
-  buttonLabel: string;
-  title: string;
-}
-
-function isSamePresetConfig(a: InferenceParams, b: InferenceParams): boolean {
-  return (
-    a.temperature === b.temperature &&
-    a.topP === b.topP &&
-    a.topK === b.topK &&
-    a.minP === b.minP &&
-    a.repetitionPenalty === b.repetitionPenalty &&
-    a.presencePenalty === b.presencePenalty &&
-    a.maxSeqLength === b.maxSeqLength &&
-    a.maxTokens === b.maxTokens &&
-    a.systemPrompt === b.systemPrompt &&
-    (a.trustRemoteCode ?? false) === (b.trustRemoteCode ?? false)
-  );
-}
-
-function getPresetSaveState({
-  rawName,
-  activePreset,
-  presets,
-  activePresetDirty,
-}: {
-  rawName: string;
-  activePreset: string;
-  presets: Preset[];
-  activePresetDirty: boolean;
-}): PresetSaveState {
-  const trimmedName = rawName.trim();
-  if (!trimmedName) {
-    return {
-      mode: "disabled",
-      canSubmit: false,
-      isSaveReady: false,
-      buttonLabel: "Save",
-      title: "Enter a preset name",
-    };
-  }
-
-  const matchingPreset = presets.find((preset) => preset.name === trimmedName);
-  if (matchingPreset) {
-    const isActiveMatch = matchingPreset.name === activePreset;
-    return {
-      mode: isActiveMatch ? "overwrite-active" : "overwrite-other",
-      canSubmit: !isActiveMatch || activePresetDirty,
-      isSaveReady: !isActiveMatch || activePresetDirty,
-      buttonLabel: isActiveMatch && !activePresetDirty ? "Saved" : "Overwrite",
-      title: isActiveMatch
-        ? activePresetDirty
-          ? "Save current settings to this preset"
-          : "No unsaved changes"
-        : `Overwrite preset "${trimmedName}"`,
-    };
-  }
-
-  return {
-    mode: "create",
-    canSubmit: true,
-    isSaveReady: true,
-    buttonLabel: "Save as New",
-    title: `Save current settings as "${trimmedName}"`,
-  };
-}
-
 function ParamSlider({
   label,
   value,
@@ -518,6 +404,10 @@ export function ChatSettingsPanel({
   const setCustomContextLength = useChatRuntimeStore(
     (s) => s.setCustomContextLength,
   );
+  const setActivePresetSource = useChatRuntimeStore(
+    (s) => s.setActivePresetSource,
+  );
+  const activePresetSource = useChatRuntimeStore((s) => s.activePresetSource);
 
   const ctxDisplayValue = customContextLength ?? ggufContextLength ?? "";
   const ctxMaxValue = ggufNativeContextLength ?? ggufContextLength ?? null;
@@ -540,12 +430,9 @@ export function ChatSettingsPanel({
   >(undefined);
   const [systemPromptEditorOpen, setSystemPromptEditorOpen] = useState(false);
   const [systemPromptDraft, setSystemPromptDraft] = useState("");
+  const [activePresetBaseline, setActivePresetBaseline] = useState(params);
   const presets = useMemo(() => {
-    const overrides = new Set(customPresets.map((preset) => preset.name));
-    return [
-      ...BUILTIN_PRESETS.filter((preset) => !overrides.has(preset.name)),
-      ...customPresets,
-    ];
+    return getOrderedPresets(customPresets);
   }, [customPresets]);
   const activePresetDefinition = useMemo(
     () => presets.find((preset) => preset.name === activePreset) ?? null,
@@ -555,17 +442,23 @@ export function ChatSettingsPanel({
     () => customPresets.find((preset) => preset.name === activePreset) ?? null,
     [activePreset, customPresets],
   );
-  const activeBuiltinPreset = useMemo(
-    () =>
-      BUILTIN_PRESETS.find((preset) => preset.name === activePreset) ?? null,
-    [activePreset],
-  );
-  const activePresetDirty = useMemo(
-    () =>
-      activePresetDefinition == null
-        ? false
-        : !isSamePresetConfig(activePresetDefinition.params, params),
-    [activePresetDefinition, params],
+  const hasUnsavedPresetChanges = useMemo(
+    () => {
+      if (activePresetDefinition == null) {
+        return false;
+      }
+      if (BUILTIN_PRESET_NAMES.has(activePresetDefinition.name)) {
+        if (activePresetDefinition.name === "Default") {
+          return activePresetSource === "modified";
+        }
+        return (
+          activePresetSource === "modified" ||
+          !isSamePresetConfig(activePresetDefinition.params, params)
+        );
+      }
+      return !isSamePresetConfig(activePresetDefinition.params, params);
+    },
+    [activePresetDefinition, activePresetSource, params],
   );
   const presetSaveState = useMemo(
     () =>
@@ -573,9 +466,9 @@ export function ChatSettingsPanel({
         rawName: presetNameInput,
         activePreset,
         presets,
-        activePresetDirty,
+        hasUnsavedPresetChanges,
       }),
-    [activePreset, activePresetDirty, presetNameInput, presets],
+    [activePreset, hasUnsavedPresetChanges, presetNameInput, presets],
   );
   const systemPromptEditorDirty = systemPromptDraft !== params.systemPrompt;
   const trustRemoteCodeMissing =
@@ -584,27 +477,24 @@ export function ChatSettingsPanel({
     !(params.trustRemoteCode ?? false);
 
   function set<K extends keyof InferenceParams>(key: K) {
-    return (v: InferenceParams[K]) => onParamsChange({ ...params, [key]: v });
+    return (v: InferenceParams[K]) => {
+      const nextParams = { ...params, [key]: v };
+      const nextSource = isSamePresetConfig(activePresetBaseline, nextParams)
+        ? getPresetSource(activePreset)
+        : "modified";
+      setActivePresetSource(nextSource);
+      onParamsChange(nextParams);
+    };
   }
 
   function applyPreset(name: string) {
     const p = presets.find((pr) => pr.name === name);
     if (p) {
-      if (
-        modelRequiresTrustRemoteCode &&
-        !(p.params.trustRemoteCode ?? false)
-      ) {
-        toast.warning("This configuration turns custom code off", {
-          description:
-            "The current model needs custom code enabled to load. Keep it on for this model.",
-        });
-        return;
-      }
       onParamsChange({
-        ...p.params,
-        checkpoint: params.checkpoint,
+        ...applyPresetParams(params, p.params),
       });
       setActivePreset(name);
+      setActivePresetSource(getPresetSource(name));
       if (canUseStorage()) {
         try {
           localStorage.setItem(CHAT_ACTIVE_PRESET_KEY, name);
@@ -621,27 +511,29 @@ export function ChatSettingsPanel({
       toast.error("Enter a preset name");
       return;
     }
+    const usedNames = new Set([
+      ...BUILTIN_PRESET_NAMES,
+      ...customPresets.map((preset) => preset.name),
+    ]);
+    const saveName = BUILTIN_PRESET_NAMES.has(trimmed)
+      ? getBuiltinVariantName(trimmed, usedNames)
+      : trimmed;
     setCustomPresets((prev) => {
-      const next = prev.filter((p) => p.name !== trimmed);
-      const merged = [...next, { name: trimmed, params: { ...params } }];
-      if (canUseStorage()) {
-        try {
-          localStorage.setItem(CHAT_PRESETS_KEY, JSON.stringify(merged));
-        } catch {
-          // ignore
-        }
-      }
+      const next = prev.filter((p) => p.name !== saveName);
+      const merged = [...next, { name: saveName, params: toPresetParams(params) }];
+      saveCustomPresets(merged);
       return merged;
     });
     if (canUseStorage()) {
       try {
-        localStorage.setItem(CHAT_ACTIVE_PRESET_KEY, trimmed);
+        localStorage.setItem(CHAT_ACTIVE_PRESET_KEY, saveName);
       } catch {
         // ignore
       }
     }
-    setActivePreset(trimmed);
-    setPresetNameInput(trimmed);
+    setActivePreset(saveName);
+    setActivePresetSource("custom");
+    setPresetNameInput(saveName);
   }
 
   function deletePreset(name: string) {
@@ -651,41 +543,20 @@ export function ChatSettingsPanel({
     if (!hasCustomPreset) {
       return;
     }
-    const builtinPreset = BUILTIN_PRESETS.find((preset) => preset.name === name);
     const fallbackPreset =
-      builtinPreset ??
-      BUILTIN_PRESETS.find((preset) => preset.name === "Default") ??
-      null;
-    if (
-      activePreset === name &&
-      fallbackPreset &&
-      modelRequiresTrustRemoteCode &&
-      !(fallbackPreset.params.trustRemoteCode ?? false)
-    ) {
-      toast.warning("Reset would turn custom code off", {
-        description:
-          "The current model needs custom code enabled to load. Keep it on for this model.",
-      });
-      return;
-    }
+      BUILTIN_PRESETS.find((preset) => preset.name === "Default") ?? null;
     setCustomPresets((prev) => {
       const next = prev.filter((preset) => preset.name !== name);
-      if (canUseStorage()) {
-        try {
-          localStorage.setItem(CHAT_PRESETS_KEY, JSON.stringify(next));
-        } catch {
-          // ignore
-        }
-      }
+      saveCustomPresets(next);
       return next;
     });
     if (activePreset === name) {
       if (fallbackPreset) {
         onParamsChange({
-          ...fallbackPreset.params,
-          checkpoint: params.checkpoint,
+          ...applyPresetParams(params, fallbackPreset.params),
         });
         setActivePreset(fallbackPreset.name);
+        setActivePresetSource("builtin-default");
         if (canUseStorage()) {
           try {
             localStorage.setItem(CHAT_ACTIVE_PRESET_KEY, fallbackPreset.name);
@@ -708,8 +579,46 @@ export function ChatSettingsPanel({
   }
 
   useEffect(() => {
-    if (presets.some((preset) => preset.name === activePreset)) return;
+    if (activePresetSource !== "modified") {
+      setActivePresetBaseline(params);
+    }
+  }, [activePresetSource, params]);
+
+  useEffect(() => {
+    if (presets.some((preset) => preset.name === activePreset)) {
+      const expectedSource = getPresetSource(activePreset);
+      if (activePresetDefinition != null) {
+        if (BUILTIN_PRESET_NAMES.has(activePresetDefinition.name)) {
+          if (activePresetDefinition.name === "Default") {
+            if (
+              activePresetSource !== "modified" &&
+              activePresetSource !== expectedSource
+            ) {
+              setActivePresetSource(expectedSource);
+            }
+            return;
+          }
+          const matchesActivePreset = isSamePresetConfig(
+            activePresetDefinition.params,
+            params,
+          );
+          const nextSource = matchesActivePreset ? expectedSource : "modified";
+          if (activePresetSource !== nextSource) {
+            setActivePresetSource(nextSource);
+          }
+          return;
+        }
+      }
+      if (
+        activePresetSource !== "modified" &&
+        activePresetSource !== expectedSource
+      ) {
+        setActivePresetSource(expectedSource);
+      }
+      return;
+    }
     setActivePreset("Default");
+    setActivePresetSource("builtin-default");
     if (canUseStorage()) {
       try {
         localStorage.setItem(CHAT_ACTIVE_PRESET_KEY, "Default");
@@ -717,7 +626,14 @@ export function ChatSettingsPanel({
         // ignore
       }
     }
-  }, [activePreset, presets]);
+  }, [
+    activePreset,
+    activePresetDefinition,
+    activePresetSource,
+    params,
+    presets,
+    setActivePresetSource,
+  ]);
 
   useEffect(() => {
     setPresetNameInput(activePreset);
@@ -741,6 +657,187 @@ export function ChatSettingsPanel({
     return () => ro.disconnect();
   }, [open]);
 
+  const modelSection = (
+    <CollapsibleSection
+      icon={Settings02Icon}
+      label="Model"
+      defaultOpen={true}
+    >
+      <div className="flex flex-col gap-3 py-1">
+        {isGguf && (
+          <>
+            <div className="space-y-2">
+              <div className="flex items-center justify-between">
+                <span className="text-xs font-medium">Context Length</span>
+                <Input
+                  type="number"
+                  value={
+                    typeof ctxDisplayValue === "number"
+                      ? ctxDisplayValue
+                      : (ggufContextLength ?? "")
+                  }
+                  placeholder="..."
+                  min={128}
+                  max={ctxMaxValue ?? undefined}
+                  step={1024}
+                  className="h-6 w-[100px] text-right text-xs tabular-nums"
+                  onChange={(e) => {
+                    const raw = e.target.value;
+                    if (raw === "") {
+                      setCustomContextLength(null);
+                      return;
+                    }
+                    const v = Number.parseInt(raw, 10);
+                    if (!Number.isNaN(v) && v >= 0) {
+                      const maxCtx = ctxMaxValue ?? Number.POSITIVE_INFINITY;
+                      const clamped = Math.min(v, maxCtx);
+                      setCustomContextLength(
+                        clamped === (ggufContextLength ?? 0) ? null : clamped,
+                      );
+                    }
+                  }}
+                />
+              </div>
+              <Slider
+                min={1024}
+                max={ctxMaxValue ?? 4096}
+                step={1024}
+                value={[
+                  Math.min(
+                    typeof ctxDisplayValue === "number"
+                      ? ctxDisplayValue
+                      : (ggufContextLength ?? 4096),
+                    ctxMaxValue ?? 4096,
+                  ),
+                ]}
+                onValueChange={([v]) => {
+                  setCustomContextLength(
+                    v === (ggufContextLength ?? 0) ? null : v,
+                  );
+                }}
+              />
+              {ggufMaxContextLength != null &&
+                typeof ctxDisplayValue === "number" &&
+                ctxDisplayValue > ggufMaxContextLength && (
+                  <p className="text-[11px] text-amber-500">
+                    Exceeds estimated VRAM capacity (
+                    {ggufMaxContextLength.toLocaleString()} tokens). The model
+                    may use system RAM.
+                  </p>
+                )}
+            </div>
+            <div className="grid grid-cols-[minmax(0,1fr)_65px] items-center gap-x-3">
+              <div className="min-w-0">
+                <div className="text-xs font-medium">KV Cache Dtype</div>
+                <div className="text-[11px] text-muted-foreground">
+                  Quantize KV cache to reduce VRAM.
+                </div>
+              </div>
+              <div className="w-full min-w-0">
+                <Select
+                  value={kvCacheDtype ?? "f16"}
+                  onValueChange={(v) => {
+                    setKvCacheDtype(v === "f16" ? null : v);
+                  }}
+                >
+                  <SelectTrigger className="grid h-7 w-full min-w-0 grid-cols-[minmax(0,1fr)_auto] items-center gap-1 px-2 py-0 text-xs [&_[data-slot=select-value]]:min-w-0 [&_[data-slot=select-value]]:truncate [&>svg]:shrink-0">
+                    <SelectValue />
+                  </SelectTrigger>
+                  <SelectContent>
+                    <SelectItem value="f16">f16</SelectItem>
+                    <SelectItem value="bf16">bf16</SelectItem>
+                    <SelectItem value="q8_0">q8_0</SelectItem>
+                    <SelectItem value="q5_1">q5_1</SelectItem>
+                    <SelectItem value="q4_1">q4_1</SelectItem>
+                  </SelectContent>
+                </Select>
+              </div>
+            </div>
+            {!currentModelIsVision && (
+              <div className="grid grid-cols-[minmax(0,1fr)_65px] items-center gap-x-3">
+                <div className="min-w-0">
+                  <div className="text-xs font-medium">
+                    Speculative Decoding
+                  </div>
+                  <div className="text-[11px] text-muted-foreground">
+                    Speed up generation with no VRAM cost.
+                  </div>
+                </div>
+                <div className="w-full min-w-0">
+                  <Select
+                    value={speculativeType ?? "off"}
+                    onValueChange={(v) => {
+                      setSpeculativeType(v === "off" ? null : v);
+                    }}
+                  >
+                    <SelectTrigger className="grid h-7 w-full min-w-0 grid-cols-[minmax(0,1fr)_auto] items-center gap-1 px-2 py-0 text-xs [&_[data-slot=select-value]]:min-w-0 [&_[data-slot=select-value]]:truncate [&>svg]:shrink-0">
+                      <SelectValue />
+                    </SelectTrigger>
+                    <SelectContent>
+                      <SelectItem value="default">On</SelectItem>
+                      <SelectItem value="off">Off</SelectItem>
+                    </SelectContent>
+                  </Select>
+                </div>
+              </div>
+            )}
+            {modelSettingsDirty && (
+              <div className="flex flex-wrap gap-1.5 pt-1">
+                <button
+                  type="button"
+                  onClick={() => onReloadModel?.()}
+                  className="rounded-md bg-primary px-2.5 py-1 text-[11px] font-medium text-primary-foreground transition-colors hover:bg-primary/90"
+                >
+                  Apply
+                </button>
+                <button
+                  type="button"
+                  onClick={() => {
+                    setCustomContextLength(null);
+                    setKvCacheDtype(loadedKvCacheDtype);
+                    setSpeculativeType(loadedSpeculativeType);
+                  }}
+                  className="rounded-md border px-2.5 py-1 text-[11px] font-medium text-muted-foreground transition-colors hover:bg-accent"
+                >
+                  Reset
+                </button>
+              </div>
+            )}
+          </>
+        )}
+        {!isGguf && params.checkpoint && (
+          <>
+            <div className="flex items-center justify-between gap-3">
+              <div className="min-w-0">
+                <div className="text-xs font-medium">Enable custom code</div>
+                <div className="text-[11px] text-muted-foreground">
+                  Allow models with custom code (e.g. Nemotron). Only enable if
+                  sure.
+                </div>
+              </div>
+              <Switch
+                checked={params.trustRemoteCode ?? false}
+                onCheckedChange={set("trustRemoteCode")}
+              />
+            </div>
+            {trustRemoteCodeMissing && (
+              <Alert className="border-amber-200/70 bg-amber-50/70 px-3 py-2 text-amber-950 dark:border-amber-900/70 dark:bg-amber-950/35 dark:text-amber-100">
+                <AlertTitle className="text-[11px] font-medium">
+                  Keep custom code enabled for this model
+                </AlertTitle>
+                <AlertDescription className="text-[11px] text-amber-800 dark:text-amber-200">
+                  This model requires custom code to load. You can edit the
+                  toggle, but loading will stay blocked until it is turned back
+                  on.
+                </AlertDescription>
+              </Alert>
+            )}
+          </>
+        )}
+      </div>
+    </CollapsibleSection>
+  );
+
   const settingsContent = (
     <>
       <div className="aui-thread-viewport relative h-full overflow-y-auto">
@@ -834,13 +931,16 @@ export function ChatSettingsPanel({
                       : undefined
                   }
                 >
-                  {presets.map((p) => (
-                    <DropdownMenuItem
-                      key={p.name}
-                      onSelect={() => applyPreset(p.name)}
-                    >
-                      {p.name}
-                    </DropdownMenuItem>
+                  {presets.map((p, index) => (
+                    <Fragment key={p.name}>
+                      <DropdownMenuItem onSelect={() => applyPreset(p.name)}>
+                        {p.name}
+                      </DropdownMenuItem>
+                      {index === BUILTIN_PRESETS.length - 1 &&
+                        presets.length > BUILTIN_PRESETS.length && (
+                          <DropdownMenuSeparator className="mx-2.5! my-1.5! h-0! border-t border-border/70 bg-transparent!" />
+                        )}
+                    </Fragment>
                   ))}
                 </DropdownMenuContent>
               </DropdownMenu>
@@ -874,9 +974,7 @@ export function ChatSettingsPanel({
                 className="h-8 w-full text-xs text-muted-foreground"
                 title={
                   activeCustomPreset
-                    ? activeBuiltinPreset
-                      ? "Reset selected preset to built-in defaults"
-                      : "Delete selected preset"
+                    ? "Delete selected preset"
                     : "No saved override to delete"
                 }
               >
@@ -918,188 +1016,6 @@ export function ChatSettingsPanel({
           />
         </div>
 
-        <CollapsibleSection
-          icon={Settings02Icon}
-          label="Model"
-          defaultOpen={true}
-        >
-          <div className="flex flex-col gap-3 py-1">
-            {isGguf && (
-              <>
-                <div className="space-y-2">
-                  <div className="flex items-center justify-between">
-                    <span className="text-xs font-medium">Context Length</span>
-                    <Input
-                      type="number"
-                      value={
-                        typeof ctxDisplayValue === "number"
-                          ? ctxDisplayValue
-                          : (ggufContextLength ?? "")
-                      }
-                      placeholder="..."
-                      min={128}
-                      max={ctxMaxValue ?? undefined}
-                      step={1024}
-                      className="h-6 w-[100px] text-right text-xs tabular-nums"
-                      onChange={(e) => {
-                        const raw = e.target.value;
-                        if (raw === "") {
-                          setCustomContextLength(null);
-                          return;
-                        }
-                        const v = Number.parseInt(raw, 10);
-                        if (!Number.isNaN(v) && v >= 0) {
-                          const maxCtx =
-                            ctxMaxValue ?? Number.POSITIVE_INFINITY;
-                          const clamped = Math.min(v, maxCtx);
-                          setCustomContextLength(
-                            clamped === (ggufContextLength ?? 0)
-                              ? null
-                              : clamped,
-                          );
-                        }
-                      }}
-                    />
-                  </div>
-                  <Slider
-                    min={1024}
-                    max={ctxMaxValue ?? 4096}
-                    step={1024}
-                    value={[
-                      Math.min(
-                        typeof ctxDisplayValue === "number"
-                          ? ctxDisplayValue
-                          : (ggufContextLength ?? 4096),
-                        ctxMaxValue ?? 4096,
-                      ),
-                    ]}
-                    onValueChange={([v]) => {
-                      setCustomContextLength(
-                        v === (ggufContextLength ?? 0) ? null : v,
-                      );
-                    }}
-                  />
-                  {ggufMaxContextLength != null &&
-                    typeof ctxDisplayValue === "number" &&
-                    ctxDisplayValue > ggufMaxContextLength && (
-                      <p className="text-[11px] text-amber-500">
-                        Exceeds estimated VRAM capacity (
-                        {ggufMaxContextLength.toLocaleString()} tokens). The
-                        model may use system RAM.
-                      </p>
-                    )}
-                </div>
-                <div className="grid grid-cols-[minmax(0,1fr)_65px] items-center gap-x-3">
-                  <div className="min-w-0">
-                    <div className="text-xs font-medium">KV Cache Dtype</div>
-                    <div className="text-[11px] text-muted-foreground">
-                      Quantize KV cache to reduce VRAM.
-                    </div>
-                  </div>
-                  <div className="w-full min-w-0">
-                    <Select
-                      value={kvCacheDtype ?? "f16"}
-                      onValueChange={(v) => {
-                        setKvCacheDtype(v === "f16" ? null : v);
-                      }}
-                    >
-                      <SelectTrigger className="grid h-7 w-full min-w-0 grid-cols-[minmax(0,1fr)_auto] items-center gap-1 px-2 py-0 text-xs [&_[data-slot=select-value]]:min-w-0 [&_[data-slot=select-value]]:truncate [&>svg]:shrink-0">
-                        <SelectValue />
-                      </SelectTrigger>
-                      <SelectContent>
-                        <SelectItem value="f16">f16</SelectItem>
-                        <SelectItem value="bf16">bf16</SelectItem>
-                        <SelectItem value="q8_0">q8_0</SelectItem>
-                        <SelectItem value="q5_1">q5_1</SelectItem>
-                        <SelectItem value="q4_1">q4_1</SelectItem>
-                      </SelectContent>
-                    </Select>
-                  </div>
-                </div>
-                {!currentModelIsVision && (
-                  <div className="grid grid-cols-[minmax(0,1fr)_65px] items-center gap-x-3">
-                    <div className="min-w-0">
-                      <div className="text-xs font-medium">
-                        Speculative Decoding
-                      </div>
-                      <div className="text-[11px] text-muted-foreground">
-                        Speed up generation with no VRAM cost.
-                      </div>
-                    </div>
-                    <div className="w-full min-w-0">
-                      <Select
-                        value={speculativeType ?? "off"}
-                        onValueChange={(v) => {
-                          setSpeculativeType(v === "off" ? null : v);
-                        }}
-                      >
-                        <SelectTrigger className="grid h-7 w-full min-w-0 grid-cols-[minmax(0,1fr)_auto] items-center gap-1 px-2 py-0 text-xs [&_[data-slot=select-value]]:min-w-0 [&_[data-slot=select-value]]:truncate [&>svg]:shrink-0">
-                          <SelectValue />
-                        </SelectTrigger>
-                        <SelectContent>
-                          <SelectItem value="ngram-mod">On</SelectItem>
-                          <SelectItem value="off">Off</SelectItem>
-                        </SelectContent>
-                      </Select>
-                    </div>
-                  </div>
-                )}
-                {modelSettingsDirty && (
-                  <div className="flex flex-wrap gap-1.5 pt-1">
-                    <button
-                      type="button"
-                      onClick={() => onReloadModel?.()}
-                      className="rounded-md bg-primary px-2.5 py-1 text-[11px] font-medium text-primary-foreground transition-colors hover:bg-primary/90"
-                    >
-                      Apply
-                    </button>
-                    <button
-                      type="button"
-                      onClick={() => {
-                        setCustomContextLength(null);
-                        setKvCacheDtype(loadedKvCacheDtype);
-                        setSpeculativeType(loadedSpeculativeType);
-                      }}
-                      className="rounded-md border px-2.5 py-1 text-[11px] font-medium text-muted-foreground transition-colors hover:bg-accent"
-                    >
-                      Reset
-                    </button>
-                  </div>
-                )}
-              </>
-            )}
-            {!isGguf && params.checkpoint && (
-              <>
-                <div className="flex items-center justify-between gap-3">
-                  <div className="min-w-0">
-                    <div className="text-xs font-medium">Enable custom code</div>
-                    <div className="text-[11px] text-muted-foreground">
-                      Allow models with custom code (e.g. Nemotron). Only
-                      enable if sure.
-                    </div>
-                  </div>
-                  <Switch
-                    checked={params.trustRemoteCode ?? false}
-                    onCheckedChange={set("trustRemoteCode")}
-                  />
-                </div>
-                {trustRemoteCodeMissing && (
-                  <Alert className="border-amber-200/70 bg-amber-50/70 px-3 py-2 text-amber-950 dark:border-amber-900/70 dark:bg-amber-950/35 dark:text-amber-100">
-                    <AlertTitle className="text-[11px] font-medium">
-                      Keep custom code enabled for this model
-                    </AlertTitle>
-                    <AlertDescription className="text-[11px] text-amber-800 dark:text-amber-200">
-                      This model requires custom code to load. You can edit the
-                      toggle, but loading will stay blocked until it is turned
-                      back on.
-                    </AlertDescription>
-                  </Alert>
-                )}
-              </>
-            )}
-          </div>
-        </CollapsibleSection>
-
         <CollapsibleSection
           icon={SlidersHorizontalIcon}
           label="Sampling"
@@ -1186,6 +1102,8 @@ export function ChatSettingsPanel({
           </div>
         </CollapsibleSection>
 
+        {modelSection}
+
         <CollapsibleSection icon={Wrench01Icon} label="Tools">
           <div className="flex flex-col gap-3 py-1">
             <AutoHealToolCallsToggle />
diff --git a/studio/frontend/src/features/chat/hooks/use-chat-model-runtime.ts b/studio/frontend/src/features/chat/hooks/use-chat-model-runtime.ts
index c9dcd911a2..3fc78231c6 100644
--- a/studio/frontend/src/features/chat/hooks/use-chat-model-runtime.ts
+++ b/studio/frontend/src/features/chat/hooks/use-chat-model-runtime.ts
@@ -3,6 +3,13 @@
 
 import { createElement, useCallback, useRef, useState } from "react";
 import { toast } from "sonner";
+import { consumeNativePathToken } from "@/features/native-intents/api";
+import {
+  notifyNative,
+  primeNativeNotificationPermission,
+  safeNotificationLabel,
+  sanitizeNotificationBody,
+} from "@/lib/native-notifications";
 import { ModelLoadDescription } from "../components/model-load-status";
 import {
   getDownloadProgress,
@@ -17,13 +24,28 @@ import {
 } from "../api/chat-api";
 import { formatEta, formatRate } from "../utils/format-transfer";
 import { useChatRuntimeStore } from "../stores/chat-runtime-store";
-import type { InferenceStatusResponse, LoadModelResponse } from "../types/api";
+import {
+  mergeBackendRecommendedInference,
+  resolveLoadMaxSeqLength,
+} from "../presets/preset-policy";
 import type {
   ChatLoraSummary,
   ChatModelSummary,
-  InferenceParams,
 } from "../types/runtime";
 
+// The simplified Speculative Decoding control surfaces "default" (which
+// maps to llama.cpp's --spec-default) and "off". A backend status / load
+// response can still report the older manual modes (ngram-mod,
+// ngram-simple) when a model is loaded via the API or carried over from an
+// older Studio version. The Select would render an empty trigger for those
+// values, so coerce them to "default" -- llama.cpp's own --spec-default
+// picks an equivalent strategy and keeps the dropdown coherent.
+function normalizeSpeculativeType(v: string | null | undefined): string | null {
+  if (v == null) return null;
+  if (v === "default" || v === "off") return v;
+  return "default";
+}
+
 type SelectedModelInput = {
   id: string;
   isLora?: boolean;
@@ -32,6 +54,8 @@ type SelectedModelInput = {
   isDownloaded?: boolean;
   expectedBytes?: number;
   forceReload?: boolean;
+  nativePathToken?: string;
+  throwOnError?: boolean;
 };
 
 const MODEL_LOAD_TOAST_CLASSNAMES = {
@@ -119,46 +143,10 @@ function toLoraSummary(lora: {
   };
 }
 
-function toFiniteNumber(value: unknown): number | undefined {
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    return undefined;
-  }
-  return value;
-}
-
 function getTrustRemoteCodeRequiredMessage(modelName: string): string {
   return `${modelName} needs custom code enabled to load. Turn on "Enable custom code" in Chat Settings, then try again.`;
 }
 
-function mergeRecommendedInference(
-  current: InferenceParams,
-  response: LoadModelResponse | InferenceStatusResponse,
-  modelId: string,
-): InferenceParams {
-  const inference = response.inference;
-  // GGUF: use actual context length from GGUF metadata, fallback to 131072
-  // Non-GGUF: 4096
-  const defaultMaxTokens = response.is_gguf
-    ? (response.context_length ?? 131072)
-    : 4096;
-  return {
-    ...current,
-    checkpoint: modelId,
-    maxTokens: defaultMaxTokens,
-    temperature:
-      toFiniteNumber(inference?.temperature) ?? current.temperature,
-    topP: toFiniteNumber(inference?.top_p) ?? current.topP,
-    topK: toFiniteNumber(inference?.top_k) ?? current.topK,
-    minP: toFiniteNumber(inference?.min_p) ?? current.minP,
-    presencePenalty:
-      toFiniteNumber(inference?.presence_penalty) ?? current.presencePenalty,
-    trustRemoteCode:
-      typeof inference?.trust_remote_code === "boolean"
-        ? inference.trust_remote_code
-        : current.trustRemoteCode,
-  };
-}
-
 export function useChatModelRuntime() {
   const params = useChatRuntimeStore((state) => state.params);
   const models = useChatRuntimeStore((state) => state.models);
@@ -175,6 +163,7 @@ export function useChatModelRuntime() {
     displayName: string;
     isDownloaded?: boolean;
     isCachedLora?: boolean;
+    nativePathToken?: string | null;
   } | null>(null);
   const [loadToastDismissed, setLoadToastDismissed] = useState(false);
   const [loadProgress, setLoadProgress] = useState<{
@@ -185,7 +174,9 @@ export function useChatModelRuntime() {
   const loadAbortRef = useRef<AbortController | null>(null);
   const loadingModelRef = useRef<typeof loadingModel>(null);
   const loadToastIdRef = useRef<string | number | null>(null);
+  const loadAttemptRef = useRef(0);
   const loadToastDismissedRef = useRef(false);
+  const cancelUnloadPendingRef = useRef(false);
 
   const setLoadToastDismissedState = useCallback((dismissed: boolean) => {
     loadToastDismissedRef.current = dismissed;
@@ -199,7 +190,9 @@ export function useChatModelRuntime() {
     loadAbortRef.current = null;
     loadToastIdRef.current = null;
     setLoadToastDismissedState(false);
-    useChatRuntimeStore.getState().setModelLoading(false);
+    if (!cancelUnloadPendingRef.current) {
+      useChatRuntimeStore.getState().setModelLoading(false);
+    }
   }, [setLoadToastDismissedState]);
 
   const renderLoadDescription = useCallback(
@@ -238,29 +231,13 @@ export function useChatModelRuntime() {
         // Apply inference defaults on reconnect (page refresh with model already loaded)
         if (statusRes.inference) {
           const currentParams = useChatRuntimeStore.getState().params;
-          const reconnectResponse: LoadModelResponse = {
-            status: "already_loaded",
-            model: statusRes.active_model,
-            display_name: statusRes.active_model,
-            is_vision: statusRes.is_vision,
-            is_lora: false,
-            is_gguf: statusRes.is_gguf,
-            is_audio: statusRes.is_audio,
-            audio_type: statusRes.audio_type,
-            has_audio_input: statusRes.has_audio_input,
-            inference: statusRes.inference,
-            context_length: statusRes.context_length,
-            max_context_length: statusRes.max_context_length,
-            native_context_length: statusRes.native_context_length,
-            supports_reasoning: statusRes.supports_reasoning,
-            reasoning_style: statusRes.reasoning_style,
-            reasoning_always_on: statusRes.reasoning_always_on,
-            supports_preserve_thinking: statusRes.supports_preserve_thinking,
-            supports_tools: statusRes.supports_tools,
-            speculative_type: statusRes.speculative_type,
-          };
           setParams(
-            mergeRecommendedInference(currentParams, statusRes, statusRes.active_model),
+            mergeBackendRecommendedInference({
+              current: currentParams,
+              response: statusRes,
+              modelId: statusRes.active_model,
+              presetSource: useChatRuntimeStore.getState().activePresetSource,
+            }),
           );
         }
 
@@ -279,7 +256,11 @@ export function useChatModelRuntime() {
         const ggufNativeContextLength = statusRes.is_gguf
           ? (statusRes.native_context_length ?? null)
           : null;
-        const currentSpecType = statusRes.speculative_type ?? null;
+        const currentSpecType = normalizeSpeculativeType(statusRes.speculative_type);
+        const nextDefaultChatTemplate =
+          statusRes.chat_template === undefined
+            ? useChatRuntimeStore.getState().defaultChatTemplate
+            : statusRes.chat_template;
         useChatRuntimeStore.setState({
           supportsReasoning,
           reasoningAlwaysOn,
@@ -296,6 +277,7 @@ export function useChatModelRuntime() {
           ggufNativeContextLength,
           modelRequiresTrustRemoteCode:
             statusRes.requires_trust_remote_code ?? false,
+          defaultChatTemplate: nextDefaultChatTemplate,
           speculativeType: currentSpecType,
           loadedSpeculativeType: currentSpecType,
         });
@@ -346,8 +328,18 @@ export function useChatModelRuntime() {
         ? undefined
         : "The current download may still finish in the background.",
     });
-    // Fire-and-forget: tell backend to stop, don't block UI
-    unloadModel({ model_path: model.id }).catch(() => {});
+    cancelUnloadPendingRef.current = true;
+    useChatRuntimeStore.getState().setModelLoading(true);
+    void (async () => {
+      try {
+        await unloadModel({ model_path: model.id }).catch(() => {});
+      } finally {
+        cancelUnloadPendingRef.current = false;
+        if (!loadingModelRef.current) {
+          useChatRuntimeStore.getState().setModelLoading(false);
+        }
+      }
+    })();
   }, [clearCheckpoint, setLoadToastDismissedState]);
 
   const selectModel = useCallback(
@@ -357,12 +349,20 @@ export function useChatModelRuntime() {
         typeof selection === "string" ? undefined : selection.ggufVariant;
       const forceReload =
         typeof selection === "string" ? false : selection.forceReload ?? false;
+      const nativePathToken =
+        typeof selection === "string" ? undefined : selection.nativePathToken;
+      const throwOnError =
+        typeof selection === "string" ? false : selection.throwOnError ?? false;
       const currentVariant = useChatRuntimeStore.getState().activeGgufVariant;
       if (!forceReload && (!modelId || (params.checkpoint === modelId && (ggufVariant ?? null) === (currentVariant ?? null)))) {
         return;
       }
       // Prevent duplicate loads if already loading this model
-      if (loadingModelRef.current?.id === modelId) return;
+      if (
+        loadingModelRef.current?.id === modelId &&
+        (loadingModelRef.current?.nativePathToken ?? null) === (nativePathToken ?? null)
+      )
+        return;
 
       const explicitIsLora =
         typeof selection === "string" ? undefined : selection.isLora;
@@ -376,6 +376,10 @@ export function useChatModelRuntime() {
       const isLora =
         explicitIsLora ?? model?.isLora ?? loraIsAdapter ?? false;
       const displayName = model?.name || lora?.name || modelId;
+      const loadAttemptId = ++loadAttemptRef.current;
+      primeNativeNotificationPermission().catch(() => undefined);
+      const notificationModelKey = `${modelId}:${ggufVariant ?? ""}:${loadAttemptId}`;
+      const safeModelName = safeNotificationLabel(displayName, "The model");
       const currentCheckpoint =
         useChatRuntimeStore.getState().params.checkpoint;
       const previousCheckpoint = currentCheckpoint;
@@ -402,7 +406,13 @@ export function useChatModelRuntime() {
         .join(" ");
       setModelsError(null);
       setLoadToastDismissedState(false);
-      const loadInfo = { id: modelId, displayName, isDownloaded, isCachedLora };
+      const loadInfo = {
+        id: modelId,
+        displayName,
+        isDownloaded,
+        isCachedLora,
+        nativePathToken: nativePathToken ?? null,
+      };
       setLoadingModel(loadInfo);
       useChatRuntimeStore.getState().setModelLoading(true);
       setLoadProgress(
@@ -419,17 +429,30 @@ export function useChatModelRuntime() {
           let previousWasUnloaded = false;
           const currentCheckpoint =
             useChatRuntimeStore.getState().params.checkpoint;
-          const paramsBeforeLoad = useChatRuntimeStore.getState().params;
-          const trustRemoteCode = paramsBeforeLoad.trustRemoteCode ?? false;
-          const maxSeqLength = paramsBeforeLoad.maxSeqLength;
-          const hfToken = useChatRuntimeStore.getState().hfToken || null;
+          const stateBeforeUnload = useChatRuntimeStore.getState();
+          const trustRemoteCode = stateBeforeUnload.params.trustRemoteCode ?? false;
+          const maxSeqLength = stateBeforeUnload.params.maxSeqLength;
+          const previousIsGguf =
+            previousModel?.isGguf === true
+            || previousVariant != null
+            || (previousCheckpoint?.toLowerCase().endsWith(".gguf") ?? false);
+          const rollbackMaxSeqLength = previousIsGguf
+            ? (stateBeforeUnload.ggufContextLength ?? 0)
+            : maxSeqLength;
+          const hfToken = stateBeforeUnload.hfToken || null;
           const previousModelRequiresTrustRemoteCode =
-            useChatRuntimeStore.getState().modelRequiresTrustRemoteCode;
+            stateBeforeUnload.modelRequiresTrustRemoteCode;
+          const previousActiveNativePathToken =
+            stateBeforeUnload.activeNativePathToken;
           try {
             // Lightweight pre-flight validation: avoid unloading a working model
             // if the new identifier is clearly invalid (e.g. bad HF id / path).
+            const validateNativePathLease = nativePathToken
+              ? (await consumeNativePathToken(nativePathToken, "validate-model")).nativePathLease
+              : undefined;
             const validation = await validateModel({
               model_path: modelId,
+              nativePathLease: validateNativePathLease,
               hf_token: hfToken,
               max_seq_length: maxSeqLength,
               load_in_4bit: true,
@@ -439,21 +462,39 @@ export function useChatModelRuntime() {
             if (validation.requires_trust_remote_code && !trustRemoteCode) {
               throw new Error(getTrustRemoteCodeRequiredMessage(displayName));
             }
+            if (abortCtrl.signal.aborted) throw new Error("Cancelled");
+            const loadNativePathLease = nativePathToken
+              ? (await consumeNativePathToken(nativePathToken, "load-model")).nativePathLease
+              : undefined;
 
             if (currentCheckpoint) {
               await unloadModel({ model_path: currentCheckpoint });
               previousWasUnloaded = true;
             }
+            if (abortCtrl.signal.aborted) throw new Error("Cancelled");
 
-            const { chatTemplateOverride, kvCacheDtype, customContextLength, ggufContextLength, speculativeType } = useChatRuntimeStore.getState();
-            // GGUF: use custom context length, or 0 = model's native context
-            // Non-GGUF: use the Max Seq Length slider value
-            const isDirectGgufFile = modelId.toLowerCase().endsWith(".gguf");
-            const effectiveMaxSeqLength = customContextLength != null
-              ? customContextLength
-              : (ggufVariant != null || isDirectGgufFile) ? (ggufContextLength ?? 0) : maxSeqLength;
+            const {
+              chatTemplateOverride,
+              kvCacheDtype,
+              customContextLength,
+              ggufContextLength,
+              speculativeType,
+              activePresetSource,
+              activeGgufVariant,
+            } = useChatRuntimeStore.getState();
+            const effectiveMaxSeqLength = resolveLoadMaxSeqLength({
+              modelId,
+              ggufVariant,
+              customContextLength,
+              ggufContextLength,
+              currentCheckpoint,
+              activeGgufVariant,
+              maxSeqLength,
+              presetSource: activePresetSource,
+            });
             const loadResponse = await loadModel({
               model_path: modelId,
+              nativePathLease: loadNativePathLease,
               hf_token: hfToken,
               max_seq_length: effectiveMaxSeqLength,
               load_in_4bit: true,
@@ -471,7 +512,12 @@ export function useChatModelRuntime() {
 
             const currentParams = useChatRuntimeStore.getState().params;
             setParams(
-              mergeRecommendedInference(currentParams, loadResponse, modelId),
+              mergeBackendRecommendedInference({
+                current: currentParams,
+                response: loadResponse,
+                modelId,
+                presetSource: useChatRuntimeStore.getState().activePresetSource,
+              }),
             );
             // Qwen3.5/3.6 small models (0.8B, 2B, 4B, 9B) disable thinking by default
             let reasoningDefault = loadResponse.supports_reasoning ?? false;
@@ -485,7 +531,7 @@ export function useChatModelRuntime() {
               }
             }
             const loadedKv = loadResponse.cache_type_kv ?? null;
-            const loadedSpec = loadResponse.speculative_type ?? null;
+            const loadedSpec = normalizeSpeculativeType(loadResponse.speculative_type);
             const nativeCtx = loadResponse.is_gguf
               ? (loadResponse.context_length ?? 131072)
               : null;
@@ -521,16 +567,36 @@ export function useChatModelRuntime() {
               customContextLength: keepCustomCtx,
               defaultChatTemplate: loadResponse.chat_template ?? null,
               chatTemplateOverride: null,
+              activeNativePathToken: nativePathToken ?? null,
             });
             // Qwen3/3.5/3.6: apply thinking-mode-specific params after load
             if (modelId.toLowerCase().includes("qwen3") && (loadResponse.supports_reasoning ?? false)) {
               const store = useChatRuntimeStore.getState();
-              const mid = modelId.toLowerCase();
-              const needsPresencePenalty = mid.includes("qwen3.5") || mid.includes("qwen3.6");
-              const p = reasoningDefault
-                ? { temperature: 0.6, topP: 0.95, topK: 20, minP: 0.0, ...(needsPresencePenalty ? { presencePenalty: 1.5 } : {}) }
-                : { temperature: 0.7, topP: 0.8, topK: 20, minP: 0.0, ...(needsPresencePenalty ? { presencePenalty: 1.5 } : {}) };
-              store.setParams({ ...store.params, ...p });
+              if (store.activePresetSource === "builtin-default") {
+                const mid = modelId.toLowerCase();
+                const needsPresencePenalty =
+                  mid.includes("qwen3.5") || mid.includes("qwen3.6");
+                const p = reasoningDefault
+                  ? {
+                      temperature: 0.6,
+                      topP: 0.95,
+                      topK: 20,
+                      minP: 0.0,
+                      ...(needsPresencePenalty
+                        ? { presencePenalty: 1.5 }
+                        : {}),
+                    }
+                  : {
+                      temperature: 0.7,
+                      topP: 0.8,
+                      topK: 20,
+                      minP: 0.0,
+                      ...(needsPresencePenalty
+                        ? { presencePenalty: 1.5 }
+                        : {}),
+                    };
+                store.setParams({ ...store.params, ...p });
+              }
             }
             await refresh();
           } catch (error) {
@@ -538,20 +604,36 @@ export function useChatModelRuntime() {
             if (abortCtrl.signal.aborted) throw error;
             // If we unloaded a previous model and the new load failed, attempt a rollback.
             if (previousWasUnloaded && previousCheckpoint) {
+              let rollbackNativePathLease: string | undefined;
+              if (previousActiveNativePathToken) {
+                try {
+                  rollbackNativePathLease = (
+                    await consumeNativePathToken(previousActiveNativePathToken, "load-model")
+                  ).nativePathLease;
+                } catch {
+                  throw new Error(
+                    "Could not reload the previous local model: please re-select the file.",
+                  );
+                }
+              }
               try {
                 await loadModel({
                   model_path: previousCheckpoint,
+                  nativePathLease: rollbackNativePathLease,
                   hf_token: hfToken,
-                  max_seq_length: maxSeqLength,
+                  max_seq_length: rollbackMaxSeqLength,
                   load_in_4bit: true,
                   is_lora: previousIsLora,
                   gguf_variant: previousVariant,
                   trust_remote_code:
                     previousModelRequiresTrustRemoteCode || trustRemoteCode,
                 });
+                useChatRuntimeStore.setState({
+                  activeNativePathToken: previousActiveNativePathToken ?? null,
+                });
                 await refresh();
               } catch {
-                // If rollback also fails, surface the original error.
+                // Rollback also failed; surface the original load error below.
               }
             }
             throw error;
@@ -742,6 +824,12 @@ export function useChatModelRuntime() {
                   },
                 });
               }
+              notifyNative({
+                key: `model-downloaded:${notificationModelKey}`,
+                title: "Model downloaded",
+                body: `${safeModelName} finished downloading and is loading into memory.`,
+                requestPermission: false,
+              }).catch(() => undefined);
               // Keep polling: the mmap branch below takes over from here.
             }
           } catch {
@@ -827,6 +915,12 @@ export function useChatModelRuntime() {
               duration: 2000,
             });
           }
+          notifyNative({
+            key: `model-loaded:${notificationModelKey}`,
+            title: "Model ready",
+            body: `${safeModelName} is loaded and ready to chat.`,
+            requestPermission: false,
+          }).catch(() => undefined);
         } catch (err) {
           if (!abortCtrl.signal.aborted) {
             const message =
@@ -841,6 +935,12 @@ export function useChatModelRuntime() {
                 duration: 5000,
               });
             }
+            notifyNative({
+              key: `model-load-failed:${notificationModelKey}`,
+              title: "Model failed to load",
+              body: sanitizeNotificationBody(message, "The model failed to load."),
+              requestPermission: false,
+            }).catch(() => undefined);
           }
           throw err;
         } finally {
@@ -853,6 +953,9 @@ export function useChatModelRuntime() {
         const message =
           error instanceof Error ? error.message : "Failed to load model";
         setModelsError(message);
+        if (throwOnError) {
+          throw error instanceof Error ? error : new Error(message);
+        }
       }
     },
     [
diff --git a/studio/frontend/src/features/chat/hooks/use-chat-search-index.ts b/studio/frontend/src/features/chat/hooks/use-chat-search-index.ts
index cab91da44f..d9c27dc436 100644
--- a/studio/frontend/src/features/chat/hooks/use-chat-search-index.ts
+++ b/studio/frontend/src/features/chat/hooks/use-chat-search-index.ts
@@ -105,6 +105,9 @@ async function buildIndex(): Promise<ChatSearchItem[]> {
       const arr = byThreadId.get(tid);
       if (arr) merged.push(...arr);
     }
+    if (merged.length === 0) {
+      continue;
+    }
     merged.sort((a, b) => b.createdAt - a.createdAt);
 
     let preview = "";
diff --git a/studio/frontend/src/features/chat/hooks/use-chat-sidebar-items.ts b/studio/frontend/src/features/chat/hooks/use-chat-sidebar-items.ts
index 33cdd88081..69ed162780 100644
--- a/studio/frontend/src/features/chat/hooks/use-chat-sidebar-items.ts
+++ b/studio/frontend/src/features/chat/hooks/use-chat-sidebar-items.ts
@@ -4,6 +4,7 @@
 import { db, useLiveQuery } from "../db";
 import { useChatRuntimeStore } from "../stores/chat-runtime-store";
 import type { ThreadRecord } from "../types";
+import { markChatThreadDeleted } from "../utils/chat-thread-tombstones";
 
 export interface SidebarItem {
   type: "single" | "compare";
@@ -80,6 +81,7 @@ export async function deleteChatItem(
   // Stop any in-flight streams before deleting, so the model doesn't keep
   // generating against a thread that no longer exists.
   for (const id of threadIds) cancelIfRunning(id);
+  for (const id of threadIds) markChatThreadDeleted(id);
 
   await db.transaction("rw", db.threads, db.messages, async () => {
     for (const id of threadIds) {
diff --git a/studio/frontend/src/features/chat/presets/preset-policy.ts b/studio/frontend/src/features/chat/presets/preset-policy.ts
new file mode 100644
index 0000000000..8c5d2573c9
--- /dev/null
+++ b/studio/frontend/src/features/chat/presets/preset-policy.ts
@@ -0,0 +1,351 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+import {
+  DEFAULT_INFERENCE_PARAMS,
+  type InferenceParams,
+} from "../types/runtime";
+
+export const defaultInferenceParams = DEFAULT_INFERENCE_PARAMS;
+
+export interface Preset {
+  name: string;
+  params: InferenceParams;
+}
+
+export type PresetOwnedParams = Pick<
+  InferenceParams,
+  | "temperature"
+  | "topP"
+  | "topK"
+  | "minP"
+  | "repetitionPenalty"
+  | "presencePenalty"
+  | "maxTokens"
+  | "systemPrompt"
+>;
+
+export const BUILTIN_PRESETS: Preset[] = [
+  { name: "Default", params: { ...defaultInferenceParams } },
+  {
+    name: "Creative",
+    params: {
+      ...defaultInferenceParams,
+      temperature: 1.5,
+      topP: 1.0,
+      topK: 0,
+      minP: 0.1,
+      repetitionPenalty: 1.0,
+    },
+  },
+  {
+    name: "Precise",
+    params: {
+      ...defaultInferenceParams,
+      temperature: 0.1,
+      topP: 0.95,
+      topK: 80,
+      minP: 0.01,
+      repetitionPenalty: 1.0,
+    },
+  },
+];
+
+export const BUILTIN_PRESET_NAMES = new Set(
+  BUILTIN_PRESETS.map((preset) => preset.name),
+);
+
+export type ChatPresetSource =
+  | "builtin-default"
+  | "builtin-fixed"
+  | "custom"
+  | "modified";
+
+export function getPresetSource(name: string): ChatPresetSource {
+  if (name === "Default") return "builtin-default";
+  if (BUILTIN_PRESET_NAMES.has(name)) return "builtin-fixed";
+  return "custom";
+}
+
+export function getUniquePresetName(
+  baseName: string,
+  usedNames: Set<string>,
+): string {
+  const normalizedBase = baseName.trim() || "Imported Prompt";
+  let nextName = normalizedBase;
+  let suffix = 2;
+  while (usedNames.has(nextName)) {
+    nextName = `${normalizedBase} ${suffix}`;
+    suffix += 1;
+  }
+  usedNames.add(nextName);
+  return nextName;
+}
+
+export function getBuiltinVariantName(
+  baseName: string,
+  usedNames: Set<string>,
+): string {
+  const normalizedBase = baseName.trim() || "Imported Prompt";
+  let suffix = 1;
+  let nextName = `${normalizedBase} ${suffix}`;
+  while (usedNames.has(nextName)) {
+    suffix += 1;
+    nextName = `${normalizedBase} ${suffix}`;
+  }
+  usedNames.add(nextName);
+  return nextName;
+}
+
+export function normalizeCustomPresets(presets: Preset[]): Preset[] {
+  const usedNames = new Set(BUILTIN_PRESET_NAMES);
+  return presets
+    .map((preset): Preset | null => {
+      const trimmedName = preset.name.trim();
+      if (!trimmedName) return null;
+      const name = usedNames.has(trimmedName)
+        ? getBuiltinVariantName(trimmedName, usedNames)
+        : trimmedName;
+      usedNames.add(name);
+      return {
+        name,
+        params: preset.params,
+      };
+    })
+    .filter((preset): preset is Preset => preset !== null);
+}
+
+export function getOrderedPresets(customPresets: Preset[]): Preset[] {
+  return [...BUILTIN_PRESETS, ...normalizeCustomPresets(customPresets)];
+}
+
+export function isSamePresetConfig(
+  a: InferenceParams,
+  b: InferenceParams,
+): boolean {
+  const left = getPresetOwnedParams(a);
+  const right = getPresetOwnedParams(b);
+  return (
+    left.temperature === right.temperature &&
+    left.topP === right.topP &&
+    left.topK === right.topK &&
+    left.minP === right.minP &&
+    left.repetitionPenalty === right.repetitionPenalty &&
+    left.presencePenalty === right.presencePenalty &&
+    left.maxTokens === right.maxTokens &&
+    left.systemPrompt === right.systemPrompt
+  );
+}
+
+export function getPresetOwnedParams(
+  params: InferenceParams,
+): PresetOwnedParams {
+  return {
+    temperature: params.temperature,
+    topP: params.topP,
+    topK: params.topK,
+    minP: params.minP,
+    repetitionPenalty: params.repetitionPenalty,
+    presencePenalty: params.presencePenalty,
+    maxTokens: params.maxTokens,
+    systemPrompt: params.systemPrompt,
+  };
+}
+
+export function getPresetOwnedConfigKey(params: InferenceParams): string {
+  return JSON.stringify(getPresetOwnedParams(params));
+}
+
+export function toPresetParams(params: InferenceParams): InferenceParams {
+  return {
+    ...defaultInferenceParams,
+    ...getPresetOwnedParams(params),
+  };
+}
+
+export function applyPresetParams(
+  current: InferenceParams,
+  preset: InferenceParams,
+): InferenceParams {
+  return {
+    ...current,
+    ...getPresetOwnedParams(preset),
+  };
+}
+
+export type PresetSaveMode =
+  | "disabled"
+  | "overwrite-active"
+  | "overwrite-other"
+  | "copy-builtin"
+  | "create";
+
+export interface PresetSaveState {
+  mode: PresetSaveMode;
+  canSubmit: boolean;
+  isSaveReady: boolean;
+  buttonLabel: string;
+  title: string;
+}
+
+export function getPresetSaveState({
+  rawName,
+  activePreset,
+  presets,
+  hasUnsavedPresetChanges,
+}: {
+  rawName: string;
+  activePreset: string;
+  presets: Preset[];
+  hasUnsavedPresetChanges: boolean;
+}): PresetSaveState {
+  const trimmedName = rawName.trim();
+  if (!trimmedName) {
+    return {
+      mode: "disabled",
+      canSubmit: false,
+      isSaveReady: false,
+      buttonLabel: "Save",
+      title: "Enter a preset name",
+    };
+  }
+
+  if (BUILTIN_PRESET_NAMES.has(trimmedName)) {
+    const variantName = getBuiltinVariantName(trimmedName, new Set(presets.map((preset) => preset.name)));
+    return {
+      mode: "copy-builtin",
+      canSubmit: activePreset !== trimmedName || hasUnsavedPresetChanges,
+      isSaveReady: activePreset !== trimmedName || hasUnsavedPresetChanges,
+      buttonLabel:
+        activePreset === trimmedName && !hasUnsavedPresetChanges
+          ? "Saved"
+          : "Save",
+      title:
+        activePreset === trimmedName && !hasUnsavedPresetChanges
+          ? "No unsaved changes"
+          : `Save current settings as "${variantName}"`,
+    };
+  }
+
+  const matchingPreset = presets.find((preset) => preset.name === trimmedName);
+  if (matchingPreset) {
+    const isActiveMatch = matchingPreset.name === activePreset;
+    return {
+      mode: isActiveMatch ? "overwrite-active" : "overwrite-other",
+      canSubmit: !isActiveMatch || hasUnsavedPresetChanges,
+      isSaveReady: !isActiveMatch || hasUnsavedPresetChanges,
+      buttonLabel:
+        isActiveMatch && !hasUnsavedPresetChanges ? "Saved" : "Save",
+      title: isActiveMatch
+        ? hasUnsavedPresetChanges
+          ? "Save current settings to this preset"
+          : "No unsaved changes"
+        : `Overwrite preset "${trimmedName}"`,
+    };
+  }
+
+  return {
+    mode: "create",
+    canSubmit: true,
+    isSaveReady: true,
+    buttonLabel: "Save",
+    title: `Save current settings as "${trimmedName}"`,
+  };
+}
+
+function toFiniteNumber(value: unknown): number | undefined {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return undefined;
+  }
+  return value;
+}
+
+interface BackendInferenceDefaults {
+  temperature?: number;
+  top_p?: number;
+  top_k?: number;
+  min_p?: number;
+  presence_penalty?: number;
+  trust_remote_code?: boolean;
+}
+
+export interface BackendInferenceEnvelope {
+  is_gguf?: boolean;
+  context_length?: number | null;
+  inference?: BackendInferenceDefaults;
+}
+
+export function mergeBackendRecommendedInference({
+  current,
+  response,
+  modelId,
+  presetSource,
+}: {
+  current: InferenceParams;
+  response: BackendInferenceEnvelope;
+  modelId: string;
+  presetSource: ChatPresetSource;
+}): InferenceParams {
+  const inference = response.inference;
+  const next: InferenceParams = {
+    ...current,
+    checkpoint: modelId,
+    trustRemoteCode:
+      typeof inference?.trust_remote_code === "boolean"
+        ? inference.trust_remote_code
+        : current.trustRemoteCode,
+  };
+
+  if (presetSource !== "builtin-default") {
+    return next;
+  }
+
+  const defaultMaxTokens = response.is_gguf
+    ? (response.context_length ?? current.maxTokens)
+    : 4096;
+  return {
+    ...next,
+    maxTokens: defaultMaxTokens,
+    temperature:
+      toFiniteNumber(inference?.temperature) ?? defaultInferenceParams.temperature,
+    topP: toFiniteNumber(inference?.top_p) ?? defaultInferenceParams.topP,
+    topK: toFiniteNumber(inference?.top_k) ?? defaultInferenceParams.topK,
+    minP: toFiniteNumber(inference?.min_p) ?? defaultInferenceParams.minP,
+    presencePenalty:
+      toFiniteNumber(inference?.presence_penalty) ??
+      defaultInferenceParams.presencePenalty,
+  };
+}
+
+export function resolveLoadMaxSeqLength({
+  modelId,
+  ggufVariant,
+  customContextLength,
+  ggufContextLength,
+  currentCheckpoint,
+  activeGgufVariant,
+  maxSeqLength,
+  presetSource,
+}: {
+  modelId: string;
+  ggufVariant?: string | null;
+  customContextLength: number | null;
+  ggufContextLength: number | null;
+  currentCheckpoint: string;
+  activeGgufVariant?: string | null;
+  maxSeqLength: number;
+  presetSource: ChatPresetSource;
+}): number {
+  const isDirectGgufFile = modelId.toLowerCase().endsWith(".gguf");
+  const isGgufLoad = ggufVariant != null || isDirectGgufFile;
+  const isReloadingCurrentGguf =
+    isGgufLoad &&
+    currentCheckpoint === modelId &&
+    (ggufVariant ?? null) === (activeGgufVariant ?? null);
+
+  if (customContextLength != null) return customContextLength;
+  if (isGgufLoad && presetSource === "builtin-default") return 0;
+  if (isReloadingCurrentGguf) return ggufContextLength ?? 0;
+  if (isGgufLoad) return 0;
+  return maxSeqLength;
+}
diff --git a/studio/frontend/src/features/chat/runtime-provider.tsx b/studio/frontend/src/features/chat/runtime-provider.tsx
index 105f2fb4b1..546cc21ed2 100644
--- a/studio/frontend/src/features/chat/runtime-provider.tsx
+++ b/studio/frontend/src/features/chat/runtime-provider.tsx
@@ -16,19 +16,32 @@ import {
   WebSpeechDictationAdapter,
   type unstable_RemoteThreadListAdapter,
   useAui,
+  useAuiEvent,
   useAuiState,
   useLocalRuntime,
   unstable_useRemoteThreadListRuntime as useRemoteThreadListRuntime,
 } from "@assistant-ui/react";
 import { createAssistantStream } from "assistant-stream";
 import mammoth from "mammoth";
-import { type ReactElement, type ReactNode, useEffect, useMemo } from "react";
+import {
+  type ReactElement,
+  type ReactNode,
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+} from "react";
 import { extractText, getDocumentProxy } from "unpdf";
 import { authFetch } from "@/features/auth";
 import { createOpenAIStreamAdapter } from "./api/chat-adapter";
 import { db } from "./db";
 import { useChatRuntimeStore } from "./stores/chat-runtime-store";
 import type { MessageRecord, ModelType } from "./types";
+import {
+  isChatThreadDeleted,
+  markChatThreadDeleted,
+} from "./utils/chat-thread-tombstones";
+import { syncExportedRepositoryToDexie } from "./utils/delete-thread-message";
 
 const DEFAULT_SUGGESTIONS = [
   {
@@ -383,6 +396,55 @@ function toThreadMessage(m: MessageRecord): ThreadMessage {
   };
 }
 
+async function ensureThreadRecord({
+  threadId,
+  modelType,
+  pairId,
+}: {
+  threadId: string;
+  modelType: ModelType;
+  pairId?: string;
+}): Promise<void> {
+  if (isChatThreadDeleted(threadId)) {
+    return;
+  }
+  const existing = await db.threads.get(threadId);
+  if (existing) {
+    return;
+  }
+
+  const currentModelId =
+    useChatRuntimeStore.getState().params.checkpoint ?? "";
+  const record = {
+    id: threadId,
+    title: "New Chat",
+    modelType,
+    modelId: currentModelId,
+    pairId,
+    archived: false,
+    createdAt: Date.now(),
+  };
+
+  try {
+    await db.threads.add(record);
+  } catch (error) {
+    // assistant-ui can issue overlapping first-message persistence calls.
+    // If another call created the same thread while this one was waiting,
+    // treat initialization as successful and let the message write continue.
+    if (await db.threads.get(threadId)) {
+      return;
+    }
+    throw error;
+  }
+}
+
+async function deleteThreadRows(threadId: string): Promise<void> {
+  await db.transaction("rw", db.threads, db.messages, async () => {
+    await db.messages.where("threadId").equals(threadId).delete();
+    await db.threads.delete(threadId);
+  });
+}
+
 function createDexieAdapter(
   modelType: ModelType,
   pairId?: string,
@@ -418,17 +480,7 @@ function createDexieAdapter(
     },
 
     async initialize(threadId: string) {
-      const currentModelId =
-        useChatRuntimeStore.getState().params.checkpoint ?? "";
-      await db.threads.add({
-        id: threadId,
-        title: "New Chat",
-        modelType,
-        modelId: currentModelId,
-        pairId,
-        archived: false,
-        createdAt: Date.now(),
-      });
+      await ensureThreadRecord({ threadId, modelType, pairId });
       return { remoteId: threadId, externalId: undefined };
     },
 
@@ -445,8 +497,8 @@ function createDexieAdapter(
     },
 
     async delete(remoteId: string) {
-      await db.messages.where("threadId").equals(remoteId).delete();
-      await db.threads.delete(remoteId);
+      markChatThreadDeleted(remoteId);
+      await deleteThreadRows(remoteId);
     },
 
     async generateTitle(remoteId: string, messages: readonly ThreadMessage[]) {
@@ -599,6 +651,10 @@ function ThreadHistoryProvider({
 
       async append({ parentId, message }: ExportedMessageRepositoryItem) {
         const { remoteId } = await aui.threadListItem().initialize();
+        if (isChatThreadDeleted(remoteId)) {
+          await deleteThreadRows(remoteId);
+          return;
+        }
         // Keep single-chat runtime state in sync once a new chat is first
         // persisted. Compare panes intentionally do not write global activeThreadId.
         const thread = await db.threads.get(remoteId);
@@ -765,6 +821,66 @@ function CancelRegistrar(): ReactElement | null {
   return null;
 }
 
+function ThreadDexieAutosave({
+  modelType,
+  pairId,
+}: {
+  modelType: ModelType;
+  pairId?: string;
+}): ReactElement | null {
+  const aui = useAui();
+  const saveChainRef = useRef(Promise.resolve());
+
+  const saveThread = useCallback(async (threadId: string): Promise<void> => {
+    const runtime = aui.threads().__internal_getAssistantRuntime?.();
+    if (!runtime) {
+      return;
+    }
+    const exported = runtime.threads.getById(threadId).export();
+    if (exported.messages.length === 0) {
+      return;
+    }
+
+    const { remoteId } = await runtime.threads.getItemById(threadId).initialize();
+    if (isChatThreadDeleted(remoteId)) {
+      await deleteThreadRows(remoteId);
+      return;
+    }
+    await syncExportedRepositoryToDexie(remoteId, exported);
+    if (isChatThreadDeleted(remoteId)) {
+      await deleteThreadRows(remoteId);
+      return;
+    }
+
+    if (modelType === "base" && !pairId) {
+      const store = useChatRuntimeStore.getState();
+      const activeThreadId = runtime.threads.getState().mainThreadId;
+      if (activeThreadId === threadId && store.activeThreadId !== remoteId) {
+        store.setActiveThreadId(remoteId);
+      }
+    }
+  }, [aui, modelType, pairId]);
+
+  const queueSave = useCallback((threadId: string): void => {
+    saveChainRef.current = saveChainRef.current
+      .catch(() => {})
+      .then(() => saveThread(threadId))
+      .catch((error) => {
+        console.error("Failed to autosave chat thread", error);
+      });
+  }, [saveThread]);
+
+  useAuiEvent("thread.runEnd", ({ threadId }) => {
+    queueSave(threadId);
+  });
+
+  useAuiEvent("thread.runStart", ({ threadId }) => {
+    queueSave(threadId);
+  });
+
+  return null;
+}
+
 export function ChatRuntimeProvider({
   children,
   modelType = "base",
@@ -797,6 +913,7 @@ export function ChatRuntimeProvider({
       <ActiveThreadSync
         enabled={modelType === "base" && !pairId && !newThreadNonce && !initialThreadId}
       />
+      <ThreadDexieAutosave modelType={modelType} pairId={pairId} />
       <CancelRegistrar />
       {initialThreadId && (
         <ThreadAutoSwitch
diff --git a/studio/frontend/src/features/chat/shared-composer.tsx b/studio/frontend/src/features/chat/shared-composer.tsx
index 3ba2f8b6f5..1741b7e409 100644
--- a/studio/frontend/src/features/chat/shared-composer.tsx
+++ b/studio/frontend/src/features/chat/shared-composer.tsx
@@ -12,6 +12,7 @@ import {
 } from "@/components/ui/dropdown-menu";
 import { applyQwenThinkingParams } from "@/features/chat/utils/qwen-params";
 import { AUDIO_ACCEPT, MAX_AUDIO_SIZE, fileToBase64 } from "@/lib/audio-utils";
+import { isTauri } from "@/lib/api-base";
 import { useAui } from "@assistant-ui/react";
 import { cn } from "@/lib/utils";
 import { ArrowUpIcon, GlobeIcon, HeadphonesIcon, LightbulbIcon, LightbulbOffIcon, MicIcon, PlusIcon, SquareIcon, XIcon } from "lucide-react";
@@ -493,11 +494,15 @@ export function SharedComposer({
     <div
       className={`chat-composer-surface relative flex w-full flex-col rounded-3xl bg-background dark:bg-card px-1 pt-2 transition-shadow outline-none ${dragging ? "border-ring bg-accent/50" : ""}`}
       onDragOver={(e) => {
+        if (isTauri) return;
         e.preventDefault();
         setDragging(true);
       }}
       onDragLeave={() => setDragging(false)}
       onDrop={(e) => {
+        // Phase 1 native model drops own Tauri local-path drops. Restore browser
+        // attachment drops in Tauri when Phase 1d adds attachment-token bridging.
+        if (isTauri) return;
         e.preventDefault();
         setDragging(false);
         addFiles(e.dataTransfer.files);
@@ -662,7 +667,7 @@ export function SharedComposer({
                     : "bg-muted text-muted-foreground hover:bg-muted-foreground/15",
               )}
               aria-label={
-                preserveThinking ? "Disable preserve thinking" : "Enable preserve thinking"
+                preserveThinking ? "Disable preserve think" : "Enable preserve think"
               }
             >
               {preserveThinking && modelLoaded ? (
@@ -670,7 +675,7 @@ export function SharedComposer({
               ) : (
                 <LightbulbOffIcon className="size-3.5" />
               )}
-              <span>Preserve Thinking</span>
+              <span>Preserve Think</span>
             </button>
           )}
           <button
diff --git a/studio/frontend/src/features/chat/stores/chat-runtime-store.ts b/studio/frontend/src/features/chat/stores/chat-runtime-store.ts
index 2a1249aea0..d67dbc36d8 100644
--- a/studio/frontend/src/features/chat/stores/chat-runtime-store.ts
+++ b/studio/frontend/src/features/chat/stores/chat-runtime-store.ts
@@ -9,6 +9,10 @@ import {
   type ChatModelSummary,
   type InferenceParams,
 } from "../types/runtime";
+import {
+  getPresetSource,
+  type ChatPresetSource,
+} from "../presets/preset-policy";
 
 const AUTO_TITLE_KEY = "unsloth_chat_auto_title";
 const AUTO_HEAL_TOOL_CALLS_KEY = "unsloth_auto_heal_tool_calls";
@@ -16,6 +20,8 @@ const MAX_TOOL_CALLS_KEY = "unsloth_max_tool_calls_per_message";
 const TOOL_CALL_TIMEOUT_KEY = "unsloth_tool_call_timeout";
 const HF_TOKEN_KEY = "unsloth_hf_token";
 const INFERENCE_PARAMS_KEY = "unsloth_chat_inference_params";
+const CHAT_ACTIVE_PRESET_KEY = "unsloth_chat_active_preset";
+const CHAT_ACTIVE_PRESET_SOURCE_KEY = "unsloth_chat_active_preset_source";
 const REASONING_EFFORT_KEY = "unsloth_reasoning_effort";
 const PRESERVE_THINKING_KEY = "unsloth_preserve_thinking";
 
@@ -157,8 +163,24 @@ function saveInferenceParams(params: InferenceParams): boolean {
   }
 }
 
+function loadPresetSource(): ChatPresetSource {
+  const activePreset = loadString(CHAT_ACTIVE_PRESET_KEY, "Default");
+  if (canUseStorage()) {
+    try {
+      const raw = localStorage.getItem(CHAT_ACTIVE_PRESET_SOURCE_KEY);
+      if (raw === "modified") {
+        return "modified";
+      }
+    } catch {
+      // ignore
+    }
+  }
+  return getPresetSource(activePreset);
+}
+
 type ChatRuntimeStore = {
   params: InferenceParams;
+  activePresetSource: ChatPresetSource;
   models: ChatModelSummary[];
   loras: ChatLoraSummary[];
   runningByThreadId: Record<string, boolean>;
@@ -204,9 +226,11 @@ type ChatRuntimeStore = {
     cachedTokens: number;
   } | null;
   modelLoading: boolean;
+  activeNativePathToken: string | null;
   setModelLoading: (loading: boolean) => void;
   setModelRequiresTrustRemoteCode: (required: boolean) => void;
   setParams: (params: InferenceParams) => void;
+  setActivePresetSource: (source: ChatPresetSource) => void;
   setModels: (models: ChatModelSummary[]) => void;
   setLoras: (loras: ChatLoraSummary[]) => void;
   setThreadRunning: (threadId: string, running: boolean) => void;
@@ -241,6 +265,7 @@ type ChatRuntimeStore = {
 
 export const useChatRuntimeStore = create<ChatRuntimeStore>((set) => ({
   params: loadInferenceParams(),
+  activePresetSource: loadPresetSource(),
   models: [],
   loras: [],
   runningByThreadId: {},
@@ -270,7 +295,7 @@ export const useChatRuntimeStore = create<ChatRuntimeStore>((set) => ({
   toolCallTimeout: loadInt(TOOL_CALL_TIMEOUT_KEY, 5),
   kvCacheDtype: null,
   loadedKvCacheDtype: null,
-  speculativeType: "ngram-mod",
+  speculativeType: "default",
   loadedSpeculativeType: null,
   customContextLength: null,
   defaultChatTemplate: null,
@@ -281,6 +306,7 @@ export const useChatRuntimeStore = create<ChatRuntimeStore>((set) => ({
   pendingAudioName: null,
   contextUsage: null,
   modelLoading: false,
+  activeNativePathToken: null,
   setModelLoading: (loading) => set({ modelLoading: loading }),
   setModelRequiresTrustRemoteCode: (modelRequiresTrustRemoteCode) =>
     set({ modelRequiresTrustRemoteCode }),
@@ -296,6 +322,11 @@ export const useChatRuntimeStore = create<ChatRuntimeStore>((set) => ({
       }
       return { params };
     }),
+  setActivePresetSource: (activePresetSource) =>
+    set(() => {
+      saveString(CHAT_ACTIVE_PRESET_SOURCE_KEY, activePresetSource);
+      return { activePresetSource };
+    }),
   setModels: (models) => set({ models }),
   setLoras: (loras) => set({ loras }),
   setThreadRunning: (threadId, running) =>
@@ -349,6 +380,7 @@ export const useChatRuntimeStore = create<ChatRuntimeStore>((set) => ({
         checkpoint: "",
       },
       activeGgufVariant: null,
+      activeNativePathToken: null,
       ggufContextLength: null,
       ggufMaxContextLength: null,
       ggufNativeContextLength: null,
@@ -365,7 +397,7 @@ export const useChatRuntimeStore = create<ChatRuntimeStore>((set) => ({
       toolStatus: null,
       kvCacheDtype: null,
       loadedKvCacheDtype: null,
-      speculativeType: "ngram-mod",
+      speculativeType: "default",
       loadedSpeculativeType: null,
       customContextLength: null,
       defaultChatTemplate: null,
diff --git a/studio/frontend/src/features/chat/types/api.ts b/studio/frontend/src/features/chat/types/api.ts
index ccfc8b2bf1..e5e7151dcc 100644
--- a/studio/frontend/src/features/chat/types/api.ts
+++ b/studio/frontend/src/features/chat/types/api.ts
@@ -32,6 +32,7 @@ export interface ListLorasResponse {
 
 export interface LoadModelRequest {
   model_path: string;
+  nativePathLease?: string | null;
   hf_token: string | null;
   max_seq_length: number;
   load_in_4bit: boolean;
@@ -129,6 +130,7 @@ export interface InferenceStatusResponse {
   reasoning_always_on?: boolean;
   supports_preserve_thinking?: boolean;
   supports_tools?: boolean;
+  chat_template?: string | null;
   context_length?: number | null;
   max_context_length?: number | null;
   native_context_length?: number | null;
@@ -179,6 +181,7 @@ export interface OpenAIChatCompletionsRequest {
   max_tool_calls_per_message?: number;
   tool_call_timeout?: number;
   session_id?: string;
+  cancel_id?: string;
 }
 
 export interface OpenAIChatDelta {
diff --git a/studio/frontend/src/features/chat/utils/chat-thread-tombstones.ts b/studio/frontend/src/features/chat/utils/chat-thread-tombstones.ts
new file mode 100644
index 0000000000..462fc3c0df
--- /dev/null
+++ b/studio/frontend/src/features/chat/utils/chat-thread-tombstones.ts
@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+const deletedThreadIds = new Set<string>();
+
+export function markChatThreadDeleted(threadId: string): void {
+  deletedThreadIds.add(threadId);
+}
+
+export function isChatThreadDeleted(threadId: string): boolean {
+  return deletedThreadIds.has(threadId);
+}
diff --git a/studio/frontend/src/features/chat/utils/delete-thread-message.ts b/studio/frontend/src/features/chat/utils/delete-thread-message.ts
index a6d6556a87..d410c37a34 100644
--- a/studio/frontend/src/features/chat/utils/delete-thread-message.ts
+++ b/studio/frontend/src/features/chat/utils/delete-thread-message.ts
@@ -9,16 +9,18 @@ import type {
 /**
  * assistant-ui does not expose a public `deleteMessage` on `ThreadRuntime` / `MessageRuntime`
  * in our version, but it already implements branch-safe deletion inside `MessageRepository`.
- * We import that helper from an **internal** package path (`runtime/utils/message-repository`).
+ * We import that helper from `@assistant-ui/core/internal`, the package's exported internal
+ * surface. Avoid importing the deeper `runtime/utils/message-repository` path directly: newer
+ * `@assistant-ui/core` releases no longer export arbitrary deep paths.
  *
  * **Maintainability:** treat this file as the only place that imports `MessageRepository` from
  * `@assistant-ui/core`. When bumping `@assistant-ui/react` / `@assistant-ui/core`, re-run chat
  * delete + reload smoke tests; the path or API may change without a semver signal on “public”
  * surface area.
  */
-import { MessageRepository } from "@assistant-ui/core/runtime/utils/message-repository";
-import { db } from "@/features/chat/db";
-import type { MessageRecord } from "@/features/chat/types";
+import { MessageRepository } from "@assistant-ui/core/internal";
+import { db } from "../db";
+import type { MessageRecord } from "../types";
 
 function cloneContent(content: ThreadMessage["content"]): ThreadMessage["content"] {
   if (typeof content === "string") {
@@ -69,21 +71,24 @@ function exportedItemToRecord(
 }
 
 /**
- * Persist the exact message list represented by `exp` for this thread, removing
- * Dexie rows that are no longer present (e.g. after a delete).
+ * Persist exported messages, pruning only for explicit delete flows.
  */
-async function syncExportedRepositoryToDexie(
+export async function syncExportedRepositoryToDexie(
   remoteId: string,
   exp: ExportedMessageRepository,
+  options: { pruneMissing?: boolean } = {},
 ): Promise<void> {
   await db.transaction("rw", db.messages, async () => {
-    const keepIds = new Set(exp.messages.map((x) => x.message.id));
-    const existing = await db.messages.where("threadId").equals(remoteId).toArray();
-    const idsToDelete = existing
-      .filter((m) => !keepIds.has(m.id))
-      .map((m) => m.id);
-    if (idsToDelete.length > 0) {
-      await db.messages.bulkDelete(idsToDelete);
+    if (options.pruneMissing) {
+      const keepIds = new Set(exp.messages.map((x) => x.message.id));
+      const existingIds = await db.messages
+        .where("threadId")
+        .equals(remoteId)
+        .primaryKeys();
+      const idsToDelete = existingIds.filter((id) => !keepIds.has(String(id)));
+      if (idsToDelete.length > 0) {
+        await db.messages.bulkDelete(idsToDelete);
+      }
     }
     await db.messages.bulkPut(
       exp.messages.map(({ message, parentId }) =>
@@ -113,7 +118,7 @@ export async function deleteThreadMessage(args: {
   repo.deleteMessage(messageId);
   const next = repo.export();
   if (remoteId) {
-    await syncExportedRepositoryToDexie(remoteId, next);
+    await syncExportedRepositoryToDexie(remoteId, next, { pruneMissing: true });
   }
   thread.import(next);
 }
diff --git a/studio/frontend/src/features/data-recipes/learning-recipes/github-support-bot.json b/studio/frontend/src/features/data-recipes/learning-recipes/github-support-bot.json
new file mode 100644
index 0000000000..b984f84d2f
--- /dev/null
+++ b/studio/frontend/src/features/data-recipes/learning-recipes/github-support-bot.json
@@ -0,0 +1,238 @@
+{
+  "recipe": {
+    "model_providers": [
+      {
+        "name": "Local Model",
+        "endpoint": "",
+        "provider_type": "openai",
+        "extra_headers": {},
+        "extra_body": {},
+        "is_local": true
+      }
+    ],
+    "mcp_providers": [],
+    "model_configs": [
+      {
+        "alias": "model_1",
+        "model": "unsloth/gemma-4-E2B-it-GGUF",
+        "provider": "Local Model",
+        "inference_parameters": {
+          "temperature": 0.4,
+          "max_tokens": 800
+        }
+      }
+    ],
+    "seed_config": {
+      "source": {
+        "seed_type": "github_repo",
+        "repos": [
+          "unslothai/unsloth",
+          "unslothai/unsloth-zoo"
+        ],
+        "item_types": [
+          "issues",
+          "pulls"
+        ],
+        "limit": 100,
+        "include_comments": true,
+        "max_comments_per_item": 20
+      },
+      "sampling_strategy": "shuffle",
+      "selection_strategy": null
+    },
+    "tool_configs": [],
+    "columns": [
+      {
+        "column_type": "llm-text",
+        "name": "User",
+        "drop": false,
+        "model_alias": "model_1",
+        "prompt": "Read the GitHub {{ item_type }} below and write ONE realistic user request that could have produced it. Imagine a developer asking a GitHub co-author model to either file this {{ item_type }} or draft a PR that resolves it. Use first-person imperative phrasing (\"Open an issue...\", \"Draft a PR that...\", \"Investigate why...\"). Preserve concrete technical details (model names, flags, file paths, tracebacks) that appear in the thread. Keep it 1-3 sentences. Output ONLY the user request, no preamble.\n\n--- INPUT ---\nRepo: {{ repo }}\nType: {{ item_type }}\nTitle: {{ title }}\nBody:\n{{ body }}\n\nFirst comments:\n{{ comments }}",
+        "system_prompt": "You invert real GitHub threads into the user request that would have produced them. Faithful to the thread, no invented facts, no em-dashes, no emojis.",
+        "with_trace": "none",
+        "extract_reasoning_content": false
+      },
+      {
+        "column_type": "llm-structured",
+        "name": "Assistant",
+        "drop": false,
+        "model_alias": "model_1",
+        "prompt": "You are generating one training row for an Unsloth GitHub co-author model. Given the real GitHub thread and a synthesized user request, produce a grounded structured response.\n\nSource thread:\n- Repo: {{ repo }}\n- Type: {{ item_type }}\n- Title: {{ title }}\n- URL: {{ url }}\n- State: {{ state }}\n- Labels: {{ labels }}\n- Body: {{ body }}\n- First comments: {{ comments }}\n\nUser request:\n{{ User }}\n\nRules:\n- `response`: 100-250 words of Markdown grounded in the thread. If the thread is a closed / resolved issue, follow the `issue_fix_plan` shape: brief diagnosis, numbered fix steps, and a short repro. If the thread is a PR, follow the `explain_pr` shape: what changed, why, and which files or symbols were touched. If the thread is open / unresolved, answer honestly and ask for the missing info.\n- Cite the source URL at least once inline as `[source: {{ url }}]`.\n- Name at least one concrete symbol (function, class, flag, env var, or file path) from the thread when available.\n- Include a short ```bash or ```python code block ONLY if the thread itself contains that code or command.\n- Never recommend `rm -rf`, force push, or other destructive commands without an explicit warning.\n- No em-dashes, no emojis, no AI-disclaimer phrases. Only cite URLs / paths that appear in the thread.\n- `followups`: 0-4 follow-up questions when the thread is missing info (versions, GPU, traceback). Empty list if the response is complete.\n- `cites`: URLs / file paths actually used. Always include `{{ url }}`.\n- `task`: one of `explain_pr`, `issue_fix_plan`, `issue_solution`, `discussion_qa`. Pick the closest match.\n- `confidence`: `high` / `medium` / `low`. Use `low` when ambiguous or out of scope.",
+        "system_prompt": "You write grounded GitHub co-author responses for Unsloth. Faithful to the thread, no invented facts, no em-dashes, no emojis, no AI-disclaimer phrases.",
+        "with_trace": "none",
+        "extract_reasoning_content": false,
+        "output_format": {
+          "type": "object",
+          "properties": {
+            "response": {
+              "type": "string",
+              "minLength": 1
+            },
+            "followups": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "maxItems": 4
+            },
+            "cites": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "maxItems": 6
+            },
+            "task": {
+              "type": "string",
+              "enum": [
+                "explain_pr",
+                "issue_fix_plan",
+                "issue_solution",
+                "discussion_qa"
+              ]
+            },
+            "confidence": {
+              "type": "string",
+              "enum": [
+                "high",
+                "medium",
+                "low"
+              ]
+            }
+          },
+          "required": [
+            "response",
+            "followups",
+            "cites",
+            "task",
+            "confidence"
+          ],
+          "additionalProperties": false
+        }
+      }
+    ],
+    "processors": []
+  },
+  "run": {
+    "rows": 5,
+    "preview": true,
+    "output_formats": [
+      "jsonl"
+    ]
+  },
+  "ui": {
+    "nodes": [
+      {
+        "id": "note_1",
+        "x": 460.4272962489311,
+        "y": 123.10114554082236,
+        "width": 400,
+        "node_type": "markdown_note",
+        "name": "note_1",
+        "markdown": "### GitHub Crawler\nReal GitHub issues and PRs turned into `{User, Assistant}` training pairs. Mirrors two of the eleven canonical enrichment tasks in the `github_data_gatherer` dataset: `pr_requests_20` / `issue_requests_20` for the input side, and `explain_pr` / `issue_fix_plan` / `issue_solution` for the output side.\n\n**Click `Run` below for 10 sample rows.** Defaults point at `unslothai/unsloth` + `unslothai/unsloth-zoo`, use the server's `GH_TOKEN` / `GITHUB_TOKEN` env var, and run the bundled local model. Paste a PAT only when you need private repos.\n\n**Configure source data**\n- Paste `owner/name` values or GitHub URLs; the editor normalizes and dedupes them.\n- Keep the seed `limit` around 100 for previews. Increase toward 5000 per item type for larger backfills.\n- Comments and large repos can make Check or Run take minutes; watch logs for GitHub page and rate-limit messages.\n\n**Upgrade to production**\n- Swap `unsloth/gemma-4-E2B-it-GGUF` for a stronger model (`gpt-5.4-mini` with `reasoning_effort=medium` is what the reference dataset uses).\n- Replace the demo prompts with the task-specific prompts from the reference dataset (see Note 3).\n- Raise `max_parallel_requests` to 4 once the inference server can handle it.",
+        "note_color": "#E0F2FE",
+        "note_opacity": "35"
+      },
+      {
+        "id": "note_2",
+        "x": -514.4586648521598,
+        "y": 869.2785862193363,
+        "width": 400,
+        "node_type": "markdown_note",
+        "name": "note_2",
+        "markdown": "The **User** column inverts each GitHub thread into a realistic request a developer would give a co-author model (`\"Draft a PR that...\"`, `\"Investigate why...\"`). Same shape as the `pr_requests_20` and `issue_requests_20` enrichments.\n\nTweak the prompt to:\n- always keep the traceback verbatim\n- vary persona (newcomer, maintainer, ops)\n- split one thread into multiple alternative phrasings for data augmentation.",
+        "note_color": "#E0F2FE",
+        "note_opacity": "35"
+      },
+      {
+        "id": "note_3",
+        "x": -536.3163554442993,
+        "y": -84.18780704666585,
+        "width": 400,
+        "node_type": "markdown_note",
+        "name": "note_3",
+        "markdown": "The **Assistant** block emits `{response, followups, cites, task, confidence}` and branches on thread type: closed issues become `issue_fix_plan` rows, PRs become `explain_pr` rows, everything else becomes `issue_solution` or `discussion_qa`.\n\n**Demo default**: 100-250 word response, one inline `[source: <url>]` cite, `max_parallel_requests=1` so a small local model stays stable.\n\n**Production prompt (paste in):**\n- Match the reference dataset's per-task prompts (`explain_pr`, `issue_fix_plan`, `pr_review_critique`, `pr_test_plan`, etc.).\n- Require 300 words for explanations, 6-12 bullets for test plans.\n- Enforce named symbols (function / flag / env var / file path).\n- Code fences only for content already in the thread.\n- Reject rows with em-dashes, emojis, or AI-disclaimer phrases.\n\nSee the `github_data_gatherer` dataset card for the full task catalog and the codex prompts used to train the reference GitHub model.",
+        "note_color": "#E0F2FE",
+        "note_opacity": "35"
+      },
+      {
+        "id": "seed",
+        "x": 0,
+        "y": 140,
+        "width": 400
+      },
+      {
+        "id": "Local Model",
+        "x": -1056,
+        "y": 520,
+        "width": 400
+      },
+      {
+        "id": "model_1",
+        "x": -544,
+        "y": 488,
+        "width": 400
+      },
+      {
+        "id": "User",
+        "x": 0,
+        "y": 440,
+        "width": 400
+      },
+      {
+        "id": "Assistant",
+        "x": 0,
+        "y": 740,
+        "width": 400
+      }
+    ],
+    "edges": [
+      {
+        "from": "seed",
+        "to": "User",
+        "type": "canvas",
+        "source_handle": "data-out-bottom",
+        "target_handle": "data-in-top"
+      },
+      {
+        "from": "User",
+        "to": "Assistant",
+        "type": "canvas",
+        "source_handle": "data-out-bottom",
+        "target_handle": "data-in-top"
+      },
+      {
+        "from": "Local Model",
+        "to": "model_1",
+        "type": "semantic",
+        "source_handle": "semantic-out",
+        "target_handle": "semantic-in"
+      },
+      {
+        "from": "model_1",
+        "to": "User",
+        "type": "semantic",
+        "source_handle": "semantic-out",
+        "target_handle": "data-in"
+      },
+      {
+        "from": "model_1",
+        "to": "Assistant",
+        "type": "semantic",
+        "source_handle": "semantic-out-bottom",
+        "target_handle": "data-in"
+      }
+    ],
+    "layout_direction": "LR",
+    "seed_source_type": "github_repo",
+    "seed_columns": [],
+    "seed_drop_columns": [],
+    "seed_preview_rows": [],
+    "local_file_name": "",
+    "unstructured_file_ids": [],
+    "unstructured_file_names": [],
+    "unstructured_file_sizes": [],
+    "unstructured_chunk_size": "1200",
+    "unstructured_chunk_overlap": "200"
+  }
+}
\ No newline at end of file
diff --git a/studio/frontend/src/features/data-recipes/learning-recipes/index.ts b/studio/frontend/src/features/data-recipes/learning-recipes/index.ts
index d7a7e66e0a..8607d3faeb 100644
--- a/studio/frontend/src/features/data-recipes/learning-recipes/index.ts
+++ b/studio/frontend/src/features/data-recipes/learning-recipes/index.ts
@@ -19,6 +19,10 @@ const ocrDocumentExtractionUrl = new URL(
   "./ocr-document-extraction.json",
   import.meta.url,
 ).href;
+const githubSupportBotUrl = new URL(
+  "./github-support-bot.json",
+  import.meta.url,
+).href;
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -137,4 +141,11 @@ export const LEARNING_RECIPES: LearningRecipeDef[] = [
       "Use image context to generate OCR-style document extraction output.",
     loadPayload: () => loadPayloadFromUrl(ocrDocumentExtractionUrl),
   },
+  {
+    id: "github-support-bot",
+    title: "GitHub Crawler",
+    description:
+      "Crawl real GitHub issues and PRs and turn each thread into a {User, Assistant} training pair.",
+    loadPayload: () => loadPayloadFromUrl(githubSupportBotUrl),
+  },
 ];
diff --git a/studio/frontend/src/features/data-recipes/pages/data-recipes-page.tsx b/studio/frontend/src/features/data-recipes/pages/data-recipes-page.tsx
index 9148b9e0da..79566f21bf 100644
--- a/studio/frontend/src/features/data-recipes/pages/data-recipes-page.tsx
+++ b/studio/frontend/src/features/data-recipes/pages/data-recipes-page.tsx
@@ -35,6 +35,7 @@ import {
   Delete02Icon,
   DocumentAttachmentIcon,
   FunctionIcon,
+  GithubIcon,
   Plant01Icon,
   PlusSignIcon,
 } from "@hugeicons/core-free-icons";
@@ -162,6 +163,22 @@ const TEMPLATE_CARDS: TemplateCard[] = [
     ],
     learningRecipeId: "structured-outputs-jinja",
   },
+  {
+    title: "GitHub Crawler",
+    description:
+      "Crawl real GitHub issues and PRs and invert each thread into a {User, Assistant} training pair.",
+    icon: GithubIcon,
+    difficulty: "Intermediate",
+    learningBadges: ["GitHub", "LLM Text", "Structured LLM"],
+    surfaceClassName:
+      "from-slate-500/15 via-zinc-500/5 to-transparent dark:from-slate-400/30 dark:via-zinc-400/14 dark:to-slate-950/16",
+    shineColor: [
+      "rgb(71 85 105 / 0.45)",
+      "rgb(100 116 139 / 0.4)",
+      "rgb(148 163 184 / 0.45)",
+    ],
+    learningRecipeId: "github-support-bot",
+  },
 ];
 
 const LEARNING_RECIPE_BY_ID = new Map(
@@ -382,7 +399,7 @@ export function DataRecipesPage(): ReactElement {
   const isBusy = creatingRecipe || Boolean(loadingTemplateId);
 
   return (
-    <div className="min-h-screen bg-background">
+    <div className="min-h-[calc(100dvh-var(--studio-titlebar-height,0px))] bg-background">
       <main className="mx-auto w-full max-w-7xl px-6 py-8">
         <div className="flex items-center justify-between gap-4">
           <div>
diff --git a/studio/frontend/src/features/data-recipes/pages/edit-recipe-page.tsx b/studio/frontend/src/features/data-recipes/pages/edit-recipe-page.tsx
index 8ade8a34af..ae87f92a53 100644
--- a/studio/frontend/src/features/data-recipes/pages/edit-recipe-page.tsx
+++ b/studio/frontend/src/features/data-recipes/pages/edit-recipe-page.tsx
@@ -28,7 +28,7 @@ function RecipeLoadState({
   onBack: () => void;
 }): ReactElement {
   return (
-    <div className="min-h-screen bg-background">
+    <div className="min-h-[calc(100dvh-var(--studio-titlebar-height,0px))] bg-background">
       <main className="mx-auto flex min-h-[70vh] w-full max-w-4xl items-center justify-center px-6 py-8">
         <div className="w-full rounded-2xl border bg-card p-8 text-center">
           <h1 className="text-lg font-semibold">{title}</h1>
diff --git a/studio/frontend/src/features/export/export-page.tsx b/studio/frontend/src/features/export/export-page.tsx
index 454ce40772..046d9efac4 100644
--- a/studio/frontend/src/features/export/export-page.tsx
+++ b/studio/frontend/src/features/export/export-page.tsx
@@ -523,8 +523,8 @@ export function ExportPage() {
 
   // ---- Render ----
   return (
-    <div className="min-h-screen bg-background">
-      <main className="mx-auto max-w-7xl px-4 py-4 sm:px-6">
+    <div className="min-h-[calc(100dvh-var(--studio-titlebar-height,0px))] bg-background">
+      <main className="mx-auto max-w-7xl px-4 py-8 sm:px-6">
         <GuidedTour {...tour.tourProps} />
 
         <div className="mb-8 flex flex-col gap-0.5">
diff --git a/studio/frontend/src/features/native-intents/api.ts b/studio/frontend/src/features/native-intents/api.ts
new file mode 100644
index 0000000000..d849f1d4b2
--- /dev/null
+++ b/studio/frontend/src/features/native-intents/api.ts
@@ -0,0 +1,46 @@
+import { isTauri } from "@/lib/api-base";
+import type {
+  NativeIntent,
+  NativePathLeaseResponse,
+  NativePathOperation,
+} from "./types";
+
+async function invokeNative<T>(command: string, args?: Record<string, unknown>): Promise<T> {
+  if (!isTauri) {
+    throw new Error("Native desktop features are only available in the Tauri app.");
+  }
+  const { invoke } = await import("@tauri-apps/api/core");
+  return invoke<T>(command, args);
+}
+
+export async function drainNativeIntents(): Promise<NativeIntent[]> {
+  if (!isTauri) return [];
+  return invokeNative<NativeIntent[]>("drain_native_intents");
+}
+
+export async function pickNativeModel(): Promise<NativeIntent | null> {
+  if (!isTauri) return null;
+  return invokeNative<NativeIntent | null>("pick_native_model");
+}
+
+export async function registerNativeModelPath(path: string): Promise<NativeIntent> {
+  return invokeNative<NativeIntent>("register_native_model_path", { path });
+}
+
+export async function consumeNativePathToken(
+  token: string,
+  operation: NativePathOperation,
+): Promise<NativePathLeaseResponse> {
+  return invokeNative<NativePathLeaseResponse>("consume_native_path_token", {
+    token,
+    operation,
+  });
+}
+
+export async function revealPathToken(token: string): Promise<void> {
+  return invokeNative<void>("reveal_path_token", { token });
+}
+
+export async function openPathToken(token: string): Promise<void> {
+  return invokeNative<void>("open_path_token", { token });
+}
diff --git a/studio/frontend/src/features/native-intents/components/native-model-chip.tsx b/studio/frontend/src/features/native-intents/components/native-model-chip.tsx
new file mode 100644
index 0000000000..22ae36c503
--- /dev/null
+++ b/studio/frontend/src/features/native-intents/components/native-model-chip.tsx
@@ -0,0 +1,107 @@
+import { revealPathToken } from "../api";
+import { useNativeIntentStore } from "../store";
+import type { NativeIntent } from "../types";
+import { XIcon } from "lucide-react";
+import { useEffect, useState } from "react";
+import { toast } from "sonner";
+
+interface NativeModelChipProps {
+  intent: NativeIntent;
+  nativeReadsDisabled: boolean;
+  onLoad: (selection: {
+    id: string;
+    nativePathToken: string;
+    isDownloaded: boolean;
+    loadingDescription: string;
+    forceReload: boolean;
+    throwOnError?: boolean;
+  }) => Promise<void> | void;
+}
+
+export function NativeModelChip({
+  intent,
+  nativeReadsDisabled,
+  onLoad,
+}: NativeModelChipProps) {
+  const clearModelIntent = useNativeIntentStore((state) => state.clearModelIntent);
+  const [loading, setLoading] = useState(false);
+  const [now, setNow] = useState(() => Date.now());
+  const label = intent.path.displayLabel || intent.displayLabel || "Local GGUF model";
+  const expired = intent.path.expiresAtMs <= now;
+
+  useEffect(() => {
+    if (expired) return;
+    const remaining = Math.max(0, intent.path.expiresAtMs - Date.now());
+    const timer = window.setTimeout(() => setNow(Date.now()), remaining);
+    return () => window.clearTimeout(timer);
+  }, [expired, intent.path.expiresAtMs]);
+
+  async function handleLoad() {
+    if (nativeReadsDisabled || expired) return;
+    setLoading(true);
+    try {
+      await onLoad({
+        id: label,
+        nativePathToken: intent.path.token,
+        isDownloaded: true,
+        loadingDescription: "Loading selected local GGUF model.",
+        forceReload: true,
+        throwOnError: true,
+      });
+      clearModelIntent(intent.id);
+    } catch {
+      // selectModel reports the failure; keep the chip available for retry.
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  async function handleReveal() {
+    try {
+      await revealPathToken(intent.path.token);
+    } catch (error) {
+      toast.error("Could not reveal model", {
+        description: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  return (
+    <div className="flex min-w-0 max-w-[34rem] items-center gap-2 rounded-lg border border-border/70 bg-muted/70 px-2.5 py-1.5 text-xs">
+      <span className="shrink-0 font-medium text-muted-foreground">Local GGUF</span>
+      <span className="min-w-0 flex-1 truncate" title={label}>{label}</span>
+      <button
+        type="button"
+        onClick={handleReveal}
+        disabled={expired}
+        title={expired ? "Selection expired, pick or drop the file again" : undefined}
+        className="rounded-md px-2 py-1 text-muted-foreground transition-colors hover:bg-background hover:text-foreground disabled:cursor-not-allowed disabled:opacity-50"
+      >
+        Reveal
+      </button>
+      <button
+        type="button"
+        onClick={handleLoad}
+        disabled={nativeReadsDisabled || expired || loading}
+        title={
+          nativeReadsDisabled
+            ? "Managed desktop backend required"
+            : expired
+              ? "Selection expired, pick or drop the file again"
+              : undefined
+        }
+        className="rounded-md bg-foreground px-2 py-1 text-background transition-opacity disabled:cursor-not-allowed disabled:opacity-50"
+      >
+        {expired ? "Expired" : loading ? "Loading…" : "Load model"}
+      </button>
+      <button
+        type="button"
+        onClick={() => clearModelIntent(intent.id)}
+        className="flex size-5 items-center justify-center rounded-full text-muted-foreground hover:bg-destructive hover:text-destructive-foreground"
+        aria-label="Dismiss local model"
+      >
+        <XIcon className="size-3" />
+      </button>
+    </div>
+  );
+}
diff --git a/studio/frontend/src/features/native-intents/components/native-model-drop-overlay.tsx b/studio/frontend/src/features/native-intents/components/native-model-drop-overlay.tsx
new file mode 100644
index 0000000000..725fb14259
--- /dev/null
+++ b/studio/frontend/src/features/native-intents/components/native-model-drop-overlay.tsx
@@ -0,0 +1,70 @@
+import { cn } from "@/lib/utils";
+import { FileUpIcon } from "lucide-react";
+import type { NativeModelDropState } from "../use-native-drop";
+
+function overlayCopy(state: NativeModelDropState): { title: string; description: string } {
+  if (state.status === "invalid") {
+    return {
+      title: "GGUF models only",
+      description: "Other files are not handled here yet.",
+    };
+  }
+  if (state.status === "valid" && state.action === "replace") {
+    return {
+      title: "Drop to replace model",
+      description: "Current model will unload first.",
+    };
+  }
+  if (state.status === "valid" && state.action === "load") {
+    return {
+      title: "Drop to load model",
+      description: "Adds it as the active chat model.",
+    };
+  }
+  return {
+    title: "Drop to add model chip",
+    description: "Review it before loading.",
+  };
+}
+
+export function NativeModelDropOverlay({ state }: { state: NativeModelDropState }) {
+  const isIdle = state.status === "idle";
+  const isAutoLoad = state.status === "valid" && state.action !== "chip";
+  const isInvalid = state.status === "invalid";
+  const { title, description } = overlayCopy(state);
+
+  return (
+    <div
+      className={cn(
+        "pointer-events-none absolute left-1/2 top-4 z-50 w-[clamp(16rem,28vw,22rem)] max-w-[calc(100vw-1rem)] -translate-x-1/2 transition-all duration-200 ease-out",
+        isIdle ? "-translate-y-1 opacity-0" : "translate-y-0 opacity-100",
+      )}
+      role="status"
+      aria-live="polite"
+      aria-hidden={isIdle}
+    >
+      <div className="flex items-center gap-2.5 rounded-xl border border-border/70 bg-card/96 px-3 py-2.5 shadow-sm shadow-black/10 backdrop-blur-sm dark:shadow-black/30">
+        <div
+          className={cn(
+            "flex size-8 shrink-0 items-center justify-center rounded-lg border transition-colors duration-200 ease-out",
+            isAutoLoad
+              ? "border-emerald-500/30 bg-emerald-500/10 text-emerald-600 dark:text-emerald-400"
+              : isInvalid
+                ? "border-amber-500/25 bg-amber-500/10 text-amber-700 dark:text-amber-300"
+                : "border-border bg-muted text-muted-foreground",
+          )}
+        >
+          <FileUpIcon className="size-4" aria-hidden="true" />
+        </div>
+        <div className="min-w-0 flex-1">
+          <div className="truncate text-xs font-medium text-foreground">
+            {title}
+          </div>
+          <div className="mt-0.5 truncate text-[11px] leading-4 text-muted-foreground">
+            {description}
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/studio/frontend/src/features/native-intents/native-intent-drain.tsx b/studio/frontend/src/features/native-intents/native-intent-drain.tsx
new file mode 100644
index 0000000000..109e8e27f9
--- /dev/null
+++ b/studio/frontend/src/features/native-intents/native-intent-drain.tsx
@@ -0,0 +1,39 @@
+import { isTauri } from "@/lib/api-base";
+import { useEffect } from "react";
+import { drainNativeIntents } from "./api";
+import { useNativeIntentStore } from "./store";
+
+export function NativeIntentDrain() {
+  const addIntent = useNativeIntentStore((state) => state.addIntent);
+
+  useEffect(() => {
+    if (!isTauri) return;
+    let disposed = false;
+    let unlisten: (() => void) | undefined;
+
+    async function drain() {
+      const intents = await drainNativeIntents().catch(() => []);
+      if (disposed) return;
+      for (const intent of intents) addIntent(intent);
+    }
+
+    void drain();
+    void import("@tauri-apps/api/event")
+      .then(({ listen }) => listen("native-intent-available", drain))
+      .then((cleanup) => {
+        if (disposed) {
+          cleanup();
+        } else {
+          unlisten = cleanup;
+        }
+      })
+      .catch(() => undefined);
+
+    return () => {
+      disposed = true;
+      unlisten?.();
+    };
+  }, [addIntent]);
+
+  return null;
+}
diff --git a/studio/frontend/src/features/native-intents/store.ts b/studio/frontend/src/features/native-intents/store.ts
new file mode 100644
index 0000000000..a9cd9e7966
--- /dev/null
+++ b/studio/frontend/src/features/native-intents/store.ts
@@ -0,0 +1,23 @@
+import { create } from "zustand";
+import type { NativeIntent } from "./types";
+
+interface NativeIntentState {
+  pendingModelIntent: NativeIntent | null;
+  addIntent: (intent: NativeIntent) => void;
+  clearModelIntent: (intentId?: string) => void;
+}
+
+export const useNativeIntentStore = create<NativeIntentState>((set, get) => ({
+  pendingModelIntent: null,
+  addIntent: (intent) => {
+    if (intent.kind !== "model") return;
+    const current = get().pendingModelIntent;
+    if (current?.path.token === intent.path.token) return;
+    set({ pendingModelIntent: intent });
+  },
+  clearModelIntent: (intentId) => {
+    const current = get().pendingModelIntent;
+    if (intentId && current?.id !== intentId) return;
+    set({ pendingModelIntent: null });
+  },
+}));
diff --git a/studio/frontend/src/features/native-intents/types.ts b/studio/frontend/src/features/native-intents/types.ts
new file mode 100644
index 0000000000..268638559a
--- /dev/null
+++ b/studio/frontend/src/features/native-intents/types.ts
@@ -0,0 +1,39 @@
+export type NativePathOperation =
+  | "validate-model"
+  | "load-model"
+  | "dataset-preview"
+  | "dataset-import"
+  | "attach"
+  | "reveal"
+  | "open";
+
+export type NativePathKind = "model" | "dataset" | "attachment" | "artifact";
+
+export type NativePathSourceKind =
+  | "dialog"
+  | "drop"
+  | "deep-link"
+  | "file-association"
+  | "artifact";
+
+export interface NativePathRef {
+  token: string;
+  kind: NativePathKind;
+  displayLabel: string;
+  allowedOperations: NativePathOperation[];
+  expiresAtMs: number;
+}
+
+export interface NativeIntent {
+  id: string;
+  kind: NativePathKind;
+  sourceKind: NativePathSourceKind;
+  path: NativePathRef;
+  displayLabel: string;
+}
+
+export interface NativePathLeaseResponse {
+  nativePathLease: string;
+  displayLabel: string;
+  expiresAtMs: number;
+}
diff --git a/studio/frontend/src/features/native-intents/use-native-dialogs.ts b/studio/frontend/src/features/native-intents/use-native-dialogs.ts
new file mode 100644
index 0000000000..45ca81343a
--- /dev/null
+++ b/studio/frontend/src/features/native-intents/use-native-dialogs.ts
@@ -0,0 +1,68 @@
+import { useCallback, useRef } from "react";
+import { toast } from "sonner";
+import { pickNativeModel } from "./api";
+import { useNativeIntentStore } from "./store";
+import type { NativeIntent } from "./types";
+
+interface ChooseNativeModelOptions {
+  shouldAutoLoad?: (intent: NativeIntent) => boolean;
+  onAutoLoad?: (intent: NativeIntent) => Promise<void> | void;
+}
+
+function isGgufModelIntent(intent: NativeIntent): boolean {
+  const label = intent.path.displayLabel || intent.displayLabel;
+  return (
+    intent.kind === "model" &&
+    intent.path.kind === "model" &&
+    label.toLowerCase().endsWith(".gguf") &&
+    intent.path.allowedOperations.includes("validate-model") &&
+    intent.path.allowedOperations.includes("load-model")
+  );
+}
+
+export function useChooseNativeModel(options: ChooseNativeModelOptions = {}) {
+  const addIntent = useNativeIntentStore((state) => state.addIntent);
+  const pickingRef = useRef(false);
+  const onAutoLoad = options.onAutoLoad;
+  const shouldAutoLoad = options.shouldAutoLoad;
+
+  return useCallback(async () => {
+    if (pickingRef.current) return;
+    pickingRef.current = true;
+    try {
+      let intent: NativeIntent | null = null;
+      try {
+        intent = await pickNativeModel();
+      } catch (error) {
+        toast.error("Could not choose local model", {
+          description: error instanceof Error ? error.message : String(error),
+        });
+        return;
+      }
+
+      if (!intent) return;
+
+      let runAutoLoad = false;
+      try {
+        runAutoLoad =
+          Boolean(onAutoLoad) &&
+          isGgufModelIntent(intent) &&
+          shouldAutoLoad?.(intent) === true;
+      } catch {
+        runAutoLoad = false;
+      }
+      if (!runAutoLoad) {
+        addIntent(intent);
+        return;
+      }
+
+      try {
+        await onAutoLoad?.(intent);
+      } catch {
+        addIntent(intent);
+      }
+    } finally {
+      pickingRef.current = false;
+    }
+  }, [addIntent, onAutoLoad, shouldAutoLoad]);
+}
diff --git a/studio/frontend/src/features/native-intents/use-native-drop.ts b/studio/frontend/src/features/native-intents/use-native-drop.ts
new file mode 100644
index 0000000000..5d35511c10
--- /dev/null
+++ b/studio/frontend/src/features/native-intents/use-native-drop.ts
@@ -0,0 +1,132 @@
+import { isTauri } from "@/lib/api-base";
+import { useEffect, useRef, useState } from "react";
+import { toast } from "sonner";
+import { registerNativeModelPath } from "./api";
+import { useNativeIntentStore } from "./store";
+import type { NativeIntent } from "./types";
+
+export type NativeModelDropState =
+  | { status: "idle" }
+  | { status: "valid"; action: "load" | "replace" | "chip" }
+  | { status: "invalid" };
+
+interface NativeModelDropOptions {
+  enabled?: boolean;
+  nativePathLeasesSupported: boolean;
+  hasActiveModel: boolean;
+  isModelLoading: boolean;
+  onAutoLoad?: (intent: NativeIntent) => Promise<void> | void;
+}
+
+function ggufPaths(paths: string[]): string[] {
+  return paths.filter((path) => path.toLowerCase().endsWith(".gguf"));
+}
+
+function canAutoLoadPaths(paths: string[], options: NativeModelDropOptions): boolean {
+  return (
+    paths.length === 1 &&
+    ggufPaths(paths).length === 1 &&
+    options.nativePathLeasesSupported &&
+    !options.isModelLoading &&
+    Boolean(options.onAutoLoad)
+  );
+}
+
+function dropStateForPaths(
+  paths: string[],
+  options: NativeModelDropOptions,
+): NativeModelDropState {
+  if (paths.length === 0) {
+    return { status: "idle" };
+  }
+  const ggufs = ggufPaths(paths);
+  if (paths.length !== 1 || ggufs.length !== 1) {
+    return { status: "invalid" };
+  }
+  if (!canAutoLoadPaths(paths, options)) {
+    return { status: "valid", action: "chip" };
+  }
+  return {
+    status: "valid",
+    action: options.hasActiveModel ? "replace" : "load",
+  };
+}
+
+export function useNativeModelDrop(options: NativeModelDropOptions): NativeModelDropState {
+  const { enabled = true } = options;
+  const addIntent = useNativeIntentStore((state) => state.addIntent);
+  const [dropState, setDropState] = useState<NativeModelDropState>({ status: "idle" });
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+
+  useEffect(() => {
+    if (!isTauri || !enabled) {
+      setDropState({ status: "idle" });
+      return;
+    }
+    let disposed = false;
+    let unlisten: (() => void) | undefined;
+
+    void import("@tauri-apps/api/window")
+      .then(({ getCurrentWindow }) => getCurrentWindow().onDragDropEvent(async (event) => {
+        const currentOptions = optionsRef.current;
+        if (event.payload.type === "enter") {
+          setDropState(dropStateForPaths(event.payload.paths, currentOptions));
+          return;
+        }
+        if (event.payload.type === "leave") {
+          setDropState({ status: "idle" });
+          return;
+        }
+        if (event.payload.type !== "drop") return;
+        setDropState({ status: "idle" });
+        const ggufs = ggufPaths(event.payload.paths);
+        if (event.payload.paths.length !== 1 || ggufs.length !== 1) {
+          if (event.payload.paths.length > 0) {
+            toast.error(
+              ggufs.length === 0
+                ? "Only .gguf model files can be dropped here."
+                : "Drop a single .gguf model file.",
+            );
+          }
+          return;
+        }
+        const ggufPath = ggufs[0];
+        try {
+          const intent = await registerNativeModelPath(ggufPath);
+          if (disposed) return;
+          if (!canAutoLoadPaths(event.payload.paths, currentOptions)) {
+            addIntent(intent);
+            return;
+          }
+          try {
+            await currentOptions.onAutoLoad?.(intent);
+          } catch (error) {
+            addIntent(intent);
+            toast.error("Could not load dropped model", {
+              description: error instanceof Error ? error.message : String(error),
+            });
+          }
+        } catch (error) {
+          toast.error("Could not use dropped model", {
+            description: error instanceof Error ? error.message : String(error),
+          });
+        }
+      }))
+      .then((cleanup) => {
+        if (disposed) {
+          cleanup();
+        } else {
+          unlisten = cleanup;
+        }
+      })
+      .catch(() => undefined);
+
+    return () => {
+      disposed = true;
+      unlisten?.();
+    };
+  }, [addIntent, enabled]);
+
+  return dropState;
+}
diff --git a/studio/frontend/src/features/native-intents/use-native-readiness.ts b/studio/frontend/src/features/native-intents/use-native-readiness.ts
new file mode 100644
index 0000000000..704ae9bc96
--- /dev/null
+++ b/studio/frontend/src/features/native-intents/use-native-readiness.ts
@@ -0,0 +1,46 @@
+import { apiUrl, isTauri } from "@/lib/api-base";
+import { useEffect, useState } from "react";
+
+const MAX_READINESS_POLLS = 720;
+
+export function useNativePathLeasesSupported(): boolean {
+  const [supported, setSupported] = useState(false);
+
+  useEffect(() => {
+    if (!isTauri) return;
+    let disposed = false;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    let controller: AbortController | undefined;
+    let polls = 0;
+
+    function check(delay = 0) {
+      if (polls >= MAX_READINESS_POLLS) return;
+      polls += 1;
+      timer = setTimeout(() => {
+        controller = new AbortController();
+        fetch(apiUrl("/api/health"), { signal: controller.signal })
+          .then((response) => response.json())
+          .then((health) => {
+            if (disposed) return;
+            if (health?.native_path_leases_supported === true) {
+              setSupported(true);
+            } else {
+              check(5000);
+            }
+          })
+          .catch(() => {
+            if (!disposed) check(5000);
+          });
+      }, delay);
+    }
+
+    check();
+    return () => {
+      disposed = true;
+      if (timer) clearTimeout(timer);
+      controller?.abort();
+    };
+  }, []);
+
+  return supported;
+}
diff --git a/studio/frontend/src/features/onboarding/components/wizard-layout.tsx b/studio/frontend/src/features/onboarding/components/wizard-layout.tsx
index 6df873ffd3..22274c5d7d 100644
--- a/studio/frontend/src/features/onboarding/components/wizard-layout.tsx
+++ b/studio/frontend/src/features/onboarding/components/wizard-layout.tsx
@@ -73,7 +73,7 @@ export function WizardLayout() {
   }, [isFinalStep]);
 
   return (
-    <div className="relative min-h-screen flex items-center justify-center overflow-hidden bg-gradient-to-br from-primary/5 via-background to-primary/3 p-4 sm:p-6 md:p-8">
+    <div className="relative flex min-h-[calc(100dvh-var(--studio-titlebar-height,0px))] items-center justify-center overflow-hidden bg-gradient-to-br from-primary/5 via-background to-primary/3 p-4 sm:p-6 md:p-8">
       {showSplash && (
         <SplashScreen
           onStartOnboarding={() => setShowSplash(false)}
diff --git a/studio/frontend/src/features/profile/components/profile-personalization-panel.tsx b/studio/frontend/src/features/profile/components/profile-personalization-panel.tsx
index 994115bc19..f30af7fcf9 100644
--- a/studio/frontend/src/features/profile/components/profile-personalization-panel.tsx
+++ b/studio/frontend/src/features/profile/components/profile-personalization-panel.tsx
@@ -139,7 +139,7 @@ export function ProfilePersonalizationPanel() {
             }}
             autoComplete="off"
             placeholder={sessionSub || "Unsloth"}
-            className="h-10 min-w-0 flex-1 rounded-lg text-sm"
+            className="h-10 min-w-0 flex-1 rounded-full text-sm"
           />
           <Button type="button" size="sm" className="h-10 px-5" onClick={saveName} disabled={!hasNameChanges}>
             Save
diff --git a/studio/frontend/src/features/profile/utils/resize-image-file.ts b/studio/frontend/src/features/profile/utils/resize-image-file.ts
index 3f829ba975..c420497395 100644
--- a/studio/frontend/src/features/profile/utils/resize-image-file.ts
+++ b/studio/frontend/src/features/profile/utils/resize-image-file.ts
@@ -3,6 +3,11 @@
 
 const MAX_EDGE = 256;
 const MAX_BYTES = 380_000;
+const MAX_DATA_URL_LENGTH = Math.floor(MAX_BYTES * 1.35);
+const JPEG_QUALITY_START = 0.88;
+const WEBP_QUALITY_START = 0.9;
+const MIN_QUALITY = 0.45;
+const QUALITY_STEP = 0.08;
 
 function loadImage(file: File): Promise<HTMLImageElement> {
   return new Promise((resolve, reject) => {
@@ -20,8 +25,33 @@ function loadImage(file: File): Promise<HTMLImageElement> {
   });
 }
 
+function canvasHasTransparency(ctx: CanvasRenderingContext2D, width: number, height: number): boolean {
+  const { data } = ctx.getImageData(0, 0, width, height);
+  for (let i = 3; i < data.length; i += 4) {
+    if (data[i] < 255) return true;
+  }
+  return false;
+}
+
+function encodeCanvasWithinLimit(
+  canvas: HTMLCanvasElement,
+  mimeType: string,
+  startQuality: number,
+): string | null {
+  let quality = startQuality;
+  let dataUrl = canvas.toDataURL(mimeType, quality);
+  if (!dataUrl.startsWith(`data:${mimeType}`)) return null;
+
+  while (dataUrl.length > MAX_DATA_URL_LENGTH && quality > MIN_QUALITY) {
+    quality -= QUALITY_STEP;
+    dataUrl = canvas.toDataURL(mimeType, quality);
+  }
+
+  return dataUrl.length <= MAX_DATA_URL_LENGTH ? dataUrl : null;
+}
+
 /**
- * Downscale and re-encode as JPEG so localStorage stays within reasonable size.
+ * Downscale the image and keep transparency when present while staying localStorage-friendly.
  */
 export async function resizeImageFileToDataUrl(file: File): Promise<string> {
   const img = await loadImage(file);
@@ -40,14 +70,14 @@ export async function resizeImageFileToDataUrl(file: File): Promise<string> {
   if (!ctx) throw new Error("Canvas not available");
   ctx.drawImage(img, 0, 0, cw, ch);
 
-  let quality = 0.88;
-  let dataUrl = canvas.toDataURL("image/jpeg", quality);
-  while (dataUrl.length > MAX_BYTES * 1.35 && quality > 0.45) {
-    quality -= 0.08;
-    dataUrl = canvas.toDataURL("image/jpeg", quality);
+  const hasTransparency = canvasHasTransparency(ctx, cw, ch);
+  if (hasTransparency) {
+    const webpDataUrl = encodeCanvasWithinLimit(canvas, "image/webp", WEBP_QUALITY_START);
+    if (webpDataUrl) return webpDataUrl;
   }
-  if (dataUrl.length > MAX_BYTES * 1.35) {
-    throw new Error("Image is still too large after compression. Try a smaller file.");
-  }
-  return dataUrl;
+
+  const jpegDataUrl = encodeCanvasWithinLimit(canvas, "image/jpeg", JPEG_QUALITY_START);
+  if (jpegDataUrl) return jpegDataUrl;
+
+  throw new Error("Image is still too large after compression. Try a smaller file.");
 }
diff --git a/studio/frontend/src/features/recipe-studio/api/index.ts b/studio/frontend/src/features/recipe-studio/api/index.ts
index 9212e4db9b..273d4aea8d 100644
--- a/studio/frontend/src/features/recipe-studio/api/index.ts
+++ b/studio/frontend/src/features/recipe-studio/api/index.ts
@@ -27,6 +27,28 @@ export type PublishRecipeJobResponse = {
   message: string;
 };
 
+export type SourceProgressResponse = {
+  source?: string | null;
+  status?: string | null;
+  repo?: string | null;
+  resource?: string | null;
+  page?: number | null;
+  // biome-ignore lint/style/useNamingConvention: api schema
+  page_items?: number | null;
+  // biome-ignore lint/style/useNamingConvention: api schema
+  fetched_items?: number | null;
+  // biome-ignore lint/style/useNamingConvention: api schema
+  estimated_total?: number | null;
+  percent?: number | null;
+  // biome-ignore lint/style/useNamingConvention: api schema
+  rate_remaining?: number | null;
+  // biome-ignore lint/style/useNamingConvention: api schema
+  retry_after_sec?: number | null;
+  message?: string | null;
+  // biome-ignore lint/style/useNamingConvention: api schema
+  updated_at?: number | null;
+};
+
 export type JobStatusResponse = {
   // biome-ignore lint/style/useNamingConvention: api schema
   job_id: string;
@@ -62,6 +84,8 @@ export type JobStatusResponse = {
     failed?: number | null;
   };
   // biome-ignore lint/style/useNamingConvention: api schema
+  source_progress?: SourceProgressResponse | null;
+  // biome-ignore lint/style/useNamingConvention: api schema
   model_usage?: Record<string, unknown>;
   rows?: number | null;
   cols?: number | null;
@@ -183,12 +207,7 @@ async function parseErrorResponse(response: Response): Promise<string> {
       // biome-ignore lint/style/useNamingConvention: api schema
       raw_detail?: string;
     };
-    return (
-      parsed.detail ??
-      parsed.message ??
-      parsed.raw_detail ??
-      text
-    );
+    return parsed.detail ?? parsed.message ?? parsed.raw_detail ?? text;
   } catch {
     return text;
   }
@@ -264,11 +283,15 @@ export async function validateRecipe(
   return postJson<ValidateResponse>("/validate", payload);
 }
 
-export async function createRecipeJob(payload: unknown): Promise<JobCreateResponse> {
+export async function createRecipeJob(
+  payload: unknown,
+): Promise<JobCreateResponse> {
   return postJson<JobCreateResponse>("/jobs", payload);
 }
 
-export async function getRecipeJobStatus(jobId: string): Promise<JobStatusResponse> {
+export async function getRecipeJobStatus(
+  jobId: string,
+): Promise<JobStatusResponse> {
   return getJson<JobStatusResponse>(`/jobs/${jobId}/status`);
 }
 
@@ -292,7 +315,9 @@ export async function getRecipeJobDataset(
   );
 }
 
-export async function cancelRecipeJob(jobId: string): Promise<JobStatusResponse> {
+export async function cancelRecipeJob(
+  jobId: string,
+): Promise<JobStatusResponse> {
   return postJson<JobStatusResponse>(`/jobs/${jobId}/cancel`, {});
 }
 
@@ -315,6 +340,13 @@ export async function inspectSeedUpload(
   return postJson<SeedInspectResponse>("/seed/inspect-upload", payload);
 }
 
+// biome-ignore lint/style/useNamingConvention: api schema
+export type GithubEnvTokenStatus = { has_token: boolean };
+
+export async function getGithubEnvTokenStatus(): Promise<GithubEnvTokenStatus> {
+  return getJson<GithubEnvTokenStatus>("/seed/github/env-token");
+}
+
 export async function listMcpTools(
   payload: McpToolsListRequest,
 ): Promise<McpToolsListResponse> {
@@ -407,11 +439,14 @@ export async function uploadUnstructuredFile(
     formData.append("existing_file_ids", existingFileIds.join(","));
   }
 
-  const res = await authFetch(`${DATA_DESIGNER_API_BASE}/seed/upload-unstructured-file`, {
-    method: "POST",
-    body: formData,
-    signal,
-  });
+  const res = await authFetch(
+    `${DATA_DESIGNER_API_BASE}/seed/upload-unstructured-file`,
+    {
+      method: "POST",
+      body: formData,
+      signal,
+    },
+  );
 
   if (res.status === 413) {
     const detail = await res.json().catch(() => ({ detail: "File too large" }));
@@ -420,13 +455,16 @@ export async function uploadUnstructuredFile(
       filename: file.name,
       size_bytes: file.size,
       status: "error",
-      error: typeof detail.detail === "string" ? detail.detail : "File too large",
+      error:
+        typeof detail.detail === "string" ? detail.detail : "File too large",
     };
   }
 
   if (!res.ok) {
     const detail = await res.json().catch(() => ({ detail: "Upload failed" }));
-    throw new Error(typeof detail.detail === "string" ? detail.detail : "Upload failed");
+    throw new Error(
+      typeof detail.detail === "string" ? detail.detail : "Upload failed",
+    );
   }
 
   return res.json();
diff --git a/studio/frontend/src/features/recipe-studio/blocks/definitions.ts b/studio/frontend/src/features/recipe-studio/blocks/definitions.ts
index 363cd85be5..ed58d1418d 100644
--- a/studio/frontend/src/features/recipe-studio/blocks/definitions.ts
+++ b/studio/frontend/src/features/recipe-studio/blocks/definitions.ts
@@ -12,6 +12,7 @@ import {
   EqualSignIcon,
   FingerPrintIcon,
   FunctionIcon,
+  GithubIcon,
   Plug01Icon,
   Parabola02Icon,
   PencilEdit02Icon,
@@ -58,11 +59,16 @@ export type BlockType =
   | "seed_hf"
   | "seed_local"
   | "seed_unstructured"
+  | "seed_github"
   | "model_provider"
   | "model_config"
   | "tool_config";
 
-export type SeedBlockType = "seed_hf" | "seed_local" | "seed_unstructured";
+export type SeedBlockType =
+  | "seed_hf"
+  | "seed_local"
+  | "seed_unstructured"
+  | "seed_github";
 
 type IconType = typeof CodeIcon;
 
@@ -169,6 +175,15 @@ const BLOCK_DEFINITIONS: BlockDefinition[] = [
     dialogKey: "seed",
     createConfig: (id, existing) => makeSeedConfig(id, existing, "unstructured"),
   },
+  {
+    kind: "seed",
+    type: "seed_github",
+    title: "GitHub repositories",
+    description: "Crawl issues, pull requests, and commits from one or more GitHub repos.",
+    icon: GithubIcon,
+    dialogKey: "seed",
+    createConfig: (id, existing) => makeSeedConfig(id, existing, "github_repo"),
+  },
   {
     kind: "sampler",
     type: "category",
@@ -388,6 +403,7 @@ export function getBlockDefinitionForConfig(
       hf: "seed_hf",
       local: "seed_local",
       unstructured: "seed_unstructured",
+      github_repo: "seed_github",
     };
     return getBlockDefinition("seed", seedType[config.seed_source_type ?? "hf"]);
   }
diff --git a/studio/frontend/src/features/recipe-studio/components/executions/execution-data-tab.tsx b/studio/frontend/src/features/recipe-studio/components/executions/execution-data-tab.tsx
index a8e12ac1ca..a3e5dbe962 100644
--- a/studio/frontend/src/features/recipe-studio/components/executions/execution-data-tab.tsx
+++ b/studio/frontend/src/features/recipe-studio/components/executions/execution-data-tab.tsx
@@ -2,6 +2,8 @@
 // Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
 
 import type { ReactElement } from "react";
+import { GithubIcon } from "@hugeicons/core-free-icons";
+import { HugeiconsIcon } from "@hugeicons/react";
 import type { ColumnDef } from "@tanstack/react-table";
 import { Button } from "@/components/ui/button";
 import { DataTable } from "@/components/ui/data-table";
@@ -12,11 +14,136 @@ import {
   DropdownMenuLabel,
   DropdownMenuTrigger,
 } from "@/components/ui/dropdown-menu";
+import { Progress } from "@/components/ui/progress";
 import { Spinner } from "@/components/ui/spinner";
-import { cn } from "@/lib/utils";
 import { isExecutionInProgress } from "../../executions/execution-helpers";
 import type { RecipeExecutionRecord } from "../../execution-types";
-import { hasExpandableTextCell } from "./executions-view-helpers";
+import { formatMetricValue } from "./executions-view-helpers";
+
+function formatSourceResource(value: string | null | undefined): string {
+  if (value === "pulls") {
+    return "PRs";
+  }
+  return value ?? "--";
+}
+
+function formatFetchedValue(execution: RecipeExecutionRecord): string {
+  const source = execution.source_progress;
+  if (!source) {
+    return "--";
+  }
+  const fetched = formatMetricValue(source.fetched_items);
+  if (typeof source.estimated_total !== "number" || source.estimated_total <= 0) {
+    return fetched;
+  }
+  return `${fetched} / ${formatMetricValue(source.estimated_total)}`;
+}
+
+function formatGitHubSourceMessage(execution: RecipeExecutionRecord): string {
+  const source = execution.source_progress;
+  if (!source) {
+    return "Collecting repository threads before rows are available.";
+  }
+  if (source.status === "rate_limited") {
+    return source.message ?? "Waiting for GitHub rate limit. Studio will resume automatically.";
+  }
+  return source.message ?? "Collecting repository threads before rows are available.";
+}
+
+function RunningDatasetEmptyState({
+  execution,
+  onOpenOverview,
+}: {
+  execution: RecipeExecutionRecord;
+  onOpenOverview: () => void;
+}): ReactElement {
+  const source = execution.source_progress;
+  if (source?.source === "github") {
+    const title =
+      source.status === "rate_limited"
+        ? "Waiting for GitHub rate limit"
+        : "Crawling GitHub source";
+    const showProgress = typeof source.percent === "number";
+
+    return (
+      <div className="rounded-xl border border-border/60 bg-card/55 p-4 shadow-border">
+        <div className="flex flex-col gap-3 sm:flex-row sm:items-start sm:justify-between">
+          <div className="flex min-w-0 gap-3">
+            <div
+              className="flex size-9 shrink-0 items-center justify-center rounded-lg border border-border/70 bg-muted/20"
+            >
+              {showProgress ? (
+                <HugeiconsIcon icon={GithubIcon} className="size-4 text-muted-foreground" />
+              ) : (
+                <Spinner className="size-4 text-muted-foreground" />
+              )}
+            </div>
+            <div className="min-w-0 space-y-1">
+              <p className="text-sm font-semibold text-foreground">{title}</p>
+              <p className="text-xs text-muted-foreground">
+                {formatGitHubSourceMessage(execution)}
+              </p>
+            </div>
+          </div>
+          <Button type="button" size="sm" variant="outline" onClick={onOpenOverview}>
+            Open Overview
+          </Button>
+        </div>
+        {showProgress && <Progress value={source.percent ?? 0} className="mt-3 h-1" />}
+        <div className="mt-3 grid gap-2 text-xs sm:grid-cols-2 lg:grid-cols-5">
+          <p className="flex items-center justify-between gap-3">
+            <span className="text-muted-foreground">Repo</span>
+            <span className="truncate font-semibold">{source.repo ?? "--"}</span>
+          </p>
+          <p className="flex items-center justify-between gap-3">
+            <span className="text-muted-foreground">Resource</span>
+            <span className="font-semibold">
+              {formatSourceResource(source.resource)}
+              {typeof source.page === "number" ? ` page ${source.page}` : ""}
+            </span>
+          </p>
+          <p className="flex items-center justify-between gap-3">
+            <span className="text-muted-foreground">Fetched</span>
+            <span className="font-semibold">{formatFetchedValue(execution)}</span>
+          </p>
+          <p className="flex items-center justify-between gap-3">
+            <span className="text-muted-foreground">Rate remaining</span>
+            <span className="font-semibold">{formatMetricValue(source.rate_remaining)}</span>
+          </p>
+          <p className="flex items-center justify-between gap-3">
+            <span className="text-muted-foreground">Retry wait</span>
+            <span className="font-semibold">
+              {typeof source.retry_after_sec === "number"
+                ? `${formatMetricValue(source.retry_after_sec)}s`
+                : "--"}
+            </span>
+          </p>
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="rounded-xl border border-border/60 bg-card/55 p-4 text-center shadow-border">
+      <div className="flex flex-col items-center justify-center gap-3 py-6">
+        <Spinner className="size-5" />
+        <div className="space-y-1">
+          <p className="text-sm font-medium text-muted-foreground">
+            Generating data…
+          </p>
+          <p className="text-xs text-muted-foreground">
+            {execution.current_column
+              ? `Current column: ${execution.current_column}`
+              : "Rows will appear here once the run produces a dataset sample."}
+          </p>
+        </div>
+        <Button type="button" size="sm" variant="outline" onClick={onOpenOverview}>
+          Open Overview
+        </Button>
+      </div>
+    </div>
+  );
+}
 
 type ExecutionDataTabProps = {
   execution: RecipeExecutionRecord;
@@ -27,13 +154,10 @@ type ExecutionDataTabProps = {
   totalPages: number;
   tableColumns: ColumnDef<Record<string, unknown>>[];
   datasetRowsForTable: Record<string, unknown>[];
-  visibleDatasetColumnNames: string[];
-  expandedDatasetRows: Record<string, boolean>;
-  selectedExecutionIdSafe: string | null;
+  onOpenOverview: () => void;
   onSetHiddenColumns: (updater: (current: string[]) => string[]) => void;
   onPrevPage: () => void;
   onNextPage: () => void;
-  onToggleRowExpanded: (rowId: string) => void;
 };
 
 export function ExecutionDataTab({
@@ -45,13 +169,10 @@ export function ExecutionDataTab({
   totalPages,
   tableColumns,
   datasetRowsForTable,
-  visibleDatasetColumnNames,
-  expandedDatasetRows,
-  selectedExecutionIdSafe,
+  onOpenOverview,
   onSetHiddenColumns,
   onPrevPage,
   onNextPage,
-  onToggleRowExpanded,
 }: ExecutionDataTabProps): ReactElement {
   return (
     <div className="mt-3">
@@ -123,17 +244,10 @@ export function ExecutionDataTab({
       </div>
       {execution.dataset.length === 0 ? (
         isExecutionInProgress(execution.status) ? (
-          <div className="flex flex-col items-center justify-center gap-3 py-12 text-center">
-            <Spinner className="size-5" />
-            <div className="space-y-1">
-              <p className="text-sm font-medium text-muted-foreground">
-                Generating data…
-              </p>
-              <p className="text-xs text-muted-foreground">
-                Check the Overview tab for live terminal logs.
-              </p>
-            </div>
-          </div>
+          <RunningDatasetEmptyState
+            execution={execution}
+            onOpenOverview={onOpenOverview}
+          />
         ) : (
           <p className="text-xs text-muted-foreground">No rows returned.</p>
         )
@@ -143,27 +257,7 @@ export function ExecutionDataTab({
         </p>
       ) : (
         <div className="max-h-[55vh] overflow-auto">
-          <DataTable
-            columns={tableColumns}
-            data={datasetRowsForTable}
-            getRowClassName={(row, _rowIndex, rowId) => {
-              const canExpand = hasExpandableTextCell(row, visibleDatasetColumnNames);
-              if (!canExpand) {
-                return undefined;
-              }
-              return cn(
-                "cursor-pointer",
-                expandedDatasetRows[rowId] ? "bg-primary/[0.05]" : "hover:bg-primary/[0.06]",
-              );
-            }}
-            onRowClick={(row, _rowIndex, rowId) => {
-              const canExpand = hasExpandableTextCell(row, visibleDatasetColumnNames);
-              if (!canExpand || !selectedExecutionIdSafe) {
-                return;
-              }
-              onToggleRowExpanded(rowId);
-            }}
-          />
+          <DataTable columns={tableColumns} data={datasetRowsForTable} />
         </div>
       )}
     </div>
diff --git a/studio/frontend/src/features/recipe-studio/components/executions/execution-overview-tab.tsx b/studio/frontend/src/features/recipe-studio/components/executions/execution-overview-tab.tsx
index 8e2e710299..72624738fc 100644
--- a/studio/frontend/src/features/recipe-studio/components/executions/execution-overview-tab.tsx
+++ b/studio/frontend/src/features/recipe-studio/components/executions/execution-overview-tab.tsx
@@ -6,6 +6,7 @@ import {
   Database01Icon,
   Database02Icon,
   Flag02Icon,
+  GithubIcon,
 } from "@hugeicons/core-free-icons";
 import { HugeiconsIcon } from "@hugeicons/react";
 import { Badge } from "@/components/ui/badge";
@@ -23,6 +24,28 @@ import type { RecipeExecutionRecord } from "../../execution-types";
 import type { ModelUsageRow } from "./executions-view-helpers";
 import { formatMetricValue } from "./executions-view-helpers";
 
+function formatSourceResource(value: string | null | undefined): string {
+  if (value === "pulls") {
+    return "PRs";
+  }
+  return value ?? "--";
+}
+
+function formatSourceMessage(execution: RecipeExecutionRecord): string {
+  const source = execution.source_progress;
+  if (!source) {
+    return "No source progress captured.";
+  }
+  if (source.status === "rate_limited") {
+    const wait =
+      typeof source.retry_after_sec === "number" && source.retry_after_sec > 0
+        ? ` Waiting ~${formatMetricValue(source.retry_after_sec)}s.`
+        : "";
+    return `Waiting for GitHub rate limit. Studio will resume automatically.${wait}`;
+  }
+  return source.message ?? "Crawling GitHub source.";
+}
+
 type ExecutionOverviewTabProps = {
   execution: RecipeExecutionRecord;
   showSummaryCards: boolean;
@@ -60,6 +83,8 @@ export function ExecutionOverviewTab({
   canPublish,
   onOpenPublish,
 }: ExecutionOverviewTabProps): ReactElement {
+  const sourceProgress = execution.source_progress;
+
   return (
     <div className="mt-3 space-y-3">
       {showSummaryCards && (
@@ -204,6 +229,47 @@ export function ExecutionOverviewTab({
           )}
         </div>
       )}
+      {sourceProgress?.source === "github" && (
+        <div className="rounded-xl border border-border/60 bg-card/55 p-3">
+          <div className="mb-2 flex items-center justify-between">
+            <p className="text-xs text-muted-foreground">Source data</p>
+            <HugeiconsIcon icon={GithubIcon} className="size-4 text-muted-foreground" />
+          </div>
+          <p className="text-sm font-medium text-foreground">
+            {sourceProgress.status === "completed"
+              ? "GitHub source complete"
+              : "Crawling GitHub source"}
+          </p>
+          <p className="mt-1 text-xs text-muted-foreground">
+            {formatSourceMessage(execution)}
+          </p>
+          <div className="mt-2 grid gap-1.5 text-xs sm:grid-cols-2 lg:grid-cols-4">
+            <p className="flex items-center justify-between gap-3">
+              <span className="text-muted-foreground">Repo</span>
+              <span className="truncate font-semibold">{sourceProgress.repo ?? "--"}</span>
+            </p>
+            <p className="flex items-center justify-between gap-3">
+              <span className="text-muted-foreground">Resource</span>
+              <span className="font-semibold">
+                {formatSourceResource(sourceProgress.resource)}
+                {typeof sourceProgress.page === "number" ? ` page ${sourceProgress.page}` : ""}
+              </span>
+            </p>
+            <p className="flex items-center justify-between gap-3">
+              <span className="text-muted-foreground">Fetched</span>
+              <span className="font-semibold">
+                {formatMetricValue(sourceProgress.fetched_items)}
+              </span>
+            </p>
+            <p className="flex items-center justify-between gap-3">
+              <span className="text-muted-foreground">Rate remaining</span>
+              <span className="font-semibold">
+                {formatMetricValue(sourceProgress.rate_remaining)}
+              </span>
+            </p>
+          </div>
+        </div>
+      )}
       <div className="overflow-hidden rounded-xl corner-squircle border">
         <div className="flex items-center justify-between border-b px-3 py-2">
           <p className="text-sm font-semibold">Terminal output</p>
diff --git a/studio/frontend/src/features/recipe-studio/components/executions/executions-view.tsx b/studio/frontend/src/features/recipe-studio/components/executions/executions-view.tsx
index f442d8f98e..cfc0e61338 100644
--- a/studio/frontend/src/features/recipe-studio/components/executions/executions-view.tsx
+++ b/studio/frontend/src/features/recipe-studio/components/executions/executions-view.tsx
@@ -32,10 +32,9 @@ import {
   formatCellValue,
   formatDuration,
   formatPercent,
-  hasExpandableTextCell,
+  isExpandableCellValue,
   parseAnalysisColumns,
   parseModelUsageRows,
-  truncateCellValue,
 } from "./executions-view-helpers";
 
 type ExecutionsViewProps = {
@@ -63,9 +62,6 @@ export function ExecutionsView({
   const [hiddenDatasetColumnsByExecution, setHiddenDatasetColumnsByExecution] = useState<
     Record<string, string[]>
   >({});
-  const [expandedDatasetRowsByExecution, setExpandedDatasetRowsByExecution] = useState<
-    Record<string, Record<string, boolean>>
-  >({});
   const [previewDatasetPageByExecution, setPreviewDatasetPageByExecution] = useState<
     Record<string, number>
   >({});
@@ -91,13 +87,6 @@ export function ExecutionsView({
     }
     return hiddenDatasetColumnsByExecution[selectedExecutionIdSafe] ?? [];
   }, [hiddenDatasetColumnsByExecution, selectedExecutionIdSafe]);
-  const expandedDatasetRows = useMemo(() => {
-    if (!selectedExecutionIdSafe) {
-      return {};
-    }
-    return expandedDatasetRowsByExecution[selectedExecutionIdSafe] ?? {};
-  }, [expandedDatasetRowsByExecution, selectedExecutionIdSafe]);
-
   const datasetColumnNames = useMemo(() => {
     if (!selectedExecution) {
       return [];
@@ -119,6 +108,36 @@ export function ExecutionsView({
     [datasetColumnNames, hiddenDatasetColumns],
   );
 
+  // Columns where at least one row has text long enough that it would wrap at
+  // the default narrow width. We give those columns a wider min-width so the
+  // text is readable without clicking anything. The table's wrapper already
+  // scrolls horizontally, so a few wide columns just add a horizontal
+  // scrollbar instead of squeezing everything into the viewport.
+  const wideColumns = useMemo(() => {
+    const result = new Set<string>();
+    if (!selectedExecution) {
+      return result;
+    }
+    for (const row of selectedExecution.dataset) {
+      for (const name of visibleDatasetColumnNames) {
+        if (result.has(name)) {
+          continue;
+        }
+        const raw = row[name];
+        if (resolveImagePreview(raw)) {
+          continue;
+        }
+        if (isExpandableCellValue(formatCellValue(raw))) {
+          result.add(name);
+        }
+      }
+      if (result.size === visibleDatasetColumnNames.length) {
+        break;
+      }
+    }
+    return result;
+  }, [selectedExecution, visibleDatasetColumnNames]);
+
   const tableColumns = useMemo<ColumnDef<Record<string, unknown>>[]>(() => {
     if (!selectedExecution) {
       return [];
@@ -126,12 +145,12 @@ export function ExecutionsView({
     return visibleDatasetColumnNames.map((name) => ({
       accessorKey: name,
       header: name,
-      cell: ({ getValue, row }) => {
+      cell: ({ getValue }) => {
         const rawValue = getValue();
         const imagePreview = resolveImagePreview(rawValue);
         if (imagePreview?.kind === "ready") {
           return (
-            <div className="max-w-[32rem]">
+            <div>
               <img
                 src={imagePreview.src}
                 alt={`${name} preview`}
@@ -143,31 +162,21 @@ export function ExecutionsView({
         }
         if (imagePreview?.kind === "too_large") {
           return (
-            <div className="max-w-[32rem]">
-              <p className="text-xs text-muted-foreground">
-                Image too large to preview
-              </p>
-            </div>
+            <p className="text-xs text-muted-foreground">
+              Image too large to preview
+            </p>
           );
         }
         const value = formatCellValue(rawValue);
-        const rowExpanded = Boolean(expandedDatasetRows[row.id]);
-        const rowHasExpandableCell = hasExpandableTextCell(
-          row.original,
-          visibleDatasetColumnNames,
-        );
-        const showTruncated = rowHasExpandableCell && !rowExpanded;
-
+        const isWide = wideColumns.has(name);
         return (
-          <div className="max-w-[32rem]">
-            <p className="whitespace-pre-wrap break-all">
-              {showTruncated ? truncateCellValue(value) : value}
-            </p>
+          <div className={cn(isWide ? "min-w-[48rem]" : "min-w-[12rem]")}>
+            <p className="whitespace-pre-wrap break-all">{value}</p>
           </div>
         );
       },
     }));
-  }, [expandedDatasetRows, selectedExecution, visibleDatasetColumnNames]);
+  }, [selectedExecution, visibleDatasetColumnNames, wideColumns]);
 
   const analysisColumns = useMemo(
     () => parseAnalysisColumns(selectedExecution?.analysis ?? null),
@@ -512,9 +521,7 @@ export function ExecutionsView({
                   totalPages={totalPages}
                   tableColumns={tableColumns}
                   datasetRowsForTable={datasetRowsForTable}
-                  visibleDatasetColumnNames={visibleDatasetColumnNames}
-                  expandedDatasetRows={expandedDatasetRows}
-                  selectedExecutionIdSafe={selectedExecutionIdSafe}
+                  onOpenOverview={() => setDetailTab("overview")}
                   onSetHiddenColumns={(updater) => {
                     const selectedId = selectedExecution.id;
                     setHiddenDatasetColumnsByExecution((current) => {
@@ -547,18 +554,6 @@ export function ExecutionsView({
                     }
                     onLoadDatasetPage(selectedExecution.id, currentDatasetPage + 1);
                   }}
-                  onToggleRowExpanded={(rowId) => {
-                    setExpandedDatasetRowsByExecution((current) => {
-                      const rows = current[selectedExecution.id] ?? {};
-                      return {
-                        ...current,
-                        [selectedExecution.id]: {
-                          ...rows,
-                          [rowId]: !rows[rowId],
-                        },
-                      };
-                    });
-                  }}
                 />
               </TabsContent>
               <TabsContent value="raw">
diff --git a/studio/frontend/src/features/recipe-studio/components/inline/inline-seed.tsx b/studio/frontend/src/features/recipe-studio/components/inline/inline-seed.tsx
index bf022fa028..82ec2f1de8 100644
--- a/studio/frontend/src/features/recipe-studio/components/inline/inline-seed.tsx
+++ b/studio/frontend/src/features/recipe-studio/components/inline/inline-seed.tsx
@@ -1,7 +1,12 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 // Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
 
-import { DocumentAttachmentIcon, DocumentCodeIcon, Plant01Icon } from "@hugeicons/core-free-icons";
+import {
+  DocumentAttachmentIcon,
+  DocumentCodeIcon,
+  GithubIcon,
+  Plant01Icon,
+} from "@hugeicons/core-free-icons";
 import { HugeiconsIcon } from "@hugeicons/react";
 import type { ReactElement } from "react";
 import type { SeedConfig } from "../../types";
@@ -13,9 +18,75 @@ type InlineSeedProps = {
   onUpdate: (patch: Partial<SeedConfig>) => void;
 };
 
-export function InlineSeed({ config, onUpdate }: InlineSeedProps): ReactElement {
+const GITHUB_REPO_LIST_SPLIT_RE = /[\n,]+/;
+
+function parseGithubRepos(value: string | undefined): string[] {
+  return (value ?? "")
+    .split(GITHUB_REPO_LIST_SPLIT_RE)
+    .map((repo) => repo.trim())
+    .filter(Boolean);
+}
+
+function hasInvalidGithubRepo(repo: string): boolean {
+  const parts = repo.split("/");
+  return parts.length !== 2 || parts.some((part) => !part.trim());
+}
+
+export function InlineSeed({
+  config,
+  onUpdate,
+}: InlineSeedProps): ReactElement {
   const mode = config.seed_source_type ?? "hf";
 
+  if (mode === "github_repo") {
+    const repos = parseGithubRepos(config.github_repo_slug);
+    const invalidCount = repos.filter(hasInvalidGithubRepo).length;
+    const summary =
+      repos.length === 0
+        ? "Add GitHub repos"
+        : repos.length === 1
+          ? repos[0]
+          : `${repos.length} repositories`;
+    const configuredItems = config.github_item_types;
+    const items =
+      configuredItems && configuredItems.length > 0
+        ? configuredItems
+        : ["issues", "pulls"];
+    const itemsLabel = items.join(" · ");
+    const limit = (config.github_limit ?? "100").trim() || "100";
+    const commentsLabel =
+      config.github_include_comments === false
+        ? "comments off"
+        : `comments ≤ ${config.github_max_comments_per_item ?? "30"}`;
+    const tokenLabel = config.github_token?.trim() ? "PAT set" : "server token";
+    const warning =
+      repos.length === 0
+        ? "No repos configured"
+        : invalidCount > 0
+          ? `${invalidCount} invalid repo${invalidCount === 1 ? "" : "s"}`
+          : null;
+    return (
+      <div
+        className={`corner-squircle flex items-center gap-2 rounded-md border px-2 py-2 ${warning ? "border-amber-500/50 bg-amber-500/10" : "border-border/60 bg-muted/30"}`}
+      >
+        <div className="corner-squircle rounded-md bg-primary/10 p-1.5 text-primary">
+          <HugeiconsIcon icon={GithubIcon} className="size-3.5" />
+        </div>
+        <div className="min-w-0">
+          <p className="truncate text-xs font-medium">{summary}</p>
+          <p className="truncate text-[11px] text-muted-foreground">
+            {warning ??
+              `${itemsLabel} · limit ${limit} · ${commentsLabel} · ${tokenLabel}`}
+          </p>
+        </div>
+        <HugeiconsIcon
+          icon={Plant01Icon}
+          className="ml-auto size-3.5 text-muted-foreground/60"
+        />
+      </div>
+    );
+  }
+
   if (mode === "hf") {
     return (
       <div className="space-y-2">
@@ -62,10 +133,14 @@ export function InlineSeed({ config, onUpdate }: InlineSeedProps): ReactElement
           {fileName || "No file selected"}
         </p>
         <p className="text-[11px] text-muted-foreground">
-          {isLocal ? "Structured file" : "Unstructured document"} · configure in dialog
+          {isLocal ? "Structured file" : "Unstructured document"} · configure in
+          dialog
         </p>
       </div>
-      <HugeiconsIcon icon={Plant01Icon} className="ml-auto size-3.5 text-muted-foreground/60" />
+      <HugeiconsIcon
+        icon={Plant01Icon}
+        className="ml-auto size-3.5 text-muted-foreground/60"
+      />
     </div>
   );
 }
diff --git a/studio/frontend/src/features/recipe-studio/components/recipe-studio-header.tsx b/studio/frontend/src/features/recipe-studio/components/recipe-studio-header.tsx
index acbda2d7d8..385bef2b77 100644
--- a/studio/frontend/src/features/recipe-studio/components/recipe-studio-header.tsx
+++ b/studio/frontend/src/features/recipe-studio/components/recipe-studio-header.tsx
@@ -34,6 +34,7 @@ type RecipeStudioHeaderProps = {
   savedAtLabel: string;
   workflowName: string;
   warnings?: GraphWarning[];
+  supportsEasyMode?: boolean;
   onWorkflowNameChange: (value: string) => void;
   onViewChange: (view: RecipeStudioView) => void;
   onSaveRecipe: () => void;
@@ -51,6 +52,7 @@ export function RecipeStudioHeader({
   savedAtLabel,
   workflowName,
   warnings = [],
+  supportsEasyMode = false,
   onWorkflowNameChange,
   onViewChange,
   onSaveRecipe,
@@ -58,7 +60,7 @@ export function RecipeStudioHeader({
   const [editingWorkflowName, setEditingWorkflowName] = useState(false);
 
   function handleViewValueChange(value: string): void {
-    if (value === "editor" || value === "executions") {
+    if (value === "easy" || value === "editor" || value === "executions") {
       onViewChange(value);
     }
   }
@@ -130,7 +132,12 @@ export function RecipeStudioHeader({
       <div className="justify-self-center">
         <Tabs value={activeView} onValueChange={handleViewValueChange}>
           <TabsList>
-            <TabsTrigger value="editor">Editor</TabsTrigger>
+            {supportsEasyMode && (
+              <TabsTrigger value="easy">Easy</TabsTrigger>
+            )}
+            <TabsTrigger value="editor">
+              {supportsEasyMode ? "Advanced" : "Editor"}
+            </TabsTrigger>
             <TabsTrigger value="executions">Runs</TabsTrigger>
           </TabsList>
         </Tabs>
diff --git a/studio/frontend/src/features/recipe-studio/components/runtime/execution-progress-island.tsx b/studio/frontend/src/features/recipe-studio/components/runtime/execution-progress-island.tsx
index 43f7437848..563280c55f 100644
--- a/studio/frontend/src/features/recipe-studio/components/runtime/execution-progress-island.tsx
+++ b/studio/frontend/src/features/recipe-studio/components/runtime/execution-progress-island.tsx
@@ -49,6 +49,52 @@ function statusLabel(input: {
   return "Run status";
 }
 
+function formatSourceResource(value: string | null | undefined): string {
+  if (value === "pulls") {
+    return "PRs";
+  }
+  return value ?? "source";
+}
+
+function formatGitHubSourceSummary(
+  execution: RecipeExecutionRecord,
+): string | null {
+  const source = execution.source_progress;
+  if (!source || source.source !== "github") {
+    return null;
+  }
+  if (source.status === "rate_limited") {
+    const wait =
+      typeof source.retry_after_sec === "number" && source.retry_after_sec > 0
+        ? ` ~${formatMetricValue(source.retry_after_sec)}s`
+        : "";
+    return `Waiting for GitHub rate limit${wait}. Studio will resume automatically.`;
+  }
+  if (source.status === "retrying") {
+    return source.message ?? "GitHub request failed; retrying automatically.";
+  }
+
+  const parts = [
+    source.repo,
+    source.resource
+      ? `${formatSourceResource(source.resource)}${
+          typeof source.page === "number" ? ` page ${source.page}` : ""
+        }`
+      : null,
+    typeof source.fetched_items === "number"
+      ? `${formatMetricValue(source.fetched_items)} fetched`
+      : null,
+    typeof source.rate_remaining === "number"
+      ? `remaining ${formatMetricValue(source.rate_remaining)}`
+      : null,
+  ].filter(Boolean);
+
+  if (parts.length === 0) {
+    return source.message ?? "Crawling GitHub source";
+  }
+  return parts.join(" · ");
+}
+
 export function ExecutionProgressIsland({
   execution,
   currentColumnIcon,
@@ -58,14 +104,24 @@ export function ExecutionProgressIsland({
 }: ExecutionProgressIslandProps): ReactElement {
   const complete = execution.status === "completed";
   const inProgress = isExecutionInProgress(execution.status);
-  const progressPercent = execution.progress?.percent ?? (complete ? 100 : 0);
+  const sourceSummary = formatGitHubSourceSummary(execution);
+  const showSourceProgress = Boolean(
+    sourceSummary &&
+      inProgress &&
+      (execution.stage === "source" ||
+        execution.source_progress?.status === "rate_limited" ||
+        execution.source_progress?.status === "retrying"),
+  );
+  const sourcePercent = showSourceProgress ? execution.source_progress?.percent : null;
+  const progressPercent = sourcePercent ?? execution.progress?.percent ?? (complete ? 100 : 0);
   const hasProgressSignal = Boolean(
-    execution.progress &&
+    (execution.progress &&
       (typeof execution.progress.done === "number" ||
         typeof execution.progress.total === "number" ||
         typeof execution.progress.percent === "number" ||
         typeof execution.progress.rate === "number" ||
-        typeof execution.progress.eta_sec === "number"),
+        typeof execution.progress.eta_sec === "number")) ||
+      typeof sourcePercent === "number",
   );
   const showLoadingSpinner = inProgress && !hasProgressSignal;
   const batchTotal = execution.batch?.total ?? null;
@@ -136,18 +192,30 @@ export function ExecutionProgressIsland({
               ETA: {formatEta(execution.progress?.eta_sec)}
             </p>
           </div>
-          <div className="mt-1 flex items-center gap-1.5 px-3 text-[11px] text-muted-foreground">
-            <HugeiconsIcon
-              icon={currentColumnIcon}
-              className="size-3.5 shrink-0"
-            />
-            <p
-              className="truncate"
-              title={execution.current_column ?? "--"}
-            >
-              Column: {execution.current_column ?? "--"}
-            </p>
-          </div>
+          {showSourceProgress ? (
+            <div className="mt-1 flex items-center gap-1.5 px-3 text-[11px] text-muted-foreground">
+              <HugeiconsIcon
+                icon={Flag02Icon}
+                className="size-3.5 shrink-0 text-amber-700 dark:text-amber-300"
+              />
+              <p className="truncate" title={sourceSummary ?? undefined}>
+                GitHub source: {sourceSummary}
+              </p>
+            </div>
+          ) : (
+            <div className="mt-1 flex items-center gap-1.5 px-3 text-[11px] text-muted-foreground">
+              <HugeiconsIcon
+                icon={currentColumnIcon}
+                className="size-3.5 shrink-0"
+              />
+              <p
+                className="truncate"
+                title={execution.current_column ?? "--"}
+              >
+                Column: {execution.current_column ?? "--"}
+              </p>
+            </div>
+          )}
           {showBatch && (
             <div
               className="mt-1 truncate px-3 text-[11px] text-muted-foreground"
diff --git a/studio/frontend/src/features/recipe-studio/dialogs/preview-dialog.tsx b/studio/frontend/src/features/recipe-studio/dialogs/preview-dialog.tsx
index fbca622d35..7bcf47a974 100644
--- a/studio/frontend/src/features/recipe-studio/dialogs/preview-dialog.tsx
+++ b/studio/frontend/src/features/recipe-studio/dialogs/preview-dialog.tsx
@@ -253,8 +253,13 @@ function ValidationResultPanel({
           ))}
         </div>
       )}
-      {!validateResult.valid && validateResult.rawDetail && (
-        <p className="break-words text-xs text-destructive">
+      {validateResult.rawDetail && (
+        <p
+          className={cn(
+            "break-words text-xs",
+            validateResult.valid ? "text-muted-foreground" : "text-destructive",
+          )}
+        >
           {validateResult.rawDetail}
         </p>
       )}
diff --git a/studio/frontend/src/features/recipe-studio/dialogs/seed/seed-dialog.tsx b/studio/frontend/src/features/recipe-studio/dialogs/seed/seed-dialog.tsx
index 868974acb5..54eae08f7c 100644
--- a/studio/frontend/src/features/recipe-studio/dialogs/seed/seed-dialog.tsx
+++ b/studio/frontend/src/features/recipe-studio/dialogs/seed/seed-dialog.tsx
@@ -31,18 +31,27 @@ import {
   TableHeader,
   TableRow,
 } from "@/components/ui/table";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
 import {
-  Tabs,
-  TabsContent,
-  TabsList,
-  TabsTrigger,
-} from "@/components/ui/tabs";
-import { type ReactElement, useCallback, useEffect, useMemo, useRef, useState } from "react";
+  type KeyboardEvent,
+  type ReactElement,
+  useCallback,
+  useEffect,
+  useId,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
 import { cn } from "@/lib/utils";
 import { UnstructuredDropZone, type FileEntry } from "./unstructured-drop-zone";
-import { inspectSeedDataset, inspectSeedUpload } from "../../api";
+import {
+  getGithubEnvTokenStatus,
+  inspectSeedDataset,
+  inspectSeedUpload,
+} from "../../api";
 import { resolveImagePreview } from "../../utils/image-preview";
 import type {
+  GithubItemType,
   SeedConfig,
   SeedSamplingStrategy,
   SeedSelectionType,
@@ -51,10 +60,11 @@ import { CollapsibleSectionTriggerButton } from "../shared/collapsible-section-t
 import { HfDatasetCombobox } from "../../components/shared/hf-dataset-combobox";
 import { FieldLabel } from "../shared/field-label";
 
-const SAMPLING_OPTIONS: Array<{ value: SeedSamplingStrategy; label: string }> = [
-  { value: "ordered", label: "Ordered" },
-  { value: "shuffle", label: "Shuffle" },
-];
+const SAMPLING_OPTIONS: Array<{ value: SeedSamplingStrategy; label: string }> =
+  [
+    { value: "ordered", label: "Ordered" },
+    { value: "shuffle", label: "Shuffle" },
+  ];
 
 const SELECTION_OPTIONS: Array<{ value: SeedSelectionType; label: string }> = [
   { value: "none", label: "None" },
@@ -68,6 +78,14 @@ const DEFAULT_CHUNK_SIZE = 1200;
 const DEFAULT_CHUNK_OVERLAP = 200;
 const MAX_CHUNK_SIZE = 20000;
 const PREVIEW_TRUNCATE_AT = 320;
+const GITHUB_TRAILING_PUNCTUATION_RE = /[),.;]+$/g;
+const GITHUB_SSH_PREFIX_RE = /^git@github\.com:/i;
+const URL_PROTOCOL_RE = /^https?:\/\//i;
+const WWW_PREFIX_RE = /^www\./i;
+const URL_QUERY_OR_HASH_RE = /[?#]/;
+const GIT_SUFFIX_RE = /\.git$/i;
+const GITHUB_REPO_INPUT_SPLIT_RE = /[\s,]+/;
+const GITHUB_REPO_PART_RE = /^[A-Za-z0-9_.-]+$/;
 
 type SeedDialogProps = {
   config: SeedConfig;
@@ -75,6 +93,367 @@ type SeedDialogProps = {
   open: boolean;
 };
 
+function normalizeGithubRepoInput(value: string): string {
+  let raw = value.trim().replace(GITHUB_TRAILING_PUNCTUATION_RE, "");
+  if (!raw) {
+    return "";
+  }
+  raw = raw.replace(GITHUB_SSH_PREFIX_RE, "https://github.com/");
+  raw = raw.replace(URL_PROTOCOL_RE, "");
+  raw = raw.replace(WWW_PREFIX_RE, "");
+  if (raw.toLowerCase().startsWith("github.com/")) {
+    raw = raw.slice("github.com/".length);
+  }
+  raw = raw.split(URL_QUERY_OR_HASH_RE)[0] ?? "";
+  raw = raw.replace(GIT_SUFFIX_RE, "");
+  const parts = raw.split("/").filter(Boolean);
+  if (parts.length >= 2) {
+    return `${parts[0]}/${parts[1]}`;
+  }
+  return raw;
+}
+
+function splitGithubRepoInput(value: string): string[] {
+  return value
+    .split(GITHUB_REPO_INPUT_SPLIT_RE)
+    .map(normalizeGithubRepoInput)
+    .filter(Boolean);
+}
+
+function getGithubRepoError(repo: string): string | null {
+  const parts = repo.split("/");
+  if (parts.length !== 2 || parts.some((part) => !part.trim())) {
+    return "Use owner/name.";
+  }
+  if (parts.some((part) => !GITHUB_REPO_PART_RE.test(part))) {
+    return "Use only GitHub repo characters.";
+  }
+  return null;
+}
+
+function githubLimitString(value: string | undefined): string {
+  return (value ?? "100").trim();
+}
+
+export function GithubRepoSeedForm({
+  config,
+  onUpdate,
+}: {
+  config: SeedConfig;
+  onUpdate: (patch: Partial<SeedConfig>) => void;
+}): ReactElement {
+  const [repoDraft, setRepoDraft] = useState("");
+  const [serverHasEnvToken, setServerHasEnvToken] = useState<boolean | null>(
+    null,
+  );
+  const repoInputId = useId();
+  const repoHelpId = useId();
+  const repoErrorId = useId();
+  const tokenId = useId();
+  const tokenHelpId = useId();
+  const limitId = useId();
+  const limitHelpId = useId();
+  const commentsId = useId();
+  const includeCommentsId = useId();
+  const commentsHelpId = useId();
+  const repos = useMemo(
+    () => splitGithubRepoInput(config.github_repo_slug ?? ""),
+    [config.github_repo_slug],
+  );
+  const repoErrors = repos
+    .map((repo, index) => ({ repo, index, error: getGithubRepoError(repo) }))
+    .filter((item) => item.error);
+  const hasRepoErrors = repoErrors.length > 0;
+  const configuredItemTypes = config.github_item_types;
+  const itemTypes: GithubItemType[] =
+    configuredItemTypes && configuredItemTypes.length > 0
+      ? configuredItemTypes
+      : ["issues", "pulls"];
+  const limitNum = Number.parseInt(githubLimitString(config.github_limit), 10);
+  const boundedLimit = Number.isFinite(limitNum)
+    ? Math.min(5000, Math.max(1, limitNum))
+    : 100;
+  const estimatedItems = repos.length * itemTypes.length * boundedLimit;
+  const includeComments = config.github_include_comments ?? true;
+  const hasToken = Boolean(config.github_token?.trim());
+  const usingEnvToken = !hasToken && serverHasEnvToken === true;
+
+  useEffect(() => {
+    let cancelled = false;
+    void getGithubEnvTokenStatus()
+      .then((status) => {
+        if (!cancelled) setServerHasEnvToken(status.has_token);
+      })
+      .catch(() => {
+        if (!cancelled) setServerHasEnvToken(false);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+
+  function updateRepos(nextRepos: string[]): void {
+    const seen = new Set<string>();
+    const deduped = nextRepos.filter((repo) => {
+      const key = repo.toLowerCase();
+      if (seen.has(key)) {
+        return false;
+      }
+      seen.add(key);
+      return true;
+    });
+    onUpdate({ github_repo_slug: deduped.join("\n") });
+  }
+
+  function addRepos(raw: string): void {
+    const next = splitGithubRepoInput(raw);
+    if (next.length === 0) {
+      return;
+    }
+    updateRepos([...repos, ...next]);
+    setRepoDraft("");
+  }
+
+  function removeRepo(index: number): void {
+    updateRepos(repos.filter((_, i) => i !== index));
+  }
+
+  function handleRepoKeyDown(event: KeyboardEvent<HTMLInputElement>): void {
+    if (["Enter", ",", " "].includes(event.key)) {
+      event.preventDefault();
+      addRepos(repoDraft);
+    } else if (event.key === "Backspace" && !repoDraft && repos.length > 0) {
+      event.preventDefault();
+      removeRepo(repos.length - 1);
+    }
+  }
+
+  return (
+    <div className="space-y-4">
+      <div className="grid gap-1.5">
+        <FieldLabel
+          label="GitHub repositories"
+          htmlFor={repoInputId}
+          hint="Paste owner/name entries or GitHub URLs. Newlines, commas, and spaces are accepted."
+        />
+        <div
+          className={cn(
+            "nodrag flex min-h-11 flex-wrap items-center gap-1.5 rounded-md border border-border/60 bg-background px-2 py-1.5",
+            hasRepoErrors && "border-red-500/70",
+          )}
+        >
+          {repos.map((repo, index) => {
+            const error = getGithubRepoError(repo);
+            return (
+              <span
+                key={`${repo}-${index}`}
+                className={cn(
+                  "inline-flex items-center gap-1 rounded-full border px-2 py-1 text-xs font-mono",
+                  error
+                    ? "border-red-500/60 bg-red-500/10 text-red-700 dark:text-red-300"
+                    : "border-border/60 bg-muted/60",
+                )}
+              >
+                {repo}
+                <button
+                  type="button"
+                  className="rounded-full px-1 text-muted-foreground hover:bg-background hover:text-foreground"
+                  onClick={() => removeRepo(index)}
+                  aria-label={`Remove ${repo}`}
+                >
+                  ×
+                </button>
+              </span>
+            );
+          })}
+          <input
+            id={repoInputId}
+            className="min-w-36 flex-1 bg-transparent text-xs outline-none placeholder:text-muted-foreground"
+            value={repoDraft}
+            onChange={(event) => setRepoDraft(event.target.value)}
+            onKeyDown={handleRepoKeyDown}
+            onBlur={() => addRepos(repoDraft)}
+            onPaste={(event) => {
+              const pasted = event.clipboardData.getData("text");
+              if (pasted) {
+                event.preventDefault();
+                addRepos(pasted);
+              }
+            }}
+            placeholder={
+              repos.length === 0
+                ? "unslothai/unsloth or GitHub URL"
+                : "Add repo…"
+            }
+            aria-invalid={hasRepoErrors}
+            aria-describedby={`${repoHelpId}${hasRepoErrors ? ` ${repoErrorId}` : ""}`}
+          />
+        </div>
+        <p id={repoHelpId} className="text-xs text-muted-foreground">
+          Stored as one <code>owner/name</code> repo per line in the recipe.
+        </p>
+        {hasRepoErrors && (
+          <ul id={repoErrorId} className="space-y-0.5 text-xs text-red-600">
+            {repoErrors.map((item) => (
+              <li key={`${item.repo}-${item.index}`}>
+                Row {item.index + 1}: {item.error}
+              </li>
+            ))}
+          </ul>
+        )}
+      </div>
+
+      <div className="grid gap-1.5">
+        <div className="flex items-start justify-between gap-2">
+          <FieldLabel
+            label="GitHub token (optional)"
+            htmlFor={tokenId}
+            hint="Prefer the server GH_TOKEN / GITHUB_TOKEN env var. Use public_repo for public repos or repo for private repos."
+          />
+          {usingEnvToken && (
+            <span className="shrink-0 rounded-md border border-emerald-500/40 bg-emerald-500/10 px-1.5 py-0.5 text-[10px] font-medium text-emerald-700 dark:text-emerald-300">
+              Using server env var
+            </span>
+          )}
+        </div>
+        <Input
+          id={tokenId}
+          type="password"
+          className="nodrag"
+          value={config.github_token ?? ""}
+          onChange={(e) => onUpdate({ github_token: e.target.value })}
+          placeholder={
+            usingEnvToken
+              ? "Using server GH_TOKEN / GITHUB_TOKEN"
+              : "Leave blank to use server GH_TOKEN"
+          }
+          aria-describedby={tokenHelpId}
+        />
+        <p id={tokenHelpId} className="text-xs text-muted-foreground">
+          {usingEnvToken
+            ? "Studio detected a server env token, so saved/shared recipes can leave this blank."
+            : "Blank is safest for saved/shared recipes because Studio will read the server environment at run time."}
+        </p>
+        {hasToken && (
+          <p className="rounded-md bg-amber-500/10 px-2 py-1.5 text-xs text-amber-700 dark:text-amber-300">
+            Personal access tokens are sensitive. Prefer server env vars when
+            possible, and avoid sharing recipes that contain a PAT.
+          </p>
+        )}
+      </div>
+
+      <fieldset className="space-y-3">
+        <legend className="text-xs font-semibold uppercase text-muted-foreground">
+          Fetch scope
+        </legend>
+        <div className="grid gap-1.5">
+          <FieldLabel
+            label="Items per repo"
+            htmlFor={limitId}
+            hint="How many issues/PRs/commits to fetch from each repo (1-5000)."
+          />
+          <Input
+            id={limitId}
+            type="number"
+            className="nodrag"
+            min={1}
+            max={5000}
+            value={githubLimitString(config.github_limit)}
+            onChange={(e) => onUpdate({ github_limit: e.target.value })}
+            placeholder="100"
+            aria-describedby={limitHelpId}
+          />
+          <p id={limitHelpId} className="text-xs text-muted-foreground">
+            Estimate before comments: up to {estimatedItems.toLocaleString()}{" "}
+            rows ({repos.length || 0} repos × {itemTypes.length} item types ×{" "}
+            {boundedLimit} limit). Commit crawling uses each repo's default
+            branch.
+          </p>
+        </div>
+
+        <div className="grid gap-1.5">
+          <span className="text-xs font-semibold uppercase text-muted-foreground">
+            Item types
+          </span>
+          <div className="flex flex-wrap gap-3 text-xs">
+            {(["issues", "pulls", "commits"] as const).map((kind) => {
+              const checked = itemTypes.includes(kind);
+              const itemTypeId = `${repoInputId}-${kind}`;
+              return (
+                <label
+                  key={kind}
+                  htmlFor={itemTypeId}
+                  className="flex cursor-pointer items-center gap-1.5"
+                >
+                  <Checkbox
+                    id={itemTypeId}
+                    checked={checked}
+                    onCheckedChange={(v) => {
+                      const next =
+                        v === true
+                          ? Array.from(new Set([...itemTypes, kind]))
+                          : itemTypes.filter((k) => k !== kind);
+                      onUpdate({
+                        github_item_types: next.length > 0 ? next : ["issues"],
+                      });
+                    }}
+                  />
+                  <span>{kind}</span>
+                </label>
+              );
+            })}
+          </div>
+        </div>
+
+        <div className="grid gap-2">
+          <label
+            htmlFor={includeCommentsId}
+            className="flex cursor-pointer items-center gap-1.5 text-xs"
+          >
+            <Checkbox
+              id={includeCommentsId}
+              checked={includeComments}
+              onCheckedChange={(v) =>
+                onUpdate({ github_include_comments: v === true })
+              }
+            />
+            <span>Include issue/PR comments</span>
+          </label>
+          <div className="grid gap-1.5">
+            <FieldLabel
+              label="Max comments / item"
+              htmlFor={commentsId}
+              hint="Comments are concatenated into the comments column for issues and PRs."
+            />
+            <Input
+              id={commentsId}
+              type="number"
+              className="nodrag"
+              min={0}
+              max={200}
+              disabled={!includeComments}
+              value={config.github_max_comments_per_item ?? "30"}
+              onChange={(e) =>
+                onUpdate({ github_max_comments_per_item: e.target.value })
+              }
+              aria-describedby={commentsHelpId}
+            />
+            <p id={commentsHelpId} className="text-xs text-muted-foreground">
+              Comments increase GraphQL cost and can make Check/Run look quiet
+              while GitHub pages and rate-limit waits stream in logs.
+            </p>
+          </div>
+        </div>
+      </fieldset>
+
+      <p className="text-xs text-muted-foreground">
+        Backed by Studio's built-in <code>github_repo</code> seed reader. Large
+        repos can take minutes, so start with small limits for previews.
+      </p>
+    </div>
+  );
+}
+
 function getErrorMessage(error: unknown, fallback: string): string {
   if (error instanceof Error && error.message) {
     return error.message;
@@ -85,7 +464,8 @@ function getErrorMessage(error: unknown, fallback: string): string {
 function stringifyCell(value: unknown): string {
   if (value === null || value === undefined) return "";
   if (typeof value === "string") return value;
-  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
   try {
     return JSON.stringify(value);
   } catch {
@@ -111,7 +491,8 @@ function getPreviewEmptyStateCopy(mode: SeedConfig["seed_source_type"]): {
   if (mode === "local") {
     return {
       title: "No preview yet",
-      description: "Upload a CSV, JSON, or JSONL file and click Load to see a sample.",
+      description:
+        "Upload a CSV, JSON, or JSONL file and click Load to see a sample.",
     };
   }
   if (mode === "unstructured") {
@@ -121,9 +502,17 @@ function getPreviewEmptyStateCopy(mode: SeedConfig["seed_source_type"]): {
         "Upload your documents and the preview will appear once processing is done.",
     };
   }
+  if (mode === "github_repo") {
+    return {
+      title: "GitHub data loads during Check or Run",
+      description:
+        "Configure repos, item types, and limits above. GitHub crawling can take minutes on large repos; watch logs for page and rate-limit updates.",
+    };
+  }
   return {
     title: "No preview yet",
-    description: "Select a Hugging Face dataset and click Load to see a sample.",
+    description:
+      "Select a Hugging Face dataset and click Load to see a sample.",
   };
 }
 
@@ -175,24 +564,32 @@ async function fileToBase64Payload(file: File): Promise<string> {
   });
 }
 
-export function SeedDialog({ config, onUpdate, open }: SeedDialogProps): ReactElement {
+export function SeedDialog({
+  config,
+  onUpdate,
+  open,
+}: SeedDialogProps): ReactElement {
   const [inspectError, setInspectError] = useState<string | null>(null);
   const [isInspecting, setIsInspecting] = useState(false);
   const advancedOpen = config.advancedOpen === true;
   const [previewRows, setPreviewRows] = useState<Record<string, unknown>[]>([]);
-  const [expandedPreviewRows, setExpandedPreviewRows] = useState<Record<number, boolean>>({});
+  const [expandedPreviewRows, setExpandedPreviewRows] = useState<
+    Record<number, boolean>
+  >({});
   const [localFile, setLocalFile] = useState<File | null>(null);
-  const [unstructuredFiles, setUnstructuredFiles] = useState<FileEntry[]>(() => {
-    if (config.unstructured_file_ids?.length) {
-      return config.unstructured_file_ids.map((id, i) => ({
-        id,
-        name: config.unstructured_file_names?.[i] ?? "Unknown",
-        size: config.unstructured_file_sizes?.[i] ?? 0,
-        status: "ok" as const,
-      }));
-    }
-    return [];
-  });
+  const [unstructuredFiles, setUnstructuredFiles] = useState<FileEntry[]>(
+    () => {
+      if (config.unstructured_file_ids?.length) {
+        return config.unstructured_file_ids.map((id, i) => ({
+          id,
+          name: config.unstructured_file_names?.[i] ?? "Unknown",
+          size: config.unstructured_file_sizes?.[i] ?? 0,
+          status: "ok" as const,
+        }));
+      }
+      return [];
+    },
+  );
 
   const mode = config.seed_source_type ?? "hf";
   const previewEmpty = getPreviewEmptyStateCopy(mode);
@@ -241,7 +638,14 @@ export function SeedDialog({ config, onUpdate, open }: SeedDialogProps): ReactEl
         status: "ok" as const,
       })),
     );
-  }, [open, mode, unstructuredFiles.length, config.unstructured_file_ids, config.unstructured_file_names, config.unstructured_file_sizes]);
+  }, [
+    open,
+    mode,
+    unstructuredFiles.length,
+    config.unstructured_file_ids,
+    config.unstructured_file_names,
+    config.unstructured_file_sizes,
+  ]);
 
   const handleUnstructuredFilesChange = useCallback(
     (updater: FileEntry[] | ((prev: FileEntry[]) => FileEntry[])) => {
@@ -291,142 +695,135 @@ export function SeedDialog({ config, onUpdate, open }: SeedDialogProps): ReactEl
     const { chunkSize, chunkOverlap } = resolveChunking(config);
     const fileKey = okFiles.map((f) => `${f.id}|${f.name}`).join(",");
     return `unstructured:${fileKey}|${chunkSize}|${chunkOverlap}`;
-  }, [
-    config,
-    localFile,
-    mode,
-    unstructuredFiles,
-  ]);
+  }, [config, localFile, mode, unstructuredFiles]);
 
-  const loadSeedMetadata = useCallback(async (opts?: { silent?: boolean }): Promise<boolean> => {
-    const loadKey = getCurrentLoadKey();
-    if (!opts?.silent) {
-      setInspectError(null);
-    }
-    setIsInspecting(true);
-    try {
-      if (mode === "hf") {
-        const datasetName = config.hf_repo_id.trim();
-        if (!datasetName) {
-          throw new Error("Dataset repo is required.");
-        }
-        const response = await inspectSeedDataset({
-          dataset_name: datasetName,
-          hf_token: config.hf_token?.trim() || undefined,
-          split: config.hf_split?.trim() || undefined,
-          subset: config.hf_subset?.trim() || undefined,
-          preview_size: 10,
-        });
-        onUpdate({
-          hf_path: response.resolved_path,
-          seed_columns: response.columns,
-          seed_drop_columns: (config.seed_drop_columns ?? []).filter((name) =>
-            response.columns.includes(name),
-          ),
-          seed_preview_rows: response.preview_rows ?? [],
-          hf_split: response.split ?? "",
-          hf_subset: response.subset ?? "",
-          local_file_name: "",
-          unstructured_file_ids: [],
-          unstructured_file_names: [],
-          unstructured_file_sizes: [],
-        });
-        setPreviewRows(response.preview_rows ?? []);
-        setLastLoadedKey(loadKey);
-        return true;
-      }
-
-      if (mode === "local") {
-        if (!localFile) {
-          throw new Error("Select a local CSV/JSON/JSONL file first.");
-        }
-        if (localFile.size > MAX_UPLOAD_BYTES) {
-          throw new Error("File too large (max 50MB).");
-        }
-        const payload = await fileToBase64Payload(localFile);
-        const response = await inspectSeedUpload({
-          filename: localFile.name,
-          content_base64: payload,
-          preview_size: 10,
-        });
-        onUpdate({
-          hf_path: response.resolved_path,
-          seed_columns: response.columns,
-          seed_drop_columns: (config.seed_drop_columns ?? []).filter((name) =>
-            response.columns.includes(name),
-          ),
-          seed_preview_rows: response.preview_rows ?? [],
-          hf_repo_id: "",
-          hf_subset: "",
-          hf_split: "",
-          local_file_name: localFile.name,
-          unstructured_file_ids: [],
-          unstructured_file_names: [],
-          unstructured_file_sizes: [],
-        });
-        setPreviewRows(response.preview_rows ?? []);
-        setLastLoadedKey(loadKey);
-        return true;
-      }
-
-      if (mode === "unstructured") {
-        const fileIds = unstructuredFiles
-          .filter((f) => f.status === "ok")
-          .map((f) => f.id);
-        const fileNames = unstructuredFiles
-          .filter((f) => f.status === "ok")
-          .map((f) => f.name);
-
-        if (fileIds.length === 0) {
-          setInspectError("No files uploaded");
-          return false;
-        }
-
-        const { chunkSize, chunkOverlap } = resolveChunking(config);
-        const response = await inspectSeedUpload({
-          block_id: config.id,
-          file_ids: fileIds,
-          file_names: fileNames,
-          preview_size: 10,
-          seed_source_type: "unstructured",
-          unstructured_chunk_size: chunkSize,
-          unstructured_chunk_overlap: chunkOverlap,
-        });
-
-        onUpdate({
-          hf_path: response.resolved_path,
-          resolved_paths: response.resolved_paths ?? [],
-          seed_columns: response.columns,
-          seed_preview_rows: response.preview_rows ?? [],
-          unstructured_file_ids: fileIds,
-          unstructured_file_names: fileNames,
-          unstructured_file_sizes: unstructuredFiles
-            .filter((f) => f.status === "ok")
-            .map((f) => f.size),
-        });
-        setPreviewRows(response.preview_rows ?? []);
-        setLastLoadedKey(loadKey);
-        return true;
-      }
-
-      return false;
-    } catch (error) {
+  const loadSeedMetadata = useCallback(
+    async (opts?: { silent?: boolean }): Promise<boolean> => {
+      const loadKey = getCurrentLoadKey();
       if (!opts?.silent) {
-        setInspectError(getErrorMessage(error, "Failed to load seed metadata."));
+        setInspectError(null);
       }
-      setPreviewRows([]);
-      return false;
-    } finally {
-      setIsInspecting(false);
-    }
-  }, [
-    config,
-    getCurrentLoadKey,
-    localFile,
-    mode,
-    onUpdate,
-    unstructuredFiles,
-  ]);
+      setIsInspecting(true);
+      try {
+        if (mode === "hf") {
+          const datasetName = config.hf_repo_id.trim();
+          if (!datasetName) {
+            throw new Error("Dataset repo is required.");
+          }
+          const response = await inspectSeedDataset({
+            dataset_name: datasetName,
+            hf_token: config.hf_token?.trim() || undefined,
+            split: config.hf_split?.trim() || undefined,
+            subset: config.hf_subset?.trim() || undefined,
+            preview_size: 10,
+          });
+          onUpdate({
+            hf_path: response.resolved_path,
+            seed_columns: response.columns,
+            seed_drop_columns: (config.seed_drop_columns ?? []).filter((name) =>
+              response.columns.includes(name),
+            ),
+            seed_preview_rows: response.preview_rows ?? [],
+            hf_split: response.split ?? "",
+            hf_subset: response.subset ?? "",
+            local_file_name: "",
+            unstructured_file_ids: [],
+            unstructured_file_names: [],
+            unstructured_file_sizes: [],
+          });
+          setPreviewRows(response.preview_rows ?? []);
+          setLastLoadedKey(loadKey);
+          return true;
+        }
+
+        if (mode === "local") {
+          if (!localFile) {
+            throw new Error("Select a local CSV/JSON/JSONL file first.");
+          }
+          if (localFile.size > MAX_UPLOAD_BYTES) {
+            throw new Error("File too large (max 50MB).");
+          }
+          const payload = await fileToBase64Payload(localFile);
+          const response = await inspectSeedUpload({
+            filename: localFile.name,
+            content_base64: payload,
+            preview_size: 10,
+          });
+          onUpdate({
+            hf_path: response.resolved_path,
+            seed_columns: response.columns,
+            seed_drop_columns: (config.seed_drop_columns ?? []).filter((name) =>
+              response.columns.includes(name),
+            ),
+            seed_preview_rows: response.preview_rows ?? [],
+            hf_repo_id: "",
+            hf_subset: "",
+            hf_split: "",
+            local_file_name: localFile.name,
+            unstructured_file_ids: [],
+            unstructured_file_names: [],
+            unstructured_file_sizes: [],
+          });
+          setPreviewRows(response.preview_rows ?? []);
+          setLastLoadedKey(loadKey);
+          return true;
+        }
+
+        if (mode === "unstructured") {
+          const fileIds = unstructuredFiles
+            .filter((f) => f.status === "ok")
+            .map((f) => f.id);
+          const fileNames = unstructuredFiles
+            .filter((f) => f.status === "ok")
+            .map((f) => f.name);
+
+          if (fileIds.length === 0) {
+            setInspectError("No files uploaded");
+            return false;
+          }
+
+          const { chunkSize, chunkOverlap } = resolveChunking(config);
+          const response = await inspectSeedUpload({
+            block_id: config.id,
+            file_ids: fileIds,
+            file_names: fileNames,
+            preview_size: 10,
+            seed_source_type: "unstructured",
+            unstructured_chunk_size: chunkSize,
+            unstructured_chunk_overlap: chunkOverlap,
+          });
+
+          onUpdate({
+            hf_path: response.resolved_path,
+            resolved_paths: response.resolved_paths ?? [],
+            seed_columns: response.columns,
+            seed_preview_rows: response.preview_rows ?? [],
+            unstructured_file_ids: fileIds,
+            unstructured_file_names: fileNames,
+            unstructured_file_sizes: unstructuredFiles
+              .filter((f) => f.status === "ok")
+              .map((f) => f.size),
+          });
+          setPreviewRows(response.preview_rows ?? []);
+          setLastLoadedKey(loadKey);
+          return true;
+        }
+
+        return false;
+      } catch (error) {
+        if (!opts?.silent) {
+          setInspectError(
+            getErrorMessage(error, "Failed to load seed metadata."),
+          );
+        }
+        setPreviewRows([]);
+        return false;
+      } finally {
+        setIsInspecting(false);
+      }
+    },
+    [config, getCurrentLoadKey, localFile, mode, onUpdate, unstructuredFiles],
+  );
 
   useEffect(() => {
     const wasOpen = wasOpenRef.current;
@@ -463,7 +860,8 @@ export function SeedDialog({ config, onUpdate, open }: SeedDialogProps): ReactEl
     return [];
   }, [config.seed_columns, previewRows]);
   const selectedSeedDropColumns = useMemo(
-    () => (config.seed_drop_columns ?? []).filter((name) => name.trim().length > 0),
+    () =>
+      (config.seed_drop_columns ?? []).filter((name) => name.trim().length > 0),
     [config.seed_drop_columns],
   );
   const selectedSeedDropSet = useMemo(
@@ -540,10 +938,11 @@ export function SeedDialog({ config, onUpdate, open }: SeedDialogProps): ReactEl
                   className="nodrag"
                   placeholder="hf_..."
                   value={config.hf_token ?? ""}
-                  onChange={(event) => onUpdate({ hf_token: event.target.value })}
+                  onChange={(event) =>
+                    onUpdate({ hf_token: event.target.value })
+                  }
                 />
               </div>
-
             </>
           )}
 
@@ -600,9 +999,15 @@ export function SeedDialog({ config, onUpdate, open }: SeedDialogProps): ReactEl
             />
           )}
 
-          {inspectError && <p className="text-xs text-red-600">{inspectError}</p>}
+          {mode === "github_repo" && (
+            <GithubRepoSeedForm config={config} onUpdate={onUpdate} />
+          )}
 
-          {mode !== "unstructured" && (
+          {inspectError && (
+            <p className="text-xs text-red-600">{inspectError}</p>
+          )}
+
+          {mode !== "unstructured" && mode !== "github_repo" && (
             <div className="space-y-2 rounded-xl corner-squircle border border-border/60 p-3">
               <FieldLabel
                 label="Drop specific seed columns"
@@ -626,8 +1031,15 @@ export function SeedDialog({ config, onUpdate, open }: SeedDialogProps): ReactEl
                           onCheckedChange={(value) => {
                             const isChecked = value === true;
                             const next = isChecked
-                              ? Array.from(new Set([...selectedSeedDropColumns, columnName]))
-                              : selectedSeedDropColumns.filter((name) => name !== columnName);
+                              ? Array.from(
+                                  new Set([
+                                    ...selectedSeedDropColumns,
+                                    columnName,
+                                  ]),
+                                )
+                              : selectedSeedDropColumns.filter(
+                                  (name) => name !== columnName,
+                                );
                             onUpdate({ seed_drop_columns: next });
                           }}
                         />
@@ -660,7 +1072,9 @@ export function SeedDialog({ config, onUpdate, open }: SeedDialogProps): ReactEl
                 <Select
                   value={config.sampling_strategy}
                   onValueChange={(value) =>
-                    onUpdate({ sampling_strategy: value as SeedSamplingStrategy })
+                    onUpdate({
+                      sampling_strategy: value as SeedSamplingStrategy,
+                    })
                   }
                 >
                   <SelectTrigger className="nodrag w-full" id={samplingId}>
@@ -713,9 +1127,14 @@ export function SeedDialog({ config, onUpdate, open }: SeedDialogProps): ReactEl
                       id={chunkSizeId}
                       className="nodrag"
                       inputMode="numeric"
-                      value={config.unstructured_chunk_size ?? String(DEFAULT_CHUNK_SIZE)}
+                      value={
+                        config.unstructured_chunk_size ??
+                        String(DEFAULT_CHUNK_SIZE)
+                      }
                       onChange={(event) =>
-                        onUpdate({ unstructured_chunk_size: event.target.value })
+                        onUpdate({
+                          unstructured_chunk_size: event.target.value,
+                        })
                       }
                     />
                   </div>
@@ -734,7 +1153,9 @@ export function SeedDialog({ config, onUpdate, open }: SeedDialogProps): ReactEl
                         String(DEFAULT_CHUNK_OVERLAP)
                       }
                       onChange={(event) =>
-                        onUpdate({ unstructured_chunk_overlap: event.target.value })
+                        onUpdate({
+                          unstructured_chunk_overlap: event.target.value,
+                        })
                       }
                     />
                   </div>
@@ -744,21 +1165,31 @@ export function SeedDialog({ config, onUpdate, open }: SeedDialogProps): ReactEl
               {config.selection_type === "index_range" && (
                 <div className="grid grid-cols-2 gap-3">
                   <div className="grid gap-1.5">
-                    <FieldLabel label="Start" hint="Inclusive start row index for index_range." />
+                    <FieldLabel
+                      label="Start"
+                      hint="Inclusive start row index for index_range."
+                    />
                     <Input
                       className="nodrag"
                       inputMode="numeric"
                       value={config.selection_start ?? ""}
-                      onChange={(event) => onUpdate({ selection_start: event.target.value })}
+                      onChange={(event) =>
+                        onUpdate({ selection_start: event.target.value })
+                      }
                     />
                   </div>
                   <div className="grid gap-1.5">
-                    <FieldLabel label="End" hint="Inclusive end row index for index_range." />
+                    <FieldLabel
+                      label="End"
+                      hint="Inclusive end row index for index_range."
+                    />
                     <Input
                       className="nodrag"
                       inputMode="numeric"
                       value={config.selection_end ?? ""}
-                      onChange={(event) => onUpdate({ selection_end: event.target.value })}
+                      onChange={(event) =>
+                        onUpdate({ selection_end: event.target.value })
+                      }
                     />
                   </div>
                 </div>
@@ -772,17 +1203,24 @@ export function SeedDialog({ config, onUpdate, open }: SeedDialogProps): ReactEl
                       className="nodrag"
                       inputMode="numeric"
                       value={config.selection_index ?? ""}
-                      onChange={(event) => onUpdate({ selection_index: event.target.value })}
+                      onChange={(event) =>
+                        onUpdate({ selection_index: event.target.value })
+                      }
                     />
                   </div>
                   <div className="grid gap-1.5">
-                    <FieldLabel label="Partitions" hint="Total number of partitions." />
+                    <FieldLabel
+                      label="Partitions"
+                      hint="Total number of partitions."
+                    />
                     <Input
                       className="nodrag"
                       inputMode="numeric"
                       value={config.selection_num_partitions ?? ""}
                       onChange={(event) =>
-                        onUpdate({ selection_num_partitions: event.target.value })
+                        onUpdate({
+                          selection_num_partitions: event.target.value,
+                        })
                       }
                     />
                   </div>
@@ -830,7 +1268,8 @@ export function SeedDialog({ config, onUpdate, open }: SeedDialogProps): ReactEl
                       <TableRow
                         key={`row-${rowIdx}`}
                         className={cn(
-                          rowHasExpandableText(row) && "cursor-pointer hover:bg-primary/[0.06]",
+                          rowHasExpandableText(row) &&
+                            "cursor-pointer hover:bg-primary/[0.06]",
                           expandedPreviewRows[rowIdx] && "bg-primary/[0.05]",
                         )}
                         onClick={() => {
@@ -850,7 +1289,9 @@ export function SeedDialog({ config, onUpdate, open }: SeedDialogProps): ReactEl
                             className="max-w-[260px] whitespace-pre-wrap break-words text-xs"
                           >
                             {(() => {
-                              const imagePreview = resolveImagePreview(row[col]);
+                              const imagePreview = resolveImagePreview(
+                                row[col],
+                              );
                               if (imagePreview?.kind === "ready") {
                                 return (
                                   <img
@@ -865,8 +1306,11 @@ export function SeedDialog({ config, onUpdate, open }: SeedDialogProps): ReactEl
                                 return "Image too large to preview";
                               }
                               const value = stringifyCell(row[col]);
-                              const rowHasExpandableCell = rowHasExpandableText(row);
-                              const rowExpanded = Boolean(expandedPreviewRows[rowIdx]);
+                              const rowHasExpandableCell =
+                                rowHasExpandableText(row);
+                              const rowExpanded = Boolean(
+                                expandedPreviewRows[rowIdx],
+                              );
                               return rowHasExpandableCell && !rowExpanded
                                 ? truncatePreviewValue(value)
                                 : value;
diff --git a/studio/frontend/src/features/recipe-studio/easy/github-crawler-easy-view.tsx b/studio/frontend/src/features/recipe-studio/easy/github-crawler-easy-view.tsx
new file mode 100644
index 0000000000..57264cb4f5
--- /dev/null
+++ b/studio/frontend/src/features/recipe-studio/easy/github-crawler-easy-view.tsx
@@ -0,0 +1,191 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+import { GithubIcon, PlayCircleIcon } from "@hugeicons/core-free-icons";
+import { HugeiconsIcon } from "@hugeicons/react";
+import { type ReactElement, useEffect, useMemo, useState } from "react";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { FieldLabel } from "../dialogs/shared/field-label";
+import { GithubRepoSeedForm } from "../dialogs/seed/seed-dialog";
+import type { ModelConfig, NodeConfig, SeedConfig } from "../types";
+
+type GithubCrawlerEasyViewProps = {
+  configs: Record<string, NodeConfig>;
+  rows: number;
+  setRows: (rows: number) => void;
+  updateConfig: (id: string, patch: Partial<NodeConfig>) => void;
+  onRun: () => void;
+  runLoading: boolean;
+  runErrors: string[];
+  onSwitchToAdvanced: () => void;
+};
+
+export function GithubCrawlerEasyView({
+  configs,
+  rows,
+  setRows,
+  updateConfig,
+  onRun,
+  runLoading,
+  runErrors,
+  onSwitchToAdvanced,
+}: GithubCrawlerEasyViewProps): ReactElement {
+  const seedConfig = useMemo(
+    () =>
+      Object.values(configs).find((c): c is SeedConfig => c.kind === "seed") ??
+      null,
+    [configs],
+  );
+  const modelConfig = useMemo(
+    () =>
+      Object.values(configs).find(
+        (c): c is ModelConfig => c.kind === "model_config",
+      ) ?? null,
+    [configs],
+  );
+
+  // Local buffer for the Rows input so the user can hold transient invalid
+  // state (empty while backspacing, partial digits, etc.) without the parent
+  // snapping them back to 1 on every keystroke. The canonical ``rows`` value
+  // only advances when the buffer parses to a valid positive integer; on
+  // blur we clamp back to a sane default if the user left it empty.
+  const [rowsText, setRowsText] = useState(String(rows));
+  useEffect(() => {
+    setRowsText(String(rows));
+  }, [rows]);
+
+  const handleSeedUpdate = (patch: Partial<SeedConfig>): void => {
+    if (!seedConfig) return;
+    updateConfig(seedConfig.id, patch);
+  };
+
+  const handleModelChange = (value: string): void => {
+    if (!modelConfig) return;
+    updateConfig(modelConfig.id, { model: value });
+  };
+
+  if (!seedConfig) {
+    return (
+      <div className="flex h-full items-center justify-center px-6">
+        <p className="text-sm text-muted-foreground">
+          This recipe has no seed node. Switch to{" "}
+          <button
+            type="button"
+            className="underline hover:text-foreground"
+            onClick={onSwitchToAdvanced}
+          >
+            Advanced
+          </button>{" "}
+          to configure it.
+        </p>
+      </div>
+    );
+  }
+
+  return (
+    <div className="mx-auto flex h-full w-full max-w-2xl flex-col gap-4 overflow-y-auto px-6 py-6">
+      <div className="flex items-start gap-3">
+        <div
+          className="flex size-10 shrink-0 items-center justify-center rounded-lg corner-squircle border border-border/70 bg-muted/20"
+          aria-hidden={true}
+        >
+          <HugeiconsIcon icon={GithubIcon} className="size-5" />
+        </div>
+        <div className="flex-1 min-w-0">
+          <h2 className="text-base font-semibold">GitHub Crawler</h2>
+          <p className="text-xs text-muted-foreground">
+            Crawl real GitHub issues and PRs and turn each thread into a{" "}
+            <code>{"{User, Assistant}"}</code> training pair.
+            Defaults use the server's <code>GH_TOKEN</code> env var and the
+            bundled local model.
+          </p>
+        </div>
+      </div>
+
+      <GithubRepoSeedForm config={seedConfig} onUpdate={handleSeedUpdate} />
+
+      <section className="space-y-3 border-t border-border/60 pt-4">
+        <h3 className="text-xs font-semibold uppercase text-muted-foreground">
+          Run settings
+        </h3>
+        <div className="grid gap-3 sm:grid-cols-[minmax(0,10rem)_minmax(0,1fr)]">
+          <div className="grid gap-1.5">
+            <FieldLabel
+              label="Rows to generate"
+              hint="How many training pairs the LLM should produce."
+            />
+            <Input
+              type="text"
+              inputMode="numeric"
+              pattern="[0-9]*"
+              className="nodrag"
+              value={rowsText}
+              onChange={(event) => {
+                // Allow empty / partial strings while the user is editing.
+                // type="text" avoids the browser's number spinner and the
+                // related backspace quirks; we still parse + clamp below.
+                const raw = event.target.value.replace(/[^0-9]/g, "");
+                setRowsText(raw);
+                const next = Number.parseInt(raw, 10);
+                if (Number.isFinite(next) && next > 0 && next <= 10000) {
+                  setRows(next);
+                }
+              }}
+              onBlur={() => {
+                const next = Number.parseInt(rowsText, 10);
+                if (!Number.isFinite(next) || next < 1) {
+                  setRows(1);
+                  setRowsText("1");
+                } else if (next > 10000) {
+                  setRows(10000);
+                  setRowsText("10000");
+                } else {
+                  setRowsText(String(next));
+                }
+              }}
+            />
+          </div>
+          <div className="grid gap-1.5">
+            <FieldLabel
+              label="Model"
+              hint="OpenAI-compatible model id. Local GGUFs run on the bundled llama-server."
+            />
+            <Input
+              className="nodrag font-mono text-xs"
+              value={modelConfig?.model ?? ""}
+              onChange={(event) => handleModelChange(event.target.value)}
+              placeholder="unsloth/gemma-4-E2B-it-GGUF"
+              disabled={!modelConfig}
+            />
+          </div>
+        </div>
+      </section>
+
+      {runErrors.length > 0 && (
+        <div className="rounded-lg border border-destructive/40 bg-destructive/5 px-3 py-2 text-xs text-destructive">
+          <p className="font-semibold">Cannot run:</p>
+          <ul className="mt-1 list-disc space-y-0.5 pl-4">
+            {runErrors.slice(0, 4).map((err) => (
+              <li key={err}>{err}</li>
+            ))}
+          </ul>
+        </div>
+      )}
+
+      <div className="flex items-center justify-between gap-3 pt-1">
+        <button
+          type="button"
+          className="text-xs text-muted-foreground underline hover:text-foreground"
+          onClick={onSwitchToAdvanced}
+        >
+          Advanced (drag and drop canvas)
+        </button>
+        <Button type="button" size="lg" onClick={onRun} disabled={runLoading}>
+          <HugeiconsIcon icon={PlayCircleIcon} className="size-4" />
+          {runLoading ? "Running..." : "Run"}
+        </Button>
+      </div>
+    </div>
+  );
+}
diff --git a/studio/frontend/src/features/recipe-studio/execution-types.ts b/studio/frontend/src/features/recipe-studio/execution-types.ts
index c1976ab3f9..92dd88c4f5 100644
--- a/studio/frontend/src/features/recipe-studio/execution-types.ts
+++ b/studio/frontend/src/features/recipe-studio/execution-types.ts
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 // Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
 
-export type RecipeStudioView = "editor" | "executions";
+export type RecipeStudioView = "easy" | "editor" | "executions";
 
 export type RecipeExecutionKind = "preview" | "full";
 
@@ -30,6 +30,28 @@ export type RecipeExecutionBatch = {
   total?: number | null;
 };
 
+export type RecipeSourceProgress = {
+  source?: string | null;
+  status?: string | null;
+  repo?: string | null;
+  resource?: string | null;
+  page?: number | null;
+  // biome-ignore lint/style/useNamingConvention: backend schema
+  page_items?: number | null;
+  // biome-ignore lint/style/useNamingConvention: backend schema
+  fetched_items?: number | null;
+  // biome-ignore lint/style/useNamingConvention: backend schema
+  estimated_total?: number | null;
+  percent?: number | null;
+  // biome-ignore lint/style/useNamingConvention: backend schema
+  rate_remaining?: number | null;
+  // biome-ignore lint/style/useNamingConvention: backend schema
+  retry_after_sec?: number | null;
+  message?: string | null;
+  // biome-ignore lint/style/useNamingConvention: backend schema
+  updated_at?: number | null;
+};
+
 export type RecipeExecutionAnalysis = {
   num_records?: number;
   target_num_records?: number;
@@ -65,6 +87,8 @@ export type RecipeExecutionRecord = {
   column_progress: RecipeExecutionProgress | null;
   batch: RecipeExecutionBatch | null;
   // biome-ignore lint/style/useNamingConvention: backend schema
+  source_progress: RecipeSourceProgress | null;
+  // biome-ignore lint/style/useNamingConvention: backend schema
   model_usage: Record<string, unknown> | null;
   // biome-ignore lint/style/useNamingConvention: backend schema
   lastEventId: number | null;
diff --git a/studio/frontend/src/features/recipe-studio/executions/runtime.ts b/studio/frontend/src/features/recipe-studio/executions/runtime.ts
index bdc3e653fc..e37a1c9929 100644
--- a/studio/frontend/src/features/recipe-studio/executions/runtime.ts
+++ b/studio/frontend/src/features/recipe-studio/executions/runtime.ts
@@ -6,6 +6,7 @@ import type {
   RecipeExecutionBatch,
   RecipeExecutionKind,
   RecipeExecutionRecord,
+  RecipeSourceProgress,
 } from "../execution-types";
 import {
   DATASET_PAGE_SIZE,
@@ -72,6 +73,14 @@ export function toExecutionLogLine(event: JobEvent): string | null {
   return null;
 }
 
+function normalizeSourceProgress(input: unknown): RecipeSourceProgress | null {
+  const raw = normalizeObject(input);
+  if (!raw) {
+    return null;
+  }
+  return raw as RecipeSourceProgress;
+}
+
 export function applyExecutionStatusSnapshot(
   execution: RecipeExecutionRecord,
   status: JobStatusResponse,
@@ -100,6 +109,7 @@ export function applyExecutionStatusSnapshot(
       (normalizeObject(status.column_progress) as RecipeExecutionRecord["column_progress"]) ??
       null,
     batch,
+    source_progress: normalizeSourceProgress(status.source_progress),
     model_usage: normalizeObject(status.model_usage),
     artifact_path: status.artifact_path ?? execution.artifact_path,
     error: status.error ?? null,
@@ -137,6 +147,7 @@ export function createBaseExecutionRecord(input: {
     progress: null,
     column_progress: null,
     batch: null,
+    source_progress: null,
     model_usage: null,
     lastEventId: null,
     artifact_path: null,
diff --git a/studio/frontend/src/features/recipe-studio/hooks/use-recipe-executions.ts b/studio/frontend/src/features/recipe-studio/hooks/use-recipe-executions.ts
index 24d02e0f6c..1040025a5d 100644
--- a/studio/frontend/src/features/recipe-studio/hooks/use-recipe-executions.ts
+++ b/studio/frontend/src/features/recipe-studio/hooks/use-recipe-executions.ts
@@ -3,7 +3,12 @@
 
 import { useCallback, useEffect, useState } from "react";
 import { useShallow } from "zustand/react/shallow";
+import { toast } from "sonner";
 import { toastError } from "@/shared/toast";
+import {
+  getInferenceStatus,
+  loadModel,
+} from "@/features/chat/api/chat-api";
 import {
   cancelRecipeJob,
   createRecipeJob,
@@ -39,10 +44,84 @@ import {
 } from "../stores/recipe-executions";
 import type { RecipePayload, RecipePayloadResult } from "../utils/payload/types";
 
+/**
+ * Auto-load the local model before running a recipe that uses it.
+ *
+ * Looks at payload.recipe.model_providers for any provider with is_local=true,
+ * finds the bound model_configs and asks the backend to load whichever model
+ * the first local-bound model_config points at. Skips when the inference
+ * server already has that exact model active. This removes the "open /chat
+ * first" prerequisite that users kept tripping on.
+ */
+async function ensureLocalModelLoaded(
+  payload: RecipePayload,
+): Promise<string | null> {
+  const providers = Array.isArray(payload.recipe.model_providers)
+    ? (payload.recipe.model_providers as Array<Record<string, unknown>>)
+    : [];
+  const localProviderNames = new Set<string>();
+  for (const p of providers) {
+    if (p.is_local === true && typeof p.name === "string") {
+      localProviderNames.add(p.name);
+    }
+  }
+  if (localProviderNames.size === 0) {
+    return null;
+  }
+  const modelConfigs = Array.isArray(payload.recipe.model_configs)
+    ? (payload.recipe.model_configs as Array<Record<string, unknown>>)
+    : [];
+  const boundConfig = modelConfigs.find(
+    (c) => typeof c.provider === "string" && localProviderNames.has(c.provider),
+  );
+  const target =
+    typeof boundConfig?.model === "string" ? boundConfig.model.trim() : "";
+  if (!target) {
+    return null;
+  }
+
+  try {
+    const status = await getInferenceStatus();
+    if (
+      status.active_model &&
+      status.active_model.toLowerCase() === target.toLowerCase()
+    ) {
+      return null;
+    }
+  } catch {
+    // Fall through to load attempt; the backend will re-error if needed.
+  }
+
+  const toastId = toast.loading(`Loading ${target}…`, {
+    description: "Starting the local inference server for this recipe.",
+  });
+  try {
+    const isGguf = /gguf/i.test(target);
+    await loadModel({
+      model_path: target,
+      hf_token: null,
+      max_seq_length: isGguf ? 0 : 4096,
+      load_in_4bit: true,
+      is_lora: false,
+      gguf_variant: null,
+      trust_remote_code: false,
+      chat_template_override: null,
+      cache_type_kv: null,
+      speculative_type: null,
+    });
+    toast.success(`Loaded ${target}`, { id: toastId, duration: 2000 });
+    return null;
+  } catch (error) {
+    toast.dismiss(toastId);
+    return error instanceof Error ? error.message : String(error);
+  }
+}
+
 type UseRecipeExecutionsParams = {
   recipeId: string;
   currentSignature: string;
   payloadResult: RecipePayloadResult;
+  initialRunRows?: number | null;
   onExecutionStart?: () => void;
   onPreviewSuccess?: () => void;
 };
@@ -101,6 +180,7 @@ export function useRecipeExecutions({
   recipeId,
   currentSignature,
   payloadResult,
+  initialRunRows,
   onExecutionStart,
   onPreviewSuccess,
 }: UseRecipeExecutionsParams): UseRecipeExecutionsResult {
@@ -181,6 +261,19 @@ export function useRecipeExecutions({
 
     resetForRecipe();
 
+    // Seed previewRows from the recipe's original run.rows (read from the
+    // loaded JSON, not the rebuilt payload (the builder hardcodes 5).
+    // Templates ship their own suggested preview size (e.g. GitHub Support
+    // Bot: 10); we honor it so users don't see a surprise 5.
+    if (
+      typeof initialRunRows === "number" &&
+      Number.isFinite(initialRunRows) &&
+      initialRunRows > 0 &&
+      initialRunRows !== 5
+    ) {
+      setPreviewRows(Math.floor(initialRunRows));
+    }
+
     async function hydrate(): Promise<void> {
       try {
         const records = await loadSortedRecipeExecutions(recipeId);
@@ -216,10 +309,12 @@ export function useRecipeExecutions({
       cancelled = true;
     };
   }, [
+    initialRunRows,
     onPreviewSuccess,
     recipeId,
     resetForRecipe,
     setExecutions,
+    setPreviewRows,
     setRunErrors,
     upsertAndPersist,
   ]);
@@ -340,6 +435,20 @@ export function useRecipeExecutions({
         return false;
       }
 
+      // Flip to the Runs pane BEFORE we run ensureLocalModelLoaded + validate.
+      // Validation re-crawls the seed (multiple seconds for the github_repo
+      // reader) and the user otherwise stares at a "Running..." button with
+      // nothing else changing. runExecution() later no-ops this callback if
+      // the view has already been flipped, so we fire it once here.
+      onExecutionStart?.();
+
+      const localLoadError = await ensureLocalModelLoaded(payload);
+      if (localLoadError) {
+        setRunErrors([localLoadError]);
+        toastError("Local model failed to load", localLoadError);
+        return false;
+      }
+
       const normalizedRows = sanitizeExecutionRows(rows, kind);
       const executionPayload = buildExecutionPayload({
         payload,
@@ -374,7 +483,13 @@ export function useRecipeExecutions({
         runName,
       });
     },
-    [readExecutablePayload, runExecution, runSettings, setRunErrors],
+    [
+      onExecutionStart,
+      readExecutablePayload,
+      runExecution,
+      runSettings,
+      setRunErrors,
+    ],
   );
 
   const runPreview = useCallback(async (): Promise<boolean> => {
diff --git a/studio/frontend/src/features/recipe-studio/hooks/use-recipe-studio-actions.ts b/studio/frontend/src/features/recipe-studio/hooks/use-recipe-studio-actions.ts
index f6f7390cf7..79c75c1885 100644
--- a/studio/frontend/src/features/recipe-studio/hooks/use-recipe-studio-actions.ts
+++ b/studio/frontend/src/features/recipe-studio/hooks/use-recipe-studio-actions.ts
@@ -112,6 +112,10 @@ export function useRecipeStudioActions({
     recipeId,
     currentSignature: persistence.currentSignature,
     payloadResult,
+    initialRunRows:
+      typeof initialPayload?.run?.rows === "number"
+        ? initialPayload.run.rows
+        : null,
     onExecutionStart,
     onPreviewSuccess,
   });
diff --git a/studio/frontend/src/features/recipe-studio/recipe-studio-page.tsx b/studio/frontend/src/features/recipe-studio/recipe-studio-page.tsx
index 586d5d8ad8..c1001c0322 100644
--- a/studio/frontend/src/features/recipe-studio/recipe-studio-page.tsx
+++ b/studio/frontend/src/features/recipe-studio/recipe-studio-page.tsx
@@ -47,6 +47,7 @@ import { ConfigDialog } from "./dialogs/config-dialog";
 import { ImportDialog } from "./dialogs/import-dialog";
 import { RunDialog } from "./dialogs/preview-dialog";
 import { ProcessorsDialog } from "./dialogs/processors-dialog";
+import { GithubCrawlerEasyView } from "./easy/github-crawler-easy-view";
 import type {
   RecipeExecutionRecord,
   RecipeStudioView,
@@ -201,7 +202,40 @@ export function RecipeStudioPage({
     null,
   );
   const flowContainerRef = useRef<HTMLDivElement | null>(null);
-  const [activeView, setActiveView] = useState<RecipeStudioView>("editor");
+  const supportsEasyMode =
+    initialPayload?.ui?.seed_source_type === "github_repo" ||
+    (initialPayload?.recipe?.seed_config as { source?: { seed_type?: string } } | undefined)
+      ?.source?.seed_type === "github_repo";
+  const viewModeStorageKey = `recipe-studio:view-mode:${recipeId}`;
+  const [activeView, setActiveViewState] = useState<RecipeStudioView>(() => {
+    if (typeof window !== "undefined") {
+      const stored = window.localStorage.getItem(viewModeStorageKey);
+      if (stored === "easy" && supportsEasyMode) return "easy";
+      if (stored === "editor" || stored === "executions") return stored;
+    }
+    return supportsEasyMode ? "easy" : "editor";
+  });
+  const setActiveView = useCallback(
+    (next: RecipeStudioView | ((prev: RecipeStudioView) => RecipeStudioView)) => {
+      setActiveViewState((prev) => {
+        const resolved = typeof next === "function" ? next(prev) : next;
+        if (typeof window !== "undefined") {
+          window.localStorage.setItem(viewModeStorageKey, resolved);
+        }
+        return resolved;
+      });
+    },
+    [viewModeStorageKey],
+  );
+  // Easy mode has no canvas overlay/progress island, so once a run starts the
+  // user sees the Run button stuck on "Running..." with nothing else changing.
+  // Flip to the Runs pane so they land where progress is actually rendered.
+  // Advanced (editor) keeps its island and stays put.
+  const handleExecutionStart = useCallback(() => {
+    setActiveView((currentView) =>
+      currentView === "easy" ? "executions" : currentView,
+    );
+  }, [setActiveView]);
   const [processorsOpen, setProcessorsOpen] = useState(false);
   const [interactive, setInteractive] = useState(true);
   const [runtimeIslandMinimized, setRuntimeIslandMinimized] = useState(false);
@@ -326,6 +360,8 @@ export function RecipeStudioPage({
     validateResult,
     cancelExecution,
     loadExecutionDatasetPage,
+    runPreview,
+    runFull,
     copyRecipe,
     importRecipe,
   } = useRecipeStudioActions({
@@ -338,6 +374,7 @@ export function RecipeStudioPage({
     resetRecipe,
     loadRecipe,
     getCurrentPayloadFromStore,
+    onExecutionStart: handleExecutionStart,
   });
   const {
     activeExecution,
@@ -359,6 +396,19 @@ export function RecipeStudioPage({
   const runBusy = previewLoading || fullLoading || executionLocked;
   const islandExecution = activeExecution ?? recentCompletedExecution;
 
+  // Easy mode runs a full run (artifact persisted, tracked in Runs pane)
+  // using runFull. runFull requires a non-empty fullRunName but the Easy form
+  // has no run-name input, so seed a default here as soon as Easy is active.
+  // User can still rename it from Advanced/Runs dialogs before clicking Run.
+  useEffect(() => {
+    if (!supportsEasyMode) return;
+    if (activeView !== "easy") return;
+    if (fullRunName.trim()) return;
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 16);
+    const base = workflowName.trim() || "Easy run";
+    setFullRunName(`${base} ${stamp}`);
+  }, [supportsEasyMode, activeView, fullRunName, workflowName, setFullRunName]);
+
   const toggleInteractive = useCallback(() => {
     if (executionLocked) {
       return;
@@ -726,7 +776,7 @@ export function RecipeStudioPage({
   }
 
   return (
-    <div className="min-h-screen bg-background">
+    <div className="min-h-[calc(100dvh-var(--studio-titlebar-height,0px))] bg-background">
       <main className="w-full px-6 py-8">
         <div
           className="relative w-full overflow-hidden rounded-2xl corner-squircle border"
@@ -739,6 +789,7 @@ export function RecipeStudioPage({
             savedAtLabel={savedAtLabel}
             workflowName={workflowName}
             warnings={getGraphWarnings(configs, edges)}
+            supportsEasyMode={supportsEasyMode}
             onWorkflowNameChange={setWorkflowName}
             onViewChange={setActiveView}
             onSaveRecipe={() => {
@@ -749,7 +800,25 @@ export function RecipeStudioPage({
             className="h-[75vh] w-full rounded-t-none"
             ref={flowContainerRef}
           >
-            {activeView === "editor" ? (
+            {activeView === "easy" ? (
+              <GithubCrawlerEasyView
+                configs={configs}
+                rows={fullRows}
+                setRows={setFullRows}
+                updateConfig={updateConfig}
+                onRun={() => {
+                  // Easy mode is a full run (artifact persisted, tracked in
+                  // the Runs pane) capped at the user's row count. runFull
+                  // requires a non-empty fullRunName; the effect below
+                  // populates one on mount so the closure in runFull is
+                  // already up to date by the time the user clicks Run.
+                  void runFull();
+                }}
+                runLoading={fullLoading || executionLocked}
+                runErrors={runErrors}
+                onSwitchToAdvanced={() => setActiveView("editor")}
+              />
+            ) : activeView === "editor" ? (
               editorContent
             ) : (
               <ExecutionsView
diff --git a/studio/frontend/src/features/recipe-studio/stores/recipe-studio.ts b/studio/frontend/src/features/recipe-studio/stores/recipe-studio.ts
index 5b16bde4b0..036cc94082 100644
--- a/studio/frontend/src/features/recipe-studio/stores/recipe-studio.ts
+++ b/studio/frontend/src/features/recipe-studio/stores/recipe-studio.ts
@@ -394,9 +394,11 @@ export const useRecipeStudioStore = create<RecipeStudioState>((set, get) => ({
         nextSourceType = "local";
       } else if (type === "seed_unstructured") {
         nextSourceType = "unstructured";
+      } else if (type === "seed_github") {
+        nextSourceType = "github_repo";
       }
 
-      const nextConfig = {
+      const nextConfig: typeof existing = {
         ...existing,
         seed_source_type: nextSourceType,
         hf_repo_id: "",
@@ -415,6 +417,12 @@ export const useRecipeStudioStore = create<RecipeStudioState>((set, get) => ({
         seed_preview_rows: [],
         unstructured_chunk_size: "1200",
         unstructured_chunk_overlap: "200",
+        github_repo_slug: "",
+        github_token: "",
+        github_limit: "100",
+        github_item_types: ["issues", "pulls"],
+        github_include_comments: true,
+        github_max_comments_per_item: "30",
       };
       return {
         configs: {
diff --git a/studio/frontend/src/features/recipe-studio/types/index.ts b/studio/frontend/src/features/recipe-studio/types/index.ts
index cd1127a4e2..9c720a06d3 100644
--- a/studio/frontend/src/features/recipe-studio/types/index.ts
+++ b/studio/frontend/src/features/recipe-studio/types/index.ts
@@ -38,7 +38,10 @@ export type LayoutDirection = "LR" | "TB";
 
 export type SeedSamplingStrategy = "ordered" | "shuffle";
 export type SeedSelectionType = "none" | "index_range" | "partition_block";
-export type SeedSourceType = "hf" | "local" | "unstructured";
+export type SeedSourceType = "hf" | "local" | "unstructured" | "github_repo";
+
+export type GithubItemType = "issues" | "pulls" | "commits";
+export type GithubStateFilter = "all" | "open" | "closed";
 export const INFRA_NODE_KINDS = new Set([
   "model_provider",
   "model_config",
@@ -338,6 +341,20 @@ export type SeedConfig = {
   unstructured_file_ids?: string[];
   unstructured_file_names?: string[];
   unstructured_file_sizes?: number[];
+  // biome-ignore lint/style/useNamingConvention: api schema
+  github_repo_slug?: string;
+  // biome-ignore lint/style/useNamingConvention: api schema
+  github_token?: string;
+  // biome-ignore lint/style/useNamingConvention: api schema
+  github_limit?: string;
+  // biome-ignore lint/style/useNamingConvention: api schema
+  github_item_types?: GithubItemType[];
+  // biome-ignore lint/style/useNamingConvention: api schema
+  github_state?: GithubStateFilter;
+  // biome-ignore lint/style/useNamingConvention: api schema
+  github_include_comments?: boolean;
+  // biome-ignore lint/style/useNamingConvention: api schema
+  github_max_comments_per_item?: string;
   resolved_paths?: string[];
   // ui-only
   seed_preview_rows?: Record<string, unknown>[];
diff --git a/studio/frontend/src/features/recipe-studio/utils/import/parsers/seed-config-parser.ts b/studio/frontend/src/features/recipe-studio/utils/import/parsers/seed-config-parser.ts
index 0d92129232..21eadb3195 100644
--- a/studio/frontend/src/features/recipe-studio/utils/import/parsers/seed-config-parser.ts
+++ b/studio/frontend/src/features/recipe-studio/utils/import/parsers/seed-config-parser.ts
@@ -80,6 +80,12 @@ function parseSeedSettings(seedConfigRaw: unknown): Partial<SeedConfig> {
   let resolved_paths: string[] = [];
   let unstructured_chunk_size = "1200";
   let unstructured_chunk_overlap = "200";
+  let github_repo_slug = "";
+  let github_token = "";
+  let github_limit = "100";
+  let github_item_types: ("issues" | "pulls" | "commits")[] = ["issues", "pulls"];
+  let github_include_comments = true;
+  let github_max_comments_per_item = "30";
   const sourceRaw = seedConfigRaw.source;
   if (isRecord(sourceRaw)) {
     const seedType = readString(sourceRaw.seed_type);
@@ -107,6 +113,26 @@ function parseSeedSettings(seedConfigRaw: unknown): Partial<SeedConfig> {
       unstructuredFileNames = [];
       unstructured_chunk_size = readNumberString(sourceRaw.chunk_size) || "1200";
       unstructured_chunk_overlap = readNumberString(sourceRaw.chunk_overlap) || "200";
+    } else if (seedType === "github_repo") {
+      seed_source_type = "github_repo";
+      const rawRepos = Array.isArray(sourceRaw.repos) ? sourceRaw.repos : [];
+      const repos = rawRepos.filter((r): r is string => typeof r === "string");
+      github_repo_slug = repos.join("\n");
+      github_token = readString(sourceRaw.token) ?? "";
+      github_limit = readNumberString(sourceRaw.limit) || "100";
+      const rawItems = Array.isArray(sourceRaw.item_types) ? sourceRaw.item_types : [];
+      const validItems = rawItems.filter(
+        (t): t is "issues" | "pulls" | "commits" =>
+          t === "issues" || t === "pulls" || t === "commits",
+      );
+      if (validItems.length > 0) {
+        github_item_types = validItems;
+      }
+      if (typeof sourceRaw.include_comments === "boolean") {
+        github_include_comments = sourceRaw.include_comments;
+      }
+      github_max_comments_per_item =
+        readNumberString(sourceRaw.max_comments_per_item) || "30";
     }
   }
 
@@ -147,6 +173,12 @@ function parseSeedSettings(seedConfigRaw: unknown): Partial<SeedConfig> {
     resolved_paths,
     unstructured_chunk_size,
     unstructured_chunk_overlap,
+    github_repo_slug,
+    github_token,
+    github_limit,
+    github_item_types,
+    github_include_comments,
+    github_max_comments_per_item,
     sampling_strategy,
     selection_type,
     selection_start,
diff --git a/studio/frontend/src/features/recipe-studio/utils/node-data.ts b/studio/frontend/src/features/recipe-studio/utils/node-data.ts
index 2fc5205db8..96042b5919 100644
--- a/studio/frontend/src/features/recipe-studio/utils/node-data.ts
+++ b/studio/frontend/src/features/recipe-studio/utils/node-data.ts
@@ -70,7 +70,9 @@ export function nodeDataFromConfig(
         ? "Hugging Face dataset"
         : seedSourceType === "local"
           ? "CSV or JSON file"
-          : "Document file";
+          : seedSourceType === "github_repo"
+            ? "GitHub repositories"
+            : "Document file";
     return {
       title: "Source data",
       kind: "seed",
diff --git a/studio/frontend/src/features/recipe-studio/utils/payload/builders-seed.ts b/studio/frontend/src/features/recipe-studio/utils/payload/builders-seed.ts
index f73a2b46da..bb48b43857 100644
--- a/studio/frontend/src/features/recipe-studio/utils/payload/builders-seed.ts
+++ b/studio/frontend/src/features/recipe-studio/utils/payload/builders-seed.ts
@@ -6,6 +6,7 @@ import type { NodeConfig, SeedConfig } from "../../types";
 const DEFAULT_CHUNK_SIZE = 1200;
 const DEFAULT_CHUNK_OVERLAP = 200;
 const MAX_CHUNK_SIZE = 20000;
+const GITHUB_ITEM_TYPES = new Set(["issues", "pulls", "commits"]);
 
 function parseIntStrict(value: string | undefined): number | null {
   const trimmed = value?.trim();
@@ -56,33 +57,86 @@ export function buildSeedConfig(
     selectionStrategy = { index, num_partitions: numPartitions };
   }
 
-  const source =
-    seedSourceType === "hf"
-      ? {
-          // biome-ignore lint/style/useNamingConvention: api schema
-          seed_type: "hf",
-          path,
-          token,
-          endpoint,
-        }
-      : seedSourceType === "unstructured"
-        ? (() => {
-            const { chunkSize, chunkOverlap } = resolveChunking(config);
-            return {
-              // biome-ignore lint/style/useNamingConvention: api schema
-              seed_type: "unstructured",
-              paths: config.resolved_paths?.length ? config.resolved_paths : [config.hf_path],
-              // biome-ignore lint/style/useNamingConvention: api schema
-              chunk_size: chunkSize,
-              // biome-ignore lint/style/useNamingConvention: api schema
-              chunk_overlap: chunkOverlap,
-            };
-          })()
-        : {
-            // biome-ignore lint/style/useNamingConvention: api schema
-            seed_type: "local",
-            path,
-          };
+  let source: Record<string, unknown>;
+  if (seedSourceType === "hf") {
+    source = {
+      // biome-ignore lint/style/useNamingConvention: api schema
+      seed_type: "hf",
+      path,
+      token,
+      endpoint,
+    };
+  } else if (seedSourceType === "unstructured") {
+    const { chunkSize, chunkOverlap } = resolveChunking(config);
+    source = {
+      // biome-ignore lint/style/useNamingConvention: api schema
+      seed_type: "unstructured",
+      paths: config.resolved_paths?.length ? config.resolved_paths : [config.hf_path],
+      // biome-ignore lint/style/useNamingConvention: api schema
+      chunk_size: chunkSize,
+      // biome-ignore lint/style/useNamingConvention: api schema
+      chunk_overlap: chunkOverlap,
+    };
+  } else if (seedSourceType === "github_repo") {
+    const repos = (config.github_repo_slug ?? "")
+      .split(/[\n,]/)
+      .map((r) => r.trim())
+      .filter(Boolean);
+    if (repos.length === 0) {
+      errors.push(`Seed ${config.name}: at least one repo is required.`);
+      return undefined;
+    }
+    const invalidRepo = repos.find((repo) => {
+      const parts = repo.split("/");
+      return parts.length !== 2 || parts.some((part) => !part);
+    });
+    if (invalidRepo) {
+      errors.push(
+        `Seed ${config.name}: GitHub repositories must use owner/name format.`,
+      );
+      return undefined;
+    }
+    const itemTypes = config.github_item_types?.length
+      ? config.github_item_types
+      : ["issues", "pulls"];
+    if (itemTypes.some((itemType) => !GITHUB_ITEM_TYPES.has(itemType))) {
+      errors.push(`Seed ${config.name}: GitHub item types invalid.`);
+      return undefined;
+    }
+    const limitNum = parseIntStrict(config.github_limit ?? "100");
+    if (limitNum === null || limitNum < 1 || limitNum > 5000) {
+      errors.push(
+        `Seed ${config.name}: GitHub items per repo must be an integer from 1 to 5000.`,
+      );
+      return undefined;
+    }
+    const maxCommentsNum = parseIntStrict(config.github_max_comments_per_item ?? "30");
+    if (maxCommentsNum === null || maxCommentsNum < 0 || maxCommentsNum > 200) {
+      errors.push(
+        `Seed ${config.name}: GitHub max comments per item must be an integer from 0 to 200.`,
+      );
+      return undefined;
+    }
+    source = {
+      // biome-ignore lint/style/useNamingConvention: api schema
+      seed_type: "github_repo",
+      repos,
+      token: (config.github_token ?? "").trim(),
+      // biome-ignore lint/style/useNamingConvention: api schema
+      item_types: itemTypes,
+      limit: limitNum,
+      // biome-ignore lint/style/useNamingConvention: api schema
+      include_comments: config.github_include_comments ?? true,
+      // biome-ignore lint/style/useNamingConvention: api schema
+      max_comments_per_item: maxCommentsNum,
+    };
+  } else {
+    source = {
+      // biome-ignore lint/style/useNamingConvention: api schema
+      seed_type: "local",
+      path,
+    };
+  }
 
   return {
     source,
diff --git a/studio/frontend/src/features/recipe-studio/utils/payload/types.ts b/studio/frontend/src/features/recipe-studio/utils/payload/types.ts
index b8b1aba93b..902ea796b4 100644
--- a/studio/frontend/src/features/recipe-studio/utils/payload/types.ts
+++ b/studio/frontend/src/features/recipe-studio/utils/payload/types.ts
@@ -57,7 +57,7 @@ export type RecipePayload = {
     // ui-only: graph orientation
     layout_direction?: "LR" | "TB";
     // ui-only, used to preserve seed block mode across imports/refresh
-    seed_source_type?: "hf" | "local" | "unstructured";
+    seed_source_type?: "hf" | "local" | "unstructured" | "github_repo";
     // ui-only, persisted aux node positions by llm name + aux key
     aux_nodes?: Array<{
       llm: string;
diff --git a/studio/frontend/src/features/recipe-studio/utils/validation.ts b/studio/frontend/src/features/recipe-studio/utils/validation.ts
index 5f48fd44a5..d5200eeed0 100644
--- a/studio/frontend/src/features/recipe-studio/utils/validation.ts
+++ b/studio/frontend/src/features/recipe-studio/utils/validation.ts
@@ -8,6 +8,7 @@ import { isOxcCodeShape } from "./validators/oxc-code-shape";
 import { isOxcValidationMode } from "./validators/oxc-mode";
 
 const TRACE_MODES = new Set(["none", "last_message", "all_messages"]);
+const GITHUB_ITEM_TYPES = new Set(["issues", "pulls", "commits"]);
 
 // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: validation rules
 export function getConfigErrors(config: NodeConfig | null): string[] {
@@ -268,15 +269,49 @@ export function getConfigErrors(config: NodeConfig | null): string[] {
   }
   if (config.kind === "seed") {
     const seedSourceType = config.seed_source_type ?? "hf";
-    if (seedSourceType === "hf" && !config.hf_repo_id.trim()) {
+    if (seedSourceType === "github_repo") {
+      const repos = (config.github_repo_slug ?? "")
+        .split(/[\n,]/)
+        .map((repo) => repo.trim())
+        .filter(Boolean);
+      if (repos.length === 0) {
+        errors.push("Add at least one GitHub repository.");
+      }
+      if (
+        repos.some((repo) => {
+          const parts = repo.split("/");
+          return parts.length !== 2 || parts.some((part) => !part);
+        })
+      ) {
+        errors.push("GitHub repositories must use owner/name format.");
+      }
+      const itemTypes = config.github_item_types?.length
+        ? config.github_item_types
+        : ["issues", "pulls"];
+      if (itemTypes.length === 0) {
+        errors.push("Choose at least one GitHub item type.");
+      } else if (itemTypes.some((itemType) => !GITHUB_ITEM_TYPES.has(itemType))) {
+        errors.push("GitHub item types must be issues, pulls, or commits.");
+      }
+      const limit = parseIntNumber(config.github_limit ?? "100");
+      if (limit === null || limit < 1 || limit > 5000) {
+        errors.push("Items per repo must be an integer from 1 to 5000.");
+      }
+      const maxComments = parseIntNumber(config.github_max_comments_per_item ?? "30");
+      if (maxComments === null || maxComments < 0 || maxComments > 200) {
+        errors.push("Max comments per item must be an integer from 0 to 200.");
+      }
+    } else if (seedSourceType === "hf" && !config.hf_repo_id.trim()) {
       errors.push("Choose a Hugging Face dataset.");
     }
-    const hasPath =
-      seedSourceType === "unstructured"
-        ? (config.resolved_paths?.length ?? 0) > 0
-        : Boolean(config.hf_path.trim());
-    if (!hasPath) {
-      errors.push("Load the source-data preview first.");
+    if (seedSourceType !== "github_repo") {
+      const hasPath =
+        seedSourceType === "unstructured"
+          ? (config.resolved_paths?.length ?? 0) > 0
+          : Boolean(config.hf_path.trim());
+      if (!hasPath) {
+        errors.push("Load the source-data preview first.");
+      }
     }
     if (
       seedSourceType === "hf" &&
@@ -304,7 +339,7 @@ export function getConfigErrors(config: NodeConfig | null): string[] {
       ) {
         errors.push("Chunk overlap must be less than chunk size.");
       }
-    } else {
+    } else if (seedSourceType !== "github_repo") {
       const selectedDropColumns = (config.seed_drop_columns ?? [])
         .map((value) => value.trim())
         .filter(Boolean);
diff --git a/studio/frontend/src/features/settings/api/api-keys.ts b/studio/frontend/src/features/settings/api/api-keys.ts
index 73d7b50def..5bf3f2825b 100644
--- a/studio/frontend/src/features/settings/api/api-keys.ts
+++ b/studio/frontend/src/features/settings/api/api-keys.ts
@@ -15,7 +15,7 @@ export interface ApiKey {
 
 export async function fetchApiKeys(): Promise<ApiKey[]> {
   const res = await authFetch("/api/auth/api-keys");
-  if (!res.ok) throw new Error("Failed to load API keys");
+  if (!res.ok) throw new Error("Failed to load API access");
   const data = (await res.json()) as { api_keys: ApiKey[] };
   return data.api_keys.filter((k) => k.is_active);
 }
@@ -29,7 +29,7 @@ export async function createApiKey(
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ name, expires_in_days: expiresInDays }),
   });
-  if (!res.ok) throw new Error("Failed to create API key");
+  if (!res.ok) throw new Error("Failed to create access token");
   return res.json();
 }
 
@@ -37,5 +37,5 @@ export async function revokeApiKey(keyId: number): Promise<void> {
   const res = await authFetch(`/api/auth/api-keys/${keyId}`, {
     method: "DELETE",
   });
-  if (!res.ok) throw new Error("Failed to revoke API key");
+  if (!res.ok) throw new Error("Failed to revoke access token");
 }
diff --git a/studio/frontend/src/features/settings/components/api-key-row.tsx b/studio/frontend/src/features/settings/components/api-key-row.tsx
index f121045e1e..ced6de17d1 100644
--- a/studio/frontend/src/features/settings/components/api-key-row.tsx
+++ b/studio/frontend/src/features/settings/components/api-key-row.tsx
@@ -92,7 +92,7 @@ export function ApiKeyRow({
             className="text-destructive focus:text-destructive"
           >
             <HugeiconsIcon icon={Delete02Icon} className="size-3.5 mr-2" />
-            Revoke key
+            Revoke token
           </DropdownMenuItem>
         </DropdownMenuContent>
       </DropdownMenu>
diff --git a/studio/frontend/src/features/settings/components/create-key-form.tsx b/studio/frontend/src/features/settings/components/create-key-form.tsx
index 2166abf3cf..a0f2d7f82d 100644
--- a/studio/frontend/src/features/settings/components/create-key-form.tsx
+++ b/studio/frontend/src/features/settings/components/create-key-form.tsx
@@ -34,7 +34,7 @@ export function CreateKeyForm({
       onCreated(result.key);
       setName("");
     } catch (err) {
-      onError(err instanceof Error ? err.message : "Couldn't create key.");
+      onError(err instanceof Error ? err.message : "Couldn't create access token.");
     } finally {
       setLoading(false);
     }
@@ -49,9 +49,9 @@ export function CreateKeyForm({
         <Input
           value={name}
           onChange={(e) => setName(e.target.value)}
-          placeholder="Key name (e.g. production)"
+          placeholder="Token name (e.g. production)"
           className="h-8 min-w-[180px] flex-1 text-sm"
-          aria-label="New key name"
+          aria-label="New access token name"
         />
         <div className="inline-flex items-center rounded-md border border-border bg-background p-0.5">
           {EXPIRY_PRESETS.map((p) => {
@@ -75,7 +75,7 @@ export function CreateKeyForm({
           })}
         </div>
         <Button type="submit" size="sm" disabled={loading || !name.trim()}>
-          {loading ? "Creating…" : "Create key"}
+          {loading ? "Creating…" : "Create token"}
         </Button>
       </div>
     </form>
diff --git a/studio/frontend/src/features/settings/components/key-reveal-card.tsx b/studio/frontend/src/features/settings/components/key-reveal-card.tsx
index ab258537da..2b589e88fe 100644
--- a/studio/frontend/src/features/settings/components/key-reveal-card.tsx
+++ b/studio/frontend/src/features/settings/components/key-reveal-card.tsx
@@ -32,7 +32,7 @@ export function KeyRevealCard({
           className="size-3.5 text-emerald-600 dark:text-emerald-500"
         />
         <span className="text-xs font-medium text-emerald-700 dark:text-emerald-500">
-          New key created
+          New access token created
         </span>
       </div>
       <button
@@ -43,7 +43,7 @@ export function KeyRevealCard({
           "focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-1 focus-visible:ring-offset-background",
           copied && "border-emerald-500/40 bg-emerald-500/10",
         )}
-        aria-label={copied ? "Key copied" : "Copy key"}
+        aria-label={copied ? "Access token copied" : "Copy access token"}
       >
         <code className="min-w-0 flex-1 break-all text-left text-foreground">
           {rawKey}
diff --git a/studio/frontend/src/features/settings/components/usage-examples.tsx b/studio/frontend/src/features/settings/components/usage-examples.tsx
index a2dc2c3774..a8f8ce31a6 100644
--- a/studio/frontend/src/features/settings/components/usage-examples.tsx
+++ b/studio/frontend/src/features/settings/components/usage-examples.tsx
@@ -4,12 +4,11 @@
 import { cn } from "@/lib/utils";
 import { copyToClipboard } from "@/lib/copy-to-clipboard";
 import {
-  ArrowDown01Icon,
+  ArrowUpRight01Icon,
   Copy01Icon,
   Tick02Icon,
 } from "@hugeicons/core-free-icons";
 import { HugeiconsIcon } from "@hugeicons/react";
-import { AnimatePresence, motion } from "motion/react";
 import { useMemo, useState } from "react";
 
 type Lang = "curl" | "python" | "tools";
@@ -20,6 +19,29 @@ const TABS: { id: Lang; label: string }[] = [
   { id: "tools", label: "Tools" },
 ];
 
+const DOC_LINKS = [
+  {
+    label: "Claude Code",
+    href: "https://unsloth.ai/docs/basics/claude-code",
+  },
+  {
+    label: "Codex",
+    href: "https://unsloth.ai/docs/basics/codex",
+  },
+  {
+    label: "OpenClaw",
+    href: "https://unsloth.ai/docs/integrations/openclaw",
+  },
+  {
+    label: "OpenCode",
+    href: "https://unsloth.ai/docs/integrations/opencode",
+  },
+  {
+    label: "Hermes Agent",
+    href: "https://unsloth.ai/docs/integrations/hermes-agent",
+  },
+];
+
 function buildSnippets(base: string) {
   return {
     curl: `curl ${base}/v1/chat/completions \\
@@ -56,7 +78,6 @@ for chunk in response:
 }
 
 export function UsageExamples() {
-  const [open, setOpen] = useState(false);
   const [lang, setLang] = useState<Lang>("curl");
   const [copied, setCopied] = useState(false);
   const snippets = useMemo(
@@ -76,71 +97,62 @@ export function UsageExamples() {
 
   return (
     <section className="flex flex-col">
-      <button
-        type="button"
-        onClick={() => setOpen((o) => !o)}
-        className="flex w-fit items-center gap-1.5 rounded text-xs font-medium text-muted-foreground transition-colors hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
-        aria-expanded={open}
-      >
-        <HugeiconsIcon
-          icon={ArrowDown01Icon}
-          className={cn("size-3.5 transition-transform", open && "rotate-180")}
-        />
-        {open ? "Hide usage examples" : "Show usage examples"}
-      </button>
-
-      <AnimatePresence initial={false}>
-        {open && (
-          <motion.div
-            initial={{ height: 0, opacity: 0 }}
-            animate={{ height: "auto", opacity: 1 }}
-            exit={{ height: 0, opacity: 0 }}
-            transition={{ duration: 0.18, ease: [0.165, 0.84, 0.44, 1] }}
-            className="overflow-hidden"
-          >
-            <div className="mt-3 overflow-hidden rounded-lg border border-border bg-muted/20">
-              <div className="flex items-center justify-between border-b border-border px-2 py-1.5">
-                <div className="flex items-center gap-0.5">
-                  {TABS.map((t) => {
-                    const active = lang === t.id;
-                    return (
-                      <button
-                        key={t.id}
-                        type="button"
-                        onClick={() => setLang(t.id)}
-                        aria-pressed={active}
-                        className={cn(
-                          "rounded px-2 py-1 text-[11px] font-medium transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
-                          active
-                            ? "bg-background text-foreground shadow-border"
-                            : "text-muted-foreground hover:text-foreground",
-                        )}
-                      >
-                        {t.label}
-                      </button>
-                    );
-                  })}
-                </div>
+      <h2 className="mb-2 text-sm font-semibold text-foreground">Usage examples</h2>
+      <div className="overflow-hidden rounded-lg border border-border bg-muted/20">
+        <div className="flex items-center justify-between border-b border-border px-2 py-1.5">
+          <div className="flex items-center gap-0.5">
+            {TABS.map((t) => {
+              const active = lang === t.id;
+              return (
                 <button
+                  key={t.id}
                   type="button"
-                  onClick={handleCopy}
-                  className="flex items-center gap-1 rounded px-1.5 py-1 text-[11px] text-muted-foreground transition-colors hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
-                  aria-label="Copy snippet"
+                  onClick={() => setLang(t.id)}
+                  aria-pressed={active}
+                  className={cn(
+                    "rounded px-2 py-1 text-[11px] font-medium transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
+                    active
+                      ? "bg-background text-foreground shadow-border"
+                      : "text-muted-foreground hover:text-foreground",
+                  )}
                 >
-                  <HugeiconsIcon
-                    icon={copied ? Tick02Icon : Copy01Icon}
-                    className={cn("size-3.5", copied && "text-emerald-600")}
-                  />
-                  {copied ? "Copied" : "Copy"}
+                  {t.label}
                 </button>
-              </div>
-              <pre className="overflow-x-auto p-3 font-mono text-[11px] leading-relaxed text-foreground">
-                {snippets[lang]}
-              </pre>
-            </div>
-          </motion.div>
-        )}
-      </AnimatePresence>
+              );
+            })}
+          </div>
+          <button
+            type="button"
+            onClick={handleCopy}
+            className="flex items-center gap-1 rounded px-1.5 py-1 text-[11px] text-muted-foreground transition-colors hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+            aria-label="Copy snippet"
+          >
+            <HugeiconsIcon
+              icon={copied ? Tick02Icon : Copy01Icon}
+              className={cn("size-3.5", copied && "text-emerald-600")}
+            />
+            {copied ? "Copied" : "Copy"}
+          </button>
+        </div>
+        <pre className="overflow-x-auto p-3 font-mono text-[11px] leading-relaxed text-foreground">
+          {snippets[lang]}
+        </pre>
+        <div className="flex flex-wrap items-center gap-x-2 gap-y-1 border-t border-border px-3 py-2 text-[11px] text-muted-foreground">
+          <span>Setup docs:</span>
+          {DOC_LINKS.map((link) => (
+            <a
+              key={link.href}
+              href={link.href}
+              target="_blank"
+              rel="noreferrer"
+              className="inline-flex items-center gap-0.5 rounded font-medium text-foreground underline decoration-border underline-offset-2 transition-colors hover:decoration-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+            >
+              {link.label}
+              <HugeiconsIcon icon={ArrowUpRight01Icon} className="size-3" />
+            </a>
+          ))}
+        </div>
+      </div>
     </section>
   );
 }
diff --git a/studio/frontend/src/features/settings/settings-dialog.tsx b/studio/frontend/src/features/settings/settings-dialog.tsx
index bb22fcb89c..63c0a9d388 100644
--- a/studio/frontend/src/features/settings/settings-dialog.tsx
+++ b/studio/frontend/src/features/settings/settings-dialog.tsx
@@ -10,15 +10,16 @@ import {
 import { cn } from "@/lib/utils";
 import {
   Cancel01Icon,
-  Key01Icon,
+  Globe02Icon,
+  HelpCircleIcon,
   Message01Icon,
   PaintBrush02Icon,
   Settings02Icon,
-  SparklesIcon,
   UserIcon,
 } from "@hugeicons/core-free-icons";
 import { HugeiconsIcon } from "@hugeicons/react";
 import { motion, useReducedMotion } from "motion/react";
+import { useEffect, useRef } from "react";
 import { useSettingsDialogStore, type SettingsTab } from "./stores/settings-dialog-store";
 import { AboutTab } from "./tabs/about-tab";
 import { ApiKeysTab } from "./tabs/api-keys-tab";
@@ -31,6 +32,7 @@ interface TabDef {
   id: SettingsTab;
   label: string;
   icon: typeof Settings02Icon;
+  badge?: string;
 }
 
 const TABS: TabDef[] = [
@@ -38,8 +40,8 @@ const TABS: TabDef[] = [
   { id: "profile", label: "Profile", icon: UserIcon },
   { id: "appearance", label: "Appearance", icon: PaintBrush02Icon },
   { id: "chat", label: "Chat", icon: Message01Icon },
-  { id: "api-keys", label: "API Keys", icon: Key01Icon },
-  { id: "about", label: "About", icon: SparklesIcon },
+  { id: "api-keys", label: "API", icon: Globe02Icon, badge: "New" },
+  { id: "about", label: "Help", icon: HelpCircleIcon },
 ];
 
 function renderTab(tab: SettingsTab) {
@@ -65,6 +67,22 @@ export function SettingsDialog() {
   const setActiveTab = useSettingsDialogStore((s) => s.setActiveTab);
   const closeDialog = useSettingsDialogStore((s) => s.closeDialog);
   const reduced = useReducedMotion();
+  const tabButtonRefs = useRef<Record<SettingsTab, HTMLButtonElement | null>>({
+    general: null,
+    profile: null,
+    appearance: null,
+    chat: null,
+    "api-keys": null,
+    about: null,
+  });
+
+  useEffect(() => {
+    if (!open) return;
+    const frame = window.requestAnimationFrame(() => {
+      tabButtonRefs.current[activeTab]?.focus({ preventScroll: true });
+    });
+    return () => window.cancelAnimationFrame(frame);
+  }, [open, activeTab]);
 
   return (
     <Dialog open={open} onOpenChange={(o) => !o && closeDialog()}>
@@ -90,6 +108,9 @@ export function SettingsDialog() {
                 return (
                   <button
                     key={tab.id}
+                    ref={(node) => {
+                      tabButtonRefs.current[tab.id] = node;
+                    }}
                     type="button"
                     onClick={() => setActiveTab(tab.id)}
                     className={cn(
@@ -121,7 +142,12 @@ export function SettingsDialog() {
                       strokeWidth={1.5}
                       className="relative z-10 size-[18px]"
                     />
-                    <span className="relative z-10">{tab.label}</span>
+                    <span className="relative z-10 min-w-0 truncate">{tab.label}</span>
+                    {tab.badge ? (
+                      <span className="relative z-10 ml-auto rounded-[6px] border border-emerald-500/25 bg-emerald-500/10 px-1.5 py-0.5 text-[10px] leading-none font-semibold text-emerald-700 dark:text-emerald-300">
+                        {tab.badge}
+                      </span>
+                    ) : null}
                   </button>
                 );
               })}
diff --git a/studio/frontend/src/features/settings/tabs/about-tab.tsx b/studio/frontend/src/features/settings/tabs/about-tab.tsx
index bb4454aa43..9629900237 100644
--- a/studio/frontend/src/features/settings/tabs/about-tab.tsx
+++ b/studio/frontend/src/features/settings/tabs/about-tab.tsx
@@ -12,6 +12,7 @@ import {
   Book03Icon,
   Cancel01Icon,
   MessageNotification01Icon,
+  NewReleasesIcon,
 } from "@hugeicons/core-free-icons";
 import { HugeiconsIcon } from "@hugeicons/react";
 import { useEffect, useState } from "react";
@@ -48,9 +49,9 @@ export function AboutTab() {
   return (
     <div className="flex flex-col gap-6">
       <header className="flex flex-col gap-1">
-        <h1 className="text-lg font-semibold font-heading">About</h1>
+        <h1 className="text-lg font-semibold font-heading">Help</h1>
         <p className="text-xs text-muted-foreground">
-          Unsloth Studio build info and support.
+          Documentation, release notes, feedback, and Studio build info.
         </p>
       </header>
 
@@ -79,6 +80,18 @@ export function AboutTab() {
             <HugeiconsIcon icon={ArrowUpRight01Icon} className="size-3" />
           </a>
         </SettingsRow>
+        <SettingsRow label="Release notes">
+          <a
+            href="https://unsloth.ai/docs/new/changelog"
+            target="_blank"
+            rel="noopener noreferrer"
+            className="inline-flex items-center gap-1 text-xs font-medium text-muted-foreground hover:text-foreground"
+          >
+            <HugeiconsIcon icon={NewReleasesIcon} className="size-3.5" />
+            What's new
+            <HugeiconsIcon icon={ArrowUpRight01Icon} className="size-3" />
+          </a>
+        </SettingsRow>
         <SettingsRow label="Feedback">
           <a
             href="https://github.com/unslothai/unsloth/issues"
diff --git a/studio/frontend/src/features/settings/tabs/api-keys-tab.tsx b/studio/frontend/src/features/settings/tabs/api-keys-tab.tsx
index e0fa6d87d2..ac9ec40543 100644
--- a/studio/frontend/src/features/settings/tabs/api-keys-tab.tsx
+++ b/studio/frontend/src/features/settings/tabs/api-keys-tab.tsx
@@ -36,7 +36,7 @@ export function ApiKeysTab() {
     try {
       setKeys(await fetchApiKeys());
     } catch (e) {
-      setError(e instanceof Error ? e.message : "Couldn't load API keys.");
+      setError(e instanceof Error ? e.message : "Couldn't load API access.");
     } finally {
       setLoading(false);
     }
@@ -54,7 +54,7 @@ export function ApiKeysTab() {
       await load();
       setRevokeTarget(null);
     } catch (e) {
-      setError(e instanceof Error ? e.message : "Couldn't revoke key.");
+      setError(e instanceof Error ? e.message : "Couldn't revoke access token.");
     } finally {
       setRevoking(false);
     }
@@ -63,9 +63,18 @@ export function ApiKeysTab() {
   return (
     <div className="flex flex-col gap-6">
       <header className="flex flex-col gap-1">
-        <h1 className="text-lg font-semibold font-heading">API Keys</h1>
+        <h1 className="text-lg font-semibold font-heading">API</h1>
         <p className="text-xs text-muted-foreground">
-          Access Unsloth Studio programmatically via the OpenAI-compatible API.
+          Access Unsloth programmatically via the OpenAI-compatible API.{" "}
+          <a
+            href="https://unsloth.ai/docs/basics/api"
+            target="_blank"
+            rel="noreferrer"
+            className="font-medium text-foreground underline decoration-border underline-offset-2 transition-colors hover:decoration-foreground"
+          >
+            Read the API docs
+          </a>
+          .
         </p>
       </header>
 
@@ -103,7 +112,7 @@ export function ApiKeysTab() {
       </AnimatePresence>
 
       <section className="flex flex-col">
-        <h2 className="mb-2 text-sm font-semibold text-foreground">Your keys</h2>
+        <h2 className="mb-2 text-sm font-semibold text-foreground">Access tokens</h2>
         {error ? (
           <div className="rounded-md border border-destructive/20 bg-destructive/5 p-3 text-xs text-destructive">
             {error}
@@ -119,7 +128,7 @@ export function ApiKeysTab() {
           </div>
         ) : keys.length === 0 ? (
           <p className="py-6 text-center text-xs text-muted-foreground">
-            No API keys yet.
+            No API access yet.
           </p>
         ) : (
           <div className="flex flex-col">
@@ -135,9 +144,9 @@ export function ApiKeysTab() {
       <Dialog open={revokeTarget !== null} onOpenChange={(o) => !o && setRevokeTarget(null)}>
         <DialogContent className="max-w-md">
           <DialogHeader>
-            <DialogTitle>Revoke key “{revokeTarget?.name}”?</DialogTitle>
+            <DialogTitle>Revoke access token “{revokeTarget?.name}”?</DialogTitle>
             <DialogDescription>
-              Applications using this key will immediately lose access. This cannot be undone.
+              Applications using this token will immediately lose access. This cannot be undone.
             </DialogDescription>
           </DialogHeader>
           <DialogFooter>
diff --git a/studio/frontend/src/features/settings/tabs/general-tab.tsx b/studio/frontend/src/features/settings/tabs/general-tab.tsx
index 6081e90605..9ea89f55cf 100644
--- a/studio/frontend/src/features/settings/tabs/general-tab.tsx
+++ b/studio/frontend/src/features/settings/tabs/general-tab.tsx
@@ -199,7 +199,7 @@ export function GeneralTab() {
         <SettingsRow
           destructive
           label="Reset all local preferences"
-          description="Clears theme, tokens, sidebar state, and presets. Chats and API keys are not affected."
+          description="Clears theme, tokens, sidebar state, and presets. Chats and API access are not affected."
         >
           <Button
             variant="outline"
@@ -218,7 +218,7 @@ export function GeneralTab() {
             <DialogTitle>Reset all local preferences?</DialogTitle>
             <DialogDescription>
               This clears your theme, tokens, and stored settings, then reloads
-              Studio. Chats and API keys are not affected.
+              Studio. Chats and API access are not affected.
             </DialogDescription>
           </DialogHeader>
           <DialogFooter>
diff --git a/studio/frontend/src/features/studio/historical-training-view.tsx b/studio/frontend/src/features/studio/historical-training-view.tsx
index d3ac434bd8..e461fc5a90 100644
--- a/studio/frontend/src/features/studio/historical-training-view.tsx
+++ b/studio/frontend/src/features/studio/historical-training-view.tsx
@@ -60,6 +60,7 @@ function mapToViewData(detail: TrainingRunDetailResponse): TrainingViewData {
     currentGradNorm: metrics.grad_norm_history.at(-1) ?? null,
     currentEpoch: metrics.final_epoch,
     currentNumTokens: metrics.final_num_tokens ?? null,
+    outputDir: run.output_dir ?? null,
     progressPercent:
       run.total_steps && run.final_step
         ? (run.final_step / run.total_steps) * 100
diff --git a/studio/frontend/src/features/studio/history-card-grid.tsx b/studio/frontend/src/features/studio/history-card-grid.tsx
index 9e72c9f75c..6fbdffce85 100644
--- a/studio/frontend/src/features/studio/history-card-grid.tsx
+++ b/studio/frontend/src/features/studio/history-card-grid.tsx
@@ -13,7 +13,12 @@ import {
 } from "@/components/ui/alert-dialog";
 import { Button } from "@/components/ui/button";
 import type { TrainingRunSummary } from "@/features/training";
-import { deleteTrainingRun, listTrainingRuns } from "@/features/training";
+import {
+  deleteTrainingRun,
+  listTrainingRuns,
+  useTrainingActions,
+  useTrainingRuntimeStore,
+} from "@/features/training";
 import { formatDuration } from "@/features/studio/sections/progress-section-lib";
 import { cn } from "@/lib/utils";
 import { Delete02Icon } from "@hugeicons/core-free-icons";
@@ -47,8 +52,28 @@ const statusBadge: Record<
     className:
       "bg-blue-100 text-blue-700 dark:bg-blue-950 dark:text-blue-400",
   },
+  resumed_later: {
+    label: "Continued",
+    className:
+      "bg-emerald-100 text-emerald-700 dark:bg-emerald-950 dark:text-emerald-400",
+  },
 };
 
+function wasContinuedInVisibleRuns(
+  run: TrainingRunSummary,
+  runs: TrainingRunSummary[],
+): boolean {
+  if (run.status !== "stopped" || !run.output_dir) return false;
+  const startedAt = new Date(run.started_at).getTime();
+  return runs.some(
+    (other) =>
+      other.id !== run.id &&
+      other.output_dir === run.output_dir &&
+      (other.status === "stopped" || other.status === "completed") &&
+      new Date(other.started_at).getTime() > startedAt,
+  );
+}
+
 function catmullRomPath(points: { x: number; y: number }[]): string {
   if (points.length < 2) return "";
   const d = [`M${points[0]!.x.toFixed(1)},${points[0]!.y.toFixed(1)}`];
@@ -133,10 +158,12 @@ function formatRelativeTime(isoDate: string): string {
 
 interface HistoryCardGridProps {
   onSelectRun: (runId: string) => void;
+  onResumeStarted?: () => void;
 }
 
 export function HistoryCardGrid({
   onSelectRun,
+  onResumeStarted,
 }: HistoryCardGridProps): ReactElement {
   const [runs, setRuns] = useState<TrainingRunSummary[]>([]);
   const [total, setTotal] = useState(0);
@@ -144,7 +171,10 @@ export function HistoryCardGrid({
   const [error, setError] = useState<string | null>(null);
   const [deleteError, setDeleteError] = useState<string | null>(null);
   const [deleteTarget, setDeleteTarget] = useState<string | null>(null);
+  const [resumeTarget, setResumeTarget] = useState<string | null>(null);
   const [manualFetchInFlight, setManualFetchInFlight] = useState(false);
+  const { resumeTrainingRunFromHistory } = useTrainingActions();
+  const isStarting = useTrainingRuntimeStore((state) => state.isStarting);
 
   const userControllerRef = useRef<AbortController | null>(null);
   const pollControllerRef = useRef<AbortController | null>(null);
@@ -233,6 +263,18 @@ export function HistoryCardGrid({
     setDeleteTarget(null);
   };
 
+  const handleResume = async (runId: string) => {
+    setResumeTarget(runId);
+    try {
+      const ok = await resumeTrainingRunFromHistory(runId);
+      if (ok) {
+        onResumeStarted?.();
+      }
+    } finally {
+      setResumeTarget(null);
+    }
+  };
+
   if (!loading && error && runs.length === 0) {
     return (
       <div className="flex flex-col items-center gap-2 py-16 text-center">
@@ -264,18 +306,25 @@ export function HistoryCardGrid({
       )}
       <div className="grid grid-cols-1 gap-4 sm:grid-cols-2 xl:grid-cols-3">
         {runs.map((run) => {
-          const badge = statusBadge[run.status] ?? statusBadge.error;
+          const wasContinued =
+            run.resumed_later || wasContinuedInVisibleRuns(run, runs);
+          const badge = wasContinued
+            ? statusBadge.resumed_later
+            : (statusBadge[run.status] ?? statusBadge.error);
           const isRunning = run.status === "running";
+          const canResume = run.can_resume && !wasContinued;
+          const isResuming = resumeTarget === run.id;
           return (
             <div
               role="button"
               tabIndex={0}
               key={run.id}
               className={cn(
-                "group relative flex cursor-pointer flex-col gap-3 rounded-xl border bg-card p-4 text-left transition-colors hover:border-border hover:bg-accent/30",
+                "group relative flex h-[11.5rem] cursor-pointer flex-col gap-3 rounded-xl border bg-card p-4 text-left transition-colors hover:border-border hover:bg-accent/30",
                 isRunning
                   ? "border-blue-400/50 dark:border-blue-500/30"
                   : "border-border/60",
+                canResume && "gap-2",
               )}
               onClick={() => onSelectRun(run.id)}
               onKeyDown={(e) => {
@@ -299,6 +348,21 @@ export function HistoryCardGrid({
                   {formatRelativeTime(run.started_at)}
                 </span>
               </div>
+              {canResume && (
+                <Button
+                  type="button"
+                  size="xs"
+                  variant="outline"
+                  className="absolute bottom-3 left-4 h-6 rounded-full px-2.5 text-[11px] leading-none shadow-sm"
+                  disabled={isStarting || isResuming}
+                  onClick={(e) => {
+                    e.stopPropagation();
+                    void handleResume(run.id);
+                  }}
+                >
+                  {isResuming ? "Resuming..." : "Resume training"}
+                </Button>
+              )}
               <div className="min-w-0">
                 <p
                   className="truncate text-sm font-medium"
@@ -311,7 +375,9 @@ export function HistoryCardGrid({
                 </p>
               </div>
               {run.loss_sparkline && run.loss_sparkline.length >= 2 && (
-                <Sparkline values={run.loss_sparkline} id={run.id} />
+                <div className={cn(canResume && "h-7 overflow-hidden")}>
+                  <Sparkline values={run.loss_sparkline} id={run.id} />
+                </div>
               )}
               <div className="flex flex-wrap gap-x-4 gap-y-1 text-[11px] text-muted-foreground">
                 <span>
diff --git a/studio/frontend/src/features/studio/live-training-view.tsx b/studio/frontend/src/features/studio/live-training-view.tsx
index 9f930ce77b..e355655d54 100644
--- a/studio/frontend/src/features/studio/live-training-view.tsx
+++ b/studio/frontend/src/features/studio/live-training-view.tsx
@@ -31,6 +31,7 @@ export function LiveTrainingView(): ReactElement {
       elapsedSeconds: state.elapsedSeconds,
       etaSeconds: state.etaSeconds,
       evalEnabled: state.evalEnabled,
+      outputDir: state.outputDir,
       isTrainingRunning: state.isTrainingRunning,
       lossHistory: state.lossHistory,
       lrHistory: state.lrHistory,
@@ -57,6 +58,7 @@ export function LiveTrainingView(): ReactElement {
     currentGradNorm: runtime.currentGradNorm,
     currentEpoch: runtime.currentEpoch,
     currentNumTokens: runtime.currentNumTokens,
+    outputDir: runtime.outputDir,
     progressPercent: runtime.progressPercent,
     elapsedSeconds: runtime.elapsedSeconds,
     etaSeconds: runtime.etaSeconds,
diff --git a/studio/frontend/src/features/studio/sections/dataset-section.tsx b/studio/frontend/src/features/studio/sections/dataset-section.tsx
index b12bdb09f0..11c2321863 100644
--- a/studio/frontend/src/features/studio/sections/dataset-section.tsx
+++ b/studio/frontend/src/features/studio/sections/dataset-section.tsx
@@ -58,17 +58,42 @@ import {
   ViewIcon,
 } from "@hugeicons/core-free-icons";
 import { HugeiconsIcon } from "@hugeicons/react";
-import { type ChangeEvent, useCallback, useEffect, useMemo, useRef, useState } from "react";
+import {
+  type ChangeEvent,
+  type DragEvent,
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
 import { toast } from "sonner";
 import { useShallow } from "zustand/react/shallow";
 import { DocumentUploadRedirectDialog } from "./document-upload-redirect-dialog";
 
+const TRAINING_UPLOAD_EXTENSIONS = [
+  ".csv",
+  ".jsonl",
+  ".json",
+  ".parquet",
+  ".pdf",
+  ".docx",
+  ".txt",
+] as const;
+const TRAINING_UPLOAD_EXTENSION_SET = new Set<string>(TRAINING_UPLOAD_EXTENSIONS);
+const TRAINING_UPLOAD_ACCEPT = TRAINING_UPLOAD_EXTENSIONS.join(",");
+const TRAINING_UPLOAD_LABEL = "CSV, JSONL, JSON, Parquet, PDF, DOCX, TXT";
 const DOCUMENT_REDIRECT_EXTENSIONS = new Set([".pdf", ".docx", ".txt"]);
 
 const SEARCH_INPUT_REASONS = new Set(["input-change", "input-paste", "input-clear"]);
 const OPEN_LEARNING_RECIPES_ON_ARRIVAL_KEY =
   "data-recipes:open-learning-recipes";
 
+function getFileExtension(fileName: string) {
+  const extensionStart = fileName.lastIndexOf(".");
+  return extensionStart >= 0 ? fileName.slice(extensionStart).toLowerCase() : "";
+}
+
 function isLikelyLocalDatasetRef(value: string) {
   return (
     value.startsWith("/") ||
@@ -354,6 +379,7 @@ export function DatasetSection() {
   );
 
   const [isUploading, setIsUploading] = useState(false);
+  const [isDatasetDragOver, setIsDatasetDragOver] = useState(false);
   const [documentRedirectOpen, setDocumentRedirectOpen] = useState(false);
   const [redirectFileName, setRedirectFileName] = useState<string | null>(null);
 
@@ -380,12 +406,15 @@ export function DatasetSection() {
     }
   };
 
-  const handleDatasetFileChange = async (event: ChangeEvent<HTMLInputElement>) => {
-    const file = event.target.files?.[0];
-    event.target.value = "";
-    if (!file) return;
+  const handleDatasetFile = async (file: File) => {
+    const extension = getFileExtension(file.name);
+    if (!TRAINING_UPLOAD_EXTENSION_SET.has(extension)) {
+      toast.error("Unsupported file type", {
+        description: `Upload one ${TRAINING_UPLOAD_LABEL} file.`,
+      });
+      return;
+    }
 
-    const extension = file.name.slice(file.name.lastIndexOf(".")).toLowerCase();
     if (DOCUMENT_REDIRECT_EXTENSIONS.has(extension)) {
       setRedirectFileName(file.name);
       setDocumentRedirectOpen(true);
@@ -395,6 +424,44 @@ export function DatasetSection() {
     await handleFileUpload(file, selectLocalDataset, "Dataset uploaded");
   };
 
+  const handleDatasetFileChange = async (event: ChangeEvent<HTMLInputElement>) => {
+    const file = event.target.files?.[0];
+    event.target.value = "";
+    if (!file) return;
+
+    await handleDatasetFile(file);
+  };
+
+  const handleDatasetDrop = (event: DragEvent<HTMLButtonElement>) => {
+    event.preventDefault();
+    setIsDatasetDragOver(false);
+    if (isUploading) return;
+
+    const files = Array.from(event.dataTransfer.files);
+    if (files.length === 0) return;
+
+    if (files.length > 1) {
+      toast.error("Upload one file at a time", {
+        description: "Training dataset upload accepts a single file.",
+      });
+      return;
+    }
+
+    void handleDatasetFile(files[0]);
+  };
+
+  const handleDatasetDragOver = (event: DragEvent<HTMLButtonElement>) => {
+    event.preventDefault();
+    if (isUploading) return;
+
+    event.dataTransfer.dropEffect = "copy";
+    setIsDatasetDragOver(true);
+  };
+
+  const handleDatasetDragLeave = () => {
+    setIsDatasetDragOver(false);
+  };
+
   const handleEvalFileChange = async (event: ChangeEvent<HTMLInputElement>) => {
     const file = event.target.files?.[0];
     event.target.value = "";
@@ -924,7 +991,7 @@ export function DatasetSection() {
             </CollapsibleContent>
           </Collapsible>
 
-          <div className="flex flex-col gap-4 pt-1">
+          <div className="flex flex-col gap-3">
             {selectedDatasetName ? (
               <div className="flex items-center gap-3 rounded-lg border bg-muted/40 px-3.5 py-3">
                 <div className="rounded-md bg-indigo-500/10 p-1.5">
@@ -971,15 +1038,32 @@ export function DatasetSection() {
                 </Button>
               </div>
             ) : (
-              <div className="flex items-center gap-3 rounded-lg border border-dashed bg-muted/20 px-3.5 py-3">
+              <button
+                type="button"
+                className={`flex w-full cursor-pointer items-center gap-3 rounded-lg border border-dashed px-3.5 py-3 text-left transition-colors ${
+                  isDatasetDragOver
+                    ? "border-indigo-500/70 bg-indigo-500/10"
+                    : "border-border bg-muted/20 hover:border-indigo-500/50 hover:bg-indigo-500/5"
+                }`}
+                disabled={isUploading}
+                onClick={handleUploadButtonClick}
+                onDrop={handleDatasetDrop}
+                onDragOver={handleDatasetDragOver}
+                onDragLeave={handleDatasetDragLeave}
+              >
                 <HugeiconsIcon
-                  icon={Database02Icon}
-                  className="size-4 text-muted-foreground/40"
+                  icon={CloudUploadIcon}
+                  className="pointer-events-none size-4 shrink-0 text-indigo-500"
                 />
-                <span className="text-xs text-muted-foreground">
-                  No dataset selected
+                <span className="pointer-events-none min-w-0">
+                  <span className="block text-xs font-medium text-foreground">
+                    Drop 1 file here or click to upload
+                  </span>
+                  <span className="mt-0.5 block truncate text-[10px] text-muted-foreground">
+                    {TRAINING_UPLOAD_LABEL}
+                  </span>
                 </span>
-              </div>
+              </button>
             )}
 
             <div className="grid grid-cols-2 gap-2">
@@ -1012,7 +1096,7 @@ export function DatasetSection() {
           <input
             ref={fileInputRef}
             type="file"
-            accept=".json,.jsonl,.csv,.parquet,.pdf,.docx,.txt"
+            accept={TRAINING_UPLOAD_ACCEPT}
             className="hidden"
             onChange={(event) => {
               void handleDatasetFileChange(event);
diff --git a/studio/frontend/src/features/studio/studio-page.tsx b/studio/frontend/src/features/studio/studio-page.tsx
index 5c5e11907c..2affe7415a 100644
--- a/studio/frontend/src/features/studio/studio-page.tsx
+++ b/studio/frontend/src/features/studio/studio-page.tsx
@@ -127,8 +127,8 @@ export function StudioPage(): ReactElement {
   })();
 
   return (
-    <div className="relative min-h-screen bg-background">
-      <main className="relative z-10 mx-auto max-w-7xl px-4 py-4 sm:px-6">
+    <div className="relative min-h-[calc(100dvh-var(--studio-titlebar-height,0px))] bg-background">
+      <main className="relative z-10 mx-auto max-w-7xl px-4 py-8 sm:px-6">
         <GuidedTour {...tour.tourProps} celebrate={isConfigTour} />
 
         <DatasetPreviewDialog
@@ -209,6 +209,9 @@ export function StudioPage(): ReactElement {
                   } else {
                     setSelectedHistoryRunId(runId);
                   }
+                }} onResumeStarted={() => {
+                  setSelectedHistoryRunId(null);
+                  handleTabChange("current-run");
                 }} />
               )}
             </TabsContent>
diff --git a/studio/frontend/src/features/studio/training-start-overlay.tsx b/studio/frontend/src/features/studio/training-start-overlay.tsx
index b6042d4ae6..27c5a13163 100644
--- a/studio/frontend/src/features/studio/training-start-overlay.tsx
+++ b/studio/frontend/src/features/studio/training-start-overlay.tsx
@@ -64,6 +64,22 @@ const EMPTY_DOWNLOAD_STATE: DownloadState = {
   cachePath: null,
 };
 
+function coerceCachedStateReady(state: DownloadState): DownloadState {
+  if (!state.cachePath) return state;
+  if (state.downloadedBytes > 0 && state.percent < 100) return state;
+  const totalBytes =
+    state.totalBytes > 0 ? state.totalBytes : state.downloadedBytes;
+  if (totalBytes <= 0) {
+    return { ...state, percent: 100 };
+  }
+  return {
+    ...state,
+    downloadedBytes: totalBytes,
+    totalBytes,
+    percent: 100,
+  };
+}
+
 type Fetcher = (repoId: string) => Promise<DownloadProgressResponse>;
 
 /**
@@ -88,10 +104,12 @@ function useHfDownloadProgress(
     phase === "downloading_model" ||
     phase === "downloading_dataset" ||
     phase === "loading_model" ||
-    phase === "loading_dataset";
+    phase === "loading_dataset" ||
+    phase === "training";
 
   useEffect(() => {
     if (!repoId || !HF_REPO_REGEX.test(repoId) || !shouldPoll) {
+      setState(EMPTY_DOWNLOAD_STATE);
       return;
     }
 
@@ -229,14 +247,42 @@ export function TrainingStartOverlay({
 }: TrainingStartOverlayProps): ReactElement {
   const { stopTrainingRun, dismissTrainingRun } = useTrainingActions();
   const isStarting = useTrainingRuntimeStore((s) => s.isStarting);
-  const selectedModel = useTrainingConfigStore((s) => s.selectedModel);
+  const phase = useTrainingRuntimeStore((s) => s.phase);
+  const startModelName = useTrainingRuntimeStore((s) => s.startModelName);
+  const startDatasetName = useTrainingRuntimeStore((s) => s.startDatasetName);
+  const startFromResume = useTrainingRuntimeStore((s) => s.startFromResume);
+  const configuredModel = useTrainingConfigStore((s) => s.selectedModel);
   const datasetSource = useTrainingConfigStore((s) => s.datasetSource);
   const dataset = useTrainingConfigStore((s) => s.dataset);
   // Only HF datasets have a download phase to track. Uploaded files are
   // already on disk by the time the overlay shows up.
   const hfDatasetName = datasetSource === "huggingface" ? dataset : null;
-  const modelDownload = useModelDownloadProgress(selectedModel);
-  const datasetDownload = useDatasetDownloadProgress(hfDatasetName);
+  const hasStartResources = startModelName !== null;
+  const useConfiguredResources = !isStarting && !hasStartResources;
+  const isDownloadPhase =
+    phase === "downloading_model" || phase === "downloading_dataset";
+  const modelName = hasStartResources
+    ? startModelName
+    : useConfiguredResources
+      ? configuredModel
+      : null;
+  const datasetName = hasStartResources
+    ? startDatasetName
+    : useConfiguredResources
+      ? hfDatasetName
+      : null;
+  const displayMessage =
+    startFromResume && !isDownloadPhase && /^download/i.test(message)
+      ? "Resuming training..."
+      : message || "starting training...";
+  const rawModelDownload = useModelDownloadProgress(modelName);
+  const rawDatasetDownload = useDatasetDownloadProgress(datasetName);
+  const modelDownload = isDownloadPhase
+    ? rawModelDownload
+    : coerceCachedStateReady(rawModelDownload);
+  const datasetDownload = isDownloadPhase
+    ? rawDatasetDownload
+    : coerceCachedStateReady(rawDatasetDownload);
   const [cancelDialogOpen, setCancelDialogOpen] = useState(false);
   const [cancelRequested, setCancelRequested] = useState(false);
 
@@ -314,7 +360,7 @@ export function TrainingStartOverlay({
             {"> We are getting everything ready for your run..."}
           </TypingAnimation>
           <AnimatedSpan className="mt-2 text-muted-foreground">
-            {`> ${message || "starting training..."} | waiting for first step... (${currentStep})`}
+            {`> ${displayMessage} | waiting for first step... (${currentStep})`}
           </AnimatedSpan>
           {datasetDownload.downloadedBytes > 0 || datasetDownload.cachePath ? (
             <AnimatedSpan className="mt-3">
diff --git a/studio/frontend/src/features/training/hooks/use-training-actions.ts b/studio/frontend/src/features/training/hooks/use-training-actions.ts
index b5b41e7a0d..deaec6c6c2 100644
--- a/studio/frontend/src/features/training/hooks/use-training-actions.ts
+++ b/studio/frontend/src/features/training/hooks/use-training-actions.ts
@@ -1,17 +1,20 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 // Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
 
+import { primeNativeNotificationPermission } from "@/lib/native-notifications";
 import { useCallback } from "react";
+import { toast } from "sonner";
 import { checkDatasetFormat } from "../api/datasets-api";
+import { getTrainingRun } from "../api/history-api";
 import { buildTrainingStartPayload } from "../api/mappers";
-import { startTraining, stopTraining, resetTraining } from "../api/train-api";
+import { resetTraining, startTraining, stopTraining } from "../api/train-api";
 import { syncTrainingRuntimeFromBackend } from "../lib/sync-runtime";
 import { validateTrainingConfig } from "../lib/validation";
 import { useDatasetPreviewDialogStore } from "../stores/dataset-preview-dialog-store";
 import { useTrainingConfigStore } from "../stores/training-config-store";
 import { useTrainingRuntimeStore } from "../stores/training-runtime-store";
+import type { TrainingStartRequest } from "../types/api";
 import type { TrainingConfigState } from "../types/config";
-import { toast } from "sonner";
 
 /** Chatml → format-specific role remap (only for formats that differ from chatml). */
 const ROLE_REMAP: Record<string, Record<string, string>> = {
@@ -48,6 +51,13 @@ export function useTrainingActions() {
       return false;
     }
 
+    primeNativeNotificationPermission().catch(() => undefined);
+
+    runtimeStore.setStartResources(
+      config.selectedModel ?? null,
+      getHfDatasetName(config),
+      false,
+    );
     runtimeStore.setStarting(true);
 
     try {
@@ -114,6 +124,7 @@ export function useTrainingActions() {
 
       // Re-read config after potential store updates from dataset check
       const payload = buildTrainingStartPayload(useTrainingConfigStore.getState());
+      runtimeStore.setStartResources(payload.model_name, payload.hf_dataset, false);
       const response = await startTraining(payload);
 
       if (response.status === "error") {
@@ -153,6 +164,56 @@ export function useTrainingActions() {
     }
   }, []);
 
+  const resumeTrainingRunFromHistory = useCallback(async (runId: string): Promise<boolean> => {
+    const runtimeStore = useTrainingRuntimeStore.getState();
+    runtimeStore.setStartError(null);
+    runtimeStore.setStartResources(null, null, true);
+    runtimeStore.setStarting(true);
+
+    try {
+      const detail = await getTrainingRun(runId);
+      const outputDir = detail.run.output_dir;
+      if (!detail.run.can_resume || !outputDir) {
+        throw new Error("Only stopped runs with a saved checkpoint can be resumed.");
+      }
+
+      primeNativeNotificationPermission().catch(() => undefined);
+
+      const config = useTrainingConfigStore.getState();
+      const savedConfig = detail.config as Partial<TrainingStartRequest>;
+      const payload = {
+        ...savedConfig,
+        hf_token:
+          typeof savedConfig.hf_token === "string"
+            ? savedConfig.hf_token
+            : config.hfToken.trim() || null,
+        wandb_token: null,
+        resume_from_checkpoint: outputDir,
+      } as TrainingStartRequest;
+
+      runtimeStore.setStartResources(payload.model_name, payload.hf_dataset, true);
+
+      const response = await startTraining(payload);
+      if (response.status === "error") {
+        throw new Error(response.error || response.message);
+      }
+
+      runtimeStore.setStartQueued(response.job_id, response.message);
+      await syncTrainingRuntimeFromBackend();
+      return true;
+    } catch (error) {
+      const rawMessage =
+        error instanceof Error ? error.message : "Failed to resume training";
+      const safeMessage = normalizeTrainingStartError(rawMessage);
+      runtimeStore.setStartError(safeMessage);
+      runtimeStore.setStarting(false);
+      toast.error("Could not resume training", {
+        description: safeMessage,
+      });
+      return false;
+    }
+  }, []);
+
   const dismissTrainingRun = useCallback(async (): Promise<void> => {
     try {
       await resetTraining();
@@ -173,6 +234,7 @@ export function useTrainingActions() {
     isStarting,
     startError,
     startTrainingRun,
+    resumeTrainingRunFromHistory,
     stopTrainingRun,
     dismissTrainingRun,
   };
@@ -184,6 +246,10 @@ function getDatasetName(config: TrainingConfigState): string | null {
     : config.uploadedFile;
 }
 
+function getHfDatasetName(config: TrainingConfigState): string | null {
+  return config.datasetSource === "huggingface" ? config.dataset : null;
+}
+
 function hasManualMapping(config: TrainingConfigState, isVlm = false, isAudio = false): boolean {
   const mapping = config.datasetManualMapping;
   const roles = new Set(Object.values(mapping));
diff --git a/studio/frontend/src/features/training/hooks/use-training-runtime-lifecycle.ts b/studio/frontend/src/features/training/hooks/use-training-runtime-lifecycle.ts
index 6e4c7c85b9..cd9e76ede9 100644
--- a/studio/frontend/src/features/training/hooks/use-training-runtime-lifecycle.ts
+++ b/studio/frontend/src/features/training/hooks/use-training-runtime-lifecycle.ts
@@ -2,6 +2,11 @@
 // Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
 
 import { hasAuthToken } from "@/features/auth";
+import {
+  notifyNative,
+  safeNotificationLabel,
+  sanitizeNotificationBody,
+} from "@/lib/native-notifications";
 import { useEffect } from "react";
 import {
   getTrainingMetrics,
@@ -9,6 +14,7 @@ import {
   isAbortError,
   streamTrainingProgress,
 } from "../api/train-api";
+import { useTrainingConfigStore } from "../stores/training-config-store";
 import { useTrainingRuntimeStore } from "../stores/training-runtime-store";
 import type { TrainingRuntimeStore } from "../types/runtime";
 
@@ -16,11 +22,78 @@ const STATUS_POLL_INTERVAL_MS = 3000;
 const METRICS_POLL_INTERVAL_MS = 5000;
 const IDLE_POLL_INTERVAL_MS = 30000;
 const STREAM_RECONNECT_DELAY_MS = 1500;
+const GENERIC_TRAINING_STREAM_ERROR = "Training stream error";
+const DEFAULT_TRAINING_ERROR_BODY = "Your training run stopped with an error.";
 
 function shouldUseLiveSync(state: TrainingRuntimeStore): boolean {
   return state.isTrainingRunning || state.phase === "training";
 }
 
+function getTrainingErrorBody(state: TrainingRuntimeStore): string {
+  return sanitizeNotificationBody(
+    state.error ?? state.message,
+    DEFAULT_TRAINING_ERROR_BODY,
+  );
+}
+
+function shouldNotifyTrainingError(
+  before: TrainingRuntimeStore,
+  after: TrainingRuntimeStore,
+): boolean {
+  if (after.phase !== "error") {
+    return false;
+  }
+  if (before.phase !== "error" || before.jobId !== after.jobId) {
+    return true;
+  }
+  if (before.error !== GENERIC_TRAINING_STREAM_ERROR) {
+    return false;
+  }
+
+  return getTrainingErrorBody(before) !== getTrainingErrorBody(after);
+}
+
+function maybeNotifyTrainingTerminalTransition(
+  before: TrainingRuntimeStore,
+  after: TrainingRuntimeStore,
+): void {
+  if (!after.jobId) {
+    return;
+  }
+  if (
+    before.stopRequested ||
+    after.stopRequested ||
+    after.phase === "stopped"
+  ) {
+    return;
+  }
+
+  const sameJob = before.jobId === after.jobId;
+  const samePhase = before.phase === after.phase;
+
+  if (after.phase === "completed" && !(sameJob && samePhase)) {
+    const model = safeNotificationLabel(
+      after.startModelName ?? useTrainingConfigStore.getState().selectedModel,
+      "Your training run",
+    );
+    notifyNative({
+      key: `training-completed:${after.jobId}`,
+      title: "Training finished",
+      body: `${model} is complete.`,
+      requestPermission: false,
+    }).catch(() => undefined);
+  }
+
+  if (shouldNotifyTrainingError(before, after)) {
+    notifyNative({
+      key: `training-error:${after.jobId}`,
+      title: "Training failed",
+      body: getTrainingErrorBody(after),
+      requestPermission: false,
+    }).catch(() => undefined);
+  }
+}
+
 export function useTrainingRuntimeLifecycle(): void {
   useEffect(() => {
     let disposed = false;
@@ -62,7 +135,9 @@ export function useTrainingRuntimeLifecycle(): void {
       }
     };
 
-    const pollStatus = async () => {
+    const pollStatus = async (options?: {
+      suppressNativeNotifications?: boolean;
+    }) => {
       if (!hasAuthToken()) return;
       const gen = runtimeStore.getState().resetGeneration;
       try {
@@ -71,9 +146,13 @@ export function useTrainingRuntimeLifecycle(): void {
           return;
         }
 
+        const previousState = runtimeStore.getState();
         runtimeStore.getState().applyStatus(status);
 
         const nextState = runtimeStore.getState();
+        if (!options?.suppressNativeNotifications) {
+          maybeNotifyTrainingTerminalTransition(previousState, nextState);
+        }
         if (shouldUseLiveSync(nextState)) {
           void ensureStream();
         } else {
@@ -124,7 +203,7 @@ export function useTrainingRuntimeLifecycle(): void {
             }
 
             if (event.event === "error") {
-              liveStore.setRuntimeError("Training stream error");
+              liveStore.setRuntimeError(GENERIC_TRAINING_STREAM_ERROR);
               stopStream();
             }
           },
@@ -154,7 +233,10 @@ export function useTrainingRuntimeLifecycle(): void {
     const hydrate = async () => {
       runtimeStore.getState().setHydrating(true);
       try {
-        await Promise.all([pollStatus(), pollMetrics()]);
+        await Promise.all([
+          pollStatus({ suppressNativeNotifications: true }),
+          pollMetrics(),
+        ]);
       } finally {
         if (!disposed) {
           runtimeStore.getState().setHydrating(false);
@@ -172,7 +254,12 @@ export function useTrainingRuntimeLifecycle(): void {
 
     const statusTimer = setInterval(() => {
       const s = runtimeStore.getState();
-      if (isIdle() && s.hasHydrated) return;
+      if (!s.hasHydrated || s.isHydrating) {
+        return;
+      }
+      if (isIdle()) {
+        return;
+      }
       void pollStatus();
     }, STATUS_POLL_INTERVAL_MS);
 
@@ -187,7 +274,13 @@ export function useTrainingRuntimeLifecycle(): void {
     // Low-frequency background poll to recover from failed hydration or detect
     // out-of-band state changes (e.g. training started from another client).
     const idleTimer = setInterval(() => {
-      if (!isIdle()) return;
+      const s = runtimeStore.getState();
+      if (!s.hasHydrated || s.isHydrating) {
+        return;
+      }
+      if (!isIdle()) {
+        return;
+      }
       void pollStatus();
     }, IDLE_POLL_INTERVAL_MS);
 
diff --git a/studio/frontend/src/features/training/stores/training-runtime-store.ts b/studio/frontend/src/features/training/stores/training-runtime-store.ts
index d958078330..da496be002 100644
--- a/studio/frontend/src/features/training/stores/training-runtime-store.ts
+++ b/studio/frontend/src/features/training/stores/training-runtime-store.ts
@@ -22,6 +22,9 @@ const initialState: TrainingRuntimeState = {
   hasHydrated: false,
   isStarting: false,
   startError: null,
+  startModelName: null,
+  startDatasetName: null,
+  startFromResume: false,
   sseConnected: false,
   firstStepReceived: false,
   lastEventId: null,
@@ -35,6 +38,7 @@ const initialState: TrainingRuntimeState = {
   etaSeconds: null,
   currentGradNorm: null,
   currentNumTokens: null,
+  outputDir: null,
   lossHistory: [],
   lrHistory: [],
   gradNormHistory: [],
@@ -120,6 +124,8 @@ export const useTrainingRuntimeStore = create<TrainingRuntimeStore>()((set) => (
   setHasHydrated: (value) => set({ hasHydrated: value }),
   setStarting: (value) => set({ isStarting: value }),
   setStartError: (value) => set({ startError: value }),
+  setStartResources: (startModelName, startDatasetName, startFromResume = false) =>
+    set({ startModelName, startDatasetName, startFromResume }),
   setSseConnected: (value) => set({ sseConnected: value }),
   setLastEventId: (value) => set({ lastEventId: value }),
 
@@ -156,6 +162,7 @@ export const useTrainingRuntimeStore = create<TrainingRuntimeStore>()((set) => (
       etaSeconds: null,
       currentGradNorm: null,
       currentNumTokens: null,
+      outputDir: null,
       lossHistory: [],
       lrHistory: [],
       gradNormHistory: [],
@@ -207,6 +214,7 @@ export const useTrainingRuntimeStore = create<TrainingRuntimeStore>()((set) => (
           typeof detailLr === "number" ? detailLr : state.currentLearningRate,
         currentEpoch:
           typeof detailEpoch === "number" ? detailEpoch : state.currentEpoch,
+        outputDir: payload.details?.output_dir ?? state.outputDir,
         lossHistory: metricHistory.lossHistory ?? state.lossHistory,
         lrHistory: metricHistory.lrHistory ?? state.lrHistory,
         gradNormHistory: metricHistory.gradNormHistory ?? state.gradNormHistory,
diff --git a/studio/frontend/src/features/training/types/api.ts b/studio/frontend/src/features/training/types/api.ts
index 1d72e9d9d8..ae65d1a53c 100644
--- a/studio/frontend/src/features/training/types/api.ts
+++ b/studio/frontend/src/features/training/types/api.ts
@@ -54,6 +54,7 @@ export interface TrainingStartRequest {
   wandb_project: string | null;
   enable_tensorboard: boolean;
   tensorboard_dir: string | null;
+  resume_from_checkpoint?: string | null;
 }
 
 export interface TrainingStartResponse {
diff --git a/studio/frontend/src/features/training/types/history.ts b/studio/frontend/src/features/training/types/history.ts
index 8b89db539b..901dfe3266 100644
--- a/studio/frontend/src/features/training/types/history.ts
+++ b/studio/frontend/src/features/training/types/history.ts
@@ -12,6 +12,8 @@ export interface TrainingRunSummary {
   final_step: number | null;
   final_loss: number | null;
   output_dir: string | null;
+  can_resume: boolean;
+  resumed_later: boolean;
   duration_seconds: number | null;
   error_message: string | null;
   loss_sparkline: number[] | null;
diff --git a/studio/frontend/src/features/training/types/runtime.ts b/studio/frontend/src/features/training/types/runtime.ts
index 3e4dbd3b79..a62ef9ef26 100644
--- a/studio/frontend/src/features/training/types/runtime.ts
+++ b/studio/frontend/src/features/training/types/runtime.ts
@@ -26,6 +26,7 @@ export interface TrainingStatusResponse {
     total_steps?: number;
     loss?: number;
     learning_rate?: number;
+    output_dir?: string;
   } | null;
   metric_history?: {
     steps?: number[];
@@ -80,6 +81,9 @@ export interface TrainingRuntimeState {
   hasHydrated: boolean;
   isStarting: boolean;
   startError: string | null;
+  startModelName: string | null;
+  startDatasetName: string | null;
+  startFromResume: boolean;
   sseConnected: boolean;
   firstStepReceived: boolean;
   lastEventId: number | null;
@@ -93,6 +97,7 @@ export interface TrainingRuntimeState {
   etaSeconds: number | null;
   currentGradNorm: number | null;
   currentNumTokens: number | null;
+  outputDir: string | null;
   lossHistory: TrainingSeriesPoint[];
   lrHistory: TrainingSeriesPoint[];
   gradNormHistory: TrainingSeriesPoint[];
@@ -108,6 +113,11 @@ export interface TrainingRuntimeActions {
   setHasHydrated: (value: boolean) => void;
   setStarting: (value: boolean) => void;
   setStartError: (value: string | null) => void;
+  setStartResources: (
+    modelName: string | null,
+    datasetName: string | null,
+    fromResume?: boolean,
+  ) => void;
   setSseConnected: (value: boolean) => void;
   setLastEventId: (value: number | null) => void;
   resetRuntime: () => void;
@@ -131,6 +141,7 @@ export interface TrainingViewData {
   currentGradNorm: number | null;
   currentEpoch: number | null;
   currentNumTokens: number | null;
+  outputDir: string | null;
   progressPercent: number;
   elapsedSeconds: number | null;
   etaSeconds: number | null;
diff --git a/studio/frontend/src/hooks/use-tauri-backend.ts b/studio/frontend/src/hooks/use-tauri-backend.ts
index ed697fe31e..6bbbdb91f9 100644
--- a/studio/frontend/src/hooks/use-tauri-backend.ts
+++ b/studio/frontend/src/hooks/use-tauri-backend.ts
@@ -3,6 +3,10 @@
 
 import { useEffect, useState, useCallback, useRef } from "react";
 import { isTauri, setApiBase } from "@/lib/api-base";
+import {
+  copySupportDiagnostics,
+  type CopySupportDiagnosticsResult,
+} from "@/lib/tauri-diagnostics";
 import {
   clearTauriAuthFailure,
   getTauriAuthFailure,
@@ -35,6 +39,54 @@ interface DesktopPreflightResult {
   managed_bin: string | null;
 }
 
+const MANAGED_STARTUP_TIMEOUT_MS = 5 * 60_000;
+const MANAGED_STARTUP_POLL_MS = 500;
+
+type TauriInvoke = typeof import("@tauri-apps/api/core").invoke;
+type ManagedStartupResult =
+  | { status: "ready"; port: number }
+  | { status: "aborted" }
+  | { status: "missing-port" }
+  | { status: "unhealthy" };
+
+function wait(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function waitForManagedServerReady(
+  invoke: TauriInvoke,
+  getPort: () => number | null,
+  shouldContinue: () => boolean,
+): Promise<ManagedStartupResult> {
+  const deadline = Date.now() + MANAGED_STARTUP_TIMEOUT_MS;
+
+  while (Date.now() < deadline) {
+    if (!shouldContinue()) {
+      return { status: "aborted" };
+    }
+
+    const port = getPort();
+    if (port === null) {
+      await wait(MANAGED_STARTUP_POLL_MS);
+      continue;
+    }
+
+    const healthy = await invoke<boolean>("check_health", { port });
+    if (!shouldContinue()) {
+      return { status: "aborted" };
+    }
+    if (healthy && getPort() === port) {
+      return { status: "ready", port };
+    }
+
+    await wait(MANAGED_STARTUP_POLL_MS);
+  }
+
+  return getPort() === null
+    ? { status: "missing-port" }
+    : { status: "unhealthy" };
+}
+
 export function useTauriBackend() {
   const [status, setStatus] = useState<BackendStatus>("checking");
   const statusRef = useRef<BackendStatus>(status);
@@ -181,8 +233,11 @@ export function useTauriBackend() {
 
   async function startManagedServer() {
     // Prevent double-start race condition
-    if (startingRef.current) return;
+    if (startingRef.current) {
+      return;
+    }
     startingRef.current = true;
+    portRef.current = null;
 
     try {
       const { invoke } = await import("@tauri-apps/api/core");
@@ -192,23 +247,27 @@ export function useTauriBackend() {
 
       // Wait for the owned backend's server-port event. Do not attach to an
       // external backend if the managed start does not report a port.
-      for (let i = 0; i < 120; i++) {
-        if (portRef.current) {
-          const healthy = await invoke<boolean>("check_health", {
-            port: portRef.current,
-          });
-          if (healthy) {
-            setApiBase(portRef.current);
-            setRunningStatus();
-            startingRef.current = false;
-            return;
-          }
-        }
-        await new Promise((r) => setTimeout(r, 500));
+      const startupResult = await waitForManagedServerReady(
+        invoke,
+        () => portRef.current,
+        () => startingRef.current,
+      );
+
+      if (startupResult.status === "ready") {
+        setApiBase(startupResult.port);
+        setRunningStatus();
+        startingRef.current = false;
+        return;
       }
-      const message = !portRef.current
-        ? "Managed server started without reporting a port. Check the logs for details."
-        : "Server started but is not responding. Check the logs for details.";
+
+      if (startupResult.status === "aborted") {
+        return;
+      }
+
+      const message =
+        startupResult.status === "missing-port"
+          ? "Managed server started without reporting a port. Check the logs for details."
+          : "Server started but is not responding. Check the logs for details.";
       setBackendError(message);
     } catch (e) {
       const msg = String(e);
@@ -283,9 +342,11 @@ export function useTauriBackend() {
     const { invoke } = await import("@tauri-apps/api/core");
     try {
       await invoke("start_install");
-      // Install completed — this is the ONLY path that starts the server
-      // after install. The install-complete event listener does NOT call
-      // startServer() to avoid a double-start race condition.
+      // Install completed — start the managed backend we just installed.
+      // Do not run the general preflight here: it can attach to an unrelated
+      // already-running CLI/backend server before launching our managed one.
+      // The install-complete event listener does NOT call startServer() to
+      // avoid a double-start race condition.
       setBackendStatus("starting");
       elevationResumeRef.current = null;
       await startServer();
@@ -315,8 +376,16 @@ export function useTauriBackend() {
     checkInstallAndStart();
   }, []);
 
-  const retryInstall = useCallback(() => {
+  const retryInstall = useCallback(async () => {
     const resume = elevationResumeRef.current;
+    if (resume) {
+      try {
+        const { invoke } = await import("@tauri-apps/api/core");
+        await invoke("cancel_pending_elevation");
+      } catch (error) {
+        console.warn("Failed to record elevation cancellation", error);
+      }
+    }
     elevationResumeRef.current = null;
     clearBackendError();
     setLogs([]);
@@ -347,6 +416,31 @@ export function useTauriBackend() {
     }
   }, [elevationPackages]);
 
+  const copyDiagnostics = useCallback((): Promise<CopySupportDiagnosticsResult> => {
+    const currentStatus = statusRef.current;
+    const flow =
+      currentStatus === "repairing" ||
+      currentStatus === "repair-error" ||
+      (currentStatus === "needs-elevation" && elevationResumeRef.current === "repair")
+        ? "repair"
+        : currentStatus === "installing" ||
+            currentStatus === "install-error" ||
+            currentStatus === "not-installed" ||
+            currentStatus === "needs-elevation"
+          ? "install"
+          : "backend";
+
+    return copySupportDiagnostics({
+      status: currentStatus,
+      error,
+      currentStepIndex,
+      progressDetail,
+      elevationPackages,
+      lastUiLogLines: logs,
+      flow,
+    });
+  }, [currentStepIndex, elevationPackages, error, logs, progressDetail]);
+
   // Initial check on mount (guarded against Strict Mode double-mount)
   useEffect(() => {
     if (mountedRef.current) return;
@@ -482,6 +576,6 @@ export function useTauriBackend() {
     status, logs, error, isExternalServer,
     currentStepIndex, progressDetail, elevationPackages,
     startServer, stopServer, startInstall,
-    retry, retryInstall, approveElevation,
+    retry, retryInstall, approveElevation, copyDiagnostics,
   };
 }
diff --git a/studio/frontend/src/hooks/use-tauri-update.ts b/studio/frontend/src/hooks/use-tauri-update.ts
index 5863ef7aa5..67f9bf4c77 100644
--- a/studio/frontend/src/hooks/use-tauri-update.ts
+++ b/studio/frontend/src/hooks/use-tauri-update.ts
@@ -3,6 +3,10 @@
 
 import { useEffect, useRef, useState } from "react";
 import { isTauri } from "@/lib/api-base";
+import {
+  copySupportDiagnostics,
+  type CopySupportDiagnosticsResult,
+} from "@/lib/tauri-diagnostics";
 import { toast } from "sonner";
 
 export type UpdateStatus =
@@ -21,19 +25,74 @@ export interface UpdateInfo {
   date?: string;
 }
 
+export type UpdatePhase =
+  | "backend"
+  | "shell_download"
+  | "shell_install"
+  | "recovered_after_shell_failure";
+
+export interface RetainedUpdateFailure {
+  error: string;
+  phase: UpdatePhase;
+  progress: number;
+  logs: string[];
+}
+
 export function useTauriUpdate(isExternalServer = false) {
   const [status, setStatus] = useState<UpdateStatus>("idle");
   const [info, setInfo] = useState<UpdateInfo | null>(null);
   const [progress, setProgress] = useState(0);
+  const progressRef = useRef(0);
   const [logs, setLogs] = useState<string[]>([]);
+  const logsRef = useRef<string[]>([]);
+  const [phase, setPhase] = useState<UpdatePhase | null>(null);
+  const phaseRef = useRef<UpdatePhase | null>(null);
   const [dismissed, setDismissed] = useState(false);
   const [error, setError] = useState<string | null>(null);
+  const [lastFailure, setLastFailure] = useState<RetainedUpdateFailure | null>(null);
   const updateRef = useRef<Awaited<
     ReturnType<typeof import("@tauri-apps/plugin-updater").check>
   > | null>(null);
   const checkedRef = useRef(false);
   const updatingRef = useRef(false);
 
+  function replaceLogs(nextLogs: string[]) {
+    logsRef.current = nextLogs;
+    setLogs(nextLogs);
+  }
+
+  function appendLog(line: string) {
+    setLogs((prev) => {
+      const next = [...prev.slice(-499), line];
+      logsRef.current = next;
+      return next;
+    });
+  }
+
+  function setUpdateProgress(nextProgress: number) {
+    progressRef.current = nextProgress;
+    setProgress(nextProgress);
+  }
+
+  function setUpdatePhase(nextPhase: UpdatePhase | null) {
+    phaseRef.current = nextPhase;
+    setPhase(nextPhase);
+  }
+
+  function retainFailure(
+    nextError: string,
+    nextPhase: UpdatePhase = phaseRef.current ?? "backend",
+  ) {
+    const failure = {
+      error: nextError,
+      phase: nextPhase,
+      progress: progressRef.current,
+      logs: logsRef.current,
+    };
+    setLastFailure(failure);
+    return failure;
+  }
+
   useEffect(() => {
     if (!isTauri || checkedRef.current) return;
     checkedRef.current = true;
@@ -71,13 +130,15 @@ export function useTauriUpdate(isExternalServer = false) {
     updatingRef.current = true;
 
     const cleanups: (() => void)[] = [];
-    let phase: "backend" | "shell" = "backend";
 
     try {
       // ── Step 1: Backend update ──
+      setUpdatePhase("backend");
       setStatus("updating-backend");
-      setLogs([]);
+      replaceLogs([]);
+      setUpdateProgress(0);
       setError(null);
+      setLastFailure(null);
       setDismissed(false);
 
       const { listen } = await import("@tauri-apps/api/event");
@@ -87,7 +148,7 @@ export function useTauriUpdate(isExternalServer = false) {
       const unlistenProgress = await listen<string>(
         "update-progress",
         (e) => {
-          setLogs((prev) => [...prev.slice(-499), e.payload]);
+          appendLog(e.payload);
         },
       );
       cleanups.push(unlistenProgress);
@@ -107,6 +168,7 @@ export function useTauriUpdate(isExternalServer = false) {
       );
 
       if (backendResult !== "complete") {
+        retainFailure(backendResult, "backend");
         setError(backendResult);
         setStatus("error");
         updatingRef.current = false;
@@ -115,9 +177,9 @@ export function useTauriUpdate(isExternalServer = false) {
       }
 
       // ── Step 2: Shell update ──
-      phase = "shell";
+      setUpdatePhase("shell_download");
       setStatus("downloading");
-      setProgress(0);
+      setUpdateProgress(0);
 
       let downloaded = 0;
       let contentLength = 0;
@@ -129,10 +191,11 @@ export function useTauriUpdate(isExternalServer = false) {
           case "Progress":
             downloaded += event.data.chunkLength;
             if (contentLength > 0) {
-              setProgress(Math.round((downloaded / contentLength) * 100));
+              setUpdateProgress(Math.round((downloaded / contentLength) * 100));
             }
             break;
           case "Finished":
+            setUpdatePhase("shell_install");
             setStatus("installing");
             break;
         }
@@ -146,21 +209,26 @@ export function useTauriUpdate(isExternalServer = false) {
       const msg = String(e);
 
       // Shell update failed — restart backend on updated code
-      if (phase === "shell") {
+      if (phaseRef.current === "shell_download" || phaseRef.current === "shell_install") {
         try {
           const { invoke } = await import("@tauri-apps/api/core");
           await invoke("start_server", { port: 8888 });
+          retainFailure(msg, "recovered_after_shell_failure");
           toast.error("App update failed", {
             description:
-              "Backend was updated. The app update will be retried on next launch.",
+              "Backend was updated. Copy diagnostics from the update banner if you need support.",
           });
+          setError(null);
           setStatus("idle");
-          setDismissed(true);
+          setDismissed(false);
+          setUpdatePhase("recovered_after_shell_failure");
         } catch {
+          retainFailure(msg, phaseRef.current ?? "shell_install");
           setError(msg);
           setStatus("error");
         }
       } else {
+        retainFailure(msg, phaseRef.current ?? "backend");
         setError(msg);
         setStatus("error");
       }
@@ -176,15 +244,23 @@ export function useTauriUpdate(isExternalServer = false) {
   }
 
   async function skipAndRestart() {
+    const skippedError = error;
     try {
       const { invoke } = await import("@tauri-apps/api/core");
       await invoke("start_server", { port: 8888 });
+      if (skippedError) {
+        retainFailure(skippedError, phaseRef.current ?? "recovered_after_shell_failure");
+        setDismissed(false);
+      } else {
+        setDismissed(true);
+      }
       setStatus("idle");
       setError(null);
-      setLogs([]);
-      setDismissed(true);
+      replaceLogs([]);
     } catch (e) {
-      setError(String(e));
+      const msg = String(e);
+      retainFailure(msg, phaseRef.current ?? "backend");
+      setError(msg);
       setStatus("error");
     }
   }
@@ -193,6 +269,18 @@ export function useTauriUpdate(isExternalServer = false) {
     setDismissed(true);
   }
 
+  function copyDiagnostics(): Promise<CopySupportDiagnosticsResult> {
+    const failure = lastFailure;
+    return copySupportDiagnostics({
+      status: failure ? "error" : status,
+      error: failure?.error ?? error,
+      lastUiLogLines: failure?.logs ?? logs,
+      flow: "update",
+      updatePhase: failure?.phase ?? phase,
+      updateProgress: failure?.progress ?? progress,
+    });
+  }
+
   return {
     status,
     info,
@@ -200,11 +288,14 @@ export function useTauriUpdate(isExternalServer = false) {
     logs,
     dismissed,
     error,
+    phase,
+    lastFailure,
     isExternalServer,
     installUpdate,
     retryUpdate,
     skipAndRestart,
     dismiss,
+    copyDiagnostics,
   };
 }
 
diff --git a/studio/frontend/src/lib/api-base.ts b/studio/frontend/src/lib/api-base.ts
index 664b9e58bd..c8be442653 100644
--- a/studio/frontend/src/lib/api-base.ts
+++ b/studio/frontend/src/lib/api-base.ts
@@ -8,6 +8,12 @@ if (isTauri && !isViteDev) {
   apiBase = 'http://127.0.0.1:8888'
 }
 
+const initialApiBase = apiBase
+
+export function resetApiBase() {
+  apiBase = initialApiBase
+}
+
 export function setApiBase(port: number) {
   apiBase = `http://127.0.0.1:${port}`
 }
diff --git a/studio/frontend/src/lib/latex.ts b/studio/frontend/src/lib/latex.ts
index 954d0f7bc6..0092d51be0 100644
--- a/studio/frontend/src/lib/latex.ts
+++ b/studio/frontend/src/lib/latex.ts
@@ -74,12 +74,126 @@ function isInCodeBlock(
   return false;
 }
 
+/**
+ * A token (no whitespace) that looks purely like currency, e.g. `5`,
+ * `1,000`, `5.99`, `100K`, `3.5M`.
+ */
+const CURRENCY_BODY_RE = /^\d+(?:,\d{3})*(?:\.\d+)?[KMBkmb]?$/;
+
+/** Body characters that almost always indicate real LaTeX. */
+const LATEX_CHAR_RE = /[\\^_{}]/;
+
+/**
+ * Operators that strongly suggest a math expression. We deliberately
+ * leave out `^` and `_` because `LATEX_CHAR_RE` already short-circuits
+ * on those before we ever consult this regex.
+ */
+const MATH_OP_RE = /[=+\-<>/*]/;
+
+/**
+ * Trailing chars stripped before the currency check. Includes prose
+ * punctuation plus the connectors `-` and `/` that appear in compact
+ * currency ranges like `$5-$10` or `$5/$10`; without them the body
+ * `5-` or `5/` would slip through the single-token math shortcut.
+ */
+const TRAIL_PUNCT_RE = /[.,;:!?\-/]+$/;
+
+/**
+ * A standalone single letter (variable name) inside the body. We require
+ * that the letter is not part of a longer word so that prose like
+ * "5 to attend" doesn't get misread as a math expression with the
+ * variable `t`.
+ */
+const LONE_LETTER_RE = /(?<![a-zA-Z])[a-zA-Z](?![a-zA-Z])/;
+
+/**
+ * Numeric or single-letter operands joined by math operators, with
+ * optional whitespace. Matches `2 + 2`, `100 < 200`, `1,000 - 500`,
+ * `2.5 * 3`, `x + y`. Lets us recognise numeric-only expressions like
+ * `$2 + 2$` as math without forcing a lone variable token.
+ */
+const SIMPLE_MATH_RE =
+  /^(?:\d+(?:,\d{3})*(?:\.\d+)?|[a-zA-Z])(?:\s*[=+\-<>/*]\s*(?:\d+(?:,\d{3})*(?:\.\d+)?|[a-zA-Z]))+$/;
+
+/**
+ * Return true if the substring between two `$` delimiters looks like a
+ * LaTeX expression rather than a span of prose between two currency
+ * tokens.
+ *
+ * Rule of thumb:
+ *   - `$30^\circ$`  -> math (LaTeX chars)
+ *   - `$x$`         -> math (single non-currency token)
+ *   - `$90 - x$`    -> math (math op + lone variable)
+ *   - `$5 to $10`   -> NOT math (multi-token prose, no math op)
+ *   - `$5, $10`     -> NOT math (currency-like token + trailing punct)
+ *   - `$1,000$`     -> NOT math (single currency-like token)
+ */
+function looksLikeMathBody(body: string): boolean {
+  if (LATEX_CHAR_RE.test(body)) return true;
+  const trimmed = body.trim().replace(TRAIL_PUNCT_RE, "");
+  if (!trimmed) return false;
+  if (CURRENCY_BODY_RE.test(trimmed)) return false;
+  // Numeric-only operator forms: `2 + 2`, `100 < 200`, `1,000 - 500`.
+  // Recognised without requiring a lone-variable letter.
+  if (SIMPLE_MATH_RE.test(trimmed)) return true;
+  if (!/\s/.test(trimmed)) return true;
+  if (!MATH_OP_RE.test(trimmed)) return false;
+  return LONE_LETTER_RE.test(trimmed);
+}
+
+/**
+ * Return true if the `$` at `offset` opens a balanced inline math span
+ * (`$...$`) on the same line. The closer must be unescaped, must not be
+ * part of `$$`, and must lie inside a 200-character window. The body
+ * must look like LaTeX so we don't pair two currency tokens that share
+ * a line (e.g. "$5 to $10"). Bold-wrapped spans (`**$X$**` and the
+ * underscore equivalent `__$X$__`) are always treated as math because
+ * LLMs reach for that pattern when they want "bold math" and the
+ * heuristic would otherwise reject prose-shaped bodies like "90 - x".
+ */
+function hasInlineMathCloser(content: string, offset: number): boolean {
+  const MAX_SPAN = 200;
+  const limit = Math.min(content.length, offset + 1 + MAX_SPAN);
+  for (let i = offset + 1; i < limit; i++) {
+    const c = content[i];
+    if (c === "\n") return false;
+    if (c !== "$") continue;
+    if (content[i - 1] === "\\") continue;
+    if (content[i + 1] === "$") {
+      i++;
+      continue;
+    }
+    // A `$` immediately followed by a digit is far more likely the start
+    // of another currency token than the closer for the current span. Keep
+    // scanning so prose like `Starts at $5 + a $10 add-on` doesn't pair
+    // the two currency markers as a math span.
+    if (/\d/.test(content[i + 1] ?? "")) {
+      continue;
+    }
+    if (offset >= 2) {
+      const op = content[offset - 1];
+      if (
+        (op === "*" || op === "_") &&
+        content[offset - 2] === op &&
+        content[i + 1] === op &&
+        content[i + 2] === op
+      ) {
+        return true;
+      }
+    }
+    return looksLikeMathBody(content.slice(offset + 1, i));
+  }
+  return false;
+}
+
 /**
  * Preprocess a markdown string to escape currency dollar signs so they are not
  * parsed as LaTeX math delimiters.
  *
  * - `$5` alone becomes `\$5` (currency, not math)
  * - `$\alpha$` is untouched (real LaTeX)
+ * - `$30^\circ$` is untouched (LaTeX whose body starts with a digit)
+ * - `**$30^\circ$**` is untouched (LaTeX wrapped in bold)
  * - `$$E = mc^2$$` is untouched (display math)
  * - Currency inside code blocks/spans is untouched
  */
@@ -92,6 +206,9 @@ export function preprocessLaTeX(content: string): string {
     if (isInCodeBlock(offset, codeRegions)) {
       return match;
     }
+    if (hasInlineMathCloser(content, offset)) {
+      return match;
+    }
     return "\\" + match;
   });
 }
diff --git a/studio/frontend/src/lib/native-notifications.ts b/studio/frontend/src/lib/native-notifications.ts
new file mode 100644
index 0000000000..641421f6ea
--- /dev/null
+++ b/studio/frontend/src/lib/native-notifications.ts
@@ -0,0 +1,234 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+import { isTauri } from "@/lib/api-base";
+
+const MAX_BODY_LENGTH = 200;
+const MAX_SENT_KEYS = 200;
+const HF_TOKEN_PATTERN = /\bhf_[A-Za-z0-9]{20,}\b/g;
+const GITHUB_TOKEN_PATTERN = /\bghp_[A-Za-z0-9_]{20,}\b/g;
+const GITHUB_PAT_PATTERN = /\bgithub_pat_[A-Za-z0-9_]{20,}\b/g;
+const OPENAI_KEY_PATTERN = /\bsk-[A-Za-z0-9_-]{20,}\b/g;
+const UNIX_HOME_PATH_PATTERN =
+  /(^|[\s"'(=])(?:\/Users|\/home)\/[^\s"'<>),;]+/gi;
+const UNIX_ABSOLUTE_PATH_PATTERN = /(^|[\s"'(=])\/[^\s"'<>),;]+/g;
+const TILDE_PATH_PATTERN = /(^|[\s"'(=])~[\\/][^\s"'<>),;]+/g;
+const RELATIVE_PATH_PATTERN = /(^|[\s"'(=])\.{1,2}[\\/][^\s"'<>),;]+/g;
+const WINDOWS_DRIVE_PATH_PATTERN = /(^|[\s"'(=])[A-Za-z]:[\\/][^\s"'<>),;]+/g;
+const WINDOWS_UNC_PATH_PATTERN = /(^|[\s"'(=])\\\\[^\s"'<>),;]+/g;
+const WHITESPACE_PATTERN = /\s+/g;
+const LOCAL_PATH_PATTERN = /^(?:\/|~[\\/]|\.{1,2}[\\/]|[A-Za-z]:[\\/]|\\\\)/;
+const PATH_SEPARATOR_PATTERN = /[\\/]/;
+const SENSITIVE_TOKEN_PATTERN =
+  /\bhf_[A-Za-z0-9]{20,}\b|\bghp_[A-Za-z0-9_]{20,}\b|\bgithub_pat_[A-Za-z0-9_]{20,}\b|\bsk-[A-Za-z0-9_-]{20,}\b/;
+
+type PermissionState = "unknown" | "granted" | "denied";
+
+let permissionState: PermissionState = "unknown";
+let permissionPrimeInFlight: Promise<void> | null = null;
+const inFlightKeys = new Set<string>();
+const sentKeys = new Set<string>();
+
+export interface NativeNotificationOptions {
+  key: string;
+  title: string;
+  body?: string;
+  requestPermission?: boolean;
+}
+
+function hasGrantedPermission(): boolean {
+  return permissionState === "granted";
+}
+
+function getBrowserNotificationApi(): typeof Notification | null {
+  if (typeof window === "undefined" || !("Notification" in window)) {
+    return null;
+  }
+
+  return window.Notification;
+}
+
+function rememberSentKey(key: string): void {
+  sentKeys.add(key);
+
+  if (sentKeys.size <= MAX_SENT_KEYS) {
+    return;
+  }
+
+  const oldestKey = sentKeys.values().next().value;
+  if (oldestKey) {
+    sentKeys.delete(oldestKey);
+  }
+}
+
+async function checkNativePermission(allowRequest: boolean): Promise<boolean> {
+  const notification = getBrowserNotificationApi();
+  if (notification?.permission === "granted") {
+    permissionState = "granted";
+    return true;
+  }
+
+  if (notification?.permission === "denied") {
+    permissionState = "denied";
+    return false;
+  }
+
+  if (allowRequest && notification?.permission === "default") {
+    const permission = await notification.requestPermission();
+    if (permission === "granted") {
+      permissionState = "granted";
+      return true;
+    }
+    if (permission === "denied") {
+      permissionState = "denied";
+    }
+    return false;
+  }
+
+  try {
+    const { isPermissionGranted } = await import(
+      "@tauri-apps/plugin-notification"
+    );
+    const granted = await isPermissionGranted();
+
+    if (granted) {
+      permissionState = "granted";
+    }
+
+    return granted;
+  } catch {
+    return false;
+  }
+}
+
+async function ensurePermission(allowRequest: boolean): Promise<boolean> {
+  if (!isTauri) {
+    return false;
+  }
+  if (permissionState !== "unknown") {
+    return hasGrantedPermission();
+  }
+
+  if (permissionPrimeInFlight) {
+    await permissionPrimeInFlight;
+    if (permissionState !== "unknown" || !allowRequest) {
+      return hasGrantedPermission();
+    }
+  }
+
+  return checkNativePermission(allowRequest);
+}
+
+export async function primeNativeNotificationPermission(): Promise<void> {
+  if (!isTauri || permissionState !== "unknown") {
+    return;
+  }
+
+  if (!permissionPrimeInFlight) {
+    permissionPrimeInFlight = checkNativePermission(true)
+      .then(() => undefined)
+      .finally(() => {
+        permissionPrimeInFlight = null;
+      });
+  }
+
+  await permissionPrimeInFlight;
+}
+
+export async function notifyNative(
+  options: NativeNotificationOptions,
+): Promise<void> {
+  if (!isTauri) {
+    return;
+  }
+  if (sentKeys.has(options.key) || inFlightKeys.has(options.key)) {
+    return;
+  }
+  inFlightKeys.add(options.key);
+
+  try {
+    const granted = await ensurePermission(options.requestPermission !== false);
+    if (!granted) {
+      return;
+    }
+
+    const body = options.body
+      ? sanitizeNotificationBody(options.body, "")
+      : undefined;
+    const { sendNotification } = await import(
+      "@tauri-apps/plugin-notification"
+    );
+    sendNotification({ title: options.title, body });
+    rememberSentKey(options.key);
+  } catch {
+    // Native notifications are non-critical UI side effects.
+  } finally {
+    inFlightKeys.delete(options.key);
+  }
+}
+
+export function sanitizeNotificationBody(
+  input: string | null | undefined,
+  fallback: string,
+): string {
+  const fallbackText = fallback.trim() || "Notification update.";
+  let text = typeof input === "string" ? input.trim() : "";
+
+  if (!text) {
+    text = fallbackText;
+  }
+
+  text = text
+    .replace(HF_TOKEN_PATTERN, "hf_[redacted]")
+    .replace(GITHUB_TOKEN_PATTERN, "ghp_[redacted]")
+    .replace(GITHUB_PAT_PATTERN, "github_pat_[redacted]")
+    .replace(OPENAI_KEY_PATTERN, "sk-[redacted]")
+    .replace(UNIX_HOME_PATH_PATTERN, "$1[path]")
+    .replace(UNIX_ABSOLUTE_PATH_PATTERN, "$1[path]")
+    .replace(TILDE_PATH_PATTERN, "$1[path]")
+    .replace(RELATIVE_PATH_PATTERN, "$1[path]")
+    .replace(WINDOWS_DRIVE_PATH_PATTERN, "$1[path]")
+    .replace(WINDOWS_UNC_PATH_PATTERN, "$1[path]")
+    .replace(WHITESPACE_PATTERN, " ")
+    .trim();
+
+  if (!text) {
+    text = fallbackText;
+  }
+
+  if (text.length > MAX_BODY_LENGTH) {
+    return `${text.slice(0, MAX_BODY_LENGTH - 1).trimEnd()}…`;
+  }
+
+  return text;
+}
+
+export function safeNotificationLabel(
+  input: string | null | undefined,
+  fallback: string,
+): string {
+  const fallbackText = fallback.trim() || "The item";
+  const raw = typeof input === "string" ? input.trim() : "";
+  if (!raw) {
+    return fallbackText;
+  }
+
+  const collapsed = raw.replace(WHITESPACE_PATTERN, " ");
+  const isLocalPath = LOCAL_PATH_PATTERN.test(collapsed);
+
+  if (isLocalPath) {
+    const basename =
+      collapsed.split(PATH_SEPARATOR_PATTERN).filter(Boolean).at(-1) ?? "";
+    if (
+      basename &&
+      basename !== "." &&
+      basename !== ".." &&
+      !SENSITIVE_TOKEN_PATTERN.test(basename)
+    ) {
+      return sanitizeNotificationBody(basename, fallbackText);
+    }
+    return fallbackText;
+  }
+
+  return sanitizeNotificationBody(collapsed, fallbackText);
+}
diff --git a/studio/frontend/src/lib/tauri-diagnostics.ts b/studio/frontend/src/lib/tauri-diagnostics.ts
new file mode 100644
index 0000000000..5c07931a86
--- /dev/null
+++ b/studio/frontend/src/lib/tauri-diagnostics.ts
@@ -0,0 +1,176 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+import { isTauri } from "@/lib/api-base";
+import { copyToClipboard } from "@/lib/copy-to-clipboard";
+
+export interface FrontendSupportSnapshot {
+  status?: string | null;
+  error?: string | null;
+  currentStepIndex?: number | null;
+  progressDetail?: string | null;
+  elevationPackages?: string[];
+  lastUiLogLines?: string[];
+  flow?: string | null;
+  updatePhase?: string | null;
+  updateProgress?: number | null;
+}
+
+export interface CopySupportDiagnosticsResult {
+  ok: boolean;
+  report: string;
+  error?: string;
+  source: "tauri" | "frontend-fallback";
+}
+
+const FALLBACK_LOG_LINE_LIMIT = 200;
+
+const ANSI_ESCAPE_PATTERN = new RegExp(
+  `${String.fromCharCode(27)}(?:[@-Z\\-_]|\\[[0-?]*[ -/]*[@-~])`,
+  "g",
+);
+
+function stripAnsi(text: string): string {
+  return text.replace(ANSI_ESCAPE_PATTERN, "");
+}
+
+export function redactDiagnosticsText(text: string): string {
+  let redacted = stripAnsi(text);
+
+  redacted = redacted.replace(
+    /-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?-----END [^-]*PRIVATE KEY-----/gi,
+    "<redacted-private-key>",
+  );
+  redacted = redacted.replace(
+    /([a-z][a-z0-9+.-]*:\/\/)([^/\s@]+)@/gi,
+    "$1<redacted>@",
+  );
+  redacted = redacted.replace(
+    /\b(authorization\s*[:=]\s*)(bearer|basic)\s+[^\s,;]+/gi,
+    "$1$2 <redacted>",
+  );
+  redacted = redacted.replace(/\bhf_[A-Za-z0-9]{20,}\b/g, "hf_<redacted>");
+  redacted = redacted.replace(/\bghp_[A-Za-z0-9_]{20,}\b/g, "ghp_<redacted>");
+  redacted = redacted.replace(/\bgithub_pat_[A-Za-z0-9_]{20,}\b/g, "github_pat_<redacted>");
+  redacted = redacted.replace(/\bsk-[A-Za-z0-9_-]{20,}\b/g, "sk-<redacted>");
+  redacted = redacted.replace(
+    /\b(cookie|set-cookie)\s*[:=]\s*[^\n\r]+/gi,
+    "$1=<redacted>",
+  );
+  redacted = redacted.replace(
+    /(^|[\s;])((?:[A-Z0-9]+_)*(?:TOKEN|KEY|SECRET|PASSWORD)(?:_[A-Z0-9]+)*\s*=\s*)[^\s]+/gi,
+    "$1$2<redacted>",
+  );
+
+  // Redact Studio paths before broader home-directory paths.
+  redacted = redacted.replace(
+    /(?:\/Users|\/home)\/[^\s/]+\/\.unsloth\/studio/gi,
+    "<studio_home>",
+  );
+  redacted = redacted.replace(
+    /[A-Z]:\\Users\\[^\s\\]+\\\.unsloth\\studio/gi,
+    "<studio_home>",
+  );
+  redacted = redacted.replace(/(?:\/Users|\/home)\/[^\s/]+/gi, "$HOME");
+  redacted = redacted.replace(/[A-Z]:\\Users\\[^\s\\]+/gi, "%USERPROFILE%");
+  redacted = redacted.replace(
+    /[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi,
+    "<redacted-email>",
+  );
+
+  return redacted;
+}
+
+function safeLines(lines: string[] | undefined): string[] {
+  return (lines ?? [])
+    .filter((line): line is string => typeof line === "string")
+    .slice(-FALLBACK_LOG_LINE_LIMIT);
+}
+
+function buildFrontendFallbackReport(
+  snapshot: FrontendSupportSnapshot,
+  invokeError: unknown,
+): string {
+  const lines = safeLines(snapshot.lastUiLogLines);
+  const report = [
+    "DEGRADED FRONTEND-ONLY DIAGNOSTICS",
+    "DEGRADED_FRONTEND_ONLY=true",
+    `createdAt=${new Date().toISOString()}`,
+    "reason=collect_support_diagnostics invoke failed",
+    `invokeError=${String(invokeError)}`,
+    `status=${snapshot.status ?? "unavailable"}`,
+    `flow=${snapshot.flow ?? "unknown"}`,
+    `error=${snapshot.error ?? ""}`,
+    `currentStepIndex=${snapshot.currentStepIndex ?? ""}`,
+    `progressDetail=${snapshot.progressDetail ?? ""}`,
+    `elevationPackages=${(snapshot.elevationPackages ?? []).join(",")}`,
+    `updatePhase=${snapshot.updatePhase ?? ""}`,
+    `updateProgress=${snapshot.updateProgress ?? ""}`,
+    "",
+    "lastUiLogLines:",
+    ...lines,
+    "",
+    "redaction=frontend_minimal_js_redaction_applied",
+    "collectionWarnings=Rust diagnostics command was unavailable; this fallback contains only bounded UI state/log lines.",
+  ].join("\n");
+
+  return redactDiagnosticsText(report);
+}
+
+async function collectDiagnosticsReport(
+  snapshot: FrontendSupportSnapshot,
+): Promise<{ report: string; source: CopySupportDiagnosticsResult["source"] }> {
+  if (!isTauri) {
+    return {
+      report: buildFrontendFallbackReport(snapshot, "not running in Tauri"),
+      source: "frontend-fallback",
+    };
+  }
+
+  try {
+    const { invoke } = await import("@tauri-apps/api/core");
+    const report = await invoke<string>("collect_support_diagnostics", {
+      snapshot,
+    });
+    return { report, source: "tauri" };
+  } catch (error) {
+    console.warn("collect_support_diagnostics failed; using frontend-only diagnostics", error);
+    return {
+      report: buildFrontendFallbackReport(snapshot, error),
+      source: "frontend-fallback",
+    };
+  }
+}
+
+async function copyWithTauriClipboard(text: string): Promise<boolean> {
+  if (!isTauri) return false;
+  try {
+    const { writeText } = await import("@tauri-apps/plugin-clipboard-manager");
+    await writeText(text);
+    return true;
+  } catch (error) {
+    console.warn("Tauri clipboard-manager writeText failed", error);
+    return false;
+  }
+}
+
+export async function copySupportDiagnostics(
+  snapshot: FrontendSupportSnapshot,
+): Promise<CopySupportDiagnosticsResult> {
+  const { report, source } = await collectDiagnosticsReport(snapshot);
+
+  if (await copyWithTauriClipboard(report)) {
+    return { ok: true, report, source };
+  }
+
+  if (await copyToClipboard(report)) {
+    return { ok: true, report, source };
+  }
+
+  return {
+    ok: false,
+    report,
+    source,
+    error: "Unable to write diagnostics to the clipboard. Select and copy the text manually.",
+  };
+}
diff --git a/studio/install_llama_prebuilt.py b/studio/install_llama_prebuilt.py
index 23e6b7c0e4..1aa3e501f8 100755
--- a/studio/install_llama_prebuilt.py
+++ b/studio/install_llama_prebuilt.py
@@ -2662,7 +2662,7 @@ def pick_windows_cuda_runtime(host: HostInfo) -> str | None:
     if not host.driver_cuda_version:
         return None
     major, minor = host.driver_cuda_version
-    if major > 13 or (major == 13 and minor >= 1):
+    if major > 13 or (major == 13):  # and minor >= 1):
         return "13.1"
     if major > 12 or (major == 12 and minor >= 4):
         return "12.4"
@@ -4470,7 +4470,7 @@ def validate_server(
                     ),
                     **windows_hidden_subprocess_kwargs(),
                 )
-                deadline = time.time() + 20
+                deadline = time.time() + 60
                 startup_started = time.time()
                 response_body = ""
                 last_error: Exception | None = None
diff --git a/studio/install_python_stack.py b/studio/install_python_stack.py
index b56b737cfa..3fd1e6af66 100644
--- a/studio/install_python_stack.py
+++ b/studio/install_python_stack.py
@@ -21,6 +21,10 @@ import tempfile
 import urllib.request
 from pathlib import Path
 
+_BACKEND_DIR = Path(__file__).resolve().parent / "backend"
+if str(_BACKEND_DIR) not in sys.path:
+    sys.path.insert(1, str(_BACKEND_DIR))
+
 from backend.utils.wheel_utils import (
     flash_attn_package_version,
     flash_attn_wheel_url,
@@ -359,6 +363,27 @@ def _ensure_rocm_torch() -> None:
             )
 
 
+def _uv_safe_path(path: object) -> str:
+    # uv 0.11.x: `-c <path with space>` truncates at the space; use 8.3 short form.
+    s = str(path)
+    if not IS_WINDOWS or " " not in s:
+        return s
+    try:
+        import ctypes
+        from ctypes import wintypes
+
+        get_short = ctypes.windll.kernel32.GetShortPathNameW
+        get_short.argtypes = [wintypes.LPCWSTR, wintypes.LPWSTR, wintypes.DWORD]
+        get_short.restype = wintypes.DWORD
+        buf = ctypes.create_unicode_buffer(32768)
+        rc = get_short(s, buf, 32768)
+        if 0 < rc < 32768 and " " not in buf.value:
+            return buf.value
+    except Exception:
+        pass
+    return s
+
+
 def _windows_hidden_subprocess_kwargs() -> dict[str, object]:
     """Return Windows-only subprocess kwargs that suppress console windows."""
     if not IS_WINDOWS:
@@ -418,6 +443,9 @@ CONSTRAINTS = SINGLE_ENV / "constraints.txt"
 LOCAL_DD_UNSTRUCTURED_PLUGIN = (
     SCRIPT_DIR / "backend" / "plugins" / "data-designer-unstructured-seed"
 )
+LOCAL_DD_GITHUB_PLUGIN = (
+    SCRIPT_DIR / "backend" / "plugins" / "data-designer-github-repo-seed"
+)
 
 # -- Unicode-safe printing ---------------------------------------------
 # On Windows the default console encoding can be a legacy code page
@@ -748,14 +776,16 @@ def pip_install_try(
     """Like pip_install but returns False on failure instead of exiting.
     For optional installs with a follow-up fallback.
     """
-    constraint_args: list[str] = []
+    constraint_args_pip: list[str] = []
+    constraint_args_uv: list[str] = []
     if constrain and CONSTRAINTS.is_file():
-        constraint_args = ["-c", str(CONSTRAINTS)]
+        constraint_args_pip = ["-c", str(CONSTRAINTS)]
+        constraint_args_uv = ["-c", _uv_safe_path(CONSTRAINTS)]
 
     if USE_UV:
-        cmd = _build_uv_cmd(args) + constraint_args
+        cmd = _build_uv_cmd(args) + constraint_args_uv
     else:
-        cmd = _build_pip_cmd(args) + constraint_args
+        cmd = _build_pip_cmd(args) + constraint_args_pip
 
     if VERBOSE:
         _step(_LABEL, f"{label}...", _dim)
@@ -778,9 +808,11 @@ def pip_install(
     constrain: bool = True,
 ) -> None:
     """Build and run a pip install command (uses uv when available, falls back to pip)."""
-    constraint_args: list[str] = []
+    constraint_args_pip: list[str] = []
+    constraint_args_uv: list[str] = []
     if constrain and CONSTRAINTS.is_file():
-        constraint_args = ["-c", str(CONSTRAINTS)]
+        constraint_args_pip = ["-c", str(CONSTRAINTS)]
+        constraint_args_uv = ["-c", _uv_safe_path(CONSTRAINTS)]
 
     actual_req = req
     temp_reqs: list[Path] = []
@@ -790,13 +822,15 @@ def pip_install(
     if actual_req is not None and NO_TORCH and NO_TORCH_SKIP_PACKAGES:
         actual_req = _filter_requirements(actual_req, NO_TORCH_SKIP_PACKAGES)
         temp_reqs.append(actual_req)
-    req_args: list[str] = []
+    req_args_pip: list[str] = []
+    req_args_uv: list[str] = []
     if actual_req is not None:
-        req_args = ["-r", str(actual_req)]
+        req_args_pip = ["-r", str(actual_req)]
+        req_args_uv = ["-r", _uv_safe_path(actual_req)]
 
     try:
         if USE_UV:
-            uv_cmd = _build_uv_cmd(args) + constraint_args + req_args
+            uv_cmd = _build_uv_cmd(args) + constraint_args_uv + req_args_uv
             if VERBOSE:
                 print(f"   {label}...")
             result = subprocess.run(
@@ -811,7 +845,7 @@ def pip_install(
             if result.stdout:
                 print(result.stdout.decode(errors = "replace"))
 
-        pip_cmd = _build_pip_cmd(args) + constraint_args + req_args
+        pip_cmd = _build_pip_cmd(args) + constraint_args_pip + req_args_pip
         run(f"{label} (pip)" if USE_UV else label, pip_cmd)
     finally:
         for temp_req in temp_reqs:
@@ -942,6 +976,7 @@ def install_python_stack() -> int:
             req = REQ_ROOT / "no-torch-runtime.txt",
         )
         if local_repo:
+            _step(_LABEL, f"overlaying local repo (editable): {local_repo}")
             pip_install(
                 "Overlaying local repo (editable)",
                 "--no-cache-dir",
@@ -950,6 +985,15 @@ def install_python_stack() -> int:
                 local_repo,
                 constrain = False,
             )
+            _step(_LABEL, "overlaying unsloth-zoo from git main")
+            pip_install(
+                "Overlaying unsloth-zoo from git main",
+                "--no-cache-dir",
+                "--no-deps",
+                "--force-reinstall",
+                "unsloth-zoo @ git+https://github.com/unslothai/unsloth-zoo",
+                constrain = False,
+            )
     elif local_repo:
         # Local dev install: update deps from base.txt, then overlay the
         # local checkout as an editable install (--no-deps so torch is
@@ -964,6 +1008,7 @@ def install_python_stack() -> int:
             "unsloth-zoo",
             req = REQ_ROOT / "base.txt",
         )
+        _step(_LABEL, f"overlaying local repo (editable): {local_repo}")
         pip_install(
             "Overlaying local repo (editable)",
             "--no-cache-dir",
@@ -972,6 +1017,15 @@ def install_python_stack() -> int:
             local_repo,
             constrain = False,
         )
+        _step(_LABEL, "overlaying unsloth-zoo from git main")
+        pip_install(
+            "Overlaying unsloth-zoo from git main",
+            "--no-cache-dir",
+            "--no-deps",
+            "--force-reinstall",
+            "unsloth-zoo @ git+https://github.com/unslothai/unsloth-zoo",
+            constrain = False,
+        )
     elif package_name != "unsloth":
         # Custom package name (e.g. roland-sloth for testing) — install directly
         _progress("base packages")
@@ -1135,22 +1189,28 @@ def install_python_stack() -> int:
         req = SINGLE_ENV / "data-designer.txt",
     )
 
-    # 11. Local Data Designer seed plugin
-    if not LOCAL_DD_UNSTRUCTURED_PLUGIN.is_dir():
-        _safe_print(
-            _red(
-                f"❌ Missing local plugin directory: {LOCAL_DD_UNSTRUCTURED_PLUGIN}",
-            ),
-        )
-        return 1
+    # 11. Local Data Designer seed plugins
+    local_dd_plugins = [
+        ("unstructured", LOCAL_DD_UNSTRUCTURED_PLUGIN),
+        ("github", LOCAL_DD_GITHUB_PLUGIN),
+    ]
+    for _plugin_name, plugin_dir in local_dd_plugins:
+        if not plugin_dir.is_dir():
+            _safe_print(
+                _red(
+                    f"❌ Missing local plugin directory: {plugin_dir}",
+                ),
+            )
+            return 1
     _progress("local plugin")
-    pip_install(
-        "Installing local data-designer unstructured plugin",
-        "--no-cache-dir",
-        "--no-deps",
-        str(LOCAL_DD_UNSTRUCTURED_PLUGIN),
-        constrain = False,
-    )
+    for plugin_name, plugin_dir in local_dd_plugins:
+        pip_install(
+            f"Installing local data-designer {plugin_name} plugin",
+            "--no-cache-dir",
+            "--no-deps",
+            str(plugin_dir),
+            constrain = False,
+        )
 
     # 12. Patch metadata for single-env compatibility
     _progress("finalizing")
diff --git a/studio/setup.ps1 b/studio/setup.ps1
index 24ef3ef1eb..3d082aa70d 100644
--- a/studio/setup.ps1
+++ b/studio/setup.ps1
@@ -1145,28 +1145,58 @@ if ($IsPipInstall) {
     }
 }
 
-# ============================================
-# 1g. Python (>= 3.11 and < 3.14, matching setup.sh)
-# ============================================
+# 1g. Python (>= 3.11 and < 3.14). Prefer py.exe so a 3.14 ahead of 3.13 on PATH does not trip the gate.
 $HasPython = $null -ne (Get-Command python -ErrorAction SilentlyContinue)
+$PyLauncher = Get-Command py -CommandType Application -ErrorAction SilentlyContinue
 $PythonOk = $false
+$DetectedPyVer = $null
 
-if ($HasPython) {
+if ($PyLauncher) {
+    foreach ($minor in @("3.13", "3.12", "3.11")) {
+        try {
+            $out = & $PyLauncher.Source "-$minor" --version 2>&1 | Out-String
+            if ($out -match 'Python (3\.\d+\.\d+)') {
+                $DetectedPyVer = $Matches[1]
+                # Make `python` resolvable for the rest of setup. Without this,
+                # py-launcher-only installs (no python.exe on PATH) pass the gate
+                # and then crash on the first bare `python` call below.
+                try {
+                    $resolvedExe = (& $PyLauncher.Source "-$minor" -c "import sys; print(sys.executable)" 2>$null | Select-Object -First 1)
+                    if ($resolvedExe -and (Test-Path $resolvedExe)) {
+                        $resolvedDir = Split-Path -Parent $resolvedExe
+                        $alreadyOnPath = ($env:PATH -split ';' | Where-Object { $_.TrimEnd('\') -ieq $resolvedDir.TrimEnd('\') }).Count -gt 0
+                        if (-not $alreadyOnPath) {
+                            $env:PATH = "$resolvedDir;$env:PATH"
+                        }
+                        $HasPython = $true
+                    }
+                } catch { }
+                $PythonOk = $true
+                break
+            }
+        } catch { }
+    }
+}
+
+if (-not $PythonOk -and $HasPython) {
     $PyVer = python --version 2>&1
     if ($PyVer -match "(\d+)\.(\d+)") {
         $PyMajor = [int]$Matches[1]; $PyMinor = [int]$Matches[2]
         if ($PyMajor -eq 3 -and $PyMinor -ge 11 -and $PyMinor -lt 14) {
-            substep "Python $PyVer"
+            $DetectedPyVer = "$PyMajor.$PyMinor"
             $PythonOk = $true
-        } else {
-            Write-Host "[ERROR] Python $PyVer is outside supported range (need >= 3.11 and < 3.14)." -ForegroundColor Red
-            Write-Host "        Install Python 3.12 from https://python.org/downloads/" -ForegroundColor Yellow
-            exit 1
         }
     }
-} else {
-    # No Python at all -- install 3.12
-    Write-Host "Python not found -- installing Python 3.12 via winget..." -ForegroundColor Yellow
+}
+
+if ($PythonOk) {
+    substep "Python $DetectedPyVer"
+} elseif (-not $HasPython) {
+    # No `python` on PATH (and py.exe either absent or only had unsupported
+    # minors). Try winget as before -- gating on $HasPython alone, not also
+    # on $PyLauncher, so a launcher-only install with just 3.14 still gets
+    # an automatic 3.12 install instead of a hard error.
+    Write-Host "Python 3.11-3.13 not found -- installing Python 3.12 via winget..." -ForegroundColor Yellow
     $HasWinget = $null -ne (Get-Command winget -ErrorAction SilentlyContinue)
     if ($HasWinget) {
         winget install -e --id Python.Python.3.12 --source winget --accept-package-agreements --accept-source-agreements
@@ -1180,6 +1210,13 @@ if ($HasPython) {
     }
     step "python" "$(python --version 2>&1)"
     $PythonOk = $true
+} else {
+    # python.exe is on PATH but its version is unsupported, and py.exe (if
+    # present) had no supported minor either.
+    Write-Host "[ERROR] No supported Python (3.11-3.13) found on this system." -ForegroundColor Red
+    Write-Host "        py.exe could not locate -3.11/-3.12/-3.13 and `python` on PATH is unsupported." -ForegroundColor Yellow
+    Write-Host "        Install Python 3.12 from https://python.org/downloads/" -ForegroundColor Yellow
+    exit 1
 }
 
 # Add user-scheme Python Scripts dir to PATH (nt_user only, no venv fallback).
@@ -1460,8 +1497,14 @@ substep "Using $PythonCmd ($(& $PythonCmd --version 2>&1))"
 $VenvDir = Join-Path $env:USERPROFILE ".unsloth\studio\unsloth_studio"
 
 # Stale-venv detection: if the venv exists but its torch flavor no longer
-# matches the current machine, wipe it so we get a clean install.
-if (Test-Path $VenvDir -PathType Container) {
+# matches the current machine, repair according to invocation context.
+# - install.ps1 sets UNSLOTH_INSTALL_ROLLBACK_MANAGED=1 so setup can delegate
+#   to the installer-level rollback that restores the previous environment.
+# - direct `unsloth studio update` keeps the pre-existing self-repair behavior.
+# In no-torch mode, a missing torch package is expected.
+$NoTorchMode = $env:UNSLOTH_NO_TORCH -match '^(?i:true|1|yes)$'
+$InstallerManagedSetup = $env:UNSLOTH_INSTALL_ROLLBACK_MANAGED -match '^(?i:true|1|yes)$'
+if ((Test-Path $VenvDir -PathType Container) -and -not $NoTorchMode) {
     $VenvPyExe = Join-Path $VenvDir "Scripts\python.exe"
     $installedTorchTag = $null
     $shouldRebuild = $false
@@ -1508,6 +1551,12 @@ if (Test-Path $VenvDir -PathType Container) {
 
     if ($shouldRebuild) {
         $reason = if ($installedTorchTag) { "torch $installedTorchTag != required $expectedTorchTag" } else { "torch could not be imported" }
+        if ($InstallerManagedSetup) {
+            substep "Stale venv detected ($reason)." "Yellow"
+            Write-Host "   [ERROR] The existing Studio environment needs repair." -ForegroundColor Red
+            Write-Host "           Re-run install.ps1 so it can replace the environment safely with rollback." -ForegroundColor Yellow
+            exit 1
+        }
         substep "Stale venv detected ($reason) -- rebuilding..." "Yellow"
         try {
             Remove-Item $VenvDir -Recurse -Force -ErrorAction Stop
diff --git a/studio/setup.sh b/studio/setup.sh
index 142d253554..3e875eed30 100755
--- a/studio/setup.sh
+++ b/studio/setup.sh
@@ -8,6 +8,21 @@ SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 REPO_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
 RULE=$(printf '\342\224\200%.0s' {1..52})
 
+# ── Parse flags ──
+# --local: install from the local repo checkout (overlays unsloth as editable
+# and unsloth-zoo from git main). Mirrors install.sh --local for the Colab
+# path that runs setup.sh directly without going through install.sh.
+if [ "$#" -gt 0 ]; then
+    for _arg in "$@"; do
+        case "$_arg" in
+            --local)
+                export STUDIO_LOCAL_INSTALL=1
+                export STUDIO_LOCAL_REPO="$REPO_ROOT"
+                ;;
+        esac
+    done
+fi
+
 # ── Maintainer-editable defaults ──────────────────────────────────────────
 # Change these in the GitHub-hosted script so all users get updated defaults.
 # User environment variables always override these baked-in values.
@@ -170,6 +185,9 @@ _LLAMA_ONLY="${UNSLOTH_STUDIO_LLAMA_ONLY:-0}"
 if [ "$_LLAMA_ONLY" = "1" ]; then
     substep "llama.cpp only mode"
 fi
+if [ "${STUDIO_LOCAL_INSTALL:-0}" = "1" ]; then
+    substep "local mode: overlaying $REPO_ROOT (editable) + unsloth-zoo from git main"
+fi
 # ── Clean up stale caches ──
 rm -rf "$REPO_ROOT/unsloth_compiled_cache"
 rm -rf "$SCRIPT_DIR/backend/unsloth_compiled_cache"
@@ -681,7 +699,7 @@ if [ "$_NEED_LLAMA_SOURCE_BUILD" = true ] && grep -qi microsoft /proc/version 2>
         case "$_pkg" in
             build-essential) command -v gcc >/dev/null 2>&1 || _STILL_MISSING="$_STILL_MISSING $_pkg" ;;
             pciutils) command -v lspci >/dev/null 2>&1 || _STILL_MISSING="$_STILL_MISSING $_pkg" ;;
-            libcurl4-openssl-dev) dpkg -s "$_pkg" >/dev/null 2>&1 || _STILL_MISSING="$_STILL_MISSING $_pkg" ;;
+            libcurl4-openssl-dev) command -v curl-config >/dev/null 2>&1 || _STILL_MISSING="$_STILL_MISSING $_pkg" ;;
             *) command -v "$_pkg" >/dev/null 2>&1 || _STILL_MISSING="$_STILL_MISSING $_pkg" ;;
         esac
     done
@@ -1069,10 +1087,11 @@ else
     fi
     printf "  ${C_DIM}%s${C_RST}\n" "$RULE"
     if [ "$_LLAMA_CPP_DEGRADED" = true ]; then
-        printf "  ${C_DIM}%-15s${C_WARN}%s${C_RST}\n" "launch" "unsloth studio -H 0.0.0.0 -p 8888"
+        printf "  ${C_DIM}%-15s${C_WARN}%s${C_RST}\n" "launch" "unsloth studio -p 8888"
     else
-        printf "  ${C_DIM}%-15s${C_OK}%s${C_RST}\n" "launch" "unsloth studio -H 0.0.0.0 -p 8888"
+        printf "  ${C_DIM}%-15s${C_OK}%s${C_RST}\n" "launch" "unsloth studio -p 8888"
     fi
+    printf "  ${C_DIM}%-15s%s${C_RST}\n" "" "(add -H 0.0.0.0 to allow network / cloud access)"
 fi
 echo ""
 
diff --git a/studio/src-tauri/Cargo.lock b/studio/src-tauri/Cargo.lock
index 62d520437c..c73d7cc0c5 100644
--- a/studio/src-tauri/Cargo.lock
+++ b/studio/src-tauri/Cargo.lock
@@ -56,6 +56,27 @@ dependencies = [
  "derive_arbitrary",
 ]
 
+[[package]]
+name = "arboard"
+version = "3.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0348a1c054491f4bfe6ab86a7b6ab1e44e45d899005de92f58b3df180b36ddaf"
+dependencies = [
+ "clipboard-win",
+ "image",
+ "log",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-foundation",
+ "parking_lot",
+ "percent-encoding",
+ "windows-sys 0.60.2",
+ "wl-clipboard-rs",
+ "x11rb",
+]
+
 [[package]]
 name = "async-broadcast"
 version = "0.7.2"
@@ -334,6 +355,12 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
+[[package]]
+name = "byteorder-lite"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"
+
 [[package]]
 name = "bytes"
 version = "1.11.1"
@@ -482,6 +509,15 @@ dependencies = [
  "windows-link 0.2.1",
 ]
 
+[[package]]
+name = "clipboard-win"
+version = "5.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bde03770d3df201d4fb868f2c9c59e66a3e4e2bd06692a0fe701e7103c7e84d4"
+dependencies = [
+ "error-code",
+]
+
 [[package]]
 name = "combine"
 version = "4.6.7"
@@ -609,6 +645,12 @@ version = "0.8.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
+[[package]]
+name = "crunchy"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
+
 [[package]]
 name = "crypto-common"
 version = "0.1.7"
@@ -766,6 +808,7 @@ checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
 dependencies = [
  "block-buffer",
  "crypto-common",
+ "subtle",
 ]
 
 [[package]]
@@ -850,6 +893,12 @@ dependencies = [
  "tendril 0.5.0",
 ]
 
+[[package]]
+name = "downcast-rs"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75b325c5dbd37f80359721ad39aca5a29fb04c89279657cffdda8736d0c0b9d2"
+
 [[package]]
 name = "dpi"
 version = "0.1.2"
@@ -983,6 +1032,12 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "error-code"
+version = "3.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dea2df4cf52843e0452895c455a1a2cfbb842a1e7329671acf418fdc53ed4c59"
+
 [[package]]
 name = "event-listener"
 version = "5.4.1"
@@ -1010,6 +1065,12 @@ version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
 
+[[package]]
+name = "fax"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "caf1079563223d5d59d83c85886a56e586cfd5c1a26292e971a0fa266531ac5a"
+
 [[package]]
 name = "fdeflate"
 version = "0.3.7"
@@ -1056,6 +1117,12 @@ dependencies = [
  "thiserror 1.0.69",
 ]
 
+[[package]]
+name = "fixedbitset"
+version = "0.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
+
 [[package]]
 name = "flate2"
 version = "1.1.9"
@@ -1347,6 +1414,16 @@ dependencies = [
  "version_check",
 ]
 
+[[package]]
+name = "gethostname"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bd49230192a3797a9a4d6abe9b3eed6f7fa4c8a8a4947977c6f80025f92cbd8"
+dependencies = [
+ "rustix",
+ "windows-link 0.2.1",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.1.16"
@@ -1562,6 +1639,17 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "half"
+version = "2.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
+dependencies = [
+ "cfg-if",
+ "crunchy",
+ "zerocopy",
+]
+
 [[package]]
 name = "hashbrown"
 version = "0.12.3"
@@ -1607,6 +1695,15 @@ version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest",
+]
+
 [[package]]
 name = "home"
 version = "0.5.12"
@@ -1787,7 +1884,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3e795dff5605e0f04bff85ca41b51a96b83e80b281e96231bcaaf1ac35103371"
 dependencies = [
  "byteorder",
- "png",
+ "png 0.17.16",
 ]
 
 [[package]]
@@ -1904,6 +2001,20 @@ dependencies = [
  "icu_properties",
 ]
 
+[[package]]
+name = "image"
+version = "0.25.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104"
+dependencies = [
+ "bytemuck",
+ "byteorder-lite",
+ "moxcms",
+ "num-traits",
+ "png 0.18.1",
+ "tiff",
+]
+
 [[package]]
 name = "indexmap"
 version = "1.9.3"
@@ -2190,6 +2301,18 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4"
 
+[[package]]
+name = "mac-notification-sys"
+version = "0.6.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29a16783dd1a47849b8c8133c9cd3eb2112cfbc6901670af3dba47c8bbfb07d3"
+dependencies = [
+ "cc",
+ "objc2",
+ "objc2-foundation",
+ "time",
+]
+
 [[package]]
 name = "markup5ever"
 version = "0.14.1"
@@ -2280,6 +2403,16 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "moxcms"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb85c154ba489f01b25c0d36ae69a87e4a1c73a72631fc6c0eb6dde34a73e44b"
+dependencies = [
+ "num-traits",
+ "pxfm",
+]
+
 [[package]]
 name = "muda"
 version = "0.17.1"
@@ -2295,7 +2428,7 @@ dependencies = [
  "objc2-core-foundation",
  "objc2-foundation",
  "once_cell",
- "png",
+ "png 0.17.16",
  "serde",
  "thiserror 2.0.18",
  "windows-sys 0.60.2",
@@ -2372,6 +2505,29 @@ version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72ef4a56884ca558e5ddb05a1d1e7e1bfd9a68d9ed024c21704cc98872dae1bb"
 
+[[package]]
+name = "nom"
+version = "8.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "notify-rust"
+version = "4.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3bdaf6120b9df005d37e58f6b75329be6255450453fbeba9ce4192324f921fb9"
+dependencies = [
+ "futures-lite",
+ "log",
+ "mac-notification-sys",
+ "serde",
+ "tauri-winrt-notification",
+ "zbus",
+]
+
 [[package]]
 name = "num-conv"
 version = "0.2.0"
@@ -2438,6 +2594,7 @@ dependencies = [
  "block2",
  "objc2",
  "objc2-core-foundation",
+ "objc2-core-graphics",
  "objc2-foundation",
 ]
 
@@ -2632,6 +2789,16 @@ dependencies = [
  "pin-project-lite",
 ]
 
+[[package]]
+name = "os_pipe"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "osakit"
 version = "0.3.1"
@@ -2712,6 +2879,17 @@ version = "2.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 
+[[package]]
+name = "petgraph"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455"
+dependencies = [
+ "fixedbitset",
+ "hashbrown 0.15.5",
+ "indexmap 2.13.0",
+]
+
 [[package]]
 name = "phf"
 version = "0.8.0"
@@ -2942,7 +3120,7 @@ checksum = "740ebea15c5d1428f910cd1a5f52cebf8d25006245ed8ade92702f4943d91e07"
 dependencies = [
  "base64 0.22.1",
  "indexmap 2.13.0",
- "quick-xml",
+ "quick-xml 0.38.4",
  "serde",
  "time",
 ]
@@ -2960,6 +3138,19 @@ dependencies = [
  "miniz_oxide",
 ]
 
+[[package]]
+name = "png"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61"
+dependencies = [
+ "bitflags 2.11.0",
+ "crc32fast",
+ "fdeflate",
+ "flate2",
+ "miniz_oxide",
+]
+
 [[package]]
 name = "polling"
 version = "3.11.0"
@@ -3094,6 +3285,27 @@ dependencies = [
  "windows 0.62.2",
 ]
 
+[[package]]
+name = "pxfm"
+version = "0.1.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e0c5ccf5294c6ccd63a74f1565028353830a9c2f5eb0c682c355c471726a6e3f"
+
+[[package]]
+name = "quick-error"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
+
+[[package]]
+name = "quick-xml"
+version = "0.37.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "331e97a1af0bf59823e6eadffe373d7b27f485be8748f71471c662c1f269b7fb"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "quick-xml"
 version = "0.38.4"
@@ -3103,6 +3315,15 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "quick-xml"
+version = "0.39.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "958f21e8e7ceb5a1aa7fa87fab28e7c75976e0bfe7e23ff069e0a260f894067d"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "quote"
 version = "1.0.45"
@@ -3149,6 +3370,16 @@ dependencies = [
  "rand_core 0.6.4",
 ]
 
+[[package]]
+name = "rand"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44c5af06bb1b7d3216d91932aed5265164bf384dc89cd6ba05cf59a35f5f76ea"
+dependencies = [
+ "rand_chacha 0.9.0",
+ "rand_core 0.9.5",
+]
+
 [[package]]
 name = "rand"
 version = "0.10.0"
@@ -3180,6 +3411,16 @@ dependencies = [
  "rand_core 0.6.4",
 ]
 
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.5",
+]
+
 [[package]]
 name = "rand_core"
 version = "0.5.1"
@@ -3198,6 +3439,15 @@ dependencies = [
  "getrandom 0.2.17",
 ]
 
+[[package]]
+name = "rand_core"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
+dependencies = [
+ "getrandom 0.3.4",
+]
+
 [[package]]
 name = "rand_core"
 version = "0.10.0"
@@ -3385,6 +3635,30 @@ dependencies = [
  "web-sys",
 ]
 
+[[package]]
+name = "rfd"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a15ad77d9e70a92437d8f74c35d99b4e4691128df018833e99f90bcd36152672"
+dependencies = [
+ "block2",
+ "dispatch2",
+ "glib-sys",
+ "gobject-sys",
+ "gtk-sys",
+ "js-sys",
+ "log",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-foundation",
+ "raw-window-handle",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+ "windows-sys 0.60.2",
+]
+
 [[package]]
 name = "ring"
 version = "0.17.14"
@@ -4275,7 +4549,7 @@ dependencies = [
  "ico",
  "json-patch",
  "plist",
- "png",
+ "png 0.17.16",
  "proc-macro2",
  "quote",
  "semver",
@@ -4322,6 +4596,82 @@ dependencies = [
  "walkdir",
 ]
 
+[[package]]
+name = "tauri-plugin-clipboard-manager"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "206dc20af4ed210748ba945c2774e60fd0acd52b9a73a028402caf809e9b6ecf"
+dependencies = [
+ "arboard",
+ "log",
+ "serde",
+ "serde_json",
+ "tauri",
+ "tauri-plugin",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "tauri-plugin-dialog"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1fa4150c95ae391946cc8b8f905ab14797427caba3a8a2f79628e956da91809"
+dependencies = [
+ "log",
+ "raw-window-handle",
+ "rfd",
+ "serde",
+ "serde_json",
+ "tauri",
+ "tauri-plugin",
+ "tauri-plugin-fs",
+ "thiserror 2.0.18",
+ "url",
+]
+
+[[package]]
+name = "tauri-plugin-fs"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36e1ec28b79f3d0683f4507e1615c36292c0ea6716668770d4396b9b39871ed8"
+dependencies = [
+ "anyhow",
+ "dunce",
+ "glob",
+ "log",
+ "objc2-foundation",
+ "percent-encoding",
+ "schemars 0.8.22",
+ "serde",
+ "serde_json",
+ "serde_repr",
+ "tauri",
+ "tauri-plugin",
+ "tauri-utils",
+ "thiserror 2.0.18",
+ "toml 0.9.12+spec-1.1.0",
+ "url",
+]
+
+[[package]]
+name = "tauri-plugin-notification"
+version = "2.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01fc2c5ff41105bd1f7242d8201fdf3efd70749b82fa013a17f2126357d194cc"
+dependencies = [
+ "log",
+ "notify-rust",
+ "rand 0.9.4",
+ "serde",
+ "serde_json",
+ "serde_repr",
+ "tauri",
+ "tauri-plugin",
+ "thiserror 2.0.18",
+ "time",
+ "url",
+]
+
 [[package]]
 name = "tauri-plugin-opener"
 version = "2.5.3"
@@ -4502,6 +4852,18 @@ dependencies = [
  "toml 0.9.12+spec-1.1.0",
 ]
 
+[[package]]
+name = "tauri-winrt-notification"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b1e66e07de489fe43a46678dd0b8df65e0c973909df1b60ba33874e297ba9b9"
+dependencies = [
+ "quick-xml 0.37.5",
+ "thiserror 2.0.18",
+ "windows 0.61.3",
+ "windows-version",
+]
+
 [[package]]
 name = "tempfile"
 version = "3.27.0"
@@ -4585,6 +4947,20 @@ dependencies = [
  "syn 2.0.117",
 ]
 
+[[package]]
+name = "tiff"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b63feaf3343d35b6ca4d50483f94843803b0f51634937cc2ec519fc32232bc52"
+dependencies = [
+ "fax",
+ "flate2",
+ "half",
+ "quick-error",
+ "weezl",
+ "zune-jpeg",
+]
+
 [[package]]
 name = "time"
 version = "0.3.47"
@@ -4886,12 +5262,23 @@ dependencies = [
  "objc2-core-graphics",
  "objc2-foundation",
  "once_cell",
- "png",
+ "png 0.17.16",
  "serde",
  "thiserror 2.0.18",
  "windows-sys 0.60.2",
 ]
 
+[[package]]
+name = "tree_magic_mini"
+version = "3.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8765b90061cba6c22b5831f675da109ae5561588290f9fa2317adab2714d5a6"
+dependencies = [
+ "memchr",
+ "nom",
+ "petgraph",
+]
+
 [[package]]
 name = "try-lock"
 version = "0.2.5"
@@ -4982,11 +5369,13 @@ checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
 [[package]]
 name = "unsloth-studio"
-version = "2026.4.7"
+version = "2026.4.8"
 dependencies = [
+ "base64 0.22.1",
  "dirs",
  "elevated-command",
  "fix-path-env",
+ "hmac",
  "libc",
  "log",
  "open",
@@ -4996,9 +5385,13 @@ dependencies = [
  "reqwest 0.12.28",
  "serde",
  "serde_json",
+ "sha2",
  "simplelog",
  "tauri",
  "tauri-build",
+ "tauri-plugin-clipboard-manager",
+ "tauri-plugin-dialog",
+ "tauri-plugin-notification",
  "tauri-plugin-opener",
  "tauri-plugin-process",
  "tauri-plugin-single-instance",
@@ -5265,6 +5658,76 @@ dependencies = [
  "semver",
 ]
 
+[[package]]
+name = "wayland-backend"
+version = "0.3.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2857dd20b54e916ec7253b3d6b4d5c4d7d4ca2c33c2e11c6c76a99bd8744755d"
+dependencies = [
+ "cc",
+ "downcast-rs",
+ "rustix",
+ "smallvec",
+ "wayland-sys",
+]
+
+[[package]]
+name = "wayland-client"
+version = "0.31.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "645c7c96bb74690c3189b5c9cb4ca1627062bb23693a4fad9d8c3de958260144"
+dependencies = [
+ "bitflags 2.11.0",
+ "rustix",
+ "wayland-backend",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-protocols"
+version = "0.32.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "563a85523cade2429938e790815fd7319062103b9f4a2dc806e9b53b95982d8f"
+dependencies = [
+ "bitflags 2.11.0",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-protocols-wlr"
+version = "0.3.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb04e52f7836d7c7976c78ca0250d61e33873c34156a2a1fc9474828ec268234"
+dependencies = [
+ "bitflags 2.11.0",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-protocols",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-scanner"
+version = "0.31.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c324a910fd86ebdc364a3e61ec1f11737d3b1d6c273c0239ee8ff4bc0d24b4a"
+dependencies = [
+ "proc-macro2",
+ "quick-xml 0.39.2",
+ "quote",
+]
+
+[[package]]
+name = "wayland-sys"
+version = "0.31.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8eab23fefc9e41f8e841df4a9c707e8a8c4ed26e944ef69297184de2785e3be"
+dependencies = [
+ "pkg-config",
+]
+
 [[package]]
 name = "web-sys"
 version = "0.3.91"
@@ -5376,6 +5839,12 @@ dependencies = [
  "windows-core 0.61.2",
 ]
 
+[[package]]
+name = "weezl"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88"
+
 [[package]]
 name = "winapi"
 version = "0.3.9"
@@ -6016,6 +6485,24 @@ dependencies = [
  "wasmparser",
 ]
 
+[[package]]
+name = "wl-clipboard-rs"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9651471a32e87d96ef3a127715382b2d11cc7c8bb9822ded8a7cc94072eb0a3"
+dependencies = [
+ "libc",
+ "log",
+ "os_pipe",
+ "rustix",
+ "thiserror 2.0.18",
+ "tree_magic_mini",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-protocols",
+ "wayland-protocols-wlr",
+]
+
 [[package]]
 name = "writeable"
 version = "0.6.2"
@@ -6087,6 +6574,23 @@ dependencies = [
  "pkg-config",
 ]
 
+[[package]]
+name = "x11rb"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9993aa5be5a26815fe2c3eacfc1fde061fc1a1f094bf1ad2a18bf9c495dd7414"
+dependencies = [
+ "gethostname",
+ "rustix",
+ "x11rb-protocol",
+]
+
+[[package]]
+name = "x11rb-protocol"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea6fc2961e4ef194dcbfe56bb845534d0dc8098940c7e5c012a258bfec6701bd"
+
 [[package]]
 name = "xattr"
 version = "1.6.1"
@@ -6279,6 +6783,21 @@ version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
 
+[[package]]
+name = "zune-core"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb8a0807f7c01457d0379ba880ba6322660448ddebc890ce29bb64da71fb40f9"
+
+[[package]]
+name = "zune-jpeg"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27bc9d5b815bc103f142aa054f561d9187d191692ec7c2d1e2b4737f8dbd7296"
+dependencies = [
+ "zune-core",
+]
+
 [[package]]
 name = "zvariant"
 version = "5.10.0"
diff --git a/studio/src-tauri/Cargo.toml b/studio/src-tauri/Cargo.toml
index ccb07cb9e2..4002ab420d 100644
--- a/studio/src-tauri/Cargo.toml
+++ b/studio/src-tauri/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "unsloth-studio"
-version = "2026.4.7"
+version = "2026.4.8"
 description = "Unsloth Studio Desktop App"
 authors = ["Unsloth AI"]
 edition = "2021"
@@ -11,6 +11,9 @@ tauri-plugin-single-instance = "2"
 tauri-plugin-process = "2"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
+base64 = "0.22"
+hmac = "0.12"
+sha2 = "0.10"
 reqwest = { version = "0.12", features = ["json"] }
 tokio = { version = "1", features = ["full"] }
 log = "0.4"
@@ -22,7 +25,10 @@ process-wrap = { version = "9", features = ["std"] }
 fix-path-env = { git = "https://github.com/tauri-apps/fix-path-env-rs" }
 tauri-plugin-opener = "2.5.3"
 tauri-plugin-updater = "2"
+tauri-plugin-clipboard-manager = "2"
+tauri-plugin-dialog = "2"
 rand = "0.10.0"
+tauri-plugin-notification = "2.3.3"
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2"
diff --git a/studio/src-tauri/capabilities/default.json b/studio/src-tauri/capabilities/default.json
index 7b6033c721..413fa14cc1 100644
--- a/studio/src-tauri/capabilities/default.json
+++ b/studio/src-tauri/capabilities/default.json
@@ -13,12 +13,21 @@
     "core:window:allow-set-size-constraints",
     "core:window:allow-center",
     "core:window:allow-current-monitor",
+    "core:window:allow-start-dragging",
+    "core:window:allow-start-resize-dragging",
+    "core:window:allow-minimize",
+    "core:window:allow-toggle-maximize",
+    "core:window:allow-close",
     "core:tray:default",
     "process:default",
+    "notification:allow-is-permission-granted",
+    "notification:allow-request-permission",
+    "notification:allow-notify",
     {
       "identifier": "opener:allow-open-url",
       "allow": [{ "url": "https://*" }, { "url": "http://*" }, { "url": "mailto:*" }]
     },
-    "updater:default"
+    "updater:default",
+    "clipboard-manager:allow-write-text"
   ]
 }
diff --git a/studio/src-tauri/src/commands.rs b/studio/src-tauri/src/commands.rs
index f2acb92e09..48a0af6e48 100644
--- a/studio/src-tauri/src/commands.rs
+++ b/studio/src-tauri/src/commands.rs
@@ -1,9 +1,19 @@
+use crate::diagnostics::{self, DiagnosticsState};
 use crate::install;
 use crate::process::{self, BackendState, ShutdownFlag};
 use crate::update;
 use log::{error, info, warn};
+use std::time::{Duration, Instant};
 use tauri::{AppHandle, Emitter};
 
+const BACKEND_STARTUP_GRACE_PERIOD: Duration = Duration::from_secs(5 * 60);
+const HEALTH_WATCHDOG_INTERVAL: Duration = Duration::from_secs(15);
+const HEALTH_WATCHDOG_MAX_FAILURES: u32 = 3;
+
+fn should_count_watchdog_failure(has_seen_healthy: bool, elapsed_since_start: Duration) -> bool {
+    has_seen_healthy || elapsed_since_start >= BACKEND_STARTUP_GRACE_PERIOD
+}
+
 async fn managed_install_ready_after_repair() -> bool {
     crate::preflight::managed_install_ready().await
 }
@@ -13,8 +23,12 @@ fn should_emit_repair_failed(msg: &str) -> bool {
 }
 
 #[tauri::command]
-pub async fn desktop_preflight() -> crate::preflight::DesktopPreflightResult {
-    crate::preflight::desktop_preflight_result().await
+pub async fn desktop_preflight(
+    diagnostics: tauri::State<'_, DiagnosticsState>,
+) -> Result<crate::preflight::DesktopPreflightResult, String> {
+    let result = crate::preflight::desktop_preflight_result().await;
+    diagnostics::record_preflight(&diagnostics, &result);
+    Ok(result)
 }
 
 /// Check if unsloth is installed AND functional.
@@ -82,11 +96,13 @@ pub async fn start_server(
     app: AppHandle,
     state: tauri::State<'_, BackendState>,
     shutdown: tauri::State<'_, ShutdownFlag>,
+    diagnostics: tauri::State<'_, DiagnosticsState>,
     port: u16,
 ) -> Result<(), String> {
     info!("start_server command called with port {}", port);
 
-    process::start_backend(&app, &state, port, &shutdown)?;
+    let diagnostics_state = diagnostics.inner().clone();
+    let generation = process::start_backend(&app, &state, port, &shutdown, &diagnostics_state)?;
 
     // Spawn health watchdog for the owned backend — detects
     // deadlocks and hangs that stdout-based crash detection misses.
@@ -94,7 +110,14 @@ pub async fn start_server(
     let watchdog_shutdown = shutdown.inner().clone();
     let watchdog_app = app.clone();
     tokio::spawn(async move {
-        health_watchdog(watchdog_app, watchdog_state, watchdog_shutdown).await;
+        health_watchdog(
+            watchdog_app,
+            watchdog_state,
+            watchdog_shutdown,
+            diagnostics_state,
+            generation,
+        )
+        .await;
     });
 
     Ok(())
@@ -106,16 +129,25 @@ pub async fn start_managed_server(
     app: AppHandle,
     state: tauri::State<'_, BackendState>,
     shutdown: tauri::State<'_, ShutdownFlag>,
+    diagnostics: tauri::State<'_, DiagnosticsState>,
     port: u16,
 ) -> Result<(), String> {
     info!("start_managed_server command called with port {}", port);
-    process::start_backend(&app, &state, port, &shutdown)?;
+    let diagnostics_state = diagnostics.inner().clone();
+    let generation = process::start_backend(&app, &state, port, &shutdown, &diagnostics_state)?;
 
     let watchdog_state = state.inner().clone();
     let watchdog_shutdown = shutdown.inner().clone();
     let watchdog_app = app.clone();
     tokio::spawn(async move {
-        health_watchdog(watchdog_app, watchdog_state, watchdog_shutdown).await;
+        health_watchdog(
+            watchdog_app,
+            watchdog_state,
+            watchdog_shutdown,
+            diagnostics_state,
+            generation,
+        )
+        .await;
     });
 
     Ok(())
@@ -128,9 +160,10 @@ pub async fn start_managed_server(
 pub fn stop_server(
     state: tauri::State<'_, BackendState>,
     shutdown: tauri::State<'_, ShutdownFlag>,
+    diagnostics: tauri::State<'_, DiagnosticsState>,
 ) -> Result<(), String> {
     info!("stop_server command called");
-    process::stop_backend(&state, &shutdown)
+    process::stop_backend(&state, &shutdown, Some(diagnostics.inner()))
 }
 
 /// Check if a healthy Unsloth backend is running on the given port.
@@ -201,13 +234,25 @@ pub fn open_logs_dir() -> Result<(), String> {
 pub async fn start_install(
     app: AppHandle,
     state: tauri::State<'_, install::InstallState>,
+    diagnostics: tauri::State<'_, DiagnosticsState>,
 ) -> Result<(), String> {
     let state = state.inner().clone();
-    tokio::task::spawn_blocking(move || install::run_install(app, state))
+    let diagnostics_state = diagnostics.inner().clone();
+    tokio::task::spawn_blocking(move || install::run_install(app, state, diagnostics_state))
         .await
         .map_err(|e| format!("Install task panicked: {e}"))?
 }
 
+/// Record that the user canceled a pending system-package elevation flow.
+#[tauri::command]
+pub fn cancel_pending_elevation(
+    state: tauri::State<'_, install::InstallState>,
+    diagnostics: tauri::State<'_, DiagnosticsState>,
+) -> Result<(), String> {
+    let _ = install::record_pending_elevation_canceled(&state, diagnostics.inner());
+    Ok(())
+}
+
 /// Install system packages with elevated permissions (Linux only).
 /// Called by frontend after user approves the elevation dialog.
 /// Only allows packages that the install script reported as needed.
@@ -216,6 +261,7 @@ pub async fn start_install(
 pub fn install_system_packages(
     packages: Vec<String>,
     state: tauri::State<'_, install::InstallState>,
+    diagnostics: tauri::State<'_, DiagnosticsState>,
 ) -> Result<(), String> {
     // Cross-check against the packages the install script actually reported
     let allowed = state
@@ -230,7 +276,7 @@ pub fn install_system_packages(
             ));
         }
     }
-    install::install_system_packages(&packages)
+    install::install_system_packages(&packages, &state, diagnostics.inner())
 }
 
 /// Stub for non-Linux platforms — elevation is handled by the scripts themselves.
@@ -239,6 +285,7 @@ pub fn install_system_packages(
 pub fn install_system_packages(
     _packages: Vec<String>,
     _state: tauri::State<'_, install::InstallState>,
+    _diagnostics: tauri::State<'_, DiagnosticsState>,
 ) -> Result<(), String> {
     Err("Elevated package install is only supported on Linux".to_string())
 }
@@ -252,6 +299,7 @@ pub async fn start_backend_update(
     shutdown: tauri::State<'_, ShutdownFlag>,
     update_state: tauri::State<'_, update::UpdateState>,
     install_state: tauri::State<'_, install::InstallState>,
+    diagnostics: tauri::State<'_, DiagnosticsState>,
 ) -> Result<(), String> {
     info!("start_backend_update command called");
 
@@ -285,12 +333,13 @@ pub async fn start_backend_update(
         .unwrap_or(false)
     {
         info!("Stopping backend before update...");
-        process::stop_backend(&backend_state, &shutdown)?;
+        process::stop_backend(&backend_state, &shutdown, Some(diagnostics.inner()))?;
     }
 
     // Run update in a blocking thread
     let state = update_state.inner().clone();
-    tokio::task::spawn_blocking(move || update::run_backend_update(app, state))
+    let diagnostics_state = diagnostics.inner().clone();
+    tokio::task::spawn_blocking(move || update::run_backend_update(app, state, diagnostics_state))
         .await
         .map_err(|e| format!("Update task panicked: {e}"))?
 }
@@ -303,6 +352,7 @@ pub async fn start_managed_repair(
     shutdown: tauri::State<'_, ShutdownFlag>,
     update_state: tauri::State<'_, update::UpdateState>,
     install_state: tauri::State<'_, install::InstallState>,
+    diagnostics: tauri::State<'_, DiagnosticsState>,
 ) -> Result<(), String> {
     info!("start_managed_repair command called");
 
@@ -322,6 +372,10 @@ pub async fn start_managed_repair(
         return Err("Repair is already running.".to_string());
     }
 
+    let diagnostics_state = diagnostics.inner().clone();
+    let repair_group_id = install::take_pending_repair_group_for_resume(&install_state)
+        .unwrap_or_else(|| diagnostics::begin_repair_group(&diagnostics_state));
+
     shutdown.store(true, std::sync::atomic::Ordering::SeqCst);
 
     if backend_state
@@ -330,14 +384,21 @@ pub async fn start_managed_repair(
         .unwrap_or(false)
     {
         info!("Stopping backend before repair...");
-        process::stop_backend(&backend_state, &shutdown)?;
+        process::stop_backend(&backend_state, &shutdown, Some(&diagnostics_state))?;
     }
 
     let _ = app.emit("repair-progress", "Updating existing Studio install...");
     let update_app = app.clone();
     let update_state = update_state.inner().clone();
+    let update_diagnostics = diagnostics_state.clone();
+    let update_repair_group_id = repair_group_id.clone();
     let update_result = tokio::task::spawn_blocking(move || {
-        update::run_backend_update_for_repair(update_app, update_state)
+        update::run_backend_update_for_repair(
+            update_app,
+            update_state,
+            update_diagnostics,
+            update_repair_group_id,
+        )
     })
     .await
     .map_err(|e| format!("Repair update task panicked: {e}"))?;
@@ -345,6 +406,7 @@ pub async fn start_managed_repair(
     match update_result {
         Ok(()) if managed_install_ready_after_repair().await => {
             info!("Managed repair complete after update");
+            diagnostics::finish_repair_group(&diagnostics_state, &repair_group_id, "success", None);
             let _ = app.emit("repair-complete", ());
             return Ok(());
         }
@@ -358,6 +420,12 @@ pub async fn start_managed_repair(
         Err(msg) => {
             if msg.to_ascii_lowercase().contains("already running") {
                 error!("Managed repair update conflict: {}", msg);
+                diagnostics::finish_repair_group(
+                    &diagnostics_state,
+                    &repair_group_id,
+                    "failed",
+                    Some(msg.clone()),
+                );
                 let _ = app.emit("repair-failed", &msg);
                 return Err(msg);
             }
@@ -375,13 +443,30 @@ pub async fn start_managed_repair(
 
     let install_app = app.clone();
     let install_state = install_state.inner().clone();
+    let install_diagnostics = diagnostics_state.clone();
+    let install_repair_group_id = repair_group_id.clone();
     let install_result = tokio::task::spawn_blocking(move || {
-        install::run_install_for_repair(install_app, install_state)
+        install::run_install_for_repair(
+            install_app,
+            install_state,
+            install_diagnostics,
+            install_repair_group_id,
+        )
     })
     .await
     .map_err(|e| format!("Repair install task panicked: {e}"))?;
 
     if let Err(msg) = install_result {
+        diagnostics::finish_repair_group(
+            &diagnostics_state,
+            &repair_group_id,
+            if msg == "NEEDS_ELEVATION" {
+                "needs_elevation"
+            } else {
+                "failed"
+            },
+            Some(msg.clone()),
+        );
         if should_emit_repair_failed(&msg) {
             error!("Managed repair installer failed: {}", msg);
             let _ = app.emit("repair-failed", &msg);
@@ -391,18 +476,27 @@ pub async fn start_managed_repair(
 
     if managed_install_ready_after_repair().await {
         info!("Managed repair complete after installer");
+        diagnostics::finish_repair_group(&diagnostics_state, &repair_group_id, "success", None);
         let _ = app.emit("repair-complete", ());
         return Ok(());
     }
 
     let msg = "Repair finished, but Studio install is still not desktop-ready.".to_string();
     error!("{}", msg);
+    diagnostics::finish_repair_group(
+        &diagnostics_state,
+        &repair_group_id,
+        "failed",
+        Some(msg.clone()),
+    );
     let _ = app.emit("repair-failed", &msg);
     Err(msg)
 }
 
 #[cfg(test)]
 mod tests {
+    use std::time::Duration;
+
     #[test]
     fn repair_elevation_is_not_a_terminal_repair_failure() {
         assert!(!super::should_emit_repair_failed("NEEDS_ELEVATION"));
@@ -410,63 +504,132 @@ mod tests {
             "Installer exited with code 1"
         ));
     }
+
+    #[test]
+    fn watchdog_ignores_startup_failures_within_grace_period() {
+        assert!(!super::should_count_watchdog_failure(
+            false,
+            super::BACKEND_STARTUP_GRACE_PERIOD - Duration::from_secs(1)
+        ));
+    }
+
+    #[test]
+    fn watchdog_counts_failures_after_backend_was_healthy() {
+        assert!(super::should_count_watchdog_failure(
+            true,
+            Duration::from_secs(1)
+        ));
+    }
+
+    #[test]
+    fn watchdog_counts_startup_failures_after_grace_period() {
+        assert!(super::should_count_watchdog_failure(
+            false,
+            super::BACKEND_STARTUP_GRACE_PERIOD
+        ));
+    }
 }
 
 /// Periodic health check that detects deadlocked or hung backends.
-/// Starts 30s after the backend is launched (to allow initial startup),
-/// then pings /api/health every 15s. After 3 consecutive failures (45s)
-/// with the process still alive, emits `server-crashed` so the frontend
-/// can offer a restart.
-async fn health_watchdog(app: AppHandle, state: BackendState, shutdown: ShutdownFlag) {
+/// During startup, failures are ignored for a generous grace period so a slow
+/// but legitimate backend boot is not killed. After the backend has answered at
+/// least once, or after the startup grace expires, 3 consecutive failed checks
+/// emit `server-crashed` so the frontend can offer a restart.
+async fn health_watchdog(
+    app: AppHandle,
+    state: BackendState,
+    shutdown: ShutdownFlag,
+    diagnostics: DiagnosticsState,
+    generation: u64,
+) {
     use std::sync::atomic::Ordering;
 
-    // Give the backend time to start up
-    tokio::time::sleep(std::time::Duration::from_secs(30)).await;
-
+    let started_at = Instant::now();
     let mut consecutive_failures: u32 = 0;
+    let mut has_seen_healthy = false;
 
     loop {
-        tokio::time::sleep(std::time::Duration::from_secs(15)).await;
+        tokio::time::sleep(HEALTH_WATCHDOG_INTERVAL).await;
 
         if shutdown.load(Ordering::SeqCst) {
             info!("Health watchdog: shutdown flag set, exiting");
             break;
         }
 
-        let (port, has_child) = {
+        let (port, has_child, current_generation) = {
             let proc = match state.lock() {
                 Ok(p) => p,
                 Err(_) => break,
             };
-            (proc.port, proc.child.is_some())
+            (proc.port, proc.child.is_some(), proc.generation)
         };
 
+        if current_generation != generation {
+            info!("Health watchdog: backend generation changed, exiting");
+            break;
+        }
+
         // Stop watching if the backend is gone
         if !has_child {
             info!("Health watchdog: backend stopped, exiting");
             break;
         }
 
+        let should_count_failure =
+            should_count_watchdog_failure(has_seen_healthy, started_at.elapsed());
+
         let Some(port) = port else {
-            continue; // Port not yet known
+            if should_count_failure {
+                consecutive_failures += 1;
+                warn!(
+                    "Health watchdog: backend has not reported a port ({}/{})",
+                    consecutive_failures, HEALTH_WATCHDOG_MAX_FAILURES
+                );
+            }
+
+            if consecutive_failures >= HEALTH_WATCHDOG_MAX_FAILURES {
+                error!(
+                    "Health watchdog: backend never reported a port, killing and declaring dead"
+                );
+                diagnostics::record_backend_watchdog(
+                    &diagnostics,
+                    generation,
+                    "no_port_after_grace",
+                );
+                let _ = process::stop_backend(&state, &shutdown, Some(&diagnostics));
+                let _ = app.emit("server-crashed", ());
+                break;
+            }
+
+            continue;
         };
 
         match check_health_inner(port).await {
             Ok(true) => {
+                has_seen_healthy = true;
                 consecutive_failures = 0;
             }
+            _ if !should_count_failure => {
+                info!(
+                    "Health watchdog: startup health check failed on port {} before grace period elapsed",
+                    port
+                );
+            }
             _ => {
                 consecutive_failures += 1;
                 warn!(
-                    "Health watchdog: failure {}/3 on port {}",
-                    consecutive_failures, port
+                    "Health watchdog: failure {}/{} on port {}",
+                    consecutive_failures, HEALTH_WATCHDOG_MAX_FAILURES, port
                 );
-                if consecutive_failures >= 3 {
-                    error!(
-                        "Health watchdog: backend unresponsive for 45s, killing and declaring dead"
+                if consecutive_failures >= HEALTH_WATCHDOG_MAX_FAILURES {
+                    error!("Health watchdog: backend unresponsive, killing and declaring dead");
+                    diagnostics::record_backend_watchdog(
+                        &diagnostics,
+                        generation,
+                        "unresponsive_health_check",
                     );
                     // Kill the zombie process so retry can start fresh
-                    let _ = process::stop_backend(&state, &shutdown);
+                    let _ = process::stop_backend(&state, &shutdown, Some(&diagnostics));
                     let _ = app.emit("server-crashed", ());
                     break;
                 }
diff --git a/studio/src-tauri/src/desktop_auth.rs b/studio/src-tauri/src/desktop_auth.rs
index df09df7a14..483e7c0432 100644
--- a/studio/src-tauri/src/desktop_auth.rs
+++ b/studio/src-tauri/src/desktop_auth.rs
@@ -1,6 +1,7 @@
+use crate::diagnostics::{self, DiagnosticsState};
 use crate::preflight::{DesktopPreflightDisposition, DesktopPreflightResult};
 use crate::process::BackendState;
-use log::info;
+use log::{info, warn};
 use reqwest::Client;
 use serde::{Deserialize, Serialize};
 use std::path::{Path, PathBuf};
@@ -39,13 +40,16 @@ struct BackendPort {
 #[derive(Debug)]
 enum AuthError {
     Connectivity(String),
+    StaleResponder(String),
     Failed(String),
 }
 
 impl AuthError {
     fn message(self) -> String {
         match self {
-            Self::Connectivity(message) | Self::Failed(message) => message,
+            Self::Connectivity(message) | Self::StaleResponder(message) | Self::Failed(message) => {
+                message
+            }
         }
     }
 }
@@ -73,11 +77,14 @@ fn read_secret_if_exists(path: &Path) -> Result<Option<String>, String> {
     match std::fs::read_to_string(path) {
         Ok(s) => Ok(Some(s.trim().to_string())),
         Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(None),
-        Err(e) => Err(format!(
-            "Failed to read auth secret at {}: {}",
-            path.display(),
-            e
-        )),
+        Err(e) => {
+            warn!(
+                "Desktop auth: ignoring unreadable auth secret at {}: {}",
+                path.display(),
+                e
+            );
+            Ok(None)
+        }
     }
 }
 
@@ -138,7 +145,10 @@ fn classify_auth_send_error(error: reqwest::Error) -> AuthError {
 fn should_retry_with_discovered_port(source: PortSource, error: &AuthError) -> bool {
     matches!(
         (source, error),
-        (PortSource::Cached, AuthError::Connectivity(_))
+        (
+            PortSource::Cached,
+            AuthError::Connectivity(_) | AuthError::StaleResponder(_)
+        )
     )
 }
 
@@ -157,7 +167,7 @@ async fn exchange_desktop_secret(
         .map_err(classify_auth_send_error)?;
 
     if response.status() == reqwest::StatusCode::NOT_FOUND {
-        return Err(AuthError::Failed(
+        return Err(AuthError::StaleResponder(
             "Running Studio backend is too old for this desktop app. Update that backend and restart."
                 .to_string(),
         ));
@@ -166,7 +176,7 @@ async fn exchange_desktop_secret(
         return Ok(None);
     }
     if !response.status().is_success() {
-        return Err(AuthError::Failed("Desktop auth failed".to_string()));
+        return Err(AuthError::StaleResponder("Desktop auth failed".to_string()));
     }
 
     response
@@ -213,6 +223,33 @@ async fn provision_desktop_auth() -> Result<(), String> {
     ))
 }
 
+async fn retry_on_discovered_port(
+    client: &Client,
+    state: &tauri::State<'_, BackendState>,
+    previous: BackendPort,
+    secret: &str,
+) -> Result<Option<(Option<DesktopAuthResponse>, BackendPort)>, String> {
+    if previous.source != PortSource::Cached {
+        return Ok(None);
+    }
+    let Some(port) = discover_compatible_backend_port().await else {
+        return Ok(None);
+    };
+    if port == previous.port {
+        return Ok(None);
+    }
+
+    update_backend_port(state, port)?;
+    let backend = BackendPort {
+        port,
+        source: PortSource::Discovered,
+    };
+    exchange_desktop_secret(client, port, secret)
+        .await
+        .map(|tokens| Some((tokens, backend)))
+        .map_err(AuthError::message)
+}
+
 async fn authenticate_with_stale_port_retry(
     client: &Client,
     state: &tauri::State<'_, BackendState>,
@@ -220,20 +257,19 @@ async fn authenticate_with_stale_port_retry(
     secret: &str,
 ) -> Result<(Option<DesktopAuthResponse>, BackendPort), String> {
     match exchange_desktop_secret(client, backend.port, secret).await {
-        Ok(tokens) => Ok((tokens, backend)),
+        Ok(Some(tokens)) => Ok((Some(tokens), backend)),
+        Ok(None) => {
+            // 401 means the backend is reachable but the cached secret is stale.
+            // Keep using the same backend so the next desktop_auth_inner attempt
+            // provisions a new secret for the server we are retrying instead of
+            // switching to an unrelated discovered/attached backend.
+            Ok((None, backend))
+        }
         Err(error) if should_retry_with_discovered_port(backend.source, &error) => {
-            let Some(port) = discover_compatible_backend_port().await else {
-                return Err(error.message());
-            };
-            update_backend_port(state, port)?;
-            let backend = BackendPort {
-                port,
-                source: PortSource::Discovered,
-            };
-            exchange_desktop_secret(client, port, secret)
-                .await
-                .map(|tokens| (tokens, backend))
-                .map_err(AuthError::message)
+            if let Some(retried) = retry_on_discovered_port(client, state, backend, secret).await? {
+                return Ok(retried);
+            }
+            Err(error.message())
         }
         Err(error) => Err(error.message()),
     }
@@ -242,9 +278,25 @@ async fn authenticate_with_stale_port_retry(
 #[tauri::command]
 pub async fn desktop_auth(
     state: tauri::State<'_, BackendState>,
+    diagnostics: tauri::State<'_, DiagnosticsState>,
+) -> Result<DesktopAuthResponse, String> {
+    let result = desktop_auth_inner(&state, diagnostics.inner()).await;
+    if let Err(message) = &result {
+        let port = state.lock().ok().and_then(|proc| proc.port);
+        diagnostics::record_auth_failure(&diagnostics, "desktop_auth", port, message);
+    }
+    result
+}
+
+async fn desktop_auth_inner(
+    state: &tauri::State<'_, BackendState>,
+    diagnostics: &DiagnosticsState,
 ) -> Result<DesktopAuthResponse, String> {
     let _auth_guard = DESKTOP_AUTH_LOCK.lock().await;
-    let mut backend = current_backend_port(&state).await?;
+    let mut backend = current_backend_port(state).await?;
+    if backend.source == PortSource::Discovered {
+        diagnostics::record_attached_external_backend(diagnostics, backend.port);
+    }
     let client = Client::builder()
         .timeout(std::time::Duration::from_secs(5))
         .build()
@@ -263,8 +315,11 @@ pub async fn desktop_auth(
 
         info!("Desktop auth: exchanging desktop secret");
         let (tokens, resolved_backend) =
-            authenticate_with_stale_port_retry(&client, &state, backend, &secret).await?;
+            authenticate_with_stale_port_retry(&client, state, backend, &secret).await?;
         backend = resolved_backend;
+        if backend.source == PortSource::Discovered {
+            diagnostics::record_attached_external_backend(diagnostics, backend.port);
+        }
         if let Some(tokens) = tokens {
             return Ok(tokens);
         }
@@ -317,11 +372,15 @@ mod tests {
     }
 
     #[test]
-    fn retry_discovery_only_for_cached_connectivity_errors() {
+    fn retry_discovery_only_for_cached_recoverable_errors() {
         assert!(should_retry_with_discovered_port(
             PortSource::Cached,
             &AuthError::Connectivity("connection refused".to_string())
         ));
+        assert!(should_retry_with_discovered_port(
+            PortSource::Cached,
+            &AuthError::StaleResponder("old responder".to_string())
+        ));
         assert!(!should_retry_with_discovered_port(
             PortSource::Discovered,
             &AuthError::Connectivity("connection refused".to_string())
@@ -332,6 +391,64 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn read_secret_returns_none_for_missing_file() {
+        let path = std::env::temp_dir().join(format!(
+            "unsloth-missing-desktop-secret-{}",
+            std::process::id()
+        ));
+        let _ = std::fs::remove_file(&path);
+
+        assert_eq!(read_secret_if_exists(&path).unwrap(), None);
+    }
+
+    #[test]
+    fn read_secret_trims_existing_file() {
+        let path =
+            std::env::temp_dir().join(format!("unsloth-desktop-secret-{}", std::process::id()));
+        std::fs::write(&path, "  desktop-secret\n").unwrap();
+
+        assert_eq!(
+            read_secret_if_exists(&path).unwrap(),
+            Some("desktop-secret".to_string())
+        );
+        std::fs::remove_file(path).unwrap();
+    }
+
+    #[test]
+    fn read_secret_treats_invalid_utf8_as_missing_for_repair() {
+        let path = std::env::temp_dir().join(format!(
+            "unsloth-invalid-desktop-secret-{}",
+            std::process::id()
+        ));
+        std::fs::write(&path, [0xff, 0xfe]).unwrap();
+
+        assert_eq!(read_secret_if_exists(&path).unwrap(), None);
+        std::fs::remove_file(path).unwrap();
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn read_secret_treats_permission_denied_as_missing_for_repair() {
+        use std::os::unix::fs::PermissionsExt;
+
+        let path = std::env::temp_dir().join(format!(
+            "unsloth-unreadable-desktop-secret-{}",
+            std::process::id()
+        ));
+        std::fs::write(&path, "desktop-stale").unwrap();
+        std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o000)).unwrap();
+
+        let result = read_secret_if_exists(&path);
+
+        std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600)).unwrap();
+        std::fs::remove_file(path).unwrap();
+        if matches!(result, Ok(Some(_))) {
+            return;
+        }
+        assert_eq!(result.unwrap(), None);
+    }
+
     #[test]
     fn attached_ready_port_requires_attached_ready_with_port() {
         let compatible = DesktopPreflightResult {
diff --git a/studio/src-tauri/src/diagnostics/mod.rs b/studio/src-tauri/src/diagnostics/mod.rs
new file mode 100644
index 0000000000..5ab940af38
--- /dev/null
+++ b/studio/src-tauri/src/diagnostics/mod.rs
@@ -0,0 +1,169 @@
+mod phase_log;
+mod redaction;
+mod report;
+mod state;
+
+use crate::process::BackendState;
+use std::path::PathBuf;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+use tauri::AppHandle;
+
+pub use phase_log::append_phase_line;
+#[cfg(target_os = "linux")]
+pub use phase_log::PhaseLogHandle;
+pub use state::{
+    begin_backend_session, begin_install_attempt, begin_repair_child, begin_repair_group,
+    begin_update_attempt, finish_attempt, finish_repair_group, new_diagnostics_state,
+    record_attached_external_backend, record_auth_failure, record_backend_exit,
+    record_backend_intentional_stop, record_backend_port, record_backend_start_failure,
+    record_backend_watchdog, record_diag_marker, record_elevation_packages, record_preflight,
+    record_progress, record_step, AttemptLog, BackendLog, DiagnosticsState,
+    FrontendSupportSnapshot,
+};
+
+pub const SCHEMA_VERSION: u32 = 1;
+pub const PHASE_LOG_SEGMENT_MAX_BYTES: u64 = 5 * 1024 * 1024;
+pub const PHASE_LOG_MAX_SEGMENTS_PER_GROUP: usize = 3;
+#[allow(dead_code)]
+pub const PHASE_LOG_KEEP_GROUPS_PER_KIND: usize = 5;
+pub const TAIL_MAX_LINES: usize = 1000;
+pub const TAIL_MAX_BYTES: usize = 200 * 1024;
+pub const REPORT_MAX_BYTES: usize = 1024 * 1024;
+
+pub(crate) const MAX_STATE_ITEMS: usize = 200;
+pub(crate) const MAX_PHASE_LINE_BYTES: usize = 16 * 1024;
+pub(crate) const FOOTER_BUDGET_BYTES: usize = 8 * 1024;
+
+static ID_COUNTER: AtomicU64 = AtomicU64::new(1);
+
+pub(crate) fn now_ms() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_else(|_| Duration::from_secs(0))
+        .as_millis() as u64
+}
+
+pub(crate) fn new_id(prefix: &str) -> String {
+    let n = ID_COUNTER.fetch_add(1, Ordering::Relaxed);
+    format!("{}-{}-{}", sanitize_component(prefix), now_ms(), n)
+}
+
+pub fn studio_dir() -> PathBuf {
+    dirs::home_dir()
+        .unwrap_or_else(|| PathBuf::from("."))
+        .join(".unsloth")
+        .join("studio")
+}
+
+pub fn logs_dir() -> PathBuf {
+    studio_dir().join("logs")
+}
+
+pub(crate) fn cap_string(value: &str, max: usize) -> String {
+    if value.len() <= max {
+        return value.to_string();
+    }
+    let boundary = valid_utf8_boundary(value, max);
+    format!("{} [truncated]", &value[..boundary])
+}
+
+pub(crate) fn valid_utf8_boundary(s: &str, max: usize) -> usize {
+    if max >= s.len() {
+        return s.len();
+    }
+    let mut index = max;
+    while index > 0 && !s.is_char_boundary(index) {
+        index -= 1;
+    }
+    index
+}
+
+pub(crate) fn sanitize_component(value: &str) -> String {
+    value
+        .chars()
+        .map(|ch| {
+            if ch.is_ascii_alphanumeric() || ch == '-' || ch == '_' || ch == '.' {
+                ch
+            } else {
+                '_'
+            }
+        })
+        .collect()
+}
+
+#[tauri::command]
+pub async fn collect_support_diagnostics(
+    _app: AppHandle,
+    diagnostics: tauri::State<'_, DiagnosticsState>,
+    backend: tauri::State<'_, BackendState>,
+    snapshot: FrontendSupportSnapshot,
+) -> Result<String, String> {
+    let diagnostics_snapshot = state::clone_snapshot(diagnostics.inner());
+    let backend_port = backend.lock().ok().and_then(|proc| proc.port).or_else(|| {
+        diagnostics_snapshot
+            .backend
+            .as_ref()
+            .and_then(|backend| backend.reported_port.or(backend.requested_port))
+    });
+
+    let health = match backend_port {
+        Some(port) => Some(collect_backend_health(port).await),
+        None => None,
+    };
+
+    match tokio::task::spawn_blocking(move || {
+        report::render_report(diagnostics_snapshot, snapshot, health)
+    })
+    .await
+    {
+        Ok(report) => Ok(report),
+        Err(error) => Ok(format!(
+            "DEGRADED RUST DIAGNOSTICS\ncollection_warning=report task failed: {error}\n"
+        )),
+    }
+}
+
+async fn collect_backend_health(port: u16) -> report::BackendHealthSection {
+    let mut section = report::BackendHealthSection {
+        port,
+        fields: Vec::new(),
+        warning: None,
+    };
+    let client = match reqwest::Client::builder()
+        .timeout(Duration::from_millis(750))
+        .build()
+    {
+        Ok(client) => client,
+        Err(error) => {
+            section.warning = Some(format!("health client unavailable: {error}"));
+            return section;
+        }
+    };
+    let url = format!("http://127.0.0.1:{port}/api/health");
+    match client.get(url).send().await {
+        Ok(response) => match response.json::<serde_json::Value>().await {
+            Ok(json) => {
+                for key in [
+                    "status",
+                    "service",
+                    "version",
+                    "device_type",
+                    "chat_only",
+                    "desktop_protocol_version",
+                    "supports_api_only",
+                    "supports_desktop_auth",
+                ] {
+                    if let Some(value) = json.get(key) {
+                        section
+                            .fields
+                            .push((key.to_string(), report::selected_json_value(value)));
+                    }
+                }
+            }
+            Err(error) => section.warning = Some(format!("health json unavailable: {error}")),
+        },
+        Err(error) => section.warning = Some(format!("health request unavailable: {error}")),
+    }
+    section
+}
diff --git a/studio/src-tauri/src/diagnostics/phase_log.rs b/studio/src-tauri/src/diagnostics/phase_log.rs
new file mode 100644
index 0000000000..a1e0c5424c
--- /dev/null
+++ b/studio/src-tauri/src/diagnostics/phase_log.rs
@@ -0,0 +1,823 @@
+use log::warn;
+use std::collections::{BTreeMap, HashMap};
+use std::fs::{self, File, OpenOptions};
+use std::io::{Read, Write};
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, Mutex};
+use std::time::UNIX_EPOCH;
+
+use super::state::{
+    forget_segment_path, record_segment_path, DiagnosticsSnapshot, DiagnosticsState,
+};
+use super::{
+    logs_dir, now_ms, sanitize_component, valid_utf8_boundary, MAX_PHASE_LINE_BYTES,
+    PHASE_LOG_KEEP_GROUPS_PER_KIND, PHASE_LOG_MAX_SEGMENTS_PER_GROUP, PHASE_LOG_SEGMENT_MAX_BYTES,
+    SCHEMA_VERSION,
+};
+
+pub type PhaseLogHandle = Arc<Mutex<PhaseLogWriter>>;
+
+#[derive(Clone, Debug)]
+pub(crate) enum SegmentOwner {
+    Install {
+        attempt_id: String,
+    },
+    Update {
+        attempt_id: String,
+    },
+    Repair {
+        repair_group_id: String,
+        attempt_id: String,
+        child_type: String,
+    },
+    Backend {
+        session_id: String,
+    },
+}
+
+pub struct PhaseLogWriter {
+    owner: SegmentOwner,
+    flow: String,
+    started_at_ms: u64,
+    backend_kind: Option<String>,
+    log_dir: PathBuf,
+    segment_index: usize,
+    current_bytes: u64,
+    segments: Vec<PathBuf>,
+    file: Option<File>,
+    disabled: bool,
+    disable_reason: Option<String>,
+    diagnostics: DiagnosticsState,
+    max_bytes: u64,
+    max_segments: usize,
+}
+
+impl PhaseLogWriter {
+    pub(crate) fn new(
+        diagnostics: DiagnosticsState,
+        owner: SegmentOwner,
+        flow: impl Into<String>,
+        started_at_ms: u64,
+        backend_kind: Option<String>,
+    ) -> Self {
+        let mut writer = Self {
+            owner,
+            flow: flow.into(),
+            started_at_ms,
+            backend_kind,
+            log_dir: logs_dir(),
+            segment_index: 1,
+            current_bytes: 0,
+            segments: Vec::new(),
+            file: None,
+            disabled: false,
+            disable_reason: None,
+            diagnostics,
+            max_bytes: PHASE_LOG_SEGMENT_MAX_BYTES,
+            max_segments: PHASE_LOG_MAX_SEGMENTS_PER_GROUP,
+        };
+        writer.open_segment();
+        writer
+    }
+
+    #[cfg(test)]
+    fn new_for_test(
+        diagnostics: DiagnosticsState,
+        owner: SegmentOwner,
+        flow: impl Into<String>,
+        started_at_ms: u64,
+        log_dir: PathBuf,
+        max_bytes: u64,
+        max_segments: usize,
+    ) -> Self {
+        let mut writer = Self {
+            owner,
+            flow: flow.into(),
+            started_at_ms,
+            backend_kind: None,
+            log_dir,
+            segment_index: 1,
+            current_bytes: 0,
+            segments: Vec::new(),
+            file: None,
+            disabled: false,
+            disable_reason: None,
+            diagnostics,
+            max_bytes,
+            max_segments,
+        };
+        writer.open_segment();
+        writer
+    }
+
+    fn open_segment(&mut self) {
+        if self.disabled {
+            return;
+        }
+        if let Err(error) = ensure_logs_dir_at(&self.log_dir) {
+            self.disable(format!("failed to create diagnostics log dir: {error}"));
+            return;
+        }
+        if self.segment_index == 1 {
+            cleanup_retention(&self.log_dir, &self.flow, &owner_group_key(&self.owner));
+        }
+
+        let path = self.segment_path(self.segment_index);
+        if path_has_symlink(&path) {
+            self.disable(format!(
+                "refusing to write diagnostics phase log through symlink: {}",
+                path.display()
+            ));
+            return;
+        }
+
+        let mut options = OpenOptions::new();
+        options.create(true).append(true);
+        #[cfg(unix)]
+        {
+            use std::os::unix::fs::OpenOptionsExt;
+            options.mode(0o600);
+        }
+
+        match options.open(&path) {
+            Ok(mut file) => {
+                let header = self.header();
+                if let Err(error) = file.write_all(header.as_bytes()) {
+                    self.disable(format!(
+                        "failed to write diagnostics phase log header to {}: {error}",
+                        path.display()
+                    ));
+                    return;
+                }
+                self.current_bytes = header.len() as u64;
+                self.segments.push(path.clone());
+                self.file = Some(file);
+                record_segment_path(&self.diagnostics, &self.owner, path);
+            }
+            Err(error) => self.disable(format!(
+                "failed to open diagnostics phase log {}: {error}",
+                path.display()
+            )),
+        }
+    }
+
+    fn header(&self) -> String {
+        let mut lines = vec![
+            "# Unsloth Studio diagnostics phase log".to_string(),
+            format!("diag_schema={SCHEMA_VERSION}"),
+            format!("flow={}", self.flow),
+            format!("segment_index={}", self.segment_index),
+            format!("started_at_ms={}", self.started_at_ms),
+        ];
+        match &self.owner {
+            SegmentOwner::Install { attempt_id }
+            | SegmentOwner::Update { attempt_id }
+            | SegmentOwner::Repair { attempt_id, .. } => {
+                lines.push(format!("attempt_id={attempt_id}"));
+            }
+            SegmentOwner::Backend { session_id } => {
+                lines.push(format!("attempt_id={session_id}"));
+                lines.push(format!("backend_session_id={session_id}"));
+            }
+        }
+        if let SegmentOwner::Repair {
+            repair_group_id,
+            child_type,
+            ..
+        } = &self.owner
+        {
+            lines.push(format!("repair_group_id={repair_group_id}"));
+            lines.push(format!("child_type={child_type}"));
+        }
+        if let Some(kind) = &self.backend_kind {
+            lines.push(format!("backend_kind={kind}"));
+        }
+        lines.push("--- log ---".to_string());
+        lines.push(String::new());
+        lines.join("\n")
+    }
+
+    fn segment_path(&self, segment_index: usize) -> PathBuf {
+        let name = match &self.owner {
+            SegmentOwner::Install { attempt_id } => {
+                format!(
+                    "install-{}-s{segment_index:02}.log",
+                    sanitize_component(attempt_id)
+                )
+            }
+            SegmentOwner::Update { attempt_id } => {
+                format!(
+                    "update-{}-s{segment_index:02}.log",
+                    sanitize_component(attempt_id)
+                )
+            }
+            SegmentOwner::Repair {
+                repair_group_id,
+                attempt_id,
+                child_type,
+            } => format!(
+                "repair-{}-{}-{}-s{segment_index:02}.log",
+                sanitize_component(repair_group_id),
+                sanitize_component(child_type),
+                sanitize_component(attempt_id)
+            ),
+            SegmentOwner::Backend { session_id } => {
+                format!(
+                    "backend-{}-s{segment_index:02}.log",
+                    sanitize_component(session_id)
+                )
+            }
+        };
+        self.log_dir.join(name)
+    }
+
+    fn append_line(&mut self, stream: &str, text: &str) {
+        if self.disabled {
+            return;
+        }
+        let mut line = text.replace('\r', "");
+        let mut truncated = false;
+        if line.len() > MAX_PHASE_LINE_BYTES {
+            line.truncate(valid_utf8_boundary(&line, MAX_PHASE_LINE_BYTES));
+            truncated = true;
+        }
+        if truncated {
+            line.push_str(" [line truncated]");
+        }
+        let entry = format!("[{}][{}] {}\n", now_ms(), stream, line);
+        if self.current_bytes + entry.len() as u64 > self.max_bytes {
+            self.rotate();
+        }
+        let Some(file) = self.file.as_mut() else {
+            return;
+        };
+        match file.write_all(entry.as_bytes()) {
+            Ok(()) => {
+                self.current_bytes += entry.len() as u64;
+            }
+            Err(error) => self.disable(format!("diagnostics phase log write failed: {error}")),
+        }
+    }
+
+    fn rotate(&mut self) {
+        self.file.take();
+        self.segment_index += 1;
+        self.current_bytes = 0;
+        self.open_segment();
+        self.prune_old_segments();
+    }
+
+    fn prune_old_segments(&mut self) {
+        while self.segments.len() > self.max_segments {
+            let old_path = self.segments.remove(0);
+            forget_segment_path(&self.diagnostics, &self.owner, &old_path);
+            safe_delete_phase_log(&self.log_dir, &old_path);
+        }
+    }
+
+    fn disable(&mut self, reason: String) {
+        if !self.disabled {
+            warn!("{}", reason);
+        }
+        self.disabled = true;
+        self.disable_reason = Some(reason);
+        self.file.take();
+    }
+}
+
+#[allow(dead_code)]
+pub fn ensure_logs_dir() -> std::io::Result<PathBuf> {
+    let dir = logs_dir();
+    ensure_logs_dir_at(&dir)?;
+    Ok(dir)
+}
+
+pub(crate) fn ensure_logs_dir_at(dir: &Path) -> std::io::Result<()> {
+    fs::create_dir_all(dir)?;
+    if fs::symlink_metadata(dir)
+        .map(|metadata| metadata.file_type().is_symlink())
+        .unwrap_or(false)
+    {
+        return Err(std::io::Error::new(
+            std::io::ErrorKind::Other,
+            "refusing diagnostics logs dir symlink",
+        ));
+    }
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        let _ = fs::set_permissions(dir, fs::Permissions::from_mode(0o700));
+    }
+    Ok(())
+}
+
+pub fn append_phase_line(handle: &PhaseLogHandle, stream: &str, text: &str) {
+    if let Ok(mut writer) = handle.lock() {
+        writer.append_line(stream, text);
+    }
+}
+#[derive(Debug)]
+pub(crate) struct PhaseGroup {
+    pub(crate) label: String,
+    pub(crate) source: String,
+    pub(crate) paths: Vec<PathBuf>,
+    pub(crate) note: Option<String>,
+}
+
+pub(crate) fn collect_phase_groups(
+    snapshot: &DiagnosticsSnapshot,
+    warnings: &mut Vec<String>,
+) -> Vec<PhaseGroup> {
+    let mut groups = Vec::new();
+    for install in snapshot.install_history.iter().rev().take(4).rev() {
+        if !install.log_segments.is_empty() {
+            groups.push(PhaseGroup {
+                label: format!("install:{}", install.attempt_id),
+                source: "live-state-history".to_string(),
+                paths: install.log_segments.clone(),
+                note: Some("previous linked install attempt retained in memory".to_string()),
+            });
+        }
+    }
+    if let Some(install) = &snapshot.install {
+        if !install.log_segments.is_empty() {
+            groups.push(PhaseGroup {
+                label: format!("install:{}", install.attempt_id),
+                source: "live-state".to_string(),
+                paths: install.log_segments.clone(),
+                note: None,
+            });
+        }
+    }
+    if let Some(update) = &snapshot.update {
+        if !update.log_segments.is_empty() {
+            groups.push(PhaseGroup {
+                label: format!("update:{}", update.attempt_id),
+                source: "live-state".to_string(),
+                paths: update.log_segments.clone(),
+                note: None,
+            });
+        }
+    }
+    for group in snapshot.repair_groups.iter().rev().take(5).rev() {
+        let mut paths = Vec::new();
+        for child in &group.children {
+            paths.extend(child.log_segments.clone());
+        }
+        if !paths.is_empty() {
+            groups.push(PhaseGroup {
+                label: format!("repair:{}", group.repair_group_id),
+                source: "live-state".to_string(),
+                paths,
+                note: None,
+            });
+        }
+    }
+    if let Some(backend) = &snapshot.backend {
+        if backend.backend_kind == "managed" && !backend.log_segments.is_empty() {
+            groups.push(PhaseGroup {
+                label: backend
+                    .session_id
+                    .as_ref()
+                    .map(|id| format!("backend:{id}"))
+                    .unwrap_or_else(|| "backend:unknown".to_string()),
+                source: "live-state".to_string(),
+                paths: backend.log_segments.clone(),
+                note: None,
+            });
+        } else if backend.backend_kind == "attached_external" {
+            groups.push(PhaseGroup {
+                label: "backend:attached_external".to_string(),
+                source: "live-state".to_string(),
+                paths: Vec::new(),
+                note: Some("Tauri does not own attached/external backend process logs".to_string()),
+            });
+        }
+    }
+
+    let has_install = groups.iter().any(|g| g.label.starts_with("install:"));
+    let has_update = groups.iter().any(|g| g.label.starts_with("update:"));
+    let has_repair = groups.iter().any(|g| g.label.starts_with("repair:"));
+    let has_backend = groups.iter().any(|g| g.label.starts_with("backend:"));
+    let fallback = scan_phase_logs(warnings);
+    for flow in ["install", "update", "repair", "backend"] {
+        let already_live = match flow {
+            "install" => has_install,
+            "update" => has_update,
+            "repair" => has_repair,
+            "backend" => has_backend,
+            _ => false,
+        };
+        if already_live {
+            continue;
+        }
+        if let Some(group) = latest_disk_group(&fallback, flow) {
+            groups.push(group);
+        }
+    }
+
+    groups
+}
+
+#[derive(Clone, Debug)]
+struct PhaseLogMeta {
+    path: PathBuf,
+    flow: String,
+    group_key: String,
+    segment_index: usize,
+    started_at_ms: u64,
+    mtime_ms: u64,
+}
+
+fn scan_phase_logs(warnings: &mut Vec<String>) -> Vec<PhaseLogMeta> {
+    scan_phase_logs_in_dir(&logs_dir(), warnings)
+}
+
+fn scan_phase_logs_in_dir(dir: &Path, warnings: &mut Vec<String>) -> Vec<PhaseLogMeta> {
+    let entries = match fs::read_dir(dir) {
+        Ok(entries) => entries,
+        Err(error) => {
+            warnings.push(format!("phase log dir unavailable: {error}"));
+            return Vec::new();
+        }
+    };
+    let mut metas = Vec::new();
+    for entry in entries.flatten() {
+        let path = entry.path();
+        let Some(file_name) = path.file_name().and_then(|n| n.to_str()) else {
+            continue;
+        };
+        if !is_phase_log_name(file_name) {
+            continue;
+        }
+        if path_has_symlink(&path) {
+            warnings.push(format!("ignored phase log symlink: {}", path.display()));
+            continue;
+        }
+        match parse_phase_log_meta(&path, file_name) {
+            Some(meta) => metas.push(meta),
+            None => warnings.push(format!(
+                "could not reconstruct phase log metadata: {}",
+                path.display()
+            )),
+        }
+    }
+    metas
+}
+
+fn safe_delete_phase_log(log_dir: &Path, path: &Path) {
+    if path_has_symlink(path) {
+        return;
+    }
+    let Ok(canonical_dir) = log_dir.canonicalize() else {
+        return;
+    };
+    let Ok(parent) = path.parent().unwrap_or(log_dir).canonicalize() else {
+        return;
+    };
+    if parent != canonical_dir {
+        return;
+    }
+    let Some(name) = path.file_name().and_then(|name| name.to_str()) else {
+        return;
+    };
+    if !is_phase_log_name(name) {
+        return;
+    }
+    let _ = fs::remove_file(path);
+}
+
+fn cleanup_retention(dir: &Path, flow: &str, current_group_key: &str) {
+    let canonical_dir = match dir.canonicalize() {
+        Ok(path) => path,
+        Err(_) => return,
+    };
+    let mut warnings = Vec::new();
+    let metas = scan_phase_logs_in_dir(dir, &mut warnings);
+    let mut groups: BTreeMap<String, Vec<PhaseLogMeta>> = BTreeMap::new();
+    for meta in metas.into_iter().filter(|meta| meta.flow == flow) {
+        groups.entry(meta.group_key.clone()).or_default().push(meta);
+    }
+    let mut ordered: Vec<(String, u64)> = groups
+        .iter()
+        .map(|(key, items)| {
+            let newest = items
+                .iter()
+                .map(|meta| meta.started_at_ms.max(meta.mtime_ms))
+                .max()
+                .unwrap_or(0);
+            (key.clone(), newest)
+        })
+        .collect();
+    ordered.sort_by_key(|(_, newest)| *newest);
+    let removable = ordered.len().saturating_sub(PHASE_LOG_KEEP_GROUPS_PER_KIND);
+    for (group_key, _) in ordered.into_iter().take(removable) {
+        if group_key == current_group_key {
+            continue;
+        }
+        let Some(items) = groups.get(&group_key) else {
+            continue;
+        };
+        for meta in items {
+            let Ok(parent) = meta.path.parent().unwrap_or(dir).canonicalize() else {
+                continue;
+            };
+            if parent != canonical_dir {
+                continue;
+            }
+            safe_delete_phase_log(dir, &meta.path);
+        }
+    }
+}
+
+fn owner_group_key(owner: &SegmentOwner) -> String {
+    match owner {
+        SegmentOwner::Install { attempt_id } => format!("install:{attempt_id}"),
+        SegmentOwner::Update { attempt_id } => format!("update:{attempt_id}"),
+        SegmentOwner::Repair {
+            repair_group_id, ..
+        } => format!("repair:{repair_group_id}"),
+        SegmentOwner::Backend { session_id } => format!("backend:{session_id}"),
+    }
+}
+
+fn parse_phase_log_meta(path: &Path, file_name: &str) -> Option<PhaseLogMeta> {
+    let mut file = File::open(path).ok()?;
+    let mut buf = vec![0u8; 8192];
+    let read = file.read(&mut buf).ok()?;
+    buf.truncate(read);
+    let header = String::from_utf8_lossy(&buf);
+    let mut map = HashMap::new();
+    for line in header.lines().take(32) {
+        if line == "--- log ---" {
+            break;
+        }
+        if let Some((key, value)) = line.split_once('=') {
+            map.insert(key.trim().to_string(), value.trim().to_string());
+        }
+    }
+
+    let flow = map
+        .get("flow")
+        .cloned()
+        .or_else(|| file_name.split('-').next().map(str::to_string))?;
+    let segment_index = map
+        .get("segment_index")
+        .and_then(|v| v.parse::<usize>().ok())
+        .or_else(|| segment_from_filename(file_name))
+        .unwrap_or(1);
+    let started_at_ms = map
+        .get("started_at_ms")
+        .and_then(|v| v.parse::<u64>().ok())
+        .unwrap_or_else(|| file_mtime_ms(path).unwrap_or(0));
+    let mtime_ms = file_mtime_ms(path).unwrap_or(started_at_ms);
+    let group_key = if flow == "repair" {
+        map.get("repair_group_id")
+            .cloned()
+            .or_else(|| repair_group_from_filename(file_name))
+            .map(|id| format!("repair:{id}"))?
+    } else if flow == "backend" {
+        map.get("backend_session_id")
+            .or_else(|| map.get("attempt_id"))
+            .cloned()
+            .or_else(|| attempt_from_filename(file_name, "backend"))
+            .map(|id| format!("backend:{id}"))?
+    } else {
+        map.get("attempt_id")
+            .cloned()
+            .or_else(|| attempt_from_filename(file_name, &flow))
+            .map(|id| format!("{flow}:{id}"))?
+    };
+
+    Some(PhaseLogMeta {
+        path: path.to_path_buf(),
+        flow,
+        group_key,
+        segment_index,
+        started_at_ms,
+        mtime_ms,
+    })
+}
+
+fn latest_disk_group(metas: &[PhaseLogMeta], flow: &str) -> Option<PhaseGroup> {
+    let mut groups: BTreeMap<String, Vec<PhaseLogMeta>> = BTreeMap::new();
+    for meta in metas.iter().filter(|m| m.flow == flow) {
+        groups
+            .entry(meta.group_key.clone())
+            .or_default()
+            .push(meta.clone());
+    }
+    let (_, mut selected) = groups
+        .into_iter()
+        .max_by_key(|(_, items)| items.iter().map(|m| (m.started_at_ms, m.mtime_ms)).max())?;
+    selected.sort_by_key(|m| (m.started_at_ms, m.segment_index, m.path.clone()));
+    let label = selected
+        .first()
+        .map(|m| m.group_key.clone())
+        .unwrap_or_else(|| format!("{flow}:unknown"));
+    Some(PhaseGroup {
+        label,
+        source: "disk-fallback".to_string(),
+        paths: selected.into_iter().map(|m| m.path).collect(),
+        note: Some("reconstructed from phase-log headers/filenames".to_string()),
+    })
+}
+
+pub(crate) fn path_has_symlink(path: &Path) -> bool {
+    fs::symlink_metadata(path)
+        .map(|metadata| metadata.file_type().is_symlink())
+        .unwrap_or(false)
+}
+
+fn file_mtime_ms(path: &Path) -> Option<u64> {
+    fs::metadata(path)
+        .ok()?
+        .modified()
+        .ok()?
+        .duration_since(UNIX_EPOCH)
+        .ok()
+        .map(|d| d.as_millis() as u64)
+}
+
+fn is_phase_log_name(name: &str) -> bool {
+    name.ends_with(".log")
+        && (name.starts_with("install-")
+            || name.starts_with("update-")
+            || name.starts_with("repair-")
+            || name.starts_with("backend-"))
+}
+
+fn segment_from_filename(name: &str) -> Option<usize> {
+    let stem = name.strip_suffix(".log")?;
+    let segment = stem.rsplit_once("-s")?.1;
+    segment.parse::<usize>().ok()
+}
+
+fn attempt_from_filename(name: &str, flow: &str) -> Option<String> {
+    let stem = name.strip_suffix(".log")?;
+    let rest = stem.strip_prefix(&format!("{flow}-"))?;
+    let (attempt, _) = rest.rsplit_once("-s")?;
+    Some(attempt.to_string())
+}
+
+fn repair_group_from_filename(name: &str) -> Option<String> {
+    let stem = name.strip_suffix(".log")?;
+    let rest = stem.strip_prefix("repair-")?;
+    let (before_segment, _) = rest.rsplit_once("-s")?;
+
+    // New repair filenames include both child type and attempt id:
+    // repair-<repair_group_id>-<child_type>-<attempt_id>-sNN.log.
+    // Repair/attempt ids contain hyphens, so split on the deterministic
+    // child/attempt prefix pair emitted by SegmentOwner::Repair.
+    for child_type in [
+        "update",
+        "install",
+        "elevation",
+        "resume",
+        "resume_update",
+        "resume_install",
+    ] {
+        let marker = format!("-{child_type}-{child_type}-");
+        if let Some((group, _)) = before_segment.split_once(&marker) {
+            return Some(group.to_string());
+        }
+    }
+
+    // Backward-compatible fallback for the older repair-<group>-<child>-sNN form.
+    let (group, _) = before_segment.rsplit_once('-')?;
+    Some(group.to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::diagnostics::state::{clone_snapshot, with_snapshot, AttemptSummary};
+    use crate::diagnostics::{new_diagnostics_state, now_ms};
+
+    #[test]
+    fn phase_writer_keeps_latest_segments_and_terminal_lines() {
+        let dir = std::env::temp_dir().join(format!(
+            "unsloth-phase-writer-{}-{}",
+            std::process::id(),
+            now_ms()
+        ));
+        let diagnostics = new_diagnostics_state();
+        let attempt_id = "install-test".to_string();
+        with_snapshot(&diagnostics, |snapshot| {
+            snapshot.install = Some(AttemptSummary::new(
+                "install",
+                attempt_id.clone(),
+                None,
+                None,
+                now_ms(),
+            ));
+        });
+        let mut writer = PhaseLogWriter::new_for_test(
+            diagnostics.clone(),
+            SegmentOwner::Install {
+                attempt_id: attempt_id.clone(),
+            },
+            "install",
+            now_ms(),
+            dir.clone(),
+            128,
+            2,
+        );
+        for i in 0..100 {
+            writer.append_line("stdout", &format!("chunk {i}"));
+        }
+        writer.append_line("stdout", "terminal failure survives");
+        let snapshot = clone_snapshot(&diagnostics);
+        let segments = snapshot.install.unwrap().log_segments;
+        assert_eq!(segments.len(), 2);
+        let total_size: u64 = segments
+            .iter()
+            .map(|path| fs::metadata(path).unwrap().len())
+            .sum();
+        assert!(total_size < 1024);
+        assert!(segments.iter().any(|path| {
+            fs::read_to_string(path)
+                .map(|text| text.contains("terminal failure survives"))
+                .unwrap_or(false)
+        }));
+        assert!(!dir.join("install-install-test-s01.log").exists());
+        let _ = fs::remove_dir_all(dir);
+    }
+
+    #[test]
+    fn repair_group_filename_fallback_handles_attempt_id_suffix() {
+        let filename = "repair-repair-123-4-install-install-567-8-s01.log";
+        assert_eq!(
+            repair_group_from_filename(filename),
+            Some("repair-123-4".to_string())
+        );
+    }
+
+    #[test]
+    fn repair_children_with_same_type_get_unique_segment_paths() {
+        let dir = std::env::temp_dir().join(format!(
+            "unsloth-repair-paths-{}-{}",
+            std::process::id(),
+            now_ms()
+        ));
+        let diagnostics = new_diagnostics_state();
+        let first = PhaseLogWriter::new_for_test(
+            diagnostics.clone(),
+            SegmentOwner::Repair {
+                repair_group_id: "repair-group".to_string(),
+                attempt_id: "attempt-one".to_string(),
+                child_type: "install".to_string(),
+            },
+            "repair",
+            now_ms(),
+            dir.clone(),
+            1024,
+            2,
+        );
+        let second = PhaseLogWriter::new_for_test(
+            diagnostics,
+            SegmentOwner::Repair {
+                repair_group_id: "repair-group".to_string(),
+                attempt_id: "attempt-two".to_string(),
+                child_type: "install".to_string(),
+            },
+            "repair",
+            now_ms(),
+            dir.clone(),
+            1024,
+            2,
+        );
+
+        assert_ne!(first.segment_path(1), second.segment_path(1));
+        let _ = fs::remove_dir_all(dir);
+    }
+
+    #[test]
+    fn parses_latest_disk_group_by_metadata_not_mtime_only() {
+        let dir = std::env::temp_dir().join(format!(
+            "unsloth-phase-parse-{}-{}",
+            std::process::id(),
+            now_ms()
+        ));
+        fs::create_dir_all(&dir).unwrap();
+        let old = dir.join("install-old-s01.log");
+        let new = dir.join("install-new-s01.log");
+        fs::write(
+            &old,
+            "diag_schema=1\nflow=install\nattempt_id=old\nsegment_index=1\nstarted_at_ms=1\n--- log ---\nold\n",
+        )
+        .unwrap();
+        fs::write(
+            &new,
+            "diag_schema=1\nflow=install\nattempt_id=new\nsegment_index=1\nstarted_at_ms=2\n--- log ---\nnew\n",
+        )
+        .unwrap();
+        let metas = vec![
+            parse_phase_log_meta(&old, "install-old-s01.log").unwrap(),
+            parse_phase_log_meta(&new, "install-new-s01.log").unwrap(),
+        ];
+        let group = latest_disk_group(&metas, "install").unwrap();
+        assert_eq!(group.label, "install:new");
+        let _ = fs::remove_dir_all(dir);
+    }
+}
diff --git a/studio/src-tauri/src/diagnostics/redaction.rs b/studio/src-tauri/src/diagnostics/redaction.rs
new file mode 100644
index 0000000000..0c7a92944a
--- /dev/null
+++ b/studio/src-tauri/src/diagnostics/redaction.rs
@@ -0,0 +1,217 @@
+use regex::Regex;
+use std::path::Path;
+use std::sync::OnceLock;
+
+use super::studio_dir;
+
+#[derive(Default, Debug)]
+pub(crate) struct RedactionReport {
+    pub(crate) replacements: usize,
+}
+
+pub(crate) fn redact_text(text: &str, report: &mut RedactionReport) -> String {
+    let mut out = ansi_re().replace_all(text, "").to_string();
+    if out.len() != text.len() {
+        report.replacements += 1;
+    }
+    out = replace_regex(private_key_re(), &out, "<redacted private key>", report);
+    out = replace_regex(url_credentials_re(), &out, "$1<redacted>@", report);
+    out = replace_regex(auth_header_re(), &out, "$1: <redacted>", report);
+    out = replace_regex(cookie_re(), &out, "$1: <redacted>", report);
+    out = replace_regex(token_re(), &out, "<redacted token>", report);
+    out = replace_regex(env_secret_re(), &out, "$1=<redacted>", report);
+    out = replace_regex(
+        native_path_lease_re(),
+        &out,
+        "$1<redacted native path lease>",
+        report,
+    );
+    out = replace_known_paths(&out, report);
+    out = replace_regex(windows_studio_re(), &out, "<studio_home>", report);
+    out = replace_regex(windows_home_re(), &out, "%USERPROFILE%", report);
+    out = replace_regex(unix_studio_re(), &out, "<studio_home>", report);
+    out = replace_regex(unix_home_re(), &out, "$HOME", report);
+    out = replace_regex(email_re(), &out, "<redacted email>", report);
+    out
+}
+
+fn replace_regex(
+    regex: &'static Regex,
+    input: &str,
+    replacement: &str,
+    report: &mut RedactionReport,
+) -> String {
+    let count = regex.find_iter(input).count();
+    if count > 0 {
+        report.replacements += count;
+        regex.replace_all(input, replacement).to_string()
+    } else {
+        input.to_string()
+    }
+}
+
+fn replace_known_paths(input: &str, report: &mut RedactionReport) -> String {
+    let mut out = input.to_string();
+    let studio = studio_dir();
+    out = replace_path_literal(&out, &studio, "<studio_home>", report);
+    if let Some(home) = dirs::home_dir() {
+        out = replace_path_literal(&out, &home, "$HOME", report);
+    }
+    out
+}
+
+fn replace_path_literal(
+    input: &str,
+    path: &Path,
+    replacement: &str,
+    report: &mut RedactionReport,
+) -> String {
+    let path_str = path.display().to_string();
+    let mut out = input.to_string();
+    for needle in path_variants(&path_str) {
+        if needle.is_empty() {
+            continue;
+        }
+        let count = out.matches(&needle).count();
+        if count > 0 {
+            report.replacements += count;
+            out = out.replace(&needle, replacement);
+        }
+    }
+    out
+}
+
+fn path_variants(path: &str) -> Vec<String> {
+    let mut variants = vec![path.to_string()];
+    variants.push(path.replace('/', "\\"));
+    variants.push(path.replace('\\', "/"));
+    variants.sort();
+    variants.dedup();
+    variants
+}
+
+fn ansi_re() -> &'static Regex {
+    static RE: OnceLock<Regex> = OnceLock::new();
+    RE.get_or_init(|| Regex::new(r"\x1b\[[0-9;?]*[ -/]*[@-~]").unwrap())
+}
+
+fn private_key_re() -> &'static Regex {
+    static RE: OnceLock<Regex> = OnceLock::new();
+    RE.get_or_init(|| {
+        Regex::new(
+            r"(?is)-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----.*?-----END [A-Z0-9 ]*PRIVATE KEY-----",
+        )
+        .unwrap()
+    })
+}
+
+fn url_credentials_re() -> &'static Regex {
+    static RE: OnceLock<Regex> = OnceLock::new();
+    RE.get_or_init(|| Regex::new(r"(?i)\b([a-z][a-z0-9+.-]*://)[^/\s:@]+(:[^/\s@]*)?@").unwrap())
+}
+
+fn auth_header_re() -> &'static Regex {
+    static RE: OnceLock<Regex> = OnceLock::new();
+    RE.get_or_init(|| Regex::new(r"(?i)\b(authorization|proxy-authorization)\s*[:=]\s*(bearer|basic)?\s*[A-Za-z0-9._~+/=-]+").unwrap())
+}
+
+fn cookie_re() -> &'static Regex {
+    static RE: OnceLock<Regex> = OnceLock::new();
+    RE.get_or_init(|| Regex::new(r"(?i)\b(cookie|set-cookie)\s*[:=]\s*[^\r\n]+").unwrap())
+}
+
+fn token_re() -> &'static Regex {
+    static RE: OnceLock<Regex> = OnceLock::new();
+    RE.get_or_init(|| Regex::new(r"(?i)\b(hf_[A-Za-z0-9]{16,}|github_pat_[A-Za-z0-9_]{20,}|ghp_[A-Za-z0-9]{20,}|sk-[A-Za-z0-9]{20,})\b").unwrap())
+}
+
+fn env_secret_re() -> &'static Regex {
+    static RE: OnceLock<Regex> = OnceLock::new();
+    RE.get_or_init(|| {
+        Regex::new(r"(?i)\b((?:[A-Z0-9]+_)*(?:TOKEN|SECRET|PASSWORD|API_KEY|ACCESS_KEY|KEY)(?:_[A-Z0-9]+)*)\s*=\s*[^\s;&]+").unwrap()
+    })
+}
+
+fn native_path_lease_re() -> &'static Regex {
+    static RE: OnceLock<Regex> = OnceLock::new();
+    RE.get_or_init(|| {
+        Regex::new(
+            r#"(?i)(\b(?:native_path_lease|nativePathLease)[\"']?\s*[:=]\s*[\"']?)[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+"#,
+        )
+        .unwrap()
+    })
+}
+
+fn windows_studio_re() -> &'static Regex {
+    static RE: OnceLock<Regex> = OnceLock::new();
+    RE.get_or_init(|| {
+        Regex::new(r"(?i)\b[A-Z]:[\\/]Users[\\/][^\\/\r\n\s]+[\\/]\.unsloth[\\/]studio").unwrap()
+    })
+}
+
+fn windows_home_re() -> &'static Regex {
+    static RE: OnceLock<Regex> = OnceLock::new();
+    RE.get_or_init(|| Regex::new(r"(?i)\b[A-Z]:[\\/]Users[\\/][^\\/\r\n\s]+").unwrap())
+}
+
+fn unix_studio_re() -> &'static Regex {
+    static RE: OnceLock<Regex> = OnceLock::new();
+    RE.get_or_init(|| Regex::new(r"(?i)(?:/Users|/home)/[A-Za-z0-9._-]+/\.unsloth/studio").unwrap())
+}
+
+fn unix_home_re() -> &'static Regex {
+    static RE: OnceLock<Regex> = OnceLock::new();
+    RE.get_or_init(|| Regex::new(r"(?i)(?:/Users|/home)/[A-Za-z0-9._-]+").unwrap())
+}
+
+fn email_re() -> &'static Regex {
+    static RE: OnceLock<Regex> = OnceLock::new();
+    RE.get_or_init(|| Regex::new(r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b").unwrap())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn redacts_common_secret_and_path_patterns() {
+        let input = concat!(
+            "\u{1b}[31mred\u{1b}[0m\n",
+            "Authorization: Bearer abcdefghijklmnop\n",
+            "Cookie: session=abcdef\n",
+            "HF_TOKEN=hf_abcdefghijklmnopqrstuvwxyz\n",
+            "API_KEY=secret123\n",
+            "native_path_lease=abc.DEF_123\n",
+            "url=https://user:pass@example.com/path\n",
+            "email=alex@example.com\n",
+            "path=/Users/alex/.unsloth/studio/logs/install.log\n",
+            "win=C:\\Users\\Alex\\.unsloth\\studio\\logs\\install.log\n",
+            "-----BEGIN PRIVATE KEY-----\nabc\n-----END PRIVATE KEY-----\n"
+        );
+        let mut report = RedactionReport::default();
+        let redacted = redact_text(input, &mut report);
+        assert!(!redacted.contains("\u{1b}"));
+        assert!(!redacted.contains("abcdefghijklmnop"));
+        assert!(!redacted.contains("session=abcdef"));
+        assert!(!redacted.contains("hf_abcdefghijklmnopqrstuvwxyz"));
+        assert!(!redacted.contains("secret123"));
+        assert!(!redacted.contains("abc.DEF_123"));
+        assert!(redacted.contains("native_path_lease=<redacted native path lease>"));
+        assert!(redacted.contains("https://<redacted>@example.com/path"));
+        assert!(!redacted.contains("alex@example.com"));
+        assert!(redacted.contains("<studio_home>"));
+        assert!(!redacted.contains("PRIVATE KEY-----\nabc"));
+    }
+
+    #[test]
+    fn redaction_avoids_keyboard_monkey_false_positives() {
+        let input = "keyboard=present monkey=banana MONKEY=banana KEYBOARD=present API_KEY=secret";
+        let mut report = RedactionReport::default();
+        let redacted = redact_text(input, &mut report);
+        assert!(redacted.contains("keyboard=present"));
+        assert!(redacted.contains("monkey=banana"));
+        assert!(redacted.contains("MONKEY=banana"));
+        assert!(redacted.contains("KEYBOARD=present"));
+        assert!(redacted.contains("API_KEY=<redacted>"));
+    }
+}
diff --git a/studio/src-tauri/src/diagnostics/report.rs b/studio/src-tauri/src/diagnostics/report.rs
new file mode 100644
index 0000000000..6301e7face
--- /dev/null
+++ b/studio/src-tauri/src/diagnostics/report.rs
@@ -0,0 +1,607 @@
+use std::fs::{self, File};
+use std::io::{Read, Seek, SeekFrom};
+use std::path::Path;
+use std::time::UNIX_EPOCH;
+
+use super::phase_log::{collect_phase_groups, path_has_symlink};
+use super::redaction::{redact_text, RedactionReport};
+use super::state::{AttemptSummary, CappedStrings, DiagnosticsSnapshot, FrontendSupportSnapshot};
+use super::{
+    cap_string, logs_dir, now_ms, studio_dir, valid_utf8_boundary, FOOTER_BUDGET_BYTES,
+    MAX_PHASE_LINE_BYTES, REPORT_MAX_BYTES, SCHEMA_VERSION, TAIL_MAX_BYTES, TAIL_MAX_LINES,
+};
+
+#[derive(Clone, Debug)]
+pub(crate) struct BackendHealthSection {
+    pub(crate) port: u16,
+    pub(crate) fields: Vec<(String, String)>,
+    pub(crate) warning: Option<String>,
+}
+
+pub(crate) fn render_report(
+    snapshot: DiagnosticsSnapshot,
+    frontend: FrontendSupportSnapshot,
+    health: Option<BackendHealthSection>,
+) -> String {
+    let mut warnings = Vec::new();
+    let mut raw = String::new();
+
+    raw.push_str("Unsloth Studio Support Diagnostics\n");
+    raw.push_str(&format!("diag_report_schema={SCHEMA_VERSION}\n"));
+    raw.push_str(&format!("created_at_ms={}\n", now_ms()));
+    raw.push_str(&format!("app_version={}\n", env!("CARGO_PKG_VERSION")));
+    raw.push_str(&format!("os={}\n", std::env::consts::OS));
+    raw.push_str(&format!("arch={}\n", std::env::consts::ARCH));
+    raw.push_str(&format!("debug_build={}\n", cfg!(debug_assertions)));
+    raw.push_str(&format!(
+        "appimage={}\n",
+        std::env::var_os("APPIMAGE").is_some()
+    ));
+    raw.push_str(&format!(
+        "cpu_logical_count={}\n",
+        std::thread::available_parallelism()
+            .map(|n| n.get().to_string())
+            .unwrap_or_else(|_| "unavailable".to_string())
+    ));
+    raw.push_str(&format!("studio_dir={}\n", studio_dir().display()));
+    raw.push_str(&format!("logs_dir={}\n", logs_dir().display()));
+    raw.push_str(&format!("app_session_id={}\n", snapshot.app_session_id));
+    raw.push_str(&format!(
+        "app_started_at_ms={}\n",
+        snapshot.app_started_at_ms
+    ));
+    raw.push_str(
+        "disk_budget=5MiB x 3 segments x 5 groups x 4 kinds ~= 300MiB plus tauri.log/.1\n",
+    );
+
+    append_frontend_section(&mut raw, &frontend);
+    append_preflight_section(&mut raw, &snapshot);
+    append_flow_section(&mut raw, &snapshot);
+    append_backend_section(&mut raw, &snapshot, health.as_ref());
+    append_device_signals_section(&mut raw, &snapshot, health.as_ref());
+    append_log_sections(&mut raw, &snapshot, &mut warnings);
+
+    if let Some(health) = &health {
+        if let Some(warning) = &health.warning {
+            warnings.push(format!("backend /api/health unavailable: {warning}"));
+        }
+    }
+
+    let mut redaction = RedactionReport::default();
+    let redacted_body = redact_text(&raw, &mut redaction);
+
+    // Redact collection warnings/footer too. Some warnings include raw local paths
+    // from failed log reads, so the footer must not be appended after redaction.
+    let footer_for_count = render_footer(&warnings, &redaction);
+    let _ = redact_text(&footer_for_count, &mut redaction);
+    let footer = redact_text(
+        &render_footer(&warnings, &redaction),
+        &mut RedactionReport::default(),
+    );
+
+    enforce_report_limit(redacted_body, footer)
+}
+
+fn append_frontend_section(out: &mut String, frontend: &FrontendSupportSnapshot) {
+    out.push_str("\n== Trigger/UI state ==\n");
+    append_opt(out, "status", frontend.status.as_deref());
+    append_opt(out, "error", frontend.error.as_deref());
+    append_opt(
+        out,
+        "current_step_index",
+        frontend
+            .current_step_index
+            .map(|v| v.to_string())
+            .as_deref(),
+    );
+    append_opt(out, "progress_detail", frontend.progress_detail.as_deref());
+    append_opt(out, "flow", frontend.flow.as_deref());
+    append_opt(out, "update_phase", frontend.update_phase.as_deref());
+    let update_progress = frontend.update_progress.as_ref().map(selected_json_value);
+    append_opt(out, "update_progress", update_progress.as_deref());
+    if let Some(packages) = &frontend.elevation_packages {
+        out.push_str(&format!("elevation_packages={}\n", packages.join(", ")));
+    }
+    out.push_str("last_ui_log_tail:\n");
+    match &frontend.last_ui_log_lines {
+        Some(lines) if !lines.is_empty() => {
+            for line in tail_lines(lines, TAIL_MAX_LINES) {
+                out.push_str("  ");
+                out.push_str(line);
+                out.push('\n');
+            }
+        }
+        _ => out.push_str("  unavailable\n"),
+    }
+}
+
+fn append_preflight_section(out: &mut String, snapshot: &DiagnosticsSnapshot) {
+    out.push_str("\n== Preflight/install state ==\n");
+    match &snapshot.latest_preflight {
+        Some(preflight) => {
+            out.push_str("source=live-state\n");
+            out.push_str(&format!("recorded_at_ms={}\n", preflight.recorded_at_ms));
+            out.push_str(&format!("disposition={}\n", preflight.disposition));
+            append_opt(out, "reason", preflight.reason.as_deref());
+            append_opt(
+                out,
+                "port",
+                preflight.port.map(|p| p.to_string()).as_deref(),
+            );
+            out.push_str(&format!("can_auto_repair={}\n", preflight.can_auto_repair));
+            if let Some(path) = &preflight.managed_bin {
+                out.push_str(&format!("managed_bin={}\n", path.display()));
+                out.push_str(&format!("managed_bin_exists={}\n", path.exists()));
+            } else {
+                out.push_str("managed_bin=unavailable\n");
+            }
+        }
+        None => out.push_str("source=live-state unavailable\n"),
+    }
+}
+
+fn append_flow_section(out: &mut String, snapshot: &DiagnosticsSnapshot) {
+    out.push_str("\n== Flow summaries ==\n");
+    append_attempt_summary(out, "install", snapshot.install.as_ref(), "live-state");
+    if !snapshot.install_history.is_empty() {
+        out.push_str("install_history:\n");
+        for install in snapshot.install_history.iter().rev().take(4).rev() {
+            append_attempt_summary(
+                out,
+                "  previous_install",
+                Some(install),
+                "live-state-history",
+            );
+        }
+    }
+    append_attempt_summary(out, "update", snapshot.update.as_ref(), "live-state");
+
+    out.push_str("repair_groups:\n");
+    if snapshot.repair_groups.is_empty() {
+        out.push_str("  unavailable\n");
+    } else {
+        for group in snapshot.repair_groups.iter().rev().take(5).rev() {
+            out.push_str(&format!(
+                "  repair_group_id={} started_at_ms={} ended_at_ms={} final_status={} last_error={}\n",
+                group.repair_group_id,
+                group.started_at_ms,
+                opt_u64(group.ended_at_ms),
+                group.final_status.as_deref().unwrap_or("unavailable"),
+                group.last_error.as_deref().unwrap_or("unavailable")
+            ));
+            for child in &group.children {
+                append_attempt_summary(out, "  child", Some(child), "live-state");
+            }
+        }
+    }
+}
+
+fn append_attempt_summary(
+    out: &mut String,
+    label: &str,
+    attempt: Option<&AttemptSummary>,
+    source: &str,
+) {
+    match attempt {
+        Some(attempt) => {
+            out.push_str(&format!(
+                "{label}: source={source} flow={} attempt_id={} group_id={} child_type={} started_at_ms={} ended_at_ms={} exit_status={} intentional_stop={} last_error={} log_segments={}\n",
+                attempt.flow,
+                attempt.attempt_id,
+                attempt.repair_group_id.as_deref().unwrap_or("none"),
+                attempt.child_type.as_deref().unwrap_or("none"),
+                attempt.started_at_ms,
+                opt_u64(attempt.ended_at_ms),
+                attempt.exit_status.as_deref().unwrap_or("unavailable"),
+                attempt.intentional_stop,
+                attempt.last_error.as_deref().unwrap_or("unavailable"),
+                attempt
+                    .log_segments
+                    .iter()
+                    .map(|p| p.display().to_string())
+                    .collect::<Vec<_>>()
+                    .join(",")
+            ));
+            if !attempt.elevation_packages.is_empty() {
+                out.push_str(&format!(
+                    "{label}.elevation_packages={}\n",
+                    attempt.elevation_packages.join(", ")
+                ));
+            }
+            append_capped(out, &format!("{label}.steps"), &attempt.steps);
+            append_capped(
+                out,
+                &format!("{label}.progress_details"),
+                &attempt.progress_details,
+            );
+            append_capped(out, &format!("{label}.diag_markers"), &attempt.diag_markers);
+        }
+        None => out.push_str(&format!("{label}: unavailable\n")),
+    }
+}
+
+fn append_backend_section(
+    out: &mut String,
+    snapshot: &DiagnosticsSnapshot,
+    health: Option<&BackendHealthSection>,
+) {
+    out.push_str("\n== Backend/auth/watchdog ==\n");
+    match &snapshot.backend {
+        Some(backend) => {
+            out.push_str("source=live-state\n");
+            out.push_str(&format!("backend_kind={}\n", backend.backend_kind));
+            append_opt(out, "session_id", backend.session_id.as_deref());
+            append_opt(
+                out,
+                "requested_port",
+                backend.requested_port.map(|p| p.to_string()).as_deref(),
+            );
+            append_opt(
+                out,
+                "reported_port",
+                backend.reported_port.map(|p| p.to_string()).as_deref(),
+            );
+            append_opt(
+                out,
+                "generation",
+                backend.generation.map(|g| g.to_string()).as_deref(),
+            );
+            append_opt(
+                out,
+                "started_at_ms",
+                backend.started_at_ms.map(|t| t.to_string()).as_deref(),
+            );
+            append_opt(
+                out,
+                "ended_at_ms",
+                backend.ended_at_ms.map(|t| t.to_string()).as_deref(),
+            );
+            append_opt(out, "exit_status", backend.exit_status.as_deref());
+            out.push_str(&format!("intentional_stop={}\n", backend.intentional_stop));
+            append_opt(out, "terminal_reason", backend.terminal_reason.as_deref());
+            append_opt(out, "last_error", backend.last_error.as_deref());
+            if backend.backend_kind == "attached_external" {
+                out.push_str("managed_process_logs=not_owned_by_tauri\n");
+            }
+        }
+        None => out.push_str("backend=unavailable backend_kind=unknown\n"),
+    }
+
+    match &snapshot.auth {
+        Some(auth) => {
+            out.push_str(&format!(
+                "auth_failure: failed_at_ms={} stage={} port={} message={}\n",
+                auth.failed_at_ms,
+                auth.stage,
+                auth.port
+                    .map(|p| p.to_string())
+                    .unwrap_or_else(|| "unavailable".to_string()),
+                auth.message
+            ));
+        }
+        None => out.push_str("auth_failure=unavailable\n"),
+    }
+
+    out.push_str("runtime_health:\n");
+    match health {
+        Some(health) => {
+            out.push_str(&format!("  port={}\n", health.port));
+            if health.fields.is_empty() {
+                out.push_str("  selected_fields=unavailable\n");
+            } else {
+                for (key, value) in &health.fields {
+                    out.push_str(&format!("  {key}={value}\n"));
+                }
+            }
+            if let Some(warning) = &health.warning {
+                out.push_str(&format!("  warning={warning}\n"));
+            }
+        }
+        None => out.push_str("  unavailable: no known backend port\n"),
+    }
+}
+
+fn append_device_signals_section(
+    out: &mut String,
+    snapshot: &DiagnosticsSnapshot,
+    health: Option<&BackendHealthSection>,
+) {
+    out.push_str("\n== Lightweight device signals ==\n");
+    out.push_str("scope=setup/runtime signals, not full hardware inventory\n");
+    out.push_str(&format!(
+        "os={} arch={}\n",
+        std::env::consts::OS,
+        std::env::consts::ARCH
+    ));
+    out.push_str("installer_diag_markers:\n");
+    let mut any = false;
+    if let Some(install) = &snapshot.install {
+        append_marker_tail(out, "install", install);
+        any |= !install.diag_markers.items.is_empty();
+    }
+    if let Some(update) = &snapshot.update {
+        append_marker_tail(out, "update", update);
+        any |= !update.diag_markers.items.is_empty();
+    }
+    for group in &snapshot.repair_groups {
+        for child in &group.children {
+            append_marker_tail(out, "repair_child", child);
+            any |= !child.diag_markers.items.is_empty();
+        }
+    }
+    if !any {
+        out.push_str("  unavailable\n");
+    }
+    if let Some(health) = health {
+        out.push_str("runtime_health_selected_fields:\n");
+        for (key, value) in &health.fields {
+            if matches!(
+                key.as_str(),
+                "version"
+                    | "device_type"
+                    | "chat_only"
+                    | "desktop_protocol_version"
+                    | "supports_api_only"
+                    | "supports_desktop_auth"
+            ) {
+                out.push_str(&format!("  {key}={value}\n"));
+            }
+        }
+    }
+}
+
+fn append_log_sections(
+    out: &mut String,
+    snapshot: &DiagnosticsSnapshot,
+    warnings: &mut Vec<String>,
+) {
+    out.push_str("\n== Log tails ==\n");
+    for name in ["tauri.log", "tauri.log.1"] {
+        let path = studio_dir().join(name);
+        append_tail_section(out, &path, name, "local-app-log", warnings);
+    }
+
+    let phase_groups = collect_phase_groups(snapshot, warnings);
+    if phase_groups.is_empty() {
+        out.push_str("phase_logs=unavailable\n");
+    }
+    for group in phase_groups {
+        out.push_str(&format!(
+            "\n-- phase_log_group label={} source={} --\n",
+            group.label, group.source
+        ));
+        if let Some(note) = &group.note {
+            out.push_str(&format!("note={}\n", note));
+        }
+        for path in group.paths {
+            append_tail_section(out, &path, &group.label, &group.source, warnings);
+        }
+    }
+}
+
+fn append_tail_section(
+    out: &mut String,
+    path: &Path,
+    label: &str,
+    source: &str,
+    warnings: &mut Vec<String>,
+) {
+    match read_tail(path, TAIL_MAX_LINES, TAIL_MAX_BYTES) {
+        Ok(tail) => {
+            out.push_str(&format!(
+                "file={} label={} source={} size_bytes={} mtime_ms={} included_bytes={} included_lines={} truncated={}\n",
+                path.display(),
+                label,
+                source,
+                tail.size_bytes,
+                opt_u64(tail.mtime_ms),
+                tail.included_bytes,
+                tail.included_lines,
+                tail.truncated
+            ));
+            out.push_str("```text\n");
+            out.push_str(&tail.text);
+            if !tail.text.ends_with('\n') {
+                out.push('\n');
+            }
+            out.push_str("```\n");
+        }
+        Err(error) => {
+            out.push_str(&format!(
+                "file={} label={} source={} unavailable={}\n",
+                path.display(),
+                label,
+                source,
+                error
+            ));
+            warnings.push(format!("{} unavailable: {}", path.display(), error));
+        }
+    }
+}
+
+#[derive(Debug)]
+struct TailRead {
+    text: String,
+    size_bytes: u64,
+    mtime_ms: Option<u64>,
+    included_bytes: usize,
+    included_lines: usize,
+    truncated: bool,
+}
+
+fn read_tail(path: &Path, max_lines: usize, max_bytes: usize) -> Result<TailRead, String> {
+    if path_has_symlink(path) {
+        return Err("refusing to read symlink".to_string());
+    }
+    let metadata = fs::metadata(path).map_err(|e| e.to_string())?;
+    let size = metadata.len();
+    let mut file = File::open(path).map_err(|e| e.to_string())?;
+    let start = size.saturating_sub(max_bytes as u64);
+    file.seek(SeekFrom::Start(start))
+        .map_err(|e| e.to_string())?;
+    let mut bytes = Vec::new();
+    file.take(max_bytes as u64)
+        .read_to_end(&mut bytes)
+        .map_err(|e| e.to_string())?;
+    let mut text = String::from_utf8_lossy(&bytes).into_owned();
+    let mut truncated = start > 0;
+    if truncated {
+        text = format!("[tail truncated to last {max_bytes} bytes]\n{text}");
+    }
+    let mut lines: Vec<String> = text
+        .lines()
+        .map(|line| {
+            if line.len() > MAX_PHASE_LINE_BYTES {
+                let boundary = valid_utf8_boundary(line, MAX_PHASE_LINE_BYTES);
+                format!("{} [line truncated]", &line[..boundary])
+            } else {
+                line.to_string()
+            }
+        })
+        .collect();
+    if lines.len() > max_lines {
+        truncated = true;
+        let omitted = lines.len() - max_lines;
+        lines = lines.split_off(omitted);
+        lines.insert(0, format!("[tail truncated to last {max_lines} lines]"));
+    }
+    let included_lines = lines.len();
+    let mut text = lines.join("\n");
+    if !text.is_empty() {
+        text.push('\n');
+    }
+    Ok(TailRead {
+        text,
+        size_bytes: size,
+        mtime_ms: metadata
+            .modified()
+            .ok()
+            .and_then(|t| t.duration_since(UNIX_EPOCH).ok())
+            .map(|d| d.as_millis() as u64),
+        included_bytes: bytes.len(),
+        included_lines,
+        truncated,
+    })
+}
+
+fn render_footer(warnings: &[String], redaction: &RedactionReport) -> String {
+    let mut footer = String::new();
+    footer.push_str("\n== Collection warnings ==\n");
+    if warnings.is_empty() {
+        footer.push_str("none\n");
+    } else {
+        for warning in warnings.iter().take(100) {
+            footer.push_str("- ");
+            footer.push_str(warning);
+            footer.push('\n');
+        }
+        if warnings.len() > 100 {
+            footer.push_str(&format!(
+                "- omitted {} additional warnings\n",
+                warnings.len() - 100
+            ));
+        }
+    }
+    footer.push_str("\n== Redaction/omission summary ==\n");
+    footer.push_str(&format!(
+        "redaction_replacements={}\n",
+        redaction.replacements
+    ));
+    footer.push_str("redaction_scope=ANSI, private keys, URL credentials, auth headers, cookies, token patterns, assignment-style secrets, studio/home paths, emails\n");
+    footer.push_str(
+        "report_bounds=log sections <=1000 lines/200KiB each; total clipboard text <=1MiB\n",
+    );
+    footer.push_str("known_v1_gap=elevated apt helper may buffer subprocess output before diagnostics caps it\n");
+    footer.push_str("known_v1_gap=normal install elevation resume is linked in same-run state/report history; disk fallback conservatively includes recent install attempts but has no explicit install_group_id in V1\n");
+    footer
+}
+
+fn enforce_report_limit(body: String, footer: String) -> String {
+    if body.len() + footer.len() <= REPORT_MAX_BYTES {
+        return format!("{body}{footer}");
+    }
+    let notice = "\n[report truncated to fit clipboard budget; footer preserved]\n";
+    let footer_budget = footer.len().min(FOOTER_BUDGET_BYTES).max(footer.len());
+    let budget = REPORT_MAX_BYTES
+        .saturating_sub(footer_budget)
+        .saturating_sub(notice.len());
+    let boundary = valid_utf8_boundary(&body, budget);
+    format!("{}{}{}", &body[..boundary], notice, footer)
+}
+fn append_opt(out: &mut String, key: &str, value: Option<&str>) {
+    out.push_str(key);
+    out.push('=');
+    out.push_str(value.unwrap_or("unavailable"));
+    out.push('\n');
+}
+
+fn append_capped(out: &mut String, label: &str, values: &CappedStrings) {
+    out.push_str(&format!("{label}: omitted={}\n", values.omitted));
+    if values.items.is_empty() {
+        out.push_str("  unavailable\n");
+    } else {
+        for value in values.items.iter().rev().take(20).rev() {
+            out.push_str("  ");
+            out.push_str(value);
+            out.push('\n');
+        }
+    }
+}
+
+fn append_marker_tail(out: &mut String, label: &str, attempt: &AttemptSummary) {
+    for marker in attempt.diag_markers.items.iter().rev().take(10).rev() {
+        out.push_str(&format!("  {label}: {marker}\n"));
+    }
+}
+
+fn tail_lines(lines: &[String], max_lines: usize) -> &[String] {
+    if lines.len() > max_lines {
+        &lines[lines.len() - max_lines..]
+    } else {
+        lines
+    }
+}
+
+fn opt_u64(value: Option<u64>) -> String {
+    value
+        .map(|v| v.to_string())
+        .unwrap_or_else(|| "unavailable".to_string())
+}
+
+pub(crate) fn selected_json_value(value: &serde_json::Value) -> String {
+    match value {
+        serde_json::Value::String(s) => cap_string(s, 256),
+        serde_json::Value::Bool(b) => b.to_string(),
+        serde_json::Value::Number(n) => n.to_string(),
+        serde_json::Value::Null => "null".to_string(),
+        _ => "<non-scalar>".to_string(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn report_redacts_footer_collection_warning_paths() {
+        let snapshot = DiagnosticsSnapshot::default();
+        let report = render_report(snapshot, FrontendSupportSnapshot::default(), None);
+        let studio = studio_dir().display().to_string();
+        assert!(!report.contains(&studio));
+        assert!(report.contains("<studio_home>"));
+    }
+
+    #[test]
+    fn tail_handles_missing_and_non_utf8() {
+        let missing =
+            std::env::temp_dir().join(format!("unsloth-missing-tail-{}", std::process::id()));
+        assert!(read_tail(&missing, 10, 100).is_err());
+
+        let path =
+            std::env::temp_dir().join(format!("unsloth-nonutf8-tail-{}", std::process::id()));
+        fs::write(&path, [0xff, b'a', b'\n', b'b']).unwrap();
+        let tail = read_tail(&path, 10, 100).unwrap();
+        assert!(tail.text.contains('�'));
+        let _ = fs::remove_file(path);
+    }
+}
diff --git a/studio/src-tauri/src/diagnostics/state.rs b/studio/src-tauri/src/diagnostics/state.rs
new file mode 100644
index 0000000000..ccbd5fbb8e
--- /dev/null
+++ b/studio/src-tauri/src/diagnostics/state.rs
@@ -0,0 +1,774 @@
+use crate::preflight::{DesktopPreflightDisposition, DesktopPreflightResult};
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+use std::sync::{Arc, Mutex};
+
+use super::phase_log::{PhaseLogHandle, PhaseLogWriter, SegmentOwner};
+use super::{cap_string, new_id, now_ms, MAX_STATE_ITEMS};
+
+pub type DiagnosticsState = Arc<Mutex<DiagnosticsSnapshot>>;
+
+#[derive(Clone, Debug)]
+pub struct DiagnosticsSnapshot {
+    pub app_session_id: String,
+    pub app_started_at_ms: u64,
+    pub latest_preflight: Option<PreflightSummary>,
+    pub install: Option<AttemptSummary>,
+    pub install_history: Vec<AttemptSummary>,
+    pub repair_groups: Vec<RepairGroupSummary>,
+    pub update: Option<AttemptSummary>,
+    pub backend: Option<BackendSummary>,
+    pub auth: Option<AuthSummary>,
+}
+
+impl Default for DiagnosticsSnapshot {
+    fn default() -> Self {
+        Self {
+            app_session_id: new_id("app"),
+            app_started_at_ms: now_ms(),
+            latest_preflight: None,
+            install: None,
+            install_history: Vec::new(),
+            repair_groups: Vec::new(),
+            update: None,
+            backend: None,
+            auth: None,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct CappedStrings {
+    pub items: Vec<String>,
+    pub omitted: usize,
+}
+
+impl CappedStrings {
+    fn push(&mut self, value: impl Into<String>) {
+        if self.items.len() >= MAX_STATE_ITEMS {
+            self.items.remove(0);
+            self.omitted += 1;
+        }
+        self.items.push(value.into());
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct PreflightSummary {
+    pub disposition: String,
+    pub reason: Option<String>,
+    pub port: Option<u16>,
+    pub can_auto_repair: bool,
+    pub managed_bin: Option<PathBuf>,
+    pub recorded_at_ms: u64,
+}
+
+#[derive(Clone, Debug)]
+pub struct AttemptSummary {
+    pub flow: String,
+    pub attempt_id: String,
+    pub repair_group_id: Option<String>,
+    pub child_type: Option<String>,
+    pub log_segments: Vec<PathBuf>,
+    pub started_at_ms: u64,
+    pub ended_at_ms: Option<u64>,
+    pub exit_status: Option<String>,
+    pub intentional_stop: bool,
+    pub last_error: Option<String>,
+    pub elevation_packages: Vec<String>,
+    pub steps: CappedStrings,
+    pub progress_details: CappedStrings,
+    pub diag_markers: CappedStrings,
+}
+
+impl AttemptSummary {
+    pub(crate) fn new(
+        flow: impl Into<String>,
+        attempt_id: String,
+        repair_group_id: Option<String>,
+        child_type: Option<String>,
+        started_at_ms: u64,
+    ) -> Self {
+        Self {
+            flow: flow.into(),
+            attempt_id,
+            repair_group_id,
+            child_type,
+            log_segments: Vec::new(),
+            started_at_ms,
+            ended_at_ms: None,
+            exit_status: None,
+            intentional_stop: false,
+            last_error: None,
+            elevation_packages: Vec::new(),
+            steps: CappedStrings::default(),
+            progress_details: CappedStrings::default(),
+            diag_markers: CappedStrings::default(),
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct RepairGroupSummary {
+    pub repair_group_id: String,
+    pub children: Vec<AttemptSummary>,
+    pub started_at_ms: u64,
+    pub ended_at_ms: Option<u64>,
+    pub final_status: Option<String>,
+    pub last_error: Option<String>,
+}
+
+#[derive(Clone, Debug)]
+pub struct BackendSummary {
+    pub session_id: Option<String>,
+    pub backend_kind: String,
+    pub log_segments: Vec<PathBuf>,
+    pub requested_port: Option<u16>,
+    pub reported_port: Option<u16>,
+    pub generation: Option<u64>,
+    pub started_at_ms: Option<u64>,
+    pub ended_at_ms: Option<u64>,
+    pub exit_status: Option<String>,
+    pub intentional_stop: bool,
+    pub terminal_reason: Option<String>,
+    pub last_error: Option<String>,
+}
+
+#[derive(Clone, Debug)]
+pub struct AuthSummary {
+    pub failed_at_ms: u64,
+    pub stage: String,
+    pub port: Option<u16>,
+    pub message: String,
+}
+
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FrontendSupportSnapshot {
+    pub status: Option<String>,
+    pub error: Option<String>,
+    pub current_step_index: Option<i64>,
+    pub progress_detail: Option<String>,
+    pub elevation_packages: Option<Vec<String>>,
+    pub last_ui_log_lines: Option<Vec<String>>,
+    pub flow: Option<String>,
+    pub update_phase: Option<String>,
+    /// Frontend update progress can be numeric today; keep this tolerant of strings/numbers.
+    pub update_progress: Option<serde_json::Value>,
+}
+
+#[derive(Clone)]
+pub struct AttemptLog {
+    pub flow: String,
+    pub attempt_id: String,
+    pub repair_group_id: Option<String>,
+    #[allow(dead_code)]
+    pub child_type: Option<String>,
+    pub handle: PhaseLogHandle,
+}
+
+#[derive(Clone)]
+pub struct BackendLog {
+    pub session_id: String,
+    pub handle: PhaseLogHandle,
+}
+
+pub fn new_diagnostics_state() -> DiagnosticsState {
+    Arc::new(Mutex::new(DiagnosticsSnapshot::default()))
+}
+
+pub fn begin_install_attempt(diagnostics: &DiagnosticsState) -> AttemptLog {
+    begin_attempt(diagnostics, "install", None, None)
+}
+
+pub fn begin_update_attempt(diagnostics: &DiagnosticsState) -> AttemptLog {
+    begin_attempt(diagnostics, "update", None, None)
+}
+
+pub fn begin_repair_group(diagnostics: &DiagnosticsState) -> String {
+    let repair_group_id = new_id("repair");
+    with_snapshot(diagnostics, |snapshot| {
+        if snapshot.repair_groups.len() >= MAX_STATE_ITEMS {
+            snapshot.repair_groups.remove(0);
+        }
+        snapshot.repair_groups.push(RepairGroupSummary {
+            repair_group_id: repair_group_id.clone(),
+            children: Vec::new(),
+            started_at_ms: now_ms(),
+            ended_at_ms: None,
+            final_status: None,
+            last_error: None,
+        });
+    });
+    repair_group_id
+}
+
+pub fn begin_repair_child(
+    diagnostics: &DiagnosticsState,
+    repair_group_id: &str,
+    child_type: &str,
+) -> AttemptLog {
+    begin_attempt(
+        diagnostics,
+        "repair",
+        Some(repair_group_id.to_string()),
+        Some(child_type.to_string()),
+    )
+}
+
+fn begin_attempt(
+    diagnostics: &DiagnosticsState,
+    flow: &str,
+    repair_group_id: Option<String>,
+    child_type: Option<String>,
+) -> AttemptLog {
+    let started_at_ms = now_ms();
+    let attempt_id = new_id(child_type.as_deref().unwrap_or(flow));
+    let owner = match (flow, repair_group_id.as_ref(), child_type.as_ref()) {
+        ("install", None, _) => SegmentOwner::Install {
+            attempt_id: attempt_id.clone(),
+        },
+        ("update", None, _) => SegmentOwner::Update {
+            attempt_id: attempt_id.clone(),
+        },
+        (_, Some(group), Some(child)) => SegmentOwner::Repair {
+            repair_group_id: group.clone(),
+            attempt_id: attempt_id.clone(),
+            child_type: child.clone(),
+        },
+        _ => SegmentOwner::Install {
+            attempt_id: attempt_id.clone(),
+        },
+    };
+
+    let summary = AttemptSummary::new(
+        flow,
+        attempt_id.clone(),
+        repair_group_id.clone(),
+        child_type.clone(),
+        started_at_ms,
+    );
+
+    with_snapshot(diagnostics, |snapshot| {
+        if let Some(group_id) = &repair_group_id {
+            let group = ensure_repair_group(snapshot, group_id);
+            if group.children.len() >= MAX_STATE_ITEMS {
+                group.children.remove(0);
+            }
+            group.children.push(summary);
+        } else if flow == "update" {
+            snapshot.update = Some(summary);
+        } else {
+            if let Some(previous) = snapshot.install.take() {
+                if snapshot.install_history.len() >= MAX_STATE_ITEMS {
+                    snapshot.install_history.remove(0);
+                }
+                snapshot.install_history.push(previous);
+            }
+            snapshot.install = Some(summary);
+        }
+    });
+
+    let writer = PhaseLogWriter::new(
+        diagnostics.clone(),
+        owner,
+        if repair_group_id.is_some() {
+            "repair"
+        } else {
+            flow
+        },
+        started_at_ms,
+        None,
+    );
+
+    AttemptLog {
+        flow: flow.to_string(),
+        attempt_id,
+        repair_group_id,
+        child_type,
+        handle: Arc::new(Mutex::new(writer)),
+    }
+}
+
+pub fn finish_attempt(
+    diagnostics: &DiagnosticsState,
+    attempt: &AttemptLog,
+    exit_status: Option<String>,
+    intentional_stop: bool,
+    last_error: Option<String>,
+) {
+    with_snapshot(diagnostics, |snapshot| {
+        update_attempt_mut(snapshot, attempt, |summary| {
+            if summary.ended_at_ms.is_none() {
+                summary.ended_at_ms = Some(now_ms());
+            }
+            if exit_status.is_some() {
+                summary.exit_status = exit_status.clone();
+            }
+            summary.intentional_stop |= intentional_stop;
+            if last_error.is_some() {
+                summary.last_error = last_error.clone();
+            }
+        });
+    });
+}
+
+pub fn finish_repair_group(
+    diagnostics: &DiagnosticsState,
+    repair_group_id: &str,
+    final_status: impl Into<String>,
+    last_error: Option<String>,
+) {
+    let status = final_status.into();
+    with_snapshot(diagnostics, |snapshot| {
+        let group = ensure_repair_group(snapshot, repair_group_id);
+        group.ended_at_ms = Some(now_ms());
+        group.final_status = Some(status.clone());
+        group.last_error = last_error.clone();
+    });
+}
+
+pub fn record_step(diagnostics: &DiagnosticsState, attempt: &AttemptLog, step: &str) {
+    record_attempt_string(diagnostics, attempt, step, |summary, value| {
+        summary.steps.push(value)
+    });
+}
+
+pub fn record_progress(diagnostics: &DiagnosticsState, attempt: &AttemptLog, progress: &str) {
+    record_attempt_string(diagnostics, attempt, progress, |summary, value| {
+        summary.progress_details.push(value)
+    });
+}
+
+pub fn record_diag_marker(diagnostics: &DiagnosticsState, attempt: &AttemptLog, marker: &str) {
+    record_attempt_string(diagnostics, attempt, marker, |summary, value| {
+        summary.diag_markers.push(value)
+    });
+}
+
+pub fn record_elevation_packages(
+    diagnostics: &DiagnosticsState,
+    attempt: &AttemptLog,
+    packages: &[String],
+) {
+    let capped: Vec<String> = packages.iter().take(100).cloned().collect();
+    with_snapshot(diagnostics, |snapshot| {
+        update_attempt_mut(snapshot, attempt, |summary| {
+            summary.elevation_packages = capped.clone();
+        });
+    });
+}
+
+fn record_attempt_string<F>(
+    diagnostics: &DiagnosticsState,
+    attempt: &AttemptLog,
+    value: &str,
+    mut update: F,
+) where
+    F: FnMut(&mut AttemptSummary, String),
+{
+    let capped = cap_string(value, 4096);
+    with_snapshot(diagnostics, |snapshot| {
+        update_attempt_mut(snapshot, attempt, |summary| {
+            update(summary, capped.clone());
+        });
+    });
+}
+
+pub fn record_preflight(diagnostics: &DiagnosticsState, result: &DesktopPreflightResult) {
+    let summary = PreflightSummary {
+        disposition: disposition_label(&result.disposition).to_string(),
+        reason: result.reason.clone(),
+        port: result.port,
+        can_auto_repair: result.can_auto_repair,
+        managed_bin: result.managed_bin.clone(),
+        recorded_at_ms: now_ms(),
+    };
+    with_snapshot(diagnostics, |snapshot| {
+        snapshot.latest_preflight = Some(summary);
+    });
+    if matches!(
+        result.disposition,
+        DesktopPreflightDisposition::AttachedReady
+    ) {
+        if let Some(port) = result.port {
+            record_attached_external_backend(diagnostics, port);
+        }
+    }
+}
+
+pub fn begin_backend_session(
+    diagnostics: &DiagnosticsState,
+    requested_port: u16,
+    generation: u64,
+) -> BackendLog {
+    let session_id = new_id("backend");
+    let started_at_ms = now_ms();
+    with_snapshot(diagnostics, |snapshot| {
+        snapshot.backend = Some(BackendSummary {
+            session_id: Some(session_id.clone()),
+            backend_kind: "managed".to_string(),
+            log_segments: Vec::new(),
+            requested_port: Some(requested_port),
+            reported_port: None,
+            generation: Some(generation),
+            started_at_ms: Some(started_at_ms),
+            ended_at_ms: None,
+            exit_status: None,
+            intentional_stop: false,
+            terminal_reason: None,
+            last_error: None,
+        });
+    });
+    let writer = PhaseLogWriter::new(
+        diagnostics.clone(),
+        SegmentOwner::Backend {
+            session_id: session_id.clone(),
+        },
+        "backend",
+        started_at_ms,
+        Some("managed".to_string()),
+    );
+    BackendLog {
+        session_id,
+        handle: Arc::new(Mutex::new(writer)),
+    }
+}
+
+pub fn record_backend_start_failure(
+    diagnostics: &DiagnosticsState,
+    requested_port: Option<u16>,
+    generation: Option<u64>,
+    stage: &str,
+    error: &str,
+) {
+    let error = cap_string(error, 4096);
+    with_snapshot(diagnostics, |snapshot| {
+        snapshot.backend = Some(BackendSummary {
+            session_id: None,
+            backend_kind: "managed".to_string(),
+            log_segments: Vec::new(),
+            requested_port,
+            reported_port: None,
+            generation,
+            started_at_ms: Some(now_ms()),
+            ended_at_ms: Some(now_ms()),
+            exit_status: None,
+            intentional_stop: false,
+            terminal_reason: Some(stage.to_string()),
+            last_error: Some(error.clone()),
+        });
+    });
+}
+
+pub fn record_backend_port(diagnostics: &DiagnosticsState, session_id: &str, port: u16) {
+    with_snapshot(diagnostics, |snapshot| {
+        if let Some(backend) = snapshot.backend.as_mut() {
+            if backend.session_id.as_deref() == Some(session_id) {
+                backend.reported_port = Some(port);
+            }
+        }
+    });
+}
+
+pub fn record_backend_exit(
+    diagnostics: &DiagnosticsState,
+    session_id: &str,
+    exit_status: Option<String>,
+    intentional_stop: bool,
+    terminal_reason: Option<String>,
+) {
+    with_snapshot(diagnostics, |snapshot| {
+        if let Some(backend) = snapshot.backend.as_mut() {
+            if backend.session_id.as_deref() != Some(session_id) {
+                return;
+            }
+            if backend.ended_at_ms.is_none() {
+                backend.ended_at_ms = Some(now_ms());
+            }
+            if exit_status.is_some() {
+                backend.exit_status = exit_status.clone();
+            }
+            backend.intentional_stop |= intentional_stop;
+            if backend.terminal_reason.is_none() {
+                backend.terminal_reason = terminal_reason.clone().or_else(|| {
+                    Some(if intentional_stop {
+                        "intentional_stop".to_string()
+                    } else {
+                        "process_exit".to_string()
+                    })
+                });
+            }
+        }
+    });
+}
+
+pub fn record_backend_watchdog(
+    diagnostics: &DiagnosticsState,
+    generation: u64,
+    terminal_reason: &str,
+) {
+    with_snapshot(diagnostics, |snapshot| {
+        if let Some(backend) = snapshot.backend.as_mut() {
+            if backend.generation == Some(generation) && backend.terminal_reason.is_none() {
+                backend.terminal_reason = Some(terminal_reason.to_string());
+                backend.ended_at_ms = Some(now_ms());
+            }
+        }
+    });
+}
+
+pub fn record_backend_intentional_stop(diagnostics: &DiagnosticsState) {
+    with_snapshot(diagnostics, |snapshot| {
+        if let Some(backend) = snapshot.backend.as_mut() {
+            if matches!(
+                backend.terminal_reason.as_deref(),
+                Some("no_port_after_grace" | "unresponsive_health_check")
+            ) {
+                return;
+            }
+            backend.intentional_stop = true;
+            if backend.terminal_reason.is_none() {
+                backend.terminal_reason = Some("intentional_stop".to_string());
+            }
+        }
+    });
+}
+
+pub fn record_attached_external_backend(diagnostics: &DiagnosticsState, port: u16) {
+    with_snapshot(diagnostics, |snapshot| {
+        let should_replace = snapshot
+            .backend
+            .as_ref()
+            .map(|backend| backend.backend_kind != "managed" || backend.session_id.is_none())
+            .unwrap_or(true);
+        if should_replace {
+            snapshot.backend = Some(BackendSummary {
+                session_id: None,
+                backend_kind: "attached_external".to_string(),
+                log_segments: Vec::new(),
+                requested_port: None,
+                reported_port: Some(port),
+                generation: None,
+                started_at_ms: None,
+                ended_at_ms: None,
+                exit_status: None,
+                intentional_stop: false,
+                terminal_reason: None,
+                last_error: None,
+            });
+        }
+    });
+}
+
+pub fn record_auth_failure(
+    diagnostics: &DiagnosticsState,
+    stage: &str,
+    port: Option<u16>,
+    message: &str,
+) {
+    let message = cap_string(message, 4096);
+    with_snapshot(diagnostics, |snapshot| {
+        snapshot.auth = Some(AuthSummary {
+            failed_at_ms: now_ms(),
+            stage: stage.to_string(),
+            port,
+            message,
+        });
+    });
+}
+
+pub(crate) fn with_snapshot<F>(diagnostics: &DiagnosticsState, update: F)
+where
+    F: FnOnce(&mut DiagnosticsSnapshot),
+{
+    match diagnostics.lock() {
+        Ok(mut snapshot) => update(&mut snapshot),
+        Err(poisoned) => {
+            let mut snapshot = poisoned.into_inner();
+            update(&mut snapshot);
+        }
+    }
+}
+
+pub(crate) fn clone_snapshot(diagnostics: &DiagnosticsState) -> DiagnosticsSnapshot {
+    match diagnostics.lock() {
+        Ok(snapshot) => snapshot.clone(),
+        Err(poisoned) => poisoned.into_inner().clone(),
+    }
+}
+
+fn ensure_repair_group<'a>(
+    snapshot: &'a mut DiagnosticsSnapshot,
+    repair_group_id: &str,
+) -> &'a mut RepairGroupSummary {
+    if let Some(index) = snapshot
+        .repair_groups
+        .iter()
+        .position(|group| group.repair_group_id == repair_group_id)
+    {
+        return &mut snapshot.repair_groups[index];
+    }
+    snapshot.repair_groups.push(RepairGroupSummary {
+        repair_group_id: repair_group_id.to_string(),
+        children: Vec::new(),
+        started_at_ms: now_ms(),
+        ended_at_ms: None,
+        final_status: None,
+        last_error: None,
+    });
+    snapshot.repair_groups.last_mut().expect("just pushed")
+}
+
+fn update_attempt_mut<F>(snapshot: &mut DiagnosticsSnapshot, attempt: &AttemptLog, update: F)
+where
+    F: FnOnce(&mut AttemptSummary),
+{
+    if let Some(group_id) = &attempt.repair_group_id {
+        if let Some(group) = snapshot
+            .repair_groups
+            .iter_mut()
+            .find(|group| &group.repair_group_id == group_id)
+        {
+            if let Some(child) = group
+                .children
+                .iter_mut()
+                .rev()
+                .find(|child| child.attempt_id == attempt.attempt_id)
+            {
+                update(child);
+            }
+        }
+    } else if attempt.flow == "update" {
+        if let Some(summary) = snapshot.update.as_mut() {
+            if summary.attempt_id == attempt.attempt_id {
+                update(summary);
+            }
+        }
+    } else if let Some(summary) = snapshot.install.as_mut() {
+        if summary.attempt_id == attempt.attempt_id {
+            update(summary);
+        }
+    }
+}
+
+pub(crate) fn record_segment_path(
+    diagnostics: &DiagnosticsState,
+    owner: &SegmentOwner,
+    path: PathBuf,
+) {
+    with_snapshot(diagnostics, |snapshot| match owner {
+        SegmentOwner::Install { attempt_id } => {
+            if let Some(summary) = snapshot.install.as_mut() {
+                if &summary.attempt_id == attempt_id && !summary.log_segments.contains(&path) {
+                    summary.log_segments.push(path.clone());
+                }
+            }
+            for summary in &mut snapshot.install_history {
+                if &summary.attempt_id == attempt_id && !summary.log_segments.contains(&path) {
+                    summary.log_segments.push(path.clone());
+                }
+            }
+        }
+        SegmentOwner::Update { attempt_id } => {
+            if let Some(summary) = snapshot.update.as_mut() {
+                if &summary.attempt_id == attempt_id && !summary.log_segments.contains(&path) {
+                    summary.log_segments.push(path.clone());
+                }
+            }
+        }
+        SegmentOwner::Repair {
+            repair_group_id,
+            attempt_id,
+            ..
+        } => {
+            if let Some(group) = snapshot
+                .repair_groups
+                .iter_mut()
+                .find(|group| &group.repair_group_id == repair_group_id)
+            {
+                if let Some(child) = group
+                    .children
+                    .iter_mut()
+                    .find(|child| &child.attempt_id == attempt_id)
+                {
+                    if !child.log_segments.contains(&path) {
+                        child.log_segments.push(path.clone());
+                    }
+                }
+            }
+        }
+        SegmentOwner::Backend { session_id } => {
+            if let Some(backend) = snapshot.backend.as_mut() {
+                if backend.session_id.as_deref() == Some(session_id)
+                    && !backend.log_segments.contains(&path)
+                {
+                    backend.log_segments.push(path.clone());
+                }
+            }
+        }
+    });
+}
+
+pub(crate) fn forget_segment_path(
+    diagnostics: &DiagnosticsState,
+    owner: &SegmentOwner,
+    path: &PathBuf,
+) {
+    with_snapshot(diagnostics, |snapshot| match owner {
+        SegmentOwner::Install { attempt_id } => {
+            if let Some(summary) = snapshot.install.as_mut() {
+                if &summary.attempt_id == attempt_id {
+                    summary.log_segments.retain(|segment| segment != path);
+                }
+            }
+            for summary in &mut snapshot.install_history {
+                if &summary.attempt_id == attempt_id {
+                    summary.log_segments.retain(|segment| segment != path);
+                }
+            }
+        }
+        SegmentOwner::Update { attempt_id } => {
+            if let Some(summary) = snapshot.update.as_mut() {
+                if &summary.attempt_id == attempt_id {
+                    summary.log_segments.retain(|segment| segment != path);
+                }
+            }
+        }
+        SegmentOwner::Repair {
+            repair_group_id,
+            attempt_id,
+            ..
+        } => {
+            if let Some(group) = snapshot
+                .repair_groups
+                .iter_mut()
+                .find(|group| &group.repair_group_id == repair_group_id)
+            {
+                if let Some(child) = group
+                    .children
+                    .iter_mut()
+                    .find(|child| &child.attempt_id == attempt_id)
+                {
+                    child.log_segments.retain(|segment| segment != path);
+                }
+            }
+        }
+        SegmentOwner::Backend { session_id } => {
+            if let Some(backend) = snapshot.backend.as_mut() {
+                if backend.session_id.as_deref() == Some(session_id) {
+                    backend.log_segments.retain(|segment| segment != path);
+                }
+            }
+        }
+    });
+}
+
+fn disposition_label(disposition: &DesktopPreflightDisposition) -> &'static str {
+    match disposition {
+        DesktopPreflightDisposition::NotInstalled => "not_installed",
+        DesktopPreflightDisposition::ManagedReady => "managed_ready",
+        DesktopPreflightDisposition::ManagedStale => "managed_stale",
+        DesktopPreflightDisposition::AttachedReady => "attached_ready",
+    }
+}
diff --git a/studio/src-tauri/src/install.rs b/studio/src-tauri/src/install.rs
index 5760989353..9d672f5e73 100644
--- a/studio/src-tauri/src/install.rs
+++ b/studio/src-tauri/src/install.rs
@@ -1,3 +1,4 @@
+use crate::diagnostics::{self, AttemptLog, DiagnosticsState};
 use log::{error, info, warn};
 use process_wrap::std::*;
 use std::io::BufRead;
@@ -14,6 +15,8 @@ pub struct InstallProcess {
     pub intentional_stop: bool,
     /// Packages needing elevated install, parsed from [TAURI:NEED_SUDO] output.
     pub needed_packages: Vec<String>,
+    /// Current diagnostics attempt; kept after NEEDS_ELEVATION so apt output can be linked.
+    pub current_attempt: Option<AttemptLog>,
 }
 
 impl Default for InstallProcess {
@@ -22,6 +25,7 @@ impl Default for InstallProcess {
             child: None,
             intentional_stop: false,
             needed_packages: Vec::new(),
+            current_attempt: None,
         }
     }
 }
@@ -228,6 +232,8 @@ fn stream_output(
     app: &AppHandle,
     state: &InstallState,
     event_mode: InstallEventMode,
+    diagnostics: DiagnosticsState,
+    attempt: AttemptLog,
     stdout: Option<std::process::ChildStdout>,
     stderr: Option<std::process::ChildStderr>,
 ) -> Vec<std::thread::JoinHandle<()>> {
@@ -236,6 +242,8 @@ fn stream_output(
     if let Some(out) = stdout {
         let app_clone = app.clone();
         let state_clone = Arc::clone(state);
+        let diagnostics_clone = diagnostics.clone();
+        let attempt_clone = attempt.clone();
         threads.push(std::thread::spawn(move || {
             let mut reader = std::io::BufReader::new(out);
             let mut buf = Vec::new();
@@ -245,14 +253,21 @@ fn stream_output(
                     Ok(0) => break,
                     Ok(_) => {
                         let text = String::from_utf8_lossy(trim_line_endings(&buf)).into_owned();
+                        diagnostics::append_phase_line(&attempt_clone.handle, "stdout", &text);
                         // Parse structured Tauri protocol lines
                         if let Some(packages) = text.strip_prefix("[TAURI:NEED_SUDO] ") {
                             let pkgs: Vec<String> =
                                 packages.split_whitespace().map(String::from).collect();
                             if let Ok(mut install) = state_clone.lock() {
-                                install.needed_packages = pkgs;
+                                install.needed_packages = pkgs.clone();
                             }
+                            diagnostics::record_elevation_packages(
+                                &diagnostics_clone,
+                                &attempt_clone,
+                                &pkgs,
+                            );
                         } else if let Some(step) = text.strip_prefix("[TAURI:STEP] ") {
+                            diagnostics::record_step(&diagnostics_clone, &attempt_clone, step);
                             if !event_mode.emit_install_structured_events() {
                                 info!("[install][stdout] {}", text);
                                 let _ = app_clone.emit(event_mode.progress_event(), &text);
@@ -260,12 +275,23 @@ fn stream_output(
                             }
                             let _ = app_clone.emit("install-step", step);
                         } else if let Some(detail) = text.strip_prefix("[TAURI:PROGRESS] ") {
+                            diagnostics::record_progress(
+                                &diagnostics_clone,
+                                &attempt_clone,
+                                detail,
+                            );
                             if !event_mode.emit_install_structured_events() {
                                 info!("[install][stdout] {}", text);
                                 let _ = app_clone.emit(event_mode.progress_event(), detail);
                                 continue;
                             }
                             let _ = app_clone.emit("install-progress-detail", detail);
+                        } else if let Some(marker) = text.strip_prefix("[TAURI:DIAG] ") {
+                            diagnostics::record_diag_marker(
+                                &diagnostics_clone,
+                                &attempt_clone,
+                                marker,
+                            );
                         }
                         // Always forward the raw line
                         info!("[install][stdout] {}", text);
@@ -282,6 +308,7 @@ fn stream_output(
 
     if let Some(err) = stderr {
         let app_clone = app.clone();
+        let attempt_clone = attempt.clone();
         threads.push(std::thread::spawn(move || {
             let mut reader = std::io::BufReader::new(err);
             let mut buf = Vec::new();
@@ -291,6 +318,7 @@ fn stream_output(
                     Ok(0) => break,
                     Ok(_) => {
                         let text = String::from_utf8_lossy(trim_line_endings(&buf)).into_owned();
+                        diagnostics::append_phase_line(&attempt_clone.handle, "stderr", &text);
                         warn!("[install][stderr] {}", text);
                         let _ = app_clone.emit(event_mode.progress_event(), &text);
                     }
@@ -345,30 +373,94 @@ fn wait_for_exit(state: &InstallState) -> Result<(ExitStatus, bool), String> {
 /// Run the install script. Returns Ok(()) on success.
 /// Returns Err("NEEDS_ELEVATION") if system packages need elevated install (Linux only).
 /// Returns Err(message) on other failures.
-pub fn run_install(app: AppHandle, state: InstallState) -> Result<(), String> {
-    run_install_with_event_mode(app, state, InstallEventMode::Full)
+pub fn run_install(
+    app: AppHandle,
+    state: InstallState,
+    diagnostics: DiagnosticsState,
+) -> Result<(), String> {
+    run_install_with_event_mode(app, state, diagnostics, InstallEventMode::Full, None)
 }
 
-pub(crate) fn run_install_for_repair(app: AppHandle, state: InstallState) -> Result<(), String> {
-    run_install_with_event_mode(app, state, InstallEventMode::Repair)
+pub(crate) fn run_install_for_repair(
+    app: AppHandle,
+    state: InstallState,
+    diagnostics: DiagnosticsState,
+    repair_group_id: String,
+) -> Result<(), String> {
+    run_install_with_event_mode(
+        app,
+        state,
+        diagnostics,
+        InstallEventMode::Repair,
+        Some(repair_group_id),
+    )
 }
 
 fn run_install_with_event_mode(
     app: AppHandle,
     state: InstallState,
+    diagnostics: DiagnosticsState,
     event_mode: InstallEventMode,
+    repair_group_id: Option<String>,
 ) -> Result<(), String> {
+    let attempt = match repair_group_id.as_deref() {
+        Some(group_id) => diagnostics::begin_repair_child(&diagnostics, group_id, "install"),
+        None => diagnostics::begin_install_attempt(&diagnostics),
+    };
+    if let Ok(mut install) = state.lock() {
+        install.current_attempt = Some(attempt.clone());
+    }
+
     emit_mode_progress(&app, event_mode, "Starting installation...");
 
-    let (script, args) = resolve_install_script(&app)?;
+    let (script, args) = match resolve_install_script(&app) {
+        Ok(resolved) => resolved,
+        Err(msg) => {
+            diagnostics::finish_attempt(
+                &diagnostics,
+                &attempt,
+                None,
+                false,
+                Some(format!("resolve_install_script: {msg}")),
+            );
+            clear_current_attempt(&state);
+            return Err(msg);
+        }
+    };
+    diagnostics::append_phase_line(
+        &attempt.handle,
+        "meta",
+        &format!("Using script: {}", script.display()),
+    );
     emit_mode_progress(
         &app,
         event_mode,
         &format!("Using script: {}", script.display()),
     );
 
-    let (stdout, stderr) = spawn_script(&script, &args, &state)?;
-    let threads = stream_output(&app, &state, event_mode, stdout, stderr);
+    let (stdout, stderr) = match spawn_script(&script, &args, &state) {
+        Ok(handles) => handles,
+        Err(msg) => {
+            diagnostics::finish_attempt(
+                &diagnostics,
+                &attempt,
+                None,
+                false,
+                Some(format!("spawn_install_script: {msg}")),
+            );
+            clear_current_attempt(&state);
+            return Err(msg);
+        }
+    };
+    let threads = stream_output(
+        &app,
+        &state,
+        event_mode,
+        diagnostics.clone(),
+        attempt.clone(),
+        stdout,
+        stderr,
+    );
 
     // Wait for exit, join reader threads
     let result = wait_for_exit(&state);
@@ -378,12 +470,20 @@ fn run_install_with_event_mode(
 
     match result {
         Ok((status, _)) if status.success() => {
+            diagnostics::finish_attempt(
+                &diagnostics,
+                &attempt,
+                Some(status.to_string()),
+                false,
+                None,
+            );
+            clear_current_attempt(&state);
             if event_mode.emit_terminal_events() {
                 emit_complete(&app);
             }
             Ok(())
         }
-        Ok((status, _)) => {
+        Ok((status, intentional)) => {
             let code = status.code().unwrap_or(-1);
             if code == 2 {
                 // Script needs elevated package install — report to frontend
@@ -391,11 +491,27 @@ fn run_install_with_event_mode(
                     .lock()
                     .map(|i| i.needed_packages.clone())
                     .unwrap_or_default();
+                diagnostics::record_elevation_packages(&diagnostics, &attempt, &packages);
+                diagnostics::finish_attempt(
+                    &diagnostics,
+                    &attempt,
+                    Some(status.to_string()),
+                    intentional,
+                    Some("needs_elevation".to_string()),
+                );
                 info!("[install] Needs elevation for packages: {:?}", packages);
                 let _ = app.emit(event_mode.needs_elevation_event(), &packages);
                 Err("NEEDS_ELEVATION".to_string())
             } else {
                 let msg = format!("Installer exited with code {}", code);
+                diagnostics::finish_attempt(
+                    &diagnostics,
+                    &attempt,
+                    Some(status.to_string()),
+                    intentional,
+                    Some(msg.clone()),
+                );
+                clear_current_attempt(&state);
                 if event_mode.emit_terminal_events() {
                     emit_failed(&app, &msg);
                 }
@@ -403,10 +519,14 @@ fn run_install_with_event_mode(
             }
         }
         Err(msg) if msg == "Installation stopped." => {
+            diagnostics::finish_attempt(&diagnostics, &attempt, None, true, Some(msg.clone()));
+            clear_current_attempt(&state);
             info!("[install] Installation stopped intentionally");
             Err(msg)
         }
         Err(msg) => {
+            diagnostics::finish_attempt(&diagnostics, &attempt, None, false, Some(msg.clone()));
+            clear_current_attempt(&state);
             if event_mode.emit_terminal_events() {
                 emit_failed(&app, &msg);
             }
@@ -415,6 +535,69 @@ fn run_install_with_event_mode(
     }
 }
 
+fn clear_current_attempt(state: &InstallState) {
+    if let Ok(mut install) = state.lock() {
+        install.current_attempt = None;
+    }
+}
+
+pub fn take_pending_repair_group_for_resume(state: &InstallState) -> Option<String> {
+    let mut install = state.lock().ok()?;
+    let repair_group_id = install
+        .current_attempt
+        .as_ref()
+        .and_then(|attempt| attempt.repair_group_id.clone());
+    if repair_group_id.is_some() {
+        install.current_attempt = None;
+    }
+    repair_group_id
+}
+
+pub fn record_pending_elevation_canceled(
+    state: &InstallState,
+    diagnostics: &DiagnosticsState,
+) -> bool {
+    let attempt = state
+        .lock()
+        .ok()
+        .and_then(|mut install| install.current_attempt.take());
+    let Some(attempt) = attempt else {
+        return false;
+    };
+    diagnostics::finish_attempt(
+        diagnostics,
+        &attempt,
+        None,
+        true,
+        Some("elevation_canceled".to_string()),
+    );
+    if let Some(repair_group_id) = attempt.repair_group_id.as_deref() {
+        diagnostics::finish_repair_group(
+            diagnostics,
+            repair_group_id,
+            "canceled",
+            Some("elevation_canceled".to_string()),
+        );
+    }
+    true
+}
+
+pub fn record_install_intentional_stop(state: &InstallState, diagnostics: &DiagnosticsState) {
+    let attempt = state
+        .lock()
+        .ok()
+        .and_then(|install| install.current_attempt.clone());
+    if let Some(attempt) = attempt {
+        diagnostics::finish_attempt(
+            diagnostics,
+            &attempt,
+            None,
+            true,
+            Some("intentional_stop".to_string()),
+        );
+    }
+}
+
 /// Stop a running install process gracefully.
 /// Unix: SIGTERM to process group -> wait up to 5s -> SIGKILL
 /// Windows: hidden taskkill /T /F to terminate the installer tree
@@ -481,65 +664,222 @@ pub fn stop_install(state: &InstallState) -> Result<(), String> {
     }
 }
 
-/// Install system packages with elevated permissions (Linux only).
+/// Install apt system packages with elevated permissions (Linux only).
 /// Uses `elevated-command` crate for native auth dialog.
 #[cfg(target_os = "linux")]
-pub fn install_system_packages(packages: &[String]) -> Result<(), String> {
+pub fn install_system_packages(
+    packages: &[String],
+    state: &InstallState,
+    diagnostics: &DiagnosticsState,
+) -> Result<(), String> {
     use regex::Regex;
     use std::path::Path;
     use std::process::Command as StdCommand;
 
+    let current_attempt = state
+        .lock()
+        .ok()
+        .and_then(|install| install.current_attempt.clone());
+    let elevation_attempt = current_attempt
+        .as_ref()
+        .and_then(|attempt| attempt.repair_group_id.as_deref())
+        .map(|group_id| diagnostics::begin_repair_child(diagnostics, group_id, "elevation"))
+        .or_else(|| current_attempt.clone());
+    if let Some(attempt) = elevation_attempt.as_ref() {
+        diagnostics::append_phase_line(
+            &attempt.handle,
+            "meta",
+            &format!("Starting elevated apt install for: {}", packages.join(", ")),
+        );
+        diagnostics::record_elevation_packages(diagnostics, attempt, packages);
+    }
+
     // Validate package names to prevent injection via elevated command.
     let valid_pkg = Regex::new(r"^[a-zA-Z0-9][a-zA-Z0-9.+\-]*$").unwrap();
     for pkg in packages {
         if !valid_pkg.is_match(pkg) {
-            return Err(format!("Invalid package name: {}", pkg));
+            let msg = format!("Invalid package name: {}", pkg);
+            finish_elevation_failure(diagnostics, elevation_attempt.as_ref(), None, msg.clone());
+            clear_current_attempt(state);
+            return Err(msg);
         }
     }
 
-    // AppImage bundles run on non-Debian distros too. Pick the first package
-    // manager we find. Names in `packages` are Debian-style; callers that want
-    // cross-distro support should translate before invoking.
-    let (program, base_args): (&str, &[&str]) = if Path::new("/usr/bin/apt-get").exists() {
-        ("apt-get", &["install", "-y"])
-    } else if Path::new("/usr/bin/dnf").exists() {
-        ("dnf", &["install", "-y"])
-    } else if Path::new("/usr/bin/zypper").exists() {
-        ("zypper", &["install", "-y"])
-    } else if Path::new("/usr/bin/pacman").exists() {
-        ("pacman", &["-S", "--noconfirm"])
-    } else {
-        return Err(
-            "No supported system package manager found (apt-get, dnf, zypper, pacman)".to_string(),
-        );
-    };
+    // install.sh reports Debian package names. Do not pass them to dnf,
+    // zypper, or pacman where names differ; show an explicit support boundary
+    // instead of offering an elevation flow that is likely to fail.
+    if !Path::new("/usr/bin/apt-get").exists() {
+        let msg = "Automatic system package installation is supported on apt-based Linux distributions (Ubuntu/Debian) only. Install the missing dependencies with your package manager and retry."
+            .to_string();
+        finish_elevation_failure(diagnostics, elevation_attempt.as_ref(), None, msg.clone());
+        clear_current_attempt(state);
+        return Err(msg);
+    }
 
     info!(
-        "[install] Elevated install of packages via {}: {}",
-        program,
+        "[install] Elevated install of apt packages: {}",
         packages.join(", ")
     );
 
-    let mut cmd = StdCommand::new(program);
-    cmd.args(base_args).args(packages);
+    let mut update_cmd = StdCommand::new("apt-get");
+    update_cmd.args(["update", "-y"]);
+    match elevated_command::Command::new(update_cmd).output() {
+        Ok(elevated_update) => {
+            if let Some(attempt) = elevation_attempt.as_ref() {
+                diagnostics::append_phase_line(
+                    &attempt.handle,
+                    "apt-update-status",
+                    &elevated_update.status.to_string(),
+                );
+                append_capped_output(
+                    &attempt.handle,
+                    "apt-update-stdout",
+                    &elevated_update.stdout,
+                );
+                append_capped_output(
+                    &attempt.handle,
+                    "apt-update-stderr",
+                    &elevated_update.stderr,
+                );
+            }
+            if !elevated_update.status.success() {
+                let stderr = capped_output_text(&elevated_update.stderr);
+                warn!(
+                    "[install] apt-get update failed before elevated install; continuing with cached package metadata: {}",
+                    stderr
+                );
+                if let Some(attempt) = elevation_attempt.as_ref() {
+                    diagnostics::append_phase_line(
+                        &attempt.handle,
+                        "apt-update-warning",
+                        "apt-get update failed; continuing with apt-get install",
+                    );
+                }
+            }
+        }
+        Err(error) => {
+            warn!(
+                "[install] Elevated apt update could not run before install; continuing with apt-get install: {}",
+                error
+            );
+            if let Some(attempt) = elevation_attempt.as_ref() {
+                diagnostics::append_phase_line(
+                    &attempt.handle,
+                    "apt-update-error",
+                    &format!(
+                        "apt-get update could not run; continuing with apt-get install: {error}"
+                    ),
+                );
+            }
+        }
+    }
 
-    let elevated = elevated_command::Command::new(cmd)
-        .output()
-        .map_err(|e| format!("Elevated install failed: {}", e))?;
+    let mut install_cmd = StdCommand::new("apt-get");
+    install_cmd.args(["install", "-y"]).args(packages);
 
-    if !elevated.status.success() {
-        let stderr = String::from_utf8_lossy(&elevated.stderr);
+    let elevated_install = match elevated_command::Command::new(install_cmd).output() {
+        Ok(output) => output,
+        Err(error) => {
+            let msg = format!("Elevated install failed: {}", error);
+            finish_elevation_failure(diagnostics, elevation_attempt.as_ref(), None, msg.clone());
+            clear_current_attempt(state);
+            return Err(msg);
+        }
+    };
+    if let Some(attempt) = elevation_attempt.as_ref() {
+        diagnostics::append_phase_line(
+            &attempt.handle,
+            "apt-install-status",
+            &elevated_install.status.to_string(),
+        );
+        append_capped_output(
+            &attempt.handle,
+            "apt-install-stdout",
+            &elevated_install.stdout,
+        );
+        append_capped_output(
+            &attempt.handle,
+            "apt-install-stderr",
+            &elevated_install.stderr,
+        );
+    }
+
+    if !elevated_install.status.success() {
+        let stderr = capped_output_text(&elevated_install.stderr);
+        finish_elevation_failure(
+            diagnostics,
+            elevation_attempt.as_ref(),
+            Some(elevated_install.status.to_string()),
+            format!("Package installation failed: {stderr}"),
+        );
+        clear_current_attempt(state);
         return Err(format!("Package installation failed: {}", stderr));
     }
 
-    info!("[install] Elevated package install succeeded");
+    if let Some(attempt) = elevation_attempt.as_ref() {
+        diagnostics::finish_attempt(
+            diagnostics,
+            attempt,
+            Some(elevated_install.status.to_string()),
+            false,
+            None,
+        );
+    }
+    info!("[install] Elevated apt package install succeeded");
     Ok(())
 }
 
+#[cfg(target_os = "linux")]
+fn finish_elevation_failure(
+    diagnostics: &DiagnosticsState,
+    attempt: Option<&AttemptLog>,
+    exit_status: Option<String>,
+    message: String,
+) {
+    if let Some(attempt) = attempt {
+        diagnostics::finish_attempt(
+            diagnostics,
+            attempt,
+            exit_status,
+            false,
+            Some(message.clone()),
+        );
+        if let Some(repair_group_id) = attempt.repair_group_id.as_deref() {
+            diagnostics::finish_repair_group(diagnostics, repair_group_id, "failed", Some(message));
+        }
+    }
+}
+
+#[cfg(target_os = "linux")]
+fn append_capped_output(handle: &diagnostics::PhaseLogHandle, stream: &str, bytes: &[u8]) {
+    diagnostics::append_phase_line(handle, stream, &capped_output_text(bytes));
+}
+
+#[cfg(any(target_os = "linux", test))]
+fn capped_output_text(bytes: &[u8]) -> String {
+    const MAX_ELEVATED_OUTPUT_BYTES: usize = 64 * 1024;
+    let text = String::from_utf8_lossy(bytes);
+    if text.len() <= MAX_ELEVATED_OUTPUT_BYTES {
+        return text.into_owned();
+    }
+    let boundary = diagnostics::valid_utf8_boundary(&text, MAX_ELEVATED_OUTPUT_BYTES);
+    let mut truncated = text[..boundary].to_string();
+    truncated.push_str("\n[elevated output truncated after 64KiB]");
+    truncated
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    #[test]
+    fn elevated_output_cap_is_utf8_boundary_safe() {
+        let text = "é".repeat(40_000);
+        let capped = capped_output_text(text.as_bytes());
+        assert!(capped.ends_with("[elevated output truncated after 64KiB]"));
+        assert!(capped.is_char_boundary(capped.len()));
+    }
+
     #[test]
     fn repair_install_mode_uses_repair_elevation_event() {
         assert_eq!(
diff --git a/studio/src-tauri/src/main.rs b/studio/src-tauri/src/main.rs
index f7d49cce60..7ad40b8be2 100644
--- a/studio/src-tauri/src/main.rs
+++ b/studio/src-tauri/src/main.rs
@@ -2,7 +2,11 @@
 
 mod commands;
 mod desktop_auth;
+mod diagnostics;
 mod install;
+mod native_backend_lease;
+mod native_intents;
+mod native_path_policy;
 mod preflight;
 mod process;
 mod update;
@@ -58,6 +62,39 @@ fn setup_logging() {
     }
 }
 
+#[cfg(any(target_os = "windows", target_os = "linux"))]
+fn setup_custom_titlebar(app: &tauri::App) -> Result<(), Box<dyn std::error::Error>> {
+    let window = app.get_webview_window("main").ok_or_else(|| {
+        std::io::Error::new(std::io::ErrorKind::NotFound, "main window not found")
+    })?;
+    window.set_decorations(false)?;
+    Ok(())
+}
+
+fn cleanup_child_processes(app: &tauri::AppHandle) {
+    let diagnostics_state = app
+        .try_state::<diagnostics::DiagnosticsState>()
+        .map(|state| state.inner().clone());
+    if let Some(install_state) = app.try_state::<install::InstallState>() {
+        if let Some(diagnostics) = diagnostics_state.as_ref() {
+            install::record_install_intentional_stop(&install_state, diagnostics);
+        }
+        let _ = install::stop_install(&install_state);
+    }
+    if let Some(update_state) = app.try_state::<update::UpdateState>() {
+        if let Some(diagnostics) = diagnostics_state.as_ref() {
+            update::record_update_intentional_stop(&update_state, diagnostics);
+        }
+        let _ = update::stop_update(&update_state);
+    }
+    if let Some(backend_state) = app.try_state::<process::BackendState>() {
+        let shutdown = app
+            .try_state::<process::ShutdownFlag>()
+            .expect("ShutdownFlag must be managed");
+        let _ = process::stop_backend(&backend_state, &shutdown, diagnostics_state.as_ref());
+    }
+}
+
 fn setup_tray(app: &tauri::App) -> Result<(), Box<dyn std::error::Error>> {
     let open = MenuItemBuilder::with_id("open", "Open Studio").build(app)?;
     let toggle = MenuItemBuilder::with_id("toggle", "Start/Stop Server").build(app)?;
@@ -81,17 +118,15 @@ fn setup_tray(app: &tauri::App) -> Result<(), Box<dyn std::error::Error>> {
                 let _ = app.emit("tray-toggle-server", ());
             }
             "quit" => {
-                let install_state = app.state::<crate::install::InstallState>();
-                let _ = crate::install::stop_install(&install_state);
-                let update_state = app.state::<crate::update::UpdateState>();
-                let _ = crate::update::stop_update(&update_state);
-                // Detach the 5s graceful-wait so the tray click does not
-                // block the Tauri main loop. Exit runs the RunEvent::Exit
-                // safety net which also calls stop_backend synchronously.
-                let shutdown = app.state::<crate::process::ShutdownFlag>().inner().clone();
-                let backend_state = app.state::<crate::process::BackendState>().inner().clone();
-                crate::process::stop_backend_detached(backend_state, shutdown);
-                app.exit(0);
+                // Run cleanup off the menu callback, but only exit after the
+                // backend tree has been reaped. Exiting first can terminate this
+                // process while a detached cleanup thread is still waiting,
+                // leaving the backend orphaned.
+                let app_handle = app.clone();
+                std::thread::spawn(move || {
+                    cleanup_child_processes(&app_handle);
+                    app_handle.exit(0);
+                });
             }
             _ => {}
         })
@@ -132,8 +167,13 @@ fn main() {
         }))
         .plugin(tauri_plugin_process::init())
         .plugin(tauri_plugin_opener::init())
+        .plugin(tauri_plugin_notification::init())
+        .plugin(tauri_plugin_dialog::init())
         .plugin(tauri_plugin_updater::Builder::new().build())
+        .plugin(tauri_plugin_clipboard_manager::init())
+        .manage(diagnostics::new_diagnostics_state())
         .manage(install::new_install_state())
+        .manage(native_intents::new_native_intake_state())
         .manage(new_backend_state())
         .manage(process::new_shutdown_flag())
         .manage(update::new_update_state())
@@ -149,10 +189,21 @@ fn main() {
             commands::open_logs_dir,
             commands::start_backend_update,
             commands::start_managed_repair,
+            commands::cancel_pending_elevation,
             commands::install_system_packages,
             desktop_auth::desktop_auth,
+            diagnostics::collect_support_diagnostics,
+            native_intents::drain_native_intents,
+            native_intents::register_native_model_path,
+            native_intents::pick_native_model,
+            native_intents::consume_native_path_token,
+            native_intents::register_artifact_path,
+            native_intents::reveal_path_token,
+            native_intents::open_path_token,
         ])
         .setup(|app| {
+            #[cfg(any(target_os = "windows", target_os = "linux"))]
+            setup_custom_titlebar(app)?;
             setup_tray(app)?;
             Ok(())
         })
@@ -172,18 +223,7 @@ fn main() {
         .run(|app, event| {
             if let tauri::RunEvent::Exit = event {
                 // Cleanup on ALL exit paths — safety net for non-tray exits
-                if let Some(install_state) = app.try_state::<install::InstallState>() {
-                    let _ = install::stop_install(&install_state);
-                }
-                if let Some(update_state) = app.try_state::<update::UpdateState>() {
-                    let _ = update::stop_update(&update_state);
-                }
-                if let Some(backend_state) = app.try_state::<process::BackendState>() {
-                    let shutdown = app
-                        .try_state::<process::ShutdownFlag>()
-                        .expect("ShutdownFlag must be managed");
-                    let _ = process::stop_backend(&backend_state, &shutdown);
-                }
+                cleanup_child_processes(app);
             }
         });
 }
diff --git a/studio/src-tauri/src/native_backend_lease.rs b/studio/src-tauri/src/native_backend_lease.rs
new file mode 100644
index 0000000000..8c94a02f86
--- /dev/null
+++ b/studio/src-tauri/src/native_backend_lease.rs
@@ -0,0 +1,199 @@
+use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine as _};
+use hmac::{Hmac, Mac};
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+type HmacSha256 = Hmac<Sha256>;
+
+pub const LEASE_SECRET_ENV: &str = "UNSLOTH_STUDIO_NATIVE_PATH_LEASE_SECRET";
+const LEASE_VERSION: u8 = 1;
+const LEASE_TTL: Duration = Duration::from_secs(2 * 60);
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum NativePathOperation {
+    ValidateModel,
+    LoadModel,
+    DatasetPreview,
+    DatasetImport,
+    Attach,
+    Reveal,
+    Open,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum NativePathKind {
+    Model,
+    Dataset,
+    Attachment,
+    Artifact,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum NativePathSourceKind {
+    Dialog,
+    Drop,
+    DeepLink,
+    FileAssociation,
+    Artifact,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum NativePathType {
+    File,
+    Directory,
+}
+
+#[derive(Clone, Debug, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub struct NativePathLeasePayload {
+    pub version: u8,
+    pub operation: NativePathOperation,
+    pub canonical_path: String,
+    pub path_kind: NativePathKind,
+    pub path_type: NativePathType,
+    pub source_kind: NativePathSourceKind,
+    pub token_id_hash: String,
+    pub issued_at_ms: u64,
+    pub expires_at_ms: u64,
+    pub nonce: String,
+    pub display_label: String,
+    pub size_bytes: Option<u64>,
+    pub modified_ms: Option<u64>,
+}
+
+#[derive(Clone, Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NativePathLeaseResponse {
+    pub native_path_lease: String,
+    pub display_label: String,
+    pub expires_at_ms: u64,
+}
+
+pub fn new_lease_secret() -> Vec<u8> {
+    rand::random::<[u8; 32]>().to_vec()
+}
+
+pub fn encode_secret_env(secret: &[u8]) -> String {
+    URL_SAFE_NO_PAD.encode(secret)
+}
+
+pub fn now_ms() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_else(|_| Duration::from_secs(0))
+        .as_millis() as u64
+}
+
+pub fn token_hash(token: &str) -> String {
+    hex_bytes(&Sha256::digest(token.as_bytes()))
+}
+
+pub fn random_token(prefix: &str) -> String {
+    format!("{}{}", prefix, hex_bytes(&rand::random::<[u8; 24]>()))
+}
+
+pub fn random_nonce() -> String {
+    hex_bytes(&rand::random::<[u8; 16]>())
+}
+
+pub fn sign_path_lease(
+    secret: &[u8],
+    operation: NativePathOperation,
+    canonical_path: String,
+    path_kind: NativePathKind,
+    path_type: NativePathType,
+    source_kind: NativePathSourceKind,
+    token: &str,
+    display_label: String,
+    size_bytes: Option<u64>,
+    modified_ms: Option<u64>,
+) -> Result<NativePathLeaseResponse, String> {
+    let issued_at_ms = now_ms();
+    let expires_at_ms = issued_at_ms + LEASE_TTL.as_millis() as u64;
+    let payload = NativePathLeasePayload {
+        version: LEASE_VERSION,
+        operation,
+        canonical_path,
+        path_kind,
+        path_type,
+        source_kind,
+        token_id_hash: token_hash(token),
+        issued_at_ms,
+        expires_at_ms,
+        nonce: random_nonce(),
+        display_label: display_label.clone(),
+        size_bytes,
+        modified_ms,
+    };
+    sign_payload(secret, &payload).map(|native_path_lease| NativePathLeaseResponse {
+        native_path_lease,
+        display_label,
+        expires_at_ms,
+    })
+}
+
+fn sign_payload(secret: &[u8], payload: &NativePathLeasePayload) -> Result<String, String> {
+    let payload_json = serde_json::to_vec(payload).map_err(|e| e.to_string())?;
+    let payload_b64 = URL_SAFE_NO_PAD.encode(payload_json);
+    let signature = sign_bytes(secret, payload_b64.as_bytes())?;
+    Ok(format!(
+        "{}.{}",
+        payload_b64,
+        URL_SAFE_NO_PAD.encode(signature)
+    ))
+}
+
+fn sign_bytes(secret: &[u8], bytes: &[u8]) -> Result<Vec<u8>, String> {
+    let mut mac = HmacSha256::new_from_slice(secret).map_err(|e| e.to_string())?;
+    mac.update(bytes);
+    Ok(mac.finalize().into_bytes().to_vec())
+}
+
+pub fn hex_bytes(bytes: &[u8]) -> String {
+    const HEX: &[u8; 16] = b"0123456789abcdef";
+    let mut out = String::with_capacity(bytes.len() * 2);
+    for &byte in bytes {
+        out.push(HEX[(byte >> 4) as usize] as char);
+        out.push(HEX[(byte & 0x0f) as usize] as char);
+    }
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn token_hash_is_stable_hex_sha256() {
+        assert_eq!(
+            token_hash("native-token"),
+            "d0c16f641bc0a0ee6b63ff88cec29756638d19590893c340a1ae36c9fae7b07f"
+        );
+    }
+
+    #[test]
+    fn signed_lease_has_two_base64url_parts() {
+        let lease = sign_path_lease(
+            b"01234567890123456789012345678901",
+            NativePathOperation::ValidateModel,
+            "/tmp/model.gguf".to_string(),
+            NativePathKind::Model,
+            NativePathType::File,
+            NativePathSourceKind::Dialog,
+            "token",
+            "model.gguf".to_string(),
+            Some(123),
+            Some(456),
+        )
+        .unwrap();
+        let parts: Vec<&str> = lease.native_path_lease.split('.').collect();
+        assert_eq!(parts.len(), 2);
+        assert!(!parts[0].contains('='));
+        assert!(!parts[1].contains('='));
+    }
+}
diff --git a/studio/src-tauri/src/native_intents.rs b/studio/src-tauri/src/native_intents.rs
new file mode 100644
index 0000000000..30e11aa310
--- /dev/null
+++ b/studio/src-tauri/src/native_intents.rs
@@ -0,0 +1,476 @@
+use crate::native_backend_lease::{
+    encode_secret_env, now_ms, random_token, sign_path_lease, NativePathKind,
+    NativePathLeaseResponse, NativePathOperation, NativePathSourceKind, NativePathType,
+};
+use crate::native_path_policy::{
+    classify_artifact_path, classify_native_model_path, reveal_target, ClassifiedPath,
+    NativeArtifactKind,
+};
+use serde::Serialize;
+use std::collections::{HashMap, VecDeque};
+use std::path::{Path, PathBuf};
+use std::sync::Mutex;
+use std::time::Duration;
+use tauri::{AppHandle, WebviewWindow};
+use tauri_plugin_dialog::DialogExt;
+
+const TOKEN_TTL: Duration = Duration::from_secs(15 * 60);
+
+#[derive(Clone, Debug)]
+struct NativePathEntry {
+    token: String,
+    canonical_path: PathBuf,
+    validation_policy: NativePathValidationPolicy,
+    path_kind: NativePathKind,
+    path_type: NativePathType,
+    source_kind: NativePathSourceKind,
+    allowed_operations: Vec<NativePathOperation>,
+    display_label: String,
+    expires_at_ms: u64,
+    size_bytes: Option<u64>,
+    modified_ms: Option<u64>,
+}
+
+#[derive(Clone, Copy, Debug)]
+enum NativePathValidationPolicy {
+    Model,
+    Artifact(NativeArtifactKind),
+}
+
+#[derive(Clone, Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NativePathRef {
+    token: String,
+    kind: NativePathKind,
+    display_label: String,
+    allowed_operations: Vec<NativePathOperation>,
+    expires_at_ms: u64,
+}
+
+#[derive(Clone, Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NativeIntent {
+    id: String,
+    kind: NativePathKind,
+    source_kind: NativePathSourceKind,
+    path: NativePathRef,
+    display_label: String,
+}
+
+#[derive(Default)]
+struct NativeIntakeInner {
+    tokens: HashMap<String, NativePathEntry>,
+    queued_intents: VecDeque<NativeIntent>,
+}
+
+pub struct NativeIntakeState {
+    inner: Mutex<NativeIntakeInner>,
+    lease_secret: Vec<u8>,
+}
+
+pub fn new_native_intake_state() -> NativeIntakeState {
+    NativeIntakeState {
+        inner: Mutex::new(NativeIntakeInner::default()),
+        lease_secret: crate::native_backend_lease::new_lease_secret(),
+    }
+}
+
+impl NativeIntakeState {
+    pub fn lease_secret_env(&self) -> String {
+        encode_secret_env(&self.lease_secret)
+    }
+
+    #[allow(dead_code)]
+    pub fn enqueue_model_path(
+        &self,
+        path: impl AsRef<Path>,
+        source_kind: NativePathSourceKind,
+    ) -> Result<NativeIntent, String> {
+        let intent = self.register_model_path(path, source_kind)?;
+        let mut inner = self.inner.lock().map_err(|e| e.to_string())?;
+        inner.queued_intents.push_back(intent.clone());
+        Ok(intent)
+    }
+
+    fn register_model_path(
+        &self,
+        path: impl AsRef<Path>,
+        source_kind: NativePathSourceKind,
+    ) -> Result<NativeIntent, String> {
+        let classified = classify_native_model_path(path.as_ref())?;
+        self.register_classified_path(classified, source_kind, NativePathValidationPolicy::Model)
+    }
+
+    fn register_artifact(
+        &self,
+        kind: NativeArtifactKind,
+        path: impl AsRef<Path>,
+    ) -> Result<NativePathRef, String> {
+        let classified = classify_artifact_path(kind, path.as_ref())?;
+        let entry = self.insert_entry(
+            classified,
+            NativePathSourceKind::Artifact,
+            NativePathValidationPolicy::Artifact(kind),
+        )?;
+        Ok(entry.to_ref())
+    }
+
+    fn register_classified_path(
+        &self,
+        classified: ClassifiedPath,
+        source_kind: NativePathSourceKind,
+        validation_policy: NativePathValidationPolicy,
+    ) -> Result<NativeIntent, String> {
+        let entry = self.insert_entry(classified, source_kind, validation_policy)?;
+        Ok(NativeIntent {
+            id: random_token("intent_"),
+            kind: entry.path_kind,
+            source_kind,
+            path: entry.to_ref(),
+            display_label: entry.display_label.clone(),
+        })
+    }
+
+    fn insert_entry(
+        &self,
+        classified: ClassifiedPath,
+        source_kind: NativePathSourceKind,
+        validation_policy: NativePathValidationPolicy,
+    ) -> Result<NativePathEntry, String> {
+        let token = random_token("path_");
+        let expires_at_ms = now_ms() + TOKEN_TTL.as_millis() as u64;
+        let entry = NativePathEntry {
+            token: token.clone(),
+            canonical_path: classified.canonical_path,
+            validation_policy,
+            path_kind: classified.path_kind,
+            path_type: classified.path_type,
+            source_kind,
+            allowed_operations: classified.allowed_operations,
+            display_label: classified.display_label,
+            expires_at_ms,
+            size_bytes: classified.size_bytes,
+            modified_ms: classified.modified_ms,
+        };
+        let mut inner = self.inner.lock().map_err(|e| e.to_string())?;
+        inner.tokens.insert(token, entry.clone());
+        Ok(entry)
+    }
+
+    fn drain_intents(&self) -> Result<Vec<NativeIntent>, String> {
+        let mut inner = self.inner.lock().map_err(|e| e.to_string())?;
+        prune_expired(&mut inner);
+        Ok(inner.queued_intents.drain(..).collect())
+    }
+
+    fn entry_for_operation(
+        &self,
+        token: &str,
+        operation: NativePathOperation,
+    ) -> Result<NativePathEntry, String> {
+        let mut inner = self.inner.lock().map_err(|e| e.to_string())?;
+        prune_expired(&mut inner);
+        let entry = inner
+            .tokens
+            .get(token)
+            .ok_or_else(|| "Native path token is unavailable or expired.".to_string())?;
+        if !entry.allowed_operations.contains(&operation) {
+            return Err("Native path token does not allow this operation.".to_string());
+        }
+        Ok(entry.clone())
+    }
+
+    fn sign_grant(
+        &self,
+        token: &str,
+        operation: NativePathOperation,
+    ) -> Result<NativePathLeaseResponse, String> {
+        let entry = self.entry_for_operation(token, operation)?;
+        validate_entry_path(&entry, operation)?;
+        sign_path_lease(
+            &self.lease_secret,
+            operation,
+            entry.canonical_path.to_string_lossy().to_string(),
+            entry.path_kind,
+            entry.path_type,
+            entry.source_kind,
+            &entry.token,
+            entry.display_label,
+            entry.size_bytes,
+            entry.modified_ms,
+        )
+    }
+
+    fn path_for_operation(
+        &self,
+        token: &str,
+        operation: NativePathOperation,
+    ) -> Result<NativePathEntry, String> {
+        let entry = self.entry_for_operation(token, operation)?;
+        validate_entry_path(&entry, operation)?;
+        Ok(entry)
+    }
+}
+
+fn validate_entry_path(
+    entry: &NativePathEntry,
+    operation: NativePathOperation,
+) -> Result<(), String> {
+    let classified = match entry.validation_policy {
+        NativePathValidationPolicy::Model => classify_native_model_path(&entry.canonical_path)?,
+        NativePathValidationPolicy::Artifact(kind) => {
+            classify_artifact_path(kind, &entry.canonical_path)?
+        }
+    };
+    let check_fingerprint = !matches!(
+        operation,
+        NativePathOperation::Reveal | NativePathOperation::Open
+    );
+    if classified.canonical_path != entry.canonical_path
+        || classified.path_kind != entry.path_kind
+        || classified.path_type != entry.path_type
+        || !classified.allowed_operations.contains(&operation)
+        || (check_fingerprint && classified.size_bytes != entry.size_bytes)
+        || (check_fingerprint && classified.modified_ms != entry.modified_ms)
+    {
+        return Err("Native path changed after it was selected.".to_string());
+    }
+    Ok(())
+}
+
+impl NativePathEntry {
+    fn to_ref(&self) -> NativePathRef {
+        NativePathRef {
+            token: self.token.clone(),
+            kind: self.path_kind,
+            display_label: self.display_label.clone(),
+            allowed_operations: self.allowed_operations.clone(),
+            expires_at_ms: self.expires_at_ms,
+        }
+    }
+}
+
+fn prune_expired(inner: &mut NativeIntakeInner) {
+    let now = now_ms();
+    inner.tokens.retain(|_, entry| entry.expires_at_ms > now);
+    inner
+        .queued_intents
+        .retain(|intent| intent.path.expires_at_ms > now);
+}
+
+fn ensure_main_window(window: &WebviewWindow) -> Result<(), String> {
+    if window.label() == "main" {
+        Ok(())
+    } else {
+        Err("Native path commands are only available to the main window.".to_string())
+    }
+}
+
+#[tauri::command]
+pub fn drain_native_intents(
+    window: WebviewWindow,
+    state: tauri::State<'_, NativeIntakeState>,
+) -> Result<Vec<NativeIntent>, String> {
+    ensure_main_window(&window)?;
+    state.drain_intents()
+}
+
+#[tauri::command]
+pub fn register_native_model_path(
+    window: WebviewWindow,
+    state: tauri::State<'_, NativeIntakeState>,
+    path: String,
+) -> Result<NativeIntent, String> {
+    ensure_main_window(&window)?;
+    state.register_model_path(path, NativePathSourceKind::Drop)
+}
+
+#[tauri::command]
+pub async fn pick_native_model(
+    window: WebviewWindow,
+    app: AppHandle,
+    state: tauri::State<'_, NativeIntakeState>,
+) -> Result<Option<NativeIntent>, String> {
+    ensure_main_window(&window)?;
+    let (tx, rx) = tokio::sync::oneshot::channel();
+    app.dialog()
+        .file()
+        .set_title("Choose a GGUF model")
+        .add_filter("GGUF models", &["gguf"])
+        .pick_file(move |path| {
+            let _ = tx.send(path);
+        });
+    let Some(file_path) = rx.await.map_err(|_| "Dialog closed".to_string())? else {
+        return Ok(None);
+    };
+    let path = file_path
+        .into_path()
+        .map_err(|_| "Only local filesystem model paths are supported.".to_string())?;
+    state
+        .register_model_path(path, NativePathSourceKind::Dialog)
+        .map(Some)
+}
+
+#[tauri::command]
+pub fn consume_native_path_token(
+    window: WebviewWindow,
+    state: tauri::State<'_, NativeIntakeState>,
+    token: String,
+    operation: NativePathOperation,
+) -> Result<NativePathLeaseResponse, String> {
+    ensure_main_window(&window)?;
+    match operation {
+        NativePathOperation::Reveal | NativePathOperation::Open => {
+            Err("Reveal/Open do not use backend path grants.".to_string())
+        }
+        _ => state.sign_grant(&token, operation),
+    }
+}
+
+#[tauri::command]
+pub fn register_artifact_path(
+    window: WebviewWindow,
+    state: tauri::State<'_, NativeIntakeState>,
+    kind: NativeArtifactKind,
+    path: String,
+) -> Result<NativePathRef, String> {
+    ensure_main_window(&window)?;
+    state.register_artifact(kind, path)
+}
+
+#[tauri::command]
+pub fn reveal_path_token(
+    window: WebviewWindow,
+    state: tauri::State<'_, NativeIntakeState>,
+    token: String,
+) -> Result<(), String> {
+    ensure_main_window(&window)?;
+    let entry = state.path_for_operation(&token, NativePathOperation::Reveal)?;
+    #[cfg(target_os = "macos")]
+    {
+        if entry.canonical_path.is_file() {
+            return std::process::Command::new("open")
+                .arg("-R")
+                .arg(&entry.canonical_path)
+                .spawn()
+                .map(|_| ())
+                .map_err(|e| format!("Failed to reveal path: {e}"));
+        }
+    }
+    #[cfg(target_os = "windows")]
+    {
+        if entry.canonical_path.is_file() {
+            let mut select_arg = std::ffi::OsString::from("/select,");
+            select_arg.push(entry.canonical_path.as_os_str());
+            return std::process::Command::new("explorer")
+                .arg(select_arg)
+                .spawn()
+                .map(|_| ())
+                .map_err(|e| format!("Failed to reveal path: {e}"));
+        }
+    }
+    let target = reveal_target(&entry.canonical_path);
+    open::that_detached(target).map_err(|e| format!("Failed to reveal path: {e}"))
+}
+
+#[tauri::command]
+pub fn open_path_token(
+    window: WebviewWindow,
+    state: tauri::State<'_, NativeIntakeState>,
+    token: String,
+) -> Result<(), String> {
+    ensure_main_window(&window)?;
+    let entry = state.path_for_operation(&token, NativePathOperation::Open)?;
+    open::that_detached(entry.canonical_path).map_err(|e| format!("Failed to open path: {e}"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+    use std::time::{SystemTime, UNIX_EPOCH};
+
+    fn temp_path(name: &str) -> PathBuf {
+        let nanos = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_nanos();
+        std::env::temp_dir().join(format!(
+            "unsloth-native-intents-{name}-{}-{nanos}",
+            std::process::id()
+        ))
+    }
+
+    #[test]
+    fn model_token_issues_distinct_validate_and_load_grants() {
+        let state = new_native_intake_state();
+        let path = temp_path("model").with_extension("gguf");
+        fs::write(&path, b"gguf").unwrap();
+        let intent = state
+            .register_model_path(&path, NativePathSourceKind::Dialog)
+            .unwrap();
+        let validate = state
+            .sign_grant(&intent.path.token, NativePathOperation::ValidateModel)
+            .unwrap();
+        let load = state
+            .sign_grant(&intent.path.token, NativePathOperation::LoadModel)
+            .unwrap();
+        assert_ne!(validate.native_path_lease, load.native_path_lease);
+        assert!(validate.display_label.ends_with(".gguf"));
+        let _ = fs::remove_file(path);
+    }
+
+    #[test]
+    fn model_token_rejects_dataset_operation() {
+        let state = new_native_intake_state();
+        let path = temp_path("model").with_extension("gguf");
+        fs::write(&path, b"gguf").unwrap();
+        let intent = state
+            .register_model_path(&path, NativePathSourceKind::Dialog)
+            .unwrap();
+        let err = state
+            .sign_grant(&intent.path.token, NativePathOperation::DatasetImport)
+            .unwrap_err();
+        assert!(err.contains("does not allow"));
+        let _ = fs::remove_file(path);
+    }
+
+    #[test]
+    fn model_token_revalidates_path_changes() {
+        let state = new_native_intake_state();
+        let path = temp_path("model").with_extension("gguf");
+        fs::write(&path, b"gguf").unwrap();
+        let intent = state
+            .register_model_path(&path, NativePathSourceKind::Dialog)
+            .unwrap();
+        fs::write(&path, b"changed").unwrap();
+        let err = state
+            .sign_grant(&intent.path.token, NativePathOperation::ValidateModel)
+            .unwrap_err();
+        assert!(err.contains("changed"));
+        let _ = fs::remove_file(path);
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn reveal_rejects_symlink_replacement() {
+        use std::os::unix::fs::symlink;
+
+        let state = new_native_intake_state();
+        let path = temp_path("model").with_extension("gguf");
+        let target = temp_path("replacement").with_extension("gguf");
+        fs::write(&path, b"gguf").unwrap();
+        fs::write(&target, b"gguf").unwrap();
+        let intent = state
+            .register_model_path(&path, NativePathSourceKind::Dialog)
+            .unwrap();
+        fs::remove_file(&path).unwrap();
+        symlink(&target, &path).unwrap();
+        let err = state
+            .path_for_operation(&intent.path.token, NativePathOperation::Reveal)
+            .unwrap_err();
+        assert!(err.contains("Symlink") || err.contains("changed"));
+        let _ = fs::remove_file(path);
+        let _ = fs::remove_file(target);
+    }
+}
diff --git a/studio/src-tauri/src/native_path_policy.rs b/studio/src-tauri/src/native_path_policy.rs
new file mode 100644
index 0000000000..b2ebb34621
--- /dev/null
+++ b/studio/src-tauri/src/native_path_policy.rs
@@ -0,0 +1,291 @@
+use crate::native_backend_lease::{NativePathKind, NativePathOperation, NativePathType};
+use serde::{Deserialize, Serialize};
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::time::UNIX_EPOCH;
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum NativeArtifactKind {
+    TrainingOutput,
+    Export,
+    DatasetUpload,
+    RecipeArtifact,
+    DiagnosticLog,
+}
+
+#[derive(Clone, Debug)]
+pub struct ClassifiedPath {
+    pub canonical_path: PathBuf,
+    pub path_kind: NativePathKind,
+    pub path_type: NativePathType,
+    pub allowed_operations: Vec<NativePathOperation>,
+    pub display_label: String,
+    pub size_bytes: Option<u64>,
+    pub modified_ms: Option<u64>,
+}
+
+pub fn classify_native_model_path(path: &Path) -> Result<ClassifiedPath, String> {
+    let classified = classify_existing_path(path)?;
+    if classified.path_type != NativePathType::File {
+        return Err("Only GGUF model files are supported for native model intake.".to_string());
+    }
+    if !has_extension(&classified.canonical_path, "gguf") {
+        return Err("Only .gguf model files are supported for native model intake.".to_string());
+    }
+    Ok(ClassifiedPath {
+        path_kind: NativePathKind::Model,
+        allowed_operations: vec![
+            NativePathOperation::ValidateModel,
+            NativePathOperation::LoadModel,
+            NativePathOperation::Reveal,
+        ],
+        ..classified
+    })
+}
+
+pub fn classify_artifact_path(
+    kind: NativeArtifactKind,
+    path: &Path,
+) -> Result<ClassifiedPath, String> {
+    let classified = classify_existing_path(path)?;
+    ensure_artifact_root(kind, &classified.canonical_path)?;
+    reject_sensitive_artifact(&classified.canonical_path)?;
+
+    let mut allowed_operations = vec![NativePathOperation::Reveal];
+    if is_open_safe_artifact(&classified.canonical_path, classified.path_type) {
+        allowed_operations.push(NativePathOperation::Open);
+    }
+
+    Ok(ClassifiedPath {
+        path_kind: NativePathKind::Artifact,
+        allowed_operations,
+        ..classified
+    })
+}
+
+pub fn refresh_path_fingerprint(
+    path: &Path,
+) -> Result<(NativePathType, Option<u64>, Option<u64>), String> {
+    let metadata = fs::metadata(path).map_err(|e| format!("Path is no longer available: {e}"))?;
+    let path_type = if metadata.is_file() {
+        NativePathType::File
+    } else if metadata.is_dir() {
+        NativePathType::Directory
+    } else {
+        return Err("Special files are not supported.".to_string());
+    };
+    let size_bytes = metadata.is_file().then_some(metadata.len());
+    let modified_ms = metadata
+        .modified()
+        .ok()
+        .and_then(|modified| modified.duration_since(UNIX_EPOCH).ok())
+        .map(|duration| duration.as_millis() as u64);
+    Ok((path_type, size_bytes, modified_ms))
+}
+
+pub fn reveal_target(path: &Path) -> PathBuf {
+    if path.is_dir() {
+        path.to_path_buf()
+    } else {
+        path.parent().unwrap_or(path).to_path_buf()
+    }
+}
+
+fn sanitize_display_label(raw: &str) -> String {
+    let cleaned: String = raw
+        .chars()
+        .map(|ch| if ch.is_control() { ' ' } else { ch })
+        .collect();
+    let trimmed = cleaned.trim();
+    if trimmed.is_empty() {
+        "Selected path".to_string()
+    } else {
+        trimmed.chars().take(160).collect()
+    }
+}
+
+pub fn is_open_safe_artifact(path: &Path, path_type: NativePathType) -> bool {
+    if path_type == NativePathType::Directory {
+        return false;
+    }
+    let Some(ext) = path.extension().and_then(|ext| ext.to_str()) else {
+        return false;
+    };
+    matches!(
+        ext.to_ascii_lowercase().as_str(),
+        "txt" | "log" | "json" | "jsonl" | "csv" | "tsv" | "parquet" | "md"
+    )
+}
+
+fn classify_existing_path(path: &Path) -> Result<ClassifiedPath, String> {
+    reject_network_or_device_path(path)?;
+    let symlink_metadata =
+        fs::symlink_metadata(path).map_err(|e| format!("Path is not available: {e}"))?;
+    if symlink_metadata.file_type().is_symlink() {
+        return Err("Symlink paths are not supported for native intake.".to_string());
+    }
+
+    let canonical_path = path
+        .canonicalize()
+        .map_err(|e| format!("Path could not be resolved: {e}"))?;
+    reject_network_or_device_path(&canonical_path)?;
+    let canonical_symlink_metadata = fs::symlink_metadata(&canonical_path)
+        .map_err(|e| format!("Path is not available: {e}"))?;
+    if canonical_symlink_metadata.file_type().is_symlink() {
+        return Err("Symlink paths are not supported for native intake.".to_string());
+    }
+    let (path_type, size_bytes, modified_ms) = refresh_path_fingerprint(&canonical_path)?;
+    let display_label = sanitize_display_label(
+        canonical_path
+            .file_name()
+            .and_then(|name| name.to_str())
+            .unwrap_or("Selected path"),
+    );
+
+    Ok(ClassifiedPath {
+        canonical_path,
+        path_kind: NativePathKind::Artifact,
+        path_type,
+        allowed_operations: vec![NativePathOperation::Reveal],
+        display_label,
+        size_bytes,
+        modified_ms,
+    })
+}
+
+fn ensure_artifact_root(kind: NativeArtifactKind, canonical_path: &Path) -> Result<(), String> {
+    let Some(home) = dirs::home_dir() else {
+        return Err("Could not determine home directory.".to_string());
+    };
+    let studio = home.join(".unsloth").join("studio");
+    let allowed_root = match kind {
+        NativeArtifactKind::TrainingOutput => studio.join("outputs"),
+        NativeArtifactKind::Export => studio.join("exports"),
+        NativeArtifactKind::DatasetUpload => studio.join("assets").join("datasets").join("uploads"),
+        NativeArtifactKind::RecipeArtifact => {
+            studio.join("assets").join("datasets").join("recipes")
+        }
+        NativeArtifactKind::DiagnosticLog => studio.join("logs"),
+    };
+    let root = allowed_root
+        .canonicalize()
+        .map_err(|_| "Artifact root is not available.".to_string())?;
+    if canonical_path == root || canonical_path.starts_with(&root) {
+        Ok(())
+    } else {
+        Err("Artifact path is outside the allowed artifact root.".to_string())
+    }
+}
+
+fn reject_sensitive_artifact(path: &Path) -> Result<(), String> {
+    let lowered = path.to_string_lossy().to_ascii_lowercase();
+    for needle in [
+        "/auth/",
+        "\\auth\\",
+        "/auth.db",
+        "\\auth.db",
+        "/studio.db",
+        "\\studio.db",
+        "/pid",
+        "\\pid",
+    ] {
+        if lowered.contains(needle) {
+            return Err("Sensitive Studio state cannot be registered as an artifact.".to_string());
+        }
+    }
+    if let Some(ext) = path.extension().and_then(|ext| ext.to_str()) {
+        if matches!(
+            ext.to_ascii_lowercase().as_str(),
+            "exe" | "dll" | "dylib" | "so" | "sh" | "bash" | "zsh" | "ps1" | "bat" | "cmd"
+        ) {
+            return Err(
+                "Executable artifacts cannot be registered for native open/reveal.".to_string(),
+            );
+        }
+    }
+    Ok(())
+}
+
+fn reject_network_or_device_path(path: &Path) -> Result<(), String> {
+    let text = path.to_string_lossy();
+    #[cfg(windows)]
+    {
+        let normalized = text.replace('/', "\\").to_ascii_lowercase();
+        if let Some(rest) = normalized.strip_prefix("\\\\?\\") {
+            let bytes = rest.as_bytes();
+            if !(bytes.len() >= 3
+                && bytes[0].is_ascii_alphabetic()
+                && bytes[1] == b':'
+                && bytes[2] == b'\\')
+            {
+                return Err("Network paths are not supported for native intake.".to_string());
+            }
+        } else if normalized.starts_with("\\\\") {
+            return Err("Network paths are not supported for native intake.".to_string());
+        }
+    }
+    #[cfg(unix)]
+    {
+        for root in ["/dev", "/proc", "/sys"] {
+            if path.starts_with(root) {
+                return Err("Device and virtual filesystem paths are not supported.".to_string());
+            }
+        }
+    }
+    if text.contains('\0') {
+        return Err("Path contains invalid NUL characters.".to_string());
+    }
+    Ok(())
+}
+
+fn has_extension(path: &Path, expected: &str) -> bool {
+    path.extension()
+        .and_then(|ext| ext.to_str())
+        .map(|ext| ext.eq_ignore_ascii_case(expected))
+        .unwrap_or(false)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+    use std::time::{SystemTime, UNIX_EPOCH};
+
+    fn temp_path(name: &str) -> PathBuf {
+        let nanos = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_nanos();
+        std::env::temp_dir().join(format!(
+            "unsloth-native-policy-{name}-{}-{nanos}",
+            std::process::id()
+        ))
+    }
+
+    #[test]
+    fn gguf_model_allows_validate_load_reveal() {
+        let path = temp_path("model").with_extension("gguf");
+        fs::write(&path, b"gguf").unwrap();
+        let classified = classify_native_model_path(&path).unwrap();
+        assert_eq!(classified.path_kind, NativePathKind::Model);
+        assert!(classified
+            .allowed_operations
+            .contains(&NativePathOperation::ValidateModel));
+        assert!(classified
+            .allowed_operations
+            .contains(&NativePathOperation::LoadModel));
+        assert!(classified
+            .allowed_operations
+            .contains(&NativePathOperation::Reveal));
+        let _ = fs::remove_file(path);
+    }
+
+    #[test]
+    fn non_gguf_model_is_rejected() {
+        let path = temp_path("model").with_extension("txt");
+        fs::write(&path, b"not gguf").unwrap();
+        assert!(classify_native_model_path(&path).is_err());
+        let _ = fs::remove_file(path);
+    }
+}
diff --git a/studio/src-tauri/src/process.rs b/studio/src-tauri/src/process.rs
index beba8c1208..9e0cf1c17f 100644
--- a/studio/src-tauri/src/process.rs
+++ b/studio/src-tauri/src/process.rs
@@ -1,3 +1,4 @@
+use crate::diagnostics::{self, BackendLog, DiagnosticsState};
 use log::{error, info, warn};
 use process_wrap::std::*;
 use regex::Regex;
@@ -6,7 +7,7 @@ use std::io::BufRead;
 use std::process::{Command, Stdio};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
-use tauri::{AppHandle, Emitter};
+use tauri::{AppHandle, Emitter, Manager};
 
 const MAX_LOG_LINES: usize = 1000;
 
@@ -15,6 +16,8 @@ pub struct BackendProcess {
     pub port: Option<u16>,
     pub logs: VecDeque<String>,
     pub intentional_stop: bool,
+    pub generation: u64,
+    pub diagnostics_session: Option<BackendLog>,
 }
 
 impl Default for BackendProcess {
@@ -24,6 +27,8 @@ impl Default for BackendProcess {
             port: None,
             logs: VecDeque::with_capacity(MAX_LOG_LINES),
             intentional_stop: false,
+            generation: 0,
+            diagnostics_session: None,
         }
     }
 }
@@ -245,30 +250,61 @@ pub fn start_backend(
     state: &BackendState,
     port: u16,
     shutdown: &ShutdownFlag,
-) -> Result<(), String> {
-    let bin = resolve_backend_binary()?;
+    diagnostics_state: &DiagnosticsState,
+) -> Result<u64, String> {
+    let bin = match resolve_backend_binary() {
+        Ok(bin) => bin,
+        Err(msg) => {
+            diagnostics::record_backend_start_failure(
+                diagnostics_state,
+                Some(port),
+                None,
+                "resolve_backend_binary",
+                &msg,
+            );
+            return Err(msg);
+        }
+    };
 
     shutdown.store(false, Ordering::SeqCst);
 
-    // Reset state
-    {
+    // Reset state and invalidate any readers from an older backend generation
+    // before we release the lock and spawn a new child.
+    let generation = {
         let mut proc = state.lock().map_err(|e| e.to_string())?;
         if proc.child.is_some() {
             return Err("Backend is already running.".to_string());
         }
+        proc.generation = proc.generation.wrapping_add(1);
         proc.port = None;
         proc.logs.clear();
         proc.intentional_stop = false;
-    }
+        proc.diagnostics_session = None;
+        proc.generation
+    };
+
+    let backend_log = diagnostics::begin_backend_session(diagnostics_state, port, generation);
 
     let args = backend_args(port);
     info!("Starting backend: {:?} {}", bin, args.join(" "));
+    diagnostics::append_phase_line(
+        &backend_log.handle,
+        "meta",
+        &format!("Starting backend: {:?} {}", bin, args.join(" ")),
+    );
 
     let mut cmd = Command::new(&bin);
     cmd.args(&args)
         .stdout(Stdio::piped())
         .stderr(Stdio::piped());
 
+    if let Some(native_state) = app.try_state::<crate::native_intents::NativeIntakeState>() {
+        cmd.env(
+            crate::native_backend_lease::LEASE_SECRET_ENV,
+            native_state.lease_secret_env(),
+        );
+    }
+
     // AppImage sets LD_LIBRARY_PATH to its bundled libs, which breaks the spawned
     // Python process (wrong libpython/libz → "No module named encodings").
     // Only clear when running inside an AppImage — native .deb/.rpm installs may
@@ -289,9 +325,17 @@ pub fn start_backend(
 
         const CREATE_NEW_PROCESS_GROUP: u32 = 0x00000200;
         cmd.creation_flags(CREATE_NEW_PROCESS_GROUP | CREATE_NO_WINDOW);
-        let child = cmd
-            .spawn()
-            .map_err(|e| format!("Failed to spawn backend: {}", e))?;
+        let child = cmd.spawn().map_err(|e| {
+            let msg = format!("Failed to spawn backend: {}", e);
+            diagnostics::record_backend_start_failure(
+                diagnostics_state,
+                Some(port),
+                Some(generation),
+                "spawn_backend",
+                &msg,
+            );
+            msg
+        })?;
         Box::new(child)
     };
 
@@ -300,25 +344,45 @@ pub fn start_backend(
         // Keep the backend tree in a process group on Unix for cleanup.
         let mut wrap = CommandWrap::from(cmd);
         wrap.wrap(ProcessGroup::leader());
-        wrap.spawn()
-            .map_err(|e| format!("Failed to spawn backend: {}", e))?
+        wrap.spawn().map_err(|e| {
+            let msg = format!("Failed to spawn backend: {}", e);
+            diagnostics::record_backend_start_failure(
+                diagnostics_state,
+                Some(port),
+                Some(generation),
+                "spawn_backend",
+                &msg,
+            );
+            msg
+        })?
     };
 
     let stdout = child.stdout().take();
     let stderr = child.stderr().take();
 
-    // Store child in state
+    // Store child in state for the already-selected generation.
     {
         let mut proc = state.lock().map_err(|e| e.to_string())?;
         proc.child = Some(child);
+        proc.diagnostics_session = Some(backend_log.clone());
     }
 
     // Spawn stdout reader thread
     if let Some(stdout) = stdout {
         let app_handle = app.clone();
         let state_clone = Arc::clone(state);
+        let diagnostics_clone = diagnostics_state.clone();
+        let backend_log_clone = backend_log.clone();
         std::thread::spawn(move || {
-            read_output_stream(stdout, &app_handle, &state_clone, false);
+            read_output_stream(
+                stdout,
+                &app_handle,
+                &state_clone,
+                &diagnostics_clone,
+                &backend_log_clone,
+                false,
+                generation,
+            );
         });
     }
 
@@ -326,12 +390,22 @@ pub fn start_backend(
     if let Some(stderr) = stderr {
         let app_handle = app.clone();
         let state_clone = Arc::clone(state);
+        let diagnostics_clone = diagnostics_state.clone();
+        let backend_log_clone = backend_log.clone();
         std::thread::spawn(move || {
-            read_output_stream(stderr, &app_handle, &state_clone, true);
+            read_output_stream(
+                stderr,
+                &app_handle,
+                &state_clone,
+                &diagnostics_clone,
+                &backend_log_clone,
+                true,
+                generation,
+            );
         });
     }
 
-    Ok(())
+    Ok(generation)
 }
 
 /// Read lines from a child process stream (stdout or stderr).
@@ -341,7 +415,10 @@ fn read_output_stream<R: std::io::Read>(
     stream: R,
     app: &AppHandle,
     state: &BackendState,
+    diagnostics_state: &DiagnosticsState,
+    backend_log: &BackendLog,
     is_stderr: bool,
+    generation: u64,
 ) {
     let mut reader = std::io::BufReader::new(stream);
     let port_re = Regex::new(r"TAURI_PORT=(\d+)").unwrap();
@@ -359,27 +436,56 @@ fn read_output_stream<R: std::io::Read>(
                     text.clone()
                 };
 
+                diagnostics::append_phase_line(
+                    &backend_log.handle,
+                    if is_stderr { "stderr" } else { "stdout" },
+                    &text,
+                );
+
                 // Check for TAURI_PORT on stdout only
-                if !is_stderr {
-                    if let Some(caps) = port_re.captures(&text) {
-                        if let Some(port_str) = caps.get(1) {
-                            if let Ok(port) = port_str.as_str().parse::<u16>() {
-                                info!("Detected backend port: {}", port);
-                                if let Ok(mut proc) = state.lock() {
-                                    proc.port = Some(port);
-                                }
-                                let _ = app.emit("server-port", port);
-                            }
+                let detected_port = if !is_stderr {
+                    port_re
+                        .captures(&text)
+                        .and_then(|caps| caps.get(1))
+                        .and_then(|port_str| port_str.as_str().parse::<u16>().ok())
+                } else {
+                    None
+                };
+
+                // Buffer the log line only for the current backend generation.
+                // Old reader threads can briefly outlive a stop/start cycle;
+                // they must not overwrite the new backend's port or logs.
+                let mut should_record_port = None;
+                let current_generation = if let Ok(mut proc) = state.lock() {
+                    if proc.generation != generation {
+                        false
+                    } else {
+                        if let Some(port) = detected_port {
+                            proc.port = Some(port);
+                            should_record_port = Some(port);
                         }
+                        if proc.logs.len() >= MAX_LOG_LINES {
+                            proc.logs.pop_front();
+                        }
+                        proc.logs.push_back(log_line.clone());
+                        true
                     }
+                } else {
+                    false
+                };
+
+                if !current_generation {
+                    break;
                 }
 
-                // Buffer the log line
-                if let Ok(mut proc) = state.lock() {
-                    if proc.logs.len() >= MAX_LOG_LINES {
-                        proc.logs.pop_front();
-                    }
-                    proc.logs.push_back(log_line.clone());
+                if let Some(port) = should_record_port {
+                    diagnostics::record_backend_port(
+                        diagnostics_state,
+                        &backend_log.session_id,
+                        port,
+                    );
+                    info!("Detected backend port: {}", port);
+                    let _ = app.emit("server-port", port);
                 }
 
                 info!("[backend] {}", log_line);
@@ -400,12 +506,18 @@ fn read_output_stream<R: std::io::Read>(
 
     // Stream closed. Only the stdout reader checks for crashes.
     if !is_stderr {
+        let mut exit_record: Option<(String, bool)> = None;
+        let mut emit_crash = false;
         if let Ok(mut proc) = state.lock() {
+            if proc.generation != generation {
+                return;
+            }
             let intentional = proc.intentional_stop;
             let exited = if let Some(ref mut child) = proc.child {
                 match child.try_wait() {
                     Ok(Some(status)) => {
                         info!("Backend stdout stream ended with status: {}", status);
+                        exit_record = Some((status.to_string(), intentional));
                         true
                     }
                     Ok(None) => {
@@ -423,20 +535,38 @@ fn read_output_stream<R: std::io::Read>(
 
             if exited {
                 proc.child = None;
-                if !intentional {
-                    error!("Backend process stdout closed unexpectedly (crash detected)");
-                    let _ = app.emit("server-crashed", ());
-                }
+                proc.diagnostics_session = None;
+                emit_crash = !intentional;
             }
         }
+        if let Some((status, intentional)) = exit_record {
+            diagnostics::record_backend_exit(
+                diagnostics_state,
+                &backend_log.session_id,
+                Some(status),
+                intentional,
+                None,
+            );
+        }
+        if emit_crash {
+            error!("Backend process stdout closed unexpectedly (crash detected)");
+            let _ = app.emit("server-crashed", ());
+        }
     }
 }
 
 /// Graceful shutdown of the backend process and its entire subprocess tree.
 /// Unix: SIGTERM to process group -> wait up to 5s -> SIGKILL to group
 /// Windows: CTRL_BREAK_EVENT -> wait up to 5s -> hidden taskkill /T /F
-pub fn stop_backend(state: &BackendState, shutdown: &ShutdownFlag) -> Result<(), String> {
+pub fn stop_backend(
+    state: &BackendState,
+    shutdown: &ShutdownFlag,
+    diagnostics_state: Option<&DiagnosticsState>,
+) -> Result<(), String> {
     shutdown.store(true, Ordering::SeqCst);
+    if let Some(diagnostics_state) = diagnostics_state {
+        diagnostics::record_backend_intentional_stop(diagnostics_state);
+    }
 
     // Extract the child and mark intentional stop.
     // We take the child OUT of the mutex so we don't hold the lock during the wait loop.
@@ -526,12 +656,3 @@ pub fn stop_backend(state: &BackendState, shutdown: &ShutdownFlag) -> Result<(),
         Ok(())
     }
 }
-
-/// Spawn `stop_backend` on a background thread and return immediately.
-/// Used by the tray "quit" path so the 5s graceful-wait does not block
-/// the Tauri main event loop before `app.exit(0)` fires.
-pub fn stop_backend_detached(state: BackendState, shutdown: ShutdownFlag) {
-    std::thread::spawn(move || {
-        let _ = stop_backend(&state, &shutdown);
-    });
-}
diff --git a/studio/src-tauri/src/update.rs b/studio/src-tauri/src/update.rs
index 477f18ce28..e79432312a 100644
--- a/studio/src-tauri/src/update.rs
+++ b/studio/src-tauri/src/update.rs
@@ -1,3 +1,4 @@
+use crate::diagnostics::{self, AttemptLog, DiagnosticsState};
 use log::{error, info, warn};
 use process_wrap::std::*;
 use std::io::BufRead;
@@ -10,6 +11,7 @@ use tauri::{AppHandle, Emitter};
 pub struct UpdateProcess {
     pub child: Option<Box<dyn ChildWrapper + Send>>,
     pub intentional_stop: bool,
+    pub current_attempt: Option<AttemptLog>,
 }
 
 impl Default for UpdateProcess {
@@ -17,6 +19,7 @@ impl Default for UpdateProcess {
         Self {
             child: None,
             intentional_stop: false,
+            current_attempt: None,
         }
     }
 }
@@ -88,6 +91,8 @@ fn spawn_update(
 fn stream_output(
     app: &AppHandle,
     progress_event: &'static str,
+    diagnostics: DiagnosticsState,
+    attempt: AttemptLog,
     stdout: Option<std::process::ChildStdout>,
     stderr: Option<std::process::ChildStderr>,
 ) -> Vec<std::thread::JoinHandle<()>> {
@@ -95,11 +100,29 @@ fn stream_output(
 
     if let Some(out) = stdout {
         let app_clone = app.clone();
+        let diagnostics_clone = diagnostics.clone();
+        let attempt_clone = attempt.clone();
         threads.push(std::thread::spawn(move || {
             let reader = std::io::BufReader::new(out);
             for line in reader.lines() {
                 match line {
                     Ok(text) => {
+                        diagnostics::append_phase_line(&attempt_clone.handle, "stdout", &text);
+                        if let Some(step) = text.strip_prefix("[TAURI:STEP] ") {
+                            diagnostics::record_step(&diagnostics_clone, &attempt_clone, step);
+                        } else if let Some(progress) = text.strip_prefix("[TAURI:PROGRESS] ") {
+                            diagnostics::record_progress(
+                                &diagnostics_clone,
+                                &attempt_clone,
+                                progress,
+                            );
+                        } else if let Some(marker) = text.strip_prefix("[TAURI:DIAG] ") {
+                            diagnostics::record_diag_marker(
+                                &diagnostics_clone,
+                                &attempt_clone,
+                                marker,
+                            );
+                        }
                         info!("[update][stdout] {}", text);
                         let _ = app_clone.emit(progress_event, &text);
                     }
@@ -114,11 +137,13 @@ fn stream_output(
 
     if let Some(err) = stderr {
         let app_clone = app.clone();
+        let attempt_clone = attempt.clone();
         threads.push(std::thread::spawn(move || {
             let reader = std::io::BufReader::new(err);
             for line in reader.lines() {
                 match line {
                     Ok(text) => {
+                        diagnostics::append_phase_line(&attempt_clone.handle, "stderr", &text);
                         warn!("[update][stderr] {}", text);
                         let _ = app_clone.emit(progress_event, &text);
                     }
@@ -167,26 +192,54 @@ fn wait_for_exit(state: &UpdateState) -> Result<(ExitStatus, bool), String> {
 
 // ── Public API ──
 
-pub fn run_backend_update(app: AppHandle, state: UpdateState) -> Result<(), String> {
-    run_backend_update_with_terminal_events(app, state, true)
+pub fn run_backend_update(
+    app: AppHandle,
+    state: UpdateState,
+    diagnostics: DiagnosticsState,
+) -> Result<(), String> {
+    run_backend_update_with_terminal_events(app, state, diagnostics, true, None)
 }
 
 pub(crate) fn run_backend_update_for_repair(
     app: AppHandle,
     state: UpdateState,
+    diagnostics: DiagnosticsState,
+    repair_group_id: String,
 ) -> Result<(), String> {
-    run_backend_update_with_terminal_events(app, state, false)
+    run_backend_update_with_terminal_events(app, state, diagnostics, false, Some(repair_group_id))
 }
 
 fn run_backend_update_with_terminal_events(
     app: AppHandle,
     state: UpdateState,
+    diagnostics: DiagnosticsState,
     terminal_events: bool,
+    repair_group_id: Option<String>,
 ) -> Result<(), String> {
-    let bin = crate::process::find_unsloth_binary()
-        .ok_or("Unsloth binary not found. Cannot run update.")?;
+    let attempt = match repair_group_id.as_deref() {
+        Some(group_id) => diagnostics::begin_repair_child(&diagnostics, group_id, "update"),
+        None => diagnostics::begin_update_attempt(&diagnostics),
+    };
+    if let Ok(mut update) = state.lock() {
+        update.current_attempt = Some(attempt.clone());
+    }
+
+    let bin = match crate::process::find_unsloth_binary() {
+        Some(bin) => bin,
+        None => {
+            let msg = "Unsloth binary not found. Cannot run update.".to_string();
+            diagnostics::finish_attempt(&diagnostics, &attempt, None, false, Some(msg.clone()));
+            clear_current_attempt(&state);
+            return Err(msg);
+        }
+    };
 
     info!("[update] Starting backend update via {:?}", bin);
+    diagnostics::append_phase_line(
+        &attempt.handle,
+        "meta",
+        &format!("Starting backend update via {:?}", bin),
+    );
     let progress_event = if terminal_events {
         "update-progress"
     } else {
@@ -194,8 +247,28 @@ fn run_backend_update_with_terminal_events(
     };
     let _ = app.emit(progress_event, "Starting backend update...");
 
-    let (stdout, stderr) = spawn_update(&bin, &state)?;
-    let threads = stream_output(&app, progress_event, stdout, stderr);
+    let (stdout, stderr) = match spawn_update(&bin, &state) {
+        Ok(handles) => handles,
+        Err(msg) => {
+            diagnostics::finish_attempt(
+                &diagnostics,
+                &attempt,
+                None,
+                false,
+                Some(format!("spawn_update: {msg}")),
+            );
+            clear_current_attempt(&state);
+            return Err(msg);
+        }
+    };
+    let threads = stream_output(
+        &app,
+        progress_event,
+        diagnostics.clone(),
+        attempt.clone(),
+        stdout,
+        stderr,
+    );
 
     let result = wait_for_exit(&state);
     for handle in threads {
@@ -204,19 +277,43 @@ fn run_backend_update_with_terminal_events(
 
     match result {
         Ok((status, _)) if status.success() => {
+            diagnostics::finish_attempt(
+                &diagnostics,
+                &attempt,
+                Some(status.to_string()),
+                false,
+                None,
+            );
+            clear_current_attempt(&state);
             info!("[update] Backend update complete");
             if terminal_events {
                 let _ = app.emit("update-complete", ());
             }
             Ok(())
         }
-        Ok((_status, intentional)) if intentional => {
+        Ok((status, intentional)) if intentional => {
+            diagnostics::finish_attempt(
+                &diagnostics,
+                &attempt,
+                Some(status.to_string()),
+                true,
+                Some("Update stopped.".to_string()),
+            );
+            clear_current_attempt(&state);
             info!("[update] Update stopped intentionally");
             Err("Update stopped.".to_string())
         }
-        Ok((status, _)) => {
+        Ok((status, intentional)) => {
             let code = status.code().unwrap_or(-1);
             let msg = format!("Update exited with code {}", code);
+            diagnostics::finish_attempt(
+                &diagnostics,
+                &attempt,
+                Some(status.to_string()),
+                intentional,
+                Some(msg.clone()),
+            );
+            clear_current_attempt(&state);
             error!("[update] {}", msg);
             if terminal_events {
                 let _ = app.emit("update-failed", &msg);
@@ -224,6 +321,8 @@ fn run_backend_update_with_terminal_events(
             Err(msg)
         }
         Err(msg) => {
+            diagnostics::finish_attempt(&diagnostics, &attempt, None, false, Some(msg.clone()));
+            clear_current_attempt(&state);
             error!("[update] {}", msg);
             if terminal_events {
                 let _ = app.emit("update-failed", &msg);
@@ -233,6 +332,28 @@ fn run_backend_update_with_terminal_events(
     }
 }
 
+fn clear_current_attempt(state: &UpdateState) {
+    if let Ok(mut update) = state.lock() {
+        update.current_attempt = None;
+    }
+}
+
+pub fn record_update_intentional_stop(state: &UpdateState, diagnostics: &DiagnosticsState) {
+    let attempt = state
+        .lock()
+        .ok()
+        .and_then(|update| update.current_attempt.clone());
+    if let Some(attempt) = attempt {
+        diagnostics::finish_attempt(
+            diagnostics,
+            &attempt,
+            None,
+            true,
+            Some("intentional_stop".to_string()),
+        );
+    }
+}
+
 pub fn stop_update(state: &UpdateState) -> Result<(), String> {
     let mut child = {
         let mut update = match state.lock() {
diff --git a/studio/src-tauri/tauri.conf.json b/studio/src-tauri/tauri.conf.json
index 49819f8a25..eed7c1f352 100644
--- a/studio/src-tauri/tauri.conf.json
+++ b/studio/src-tauri/tauri.conf.json
@@ -2,8 +2,14 @@
   "productName": "Unsloth Studio (Desktop)",
   "identifier": "ai.unsloth.studio",
   "build": {
-    "beforeDevCommand": "npm --prefix ../frontend run dev -- --port 5173 --strictPort",
-    "beforeBuildCommand": "npm --prefix ../frontend run build",
+    "beforeDevCommand": {
+      "cwd": "../frontend",
+      "script": "npm run dev -- --port 5173 --strictPort"
+    },
+    "beforeBuildCommand": {
+      "cwd": "../frontend",
+      "script": "npm run build"
+    },
     "frontendDist": "../frontend/dist",
     "devUrl": "http://localhost:5173"
   },
@@ -18,21 +24,17 @@
         "title": "Unsloth Studio (Desktop)",
         "width": 690,
         "height": 480,
+        "center": true,
         "visible": false,
         "resizable": false
       }
-    ],
-    "trayIcon": {
-      "iconPath": "icons/icon.png",
-      "id": "main",
-      "tooltip": "Unsloth Studio (Desktop)"
-    }
+    ]
   },
   "plugins": {
     "updater": {
-      "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IDJENjJENDYxMTQ1QTYyOEIKUldTTFlsb1VZZFJpTFY1aHgyRkRqZUdjWGg0Sm1BVEZoMDVWME5PdE42bjZiekFRc1Fsb0JNbmIK",
+      "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IEQ2RDhGMDMzNDNEMTlGMkQKUldRdG45RkRNL0RZMXZsaVo2TElUQlVHb1hVNWEyajhUOGFXeTdNVDFZTFdBVUtlZUh5L2wwWVYK",
       "endpoints": [
-        "https://github.com/danielhanchen/unsloth-staging-2/releases/latest/download/latest.json"
+        "https://github.com/unslothai/unsloth/releases/latest/download/latest.json"
       ],
       "windows": {
         "installMode": "passive"
@@ -42,11 +44,14 @@
   "bundle": {
     "active": true,
     "createUpdaterArtifacts": true,
+    "publisher": "Unsloth AI",
+    "homepage": "https://unsloth.ai/",
+    "copyright": "© 2026 Unsloth AI. All rights reserved.",
+    "license": "AGPL-3.0-only",
     "targets": ["app", "appimage", "deb", "dmg", "nsis"],
     "resources": {
       "../../install.sh": "install.sh",
-      "../../install.ps1": "install.ps1",
-      "../install_python_stack.py": "install_python_stack.py"
+      "../../install.ps1": "install.ps1"
     },
     "icon": [
       "icons/32x32.png",
@@ -54,6 +59,18 @@
       "icons/icon.ico",
       "icons/icon.icns"
     ],
+    "windows": {
+      "nsis": {
+        "installerHooks": "./windows/hooks.nsh",
+        "template": "./windows/installer.nsi",
+        "installerIcon": "./icons/icon.ico",
+        "headerImage": "./windows/branding/nsis-header.bmp",
+        "sidebarImage": "./windows/branding/nsis-sidebar.bmp",
+        "installMode": "currentUser",
+        "languages": ["English"],
+        "displayLanguageSelector": false
+      }
+    },
     "linux": {
       "deb": {
         "postRemoveScript": "./linux/postremove.sh"
diff --git a/studio/src-tauri/tauri.windows.conf.json b/studio/src-tauri/tauri.windows.conf.json
index a68cf6351f..83f685cda4 100644
--- a/studio/src-tauri/tauri.windows.conf.json
+++ b/studio/src-tauri/tauri.windows.conf.json
@@ -4,12 +4,6 @@
       "signCommand": {
         "cmd": "trusted-signing-cli",
         "args": ["-e", "https://eus.codesigning.azure.net", "-d", "Unsloth Studio (Desktop)", "%1"]
-      },
-      "nsis": {
-        "installerHooks": "./windows/hooks.nsh",
-        "installerIcon": "./icons/icon.ico",
-        "headerImage": "./windows/branding/nsis-header.bmp",
-        "sidebarImage": "./windows/branding/nsis-sidebar.bmp"
       }
     }
   }
diff --git a/studio/src-tauri/windows/branding/nsis-header.bmp b/studio/src-tauri/windows/branding/nsis-header.bmp
index 7eacdce7db..b675c4e1c3 100644
Binary files a/studio/src-tauri/windows/branding/nsis-header.bmp and b/studio/src-tauri/windows/branding/nsis-header.bmp differ
diff --git a/studio/src-tauri/windows/branding/nsis-sidebar.bmp b/studio/src-tauri/windows/branding/nsis-sidebar.bmp
index c3bd480fc8..0113ee5932 100644
Binary files a/studio/src-tauri/windows/branding/nsis-sidebar.bmp and b/studio/src-tauri/windows/branding/nsis-sidebar.bmp differ
diff --git a/studio/src-tauri/windows/hooks.nsh b/studio/src-tauri/windows/hooks.nsh
index 64655e8f6e..8c68a3e54f 100644
--- a/studio/src-tauri/windows/hooks.nsh
+++ b/studio/src-tauri/windows/hooks.nsh
@@ -1,8 +1,9 @@
 ; Unsloth Studio NSIS installer hooks
 
 !macro NSIS_HOOK_POSTUNINSTALL
-  MessageBox MB_YESNO|MB_ICONQUESTION "Remove all Unsloth data ($PROFILE\.unsloth)?$\n$\nThis deletes installed models, training outputs, and configuration." IDNO skip_cleanup
-    RMDir /r "$PROFILE\.unsloth"
-    DetailPrint "Removed $PROFILE\.unsloth"
-  skip_cleanup:
+  ; Desktop uninstall must not remove $PROFILE\.unsloth. The CLI/web
+  ; installers also use that tree for environments, models, outputs, and
+  ; configuration, and there has been no prior public desktop release whose
+  ; private state needs cleanup here.
+  DetailPrint "Preserved shared Unsloth data at $PROFILE\.unsloth"
 !macroend
diff --git a/studio/src-tauri/windows/installer.nsi b/studio/src-tauri/windows/installer.nsi
new file mode 100644
index 0000000000..7cc2f223c7
--- /dev/null
+++ b/studio/src-tauri/windows/installer.nsi
@@ -0,0 +1,994 @@
+; Unsloth Studio custom NSIS template.
+; Source: https://raw.githubusercontent.com/tauri-apps/tauri/tauri-cli-v2.10.1/crates/tauri-bundler/src/bundle/windows/nsis/installer.nsi
+; Source tags tauri-cli-v2.10.1 and tauri-bundler-v2.8.1 resolve to commit 9b17a7aeae9a83222ffe829aa4e2d8a5ba6bed8c.
+; Verified release CLI: @tauri-apps/cli 2.10.1 / tauri-cli 2.10.1
+; Verified bundler/template crate: tauri-bundler 2.8.1
+; Copied: 2026-04-30
+; Local patches:
+; - UNSLOTH_PATCH_START: non-WiX newer/unknown upgrades install in place.
+; - UNSLOTH_PATCH_START: guard non-WiX upgrade leave routing.
+
+Unicode true
+ManifestDPIAware true
+; Add in `dpiAwareness` `PerMonitorV2` to manifest for Windows 10 1607+ (note this should not affect lower versions since they should be able to ignore this and pick up `dpiAware` `true` set by `ManifestDPIAware true`)
+; Currently undocumented on NSIS's website but is in the Docs folder of source tree, see
+; https://github.com/kichik/nsis/blob/5fc0b87b819a9eec006df4967d08e522ddd651c9/Docs/src/attributes.but#L286-L300
+; https://github.com/tauri-apps/tauri/pull/10106
+ManifestDPIAwareness PerMonitorV2
+
+!if "{{compression}}" == "none"
+  SetCompress off
+!else
+  ; Set the compression algorithm. We default to LZMA.
+  SetCompressor /SOLID "{{compression}}"
+!endif
+
+!include MUI2.nsh
+!include FileFunc.nsh
+!include x64.nsh
+!include WordFunc.nsh
+!include "utils.nsh"
+!include "FileAssociation.nsh"
+!include "Win\COM.nsh"
+!include "Win\Propkey.nsh"
+!include "StrFunc.nsh"
+${StrCase}
+${StrLoc}
+
+{{#if installer_hooks}}
+!include "{{installer_hooks}}"
+{{/if}}
+
+!define WEBVIEW2APPGUID "{F3017226-FE2A-4295-8BDF-00C3A9A7E4C5}"
+
+!define MANUFACTURER "{{manufacturer}}"
+!define PRODUCTNAME "{{product_name}}"
+!define VERSION "{{version}}"
+!define VERSIONWITHBUILD "{{version_with_build}}"
+!define HOMEPAGE "{{homepage}}"
+!define INSTALLMODE "{{install_mode}}"
+!define LICENSE "{{license}}"
+!define INSTALLERICON "{{installer_icon}}"
+!define SIDEBARIMAGE "{{sidebar_image}}"
+!define HEADERIMAGE "{{header_image}}"
+!define MAINBINARYNAME "{{main_binary_name}}"
+!define MAINBINARYSRCPATH "{{main_binary_path}}"
+!define BUNDLEID "{{bundle_id}}"
+!define COPYRIGHT "{{copyright}}"
+!define OUTFILE "{{out_file}}"
+!define ARCH "{{arch}}"
+!define ADDITIONALPLUGINSPATH "{{additional_plugins_path}}"
+!define ALLOWDOWNGRADES "{{allow_downgrades}}"
+!define DISPLAYLANGUAGESELECTOR "{{display_language_selector}}"
+!define INSTALLWEBVIEW2MODE "{{install_webview2_mode}}"
+!define WEBVIEW2INSTALLERARGS "{{webview2_installer_args}}"
+!define WEBVIEW2BOOTSTRAPPERPATH "{{webview2_bootstrapper_path}}"
+!define WEBVIEW2INSTALLERPATH "{{webview2_installer_path}}"
+!define MINIMUMWEBVIEW2VERSION "{{minimum_webview2_version}}"
+!define UNINSTKEY "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}"
+!define MANUKEY "Software\${MANUFACTURER}"
+!define MANUPRODUCTKEY "${MANUKEY}\${PRODUCTNAME}"
+!define UNINSTALLERSIGNCOMMAND "{{uninstaller_sign_cmd}}"
+!define ESTIMATEDSIZE "{{estimated_size}}"
+!define STARTMENUFOLDER "{{start_menu_folder}}"
+
+Var PassiveMode
+Var UpdateMode
+Var NoShortcutMode
+Var WixMode
+Var OldMainBinaryName
+
+Name "${PRODUCTNAME}"
+BrandingText "${COPYRIGHT}"
+OutFile "${OUTFILE}"
+
+; We don't actually use this value as default install path,
+; it's just for nsis to append the product name folder in the directory selector
+; https://nsis.sourceforge.io/Reference/InstallDir
+!define PLACEHOLDER_INSTALL_DIR "placeholder\${PRODUCTNAME}"
+InstallDir "${PLACEHOLDER_INSTALL_DIR}"
+
+VIProductVersion "${VERSIONWITHBUILD}"
+VIAddVersionKey "ProductName" "${PRODUCTNAME}"
+VIAddVersionKey "FileDescription" "${PRODUCTNAME}"
+VIAddVersionKey "LegalCopyright" "${COPYRIGHT}"
+VIAddVersionKey "FileVersion" "${VERSION}"
+VIAddVersionKey "ProductVersion" "${VERSION}"
+
+# additional plugins
+!addplugindir "${ADDITIONALPLUGINSPATH}"
+
+; Uninstaller signing command
+!if "${UNINSTALLERSIGNCOMMAND}" != ""
+  !uninstfinalize '${UNINSTALLERSIGNCOMMAND}'
+!endif
+
+; Handle install mode, `perUser`, `perMachine` or `both`
+!if "${INSTALLMODE}" == "perMachine"
+  RequestExecutionLevel admin
+!endif
+
+!if "${INSTALLMODE}" == "currentUser"
+  RequestExecutionLevel user
+!endif
+
+!if "${INSTALLMODE}" == "both"
+  !define MULTIUSER_MUI
+  !define MULTIUSER_INSTALLMODE_INSTDIR "${PRODUCTNAME}"
+  !define MULTIUSER_INSTALLMODE_COMMANDLINE
+  !if "${ARCH}" == "x64"
+    !define MULTIUSER_USE_PROGRAMFILES64
+  !else if "${ARCH}" == "arm64"
+    !define MULTIUSER_USE_PROGRAMFILES64
+  !endif
+  !define MULTIUSER_INSTALLMODE_DEFAULT_REGISTRY_KEY "${UNINSTKEY}"
+  !define MULTIUSER_INSTALLMODE_DEFAULT_REGISTRY_VALUENAME "CurrentUser"
+  !define MULTIUSER_INSTALLMODEPAGE_SHOWUSERNAME
+  !define MULTIUSER_INSTALLMODE_FUNCTION RestorePreviousInstallLocation
+  !define MULTIUSER_EXECUTIONLEVEL Highest
+  !include MultiUser.nsh
+!endif
+
+; Installer icon
+!if "${INSTALLERICON}" != ""
+  !define MUI_ICON "${INSTALLERICON}"
+!endif
+
+; Installer sidebar image
+!if "${SIDEBARIMAGE}" != ""
+  !define MUI_WELCOMEFINISHPAGE_BITMAP "${SIDEBARIMAGE}"
+!endif
+
+; Installer header image
+!if "${HEADERIMAGE}" != ""
+  !define MUI_HEADERIMAGE
+  !define MUI_HEADERIMAGE_BITMAP  "${HEADERIMAGE}"
+!endif
+
+; Define registry key to store installer language
+!define MUI_LANGDLL_REGISTRY_ROOT "HKCU"
+!define MUI_LANGDLL_REGISTRY_KEY "${MANUPRODUCTKEY}"
+!define MUI_LANGDLL_REGISTRY_VALUENAME "Installer Language"
+
+; Installer pages, must be ordered as they appear
+; 1. Welcome Page
+!define MUI_PAGE_CUSTOMFUNCTION_PRE SkipIfPassive
+!insertmacro MUI_PAGE_WELCOME
+
+; 2. License Page (if defined)
+!if "${LICENSE}" != ""
+  !define MUI_PAGE_CUSTOMFUNCTION_PRE SkipIfPassive
+  !insertmacro MUI_PAGE_LICENSE "${LICENSE}"
+!endif
+
+; 3. Install mode (if it is set to `both`)
+!if "${INSTALLMODE}" == "both"
+  !define MUI_PAGE_CUSTOMFUNCTION_PRE SkipIfPassive
+  !insertmacro MULTIUSER_PAGE_INSTALLMODE
+!endif
+
+; 4. Custom page to ask user if he wants to reinstall/uninstall
+;    only if a previous installation was detected
+Var ReinstallPageCheck
+Page custom PageReinstall PageLeaveReinstall
+Function PageReinstall
+  ; Uninstall previous WiX installation if exists.
+  ;
+  ; A WiX installer stores the installation info in registry
+  ; using a UUID and so we have to loop through all keys under
+  ; `HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall`
+  ; and check if `DisplayName` and `Publisher` keys match ${PRODUCTNAME} and ${MANUFACTURER}
+  ;
+  ; This has a potential issue that there maybe another installation that matches
+  ; our ${PRODUCTNAME} and ${MANUFACTURER} but wasn't installed by our WiX installer,
+  ; however, this should be fine since the user will have to confirm the uninstallation
+  ; and they can chose to abort it if doesn't make sense.
+  StrCpy $0 0
+  wix_loop:
+    EnumRegKey $1 HKLM "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall" $0
+    StrCmp $1 "" wix_loop_done ; Exit loop if there is no more keys to loop on
+    IntOp $0 $0 + 1
+    ReadRegStr $R0 HKLM "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\$1" "DisplayName"
+    ReadRegStr $R1 HKLM "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\$1" "Publisher"
+    StrCmp "$R0$R1" "${PRODUCTNAME}${MANUFACTURER}" 0 wix_loop
+    ReadRegStr $R0 HKLM "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\$1" "UninstallString"
+    ${StrCase} $R1 $R0 "L"
+    ${StrLoc} $R0 $R1 "msiexec" ">"
+    StrCmp $R0 0 0 wix_loop_done
+    StrCpy $WixMode 1
+    StrCpy $R6 "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\$1"
+    Goto compare_version
+  wix_loop_done:
+
+  ; Check if there is an existing installation, if not, abort the reinstall page
+  ReadRegStr $R0 SHCTX "${UNINSTKEY}" ""
+  ReadRegStr $R1 SHCTX "${UNINSTKEY}" "UninstallString"
+  ${IfThen} "$R0$R1" == "" ${|} Abort ${|}
+
+  ; Compare this installar version with the existing installation
+  ; and modify the messages presented to the user accordingly
+  compare_version:
+  StrCpy $R4 "$(older)"
+  ${If} $WixMode = 1
+    ReadRegStr $R0 HKLM "$R6" "DisplayVersion"
+  ${Else}
+    ReadRegStr $R0 SHCTX "${UNINSTKEY}" "DisplayVersion"
+  ${EndIf}
+  ${IfThen} $R0 == "" ${|} StrCpy $R4 "$(unknown)" ${|}
+
+  nsis_tauri_utils::SemverCompare "${VERSION}" $R0
+  Pop $R0
+
+  ; UNSLOTH_PATCH_START: non-WiX newer/unknown upgrades install in place.
+  ; Do not invoke stale internal NSIS uninstallers during normal desktop
+  ; upgrades; continue to Section Install so Tauri handles the running app.
+  ${If} $WixMode <> 1
+    ${If} $UpdateMode = 1
+      Abort
+    ${ElseIf} $R0 = 1
+      Abort
+    ${ElseIf} $R0 <> 0
+      ${If} $R0 <> -1
+        StrCpy $R0 1
+        Abort
+      ${EndIf}
+    ${EndIf}
+  ${EndIf}
+  ; UNSLOTH_PATCH_END
+
+  ; Reinstalling the same version
+  ${If} $R0 = 0
+    StrCpy $R1 "$(alreadyInstalledLong)"
+    StrCpy $R2 "$(addOrReinstall)"
+    StrCpy $R3 "$(uninstallApp)"
+    !insertmacro MUI_HEADER_TEXT "$(alreadyInstalled)" "$(chooseMaintenanceOption)"
+  ; Upgrading
+  ${ElseIf} $R0 = 1
+    StrCpy $R1 "$(olderOrUnknownVersionInstalled)"
+    StrCpy $R2 "$(uninstallBeforeInstalling)"
+    StrCpy $R3 "$(dontUninstall)"
+    !insertmacro MUI_HEADER_TEXT "$(alreadyInstalled)" "$(choowHowToInstall)"
+  ; Downgrading
+  ${ElseIf} $R0 = -1
+    StrCpy $R1 "$(newerVersionInstalled)"
+    StrCpy $R2 "$(uninstallBeforeInstalling)"
+    !if "${ALLOWDOWNGRADES}" == "true"
+      StrCpy $R3 "$(dontUninstall)"
+    !else
+      StrCpy $R3 "$(dontUninstallDowngrade)"
+    !endif
+    !insertmacro MUI_HEADER_TEXT "$(alreadyInstalled)" "$(choowHowToInstall)"
+  ${Else}
+    Abort
+  ${EndIf}
+
+  ; Skip showing the page if passive
+  ;
+  ; Note that we don't call this earlier at the begining
+  ; of this function because we need to populate some variables
+  ; related to current installed version if detected and whether
+  ; we are downgrading or not.
+  ${If} $PassiveMode = 1
+    Call PageLeaveReinstall
+  ${Else}
+    nsDialogs::Create 1018
+    Pop $R4
+    ${IfThen} $(^RTL) = 1 ${|} nsDialogs::SetRTL $(^RTL) ${|}
+
+    ${NSD_CreateLabel} 0 0 100% 24u $R1
+    Pop $R1
+
+    ${NSD_CreateRadioButton} 30u 50u -30u 8u $R2
+    Pop $R2
+    ${NSD_OnClick} $R2 PageReinstallUpdateSelection
+
+    ${NSD_CreateRadioButton} 30u 70u -30u 8u $R3
+    Pop $R3
+    ; Disable this radio button if downgrading and downgrades are disabled
+    !if "${ALLOWDOWNGRADES}" == "false"
+      ${IfThen} $R0 = -1 ${|} EnableWindow $R3 0 ${|}
+    !endif
+    ${NSD_OnClick} $R3 PageReinstallUpdateSelection
+
+    ; Check the first radio button if this the first time
+    ; we enter this page or if the second button wasn't
+    ; selected the last time we were on this page
+    ${If} $ReinstallPageCheck <> 2
+      SendMessage $R2 ${BM_SETCHECK} ${BST_CHECKED} 0
+    ${Else}
+      SendMessage $R3 ${BM_SETCHECK} ${BST_CHECKED} 0
+    ${EndIf}
+
+    ${NSD_SetFocus} $R2
+    nsDialogs::Show
+  ${EndIf}
+FunctionEnd
+Function PageReinstallUpdateSelection
+  ${NSD_GetState} $R2 $R1
+  ${If} $R1 == ${BST_CHECKED}
+    StrCpy $ReinstallPageCheck 1
+  ${Else}
+    StrCpy $ReinstallPageCheck 2
+  ${EndIf}
+FunctionEnd
+Function PageLeaveReinstall
+  ${NSD_GetState} $R2 $R1
+
+  ; If migrating from Wix, always uninstall
+  ${If} $WixMode = 1
+    Goto reinst_uninstall
+  ${EndIf}
+
+  ; In update mode, always proceeds without uninstalling
+  ${If} $UpdateMode = 1
+    Goto reinst_done
+  ${EndIf}
+
+  ; UNSLOTH_PATCH_START: guard non-WiX upgrade leave routing.
+  ; Passive/default upgrade choices must not ExecWait the old UninstallString.
+  ${If} $WixMode <> 1
+    ${If} $R0 = 1
+      Goto reinst_done
+    ${ElseIf} $R0 <> 0
+      ${If} $R0 <> -1
+        Goto reinst_done
+      ${EndIf}
+    ${EndIf}
+  ${EndIf}
+  ; UNSLOTH_PATCH_END
+
+  ; $R0 holds whether same(0)/upgrading(1)/downgrading(-1) version
+  ; $R1 holds the radio buttons state:
+  ;   1 => first choice was selected
+  ;   0 => second choice was selected
+  ${If} $R0 = 0 ; Same version, proceed
+    ${If} $R1 = 1              ; User chose to add/reinstall
+      Goto reinst_done
+    ${Else}                    ; User chose to uninstall
+      Goto reinst_uninstall
+    ${EndIf}
+  ${ElseIf} $R0 = 1 ; Upgrading
+    ${If} $R1 = 1              ; User chose to uninstall
+      Goto reinst_uninstall
+    ${Else}
+      Goto reinst_done         ; User chose NOT to uninstall
+    ${EndIf}
+  ${ElseIf} $R0 = -1 ; Downgrading
+    ${If} $R1 = 1              ; User chose to uninstall
+      Goto reinst_uninstall
+    ${Else}
+      Goto reinst_done         ; User chose NOT to uninstall
+    ${EndIf}
+  ${EndIf}
+
+  reinst_uninstall:
+    HideWindow
+    ClearErrors
+
+    ${If} $WixMode = 1
+      ReadRegStr $R1 HKLM "$R6" "UninstallString"
+      ExecWait '$R1' $0
+    ${Else}
+      ReadRegStr $4 SHCTX "${MANUPRODUCTKEY}" ""
+      ReadRegStr $R1 SHCTX "${UNINSTKEY}" "UninstallString"
+      ${IfThen} $UpdateMode = 1 ${|} StrCpy $R1 "$R1 /UPDATE" ${|} ; append /UPDATE
+      ${IfThen} $PassiveMode = 1 ${|} StrCpy $R1 "$R1 /P" ${|} ; append /P
+      StrCpy $R1 "$R1 _?=$4" ; append uninstall directory
+      ExecWait '$R1' $0
+    ${EndIf}
+
+    BringToFront
+
+    ${IfThen} ${Errors} ${|} StrCpy $0 2 ${|} ; ExecWait failed, set fake exit code
+
+    ${If} $0 <> 0
+    ${OrIf} ${FileExists} "$INSTDIR\${MAINBINARYNAME}.exe"
+      ; User cancelled wix uninstaller? return to select un/reinstall page
+      ${If} $WixMode = 1
+      ${AndIf} $0 = 1602
+        Abort
+      ${EndIf}
+
+      ; User cancelled NSIS uninstaller? return to select un/reinstall page
+      ${If} $0 = 1
+        Abort
+      ${EndIf}
+
+      ; Other erros? show generic error message and return to select un/reinstall page
+      MessageBox MB_ICONEXCLAMATION "$(unableToUninstall)"
+      Abort
+    ${EndIf}
+  reinst_done:
+FunctionEnd
+
+; 5. Choose install directory page
+!define MUI_PAGE_CUSTOMFUNCTION_PRE SkipIfPassive
+!insertmacro MUI_PAGE_DIRECTORY
+
+; 6. Start menu shortcut page
+Var AppStartMenuFolder
+!if "${STARTMENUFOLDER}" != ""
+  !define MUI_PAGE_CUSTOMFUNCTION_PRE SkipIfPassive
+  !define MUI_STARTMENUPAGE_DEFAULTFOLDER "${STARTMENUFOLDER}"
+!else
+  !define MUI_PAGE_CUSTOMFUNCTION_PRE Skip
+!endif
+!insertmacro MUI_PAGE_STARTMENU Application $AppStartMenuFolder
+
+; 7. Installation page
+!insertmacro MUI_PAGE_INSTFILES
+
+; 8. Finish page
+;
+; Don't auto jump to finish page after installation page,
+; because the installation page has useful info that can be used debug any issues with the installer.
+!define MUI_FINISHPAGE_NOAUTOCLOSE
+; Use show readme button in the finish page as a button create a desktop shortcut
+!define MUI_FINISHPAGE_SHOWREADME
+!define MUI_FINISHPAGE_SHOWREADME_TEXT "$(createDesktop)"
+!define MUI_FINISHPAGE_SHOWREADME_FUNCTION CreateOrUpdateDesktopShortcut
+; Show run app after installation.
+!define MUI_FINISHPAGE_RUN
+!define MUI_FINISHPAGE_RUN_FUNCTION RunMainBinary
+!define MUI_PAGE_CUSTOMFUNCTION_PRE SkipIfPassive
+!insertmacro MUI_PAGE_FINISH
+
+Function RunMainBinary
+  nsis_tauri_utils::RunAsUser "$INSTDIR\${MAINBINARYNAME}.exe" ""
+FunctionEnd
+
+; Uninstaller Pages
+; 1. Confirm uninstall page
+Var DeleteAppDataCheckbox
+Var DeleteAppDataCheckboxState
+!define /ifndef WS_EX_LAYOUTRTL         0x00400000
+!define MUI_PAGE_CUSTOMFUNCTION_SHOW un.ConfirmShow
+Function un.ConfirmShow ; Add add a `Delete app data` check box
+  ; $1 inner dialog HWND
+  ; $2 window DPI
+  ; $3 style
+  ; $4 x
+  ; $5 y
+  ; $6 width
+  ; $7 height
+  FindWindow $1 "#32770" "" $HWNDPARENT ; Find inner dialog
+  System::Call "user32::GetDpiForWindow(p r1) i .r2"
+  ${If} $(^RTL) = 1
+    StrCpy $3 "${__NSD_CheckBox_EXSTYLE} | ${WS_EX_LAYOUTRTL}"
+    IntOp $4 50 * $2
+  ${Else}
+    StrCpy $3 "${__NSD_CheckBox_EXSTYLE}"
+    IntOp $4 0 * $2
+  ${EndIf}
+  IntOp $5 100 * $2
+  IntOp $6 400 * $2
+  IntOp $7 25 * $2
+  IntOp $4 $4 / 96
+  IntOp $5 $5 / 96
+  IntOp $6 $6 / 96
+  IntOp $7 $7 / 96
+  System::Call 'user32::CreateWindowEx(i r3, w "${__NSD_CheckBox_CLASS}", w "$(deleteAppData)", i ${__NSD_CheckBox_STYLE}, i r4, i r5, i r6, i r7, p r1, i0, i0, i0) i .s'
+  Pop $DeleteAppDataCheckbox
+  SendMessage $HWNDPARENT ${WM_GETFONT} 0 0 $1
+  SendMessage $DeleteAppDataCheckbox ${WM_SETFONT} $1 1
+FunctionEnd
+!define MUI_PAGE_CUSTOMFUNCTION_LEAVE un.ConfirmLeave
+Function un.ConfirmLeave
+  SendMessage $DeleteAppDataCheckbox ${BM_GETCHECK} 0 0 $DeleteAppDataCheckboxState
+FunctionEnd
+!define MUI_PAGE_CUSTOMFUNCTION_PRE un.SkipIfPassive
+!insertmacro MUI_UNPAGE_CONFIRM
+
+; 2. Uninstalling Page
+!insertmacro MUI_UNPAGE_INSTFILES
+
+;Languages
+{{#each languages}}
+!insertmacro MUI_LANGUAGE "{{this}}"
+{{/each}}
+!insertmacro MUI_RESERVEFILE_LANGDLL
+{{#each language_files}}
+  !include "{{this}}"
+{{/each}}
+
+Function .onInit
+  ${GetOptions} $CMDLINE "/P" $PassiveMode
+  ${IfNot} ${Errors}
+    StrCpy $PassiveMode 1
+  ${EndIf}
+
+  ${GetOptions} $CMDLINE "/NS" $NoShortcutMode
+  ${IfNot} ${Errors}
+    StrCpy $NoShortcutMode 1
+  ${EndIf}
+
+  ${GetOptions} $CMDLINE "/UPDATE" $UpdateMode
+  ${IfNot} ${Errors}
+    StrCpy $UpdateMode 1
+  ${EndIf}
+
+  !if "${DISPLAYLANGUAGESELECTOR}" == "true"
+    !insertmacro MUI_LANGDLL_DISPLAY
+  !endif
+
+  !insertmacro SetContext
+
+  ${If} $INSTDIR == "${PLACEHOLDER_INSTALL_DIR}"
+    ; Set default install location
+    !if "${INSTALLMODE}" == "perMachine"
+      ${If} ${RunningX64}
+        !if "${ARCH}" == "x64"
+          StrCpy $INSTDIR "$PROGRAMFILES64\${PRODUCTNAME}"
+        !else if "${ARCH}" == "arm64"
+          StrCpy $INSTDIR "$PROGRAMFILES64\${PRODUCTNAME}"
+        !else
+          StrCpy $INSTDIR "$PROGRAMFILES\${PRODUCTNAME}"
+        !endif
+      ${Else}
+        StrCpy $INSTDIR "$PROGRAMFILES\${PRODUCTNAME}"
+      ${EndIf}
+    !else if "${INSTALLMODE}" == "currentUser"
+      StrCpy $INSTDIR "$LOCALAPPDATA\${PRODUCTNAME}"
+    !endif
+
+    Call RestorePreviousInstallLocation
+  ${EndIf}
+
+
+  !if "${INSTALLMODE}" == "both"
+    !insertmacro MULTIUSER_INIT
+  !endif
+FunctionEnd
+
+
+Section EarlyChecks
+  ; Abort silent installer if downgrades is disabled
+  !if "${ALLOWDOWNGRADES}" == "false"
+  ${If} ${Silent}
+    ; If downgrading
+    ${If} $R0 = -1
+      System::Call 'kernel32::AttachConsole(i -1)i.r0'
+      ${If} $0 <> 0
+        System::Call 'kernel32::GetStdHandle(i -11)i.r0'
+        System::call 'kernel32::SetConsoleTextAttribute(i r0, i 0x0004)' ; set red color
+        FileWrite $0 "$(silentDowngrades)"
+      ${EndIf}
+      Abort
+    ${EndIf}
+  ${EndIf}
+  !endif
+
+SectionEnd
+
+Section WebView2
+  ; Check if Webview2 is already installed and skip this section
+  ${If} ${RunningX64}
+    ReadRegStr $4 HKLM "SOFTWARE\WOW6432Node\Microsoft\EdgeUpdate\Clients\${WEBVIEW2APPGUID}" "pv"
+  ${Else}
+    ReadRegStr $4 HKLM "SOFTWARE\Microsoft\EdgeUpdate\Clients\${WEBVIEW2APPGUID}" "pv"
+  ${EndIf}
+  ${If} $4 == ""
+    ReadRegStr $4 HKCU "SOFTWARE\Microsoft\EdgeUpdate\Clients\${WEBVIEW2APPGUID}" "pv"
+  ${EndIf}
+
+  ${If} $4 == ""
+    ; Webview2 installation
+    ;
+    ; Skip if updating
+    ${If} $UpdateMode <> 1
+      !if "${INSTALLWEBVIEW2MODE}" == "downloadBootstrapper"
+        Delete "$TEMP\MicrosoftEdgeWebview2Setup.exe"
+        DetailPrint "$(webview2Downloading)"
+        NSISdl::download "https://go.microsoft.com/fwlink/p/?LinkId=2124703" "$TEMP\MicrosoftEdgeWebview2Setup.exe"
+        Pop $0
+        ${If} $0 == "success"
+          DetailPrint "$(webview2DownloadSuccess)"
+        ${Else}
+          DetailPrint "$(webview2DownloadError)"
+          Abort "$(webview2AbortError)"
+        ${EndIf}
+        StrCpy $6 "$TEMP\MicrosoftEdgeWebview2Setup.exe"
+        Goto install_webview2
+      !endif
+
+      !if "${INSTALLWEBVIEW2MODE}" == "embedBootstrapper"
+        Delete "$TEMP\MicrosoftEdgeWebview2Setup.exe"
+        File "/oname=$TEMP\MicrosoftEdgeWebview2Setup.exe" "${WEBVIEW2BOOTSTRAPPERPATH}"
+        DetailPrint "$(installingWebview2)"
+        StrCpy $6 "$TEMP\MicrosoftEdgeWebview2Setup.exe"
+        Goto install_webview2
+      !endif
+
+      !if "${INSTALLWEBVIEW2MODE}" == "offlineInstaller"
+        Delete "$TEMP\MicrosoftEdgeWebView2RuntimeInstaller.exe"
+        File "/oname=$TEMP\MicrosoftEdgeWebView2RuntimeInstaller.exe" "${WEBVIEW2INSTALLERPATH}"
+        DetailPrint "$(installingWebview2)"
+        StrCpy $6 "$TEMP\MicrosoftEdgeWebView2RuntimeInstaller.exe"
+        Goto install_webview2
+      !endif
+
+      Goto webview2_done
+
+      install_webview2:
+        DetailPrint "$(installingWebview2)"
+        ; $6 holds the path to the webview2 installer
+        ExecWait "$6 ${WEBVIEW2INSTALLERARGS} /install" $1
+        ${If} $1 = 0
+          DetailPrint "$(webview2InstallSuccess)"
+        ${Else}
+          DetailPrint "$(webview2InstallError)"
+          Abort "$(webview2AbortError)"
+        ${EndIf}
+      webview2_done:
+    ${EndIf}
+  ${Else}
+    !if "${MINIMUMWEBVIEW2VERSION}" != ""
+      ${VersionCompare} "${MINIMUMWEBVIEW2VERSION}" "$4" $R0
+      ${If} $R0 = 1
+        update_webview:
+          DetailPrint "$(installingWebview2)"
+          ${If} ${RunningX64}
+            ReadRegStr $R1 HKLM "SOFTWARE\WOW6432Node\Microsoft\EdgeUpdate" "path"
+          ${Else}
+            ReadRegStr $R1 HKLM "SOFTWARE\Microsoft\EdgeUpdate" "path"
+          ${EndIf}
+          ${If} $R1 == ""
+            ReadRegStr $R1 HKCU "SOFTWARE\Microsoft\EdgeUpdate" "path"
+          ${EndIf}
+          ${If} $R1 != ""
+            ; Chromium updater docs: https://source.chromium.org/chromium/chromium/src/+/main:docs/updater/user_manual.md
+            ; Modified from "HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\Microsoft EdgeWebView\ModifyPath"
+            ExecWait `"$R1" /install appguid=${WEBVIEW2APPGUID}&needsadmin=true` $1
+            ${If} $1 = 0
+              DetailPrint "$(webview2InstallSuccess)"
+            ${Else}
+              MessageBox MB_ICONEXCLAMATION|MB_ABORTRETRYIGNORE "$(webview2InstallError)" IDIGNORE ignore IDRETRY update_webview
+              Quit
+              ignore:
+            ${EndIf}
+          ${EndIf}
+      ${EndIf}
+    !endif
+  ${EndIf}
+SectionEnd
+
+Section Install
+  SetOutPath $INSTDIR
+
+  !ifmacrodef NSIS_HOOK_PREINSTALL
+    !insertmacro NSIS_HOOK_PREINSTALL
+  !endif
+
+  !insertmacro CheckIfAppIsRunning "${MAINBINARYNAME}.exe" "${PRODUCTNAME}"
+
+  ; Copy main executable
+  File "${MAINBINARYSRCPATH}"
+
+  ; Copy resources
+  {{#each resources_dirs}}
+    CreateDirectory "$INSTDIR\\{{this}}"
+  {{/each}}
+  {{#each resources}}
+    File /a "/oname={{this.[1]}}" "{{no-escape @key}}"
+  {{/each}}
+
+  ; Copy external binaries
+  {{#each binaries}}
+    File /a "/oname={{this}}" "{{no-escape @key}}"
+  {{/each}}
+
+  ; Create file associations
+  {{#each file_associations as |association| ~}}
+    {{#each association.ext as |ext| ~}}
+       !insertmacro APP_ASSOCIATE "{{ext}}" "{{or association.name ext}}" "{{association-description association.description ext}}" "$INSTDIR\${MAINBINARYNAME}.exe,0" "Open with ${PRODUCTNAME}" "$INSTDIR\${MAINBINARYNAME}.exe $\"%1$\""
+    {{/each}}
+  {{/each}}
+
+  ; Register deep links
+  {{#each deep_link_protocols as |protocol| ~}}
+    WriteRegStr SHCTX "Software\Classes\\{{protocol}}" "URL Protocol" ""
+    WriteRegStr SHCTX "Software\Classes\\{{protocol}}" "" "URL:${BUNDLEID} protocol"
+    WriteRegStr SHCTX "Software\Classes\\{{protocol}}\DefaultIcon" "" "$\"$INSTDIR\${MAINBINARYNAME}.exe$\",0"
+    WriteRegStr SHCTX "Software\Classes\\{{protocol}}\shell\open\command" "" "$\"$INSTDIR\${MAINBINARYNAME}.exe$\" $\"%1$\""
+  {{/each}}
+
+  ; Create uninstaller
+  WriteUninstaller "$INSTDIR\uninstall.exe"
+
+  ; Save $INSTDIR in registry for future installations
+  WriteRegStr SHCTX "${MANUPRODUCTKEY}" "" $INSTDIR
+
+  !if "${INSTALLMODE}" == "both"
+    ; Save install mode to be selected by default for the next installation such as updating
+    ; or when uninstalling
+    WriteRegStr SHCTX "${UNINSTKEY}" $MultiUser.InstallMode 1
+  !endif
+
+  ; Remove old main binary if it doesn't match new main binary name
+  ReadRegStr $OldMainBinaryName SHCTX "${UNINSTKEY}" "MainBinaryName"
+  ${If} $OldMainBinaryName != ""
+  ${AndIf} $OldMainBinaryName != "${MAINBINARYNAME}.exe"
+    Delete "$INSTDIR\$OldMainBinaryName"
+  ${EndIf}
+
+  ; Save current MAINBINARYNAME for future updates
+  WriteRegStr SHCTX "${UNINSTKEY}" "MainBinaryName" "${MAINBINARYNAME}.exe"
+
+  ; Registry information for add/remove programs
+  WriteRegStr SHCTX "${UNINSTKEY}" "DisplayName" "${PRODUCTNAME}"
+  WriteRegStr SHCTX "${UNINSTKEY}" "DisplayIcon" "$\"$INSTDIR\${MAINBINARYNAME}.exe$\""
+  WriteRegStr SHCTX "${UNINSTKEY}" "DisplayVersion" "${VERSION}"
+  WriteRegStr SHCTX "${UNINSTKEY}" "Publisher" "${MANUFACTURER}"
+  WriteRegStr SHCTX "${UNINSTKEY}" "InstallLocation" "$\"$INSTDIR$\""
+  WriteRegStr SHCTX "${UNINSTKEY}" "UninstallString" "$\"$INSTDIR\uninstall.exe$\""
+  WriteRegDWORD SHCTX "${UNINSTKEY}" "NoModify" "1"
+  WriteRegDWORD SHCTX "${UNINSTKEY}" "NoRepair" "1"
+
+  ${GetSize} "$INSTDIR" "/M=uninstall.exe /S=0K /G=0" $0 $1 $2
+  IntOp $0 $0 + ${ESTIMATEDSIZE}
+  IntFmt $0 "0x%08X" $0
+  WriteRegDWORD SHCTX "${UNINSTKEY}" "EstimatedSize" "$0"
+
+  !if "${HOMEPAGE}" != ""
+    WriteRegStr SHCTX "${UNINSTKEY}" "URLInfoAbout" "${HOMEPAGE}"
+    WriteRegStr SHCTX "${UNINSTKEY}" "URLUpdateInfo" "${HOMEPAGE}"
+    WriteRegStr SHCTX "${UNINSTKEY}" "HelpLink" "${HOMEPAGE}"
+  !endif
+
+  ; Create start menu shortcut
+  !insertmacro MUI_STARTMENU_WRITE_BEGIN Application
+    Call CreateOrUpdateStartMenuShortcut
+  !insertmacro MUI_STARTMENU_WRITE_END
+
+  ; Create desktop shortcut for silent and passive installers
+  ; because finish page will be skipped
+  ${If} $PassiveMode = 1
+  ${OrIf} ${Silent}
+    Call CreateOrUpdateDesktopShortcut
+  ${EndIf}
+
+  !ifmacrodef NSIS_HOOK_POSTINSTALL
+    !insertmacro NSIS_HOOK_POSTINSTALL
+  !endif
+
+  ; Auto close this page for passive mode
+  ${If} $PassiveMode = 1
+    SetAutoClose true
+  ${EndIf}
+SectionEnd
+
+Function .onInstSuccess
+  ; Check for `/R` flag only in silent and passive installers because
+  ; GUI installer has a toggle for the user to (re)start the app
+  ${If} $PassiveMode = 1
+  ${OrIf} ${Silent}
+    ${GetOptions} $CMDLINE "/R" $R0
+    ${IfNot} ${Errors}
+      ${GetOptions} $CMDLINE "/ARGS" $R0
+      nsis_tauri_utils::RunAsUser "$INSTDIR\${MAINBINARYNAME}.exe" "$R0"
+    ${EndIf}
+  ${EndIf}
+FunctionEnd
+
+Function un.onInit
+  !insertmacro SetContext
+
+  !if "${INSTALLMODE}" == "both"
+    !insertmacro MULTIUSER_UNINIT
+  !endif
+
+  !insertmacro MUI_UNGETLANGUAGE
+
+  ${GetOptions} $CMDLINE "/P" $PassiveMode
+  ${IfNot} ${Errors}
+    StrCpy $PassiveMode 1
+  ${EndIf}
+
+  ${GetOptions} $CMDLINE "/UPDATE" $UpdateMode
+  ${IfNot} ${Errors}
+    StrCpy $UpdateMode 1
+  ${EndIf}
+FunctionEnd
+
+Section Uninstall
+
+  !ifmacrodef NSIS_HOOK_PREUNINSTALL
+    !insertmacro NSIS_HOOK_PREUNINSTALL
+  !endif
+
+  !insertmacro CheckIfAppIsRunning "${MAINBINARYNAME}.exe" "${PRODUCTNAME}"
+
+  ; Delete the app directory and its content from disk
+  ; Copy main executable
+  Delete "$INSTDIR\${MAINBINARYNAME}.exe"
+
+  ; Delete resources
+  {{#each resources}}
+    Delete "$INSTDIR\\{{this.[1]}}"
+  {{/each}}
+
+  ; Delete external binaries
+  {{#each binaries}}
+    Delete "$INSTDIR\\{{this}}"
+  {{/each}}
+
+  ; Delete app associations
+  {{#each file_associations as |association| ~}}
+    {{#each association.ext as |ext| ~}}
+      !insertmacro APP_UNASSOCIATE "{{ext}}" "{{or association.name ext}}"
+    {{/each}}
+  {{/each}}
+
+  ; Delete deep links
+  {{#each deep_link_protocols as |protocol| ~}}
+    ReadRegStr $R7 SHCTX "Software\Classes\\{{protocol}}\shell\open\command" ""
+    ${If} $R7 == "$\"$INSTDIR\${MAINBINARYNAME}.exe$\" $\"%1$\""
+      DeleteRegKey SHCTX "Software\Classes\\{{protocol}}"
+    ${EndIf}
+  {{/each}}
+
+
+  ; Delete uninstaller
+  Delete "$INSTDIR\uninstall.exe"
+
+  {{#each resources_ancestors}}
+  RMDir /REBOOTOK "$INSTDIR\\{{this}}"
+  {{/each}}
+  RMDir "$INSTDIR"
+
+  ; Remove shortcuts if not updating
+  ${If} $UpdateMode <> 1
+    !insertmacro DeleteAppUserModelId
+
+    ; Remove start menu shortcut
+    !insertmacro MUI_STARTMENU_GETFOLDER Application $AppStartMenuFolder
+    !insertmacro IsShortcutTarget "$SMPROGRAMS\$AppStartMenuFolder\${PRODUCTNAME}.lnk" "$INSTDIR\${MAINBINARYNAME}.exe"
+    Pop $0
+    ${If} $0 = 1
+      !insertmacro UnpinShortcut "$SMPROGRAMS\$AppStartMenuFolder\${PRODUCTNAME}.lnk"
+      Delete "$SMPROGRAMS\$AppStartMenuFolder\${PRODUCTNAME}.lnk"
+      RMDir "$SMPROGRAMS\$AppStartMenuFolder"
+    ${EndIf}
+    !insertmacro IsShortcutTarget "$SMPROGRAMS\${PRODUCTNAME}.lnk" "$INSTDIR\${MAINBINARYNAME}.exe"
+    Pop $0
+    ${If} $0 = 1
+      !insertmacro UnpinShortcut "$SMPROGRAMS\${PRODUCTNAME}.lnk"
+      Delete "$SMPROGRAMS\${PRODUCTNAME}.lnk"
+    ${EndIf}
+
+    ; Remove desktop shortcuts
+    !insertmacro IsShortcutTarget "$DESKTOP\${PRODUCTNAME}.lnk" "$INSTDIR\${MAINBINARYNAME}.exe"
+    Pop $0
+    ${If} $0 = 1
+      !insertmacro UnpinShortcut "$DESKTOP\${PRODUCTNAME}.lnk"
+      Delete "$DESKTOP\${PRODUCTNAME}.lnk"
+    ${EndIf}
+  ${EndIf}
+
+  ; Remove registry information for add/remove programs
+  !if "${INSTALLMODE}" == "both"
+    DeleteRegKey SHCTX "${UNINSTKEY}"
+  !else if "${INSTALLMODE}" == "perMachine"
+    DeleteRegKey HKLM "${UNINSTKEY}"
+  !else
+    DeleteRegKey HKCU "${UNINSTKEY}"
+  !endif
+
+  ; Removes the Autostart entry for ${PRODUCTNAME} from the HKCU Run key if it exists.
+  ; This ensures the program does not launch automatically after uninstallation if it exists.
+  ; If it doesn't exist, it does nothing.
+  ; We do this when not updating (to preserve the registry value on updates)
+  ${If} $UpdateMode <> 1
+    DeleteRegValue HKCU "Software\Microsoft\Windows\CurrentVersion\Run" "${PRODUCTNAME}"
+  ${EndIf}
+
+  ; Delete app data if the checkbox is selected
+  ; and if not updating
+  ${If} $DeleteAppDataCheckboxState = 1
+  ${AndIf} $UpdateMode <> 1
+    ; Clear the install location $INSTDIR from registry
+    DeleteRegKey SHCTX "${MANUPRODUCTKEY}"
+    DeleteRegKey /ifempty SHCTX "${MANUKEY}"
+
+    ; Clear the install language from registry
+    DeleteRegValue HKCU "${MANUPRODUCTKEY}" "Installer Language"
+    DeleteRegKey /ifempty HKCU "${MANUPRODUCTKEY}"
+    DeleteRegKey /ifempty HKCU "${MANUKEY}"
+
+    SetShellVarContext current
+    RmDir /r "$APPDATA\${BUNDLEID}"
+    RmDir /r "$LOCALAPPDATA\${BUNDLEID}"
+  ${EndIf}
+
+  !ifmacrodef NSIS_HOOK_POSTUNINSTALL
+    !insertmacro NSIS_HOOK_POSTUNINSTALL
+  !endif
+
+  ; Auto close if passive mode or updating
+  ${If} $PassiveMode = 1
+  ${OrIf} $UpdateMode = 1
+    SetAutoClose true
+  ${EndIf}
+SectionEnd
+
+Function RestorePreviousInstallLocation
+  ReadRegStr $4 SHCTX "${MANUPRODUCTKEY}" ""
+  StrCmp $4 "" +2 0
+    StrCpy $INSTDIR $4
+FunctionEnd
+
+Function Skip
+  Abort
+FunctionEnd
+
+Function SkipIfPassive
+  ${IfThen} $PassiveMode = 1  ${|} Abort ${|}
+FunctionEnd
+Function un.SkipIfPassive
+  ${IfThen} $PassiveMode = 1  ${|} Abort ${|}
+FunctionEnd
+
+Function CreateOrUpdateStartMenuShortcut
+  ; We used to use product name as MAINBINARYNAME
+  ; migrate old shortcuts to target the new MAINBINARYNAME
+  StrCpy $R0 0
+
+  !insertmacro IsShortcutTarget "$SMPROGRAMS\$AppStartMenuFolder\${PRODUCTNAME}.lnk" "$INSTDIR\$OldMainBinaryName"
+  Pop $0
+  ${If} $0 = 1
+    !insertmacro SetShortcutTarget "$SMPROGRAMS\$AppStartMenuFolder\${PRODUCTNAME}.lnk" "$INSTDIR\${MAINBINARYNAME}.exe"
+    StrCpy $R0 1
+  ${EndIf}
+
+  !insertmacro IsShortcutTarget "$SMPROGRAMS\${PRODUCTNAME}.lnk" "$INSTDIR\$OldMainBinaryName"
+  Pop $0
+  ${If} $0 = 1
+    !insertmacro SetShortcutTarget "$SMPROGRAMS\${PRODUCTNAME}.lnk" "$INSTDIR\${MAINBINARYNAME}.exe"
+    StrCpy $R0 1
+  ${EndIf}
+
+  ${If} $R0 = 1
+    Return
+  ${EndIf}
+
+  ; Skip creating shortcut if in update mode or no shortcut mode
+  ; but always create if migrating from wix
+  ${If} $WixMode = 0
+    ${If} $UpdateMode = 1
+    ${OrIf} $NoShortcutMode = 1
+      Return
+    ${EndIf}
+  ${EndIf}
+
+  !if "${STARTMENUFOLDER}" != ""
+    CreateDirectory "$SMPROGRAMS\$AppStartMenuFolder"
+    CreateShortcut "$SMPROGRAMS\$AppStartMenuFolder\${PRODUCTNAME}.lnk" "$INSTDIR\${MAINBINARYNAME}.exe"
+    !insertmacro SetLnkAppUserModelId "$SMPROGRAMS\$AppStartMenuFolder\${PRODUCTNAME}.lnk"
+  !else
+    CreateShortcut "$SMPROGRAMS\${PRODUCTNAME}.lnk" "$INSTDIR\${MAINBINARYNAME}.exe"
+    !insertmacro SetLnkAppUserModelId "$SMPROGRAMS\${PRODUCTNAME}.lnk"
+  !endif
+FunctionEnd
+
+Function CreateOrUpdateDesktopShortcut
+  ; We used to use product name as MAINBINARYNAME
+  ; migrate old shortcuts to target the new MAINBINARYNAME
+  !insertmacro IsShortcutTarget "$DESKTOP\${PRODUCTNAME}.lnk" "$INSTDIR\$OldMainBinaryName"
+  Pop $0
+  ${If} $0 = 1
+    !insertmacro SetShortcutTarget "$DESKTOP\${PRODUCTNAME}.lnk" "$INSTDIR\${MAINBINARYNAME}.exe"
+    Return
+  ${EndIf}
+
+  ; Skip creating shortcut if in update mode or no shortcut mode
+  ; but always create if migrating from wix
+  ${If} $WixMode = 0
+    ${If} $UpdateMode = 1
+    ${OrIf} $NoShortcutMode = 1
+      Return
+    ${EndIf}
+  ${EndIf}
+
+  CreateShortcut "$DESKTOP\${PRODUCTNAME}.lnk" "$INSTDIR\${MAINBINARYNAME}.exe"
+  !insertmacro SetLnkAppUserModelId "$DESKTOP\${PRODUCTNAME}.lnk"
+FunctionEnd
diff --git a/tests/python/test_dpo_vision_processor_passthrough.py b/tests/python/test_dpo_vision_processor_passthrough.py
new file mode 100644
index 0000000000..a4f2e2e12a
--- /dev/null
+++ b/tests/python/test_dpo_vision_processor_passthrough.py
@@ -0,0 +1,149 @@
+"""Verify dpo_trainer_vision_process_row forwards prompt and images verbatim."""
+
+import ast
+import os
+
+import numpy as np
+
+
+REPO_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+RL_PATH = os.path.join(REPO_ROOT, "unsloth", "models", "rl_replacements.py")
+
+
+def _load_helpers():
+    src = open(RL_PATH).read()
+    tree = ast.parse(src)
+    import torch as _torch
+
+    ns = {"torch": _torch}
+    for node in tree.body:
+        if isinstance(node, ast.Assign) and any(
+            isinstance(t, ast.Name) and t.id == "_DPO_VISION_KEYS" for t in node.targets
+        ):
+            exec(ast.get_source_segment(src, node), ns)
+    for node in tree.body:
+        if isinstance(node, ast.FunctionDef) and node.name.startswith(
+            ("dpo_trainer_", "_dpo_trainer_")
+        ):
+            exec(ast.get_source_segment(src, node), ns)
+    return ns
+
+
+class _Tok:
+    eos_token_id = 99
+    bos_token_id = None
+
+    def __call__(self, t, add_special_tokens = False):
+        return {"input_ids": [10]}
+
+
+class _Capture:
+    image_token = "<img>"
+    boi_token = "<boi>"
+
+    def __init__(self):
+        self.tokenizer = _Tok()
+        self.last_text = None
+        self.last_images = "__sentinel__"
+
+    def __call__(self, images = None, text = None, add_special_tokens = False):
+        self.last_text = text
+        self.last_images = images
+        out = {"input_ids": [[1, 2]]}
+        if images is not None:
+            out["pixel_values"] = [object()]
+        return out
+
+
+def test_prompt_passes_through_without_image_token_synthesis():
+    ns = _load_helpers()
+    proc = _Capture()
+    ns["dpo_trainer_vision_process_row"](
+        {"prompt": "describe", "chosen": "c", "rejected": "r", "images": ["i"]},
+        proc,
+    )
+    assert proc.last_text == "describe"
+
+
+def test_prompt_with_existing_image_token_unchanged():
+    ns = _load_helpers()
+    proc = _Capture()
+    ns["dpo_trainer_vision_process_row"](
+        {"prompt": "<img> describe", "chosen": "c", "rejected": "r", "images": ["i"]},
+        proc,
+    )
+    assert proc.last_text == "<img> describe"
+
+
+def test_gemma3_style_boi_token_prompt_not_corrupted():
+    ns = _load_helpers()
+    proc = _Capture()
+    ns["dpo_trainer_vision_process_row"](
+        {"prompt": "<boi> describe", "chosen": "c", "rejected": "r", "images": ["i"]},
+        proc,
+    )
+    assert proc.last_text == "<boi> describe"
+    assert "<img>" not in proc.last_text
+
+
+def test_multi_image_prompt_unchanged_no_extra_placeholders():
+    ns = _load_helpers()
+    proc = _Capture()
+    ns["dpo_trainer_vision_process_row"](
+        {
+            "prompt": "compare",
+            "chosen": "c",
+            "rejected": "r",
+            "images": ["a", "b", "c"],
+        },
+        proc,
+    )
+    assert proc.last_text == "compare"
+
+
+def test_list_images_forwarded_verbatim():
+    ns = _load_helpers()
+    proc = _Capture()
+    payload = ["a", "b"]
+    ns["dpo_trainer_vision_process_row"](
+        {"prompt": "p", "chosen": "c", "rejected": "r", "images": payload},
+        proc,
+    )
+    assert proc.last_images is payload
+
+
+def test_single_pil_like_image_forwarded_verbatim():
+    ns = _load_helpers()
+
+    class PIL:
+        def __bool__(self):
+            return True
+
+    proc = _Capture()
+    pil = PIL()
+    ns["dpo_trainer_vision_process_row"](
+        {"prompt": "p", "chosen": "c", "rejected": "r", "images": pil},
+        proc,
+    )
+    assert proc.last_images is pil
+
+
+def test_numpy_ndarray_image_forwarded_verbatim():
+    ns = _load_helpers()
+    proc = _Capture()
+    arr = np.zeros((2, 3, 3), dtype = np.uint8)
+    ns["dpo_trainer_vision_process_row"](
+        {"prompt": "p", "chosen": "c", "rejected": "r", "images": arr},
+        proc,
+    )
+    assert proc.last_images is arr
+
+
+def test_missing_images_key_passes_none_to_processor():
+    ns = _load_helpers()
+    proc = _Capture()
+    ns["dpo_trainer_vision_process_row"](
+        {"prompt": "p", "chosen": "c", "rejected": "r"},
+        proc,
+    )
+    assert proc.last_images is None
diff --git a/tests/python/test_fast_sentence_transformer_redirect_lifecycle.py b/tests/python/test_fast_sentence_transformer_redirect_lifecycle.py
new file mode 100644
index 0000000000..ff9b91ec23
--- /dev/null
+++ b/tests/python/test_fast_sentence_transformer_redirect_lifecycle.py
@@ -0,0 +1,218 @@
+"""FastSentenceTransformer constructor-redirect lifecycle:
+- AutoModel/AutoProcessor/AutoTokenizer.from_pretrained are restored even
+  when the Transformer constructor raises (try/finally invariant).
+- The closure that decides whether to substitute the pre-loaded objects
+  (`is_requested_model_name`) handles HF repo IDs, local paths, trailing
+  slashes, pathlib.Path objects, and missing identifiers correctly.
+"""
+
+from __future__ import annotations
+
+import os
+import pathlib
+import sys
+import types
+
+
+class _FakeAuto:
+    def __init__(self, name):
+        self.name = name
+        self.from_pretrained = self._original
+
+    def _original(self, *args, **kwargs):
+        return ("orig", self.name, args, kwargs)
+
+
+class _RecordingTransformerOk:
+    last_calls = None
+
+    def __init__(self, model_name, **kwargs):
+        from transformers import AutoModel, AutoProcessor, AutoTokenizer
+
+        type(self).last_calls = {
+            "model": AutoModel.from_pretrained(model_name),
+            "processor": AutoProcessor.from_pretrained(model_name),
+            "tokenizer": AutoTokenizer.from_pretrained(model_name),
+        }
+
+
+class _RaisingTransformer:
+    def __init__(self, *a, **kw):
+        from transformers import AutoModel
+
+        AutoModel.from_pretrained(a[0] if a else kw.get("model_name_or_path"))
+        raise RuntimeError("simulated init failure")
+
+
+def _build_driver(transformer_class):
+    transformers_mod = types.ModuleType("transformers")
+    transformers_mod.AutoModel = _FakeAuto("AutoModel")
+    transformers_mod.AutoProcessor = _FakeAuto("AutoProcessor")
+    transformers_mod.AutoTokenizer = _FakeAuto("AutoTokenizer")
+    sys.modules["transformers"] = transformers_mod
+
+    st_root = types.ModuleType("sentence_transformers")
+    st_models = types.ModuleType("sentence_transformers.models")
+    st_models.Transformer = transformer_class
+    sys.modules["sentence_transformers"] = st_root
+    sys.modules["sentence_transformers.models"] = st_models
+
+    captured = {"calls": None}
+
+    def driver(model_name, model, tokenizer):
+        from transformers import AutoModel, AutoProcessor, AutoTokenizer
+        from sentence_transformers.models import Transformer
+
+        def is_requested_model_name(args, kwargs):
+            requested = None
+            if args:
+                requested = args[0]
+            else:
+                requested = kwargs.get("pretrained_model_name_or_path")
+                if requested is None:
+                    requested = kwargs.get("model_name_or_path")
+            if requested is None:
+                return False
+            try:
+                requested = os.fspath(requested)
+                expected = os.fspath(model_name)
+            except (TypeError, ValueError):
+                return False
+            if requested == expected:
+                return True
+            try:
+                if os.path.exists(requested) or os.path.exists(expected):
+                    return os.path.abspath(requested) == os.path.abspath(expected)
+            except (OSError, TypeError, ValueError):
+                pass
+            return False
+
+        original_model = AutoModel.from_pretrained
+        original_processor = AutoProcessor.from_pretrained
+        original_tokenizer = AutoTokenizer.from_pretrained
+
+        def return_existing_model(*a, **kw):
+            return model if is_requested_model_name(a, kw) else original_model(*a, **kw)
+
+        def return_existing_tokenizer(*a, **kw):
+            return (
+                tokenizer
+                if is_requested_model_name(a, kw)
+                else original_tokenizer(*a, **kw)
+            )
+
+        def return_existing_processor(*a, **kw):
+            return (
+                tokenizer
+                if is_requested_model_name(a, kw)
+                else original_processor(*a, **kw)
+            )
+
+        try:
+            AutoModel.from_pretrained = return_existing_model
+            AutoProcessor.from_pretrained = return_existing_processor
+            AutoTokenizer.from_pretrained = return_existing_tokenizer
+            t = Transformer(model_name)
+            captured["calls"] = getattr(type(t), "last_calls", None)
+            return t
+        finally:
+            AutoModel.from_pretrained = original_model
+            AutoProcessor.from_pretrained = original_processor
+            AutoTokenizer.from_pretrained = original_tokenizer
+
+    return driver, transformers_mod, captured
+
+
+def test_redirect_substitutes_preloaded_objects_on_match():
+    driver, _mod, captured = _build_driver(_RecordingTransformerOk)
+    sentinel_model = object()
+    sentinel_tok = object()
+    driver("sentence-transformers/all-MiniLM-L6-v2", sentinel_model, sentinel_tok)
+    calls = captured["calls"]
+    assert calls["model"] is sentinel_model
+    assert calls["processor"] is sentinel_tok
+    assert calls["tokenizer"] is sentinel_tok
+
+
+def test_redirect_restored_on_constructor_exception():
+    driver, transformers_mod, _ = _build_driver(_RaisingTransformer)
+    pre_model = transformers_mod.AutoModel.from_pretrained
+    pre_processor = transformers_mod.AutoProcessor.from_pretrained
+    pre_tokenizer = transformers_mod.AutoTokenizer.from_pretrained
+
+    try:
+        driver("model-id", object(), object())
+    except RuntimeError:
+        pass
+
+    assert transformers_mod.AutoModel.from_pretrained is pre_model
+    assert transformers_mod.AutoProcessor.from_pretrained is pre_processor
+    assert transformers_mod.AutoTokenizer.from_pretrained is pre_tokenizer
+
+
+def test_redirect_passes_through_for_other_model_names():
+    class _OtherNameTransformer:
+        captured = None
+
+        def __init__(self, model_name, **kw):
+            from transformers import AutoModel
+
+            type(self).captured = AutoModel.from_pretrained("some-other/aux-model")
+
+    driver, *_ = _build_driver(_OtherNameTransformer)
+    sentinel = object()
+    driver("primary/model-id", sentinel, object())
+    assert _OtherNameTransformer.captured is not sentinel
+    assert isinstance(_OtherNameTransformer.captured, tuple)
+    assert _OtherNameTransformer.captured[0] == "orig"
+
+
+def test_is_requested_model_name_handles_pathlib_path(tmp_path):
+    target = tmp_path / "model_dir"
+    target.mkdir()
+
+    class _PathTransformer:
+        last_calls = None
+
+        def __init__(self, model_name, **kw):
+            from transformers import AutoModel
+
+            type(self).last_calls = AutoModel.from_pretrained(pathlib.Path(model_name))
+
+    driver, *_ = _build_driver(_PathTransformer)
+    sentinel_model = object()
+    driver(str(target), sentinel_model, object())
+    assert _PathTransformer.last_calls is sentinel_model
+
+
+def test_is_requested_model_name_trailing_slash_local_path(tmp_path):
+    target = tmp_path / "model_dir"
+    target.mkdir()
+
+    class _SlashTransformer:
+        last_calls = None
+
+        def __init__(self, model_name, **kw):
+            from transformers import AutoModel
+
+            type(self).last_calls = AutoModel.from_pretrained(str(target) + "/")
+
+    driver, *_ = _build_driver(_SlashTransformer)
+    sentinel_model = object()
+    driver(str(target), sentinel_model, object())
+    assert _SlashTransformer.last_calls is sentinel_model
+
+
+def test_is_requested_model_name_returns_false_when_no_identifier():
+    captured = {"args": None}
+
+    class _NoNameTransformer:
+        def __init__(self, model_name, **kw):
+            from transformers import AutoModel
+
+            captured["args"] = AutoModel.from_pretrained(some_other_kwarg = "x")
+
+    driver, *_ = _build_driver(_NoNameTransformer)
+    driver("primary/model-id", object(), object())
+    assert isinstance(captured["args"], tuple)
+    assert captured["args"][0] == "orig"
diff --git a/tests/python/test_unsloth_run_tool_policy_resolver.py b/tests/python/test_unsloth_run_tool_policy_resolver.py
new file mode 100644
index 0000000000..6aff02494b
--- /dev/null
+++ b/tests/python/test_unsloth_run_tool_policy_resolver.py
@@ -0,0 +1,201 @@
+# Copyright 2025-present the Unsloth AI Inc. team. All rights reserved.
+
+"""
+Truth-table tests for `resolve_tool_policy` -- the pure resolver behind
+`unsloth run --enable-tools/--disable-tools`.
+
+Covers:
+  - 127.0.0.1 default-on, explicit on, explicit off
+  - 0.0.0.0 default-off, explicit off
+  - 0.0.0.0 + explicit on: confirm prompt unless --silent or --yes,
+    abort on negative answer.
+"""
+
+import pytest
+import typer
+
+from unsloth_cli._tool_policy import is_external_host, resolve_tool_policy
+
+
+def _never_prompt(_msg: str) -> bool:
+    raise AssertionError("prompt should not have been called")
+
+
+def _prompt_yes(_msg: str) -> bool:
+    return True
+
+
+def _prompt_no(_msg: str) -> bool:
+    return False
+
+
+class TestLocalhostHost:
+    @pytest.mark.parametrize("flag", [None, True, False])
+    def test_no_prompt(self, flag):
+        # localhost never prompts regardless of flag
+        result = resolve_tool_policy(
+            host = "127.0.0.1",
+            flag = flag,
+            yes = False,
+            silent = False,
+            prompt = _never_prompt,
+        )
+        assert result is (True if flag in (None, True) else False)
+
+    def test_default_is_on(self):
+        assert (
+            resolve_tool_policy(
+                host = "127.0.0.1",
+                flag = None,
+                yes = False,
+                silent = False,
+                prompt = _never_prompt,
+            )
+            is True
+        )
+
+    def test_explicit_off(self):
+        assert (
+            resolve_tool_policy(
+                host = "127.0.0.1",
+                flag = False,
+                yes = False,
+                silent = False,
+                prompt = _never_prompt,
+            )
+            is False
+        )
+
+
+class TestZeroHost:
+    def test_default_is_off(self):
+        assert (
+            resolve_tool_policy(
+                host = "0.0.0.0",
+                flag = None,
+                yes = False,
+                silent = False,
+                prompt = _never_prompt,
+            )
+            is False
+        )
+
+    def test_explicit_off_no_prompt(self):
+        assert (
+            resolve_tool_policy(
+                host = "0.0.0.0",
+                flag = False,
+                yes = False,
+                silent = False,
+                prompt = _never_prompt,
+            )
+            is False
+        )
+
+    def test_explicit_on_silent_skips_prompt(self):
+        assert (
+            resolve_tool_policy(
+                host = "0.0.0.0",
+                flag = True,
+                yes = False,
+                silent = True,
+                prompt = _never_prompt,
+            )
+            is True
+        )
+
+    def test_explicit_on_yes_skips_prompt(self):
+        assert (
+            resolve_tool_policy(
+                host = "0.0.0.0",
+                flag = True,
+                yes = True,
+                silent = False,
+                prompt = _never_prompt,
+            )
+            is True
+        )
+
+    def test_explicit_on_prompt_yes(self):
+        assert (
+            resolve_tool_policy(
+                host = "0.0.0.0",
+                flag = True,
+                yes = False,
+                silent = False,
+                prompt = _prompt_yes,
+            )
+            is True
+        )
+
+    def test_explicit_on_prompt_no_aborts(self):
+        with pytest.raises(typer.Exit) as exc_info:
+            resolve_tool_policy(
+                host = "0.0.0.0",
+                flag = True,
+                yes = False,
+                silent = False,
+                prompt = _prompt_no,
+            )
+        assert exc_info.value.exit_code == 1
+
+
+class TestIsExternalHost:
+    @pytest.mark.parametrize(
+        "host", ["127.0.0.1", "localhost", "::1", "LOCALHOST", "Localhost"]
+    )
+    def test_loopback_aliases_are_local(self, host):
+        assert is_external_host(host) is False
+
+    @pytest.mark.parametrize(
+        "host", ["0.0.0.0", "::", "192.168.1.5", "10.0.0.1", "example.com"]
+    )
+    def test_non_loopback_is_external(self, host):
+        assert is_external_host(host) is True
+
+
+class TestSpecificNetworkIP:
+    """Binding to a specific LAN IP must follow the same rules as 0.0.0.0."""
+
+    def test_default_is_off(self):
+        assert (
+            resolve_tool_policy(
+                host = "192.168.1.5",
+                flag = None,
+                yes = False,
+                silent = False,
+                prompt = _never_prompt,
+            )
+            is False
+        )
+
+    def test_explicit_on_prompts(self):
+        seen = []
+
+        def _prompt(msg: str) -> bool:
+            seen.append(msg)
+            return True
+
+        assert (
+            resolve_tool_policy(
+                host = "192.168.1.5",
+                flag = True,
+                yes = False,
+                silent = False,
+                prompt = _prompt,
+            )
+            is True
+        )
+        assert any("192.168.1.5" in m for m in seen)
+
+    def test_localhost_alias_does_not_prompt(self):
+        assert (
+            resolve_tool_policy(
+                host = "localhost",
+                flag = True,
+                yes = False,
+                silent = False,
+                prompt = _never_prompt,
+            )
+            is True
+        )
diff --git a/tests/saving/non_peft/test_mistral_non_peft.py b/tests/saving/non_peft/test_mistral_non_peft.py
index e03813367d..b2610360fe 100644
--- a/tests/saving/non_peft/test_mistral_non_peft.py
+++ b/tests/saving/non_peft/test_mistral_non_peft.py
@@ -27,7 +27,7 @@ model, tokenizer = FastLanguageModel.from_pretrained(
 
 print("✅ Base model loaded successfully!")
 
-### Attemtping save merge
+### Attempting save merge
 
 
 print(f"\n{'='*80}")
diff --git a/tests/saving/non_peft/test_whisper_non_peft.py b/tests/saving/non_peft/test_whisper_non_peft.py
index 303d596c85..2d5676ec9c 100644
--- a/tests/saving/non_peft/test_whisper_non_peft.py
+++ b/tests/saving/non_peft/test_whisper_non_peft.py
@@ -27,7 +27,7 @@ model, tokenizer = FastModel.from_pretrained(
 
 print("✅ Base model loaded successfully!")
 
-### Attemtping save merge
+### Attempting save merge
 
 
 print(f"\n{'='*80}")
diff --git a/tests/saving/vision_models/test_index_file_sharded_model.py b/tests/saving/vision_models/test_index_file_sharded_model.py
index f737169841..8d107463e0 100644
--- a/tests/saving/vision_models/test_index_file_sharded_model.py
+++ b/tests/saving/vision_models/test_index_file_sharded_model.py
@@ -65,7 +65,7 @@ def format_data(sample):
 print("\n🔄 Formatting dataset for vision training...")
 system_message = "You are an expert french ocr system."
 # Convert dataset to OAI messages
-# need to use list comprehension to keep Pil.Image type, .mape convert image to bytes
+# need to use list comprehension to keep Pil.Image type, .map convert image to bytes
 train_dataset = [format_data(sample) for sample in train_dataset]
 eval_dataset = [format_data(sample) for sample in eval_dataset]
 print("✅ Dataset formatting completed!")
@@ -99,7 +99,7 @@ try:
         finetune_vision_layers = True,  # Turn off for just text!
         finetune_language_layers = True,  # Should leave on!
         finetune_attention_modules = True,  # Attention good for GRPO
-        finetune_mlp_modules = True,  # SHould leave on always!
+        finetune_mlp_modules = True,  # Should leave on always!
         r = 16,  # Choose any number > 0 ! Suggested 8, 16, 32, 64, 128
         lora_alpha = 32,
         lora_dropout = 0,  # Supports any, but = 0 is optimized
diff --git a/tests/saving/vision_models/test_push_to_hub_merged.py b/tests/saving/vision_models/test_push_to_hub_merged.py
index 74fa058988..fb2af4b4fe 100644
--- a/tests/saving/vision_models/test_push_to_hub_merged.py
+++ b/tests/saving/vision_models/test_push_to_hub_merged.py
@@ -66,7 +66,7 @@ def format_data(sample):
 print("\n🔄 Formatting dataset for vision training...")
 system_message = "You are an expert french ocr system."
 # Convert dataset to OAI messages
-# need to use list comprehension to keep Pil.Image type, .mape convert image to bytes
+# need to use list comprehension to keep Pil.Image type, .map convert image to bytes
 train_dataset = [format_data(sample) for sample in train_dataset]
 eval_dataset = [format_data(sample) for sample in eval_dataset]
 print("✅ Dataset formatting completed!")
@@ -100,7 +100,7 @@ try:
         finetune_vision_layers = True,  # Turn off for just text!
         finetune_language_layers = True,  # Should leave on!
         finetune_attention_modules = True,  # Attention good for GRPO
-        finetune_mlp_modules = True,  # SHould leave on always!
+        finetune_mlp_modules = True,  # Should leave on always!
         r = 16,  # Choose any number > 0 ! Suggested 8, 16, 32, 64, 128
         lora_alpha = 32,
         lora_dropout = 0,  # Supports any, but = 0 is optimized
diff --git a/tests/saving/vision_models/test_save_merge_qwen2.5vl32B_model_ocr_benchmark.py b/tests/saving/vision_models/test_save_merge_qwen2.5vl32B_model_ocr_benchmark.py
index ebe078c73b..2b24bc4a32 100644
--- a/tests/saving/vision_models/test_save_merge_qwen2.5vl32B_model_ocr_benchmark.py
+++ b/tests/saving/vision_models/test_save_merge_qwen2.5vl32B_model_ocr_benchmark.py
@@ -61,7 +61,7 @@ def format_data(sample):
 
 system_message = "You are an expert french ocr system."
 # Convert dataset to OAI messages
-# need to use list comprehension to keep Pil.Image type, .mape convert image to bytes
+# need to use list comprehension to keep Pil.Image type, .map convert image to bytes
 train_dataset = [format_data(sample) for sample in train_dataset]
 eval_dataset = [format_data(sample) for sample in eval_dataset]
 
@@ -102,7 +102,7 @@ model = FastVisionModel.get_peft_model(
     finetune_vision_layers = True,  # Turn off for just text!
     finetune_language_layers = True,  # Should leave on!
     finetune_attention_modules = True,  # Attention good for GRPO
-    finetune_mlp_modules = True,  # SHould leave on always!
+    finetune_mlp_modules = True,  # Should leave on always!
     r = 16,  # Choose any number > 0 ! Suggested 8, 16, 32, 64, 128
     # target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
     # "gate_proj", "up_proj", "down_proj",],
diff --git a/tests/saving/vision_models/test_save_merge_vision_model_ocr_benchmark.py b/tests/saving/vision_models/test_save_merge_vision_model_ocr_benchmark.py
index b99785bcb1..16914707c2 100644
--- a/tests/saving/vision_models/test_save_merge_vision_model_ocr_benchmark.py
+++ b/tests/saving/vision_models/test_save_merge_vision_model_ocr_benchmark.py
@@ -61,7 +61,7 @@ def format_data(sample):
 
 system_message = "You are an expert french ocr system."
 # Convert dataset to OAI messages
-# need to use list comprehension to keep Pil.Image type, .mape convert image to bytes
+# need to use list comprehension to keep Pil.Image type, .map convert image to bytes
 train_dataset = [format_data(sample) for sample in train_dataset]
 eval_dataset = [format_data(sample) for sample in eval_dataset]
 
@@ -102,7 +102,7 @@ model = FastVisionModel.get_peft_model(
     finetune_vision_layers = True,  # Turn off for just text!
     finetune_language_layers = True,  # Should leave on!
     finetune_attention_modules = True,  # Attention good for GRPO
-    finetune_mlp_modules = True,  # SHould leave on always!
+    finetune_mlp_modules = True,  # Should leave on always!
     r = 16,  # Choose any number > 0 ! Suggested 8, 16, 32, 64, 128
     # target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
     # "gate_proj", "up_proj", "down_proj",],
diff --git a/tests/sh/test_install_host_defaults.sh b/tests/sh/test_install_host_defaults.sh
new file mode 100755
index 0000000000..7b01eaa716
--- /dev/null
+++ b/tests/sh/test_install_host_defaults.sh
@@ -0,0 +1,104 @@
+#!/bin/bash
+# Static analysis: installer scripts and README must not hard-code 0.0.0.0
+# in any user-visible default launch command. The dynamic-port launcher
+# templates and post-install hints should rely on the new loopback default.
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+INSTALL_SH="$SCRIPT_DIR/../../install.sh"
+INSTALL_PS1="$SCRIPT_DIR/../../install.ps1"
+SETUP_SH="$SCRIPT_DIR/../../studio/setup.sh"
+README="$SCRIPT_DIR/../../README.md"
+PASS=0
+FAIL=0
+
+assert_contains() {
+    _label="$1"; _haystack="$2"; _needle="$3"
+    if echo "$_haystack" | grep -qF -- "$_needle"; then
+        echo "  PASS: $_label"
+        PASS=$((PASS + 1))
+    else
+        echo "  FAIL: $_label (expected to find '$_needle')"
+        FAIL=$((FAIL + 1))
+    fi
+}
+
+assert_not_contains() {
+    _label="$1"; _haystack="$2"; _needle="$3"
+    if echo "$_haystack" | grep -qF -- "$_needle"; then
+        echo "  FAIL: $_label (found '$_needle' but should not)"
+        FAIL=$((FAIL + 1))
+    else
+        echo "  PASS: $_label"
+        PASS=$((PASS + 1))
+    fi
+}
+
+echo ""
+echo "=== install.sh launcher template ==="
+
+# Extract the heredoc that generates ~/.local/share/unsloth/launch-studio.sh.
+_launcher=$(awk '/cat > "\$_css_launcher"/{found=1} found{print} /^LAUNCHER_EOF$/{found=0}' "$INSTALL_SH")
+assert_contains \
+    "launcher template: extraction found the heredoc content" \
+    "$_launcher" "#!/usr/bin/env bash"
+# The desktop launcher should rely on the new 127.0.0.1 default.
+assert_not_contains \
+    "launcher template: no hardcoded 'studio -H 0.0.0.0'" \
+    "$_launcher" "studio -H 0.0.0.0"
+
+echo ""
+echo "=== install.sh end-of-install block ==="
+
+_end=$(tail -50 "$INSTALL_SH")
+assert_contains \
+    "install.sh: interactive block prompts user (read)" \
+    "$_end" "read"
+assert_not_contains \
+    "install.sh: no 'studio -H 0.0.0.0' in end-of-install commands" \
+    "$_end" "studio -H 0.0.0.0"
+
+echo ""
+echo "=== install.ps1 end-of-install block ==="
+
+_ps1_end=$(tail -25 "$INSTALL_PS1")
+assert_contains \
+    "install.ps1: interactive block prompts user (Read-Host)" \
+    "$_ps1_end" "Read-Host"
+assert_not_contains \
+    "install.ps1: no 'studio -H 0.0.0.0' in end-of-install commands" \
+    "$_ps1_end" "studio -H 0.0.0.0"
+
+echo ""
+echo "=== studio/setup.sh launch hint ==="
+
+_setup_tail=$(tail -30 "$SETUP_SH")
+assert_not_contains \
+    "studio/setup.sh: launch hint has no '-H 0.0.0.0'" \
+    "$_setup_tail" "studio -H 0.0.0.0"
+
+echo ""
+echo "=== README.md Launch section ==="
+
+# The primary Launch example must not include -H 0.0.0.0; the LAN/cloud
+# note appears as an opt-in line outside the code block.
+_readme_launch=$(awk '/^#### Launch$/{found=1} found{print} /^#### Update$/{found=0}' "$README")
+assert_contains \
+    "README: Launch section exists" \
+    "$_readme_launch" "unsloth studio"
+assert_not_contains \
+    "README: Launch section primary command has no -H 0.0.0.0" \
+    "$_readme_launch" "studio -H 0.0.0.0"
+assert_contains \
+    "README: Launch section documents -H 0.0.0.0 opt-in" \
+    "$_readme_launch" "0.0.0.0"
+
+echo ""
+echo "=== Results ==="
+echo "  PASS: $PASS"
+echo "  FAIL: $FAIL"
+if [ "$FAIL" -gt 0 ]; then
+    echo "FAILED"
+    exit 1
+fi
+echo "ALL PASSED"
diff --git a/tests/studio/install/test_selection_logic.py b/tests/studio/install/test_selection_logic.py
index 6a2e367dc8..5150d2d2ab 100644
--- a/tests/studio/install/test_selection_logic.py
+++ b/tests/studio/install/test_selection_logic.py
@@ -420,6 +420,10 @@ class TestPickWindowsCudaRuntime:
         host = make_host(driver_cuda_version = (13, 1))
         assert pick_windows_cuda_runtime(host) == "13.1"
 
+    def test_driver_13_0_uses_cuda13_line(self):
+        host = make_host(driver_cuda_version = (13, 0))
+        assert pick_windows_cuda_runtime(host) == "13.1"
+
 
 class TestCompatibleWindowsRuntimeLines:
     def test_no_driver(self):
@@ -434,6 +438,10 @@ class TestCompatibleWindowsRuntimeLines:
         host = make_host(driver_cuda_version = (13, 1))
         assert compatible_windows_runtime_lines(host) == ["cuda13", "cuda12"]
 
+    def test_driver_13_0_uses_cuda13_line(self):
+        host = make_host(driver_cuda_version = (13, 0))
+        assert compatible_windows_runtime_lines(host) == ["cuda13", "cuda12"]
+
 
 # ===========================================================================
 # H. runtime_line_from_cuda_version
@@ -1769,6 +1777,15 @@ class TestWindowsCudaAttempts:
         assert result[0].runtime_line == "cuda13"
         assert result[1].runtime_line == "cuda12"
 
+    def test_driver_13_0_cuda13_dlls_selects_cuda13_asset(self, monkeypatch):
+        mock_windows_runtime(monkeypatch, ["cuda13"])
+        host = make_host(system = "Windows", machine = "AMD64", driver_cuda_version = (13, 0))
+        assets = self._upstream("13.1", "12.4")
+        result = windows_cuda_attempts(host, self.TAG, assets, None)
+        assert len(result) == 1
+        assert result[0].runtime_line == "cuda13"
+        assert result[0].name == f"llama-{self.TAG}-bin-win-cuda-13.1-x64.zip"
+
     def test_preferred_reorders(self, monkeypatch):
         mock_windows_runtime(monkeypatch, ["cuda13", "cuda12"])
         host = make_host(system = "Windows", machine = "AMD64", driver_cuda_version = (13, 1))
diff --git a/tests/studio/test_cancel_atomicity.py b/tests/studio/test_cancel_atomicity.py
new file mode 100644
index 0000000000..a8d4839454
--- /dev/null
+++ b/tests/studio/test_cancel_atomicity.py
@@ -0,0 +1,289 @@
+"""
+TOCTOU atomicity guards for the cancel path.
+
+Structural: cancel_inference, _cancel_by_cancel_id_or_stash, and
+_TrackedCancel.__enter__ must each use a single _CANCEL_LOCK critical
+section over lookup + stash / register + consume-pending.
+
+Behavioral: parallel cancel-POST vs __enter__ must never drop a cancel.
+"""
+
+from __future__ import annotations
+
+import ast
+import random
+import threading
+from pathlib import Path
+
+
+SOURCE_PATH = (
+    Path(__file__).resolve().parents[2]
+    / "studio"
+    / "backend"
+    / "routes"
+    / "inference.py"
+)
+_SRC = SOURCE_PATH.read_text()
+_TREE = ast.parse(_SRC)
+
+
+def _find_function(name: str) -> ast.FunctionDef | ast.AsyncFunctionDef:
+    for node in ast.walk(_TREE):
+        if (
+            isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
+            and node.name == name
+        ):
+            return node
+    raise AssertionError(f"function {name!r} not found")
+
+
+def _find_class(name: str) -> ast.ClassDef:
+    for node in ast.walk(_TREE):
+        if isinstance(node, ast.ClassDef) and node.name == name:
+            return node
+    raise AssertionError(f"class {name!r} not found")
+
+
+def _count_with_cancel_lock_blocks(node: ast.AST) -> int:
+    n = 0
+    for sub in ast.walk(node):
+        if not isinstance(sub, ast.With):
+            continue
+        for item in sub.items:
+            ctx = item.context_expr
+            if isinstance(ctx, ast.Name) and ctx.id == "_CANCEL_LOCK":
+                n += 1
+                break
+    return n
+
+
+def test_cancel_by_cancel_id_or_stash_is_single_lock_critical_section():
+    fn = _find_function("_cancel_by_cancel_id_or_stash")
+    assert _count_with_cancel_lock_blocks(fn) == 1, (
+        "_cancel_by_cancel_id_or_stash must use exactly one `with "
+        "_CANCEL_LOCK:` block; splitting into two acquisitions reopens "
+        "the TOCTOU race with _TrackedCancel.__enter__"
+    )
+    src = ast.unparse(fn)
+    assert "_CANCEL_REGISTRY.get(cancel_id)" in src
+    assert "_PENDING_CANCELS[cancel_id]" in src
+
+
+def test_tracked_cancel_enter_registers_and_consumes_pending_under_one_lock():
+    cls = _find_class("_TrackedCancel")
+    enter = None
+    for n in cls.body:
+        if isinstance(n, ast.FunctionDef) and n.name == "__enter__":
+            enter = n
+            break
+    assert enter is not None
+    assert _count_with_cancel_lock_blocks(enter) == 1, (
+        "_TrackedCancel.__enter__ must acquire _CANCEL_LOCK exactly once. "
+        "A second acquisition for consume-pending lets a concurrent "
+        "cancel POST stash after consume sees an empty map, silently "
+        "dropping the cancel"
+    )
+    with_block = None
+    for sub in ast.walk(enter):
+        if isinstance(sub, ast.With) and any(
+            isinstance(i.context_expr, ast.Name) and i.context_expr.id == "_CANCEL_LOCK"
+            for i in sub.items
+        ):
+            with_block = sub
+            break
+    assert with_block is not None
+    block_src = "\n".join(ast.unparse(s) for s in with_block.body)
+    assert "_CANCEL_REGISTRY.setdefault" in block_src
+    assert "_PENDING_CANCELS.pop" in block_src, (
+        "__enter__ critical section must consume from _PENDING_CANCELS "
+        "inside the same lock, not a later re-acquisition"
+    )
+
+
+def test_cancel_inference_uses_atomic_helper_for_cancel_id_path():
+    fn = _find_function("cancel_inference")
+    src = ast.unparse(fn)
+    assert "_cancel_by_cancel_id_or_stash" in src
+    # The pre-fix two-step idiom must be gone.
+    assert "_remember_pending_cancel(cancel_id)" not in src, (
+        "two-step _cancel_by_keys + _remember_pending_cancel produced "
+        "the TOCTOU race and must not return"
+    )
+
+
+_WANTED = {
+    "_CANCEL_REGISTRY",
+    "_CANCEL_LOCK",
+    "_PENDING_CANCELS",
+    "_PENDING_CANCEL_TTL_S",
+    "_prune_pending",
+    "_remember_pending_cancel",
+    "_TrackedCancel",
+    "_cancel_by_keys",
+    "_cancel_by_cancel_id_or_stash",
+}
+
+
+def _load_registry_module():
+    chunks = []
+    for n in _TREE.body:
+        seg = ast.get_source_segment(_SRC, n)
+        if seg is None:
+            continue
+        if isinstance(n, (ast.FunctionDef, ast.ClassDef)) and n.name in _WANTED:
+            chunks.append(seg)
+        elif isinstance(n, ast.Assign):
+            names = [t.id for t in n.targets if isinstance(t, ast.Name)]
+            if any(name in _WANTED for name in names):
+                chunks.append(seg)
+        elif (
+            isinstance(n, ast.AnnAssign)
+            and isinstance(n.target, ast.Name)
+            and n.target.id in _WANTED
+        ):
+            chunks.append(seg)
+    mod = {}
+    exec(
+        "import threading, time\nfrom typing import Optional\n" + "\n\n".join(chunks),
+        mod,
+    )
+    return mod
+
+
+def test_parallel_cancel_vs_register_never_drops():
+    m = _load_registry_module()
+    trials = 500
+    dropped = 0
+    for i in range(trials):
+        m["_CANCEL_REGISTRY"].clear()
+        m["_PENDING_CANCELS"].clear()
+        cid = f"cid-{i}"
+        ev = threading.Event()
+        tracker = m["_TrackedCancel"](ev, cid, "thread")
+        start = threading.Event()
+
+        def do_cancel():
+            start.wait()
+            m["_cancel_by_cancel_id_or_stash"](cid)
+
+        def do_enter():
+            start.wait()
+            tracker.__enter__()
+
+        threads = [
+            threading.Thread(target = do_cancel),
+            threading.Thread(target = do_enter),
+        ]
+        random.shuffle(threads)
+        for t in threads:
+            t.start()
+        start.set()
+        for t in threads:
+            t.join(timeout = 5.0)
+            assert not t.is_alive()
+
+        if not ev.is_set():
+            dropped += 1
+        tracker.__exit__(None, None, None)
+
+    assert dropped == 0, (
+        f"TOCTOU regression: {dropped}/{trials} parallel trials silently "
+        f"dropped the cancel"
+    )
+
+
+def test_cancel_before_register_replays_atomically():
+    m = _load_registry_module()
+    cid = "early-cid"
+    ev = threading.Event()
+    tracker = m["_TrackedCancel"](ev, cid, "thread-x")
+
+    assert m["_cancel_by_cancel_id_or_stash"](cid) == 0
+    assert cid in m["_PENDING_CANCELS"]
+
+    tracker.__enter__()
+    assert ev.is_set()
+    assert cid not in m["_PENDING_CANCELS"]
+    tracker.__exit__(None, None, None)
+
+
+def test_cancel_after_register_signals_without_stash():
+    m = _load_registry_module()
+    cid = "post-cid"
+    ev = threading.Event()
+    tracker = m["_TrackedCancel"](ev, cid, "thread-y")
+    tracker.__enter__()
+
+    assert m["_cancel_by_cancel_id_or_stash"](cid) == 1
+    assert ev.is_set()
+    assert cid not in m["_PENDING_CANCELS"]
+    tracker.__exit__(None, None, None)
+
+
+def test_cancel_by_keys_tolerates_empty_and_falsy_keys():
+    m = _load_registry_module()
+    m["_CANCEL_REGISTRY"].clear()
+    m["_PENDING_CANCELS"].clear()
+    assert m["_cancel_by_keys"]([]) == 0
+    assert m["_cancel_by_keys"](["", None, "unknown"]) == 0
+    # Non-stashing fallback must never leak into _PENDING_CANCELS.
+    assert m["_PENDING_CANCELS"] == {}
+
+
+def test_cancel_by_keys_fans_out_to_all_streams_on_same_session():
+    # Compare mode and other flows launch concurrent streams under a
+    # shared session_id; a single session cancel POST must hit all of them.
+    m = _load_registry_module()
+    m["_CANCEL_REGISTRY"].clear()
+    m["_PENDING_CANCELS"].clear()
+    session = "shared-thread"
+    ev_a = threading.Event()
+    ev_b = threading.Event()
+    tracker_a = m["_TrackedCancel"](ev_a, "cancel-a", session, "chatcmpl-a")
+    tracker_b = m["_TrackedCancel"](ev_b, "cancel-b", session, "chatcmpl-b")
+    tracker_a.__enter__()
+    tracker_b.__enter__()
+    try:
+        assert m["_cancel_by_keys"]([session]) == 2
+        assert ev_a.is_set() and ev_b.is_set()
+    finally:
+        tracker_a.__exit__(None, None, None)
+        tracker_b.__exit__(None, None, None)
+    assert session not in m["_CANCEL_REGISTRY"]
+
+
+def test_cancel_by_cancel_id_is_exclusive_to_single_run():
+    # cancel_id is per-run unique; cancelling run A must not touch run B
+    # even when both share a session_id.
+    m = _load_registry_module()
+    m["_CANCEL_REGISTRY"].clear()
+    m["_PENDING_CANCELS"].clear()
+    session = "shared-thread-2"
+    ev_a = threading.Event()
+    ev_b = threading.Event()
+    tracker_a = m["_TrackedCancel"](ev_a, "cancel-only-a", session, "chatcmpl-a")
+    tracker_b = m["_TrackedCancel"](ev_b, "cancel-only-b", session, "chatcmpl-b")
+    tracker_a.__enter__()
+    tracker_b.__enter__()
+    try:
+        assert m["_cancel_by_cancel_id_or_stash"]("cancel-only-a") == 1
+        assert ev_a.is_set()
+        assert not ev_b.is_set()
+    finally:
+        tracker_a.__exit__(None, None, None)
+        tracker_b.__exit__(None, None, None)
+
+
+def test_tracked_cancel_exit_is_idempotent():
+    # Outer except BaseException + the generator's finally may both call
+    # __exit__ under certain race combos; must not raise.
+    m = _load_registry_module()
+    m["_CANCEL_REGISTRY"].clear()
+    m["_PENDING_CANCELS"].clear()
+    ev = threading.Event()
+    tracker = m["_TrackedCancel"](ev, "cid", "sess", "chatcmpl-x")
+    tracker.__enter__()
+    tracker.__exit__(None, None, None)
+    tracker.__exit__(None, None, None)
+    tracker.__exit__(None, None, None)
+    assert not m["_CANCEL_REGISTRY"]
diff --git a/tests/studio/test_cancel_id_wiring.py b/tests/studio/test_cancel_id_wiring.py
new file mode 100644
index 0000000000..5fd76ded9b
--- /dev/null
+++ b/tests/studio/test_cancel_id_wiring.py
@@ -0,0 +1,169 @@
+"""
+Wiring tests for the per-run cancel_id field.
+
+A chat-thread-scoped session_id is not safe as a cancel key because a
+late stop POST can match a subsequent run on the same thread. The fix
+adds cancel_id (a fresh UUID per generation) that is sent both in the
+completion payload and in the /api/inference/cancel body.
+
+Verifies:
+  - ChatCompletionRequest exposes an Optional[str] `cancel_id` field.
+  - /api/inference/cancel accepts `cancel_id` as the first-preferred key.
+  - OpenAIChatCompletionsRequest (frontend type) includes cancel_id.
+  - chat-adapter.ts generates a per-run cancelId (crypto.randomUUID
+    with a Math.random fallback), sends it in the completion payload,
+    and includes it in the /inference/cancel body on abort.
+"""
+
+from __future__ import annotations
+
+import ast
+import re
+from pathlib import Path
+
+
+WORKSPACE = Path(__file__).resolve().parents[2]
+MODELS_SRC = (WORKSPACE / "studio/backend/models/inference.py").read_text()
+ROUTES_SRC = (WORKSPACE / "studio/backend/routes/inference.py").read_text()
+ADAPTER_SRC = (
+    WORKSPACE / "studio/frontend/src/features/chat/api/chat-adapter.ts"
+).read_text()
+API_TYPES_SRC = (
+    WORKSPACE / "studio/frontend/src/features/chat/types/api.ts"
+).read_text()
+
+
+def _find_class(tree: ast.AST, name: str) -> ast.ClassDef | None:
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef) and node.name == name:
+            return node
+    return None
+
+
+def test_chat_completion_request_has_cancel_id_field():
+    tree = ast.parse(MODELS_SRC)
+    cls = _find_class(tree, "ChatCompletionRequest")
+    assert cls is not None
+    fields = {
+        n.target.id
+        for n in cls.body
+        if isinstance(n, ast.AnnAssign) and isinstance(n.target, ast.Name)
+    }
+    assert "cancel_id" in fields, (
+        "ChatCompletionRequest must expose a cancel_id field for per-run "
+        "cancellation routing"
+    )
+
+
+def test_cancel_route_matches_cancel_id_exclusively_when_present():
+    # A stale cancel POST carrying cancel_id AND session_id must not
+    # cancel a later run on the same thread via the shared session_id.
+    # Enforce this by requiring the handler to early-return through an
+    # exclusive-cancel_id path -- either an atomic helper or a keys
+    # list containing ONLY cancel_id (never session_id).
+    for node in ast.walk(ast.parse(ROUTES_SRC)):
+        if isinstance(node, ast.AsyncFunctionDef) and node.name == "cancel_inference":
+            break
+    else:
+        raise AssertionError("cancel_inference handler missing")
+
+    cancel_id_exclusive_branch = False
+    for sub in ast.walk(node):
+        if not isinstance(sub, ast.If):
+            continue
+        test_src = ast.unparse(sub.test)
+        if "cancel_id" not in test_src or "isinstance" not in test_src:
+            continue
+        branch_src = "\n".join(ast.unparse(s) for s in sub.body)
+        before_return = branch_src.split("return", 1)[0]
+        matches_cancel_id_only = (
+            "_cancel_by_cancel_id_or_stash(cancel_id)" in branch_src
+            or "_cancel_by_keys([cancel_id])" in branch_src
+        )
+        if matches_cancel_id_only and "session_id" not in before_return:
+            cancel_id_exclusive_branch = True
+            break
+    assert cancel_id_exclusive_branch, (
+        "cancel_inference must early-return with an exclusive cancel_id "
+        "match when a cancel_id is supplied, so a stale stop POST "
+        "cannot cancel a later run on the same thread via session_id"
+    )
+
+
+def test_cancel_route_falls_back_to_session_or_completion_when_no_cancel_id():
+    for node in ast.walk(ast.parse(ROUTES_SRC)):
+        if isinstance(node, ast.AsyncFunctionDef) and node.name == "cancel_inference":
+            break
+    else:
+        raise AssertionError("cancel_inference handler missing")
+
+    src = ast.unparse(node)
+    assert "session_id" in src and "completion_id" in src, (
+        "cancel_inference must still accept session_id / completion_id as "
+        "fallback keys when cancel_id is absent"
+    )
+
+
+def test_frontend_request_type_has_cancel_id():
+    assert re.search(
+        r"cancel_id\?\s*:\s*string\s*;", API_TYPES_SRC
+    ), "OpenAIChatCompletionsRequest must expose an optional cancel_id"
+
+
+def test_chat_adapter_generates_cancel_id_per_run():
+    m = re.search(
+        r"const\s+cancelId\s*=\s*([^;]+);",
+        ADAPTER_SRC,
+    )
+    assert m, "chat-adapter.ts must declare a per-run `cancelId` constant"
+    rhs = m.group(1)
+    assert (
+        "randomUUID" in rhs
+    ), "cancelId should prefer crypto.randomUUID() for uniqueness"
+
+
+def test_chat_adapter_sends_cancel_id_in_completion_payload():
+    assert "cancel_id: cancelId" in ADAPTER_SRC, (
+        "chat-adapter.ts must include cancel_id in the streamChatCompletions "
+        "request payload so the backend registers under that key"
+    )
+
+
+def test_chat_adapter_sends_cancel_id_in_abort_cancel_post():
+    m = re.search(
+        r"const\s+onAbortCancel\s*=\s*\(\)\s*=>\s*\{(.*?)\};",
+        ADAPTER_SRC,
+        flags = re.DOTALL,
+    )
+    assert m, "onAbortCancel arrow function missing"
+    body = m.group(1)
+    assert re.search(r"cancel_id\s*:\s*cancelId", body), (
+        "onAbortCancel must include cancel_id in the /inference/cancel body "
+        "so a stop POST matches the specific run, not the whole thread"
+    )
+
+
+def test_abort_cancel_post_uses_plain_fetch_with_manual_auth_header():
+    # authFetch redirects to login on 401, which would kick the user to
+    # the login page mid-stop if the access token expired during a long
+    # stream. Use plain fetch + manual Authorization header for a
+    # best-effort cancel that never triggers the refresh/redirect flow.
+    start = ADAPTER_SRC.find("const onAbortCancel")
+    assert start >= 0, "onAbortCancel handler missing"
+    rest = ADAPTER_SRC[start:]
+    end = rest.find("\n      try {")
+    body = rest if end < 0 else rest[:end]
+    assert "/api/inference/cancel" in body
+    assert "authFetch(" not in body, (
+        "onAbortCancel must NOT call authFetch; a 401 from it would "
+        "redirect the user to the login page during a stop click"
+    )
+    assert "fetch(" in body, "onAbortCancel must use plain fetch(...)"
+    assert "getAuthToken" in body, (
+        "onAbortCancel must read the bearer token via getAuthToken() "
+        "rather than relying on authFetch's 401 flow"
+    )
+    assert "Authorization" in body
+    assert (
+        "keepalive: true" in body
+    ), "keepalive is required so the fetch survives page unload during stop"
diff --git a/tests/studio/test_chat_preset_builtin_invariants.py b/tests/studio/test_chat_preset_builtin_invariants.py
new file mode 100644
index 0000000000..da5f21099e
--- /dev/null
+++ b/tests/studio/test_chat_preset_builtin_invariants.py
@@ -0,0 +1,272 @@
+import json
+import os
+import shutil
+import subprocess
+import textwrap
+from pathlib import Path
+
+import pytest
+
+WORKDIR = Path(__file__).resolve().parents[2]
+PRESET_POLICY = (
+    WORKDIR / "unsloth_repo/studio/frontend/src/features/chat/presets/preset-policy.ts"
+)
+RUNTIME_TYPES = (
+    WORKDIR / "unsloth_repo/studio/frontend/src/features/chat/types/runtime.ts"
+)
+TEMP = WORKDIR / "temp" / "chat_preset_builtin_invariants"
+
+
+def _require_node():
+    if shutil.which("node") is None:
+        pytest.skip("node not available")
+    if not PRESET_POLICY.exists() or not RUNTIME_TYPES.exists():
+        pytest.skip("studio chat sources not present")
+
+
+def _ensure_harness():
+    TEMP.mkdir(parents = True, exist_ok = True)
+    (TEMP / "register.mjs").write_text(
+        "import { register } from 'node:module';\n"
+        "register('./loader.mjs', import.meta.url);\n"
+    )
+    (TEMP / "loader.mjs").write_text(
+        "export function resolve(specifier, context, next) {\n"
+        "  if (specifier.endsWith('/types/runtime')) return next(specifier + '.ts', context);\n"
+        "  return next(specifier, context);\n"
+        "}\n"
+    )
+
+
+def _run(script: str):
+    _require_node()
+    _ensure_harness()
+    script_path = TEMP / "run.mts"
+    script_path.write_text(script)
+    env = dict(os.environ, NODE_NO_WARNINGS = "1")
+    result = subprocess.run(
+        [
+            "node",
+            "--experimental-strip-types",
+            "--import=./register.mjs",
+            "--no-warnings",
+            "run.mts",
+        ],
+        cwd = str(TEMP),
+        capture_output = True,
+        text = True,
+        timeout = 30,
+        env = env,
+    )
+    assert result.returncode == 0, f"stderr: {result.stderr}\nstdout: {result.stdout}"
+    last = [line for line in result.stdout.strip().splitlines() if line.strip()][-1]
+    return json.loads(last)
+
+
+def _policy_path():
+    return os.path.relpath(PRESET_POLICY, TEMP).replace("\\", "/")
+
+
+def _runtime_path():
+    return os.path.relpath(RUNTIME_TYPES, TEMP).replace("\\", "/")
+
+
+def test_default_builtin_matches_default_inference_params():
+    out = _run(
+        textwrap.dedent(
+            f"""
+            // @ts-nocheck
+            import {{ BUILTIN_PRESETS, isSamePresetConfig }} from "{_policy_path()}";
+            import {{ DEFAULT_INFERENCE_PARAMS }} from "{_runtime_path()}";
+            const def = BUILTIN_PRESETS.find((p) => p.name === "Default");
+            console.log(JSON.stringify({{
+                found: !!def,
+                matches: def ? isSamePresetConfig(def.params, DEFAULT_INFERENCE_PARAMS) : null,
+            }}));
+            """
+        )
+    )
+    assert out["found"] is True
+    assert out["matches"] is True
+
+
+def test_is_same_preset_config_detects_temperature_edit():
+    out = _run(
+        textwrap.dedent(
+            f"""
+            // @ts-nocheck
+            import {{ BUILTIN_PRESETS, isSamePresetConfig }} from "{_policy_path()}";
+            const def = BUILTIN_PRESETS.find((p) => p.name === "Default");
+            const edited = {{ ...def.params, temperature: def.params.temperature + 0.1 }};
+            console.log(JSON.stringify({{ same: isSamePresetConfig(def.params, edited) }}));
+            """
+        )
+    )
+    assert out["same"] is False
+
+
+def test_is_same_preset_config_detects_system_prompt_edit():
+    out = _run(
+        textwrap.dedent(
+            f"""
+            // @ts-nocheck
+            import {{ BUILTIN_PRESETS, isSamePresetConfig }} from "{_policy_path()}";
+            const def = BUILTIN_PRESETS.find((p) => p.name === "Default");
+            const edited = {{ ...def.params, systemPrompt: "you are a pirate" }};
+            console.log(JSON.stringify({{ same: isSamePresetConfig(def.params, edited) }}));
+            """
+        )
+    )
+    assert out["same"] is False
+
+
+def test_is_same_preset_config_ignores_checkpoint_difference():
+    out = _run(
+        textwrap.dedent(
+            f"""
+            // @ts-nocheck
+            import {{ BUILTIN_PRESETS, isSamePresetConfig }} from "{_policy_path()}";
+            const def = BUILTIN_PRESETS.find((p) => p.name === "Default");
+            const withCheckpoint = {{ ...def.params, checkpoint: "meta-llama/Llama-3-8B" }};
+            console.log(JSON.stringify({{ same: isSamePresetConfig(def.params, withCheckpoint) }}));
+            """
+        )
+    )
+    assert out["same"] is True
+
+
+def test_is_same_preset_config_ignores_model_owned_fields():
+    out = _run(
+        textwrap.dedent(
+            f"""
+            // @ts-nocheck
+            import {{ BUILTIN_PRESETS, isSamePresetConfig }} from "{_policy_path()}";
+            const def = BUILTIN_PRESETS.find((p) => p.name === "Default");
+            const edited = {{
+                ...def.params,
+                maxSeqLength: def.params.maxSeqLength + 1024,
+                trustRemoteCode: !def.params.trustRemoteCode,
+            }};
+            console.log(JSON.stringify({{ same: isSamePresetConfig(def.params, edited) }}));
+            """
+        )
+    )
+    assert out["same"] is True
+
+
+def test_preset_owned_config_key_ignores_model_owned_fields():
+    out = _run(
+        textwrap.dedent(
+            f"""
+            // @ts-nocheck
+            import {{ BUILTIN_PRESETS, getPresetOwnedConfigKey }} from "{_policy_path()}";
+            const def = BUILTIN_PRESETS.find((p) => p.name === "Default");
+            const edited = {{
+                ...def.params,
+                checkpoint: "foo/bar",
+                maxSeqLength: def.params.maxSeqLength + 1024,
+                trustRemoteCode: !def.params.trustRemoteCode,
+            }};
+            console.log(JSON.stringify({{
+                same: getPresetOwnedConfigKey(def.params) === getPresetOwnedConfigKey(edited),
+            }}));
+            """
+        )
+    )
+    assert out["same"] is True
+
+
+def test_to_preset_params_strips_model_owned_fields():
+    out = _run(
+        textwrap.dedent(
+            f"""
+            // @ts-nocheck
+            import {{ toPresetParams }} from "{_policy_path()}";
+            const sanitized = toPresetParams({{
+                temperature: 0.9,
+                topP: 0.8,
+                topK: 40,
+                minP: 0.05,
+                repetitionPenalty: 1.1,
+                presencePenalty: 0.4,
+                maxSeqLength: 16384,
+                maxTokens: 2048,
+                systemPrompt: "hello",
+                checkpoint: "foo/bar",
+                trustRemoteCode: true,
+            }});
+            console.log(JSON.stringify({{
+                checkpoint: sanitized.checkpoint,
+                trustRemoteCode: sanitized.trustRemoteCode,
+                maxSeqLength: sanitized.maxSeqLength,
+                maxTokens: sanitized.maxTokens,
+                systemPrompt: sanitized.systemPrompt,
+            }}));
+            """
+        )
+    )
+    assert out["checkpoint"] == ""
+    assert out["trustRemoteCode"] is False
+    assert out["maxSeqLength"] == 4096
+    assert out["maxTokens"] == 2048
+    assert out["systemPrompt"] == "hello"
+
+
+def test_apply_preset_params_preserves_model_owned_fields():
+    out = _run(
+        textwrap.dedent(
+            f"""
+            // @ts-nocheck
+            import {{ BUILTIN_PRESETS, applyPresetParams }} from "{_policy_path()}";
+            const creative = BUILTIN_PRESETS.find((p) => p.name === "Creative");
+            const applied = applyPresetParams(
+                {{
+                    temperature: 0.6,
+                    topP: 0.95,
+                    topK: 20,
+                    minP: 0.01,
+                    repetitionPenalty: 1.0,
+                    presencePenalty: 0.0,
+                    maxSeqLength: 16384,
+                    maxTokens: 8192,
+                    systemPrompt: "keep me?",
+                    checkpoint: "foo/bar",
+                    trustRemoteCode: true,
+                }},
+                creative.params,
+            );
+            console.log(JSON.stringify({{
+                checkpoint: applied.checkpoint,
+                trustRemoteCode: applied.trustRemoteCode,
+                maxSeqLength: applied.maxSeqLength,
+                temperature: applied.temperature,
+                topK: applied.topK,
+            }}));
+            """
+        )
+    )
+    assert out["checkpoint"] == "foo/bar"
+    assert out["trustRemoteCode"] is True
+    assert out["maxSeqLength"] == 16384
+    assert out["temperature"] == 1.5
+    assert out["topK"] == 0
+
+
+def test_creative_and_precise_builtins_differ_from_default():
+    out = _run(
+        textwrap.dedent(
+            f"""
+            // @ts-nocheck
+            import {{ BUILTIN_PRESETS, isSamePresetConfig }} from "{_policy_path()}";
+            const def = BUILTIN_PRESETS.find((p) => p.name === "Default");
+            const creative = BUILTIN_PRESETS.find((p) => p.name === "Creative");
+            const precise = BUILTIN_PRESETS.find((p) => p.name === "Precise");
+            console.log(JSON.stringify({{
+                creativeDiffers: !isSamePresetConfig(def.params, creative.params),
+                preciseDiffers: !isSamePresetConfig(def.params, precise.params),
+            }}));
+            """
+        )
+    )
+    assert out["creativeDiffers"] is True
+    assert out["preciseDiffers"] is True
diff --git a/tests/studio/test_cli_repo_variant.py b/tests/studio/test_cli_repo_variant.py
new file mode 100644
index 0000000000..1aa21cfd7d
--- /dev/null
+++ b/tests/studio/test_cli_repo_variant.py
@@ -0,0 +1,145 @@
+"""Tests for the ``repo:variant`` shorthand parser used by ``unsloth studio run``.
+
+Loads ``unsloth_cli/commands/studio.py`` directly via ``importlib`` with a
+minimal ``typer`` stub so the test doesn't drag in the rest of
+``unsloth_cli`` (which transitively imports the unsloth training stack).
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+import types
+from pathlib import Path
+
+import pytest
+
+
+def _load_split_repo_variant():
+    """Load ``_split_repo_variant`` from studio.py with typer stubbed.
+
+    studio.py decorates Typer commands at import time, so a stub that
+    accepts (and discards) those calls is enough to let module
+    execution complete and expose the helper we want to test.
+    """
+    if "typer" not in sys.modules:
+        typer_stub = types.ModuleType("typer")
+
+        class _Typer:
+            def __init__(self, **kwargs):
+                pass
+
+            def callback(self, *args, **kwargs):
+                return lambda fn: fn
+
+            def command(self, *args, **kwargs):
+                return lambda fn: fn
+
+        typer_stub.Typer = _Typer
+        typer_stub.Option = lambda *args, **kwargs: (args[0] if args else None)
+        typer_stub.Context = type("Context", (), {})
+        typer_stub.Exit = type("Exit", (Exception,), {})
+        typer_stub.echo = lambda *args, **kwargs: None
+        sys.modules["typer"] = typer_stub
+
+    studio_py = (
+        Path(__file__).resolve().parents[2] / "unsloth_cli" / "commands" / "studio.py"
+    )
+    spec = importlib.util.spec_from_file_location(
+        "_studio_for_repo_variant_test", studio_py
+    )
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module._split_repo_variant
+
+
+_split = _load_split_repo_variant()
+
+
+# ── HF-style repo:variant inputs -------------------------------------
+
+
+@pytest.mark.parametrize(
+    "model_arg, expected",
+    [
+        (
+            "unsloth/gpt-oss-20b-GGUF:UD-Q4_K_XL",
+            ("unsloth/gpt-oss-20b-GGUF", "UD-Q4_K_XL"),
+        ),
+        ("unsloth/gpt-oss-120b-GGUF:Q4_K_XL", ("unsloth/gpt-oss-120b-GGUF", "Q4_K_XL")),
+        ("unsloth/Qwen3-0.6B-GGUF:Q4_K_M", ("unsloth/Qwen3-0.6B-GGUF", "Q4_K_M")),
+        # Variants commonly contain dashes, dots, and underscores.
+        ("org/repo:UD-Q5_K_M", ("org/repo", "UD-Q5_K_M")),
+        ("org/repo:F16", ("org/repo", "F16")),
+    ],
+)
+def test_repo_variant_split(model_arg, expected):
+    assert _split(model_arg) == expected
+
+
+# ── No variant suffix ------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "model_arg",
+    [
+        "unsloth/gpt-oss-20b-GGUF",
+        "unsloth/Qwen3-0.6B-GGUF",
+        "shorthand-no-org-no-colon",
+    ],
+)
+def test_no_colon_returns_none_variant(model_arg):
+    repo, variant = _split(model_arg)
+    assert repo == model_arg
+    assert variant is None
+
+
+# ── Local paths must NOT be split ------------------------------------
+
+
+@pytest.mark.parametrize(
+    "local_path",
+    [
+        "/abs/path/to/model.gguf",
+        "/abs/path:with-colon-in-name",
+        "./relative/model",
+        "../parent/model",
+        "~/home/model",
+        ".",
+        "C:\\Users\\me\\model.gguf",
+        "C:/Users/me/model.gguf",
+        "D:/data/model:Q4",  # Windows drive + colon-suffixed filename: drive wins
+    ],
+)
+def test_local_path_passthrough(local_path):
+    repo, variant = _split(local_path)
+    assert repo == local_path
+    assert variant is None
+
+
+# ── Edge cases -------------------------------------------------------
+
+
+def test_empty_string():
+    assert _split("") == ("", None)
+
+
+def test_trailing_colon_no_variant():
+    # "org/repo:" -- no quant label after the colon. Pass through
+    # unchanged so the backend's existing validation surfaces a
+    # clearer error than "variant ''".
+    repo, variant = _split("org/repo:")
+    assert repo == "org/repo:"
+    assert variant is None
+
+
+def test_slash_in_variant_disqualifies_split():
+    # "foo:bar/baz" -- the suffix has a slash, so this isn't a quant
+    # label; treat the whole thing as opaque.
+    repo, variant = _split("foo:bar/baz")
+    assert repo == "foo:bar/baz"
+    assert variant is None
+
+
+def test_whitespace_stripped():
+    assert _split("  org/repo:Q4  ") == ("org/repo", "Q4")
diff --git a/tests/studio/test_cli_run_alias.py b/tests/studio/test_cli_run_alias.py
new file mode 100644
index 0000000000..aed6361ee2
--- /dev/null
+++ b/tests/studio/test_cli_run_alias.py
@@ -0,0 +1,69 @@
+"""Tests that ``unsloth run`` is registered as a top-level alias for
+``unsloth studio run``.
+
+AST-based to avoid importing ``unsloth_cli`` (which pulls in the heavy
+training stack) at test-collection time.
+"""
+
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+_CLI_INIT = Path(__file__).resolve().parents[2] / "unsloth_cli" / "__init__.py"
+
+
+def _module_calls(source: str):
+    tree = ast.parse(source)
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Call):
+            yield node
+
+
+def test_top_level_run_alias_registered():
+    """`app.command("run", ...)` must be invoked with studio_run as its target."""
+    source = _CLI_INIT.read_text()
+
+    # Find ``app.command("run", ...)`` call -- the decorator-call form.
+    found_decorator_call = False
+    for call in _module_calls(source):
+        # Match ``app.command(...)`` syntactically.
+        if not (
+            isinstance(call.func, ast.Attribute)
+            and call.func.attr == "command"
+            and isinstance(call.func.value, ast.Name)
+            and call.func.value.id == "app"
+        ):
+            continue
+        # Decorator-call form has a string literal "run" as the first
+        # positional or as keyword ``name="run"``.
+        first_pos = call.args[0] if call.args else None
+        keyword_name = next(
+            (kw.value for kw in call.keywords if kw.arg == "name"), None
+        )
+        is_run = (isinstance(first_pos, ast.Constant) and first_pos.value == "run") or (
+            isinstance(keyword_name, ast.Constant) and keyword_name.value == "run"
+        )
+        if is_run:
+            found_decorator_call = True
+            break
+    assert (
+        found_decorator_call
+    ), 'Expected `app.command("run", ...)` registration in unsloth_cli/__init__.py'
+
+
+def test_studio_run_imported_for_alias():
+    """The alias must wire up to the studio.run function, not redefine it."""
+    source = _CLI_INIT.read_text()
+    tree = ast.parse(source)
+    has_import = False
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.ImportFrom):
+            continue
+        if node.module != "unsloth_cli.commands.studio":
+            continue
+        for alias in node.names:
+            if alias.name == "run":
+                has_import = True
+                break
+    assert has_import, "Expected `from unsloth_cli.commands.studio import run` in unsloth_cli/__init__.py"
diff --git a/tests/studio/test_cli_studio_defaults.py b/tests/studio/test_cli_studio_defaults.py
new file mode 100644
index 0000000000..4d6f28f075
--- /dev/null
+++ b/tests/studio/test_cli_studio_defaults.py
@@ -0,0 +1,87 @@
+"""Tests that the 'unsloth studio' CLI defaults to 127.0.0.1.
+
+Uses AST parsing to inspect source-level defaults without requiring the
+full unsloth_cli dependencies (typer/pydantic) at test-collection time.
+"""
+
+import ast
+from pathlib import Path
+
+_STUDIO_CMD_PY = (
+    Path(__file__).resolve().parents[2] / "unsloth_cli" / "commands" / "studio.py"
+)
+
+
+def _find_typer_option_default(source: str, func_name: str, long_option: str):
+    """Return the default value of a typer.Option(...) parameter in *func_name*.
+
+    Matches by the long option name (e.g. '--host') among the positional args
+    of the typer.Option() call and returns the first positional arg (the
+    default value). Only handles ast.Constant defaults.
+    """
+    tree = ast.parse(source)
+    for func_node in ast.walk(tree):
+        if not isinstance(func_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            continue
+        if func_node.name != func_name:
+            continue
+        # Walk both regular args and kwonly args, each paired with its default.
+        all_args = func_node.args.args + func_node.args.kwonlyargs
+        all_defaults = func_node.args.defaults + [
+            d for d in func_node.args.kw_defaults if d is not None
+        ]
+        # ast pads defaults right-aligned against args (ignoring kwonly). We
+        # iterate calls directly, which is simpler and robust.
+        for default in all_defaults:
+            if not isinstance(default, ast.Call):
+                continue
+            call_func = default.func
+            is_typer_option = (
+                isinstance(call_func, ast.Attribute)
+                and call_func.attr == "Option"
+                and isinstance(call_func.value, ast.Name)
+                and call_func.value.id == "typer"
+            )
+            if not is_typer_option:
+                continue
+            # First positional is the default value; remaining positionals are
+            # option flags like "--host", "-H".
+            if not default.args:
+                continue
+            flags = [
+                a.value
+                for a in default.args[1:]
+                if isinstance(a, ast.Constant) and isinstance(a.value, str)
+            ]
+            if long_option not in flags:
+                continue
+            first = default.args[0]
+            if isinstance(first, ast.Constant):
+                return first.value
+    return None
+
+
+def test_studio_default_host_is_loopback():
+    """`unsloth studio` (studio_default) --host typer Option default must be 127.0.0.1."""
+    source = _STUDIO_CMD_PY.read_text()
+    host_default = _find_typer_option_default(source, "studio_default", "--host")
+    assert (
+        host_default is not None
+    ), "Could not find --host typer.Option default in studio_default()"
+    assert host_default == "127.0.0.1", (
+        f"studio_default() --host default must be '127.0.0.1' (loopback) "
+        f"but got '{host_default}'."
+    )
+
+
+def test_studio_run_host_is_loopback():
+    """`unsloth studio run` --host typer Option default must be 127.0.0.1."""
+    source = _STUDIO_CMD_PY.read_text()
+    host_default = _find_typer_option_default(source, "run", "--host")
+    assert (
+        host_default is not None
+    ), "Could not find --host typer.Option default in run()"
+    assert host_default == "127.0.0.1", (
+        f"`unsloth studio run` --host default must be '127.0.0.1' (loopback) "
+        f"but got '{host_default}'."
+    )
diff --git a/tests/studio/test_llama_cpp_wall_clock_cap.py b/tests/studio/test_llama_cpp_wall_clock_cap.py
new file mode 100644
index 0000000000..671abea823
--- /dev/null
+++ b/tests/studio/test_llama_cpp_wall_clock_cap.py
@@ -0,0 +1,123 @@
+"""
+Tests for the llama-server wall-clock cap (t_max_predict_ms).
+
+The UI always sends max_tokens = context_length, so gating
+t_max_predict_ms on `max_tokens is None` makes the safety net dead
+code. The fix applies the wall-clock cap unconditionally on all three
+streaming payload sites and raises the default to 10 minutes so slow
+CPU / macOS / Windows installs are not cut off mid-generation.
+
+Verifies:
+  - t_max_predict_ms is assigned unconditionally at the three
+    payload-builder sites (not inside an `if max_tokens is None` else
+    branch).
+  - _DEFAULT_T_MAX_PREDICT_MS is at least 10 minutes (previously
+    120_000).
+  - The default max_tokens path still applies _DEFAULT_MAX_TOKENS.
+  - The three payload variable names (payload x2, stream_payload x1)
+    each get both `max_tokens` and `t_max_predict_ms`.
+"""
+
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+SOURCE_PATH = (
+    Path(__file__).resolve().parents[2]
+    / "studio"
+    / "backend"
+    / "core"
+    / "inference"
+    / "llama_cpp.py"
+)
+SRC = SOURCE_PATH.read_text()
+TREE = ast.parse(SRC)
+
+
+def _is_subscript_assign(stmt: ast.stmt, target_name: str, key: str) -> bool:
+    if not isinstance(stmt, ast.Assign) or len(stmt.targets) != 1:
+        return False
+    t = stmt.targets[0]
+    if not isinstance(t, ast.Subscript):
+        return False
+    if not (isinstance(t.value, ast.Name) and t.value.id == target_name):
+        return False
+    slc = t.slice
+    return isinstance(slc, ast.Constant) and slc.value == key
+
+
+def _collect_assignments(tree, target_name, key):
+    """Return list of (node, stack_of_enclosing_ifs) for each match."""
+    hits = []
+
+    def visit(node, stack):
+        if _is_subscript_assign(node, target_name, key):
+            hits.append((node, stack))
+        for child in ast.iter_child_nodes(node):
+            if isinstance(child, ast.If):
+                for sub in child.body:
+                    visit(sub, stack + [(child, "body")])
+                for sub in child.orelse:
+                    visit(sub, stack + [(child, "orelse")])
+            else:
+                visit(child, stack)
+
+    visit(tree, [])
+    return hits
+
+
+def test_default_t_max_predict_ms_is_at_least_ten_minutes():
+    for node in TREE.body:
+        if isinstance(node, ast.Assign) and len(node.targets) == 1:
+            t = node.targets[0]
+            if isinstance(t, ast.Name) and t.id == "_DEFAULT_T_MAX_PREDICT_MS":
+                value = node.value
+                assert isinstance(value, ast.Constant)
+                assert value.value >= 600_000, (
+                    f"_DEFAULT_T_MAX_PREDICT_MS must be >= 10 minutes "
+                    f"(600_000 ms) to avoid cutting off slow-CPU generations; "
+                    f"got {value.value}"
+                )
+                return
+    raise AssertionError("_DEFAULT_T_MAX_PREDICT_MS constant missing")
+
+
+def test_t_max_predict_ms_set_unconditionally_at_three_sites():
+    hits_payload = _collect_assignments(TREE, "payload", "t_max_predict_ms")
+    hits_stream = _collect_assignments(TREE, "stream_payload", "t_max_predict_ms")
+    total = len(hits_payload) + len(hits_stream)
+    assert total == 3, (
+        f"expected 3 total t_max_predict_ms assignments "
+        f"(payload x2 + stream_payload x1), got {total}"
+    )
+    for node, stack in hits_payload + hits_stream:
+        for parent_if, branch in stack:
+            # The assignment must not be gated by a test that checks
+            # `max_tokens is None` (which would make it dead code for
+            # the UI path where max_tokens is always set).
+            test_src = ast.unparse(parent_if.test)
+            assert "max_tokens" not in test_src, (
+                f"t_max_predict_ms at line {node.lineno} is nested under "
+                f"`if {test_src}:` -- it must be applied unconditionally so "
+                f"the wall-clock cap is not dead code for callers that set "
+                f"max_tokens"
+            )
+
+
+def test_max_tokens_default_cap_still_applied():
+    # _DEFAULT_MAX_TOKENS must still kick in when caller passes None.
+    # We check the conditional expression `max_tokens if max_tokens is not
+    # None else _DEFAULT_MAX_TOKENS` appears at each site.
+    matches = 0
+    for node in ast.walk(TREE):
+        if not isinstance(node, ast.IfExp):
+            continue
+        src = ast.unparse(node)
+        if "max_tokens" in src and "_DEFAULT_MAX_TOKENS" in src:
+            matches += 1
+    assert matches >= 3, (
+        f"expected >=3 `max_tokens if max_tokens is not None else "
+        f"_DEFAULT_MAX_TOKENS` expressions; got {matches}"
+    )
diff --git a/tests/studio/test_stream_cancel_registration_timing.py b/tests/studio/test_stream_cancel_registration_timing.py
new file mode 100644
index 0000000000..40ec3d6e1f
--- /dev/null
+++ b/tests/studio/test_stream_cancel_registration_timing.py
@@ -0,0 +1,718 @@
+"""
+Tests that the cancel tracker is registered BEFORE StreamingResponse is
+returned, and that cleanup runs via a `finally` block inside each
+async generator.
+
+The zombie-generation scenario is: user clicks Stop during prefill /
+warmup / proxy buffering, before the first SSE chunk. If _tracker
+__enter__ lives inside the async generator body, the registry is empty
+at the moment /api/inference/cancel lands -- so cancel returns 0 and
+the decode runs to completion.
+
+The fix moves _tracker = _TrackedCancel(...) and _tracker.__enter__()
+to the synchronous body of openai_chat_completions (before the
+StreamingResponse is returned) and places _tracker.__exit__ inside
+each generator's `finally` block. Using a generator `finally` (rather
+than a Starlette BackgroundTask) guarantees cleanup on every
+termination path -- normal exhaustion, CancelledError from
+ClientDisconnect, and OSError / BrokenPipeError during send() --
+because Starlette skips `background` callbacks when stream_response
+raises.
+
+Structural verifies:
+  - No `async def ...:` body contains `_tracker.__enter__()` in
+    routes/inference.py (registration moved to sync body).
+  - Each of the four async generators (gguf_tool_stream,
+    gguf_stream_chunks, stream_chunks, audio_input_stream) contains
+    `_tracker.__exit__(None, None, None)` inside a try/finally block.
+  - No StreamingResponse in openai_chat_completions passes
+    `background=` (cleanup now lives in the generator finally).
+
+Behavioral verifies (extracting `_TrackedCancel` from source and
+exercising the actual runtime semantics):
+  - `finally: _tracker.__exit__(...)` runs on normal completion,
+    mid-stream exception (OSError / BrokenPipeError from send()),
+    and aclose() from Starlette ClientDisconnect.
+  - A pre-set cancel_event (from `_TrackedCancel.__enter__` replaying
+    a pending cancel POST) lets the GGUF while-loop break cleanly
+    and emit final_chunk + [DONE] instead of propagating
+    `GeneratorExit` out of `_stream_with_retry` into the async
+    generator's `except Exception` (which would not catch it).
+"""
+
+from __future__ import annotations
+
+import ast
+import asyncio
+import threading
+import time
+from pathlib import Path
+
+
+SOURCE_PATH = (
+    Path(__file__).resolve().parents[2]
+    / "studio"
+    / "backend"
+    / "routes"
+    / "inference.py"
+)
+SRC = SOURCE_PATH.read_text()
+_TREE = ast.parse(SRC)
+
+
+# ── Structural (AST) helpers ─────────────────────────────────
+
+
+def _collect_async_functions(tree: ast.AST):
+    return [n for n in ast.walk(tree) if isinstance(n, ast.AsyncFunctionDef)]
+
+
+def _has_tracker_enter_call(node: ast.AST) -> bool:
+    for sub in ast.walk(node):
+        if not isinstance(sub, ast.Call):
+            continue
+        fn = sub.func
+        if (
+            isinstance(fn, ast.Attribute)
+            and fn.attr == "__enter__"
+            and isinstance(fn.value, ast.Name)
+            and fn.value.id.startswith("_tracker")
+        ):
+            return True
+    return False
+
+
+def _finalbody_has_tracker_exit(finalbody) -> bool:
+    for stmt in finalbody:
+        if not isinstance(stmt, ast.Expr):
+            continue
+        call = stmt.value
+        if not (isinstance(call, ast.Call) and isinstance(call.func, ast.Attribute)):
+            continue
+        fn = call.func
+        if (
+            fn.attr == "__exit__"
+            and isinstance(fn.value, ast.Name)
+            and fn.value.id.startswith("_tracker")
+        ):
+            return True
+    return False
+
+
+# ── Structural tests ─────────────────────────────────────────
+
+
+def test_no_tracker_enter_inside_async_generators():
+    offenders = []
+    for fn in _collect_async_functions(_TREE):
+        if fn.name in {
+            "gguf_tool_stream",
+            "gguf_stream_chunks",
+            "stream_chunks",
+            "audio_input_stream",
+        }:
+            if _has_tracker_enter_call(fn):
+                offenders.append(fn.name)
+    assert not offenders, (
+        f"Cancel tracker registration must live OUTSIDE the async generator "
+        f"body so a stop POST can find the registry entry before the first "
+        f"SSE chunk. Offending generators: {offenders}"
+    )
+
+
+def test_tracker_enter_exists_in_sync_body_of_chat_completions():
+    top = None
+    for n in ast.walk(_TREE):
+        if isinstance(n, ast.AsyncFunctionDef) and n.name == "openai_chat_completions":
+            top = n
+            break
+    assert top is not None, "openai_chat_completions handler missing"
+    count = 0
+    for sub in ast.walk(top):
+        if not isinstance(sub, ast.Call):
+            continue
+        fn = sub.func
+        if (
+            isinstance(fn, ast.Attribute)
+            and fn.attr == "__enter__"
+            and isinstance(fn.value, ast.Name)
+            and fn.value.id.startswith("_tracker")
+        ):
+            count += 1
+    assert count >= 3, (
+        f"expected >=3 _tracker.__enter__() calls in openai_chat_completions "
+        f"(one per streaming path), got {count}"
+    )
+
+
+def test_async_generators_cleanup_tracker_in_finally():
+    required = {
+        "gguf_tool_stream",
+        "gguf_stream_chunks",
+        "stream_chunks",
+        "audio_input_stream",
+    }
+    found: set[str] = set()
+    for fn in [n for n in ast.walk(_TREE) if isinstance(n, ast.AsyncFunctionDef)]:
+        if fn.name not in required:
+            continue
+        for sub in ast.walk(fn):
+            if isinstance(sub, ast.Try) and sub.finalbody:
+                if _finalbody_has_tracker_exit(sub.finalbody):
+                    found.add(fn.name)
+                    break
+    missing = required - found
+    assert not missing, (
+        f"Cleanup must run via `finally: _tracker.__exit__(None, None, None)` "
+        f"inside each streaming generator so ClientDisconnect / OSError paths "
+        f"also release registry entries (Starlette skips `background` callbacks "
+        f"when stream_response raises). Missing in: {sorted(missing)}"
+    )
+
+
+def test_streaming_responses_have_no_background_task():
+    top = None
+    for n in ast.walk(_TREE):
+        if isinstance(n, ast.AsyncFunctionDef) and n.name == "openai_chat_completions":
+            top = n
+            break
+    assert top is not None
+    for sub in ast.walk(top):
+        if not (isinstance(sub, ast.Call) and isinstance(sub.func, ast.Name)):
+            continue
+        if sub.func.id != "StreamingResponse":
+            continue
+        kwargs = {kw.arg for kw in sub.keywords if kw.arg}
+        assert "background" not in kwargs, (
+            "StreamingResponse in openai_chat_completions must not pass "
+            "`background=` -- cleanup now lives in the generator's finally "
+            "block; a BackgroundTask would be skipped on abrupt disconnect"
+        )
+
+
+# ── Behavioral helpers ───────────────────────────────────────
+
+_WANTED = {
+    "_CANCEL_REGISTRY",
+    "_CANCEL_LOCK",
+    "_PENDING_CANCELS",
+    "_PENDING_CANCEL_TTL_S",
+    "_prune_pending",
+    "_TrackedCancel",
+    "_cancel_by_keys",
+    "_cancel_by_cancel_id_or_stash",
+}
+
+
+def _load_registry_module():
+    chunks = []
+    for n in _TREE.body:
+        seg = ast.get_source_segment(SRC, n)
+        if seg is None:
+            continue
+        if isinstance(n, (ast.FunctionDef, ast.ClassDef)) and n.name in _WANTED:
+            chunks.append(seg)
+        elif isinstance(n, ast.Assign):
+            names = [t.id for t in n.targets if isinstance(t, ast.Name)]
+            if any(name in _WANTED for name in names):
+                chunks.append(seg)
+        elif (
+            isinstance(n, ast.AnnAssign)
+            and isinstance(n.target, ast.Name)
+            and n.target.id in _WANTED
+        ):
+            chunks.append(seg)
+    mod = {}
+    exec("import threading, time\n" + "\n\n".join(chunks), mod)
+    return mod
+
+
+def _make_stream(tracker, raise_exc):
+    async def gen():
+        try:
+            try:
+                yield "data: first\n\n"
+                if raise_exc is not None:
+                    raise raise_exc
+                yield "data: [DONE]\n\n"
+            except asyncio.CancelledError:
+                raise
+            except Exception:
+                yield "data: error\n\n"
+            finally:
+                tracker.__exit__(None, None, None)
+        except BaseException:
+            raise
+
+    return gen()
+
+
+async def _consume(agen):
+    out = []
+    try:
+        async for ch in agen:
+            out.append(ch)
+    except BaseException as e:
+        out.append(type(e).__name__)
+    return out
+
+
+def _llama_stub_raises_on_preset_cancel(cancel_event):
+    # Reproduces llama_cpp.py _stream_with_retry:2240 `raise GeneratorExit`
+    # when cancel_event is already set at entry.
+    if cancel_event.is_set():
+        raise GeneratorExit
+    yield "cumulative-1"
+    yield "cumulative-2"
+
+
+async def _post_fix_gguf_loop(cancel_event):
+    yield "first_chunk"
+    gen = _llama_stub_raises_on_preset_cancel(cancel_event)
+    sentinel = object()
+    while True:
+        if cancel_event.is_set():
+            break
+        cumulative = await asyncio.to_thread(next, gen, sentinel)
+        if cumulative is sentinel:
+            break
+        yield cumulative
+    yield "final_chunk"
+    yield "[DONE]"
+
+
+# ── Behavioral tests ─────────────────────────────────────────
+
+
+def test_finally_cleanup_on_normal_completion():
+    m = _load_registry_module()
+    m["_CANCEL_REGISTRY"].clear()
+    ev = threading.Event()
+    tr = m["_TrackedCancel"](ev, "cid-ok", "sid-ok")
+    tr.__enter__()
+    assert "cid-ok" in m["_CANCEL_REGISTRY"]
+    chunks = asyncio.run(_consume(_make_stream(tr, None)))
+    assert chunks == ["data: first\n\n", "data: [DONE]\n\n"]
+    assert "cid-ok" not in m["_CANCEL_REGISTRY"]
+    assert "sid-ok" not in m["_CANCEL_REGISTRY"]
+
+
+def test_finally_cleanup_on_mid_stream_exception():
+    # Simulates OSError / BrokenPipeError from Starlette send() mid-stream --
+    # the exact case where pre-fix `background = BackgroundTask(...)` was
+    # skipped and leaked the registry entry.
+    m = _load_registry_module()
+    m["_CANCEL_REGISTRY"].clear()
+    ev = threading.Event()
+    tr = m["_TrackedCancel"](ev, "cid-err", "sid-err")
+    tr.__enter__()
+    assert "cid-err" in m["_CANCEL_REGISTRY"]
+    asyncio.run(_consume(_make_stream(tr, OSError("disconnect"))))
+    assert "cid-err" not in m["_CANCEL_REGISTRY"]
+    assert "sid-err" not in m["_CANCEL_REGISTRY"]
+
+
+def test_finally_cleanup_on_aclose():
+    # Starlette calls aclose() on the async generator when the client
+    # disconnects mid-stream. The generator's finally block must run.
+    m = _load_registry_module()
+    m["_CANCEL_REGISTRY"].clear()
+    ev = threading.Event()
+    tr = m["_TrackedCancel"](ev, "cid-abort", "sid-abort")
+    tr.__enter__()
+    assert "cid-abort" in m["_CANCEL_REGISTRY"]
+
+    async def run():
+        gen = _make_stream(tr, None)
+        it = gen.__aiter__()
+        await it.__anext__()
+        await gen.aclose()
+
+    asyncio.run(run())
+    assert "cid-abort" not in m["_CANCEL_REGISTRY"]
+    assert "sid-abort" not in m["_CANCEL_REGISTRY"]
+
+
+def test_preset_cancel_event_exits_cleanly_with_done():
+    # Pending-replay: POST /cancel arrived before the stream registered,
+    # was stashed, then consumed by _TrackedCancel.__enter__ which set
+    # cancel_event. The generator must break out of the loop cleanly
+    # and emit final_chunk + [DONE] rather than calling next(gen) and
+    # propagating `GeneratorExit` out of the GGUF stream wrapper.
+    ev = threading.Event()
+    ev.set()
+    chunks = asyncio.run(_consume(_post_fix_gguf_loop(ev)))
+    assert "first_chunk" in chunks
+    assert "final_chunk" in chunks
+    assert "[DONE]" in chunks
+    assert "GeneratorExit" not in chunks
+    assert "cumulative-1" not in chunks
+    assert "cumulative-2" not in chunks
+
+
+def test_normal_path_streams_all_tokens():
+    # Regression: the top-of-loop cancel_event check must not short-circuit
+    # when cancel_event is unset.
+    ev = threading.Event()
+    chunks = asyncio.run(_consume(_post_fix_gguf_loop(ev)))
+    assert chunks == [
+        "first_chunk",
+        "cumulative-1",
+        "cumulative-2",
+        "final_chunk",
+        "[DONE]",
+    ]
+
+
+def test_cancel_during_streaming_stops_iteration_promptly():
+    # Setting cancel_event between yields breaks out on the next iteration
+    # rather than draining the stub generator.
+    ev = threading.Event()
+
+    async def _run():
+        gen = _post_fix_gguf_loop(ev)
+        seen = []
+        async for ch in gen:
+            seen.append(ch)
+            if ch == "cumulative-1":
+                ev.set()
+        return seen
+
+    seen = asyncio.run(_run())
+    assert "first_chunk" in seen
+    assert "cumulative-1" in seen
+    assert "cumulative-2" not in seen
+    assert "final_chunk" in seen
+    assert "[DONE]" in seen
+
+
+# ── Cancel-event responsiveness in the streaming loops ───────
+
+
+def _loop_has_cancel_event_check(fn) -> bool:
+    # An `if cancel_event.is_set():` statement anywhere inside a
+    # `while`/`for` loop body is sufficient -- without it, a cancel POST
+    # cannot interrupt the loop because Colab-style proxies do not
+    # propagate request.is_disconnected().
+    for sub in ast.walk(fn):
+        if not isinstance(sub, (ast.While, ast.For, ast.AsyncFor)):
+            continue
+        for stmt in ast.walk(sub):
+            if not isinstance(stmt, ast.If):
+                continue
+            t = stmt.test
+            if (
+                isinstance(t, ast.Call)
+                and isinstance(t.func, ast.Attribute)
+                and t.func.attr == "is_set"
+                and isinstance(t.func.value, ast.Name)
+                and t.func.value.id == "cancel_event"
+            ):
+                return True
+    return False
+
+
+def test_streaming_generators_check_cancel_event_in_loop():
+    required = {
+        "gguf_tool_stream",
+        "gguf_stream_chunks",
+        "stream_chunks",
+        "audio_input_stream",
+    }
+    missing = []
+    for fn in [n for n in ast.walk(_TREE) if isinstance(n, ast.AsyncFunctionDef)]:
+        if fn.name not in required:
+            continue
+        if not _loop_has_cancel_event_check(fn):
+            missing.append(fn.name)
+    assert not missing, (
+        f"Each streaming generator must check `cancel_event.is_set()` inside "
+        f"its main loop so `POST /api/inference/cancel` can interrupt the "
+        f"stream through proxies that do not forward fetch aborts. "
+        f"Missing in: {sorted(missing)}"
+    )
+
+
+def test_audio_input_stream_offloads_blocking_next_to_thread():
+    # Guards against regression back to `for chunk_text in
+    # audio_input_generate():` -- which blocks the event loop on each
+    # whisper chunk and prevents POST /api/inference/cancel from being
+    # serviced until the chunk yields.
+    audio = None
+    for fn in ast.walk(_TREE):
+        if isinstance(fn, ast.AsyncFunctionDef) and fn.name == "audio_input_stream":
+            audio = fn
+            break
+    assert audio is not None, "audio_input_stream generator missing"
+
+    for sub in ast.walk(audio):
+        if isinstance(sub, (ast.For, ast.AsyncFor)):
+            it_src = ast.unparse(sub.iter)
+            assert "audio_input_generate" not in it_src, (
+                "audio_input_stream must not iterate audio_input_generate() "
+                "directly -- that blocks the event loop. Use "
+                "`await asyncio.to_thread(next, gen, _DONE)` inside a "
+                "`while True` loop instead"
+            )
+
+    found_to_thread_next = False
+    for sub in ast.walk(audio):
+        if not isinstance(sub, ast.Call):
+            continue
+        fn_expr = sub.func
+        if not (
+            isinstance(fn_expr, ast.Attribute)
+            and fn_expr.attr == "to_thread"
+            and isinstance(fn_expr.value, ast.Name)
+            and fn_expr.value.id == "asyncio"
+        ):
+            continue
+        if sub.args and isinstance(sub.args[0], ast.Name) and sub.args[0].id == "next":
+            found_to_thread_next = True
+            break
+    assert found_to_thread_next, (
+        "audio_input_stream must call `asyncio.to_thread(next, gen, ...)` "
+        "to keep the event loop free while whisper yields the next chunk"
+    )
+
+
+def test_stream_chunks_cancel_branch_resets_backend_state():
+    # The Unsloth path's cancel branch must flush GPU / KV-cache state
+    # via `backend.reset_generation_state()` -- the orchestrator's
+    # internal cancel path does not do this, so a cancel-via-POST that
+    # only broke the loop would leave the subprocess in a dirty state
+    # for the next request.
+    fn = None
+    top = None
+    for n in ast.walk(_TREE):
+        if isinstance(n, ast.AsyncFunctionDef) and n.name == "openai_chat_completions":
+            top = n
+            break
+    assert top is not None
+    for n in ast.walk(top):
+        if isinstance(n, ast.AsyncFunctionDef) and n.name == "stream_chunks":
+            fn = n
+            break
+    assert fn is not None, "stream_chunks generator missing"
+
+    for sub in ast.walk(fn):
+        if not isinstance(sub, ast.If):
+            continue
+        t = sub.test
+        if not (
+            isinstance(t, ast.Call)
+            and isinstance(t.func, ast.Attribute)
+            and t.func.attr == "is_set"
+            and isinstance(t.func.value, ast.Name)
+            and t.func.value.id == "cancel_event"
+        ):
+            continue
+        body_src = "\n".join(ast.unparse(s) for s in sub.body)
+        if "backend.reset_generation_state()" in body_src:
+            return
+    raise AssertionError(
+        "stream_chunks `if cancel_event.is_set():` branch must call "
+        "backend.reset_generation_state() -- matches the existing "
+        "request.is_disconnected() / CancelledError cleanup paths and "
+        "prevents KV-cache drift after cancel-via-POST"
+    )
+
+
+# ── Behavioral simulations for the iter-1 fixes ──────────────
+
+
+def test_unsloth_stream_loop_breaks_on_external_cancel_event():
+    cancel_event = threading.Event()
+    reset_calls = [0]
+
+    class _Backend:
+        def reset_generation_state(self):
+            reset_calls[0] += 1
+
+    backend = _Backend()
+
+    def _generate():
+        for i in range(200):
+            time.sleep(0.005)
+            yield f"cum-{i}"
+
+    async def _loop():
+        _DONE = object()
+        loop = asyncio.get_event_loop()
+        gen = _generate()
+        seen = []
+        while True:
+            if cancel_event.is_set():
+                backend.reset_generation_state()
+                break
+            cumulative = await loop.run_in_executor(None, next, gen, _DONE)
+            if cumulative is _DONE:
+                break
+            seen.append(cumulative)
+        return seen
+
+    async def _fire():
+        await asyncio.sleep(0.05)
+        cancel_event.set()
+
+    async def _main():
+        return await asyncio.gather(_loop(), _fire())
+
+    seen, _ = asyncio.run(_main())
+    assert (
+        len(seen) < 200
+    ), f"loop must not drain the generator after cancel; got {len(seen)} tokens"
+    assert reset_calls[0] == 1, (
+        f"backend.reset_generation_state() must be called exactly once on "
+        f"cancel-via-POST, got {reset_calls[0]}"
+    )
+
+
+def test_audio_stream_stays_responsive_under_blocking_next():
+    # Regression guard: replace the post-fix loop with the pre-fix
+    # `for chunk in audio_input_generate()` pattern and assert it blocks
+    # the event loop; then confirm the post-fix pattern exits promptly.
+    cancel_event = threading.Event()
+
+    def _audio_gen():
+        for i in range(8):
+            time.sleep(0.15)
+            yield f"chunk-{i}"
+
+    async def _prefix_loop():
+        seen = []
+        for chunk_text in _audio_gen():
+            if cancel_event.is_set():
+                break
+            seen.append(chunk_text)
+        return seen
+
+    async def _postfix_loop():
+        _DONE = object()
+        gen = _audio_gen()
+        seen = []
+        while True:
+            if cancel_event.is_set():
+                break
+            chunk_text = await asyncio.to_thread(next, gen, _DONE)
+            if chunk_text is _DONE:
+                break
+            seen.append(chunk_text)
+        return seen
+
+    async def _fire_early():
+        await asyncio.sleep(0.05)
+        cancel_event.set()
+
+    async def _run(loop_coro):
+        return await asyncio.gather(loop_coro, _fire_early())
+
+    cancel_event.clear()
+    t0 = time.monotonic()
+    prefix_seen, _ = asyncio.run(_run(_prefix_loop()))
+    prefix_elapsed = time.monotonic() - t0
+    assert prefix_elapsed >= 0.13, (
+        f"pre-fix pattern should block event loop for >=1 chunk time "
+        f"(~150ms); got {prefix_elapsed:.3f}s, {len(prefix_seen)} chunks"
+    )
+
+    cancel_event.clear()
+    t0 = time.monotonic()
+    postfix_seen, _ = asyncio.run(_run(_postfix_loop()))
+    postfix_elapsed = time.monotonic() - t0
+    assert postfix_elapsed < prefix_elapsed, (
+        f"post-fix pattern must exit faster than pre-fix (blocking) "
+        f"pattern; post={postfix_elapsed:.3f}s vs pre={prefix_elapsed:.3f}s"
+    )
+    assert (
+        len(postfix_seen) < 8
+    ), f"post-fix loop must not drain all chunks; got {len(postfix_seen)}"
+
+
+def test_unsloth_stream_loop_emits_zero_tokens_on_preset_cancel():
+    # Pending-cancel replay: _TrackedCancel.__enter__ already set
+    # cancel_event before the generator body starts iterating. The
+    # top-of-loop check must short-circuit the very first iteration so
+    # no token is emitted. Catches a regression that moves the check
+    # below `next()` -- the mid-loop test would still pass but this
+    # test would observe one extra token leak.
+    cancel_event = threading.Event()
+    cancel_event.set()
+    reset_calls = [0]
+
+    class _Backend:
+        def reset_generation_state(self):
+            reset_calls[0] += 1
+
+    backend = _Backend()
+
+    next_calls = [0]
+
+    def _generate():
+        while True:
+            next_calls[0] += 1
+            yield f"cum-{next_calls[0]}"
+
+    async def _loop():
+        _DONE = object()
+        loop = asyncio.get_event_loop()
+        gen = _generate()
+        seen = []
+        while True:
+            if cancel_event.is_set():
+                backend.reset_generation_state()
+                break
+            cumulative = await loop.run_in_executor(None, next, gen, _DONE)
+            if cumulative is _DONE:
+                break
+            seen.append(cumulative)
+        return seen
+
+    seen = asyncio.run(_loop())
+    assert seen == [], (
+        f"loop must emit zero tokens when cancel_event is pre-set "
+        f"(pending-replay path); got {seen}"
+    )
+    assert next_calls[0] == 0, (
+        f"loop must not call next() at all on pre-set cancel; got "
+        f"{next_calls[0]} calls"
+    )
+    assert reset_calls[0] == 1, (
+        f"backend.reset_generation_state() must still fire exactly once "
+        f"on pre-set cancel; got {reset_calls[0]}"
+    )
+
+
+def test_audio_stream_emits_zero_chunks_on_preset_cancel():
+    # Symmetric to the Unsloth pre-set test: the audio loop's top-of-loop
+    # cancel check must skip the asyncio.to_thread(next, ...) call when
+    # cancel_event was already set via pending-replay.
+    cancel_event = threading.Event()
+    cancel_event.set()
+
+    next_calls = [0]
+
+    def _audio_gen():
+        while True:
+            next_calls[0] += 1
+            yield f"chunk-{next_calls[0]}"
+
+    async def _loop():
+        _DONE = object()
+        gen = _audio_gen()
+        seen = []
+        while True:
+            if cancel_event.is_set():
+                break
+            chunk_text = await asyncio.to_thread(next, gen, _DONE)
+            if chunk_text is _DONE:
+                break
+            seen.append(chunk_text)
+        return seen
+
+    seen = asyncio.run(_loop())
+    assert seen == [], f"audio loop must emit zero chunks on pre-set cancel; got {seen}"
+    assert next_calls[0] == 0, (
+        f"audio loop must not call next() on pre-set cancel; got "
+        f"{next_calls[0]} calls"
+    )
diff --git a/tests/studio/test_studio_gguf_export_script_pin.py b/tests/studio/test_studio_gguf_export_script_pin.py
new file mode 100644
index 0000000000..12aaaafff4
--- /dev/null
+++ b/tests/studio/test_studio_gguf_export_script_pin.py
@@ -0,0 +1,231 @@
+"""Tests for Studio GGUF export pinning convert_hf_to_gguf.py via
+UNSLOTH_LLAMA_CPP_SCRIPTS_DIR with graceful fallback when unsloth_zoo
+lacks the local-script resolver.
+
+Verifies:
+  - export.py imports LLAMA_CPP_DEFAULT_DIR and _resolve_local_convert_script
+    from unsloth_zoo.llama_cpp inside a single try/except ImportError so a
+    zoo missing either symbol degrades to a warning instead of crashing.
+  - os.environ.setdefault("UNSLOTH_LLAMA_CPP_SCRIPTS_DIR", LLAMA_CPP_DEFAULT_DIR)
+    is called inside the try; setdefault preserves explicit user overrides
+    and assigns the default when unset.
+  - The compatibility warning is gated on a module-level flag so it fires
+    once per process rather than on every export call.
+"""
+
+from __future__ import annotations
+
+import ast
+import os
+import sys
+import types
+from pathlib import Path
+
+
+SOURCE_PATH = (
+    Path(__file__).resolve().parents[2]
+    / "studio"
+    / "backend"
+    / "core"
+    / "export"
+    / "export.py"
+)
+SRC = SOURCE_PATH.read_text()
+TREE = ast.parse(SRC)
+
+
+def _module_level_assignments(tree: ast.Module):
+    for node in tree.body:
+        if isinstance(node, ast.Assign):
+            for target in node.targets:
+                if isinstance(target, ast.Name):
+                    yield target.id, node.value
+
+
+def _find_pin_try(tree: ast.AST):
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.Try):
+            continue
+        for stmt in node.body:
+            if (
+                isinstance(stmt, ast.ImportFrom)
+                and stmt.module == "unsloth_zoo.llama_cpp"
+                and any(
+                    alias.name == "_resolve_local_convert_script"
+                    for alias in stmt.names
+                )
+            ):
+                return node
+    return None
+
+
+def test_warning_flag_defined_at_module_scope():
+    flags = {
+        name: value
+        for name, value in _module_level_assignments(TREE)
+        if name == "_LLAMA_CPP_SCRIPTS_WARNING_EMITTED"
+    }
+    assert flags, "expected module-level _LLAMA_CPP_SCRIPTS_WARNING_EMITTED flag"
+    init = flags["_LLAMA_CPP_SCRIPTS_WARNING_EMITTED"]
+    assert isinstance(init, ast.Constant) and init.value is False
+
+
+def test_constant_and_resolver_imported_in_same_try():
+    try_node = _find_pin_try(TREE)
+    assert try_node is not None
+    imported = []
+    for stmt in try_node.body:
+        if isinstance(stmt, ast.ImportFrom) and stmt.module == "unsloth_zoo.llama_cpp":
+            imported.extend(alias.name for alias in stmt.names)
+    assert "LLAMA_CPP_DEFAULT_DIR" in imported
+    assert "_resolve_local_convert_script" in imported
+
+
+def test_setdefault_inside_try_block():
+    try_node = _find_pin_try(TREE)
+    assert try_node is not None
+    setdefault_calls = []
+    for stmt in try_node.body:
+        for node in ast.walk(stmt):
+            if (
+                isinstance(node, ast.Call)
+                and isinstance(node.func, ast.Attribute)
+                and node.func.attr == "setdefault"
+                and isinstance(node.func.value, ast.Attribute)
+                and node.func.value.attr == "environ"
+                and node.args
+                and isinstance(node.args[0], ast.Constant)
+                and node.args[0].value == "UNSLOTH_LLAMA_CPP_SCRIPTS_DIR"
+            ):
+                setdefault_calls.append(node)
+    assert setdefault_calls
+    second = setdefault_calls[0].args[1]
+    assert isinstance(second, ast.Name) and second.id == "LLAMA_CPP_DEFAULT_DIR"
+
+
+def test_warning_handler_gated_on_module_flag():
+    try_node = _find_pin_try(TREE)
+    assert try_node is not None
+    handlers = [
+        h
+        for h in try_node.handlers
+        if isinstance(h.type, ast.Name) and h.type.id == "ImportError"
+    ]
+    assert handlers
+    handler = handlers[0]
+    flag_reads = []
+    flag_writes = []
+    warning_calls = []
+    for node in ast.walk(ast.Module(body = handler.body, type_ignores = [])):
+        if (
+            isinstance(node, ast.Name)
+            and node.id == "_LLAMA_CPP_SCRIPTS_WARNING_EMITTED"
+        ):
+            if isinstance(node.ctx, ast.Load):
+                flag_reads.append(node)
+            elif isinstance(node.ctx, ast.Store):
+                flag_writes.append(node)
+        elif (
+            isinstance(node, ast.Call)
+            and isinstance(node.func, ast.Attribute)
+            and node.func.attr == "warning"
+        ):
+            warning_calls.append(node)
+    assert flag_reads
+    assert flag_writes
+    assert warning_calls
+    msg = ast.dump(warning_calls[0])
+    assert "UNSLOTH_LLAMA_CPP_SCRIPTS_DIR" in msg
+    assert "unsloth_zoo" in msg
+
+
+def test_default_dir_is_string_for_setdefault_compat():
+    from unsloth_zoo.llama_cpp import LLAMA_CPP_DEFAULT_DIR
+
+    assert isinstance(LLAMA_CPP_DEFAULT_DIR, str)
+
+
+def test_setdefault_preserves_explicit_user_override(monkeypatch):
+    monkeypatch.setenv("UNSLOTH_LLAMA_CPP_SCRIPTS_DIR", "/explicit/override")
+    from unsloth_zoo.llama_cpp import LLAMA_CPP_DEFAULT_DIR
+
+    os.environ.setdefault("UNSLOTH_LLAMA_CPP_SCRIPTS_DIR", LLAMA_CPP_DEFAULT_DIR)
+    assert os.environ["UNSLOTH_LLAMA_CPP_SCRIPTS_DIR"] == "/explicit/override"
+
+
+def test_setdefault_assigns_default_when_unset(monkeypatch):
+    monkeypatch.delenv("UNSLOTH_LLAMA_CPP_SCRIPTS_DIR", raising = False)
+    from unsloth_zoo.llama_cpp import LLAMA_CPP_DEFAULT_DIR
+
+    os.environ.setdefault("UNSLOTH_LLAMA_CPP_SCRIPTS_DIR", LLAMA_CPP_DEFAULT_DIR)
+    assert os.environ["UNSLOTH_LLAMA_CPP_SCRIPTS_DIR"] == LLAMA_CPP_DEFAULT_DIR
+
+
+def _simulate_pin_block(emit_records, set_value):
+    fake = types.ModuleType("unsloth_zoo.llama_cpp")
+    if set_value is not None:
+        fake.LLAMA_CPP_DEFAULT_DIR = set_value
+    sys.modules["unsloth_zoo.llama_cpp"] = fake
+
+    state = {"emitted": False}
+
+    def run_once():
+        try:
+            from unsloth_zoo.llama_cpp import (
+                LLAMA_CPP_DEFAULT_DIR,
+                _resolve_local_convert_script,  # noqa: F401
+            )
+
+            os.environ.setdefault(
+                "UNSLOTH_LLAMA_CPP_SCRIPTS_DIR", LLAMA_CPP_DEFAULT_DIR
+            )
+        except ImportError:
+            if not state["emitted"]:
+                emit_records.append("warned")
+                state["emitted"] = True
+
+    return run_once
+
+
+def test_warning_fires_at_most_once_across_calls(monkeypatch):
+    monkeypatch.delenv("UNSLOTH_LLAMA_CPP_SCRIPTS_DIR", raising = False)
+    emits = []
+    runner = _simulate_pin_block(emits, set_value = "/fake/default")
+    runner()
+    runner()
+    runner()
+    assert emits == ["warned"]
+
+
+def test_missing_default_dir_degrades_to_warning(monkeypatch):
+    monkeypatch.delenv("UNSLOTH_LLAMA_CPP_SCRIPTS_DIR", raising = False)
+    emits = []
+    runner = _simulate_pin_block(emits, set_value = None)
+    runner()
+    assert emits == ["warned"]
+    assert "UNSLOTH_LLAMA_CPP_SCRIPTS_DIR" not in os.environ
+
+
+def test_no_warning_when_both_symbols_present(monkeypatch):
+    monkeypatch.delenv("UNSLOTH_LLAMA_CPP_SCRIPTS_DIR", raising = False)
+    fake = types.ModuleType("unsloth_zoo.llama_cpp")
+    fake.LLAMA_CPP_DEFAULT_DIR = "/fake/dir"
+    fake._resolve_local_convert_script = lambda: None
+    monkeypatch.setitem(sys.modules, "unsloth_zoo.llama_cpp", fake)
+
+    emits = []
+    state = {"emitted": False}
+    try:
+        from unsloth_zoo.llama_cpp import (
+            LLAMA_CPP_DEFAULT_DIR,
+            _resolve_local_convert_script,  # noqa: F401
+        )
+
+        os.environ.setdefault("UNSLOTH_LLAMA_CPP_SCRIPTS_DIR", LLAMA_CPP_DEFAULT_DIR)
+    except ImportError:
+        if not state["emitted"]:
+            emits.append("warned")
+            state["emitted"] = True
+
+    assert emits == []
+    assert os.environ.get("UNSLOTH_LLAMA_CPP_SCRIPTS_DIR") == "/fake/dir"
diff --git a/tests/studio/test_studio_text_descender_clipping.py b/tests/studio/test_studio_text_descender_clipping.py
new file mode 100644
index 0000000000..dd0df320bc
--- /dev/null
+++ b/tests/studio/test_studio_text_descender_clipping.py
@@ -0,0 +1,69 @@
+"""
+Regression guard: descender-prone text spans in Studio must not pair
+`leading-none` with `truncate` (overflow: hidden), which clips glyph
+descenders (g, p, q, y, j) in real user-visible labels.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+
+WORKDIR = Path(__file__).resolve().parents[2]
+MODEL_SELECTOR = (
+    WORKDIR
+    / "studio"
+    / "frontend"
+    / "src"
+    / "components"
+    / "assistant-ui"
+    / "model-selector.tsx"
+)
+APP_SIDEBAR = WORKDIR / "studio" / "frontend" / "src" / "components" / "app-sidebar.tsx"
+
+
+def _read(path: Path) -> str:
+    assert path.exists(), f"missing source file: {path}"
+    return path.read_text()
+
+
+def test_model_selector_trigger_label_uses_leading_tight():
+    src = _read(MODEL_SELECTOR)
+    pattern = re.compile(
+        r'<span\s+className="[^"]*\bmin-w-0\b[^"]*\bflex-1\b[^"]*\btruncate\b[^"]*\bfont-heading\b[^"]*\btext-\[16px\][^"]*"',
+    )
+    matches = pattern.findall(src)
+    assert matches, "could not find ModelSelectorTrigger model-name span"
+    for cls in matches:
+        assert "leading-tight" in cls, f"expected leading-tight, got: {cls}"
+        assert (
+            "leading-none" not in cls
+        ), f"leading-none must not coexist with truncate here: {cls}"
+
+
+def test_sidebar_account_block_uses_leading_tight():
+    src = _read(APP_SIDEBAR)
+    pattern = re.compile(
+        r'<div\s+className="flex\s+flex-col\s+gap-0\.5\s+(\S+)\s+group-data-\[collapsible=icon\]:hidden">',
+    )
+    matches = pattern.findall(src)
+    assert matches, "could not find sidebar account-block parent div"
+    leading_classes = [m for m in matches if m.startswith("leading-")]
+    assert (
+        leading_classes
+    ), f"no leading-* class on sidebar account-block parent: {matches}"
+    for cls in leading_classes:
+        assert (
+            cls == "leading-tight"
+        ), f"sidebar account-block must use leading-tight, got: {cls}"
+
+
+def test_no_truncate_plus_leading_none_in_changed_files():
+    for path in (MODEL_SELECTOR, APP_SIDEBAR):
+        src = _read(path)
+        for line in src.splitlines():
+            if "truncate" in line and "leading-none" in line:
+                raise AssertionError(
+                    f"{path.name}: same line uses truncate + leading-none, descenders will clip: {line.strip()}"
+                )
diff --git a/tests/test_peft_weight_converter_compat.py b/tests/test_peft_weight_converter_compat.py
new file mode 100644
index 0000000000..62f17f0f45
--- /dev/null
+++ b/tests/test_peft_weight_converter_compat.py
@@ -0,0 +1,259 @@
+import importlib.util
+import inspect
+import sys
+import threading
+import types
+from pathlib import Path
+
+import pytest
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+IMPORT_FIXES = REPO_ROOT / "unsloth" / "import_fixes.py"
+
+
+def _load_patch_function():
+    spec = importlib.util.spec_from_file_location(
+        "_unsloth_import_fixes_under_test", IMPORT_FIXES
+    )
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module.patch_peft_weight_converter_compatibility
+
+
+def _install_fake_peft(twc_namespace):
+    peft_pkg = types.ModuleType("peft")
+    peft_pkg.__path__ = []
+    peft_utils = types.ModuleType("peft.utils")
+    peft_utils.__path__ = []
+    twc = types.ModuleType("peft.utils.transformers_weight_conversion")
+    for k, v in twc_namespace.items():
+        setattr(twc, k, v)
+    peft_utils.transformers_weight_conversion = twc
+    sys.modules["peft"] = peft_pkg
+    sys.modules["peft.utils"] = peft_utils
+    sys.modules["peft.utils.transformers_weight_conversion"] = twc
+    return twc
+
+
+@pytest.fixture(autouse = True)
+def _restore_peft_modules():
+    saved = {
+        k: sys.modules.get(k)
+        for k in (
+            "peft",
+            "peft.utils",
+            "peft.utils.transformers_weight_conversion",
+        )
+    }
+    yield
+    for k, v in saved.items():
+        if v is None:
+            sys.modules.pop(k, None)
+        else:
+            sys.modules[k] = v
+
+
+class _LegacyConverter:
+    def __init__(self, source_patterns, target_patterns, operations):
+        self.source_patterns = source_patterns
+        self.target_patterns = target_patterns
+        self.operations = operations
+        self.distributed_operation = None
+        self.quantization_operation = None
+
+
+class _ModernConverter:
+    def __init__(
+        self,
+        source_patterns,
+        target_patterns,
+        operations,
+        distributed_operation = None,
+        quantization_operation = None,
+    ):
+        self.source_patterns = source_patterns
+        self.target_patterns = target_patterns
+        self.operations = operations
+        self.distributed_operation = distributed_operation
+        self.quantization_operation = quantization_operation
+
+
+def _make_legacy_converter():
+    return _LegacyConverter(["src.*"], ["tgt.*"], [])
+
+
+def _make_modern_converter():
+    return _ModernConverter(["src.*"], ["tgt.*"], [])
+
+
+def _build_that_calls_init(weight_conversions, adapter_name, peft_config = None):
+    out = []
+    for c in weight_conversions or []:
+        out.append(
+            c.__class__(
+                source_patterns = c.source_patterns,
+                target_patterns = c.target_patterns,
+                operations = c.operations,
+                distributed_operation = "dist-x",
+                quantization_operation = "quant-y",
+            )
+        )
+    return out
+
+
+def test_two_arg_call_preserves_upstream_signature():
+    twc = _install_fake_peft({"build_peft_weight_mapping": _build_that_calls_init})
+    patch = _load_patch_function()
+    patch()
+
+    sig = inspect.signature(twc.build_peft_weight_mapping)
+    assert "peft_config" in sig.parameters
+    assert sig.parameters["peft_config"].default is None
+
+    out = twc.build_peft_weight_mapping([_make_legacy_converter()], "default")
+    assert len(out) == 1
+    assert out[0].distributed_operation == "dist-x"
+    assert out[0].quantization_operation == "quant-y"
+
+
+def test_legacy_init_succeeds_after_patch():
+    twc = _install_fake_peft({"build_peft_weight_mapping": _build_that_calls_init})
+    patch = _load_patch_function()
+    patch()
+
+    out = twc.build_peft_weight_mapping([_make_legacy_converter()], "default", None)
+    assert len(out) == 1
+    assert out[0].distributed_operation == "dist-x"
+    assert out[0].quantization_operation == "quant-y"
+
+
+def test_modern_init_not_patched():
+    twc = _install_fake_peft({"build_peft_weight_mapping": _build_that_calls_init})
+    pre_init = _ModernConverter.__init__
+    patch = _load_patch_function()
+    patch()
+
+    twc.build_peft_weight_mapping([_make_modern_converter()], "default", None)
+    assert _ModernConverter.__init__ is pre_init
+
+
+def test_class_init_restored_after_call():
+    twc = _install_fake_peft({"build_peft_weight_mapping": _build_that_calls_init})
+    pre_init = _LegacyConverter.__init__
+    patch = _load_patch_function()
+    patch()
+
+    twc.build_peft_weight_mapping([_make_legacy_converter()], "default", None)
+    assert _LegacyConverter.__init__ is pre_init
+
+
+def test_class_init_restored_after_original_build_raises():
+    def _raise(weight_conversions, adapter_name, peft_config = None):
+        raise RuntimeError("simulated PEFT failure")
+
+    twc = _install_fake_peft({"build_peft_weight_mapping": _raise})
+    pre_init = _LegacyConverter.__init__
+    patch = _load_patch_function()
+    patch()
+
+    with pytest.raises(RuntimeError):
+        twc.build_peft_weight_mapping([_make_legacy_converter()], "default", None)
+    assert _LegacyConverter.__init__ is pre_init
+
+
+def test_partial_patch_restored_when_inspect_signature_raises_mid_loop():
+    twc = _install_fake_peft({"build_peft_weight_mapping": _build_that_calls_init})
+    pre_legacy = _LegacyConverter.__init__
+
+    class _BadInitConverter:
+        def __init__(self, source_patterns, target_patterns, operations):
+            self.source_patterns = source_patterns
+            self.target_patterns = target_patterns
+            self.operations = operations
+
+    pre_bad = _BadInitConverter.__init__
+    patch = _load_patch_function()
+    patch()
+
+    real_signature = inspect.signature
+
+    def _fake_signature(callable_):
+        if callable_ is _BadInitConverter.__init__:
+            raise ValueError("inspect.signature failed mid-loop")
+        return real_signature(callable_)
+
+    inspect.signature = _fake_signature
+    try:
+        legacy = _LegacyConverter(["src.*"], ["tgt.*"], [])
+        bad = _BadInitConverter.__new__(_BadInitConverter)
+        bad.source_patterns = ["src.*"]
+        bad.target_patterns = ["tgt.*"]
+        bad.operations = []
+        with pytest.raises(ValueError):
+            twc.build_peft_weight_mapping([legacy, bad], "default", None)
+    finally:
+        inspect.signature = real_signature
+
+    assert _LegacyConverter.__init__ is pre_legacy
+    assert _BadInitConverter.__init__ is pre_bad
+
+
+def test_idempotent_install_does_not_double_wrap():
+    twc = _install_fake_peft({"build_peft_weight_mapping": _build_that_calls_init})
+    patch = _load_patch_function()
+    patch()
+    first_wrapped = twc.build_peft_weight_mapping
+    patch()
+    assert twc.build_peft_weight_mapping is first_wrapped
+
+
+def test_concurrent_legacy_calls_no_typeerror():
+    import time
+
+    def _slow_build(weight_conversions, adapter_name, peft_config = None):
+        time.sleep(0.05)
+        return _build_that_calls_init(weight_conversions, adapter_name, peft_config)
+
+    twc = _install_fake_peft({"build_peft_weight_mapping": _slow_build})
+    patch = _load_patch_function()
+    patch()
+
+    errors = []
+    results = []
+    start = threading.Event()
+
+    def _worker():
+        start.wait(timeout = 10)
+        try:
+            out = twc.build_peft_weight_mapping(
+                [_make_legacy_converter()], "default", None
+            )
+            results.append(out)
+        except Exception as e:
+            errors.append(e)
+
+    threads = [threading.Thread(target = _worker) for _ in range(8)]
+    for t in threads:
+        t.start()
+    start.set()
+    for t in threads:
+        t.join(timeout = 15)
+
+    assert errors == []
+    assert len(results) == 8
+    for out in results:
+        assert out[0].distributed_operation == "dist-x"
+        assert out[0].quantization_operation == "quant-y"
+    assert _LegacyConverter.__init__.__qualname__.startswith("_LegacyConverter")
+
+
+def test_empty_conversions_short_circuits_without_patching():
+    twc = _install_fake_peft({"build_peft_weight_mapping": _build_that_calls_init})
+    pre_init = _LegacyConverter.__init__
+    patch = _load_patch_function()
+    patch()
+
+    out = twc.build_peft_weight_mapping([], "default", None)
+    assert out == []
+    assert _LegacyConverter.__init__ is pre_init
diff --git a/tests/test_resolve_model_class.py b/tests/test_resolve_model_class.py
new file mode 100644
index 0000000000..5ec2a21a07
--- /dev/null
+++ b/tests/test_resolve_model_class.py
@@ -0,0 +1,137 @@
+from unsloth.models._utils import resolve_model_class
+
+
+class _AutoModelLike:
+    def __init__(self, mapping):
+        self._model_mapping = mapping
+
+
+class _FakeLazyMapping:
+    def __init__(self, entries, extra_content = None, broken_keys = ()):
+        self._entries = dict(entries)
+        self._config_mapping = {k: f"Cfg_{k}" for k in self._entries}
+        self._model_mapping = {k: f"Mdl_{k}" for k in self._entries}
+        self._extra_content = dict(extra_content or {})
+        self._broken_keys = set(broken_keys)
+
+    def __getitem__(self, key):
+        if key in self._extra_content:
+            return self._extra_content[key]
+        for k, (cfg_cls, mdl_cls) in self._entries.items():
+            if k in self._broken_keys:
+                raise ValueError(f"broken entry {k}")
+            if cfg_cls is key:
+                return mdl_cls
+        raise KeyError(key)
+
+    def _load_attr_from_module(self, key, attr):
+        if key in self._broken_keys:
+            raise ValueError(f"broken entry {key}")
+        cfg_cls, mdl_cls = self._entries[key]
+        if attr == self._config_mapping[key]:
+            return cfg_cls
+        if attr == self._model_mapping[key]:
+            return mdl_cls
+        raise KeyError(attr)
+
+
+class CfgA:
+    pass
+
+
+class CfgB:
+    pass
+
+
+class CfgBChild(CfgB):
+    pass
+
+
+class ModelA:
+    pass
+
+
+class ModelB:
+    pass
+
+
+class RegBase:
+    pass
+
+
+class RegChild(RegBase):
+    pass
+
+
+class RegModel:
+    pass
+
+
+class UnknownCfg:
+    pass
+
+
+def test_fast_path_exact_match():
+    m = _FakeLazyMapping({"a": (CfgA, ModelA), "b": (CfgB, ModelB)})
+    am = _AutoModelLike(m)
+    assert resolve_model_class(am, CfgA()) is ModelA
+
+
+def test_fallback_subclass_match_via_lazy_mapping():
+    m = _FakeLazyMapping({"a": (CfgA, ModelA), "b": (CfgB, ModelB)})
+    am = _AutoModelLike(m)
+    assert resolve_model_class(am, CfgBChild()) is ModelB
+
+
+def test_broken_lazy_entry_does_not_crash():
+    m = _FakeLazyMapping(
+        {"broken": (CfgA, ModelA), "b": (CfgB, ModelB)},
+        broken_keys = ("broken",),
+    )
+    am = _AutoModelLike(m)
+    assert resolve_model_class(am, CfgBChild()) is ModelB
+
+
+def test_unknown_config_returns_none():
+    m = _FakeLazyMapping({"a": (CfgA, ModelA)})
+    am = _AutoModelLike(m)
+    assert resolve_model_class(am, UnknownCfg()) is None
+
+
+def test_extra_content_subclass_fallback():
+    m = _FakeLazyMapping(
+        {"a": (CfgA, ModelA)},
+        extra_content = {RegBase: RegModel},
+    )
+    am = _AutoModelLike(m)
+    assert resolve_model_class(am, RegChild()) is RegModel
+
+
+def test_extra_content_exact_match_fast_path():
+    m = _FakeLazyMapping(
+        {"a": (CfgA, ModelA)},
+        extra_content = {RegBase: RegModel},
+    )
+    am = _AutoModelLike(m)
+    assert resolve_model_class(am, RegBase()) is RegModel
+
+
+def test_broken_entry_with_extra_content_subclass():
+    m = _FakeLazyMapping(
+        {"broken": (CfgA, ModelA)},
+        extra_content = {RegBase: RegModel},
+        broken_keys = ("broken",),
+    )
+    am = _AutoModelLike(m)
+    assert resolve_model_class(am, RegChild()) is RegModel
+
+
+def test_plain_dict_mapping_is_not_required():
+    am = _AutoModelLike({CfgA: ModelA})
+    assert resolve_model_class(am, CfgA()) is ModelA
+
+
+def test_tuple_result_unwrapped():
+    m = _FakeLazyMapping({"a": (CfgA, (ModelA, "extra"))})
+    am = _AutoModelLike(m)
+    assert resolve_model_class(am, CfgA()) is ModelA
diff --git a/unsloth/__init__.py b/unsloth/__init__.py
index 52114bb544..9db9ae0a32 100644
--- a/unsloth/__init__.py
+++ b/unsloth/__init__.py
@@ -153,6 +153,7 @@ from .import_fixes import (
     patch_torchcodec_audio_decoder,
     disable_torchcodec_if_broken,
     disable_broken_wandb,
+    patch_peft_weight_converter_compatibility,
 )
 
 fix_xformers_performance_issue()
@@ -176,6 +177,7 @@ patch_vllm_for_notebooks()
 patch_torchcodec_audio_decoder()
 disable_torchcodec_if_broken()
 disable_broken_wandb()
+patch_peft_weight_converter_compatibility()
 
 del fix_xformers_performance_issue
 del fix_vllm_aimv2_issue
@@ -197,6 +199,7 @@ del patch_vllm_for_notebooks
 del patch_torchcodec_audio_decoder
 del disable_torchcodec_if_broken
 del disable_broken_wandb
+del patch_peft_weight_converter_compatibility
 
 # Torch 2.4 has including_emulation
 if DEVICE_TYPE == "cuda":
diff --git a/unsloth/import_fixes.py b/unsloth/import_fixes.py
index 6cebad7939..f1fba0ce91 100644
--- a/unsloth/import_fixes.py
+++ b/unsloth/import_fixes.py
@@ -25,6 +25,7 @@ import textwrap
 import warnings
 import sys
 import functools
+import inspect
 
 # We cannot do from unsloth_zoo.log import logger since FBGEMM might cause seg faults.
 UNSLOTH_ENABLE_LOGGING = os.environ.get("UNSLOTH_ENABLE_LOGGING", "0") in (
@@ -1371,6 +1372,88 @@ def disable_broken_wandb():
         os.environ["WANDB_DISABLED"] = "true"
 
 
+def patch_peft_weight_converter_compatibility():
+    """Allow PEFT converter rebuilds on legacy converter constructors."""
+    try:
+        from peft.utils import transformers_weight_conversion as twc
+    except (ImportError, AttributeError):
+        return
+
+    if getattr(twc, "_unsloth_weight_converter_compat_patch", False):
+        return
+
+    import threading
+
+    original_build = twc.build_peft_weight_mapping
+    patch_lock = threading.RLock()
+
+    def _patch_weight_converter_ctors(weight_conversions, patched):
+        seen_classes = set()
+
+        for conversion in weight_conversions:
+            conversion_cls = conversion.__class__
+            if conversion_cls in seen_classes:
+                continue
+            seen_classes.add(conversion_cls)
+
+            original_init = conversion_cls.__init__
+            params = inspect.signature(original_init).parameters
+            supports_kwargs = any(
+                p.kind == inspect.Parameter.VAR_KEYWORD for p in params.values()
+            )
+            supports_distributed = "distributed_operation" in params
+            supports_quantization = "quantization_operation" in params
+            if supports_kwargs or (supports_distributed and supports_quantization):
+                continue
+
+            def _compat_init(
+                self,
+                *args,
+                __original_init = original_init,
+                __supports_distributed = supports_distributed,
+                __supports_quantization = supports_quantization,
+                **kwargs,
+            ):
+                unsupported = {}
+                if not __supports_distributed and "distributed_operation" in kwargs:
+                    unsupported["distributed_operation"] = kwargs.pop(
+                        "distributed_operation"
+                    )
+                if not __supports_quantization and "quantization_operation" in kwargs:
+                    unsupported["quantization_operation"] = kwargs.pop(
+                        "quantization_operation"
+                    )
+                result = __original_init(self, *args, **kwargs)
+                for name, value in unsupported.items():
+                    if hasattr(self, name):
+                        setattr(self, name, value)
+                return result
+
+            conversion_cls.__init__ = _compat_init
+            patched.append((conversion_cls, original_init))
+
+    @functools.wraps(original_build)
+    def _build_peft_weight_mapping_compat(
+        weight_conversions,
+        adapter_name,
+        peft_config = None,
+    ):
+        if not weight_conversions:
+            return original_build(weight_conversions, adapter_name, peft_config)
+
+        patched_classes = []
+        with patch_lock:
+            try:
+                _patch_weight_converter_ctors(weight_conversions, patched_classes)
+                return original_build(weight_conversions, adapter_name, peft_config)
+            finally:
+                for conversion_cls, original_init in patched_classes:
+                    conversion_cls.__init__ = original_init
+
+    twc.build_peft_weight_mapping = _build_peft_weight_mapping_compat
+    twc._unsloth_weight_converter_compat_patch = True
+
+
 CAUSAL_CONV1D_BROKEN = False
 _CAUSAL_CONV1D_PREFIX = "causal_conv1d"
 _CAUSAL_CONV1D_BLOCKER_SENTINEL = "_unsloth_causal_conv1d_blocker"
diff --git a/unsloth/kernels/fp8.py b/unsloth/kernels/fp8.py
index a57f4ffb64..f704d4e3c4 100644
--- a/unsloth/kernels/fp8.py
+++ b/unsloth/kernels/fp8.py
@@ -432,13 +432,14 @@ class FbgemmFp8Linear_matmul(torch.autograd.Function):
         elif (
             weight.shape[0] != weight_scale.shape[0]
             and weight.shape[1] == weight_scale.shape[0]
-        ) or (weight.shape[0] // 8 != 0 or weight.shape[1] // 8 != 0):
+        ) or (weight.shape[0] % 8 != 0 or weight.shape[1] % 8 != 0):
             # Either the weight/scale is transposed or its shape is not divisible by 8. Both cases, dequantizing is the preferred way.
             # The transpose case is generally noticed in backward pass when we do dY@W instead of @W.T as we do for forward.
             # The shape case, I noticed to happen in MLP of Qwen 2.5 VL 7B where the gate proj is of shape (3420, 1280) and 3420/8=427.5
 
             W_deq = weight_dequant(weight, weight_scale).T
             output = torch_matmul(x, W_deq)
+            output = output + bias if bias is not None else output
             del W_deq
         else:
             raise ValueError(
diff --git a/unsloth/models/_utils.py b/unsloth/models/_utils.py
index 8b8dec3d3e..1120e1941d 100644
--- a/unsloth/models/_utils.py
+++ b/unsloth/models/_utils.py
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__version__ = "2026.4.8"
+__version__ = "2026.5.1"
 
 __all__ = [
     "SUPPORTS_BFLOAT16",
@@ -415,13 +415,31 @@ def resolve_model_class(auto_model, config):
     try:
         result = mapping[config.__class__]
     except Exception:
-        for config_class, model_class in mapping.items():
-            if isinstance(config, config_class):
-                result = model_class
-                break
-        else:
+        result = None
+        for key in list(getattr(mapping, "_model_mapping", {})):
+            try:
+                config_class = mapping._load_attr_from_module(
+                    key, mapping._config_mapping[key]
+                )
+                if isinstance(config, config_class):
+                    result = mapping._load_attr_from_module(
+                        key, mapping._model_mapping[key]
+                    )
+                    break
+            except Exception:
+                continue
+        if result is None:
+            for extra_cls, extra_model in getattr(
+                mapping, "_extra_content", {}
+            ).items():
+                try:
+                    if isinstance(config, extra_cls):
+                        result = extra_model
+                        break
+                except Exception:
+                    continue
+        if result is None:
             return None
-
     return result[0] if isinstance(result, (list, tuple)) else result
 
 
diff --git a/unsloth/models/rl_replacements.py b/unsloth/models/rl_replacements.py
index 4d36af62cc..0f10847282 100755
--- a/unsloth/models/rl_replacements.py
+++ b/unsloth/models/rl_replacements.py
@@ -30,6 +30,8 @@ from unsloth_zoo.rl_replacements import (
     RL_REPLACEMENTS,
     left_pack_padding,
     chunked_selective_log_softmax,
+    _unsloth_get_mm_token_id,
+    _unsloth_fix_mm_token_type_ids,
 )
 from unsloth_zoo.utils import Version
 from trl import __version__ as trl_version_raw
@@ -55,6 +57,12 @@ RL_CONFIG_CHANGES = defaultdict(list)
 RL_METRICS_CHANGES = defaultdict(list)
 RL_ADDITIONAL_FUNCTIONS = defaultdict(list)
 
+_DPO_VISION_KEYS = (
+    "pixel_position_ids",
+    "image_position_ids",
+    "mm_token_type_ids",
+)
+
 torch_compile_options = {
     "epilogue_fusion": True,
     "max_autotune": False,  # I saw speedups, but not sure if this has issues in collab
@@ -120,6 +128,272 @@ def dpo_trainer_fix_columns(call_args, extra_args):
 RL_EXTRA_ARGS["dpo_trainer"].append(dpo_trainer_fix_columns)
 
 
+def dpo_trainer_fix_data_collator(call_args, extra_args):
+    if (
+        "data_collator" in call_args
+        and "train_dataset" in call_args
+        and "processing_class" in call_args
+    ):
+        fix_collator = (
+            "if hasattr(train_dataset, 'column_names'):\n"
+            "    column_names = set(train_dataset.column_names)\n"
+            "    is_dpo_dataset = ({'chosen', 'rejected'}.issubset(column_names) or\n"
+            "                      {'prompt_input_ids', 'chosen_input_ids', 'rejected_input_ids'}.issubset(column_names))\n"
+            "    if is_dpo_dataset and isinstance(data_collator, TransformersDataCollatorForLanguageModeling):\n"
+            "        data_collator = None\n"
+            "    del is_dpo_dataset, column_names\n"
+        )
+        return fix_collator
+    return ""
+
+
+RL_EXTRA_ARGS["dpo_trainer"].append(dpo_trainer_fix_data_collator)
+
+
+def dpo_trainer_vision_process_row(
+    features,
+    processing_class,
+    max_prompt_length = None,
+    max_completion_length = None,
+    add_special_tokens = True,
+    is_chat = False,
+):
+    text = features.get("prompt", "")
+    images = features.get("images")
+    processor, tokenizer = processing_class, processing_class.tokenizer
+    processed_features = processor(
+        images = images,
+        text = text,
+        add_special_tokens = False,
+    )
+
+    prompt_input_ids = processed_features["input_ids"][0]
+    chosen_input_ids = tokenizer(features["chosen"], add_special_tokens = False)[
+        "input_ids"
+    ]
+    rejected_input_ids = tokenizer(features["rejected"], add_special_tokens = False)[
+        "input_ids"
+    ]
+
+    if add_special_tokens:
+        if tokenizer.bos_token_id is not None:
+            prompt_input_ids = [tokenizer.bos_token_id] + prompt_input_ids
+        if tokenizer.eos_token_id is not None:
+            prompt_input_ids = prompt_input_ids + [tokenizer.eos_token_id]
+    if not is_chat and tokenizer.eos_token_id is not None:
+        chosen_input_ids = chosen_input_ids + [tokenizer.eos_token_id]
+        rejected_input_ids = rejected_input_ids + [tokenizer.eos_token_id]
+
+    if max_prompt_length is not None:
+        prompt_input_ids = prompt_input_ids[-max_prompt_length:]
+    if max_completion_length is not None:
+        chosen_input_ids = chosen_input_ids[:max_completion_length]
+        rejected_input_ids = rejected_input_ids[:max_completion_length]
+
+    output = {
+        "prompt_input_ids": prompt_input_ids,
+        "chosen_input_ids": chosen_input_ids,
+        "rejected_input_ids": rejected_input_ids,
+    }
+    if "pixel_values" in processed_features:
+        output["pixel_values"] = processed_features["pixel_values"][0]
+    if "pixel_attention_mask" in processed_features:
+        output["pixel_attention_mask"] = processed_features["pixel_attention_mask"][0]
+    if "image_sizes" in processed_features:
+        output["image_sizes"] = processed_features["image_sizes"][0]
+    if "token_type_ids" in processed_features:
+        token_type_ids = processed_features["token_type_ids"][0]
+        if max_prompt_length is not None:
+            token_type_ids = token_type_ids[-max_prompt_length:]
+        output["token_type_ids"] = token_type_ids
+    if "pixel_position_ids" in processed_features:
+        output["pixel_position_ids"] = processed_features["pixel_position_ids"][0]
+    if "image_position_ids" in processed_features:
+        output["image_position_ids"] = processed_features["image_position_ids"][0]
+    if "mm_token_type_ids" in processed_features:
+        mm_token_type_ids = processed_features["mm_token_type_ids"][0]
+        if max_prompt_length is not None:
+            mm_token_type_ids = mm_token_type_ids[-max_prompt_length:]
+        output["mm_token_type_ids"] = mm_token_type_ids
+
+    return output
+
+
+def dpo_trainer_vision_signature_columns(function_name, function):
+    if function_name != "_set_signature_columns_if_needed":
+        return function
+
+    if all(_k in function for _k in _DPO_VISION_KEYS):
+        return function
+
+    _extra_columns = "".join(f'                "{_k}",\n' for _k in _DPO_VISION_KEYS)
+    new_function = function.replace(
+        '                "image_sizes",\n' '                "token_type_ids",\n',
+        f'                "image_sizes",\n'
+        f"{_extra_columns}"
+        f'                "token_type_ids",\n',
+    )
+    if new_function != function:
+        return new_function
+    return function.replace(
+        '                "image_sizes",\n' '                "ref_chosen_logps",\n',
+        f'                "image_sizes",\n'
+        f"{_extra_columns}"
+        f'                "ref_chosen_logps",\n',
+    )
+
+
+def dpo_trainer_concatenated_inputs(function_name, function):
+    if function_name != "concatenated_inputs":
+        return function
+
+    if all(_k in function for _k in _DPO_VISION_KEYS):
+        return function
+
+    _extra_inputs = "".join(
+        f'        if "{_k}" in batch:\n'
+        f'            output["{_k}"] = torch.cat((batch["{_k}"], batch["{_k}"]), dim=0)\n'
+        for _k in _DPO_VISION_KEYS
+    )
+
+    image_sizes_block = (
+        '        if "image_sizes" in batch:\n'
+        '            output["image_sizes"] = torch.cat([batch["image_sizes"], batch["image_sizes"]], dim=0)\n'
+    )
+    new_function = function.replace(
+        image_sizes_block + '        if "token_type_ids" in batch:\n',
+        image_sizes_block + _extra_inputs + '        if "token_type_ids" in batch:\n',
+    )
+    if new_function != function:
+        return new_function
+    if image_sizes_block in function:
+        return function.replace(image_sizes_block, image_sizes_block + _extra_inputs, 1)
+    return function
+
+
+def _dpo_trainer_extend_vision_model_kwargs(function):
+    if all(_k in function for _k in _DPO_VISION_KEYS):
+        return function
+
+    _extra_forward = "".join(
+        f'        if "{_k}" in concatenated_batch:\n'
+        f'            model_kwargs["{_k}"] = concatenated_batch["{_k}"]\n'
+        for _k in (
+            "pixel_values",
+            "pixel_attention_mask",
+            "image_sizes",
+            *_DPO_VISION_KEYS,
+        )
+    )
+
+    return function.replace(
+        '        if "pixel_values" in concatenated_batch:\n'
+        '            model_kwargs["pixel_values"] = concatenated_batch["pixel_values"]\n'
+        '        if "pixel_attention_mask" in concatenated_batch:\n'
+        '            model_kwargs["pixel_attention_mask"] = concatenated_batch["pixel_attention_mask"]\n'
+        '        if "image_sizes" in concatenated_batch:\n'
+        '            model_kwargs["image_sizes"] = concatenated_batch["image_sizes"]\n',
+        f"{_extra_forward}",
+    )
+
+
+def dpo_trainer_concatenated_forward(function_name, function):
+    if function_name != "concatenated_forward":
+        return function
+    return _dpo_trainer_extend_vision_model_kwargs(function)
+
+
+def dpo_trainer_compute_loss_liger(function_name, function):
+    if function_name != "_compute_loss_liger":
+        return function
+    return _dpo_trainer_extend_vision_model_kwargs(function)
+
+
+def dpo_trainer_data_collator_vision_keys(call_args, extra_args):
+    if "data_collator" not in call_args:
+        return ""
+
+    _vision_keys = str(_DPO_VISION_KEYS)
+    return (
+        "from trl.trainer.dpo_trainer import DataCollatorForPreference\n"
+        "if not hasattr(DataCollatorForPreference, '_unsloth_vision_keys_patch'):\n"
+        "    _old_dpo_collator_torch_call = DataCollatorForPreference.torch_call\n"
+        "\n"
+        "    def _unsloth_dpo_torch_call(self, examples):\n"
+        "        output = _old_dpo_collator_torch_call(self, examples)\n"
+        "        import torch as _unsloth_torch\n"
+        "        try:\n"
+        "            from trl.trainer.utils import pad as _unsloth_trl_pad\n"
+        "        except Exception:\n"
+        "            _unsloth_trl_pad = None\n"
+        "        for _k in " + _vision_keys + ":\n"
+        "            if not all(_k in example for example in examples):\n"
+        "                continue\n"
+        "            _is_position_key = _k.endswith('position_ids')\n"
+        "            _padding_value = -1 if _is_position_key else 0\n"
+        "            _padding_side = 'right' if _is_position_key else 'left'\n"
+        "            _values = [_unsloth_torch.as_tensor(example[_k]) for example in examples]\n"
+        "            try:\n"
+        "                if _unsloth_trl_pad is not None:\n"
+        "                    output[_k] = _unsloth_trl_pad(_values, padding_value=_padding_value, padding_side=_padding_side)\n"
+        "                else:\n"
+        "                    from torch.nn.utils.rnn import pad_sequence as _unsloth_pad_sequence\n"
+        "                    output[_k] = _unsloth_pad_sequence(_values, batch_first=True, padding_value=_padding_value)\n"
+        "            except Exception:\n"
+        "                from torch.nn.utils.rnn import pad_sequence as _unsloth_pad_sequence\n"
+        "                output[_k] = _unsloth_pad_sequence(_values, batch_first=True, padding_value=_padding_value)\n"
+        "        return output\n"
+        "\n"
+        "    DataCollatorForPreference.torch_call = _unsloth_dpo_torch_call\n"
+        "    DataCollatorForPreference._unsloth_vision_keys_patch = True\n"
+    )
+
+
+def dpo_trainer_prepare_dataset(function_name, function):
+    if function_name != "_prepare_dataset":
+        return function
+
+    legacy_call = "self.tokenize_row if not self.is_vision_model else self.process_row"
+    if legacy_call not in function:
+        return function
+
+    function = function.replace(
+        legacy_call,
+        "self.tokenize_row if not self.is_vision_model else dpo_trainer_vision_process_row",
+    )
+
+    legacy_tokenize_block = (
+        "            # Tokenize the dataset\n"
+        "            if isinstance(dataset, Dataset):  # `IterableDataset.map` does not support `desc`\n"
+        '                map_kwargs["desc"] = f"Tokenizing {dataset_name} dataset"\n'
+        "\n"
+        "            dataset = dataset.map(\n"
+        "                self.tokenize_row if not self.is_vision_model else dpo_trainer_vision_process_row,\n"
+    )
+    patched_tokenize_block = (
+        "            # Tokenize the dataset\n"
+        "            if isinstance(dataset, Dataset):  # `IterableDataset.map` does not support `desc`\n"
+        '                map_kwargs["desc"] = f"Tokenizing {dataset_name} dataset"\n'
+        "            if self.is_vision_model:\n"
+        '                map_kwargs.pop("num_proc", None)\n'
+        "\n"
+        "            dataset = dataset.map(\n"
+        "                self.tokenize_row if not self.is_vision_model else dpo_trainer_vision_process_row,\n"
+    )
+    if legacy_tokenize_block in function:
+        function = function.replace(legacy_tokenize_block, patched_tokenize_block, 1)
+    return function
+
+
+RL_FUNCTIONS["dpo_trainer"].append(dpo_trainer_prepare_dataset)
+RL_PRE_ITEMS["dpo_trainer"].append(inspect.getsource(dpo_trainer_vision_process_row))
+RL_FUNCTIONS["dpo_trainer"].append(dpo_trainer_vision_signature_columns)
+RL_FUNCTIONS["dpo_trainer"].append(dpo_trainer_concatenated_inputs)
+RL_FUNCTIONS["dpo_trainer"].append(dpo_trainer_concatenated_forward)
+RL_FUNCTIONS["dpo_trainer"].append(dpo_trainer_compute_loss_liger)
+RL_EXTRA_ARGS["dpo_trainer"].append(dpo_trainer_data_collator_vision_keys)
+
+
 # Fix tokenizer double BOS
 def sft_trainer_prepare_dataset(function_name, function):
     if (
@@ -323,6 +597,23 @@ def grpo_trainer__generate_single_turn(function_name, function):
     ]:
         function = re.sub(pattern, "", function)
 
+    string_to_find = (
+        "            generate_inputs = super()._prepare_inputs(generate_inputs)"
+    )
+    replacement_string = (
+        string_to_find
+        + """
+            if "mm_token_type_ids" in generate_inputs or "image_grid_thw" in generate_inputs:
+                mm_token_type_ids = _unsloth_fix_mm_token_type_ids(
+                    self.processing_class,
+                    generate_inputs["input_ids"],
+                    generate_inputs.get("mm_token_type_ids", None),
+                )
+                if mm_token_type_ids is not None:
+                    generate_inputs["mm_token_type_ids"] = mm_token_type_ids"""
+    )
+    function = function.replace(string_to_find, replacement_string)
+
     return function
 
 
@@ -542,36 +833,45 @@ def grpo_trainer__generate_and_score_completions(function_name, function):
 
         function = patched
 
-    # Transformers 5.x: Extend mm_token_type_ids for completion tokens (Qwen3VL M-RoPE).
-    # TRL handles token_type_ids but not mm_token_type_ids.
-    _tt_search = (
-        'if "token_type_ids" in forward_kwargs:\n'
-        '            token_type_ids = forward_kwargs["token_type_ids"]\n'
-        '            forward_kwargs["token_type_ids"] = torch.cat(\n'
-        "                [token_type_ids, token_type_ids.new_zeros(completion_ids.shape)], dim=1\n"
-        "            )"
-    )
-    _tt_replace = (
-        _tt_search + "\n"
-        '        if "mm_token_type_ids" in forward_kwargs:\n'
-        '            mm_tti = forward_kwargs["mm_token_type_ids"]\n'
-        '            forward_kwargs["mm_token_type_ids"] = torch.cat(\n'
-        "                [mm_tti, mm_tti.new_zeros(completion_ids.shape)], dim=1\n"
-        "            )"
-    )
-    function = function.replace(_tt_search, _tt_replace)
+    _mm_alignment = """
+        if "mm_token_type_ids" in forward_kwargs or "image_grid_thw" in forward_kwargs:
+            _mm_token_type_ids = _unsloth_fix_mm_token_type_ids(
+                self.processing_class,
+                prompt_completion_ids,
+                forward_kwargs.get("mm_token_type_ids", None),
+                completion_ids = completion_ids,
+            )
+            if _mm_token_type_ids is not None:
+                forward_kwargs["mm_token_type_ids"] = _mm_token_type_ids
+"""
+    _tool_image_marker = "        # For VLM tool images: build token type IDs from the full prompt_completion_ids."
+    if _tool_image_marker in function:
+        function = function.replace(
+            _tool_image_marker, _mm_alignment + "\n" + _tool_image_marker
+        )
+    else:
+        _tt_search = (
+            'if "token_type_ids" in forward_kwargs:\n'
+            '            token_type_ids = forward_kwargs["token_type_ids"]\n'
+            '            forward_kwargs["token_type_ids"] = torch.cat(\n'
+            "                [token_type_ids, token_type_ids.new_zeros(completion_ids.shape)], dim=1\n"
+            "            )"
+        )
+        function = function.replace(
+            _tt_search, _tt_search + "\n" + _mm_alignment.rstrip()
+        )
 
-    # Save mm_token_type_ids to output dict alongside token_type_ids
     _save_search = (
         'if "token_type_ids" in forward_kwargs:\n'
         '            output["token_type_ids"] = forward_kwargs["token_type_ids"]'
     )
-    _save_replace = (
-        _save_search + "\n"
-        '        if "mm_token_type_ids" in forward_kwargs:\n'
-        '            output["mm_token_type_ids"] = forward_kwargs["mm_token_type_ids"]'
-    )
-    function = function.replace(_save_search, _save_replace)
+    if 'output["mm_token_type_ids"]' not in function:
+        _save_replace = (
+            _save_search + "\n"
+            '        if "mm_token_type_ids" in forward_kwargs:\n'
+            '            output["mm_token_type_ids"] = forward_kwargs["mm_token_type_ids"]'
+        )
+        function = function.replace(_save_search, _save_replace)
 
     return function
 
@@ -748,6 +1048,10 @@ def grpo_trainer__get_per_token_logps_and_entropies(function_name, function):
             # Transformers 5.x needs token_type_ids/mm_token_type_ids for some vision models
             token_type_ids = kwargs.get("token_type_ids", None)
             mm_token_type_ids = kwargs.get("mm_token_type_ids", None)
+            if mm_token_type_ids is not None or image_grid_thw is not None:
+                mm_token_type_ids = _unsloth_fix_mm_token_type_ids(
+                    self.processing_class, input_ids, mm_token_type_ids
+                )
 
             unwrapped_model = self.accelerator.unwrap_model(
                 model, keep_fp32_wrapper = False
@@ -1034,6 +1338,8 @@ grpo_update_SamplingParams = RL_REPLACEMENTS["grpo_update_SamplingParams"]
 RL_PRE_ITEMS["grpo_trainer"].append(
     inspect.getsource(_unsloth_get_final_logit_softcapping)
 )
+RL_PRE_ITEMS["grpo_trainer"].append(inspect.getsource(_unsloth_get_mm_token_id))
+RL_PRE_ITEMS["grpo_trainer"].append(inspect.getsource(_unsloth_fix_mm_token_type_ids))
 RL_PRE_ITEMS["grpo_trainer"].append(inspect.getsource(grpo_compute_loss))
 RL_PRE_ITEMS["grpo_trainer"].append(inspect.getsource(UnslothEfficientGRPO))
 RL_PRE_ITEMS["grpo_trainer"].append(inspect.getsource(grpo_accumulated_loss))
@@ -1080,6 +1386,13 @@ def grpo_trainer_compute_loss(function_name, function):
         input_ids = torch.cat([prompt_ids, completion_ids], dim = 1)
         bsz, qlen = input_ids.shape
         attention_mask = torch.cat([prompt_mask, completion_mask], dim = 1)
+        if mm_token_type_ids is not None or image_grid_thw is not None:
+            mm_token_type_ids = _unsloth_fix_mm_token_type_ids(
+                self.processing_class,
+                input_ids,
+                mm_token_type_ids,
+                completion_ids = completion_ids,
+            )
         # attention_mask = None
         logits_to_keep = completion_ids.size(
             1
diff --git a/unsloth/models/sentence_transformer.py b/unsloth/models/sentence_transformer.py
index 541875a3fc..52ff268314 100644
--- a/unsloth/models/sentence_transformer.py
+++ b/unsloth/models/sentence_transformer.py
@@ -23,6 +23,7 @@ from ._utils import (
 import inspect
 import json
 import os
+import threading
 import types
 from huggingface_hub import hf_hub_download
 from typing import Optional
@@ -42,6 +43,9 @@ import contextlib
 import shutil
 
 
+_CREATE_TRANSFORMER_MODULE_LOCK = threading.RLock()
+
+
 def _save_pretrained_torchao(
     self,
     save_directory,
@@ -1012,37 +1016,128 @@ class FastSentenceTransformer(FastModel):
         from sentence_transformers.models import Transformer
 
         # prevents sentence-transformers from loading the model a second time, thanks Etherl
-        original_from_pretrained = AutoModel.from_pretrained
+        # Also redirect AutoProcessor / AutoTokenizer so the Transformer.__init__
+        # picks up our pre-fixed tokenizer. On sentence-transformers >=5.4 the
+        # `tokenizer` attribute became a read-only @property backed by `self.processor`,
+        # so a post-init assignment raises AttributeError; redirecting the constructor's
+        # AutoProcessor.from_pretrained call sets self.processor correctly and keeps
+        # downstream state (input_formatter) consistent.
+        from transformers import AutoProcessor, AutoTokenizer
 
-        def return_existing_model(*args, **kwargs):
-            return model
+        def is_requested_model_name(args, kwargs):
+            requested = None
+            if args:
+                requested = args[0]
+            else:
+                requested = kwargs.get("pretrained_model_name_or_path")
+                if requested is None:
+                    requested = kwargs.get("model_name_or_path")
+            if requested is None:
+                return False
 
-        try:
-            # Temporarily redirect AutoModel loading to return our pre-loaded model
-            AutoModel.from_pretrained = return_existing_model
+            try:
+                requested = os.fspath(requested)
+                expected = os.fspath(model_name)
+            except (TypeError, ValueError) as exception:
+                logging.debug(
+                    "Unsloth: Could not normalize SentenceTransformer model path: %s",
+                    exception,
+                )
+                return False
+            if requested == expected:
+                return True
 
-            # Initialize Transformer
-            transformer_module = Transformer(
-                model_name,
-                max_seq_length = max_seq_length,
-                model_args = {"trust_remote_code": trust_remote_code},
-                config_args = {"trust_remote_code": trust_remote_code},
-            )
-        finally:
-            # Restore original functionality immediately
-            AutoModel.from_pretrained = original_from_pretrained
+            try:
+                if os.path.exists(requested) or os.path.exists(expected):
+                    return os.path.abspath(requested) == os.path.abspath(expected)
+            except (OSError, TypeError, ValueError) as exception:
+                logging.debug(
+                    "Unsloth: Could not compare SentenceTransformer model paths: %s",
+                    exception,
+                )
+            return False
 
-        transformer_module.tokenizer = tokenizer
+        with _CREATE_TRANSFORMER_MODULE_LOCK:
+            original_model_from_pretrained = AutoModel.from_pretrained
+            original_processor_from_pretrained = AutoProcessor.from_pretrained
+            original_tokenizer_from_pretrained = AutoTokenizer.from_pretrained
+
+            def return_existing_model(*args, **kwargs):
+                if is_requested_model_name(args, kwargs):
+                    return model
+                return original_model_from_pretrained(*args, **kwargs)
+
+            def return_existing_tokenizer(*args, **kwargs):
+                if is_requested_model_name(args, kwargs):
+                    return tokenizer
+                return original_tokenizer_from_pretrained(*args, **kwargs)
+
+            def return_existing_processor(*args, **kwargs):
+                if is_requested_model_name(args, kwargs):
+                    return tokenizer
+                return original_processor_from_pretrained(*args, **kwargs)
+
+            try:
+                # Temporarily redirect Auto* loading to return our pre-loaded objects
+                AutoModel.from_pretrained = return_existing_model
+                AutoProcessor.from_pretrained = return_existing_processor
+                AutoTokenizer.from_pretrained = return_existing_tokenizer
+
+                transformer_init_params = inspect.signature(
+                    Transformer.__init__
+                ).parameters
+                trust_remote_code_kwargs = {"trust_remote_code": trust_remote_code}
+                do_lower_case = getattr(tokenizer, "do_lower_case", False)
+                transformer_kwargs = {"max_seq_length": max_seq_length}
+                if "do_lower_case" in transformer_init_params:
+                    transformer_kwargs["do_lower_case"] = do_lower_case
+                if "model_kwargs" in transformer_init_params:
+                    transformer_kwargs["model_kwargs"] = trust_remote_code_kwargs.copy()
+                    transformer_kwargs["config_kwargs"] = (
+                        trust_remote_code_kwargs.copy()
+                    )
+                else:
+                    transformer_kwargs["model_args"] = trust_remote_code_kwargs.copy()
+                    transformer_kwargs["config_args"] = trust_remote_code_kwargs.copy()
+                if "processor_kwargs" in transformer_init_params:
+                    transformer_kwargs["processor_kwargs"] = (
+                        trust_remote_code_kwargs.copy()
+                    )
+                elif "tokenizer_args" in transformer_init_params:
+                    transformer_kwargs["tokenizer_args"] = (
+                        trust_remote_code_kwargs.copy()
+                    )
+
+                # Initialize Transformer
+                transformer_module = Transformer(model_name, **transformer_kwargs)
+            finally:
+                # Restore original functionality immediately
+                AutoModel.from_pretrained = original_model_from_pretrained
+                AutoProcessor.from_pretrained = original_processor_from_pretrained
+                AutoTokenizer.from_pretrained = original_tokenizer_from_pretrained
+
+        # On sentence-transformers >=5.4 `tokenizer` is a read-only property backed
+        # by `self.processor` (already wired via the redirect above). On older
+        # versions it's a regular attribute and the explicit assignment is required.
+        if not isinstance(
+            getattr(type(transformer_module), "tokenizer", None), property
+        ):
+            transformer_module.tokenizer = tokenizer
         transformer_module.do_lower_case = getattr(tokenizer, "do_lower_case", False)
 
         # sentence-transformers only passes along known keys to model.forward
+        preinit_model_forward_params = getattr(
+            transformer_module, "model_forward_params", set()
+        )
         model_forward_params = list(inspect.signature(model.forward).parameters)
         transformer_module.model_forward_params = set(model_forward_params) | {
             "input_ids",
             "attention_mask",
             "token_type_ids",
             "inputs_embeds",
+            "return_dict",
         }
+        transformer_module.model_forward_params |= preinit_model_forward_params
 
         # determine max_seq_length if not provided
         if max_seq_length is None:
@@ -1056,7 +1151,11 @@ class FastSentenceTransformer(FastModel):
                 max_seq_length = 512
 
         transformer_module.max_seq_length = max_seq_length
-        transformer_module.config_keys = ["max_seq_length", "do_lower_case"]
+        config_keys = list(getattr(transformer_module, "config_keys", []) or [])
+        for config_key in ("max_seq_length", "do_lower_case"):
+            if config_key not in config_keys:
+                config_keys.append(config_key)
+        transformer_module.config_keys = config_keys
         transformer_module.save_in_root = True
 
         if hasattr(model, "config"):
@@ -1064,6 +1163,29 @@ class FastSentenceTransformer(FastModel):
 
         return transformer_module
 
+    @staticmethod
+    def _is_transformer_module_ref(class_ref):
+        if class_ref in {
+            "sentence_transformers.models.Transformer",
+            "sentence_transformers.models.transformer.Transformer",
+            "sentence_transformers.base.modules.transformer.Transformer",
+        }:
+            return True
+
+        try:
+            from sentence_transformers.models import Transformer
+            from sentence_transformers.util import import_from_string
+
+            module_class = import_from_string(class_ref)
+            return module_class is Transformer
+        except (ImportError, AttributeError, TypeError, ValueError) as exception:
+            logging.debug(
+                "Unsloth: Could not resolve SentenceTransformer module ref %r: %s",
+                class_ref,
+                exception,
+            )
+            return False
+
     @staticmethod
     def _load_modules(
         model_name,
@@ -1096,7 +1218,7 @@ class FastSentenceTransformer(FastModel):
                     "name", str(module_config.get("idx", len(modules)))
                 )
 
-                if class_ref == "sentence_transformers.models.Transformer":
+                if FastSentenceTransformer._is_transformer_module_ref(class_ref):
                     transformer_module = (
                         FastSentenceTransformer._create_transformer_module(
                             model_name,
@@ -1299,7 +1421,10 @@ class FastSentenceTransformer(FastModel):
         if hasattr(model, "__getitem__"):
             inner_model = model[0].auto_model
             compiled = torch.compile(inner_model, mode = mode)
-            model[0].auto_model = compiled
+            if isinstance(getattr(type(model[0]), "auto_model", None), property):
+                model[0].model = compiled
+            else:
+                model[0].auto_model = compiled
             # Fix for accelerate unwrap_model bug:
             # When SentenceTransformer contains a compiled inner model,
             # accelerate checks has_compiled_regions() which returns True,
@@ -1933,8 +2058,15 @@ class FastSentenceTransformer(FastModel):
                         "Unsloth: Re-enabling torch.compile since gradient checkpointing is not supported"
                     )
 
-                # Re-assign the peft model back to the transformer module
-                transformer_module.auto_model = peft_model
+                # Re-assign the peft model back to the transformer module.
+                # On sentence-transformers >=5.4 `auto_model` is a read-only property
+                # backed by `self.model`, so write to the backing attribute there.
+                if isinstance(
+                    getattr(type(transformer_module), "auto_model", None), property
+                ):
+                    transformer_module.model = peft_model
+                else:
+                    transformer_module.auto_model = peft_model
 
                 # Store compile info for auto-compile at trainer time
                 # torch.compile is deferred until training starts so we can check max_steps
@@ -1980,8 +2112,15 @@ class FastSentenceTransformer(FastModel):
                 **kwargs,
             )
 
-            # re-assign the peft model back to the transformer module
-            transformer_module.auto_model = peft_model
+            # re-assign the peft model back to the transformer module.
+            # On sentence-transformers >=5.4 `auto_model` is a read-only property
+            # backed by `self.model`, so write to the backing attribute there.
+            if isinstance(
+                getattr(type(transformer_module), "auto_model", None), property
+            ):
+                transformer_module.model = peft_model
+            else:
+                transformer_module.auto_model = peft_model
             return model
         else:
             return FastModel.get_peft_model(
diff --git a/unsloth/save.py b/unsloth/save.py
index df3df13a04..472eb14933 100644
--- a/unsloth/save.py
+++ b/unsloth/save.py
@@ -1552,19 +1552,33 @@ def save_to_gguf(
                             f"Error: {e}"
                         )
         print("Unsloth: Model files cleanup...")
+        want_full_precision = first_conversion in quantization_method
         if quants_created:
-            all_saved_locations.remove(base_gguf)
-            Path(base_gguf).unlink(missing_ok = True)
+            # convert_to_gguf may return multiple base shards plus an mmproj entry,
+            # so treat every initial file that is not an mmproj as part of the base set.
+            base_files = [
+                f for f in initial_files if "-mmproj" not in os.path.basename(f).lower()
+            ]
+            if not want_full_precision:
+                for f in base_files:
+                    if f in all_saved_locations:
+                        all_saved_locations.remove(f)
+                    Path(f).unlink(missing_ok = True)
 
             # flip the list to get [text_model, mmproj] order. for text models stays the same.
             all_saved_locations.reverse()
+
+            # When the base format is preserved, move base files (incl. shards) away from
+            # list boundaries so example commands ([0]=model, [-1]=mmproj) stay correct.
+            if want_full_precision and len(all_saved_locations) > len(base_files) + 1:
+                for f in base_files:
+                    if f in all_saved_locations:
+                        all_saved_locations.remove(f)
+                for i, f in enumerate(base_files):
+                    all_saved_locations.insert(1 + i, f)
     else:
         print("Unsloth: GPT-OSS model - skipping additional quantizations")
-
-    if is_gpt_oss:
         want_full_precision = True
-    else:
-        want_full_precision = first_conversion in frozenset(quantization_method)
 
     print(f"Unsloth: All GGUF conversions completed successfully!")
     print(f"Generated files: {all_saved_locations}")
diff --git a/unsloth_cli/__init__.py b/unsloth_cli/__init__.py
index 3a821359b7..28da00f37b 100644
--- a/unsloth_cli/__init__.py
+++ b/unsloth_cli/__init__.py
@@ -6,7 +6,7 @@ import typer
 from unsloth_cli.commands.train import train
 from unsloth_cli.commands.inference import inference
 from unsloth_cli.commands.export import export, list_checkpoints
-from unsloth_cli.commands.studio import studio_app
+from unsloth_cli.commands.studio import run as studio_run, studio_app
 
 app = typer.Typer(
     help = "Command-line interface for Unsloth training, inference, and export.",
@@ -18,3 +18,15 @@ app.command()(inference)
 app.command()(export)
 app.command("list-checkpoints")(list_checkpoints)
 app.add_typer(studio_app, name = "studio", help = "Unsloth Studio commands.")
+
+# Top-level alias: `unsloth run ...` is equivalent to `unsloth studio run ...`.
+# Same context_settings as the studio_app registration so unknown flags
+# still pass through to llama-server.
+app.command(
+    "run",
+    context_settings = {
+        "allow_extra_args": True,
+        "ignore_unknown_options": True,
+    },
+    help = "Alias for `unsloth studio run`.",
+)(studio_run)
diff --git a/unsloth_cli/_tool_policy.py b/unsloth_cli/_tool_policy.py
new file mode 100644
index 0000000000..5dd6c70d9f
--- /dev/null
+++ b/unsloth_cli/_tool_policy.py
@@ -0,0 +1,71 @@
+# Copyright 2025-present the Unsloth AI Inc. team. All rights reserved.
+
+"""Pure resolver for `unsloth run --enable-tools/--disable-tools`.
+
+Kept as a standalone module so the truth table can be unit-tested
+without spinning up Typer or the studio venv.
+"""
+
+from typing import Callable, Optional
+
+import typer
+
+# Claude Code brand orange — used so the security warning stands out
+# in a crowded terminal.
+_PROMPT_FG = (217, 119, 87)
+
+# Loopback aliases. Any other bind address (0.0.0.0, ::, a specific
+# LAN IP, a hostname, ...) is treated as network-reachable.
+_LOOPBACK_HOSTS = frozenset({"127.0.0.1", "localhost", "::1"})
+
+
+def is_external_host(host: str) -> bool:
+    """True when `host` is reachable from beyond loopback."""
+    return host.lower() not in _LOOPBACK_HOSTS
+
+
+def _build_prompt_text(host: str) -> str:
+    return typer.style(
+        (
+            f"Tools include arbitrary code execution (Python, terminal). "
+            f"You're binding to {host}, which is reachable from your network. "
+            f"If your API key leaks, anyone with it can run code on this machine. "
+            f"Do not share the API key. Continue?"
+        ),
+        fg = _PROMPT_FG,
+        bold = True,
+    )
+
+
+def resolve_tool_policy(
+    host: str,
+    flag: Optional[bool],
+    yes: bool,
+    silent: bool,
+    prompt: Callable[[str], bool] = typer.confirm,
+) -> bool:
+    """Return the resolved server-side tool policy.
+
+    Args:
+        host: The bind address (e.g. "127.0.0.1", "0.0.0.0", or a
+              specific network IP).
+        flag: Tri-state from `--enable-tools/--disable-tools`
+              (None when neither was passed).
+        yes:  True if the operator passed `--yes/-y`.
+        silent: True if the operator passed `--silent/-q`.
+        prompt: Callable used for the network-bind + on confirmation
+                (injected for testability; defaults to ``typer.confirm``).
+
+    Raises:
+        typer.Exit: when the operator declines the confirmation.
+    """
+    is_external = is_external_host(host)
+    default = not is_external  # loopback defaults on, network defaults off
+
+    resolved = default if flag is None else flag
+
+    if is_external and resolved is True and not yes and not silent:
+        if not prompt(_build_prompt_text(host)):
+            raise typer.Exit(1)
+
+    return resolved
diff --git a/unsloth_cli/commands/studio.py b/unsloth_cli/commands/studio.py
index b74f42674d..140940209f 100644
--- a/unsloth_cli/commands/studio.py
+++ b/unsloth_cli/commands/studio.py
@@ -15,7 +15,7 @@ import time
 import types
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Optional
+from typing import List, Optional
 import typer
 
 studio_app = typer.Typer(help = "Unsloth Studio commands.")
@@ -374,6 +374,7 @@ def _load_model_via_http(
     gguf_variant: Optional[str],
     max_seq_length: int,
     load_in_4bit: bool,
+    llama_extra_args: Optional[List[str]] = None,
     timeout: int = 600,
 ) -> dict:
     """POST to ``/api/inference/load`` using the API key for auth."""
@@ -388,6 +389,8 @@ def _load_model_via_http(
     }
     if gguf_variant:
         payload["gguf_variant"] = gguf_variant
+    if llama_extra_args:
+        payload["llama_extra_args"] = list(llama_extra_args)
 
     data = json.dumps(payload).encode()
     req = urllib.request.Request(
@@ -414,7 +417,7 @@ def _load_model_via_http(
 def studio_default(
     ctx: typer.Context,
     port: int = typer.Option(8888, "--port", "-p"),
-    host: str = typer.Option("0.0.0.0", "--host", "-H"),
+    host: str = typer.Option("127.0.0.1", "--host", "-H"),
     frontend: Optional[Path] = typer.Option(None, "--frontend", "-f"),
     silent: bool = typer.Option(False, "--silent", "-q"),
     api_only: bool = typer.Option(
@@ -514,9 +517,57 @@ def studio_default(
 # ── unsloth studio run ───────────────────────────────────────────────
 
 
-@studio_app.command()
+def _split_repo_variant(model_arg: str) -> tuple[str, Optional[str]]:
+    """Split ``org/name:variant`` HF-style identifiers into (repo, variant).
+
+    Mirrors llama.cpp's ``-hf <repo>:<quant>`` convention so users can
+    write ``unsloth/gpt-oss-20b-GGUF:UD-Q4_K_XL`` instead of passing
+    ``--gguf-variant`` separately. Local paths (absolute, ``./``,
+    ``~/``, Windows drive letters) and identifiers without a ``:``
+    suffix are returned verbatim.
+    """
+    s = model_arg.strip()
+    if not s:
+        return s, None
+    if s.startswith(("/", "./", "../", "~")) or s == ".":
+        return s, None
+    # Windows drive letter (e.g. "C:\\path" or "C:/path") -- the colon
+    # here is a path separator, not a variant suffix.
+    if len(s) >= 2 and s[1] == ":" and s[0].isalpha():
+        return s, None
+    if ":" not in s:
+        return s, None
+    repo, _, variant = s.rpartition(":")
+    if not repo or not variant:
+        return s, None
+    # A real quant label has no slashes; ``foo:bar/baz`` is not
+    # ``repo:variant`` syntax.
+    if "/" in variant:
+        return s, None
+    return repo, variant
+
+
+@studio_app.command(
+    context_settings = {
+        "allow_extra_args": True,
+        "ignore_unknown_options": True,
+    },
+)
 def run(
-    model: str = typer.Option(..., "--model", "-m", help = "Model path or HF repo"),
+    ctx: typer.Context,
+    model: str = typer.Option(
+        ...,
+        "--model",
+        "-m",
+        "-hf",
+        "-hfr",
+        "--hf-repo",
+        help = (
+            "Model path or HF repo. Accepts llama.cpp-style "
+            "`org/repo:variant` syntax. The `-hf` / `--hf-repo` aliases "
+            "match llama-server's spelling."
+        ),
+    ),
     gguf_variant: Optional[str] = typer.Option(
         None, "--gguf-variant", help = "GGUF quant variant (e.g. UD-Q4_K_XL)"
     ),
@@ -528,15 +579,66 @@ def run(
         "cli", "--api-key-name", help = "Label for the auto-generated API key"
     ),
     port: int = typer.Option(8888, "--port", "-p"),
-    host: str = typer.Option("0.0.0.0", "--host", "-H"),
+    host: str = typer.Option("127.0.0.1", "--host", "-H"),
     frontend: Optional[Path] = typer.Option(None, "--frontend", "-f"),
     silent: bool = typer.Option(False, "--silent", "-q"),
+    enable_tools: Optional[bool] = typer.Option(
+        None,
+        "--enable-tools/--disable-tools",
+        help = (
+            "Force server-side tools on/off for all requests. "
+            "Default: on for 127.0.0.1, off for 0.0.0.0."
+        ),
+    ),
+    yes: bool = typer.Option(
+        False,
+        "--yes",
+        "-y",
+        help = "Skip the 0.0.0.0 + --enable-tools confirmation prompt.",
+    ),
 ):
     """Start Studio, load a model, and print an API key -- one-liner server.
 
+    Any flag this command does not recognize is forwarded verbatim to
+    the underlying llama-server (GGUF only). Studio-managed flags
+    (--port, -c / --ctx-size, --api-key, -ngl, --jinja, --flash-attn,
+    --no-context-shift, model-identity flags, ...) are rejected with
+    HTTP 400.
+
     Example:
         unsloth studio run --model unsloth/Qwen3-1.7B-GGUF --gguf-variant UD-Q4_K_XL
+        unsloth studio run --model unsloth/Qwen3-1.7B-GGUF --top-k 20 --seed 42
+        unsloth studio run --model some-model --chat-template-file /path/to/tpl.jinja
     """
+    extra_llama_args: List[str] = list(ctx.args) if ctx.args else []
+
+    # ── 0. Parse llama.cpp-style ``repo:variant`` syntax in --model. ───
+    # Lets users write ``--model unsloth/foo-GGUF:UD-Q4_K_XL`` instead
+    # of pairing ``--model`` with ``--gguf-variant``. If both are given
+    # and disagree, fail loudly instead of silently picking one.
+    parsed_repo, embedded_variant = _split_repo_variant(model)
+    if embedded_variant:
+        if gguf_variant and gguf_variant != embedded_variant:
+            typer.echo(
+                f"Error: --model embeds variant '{embedded_variant}' but "
+                f"--gguf-variant '{gguf_variant}' was also provided.",
+                err = True,
+            )
+            raise typer.Exit(1)
+        model = parsed_repo
+        gguf_variant = gguf_variant or embedded_variant
+
+    # ── Resolve the server-side tool policy. The y/N prompt (if any)
+    # runs in the outer process so the re-exec'd child never re-prompts.
+    from unsloth_cli._tool_policy import is_external_host, resolve_tool_policy
+
+    enable_tools = resolve_tool_policy(
+        host = host,
+        flag = enable_tools,
+        yes = yes,
+        silent = silent,
+    )
+
     # ── 1. Venv re-exec (same pattern as studio_default) ──────────────
     studio_venv_dir = STUDIO_HOME / "unsloth_studio"
     in_studio_venv = sys.prefix.startswith(str(studio_venv_dir))
@@ -576,6 +678,23 @@ def run(
             args.extend(["--frontend", str(frontend)])
         if silent:
             args.append("--silent")
+        # Forward the resolved tool policy (always concrete True/False
+        # at this point — the resolver above ran before the re-exec).
+        if enable_tools:
+            args.append("--enable-tools")
+        else:
+            args.append("--disable-tools")
+        # Forward --yes whenever the parent already cleared the prompt
+        # (either operator passed --yes, or the parent's resolver
+        # accepted the network-bind confirmation). Otherwise the child
+        # re-runs the resolver and prompts a second time.
+        if yes or (enable_tools and is_external_host(host)):
+            args.append("--yes")
+        # Forward unknown args (llama-server pass-through) to the
+        # re-exec'd command so the studio venv sees them in ctx.args
+        # and the re-execed run() can include them in the load payload.
+        if extra_llama_args:
+            args.extend(extra_llama_args)
 
         if sys.platform == "win32":
             proc = subprocess.Popen(args)
@@ -596,6 +715,17 @@ def run(
     app = run_server(**run_kwargs)
     actual_port = getattr(app.state, "server_port", port) or port
 
+    # ── Apply the resolved tool policy as a process-level override.
+    # Must use the same import path the route handlers use --
+    # `studio/backend/run.py` adds `studio/backend/` to sys.path so the
+    # routes import this module as top-level `state.tool_policy`. If we
+    # imported via `studio.backend.state.tool_policy` instead, Python
+    # would cache two different module objects with two different
+    # `_tool_policy` globals, and the gates would never see our value.
+    from state.tool_policy import set_tool_policy
+
+    set_tool_policy(enable_tools)
+
     # ── 3. Wait for server health ─────────────────────────────────────
     if not silent:
         typer.echo("Starting Unsloth Studio...")
@@ -617,6 +747,7 @@ def run(
             gguf_variant = gguf_variant,
             max_seq_length = max_seq_length,
             load_in_4bit = load_in_4bit,
+            llama_extra_args = extra_llama_args,
         )
     except RuntimeError as exc:
         typer.echo(f"Error: {exc}", err = True)
@@ -630,6 +761,32 @@ def run(
     base_url = f"http://{display_host}:{actual_port}"
     sdk_base_url = f"{base_url}/v1"
 
+    # Claude orange (Claude Code's brand color) for tool-policy notices
+    # so they stand out from the surrounding banner. Always printed --
+    # even under --silent / --yes -- so the operator never misses the
+    # current tool-execution status.
+    _tool_notice_fg = (217, 119, 87)
+    _is_external = is_external_host(host)
+    if _is_external and enable_tools:
+        _tool_notice = (
+            f"Server-side tools are ENABLED on {host} (network-reachable). "
+            f"Anyone with the API key can run code on this machine. "
+            f"Do not share the API key."
+        )
+    elif _is_external:
+        _tool_notice = (
+            f"Server-side tools are disabled by default on {host} "
+            f"(network-reachable). Pass --enable-tools to turn on "
+            f"(you will be warned about API-key risk)."
+        )
+    elif enable_tools:
+        _tool_notice = (
+            "Server-side tools are enabled by default for loopback. "
+            "Pass --disable-tools to turn off."
+        )
+    else:
+        _tool_notice = "Server-side tools are disabled."
+
     if not silent:
         typer.echo("")
         typer.echo("=" * 56)
@@ -640,6 +797,7 @@ def run(
         typer.echo("  OpenAI / Anthropic SDK base URL:")
         typer.echo(f"    {sdk_base_url}")
         typer.echo("=" * 56)
+        typer.secho(_tool_notice, fg = _tool_notice_fg, bold = True)
         typer.echo("")
         typer.echo("OpenAI Chat Completions:")
         typer.echo(f"  curl {sdk_base_url}/chat/completions \\")
@@ -663,6 +821,13 @@ def run(
         typer.echo('    -H "Content-Type: application/json" \\')
         typer.echo("""    -d '{"input": "Hello", "stream": true}'""")
         typer.echo("")
+    else:
+        # Silent mode still prints the essentials (URL, API key) plus
+        # the orange tool-status notice so the operator never loses
+        # visibility into the security-relevant policy.
+        typer.echo(f"URL:     {base_url}")
+        typer.echo(f"API Key: {api_key}")
+        typer.secho(_tool_notice, fg = _tool_notice_fg, bold = True)
 
     # ── 7. Wait for Ctrl+C ────────────────────────────────────────────
     from studio.backend.run import _shutdown_event, _graceful_shutdown, _server